Un servicio Delphi que envuelve la extracción de imágenes en try..except puede verse perfectamente sano en su log: un EAccessViolation se captura, la carga se marca como mala, y el siguiente trabajo empieza. Minutos después una solicitud no relacionada puede morir con EInvalidPointer mientras libera una lista de cadenas. Los dos eventos están conectados. Un decodificador JPEG 2000 o JBIG2 que escribió más allá del final de un búfer antes de fallar ya dañó el heap, y capturar la excepción restaura el flujo de control dejando ese daño exactamente donde estaba. La memoria en la que no se puede confiar solo se puede tirar, y la unidad de memoria que Windows le deja tirar limpiamente es un proceso
Por qué un try..except alrededor del decodificador no basta
Un códec de imagen es la parte de un lector PDF que ejecuta la máquina de estados más complicada sobre los datos menos verificados. Para cuando los bytes llegan a un decodificador JPEG 2000 o JBIG2, la tabla de referencias cruzadas fue parseada, el objeto de imagen resuelto y la cadena de filtros desenrollada. Lo que queda es un codestream crudo que anuncia cuántos tiles, cuántos componentes y cuántos bits por muestra contiene. Un número equivocado ahí no es un error de sintaxis que el parser pueda rechazar. Se convierte en un tamaño de asignación, un límite de bucle o un índice de arreglo dentro de un bucle de decodificación ajustado
Los presupuestos de bytes cubren parte de esto, y una ruta de ingesta debería tenerlos de todos modos. HotPDF acota la expansión con DecodeBudgetBytes y DocumentDecodeBudgetBytes, y acota las cadenas de filtros con DecodeFilterLimit y DecodePipelineDepthLimit; el razonamiento detrás de esos topes está en decodificación acotada para filtros anidados y bombas PDF. Un presupuesto responde una pregunta: cuánta salida se permite. No tiene nada que decir sobre un decodificador que falla después de escribir un puñado de bytes en el lugar equivocado
El fallo que sí se captura es en cierto sentido el peor desenlace. Un crash no manejado al menos detiene el proceso. Uno capturado lo deja sirviendo solicitudes encima de un heap corrompido, y el fallo eventual lleva un stack trace que no apunta ni cerca del PDF que lo causó
Mover DCTDecode, JPXDecode y JBIG2Decode a un proceso worker
HotPDF puede ejecutar los tres filtros de imagen de alto riesgo, DCTDecode, JPXDecode y JBIG2Decode, en un proceso worker de corta vida, HotPDFCodecWorker.exe, en lugar de dentro de su aplicación. La unidad HPDFCodecIsolation los nombra hckDCT, hckJPX y hckJBIG2. Flate, LZW, RunLength, ASCII85 y CCITT se quedan en el mismo proceso: esos decodificadores tienen estado simple, y los presupuestos de decodificación son la herramienta correcta para ellos
Cada solicitud recibe un proceso fresco. El host crea un mapeo de memoria compartida de nombre aleatorio, escribe un THPDFCodecSharedHeader fijo seguido del codestream comprimido y, para JBIG2, los segmentos globales, luego arranca el worker suspendido, lo coloca en un Windows Job Object y solo entonces lo deja correr. El job permite exactamente un proceso activo, así que un decodificador comprometido no puede crear un hijo, y se crea con kill-on-close, así que el worker no puede sobrevivir al handle del job. Los píxeles decodificados regresan como BGR de 24 bits en el mismo mapeo, junto con una palabra de estado
Activarlo toma cuatro propiedades en THotPDF. Las llamadas de imagen siguen siendo las mismas que usted ya usa:
uses
Vcl.Graphics, HPDFDoc, HPDFCodecIsolation;
procedure ExtractUntrustedImages(const FileName: string);
var
Pdf: THotPDF;
Info: THPDFCodecWorkerInfo;
Bmp: TBitmap;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
Pdf.CodecIsolationMode := cimRequired; // nunca decodificar estos en el mismo proceso
Pdf.CodecWorkerExecutable := ''; // '' = junto al EXE del host
Pdf.CodecWorkerTimeoutMilliseconds := 5000; // 1..600000, si no ERangeError
Pdf.CodecWorkerMemoryLimitBytes := 256 * 1024 * 1024; // 0 o >= 64 MiB
Pdf.DecodeBudgetBytes := 128 * 1024 * 1024;
if Pdf.LoadFromFile(FileName) > 0 then // devuelve el número de páginas
for I := 0 to Pdf.GetLoadedImageCount - 1 do
begin
Bmp := Pdf.ExtractLoadedImage(I);
try
// Lea el veredicto de inmediato: describe solo la solicitud más reciente
if Pdf.GetLastCodecWorkerInfo(Info) then
LogCodecOutcome(FileName, I, Info);
if Bmp <> nil then
StoreImage(FileName, I, Bmp); // su propio código
finally
Bmp.Free;
end;
end;
finally
Pdf.Free;
end;
end;
Cuando una decodificación aislada falla, ExtractLoadedImage devuelve nil, así que la verificación Bmp <> nil lleva peso real aquí. GetLastCodecWorkerInfo devuelve False cuando no se registró ninguna solicitud al worker, que es lo que se ve con una imagen comprimida con Flate o con cimDisabled
Dos detalles de despliegue causan la mayor parte del problema. Un CodecWorkerExecutable vacío se resuelve a HotPDFCodecWorker.exe en el directorio de ParamStr(0). Un valor no vacío pasa por ExpandFileName, lo que significa que una ruta relativa se resuelve contra el directorio actual. Para un servicio de Windows ese directorio suele ser System32, así que 'bin\HotPDFCodecWorker.exe' funciona desde el IDE y falla después de la instalación. El otro detalle es el bitness: el script de compilación del worker produce binarios Win32 y Win64 separados, y el que distribuya debe coincidir con la arquitectura del proceso host
Automático o requerido: ¿qué pasa cuando falta el worker?
Los tres valores de THPDFCodecIsolationMode responden una sola pregunta, que es qué hacer cuando el worker no se puede usar en absoluto. cimDisabled nunca lo intenta y decodifica todo en el mismo proceso. cimAutomatic, el valor predeterminado, usa el worker cuando HotPDFCodecWorker.exe existe y recae en la decodificación en el mismo proceso cuando el archivo no está ahí, registrando cwsUnavailable. cimRequired rechaza el respaldo; un worker faltante significa que la imagen no se decodifica
El respaldo es más angosto de lo que parece a primera vista, y la angostura es deliberada. Solo un ejecutable faltante recae. Si el archivo existe pero CreateProcess falla, típicamente porque un producto de seguridad de endpoint lo bloquea, el resultado es cwsLaunchFailed y la imagen no se decodifica, incluso bajo cimAutomatic. Un worker que arrancó y luego se colgó, expiró o excedió un límite nunca se reintenta en el mismo proceso en ninguno de los dos modos. Reintentar un archivo que acaba de matar al worker dentro de su propio proceso le entregaría al atacante un segundo intento sobre precisamente el blanco que el worker estaba ahí para proteger
Para cualquier cosa que lea cargas, adjuntos de correo o depósitos de socios, configure cimRequired. El modo predeterminado tiene una trampa que solo aparece después del despliegue: un instalador que olvida el worker produce un servidor que extrae cada imagen correctamente, pasa cada prueba funcional, y ejecuta los códecs dentro del host en cada solicitud. Nada se ve roto. cimAutomatic es razonable para un visor de escritorio que abre archivos que el usuario ya tiene, donde un worker faltante debería degradarse en lugar de detener el producto. cimRequired también apaga ProgressiveJPEGScanDecoding, la ruta de JPEG progresivo escaneo por escaneo, porque esa ruta decodifica en el host
Una verificación de arranque convierte un worker olvidado en un fallo inmediato y ruidoso. HPDFResolveCodecWorkerExecutable es público en HPDFCodecIsolation y aplica la misma regla de resolución que el componente:
// Una verificación de arranque que usted agrega: negarse a arrancar sin el worker
procedure RequireCodecWorker(Pdf: THotPDF);
var
WorkerPath: string;
begin
WorkerPath := HPDFResolveCodecWorkerExecutable(Pdf.CodecWorkerExecutable);
if not FileExists(WorkerPath) then
raise Exception.CreateFmt(
'Codec worker missing at %s; refusing to accept PDF uploads',
[WorkerPath]);
end;
Leer THPDFCodecWorkerStatus
THPDFCodecWorkerInfo lleva Status, ProcessId, ExitCode, ElapsedMilliseconds y un ErrorMessage del lado del host. Los valores de estado son cwsNotRun, cwsSucceeded, cwsUnavailable, cwsLaunchFailed, cwsTimedOut, cwsCrashed, cwsDecodeFailed, cwsProtocolError y cwsOutputLimit, y se ordenan en tres grupos operativos
- Despliegue:
cwsUnavailableycwsLaunchFailed. El worker falta, está bloqueado, o no pudo arrancar dentro de su job. Llame a quien administra el servidor; el documento en sí puede estar bien - Documento:
cwsDecodeFailedycwsOutputLimit. El codestream está malformado o es más grande de lo que su política permite. Rechazar el archivo es la respuesta correcta - Contención:
cwsTimedOut,cwsCrashedycwsProtocolError. Un cuelgue, un worker muerto, o una respuesta cuyo encabezado no coincide con la versión del protocolo o cuya geometría declarada no cuadra. Estos son los eventos para los que existe la frontera de proceso, y el archivo merece cuarentena en lugar de un rechazo simple
La línea entre cwsDecodeFailed y cwsCrashed vale la pena conocerla cuando lee los números. Delphi convierte la mayoría de las violaciones de acceso en excepciones, y el worker captura excepciones alrededor del decodificador y las reporta como una decodificación fallida. cwsCrashed significa que el proceso worker terminó con un código de salida distinto de cero, lo que sucede cuando el fallo fue lo bastante severo para que ningún manejador de excepciones llegara a ejecutarse. ExitCode es un Cardinal, así que formatéelo con %u o como hex; $C0000005 impreso con %d se convierte en un número negativo que nadie busca correctamente
procedure LogCodecOutcome(const FileName: string; ImageIndex: Integer;
const Info: THPDFCodecWorkerInfo);
begin
case Info.Status of
cwsSucceeded:
;
cwsUnavailable, cwsLaunchFailed:
AlertOps('Codec worker not usable: ' + Info.ErrorMessage); // su propio código
cwsTimedOut, cwsCrashed, cwsProtocolError:
Quarantine(FileName, Format('image %d: pid %u exit $%.8x after %u ms: %s',
[ImageIndex, Info.ProcessId, Info.ExitCode,
Info.ElapsedMilliseconds, Info.ErrorMessage])); // su propio código
else
RejectDocument(FileName, Info.ErrorMessage); // su propio código
end;
end;
El worker también suprime el diálogo de fallos de Windows para sí mismo, así que un crash en un servidor desatendido aparece en este log en lugar de como un cuadro modal esperando que alguien haga clic en Aceptar en una máquina que nadie está mirando
Los tres techos de cada decodificación aislada
Cada decodificación aislada corre bajo un límite de tiempo, un límite de memoria y un límite de salida, y el estado le dice cuál la terminó. CodecWorkerTimeoutMilliseconds tiene como predeterminado 10,000 y acepta de 1 a 600,000; cualquier cosa fuera de ese rango lanza ERangeError en la asignación en lugar de recortarse. En timeout el host termina todo el job y reporta cwsTimedOut. CodecWorkerMemoryLimitBytes tiene como predeterminado 536,870,912 bytes y debe ser cero, significando sin tope, o al menos 67,108,864 bytes; se convierte en un límite de memoria comprometida por proceso en el Job Object
El límite de salida se deriva. HotPDF calcula los bytes que la imagen decodificada debería necesitar a partir del tamaño objetivo solicitado, la región solicitada, o la geometría de imagen declarada en el PDF, a tres bytes por píxel, y luego recorta esa cifra a DecodeBudgetBytes cuando hay un presupuesto configurado. El mapeo compartido se dimensiona a partir de esa cifra, así que el worker no tiene espacio para escribir más allá. Suponga que un escaneo declara 10,000 por 10,000 píxeles: eso son 300,000,000 bytes de salida BGR, más que los DecodeBudgetBytes predeterminados de 268,435,456 bytes, así que el límite se vuelve 256 MiB y la decodificación termina con cwsOutputLimit
El host tampoco confía en el tamaño que el worker reporta de vuelta. Una respuesta se acepta solo si su ancho por alto por tres iguala el conteo de bytes que declara, y ese conteo cabe tanto en el límite de salida del propio host como en el mapeo. Un worker subvertido puede escribir cualquier valor en el encabezado; un desfase se reporta como cwsProtocolError y no se copia ningún píxel
Mantenga el límite de memoria cómodamente por encima del límite de salida. Con la configuración del primer ejemplo, un presupuesto de salida de 128 MiB dentro de un tope de proceso de 256 MiB deja espacio para la entrada comprimida y el conjunto de trabajo del propio decodificador. Ponga los dos cerca uno del otro y los escaneos legítimos grandes empiezan a fallar dentro del worker por razones que no tienen nada que ver con entrada hostil
Lo que cuesta la frontera de proceso
Arrancar un proceso por cada imagen aislada cuesta tiempo, y un documento con varios cientos de páginas JPEG escaneadas lo va a sentir. En un conversor por lotes desatendido ese costo desaparece en la ventana nocturna y la contención es la razón por la que existe el trabajo. Un visor interactivo que muestra archivos en los que el usuario ya confía es un caso distinto; ahí cimAutomatic, o cimDisabled para un archivo interno conocido, es una elección justa. CodecIsolationMode es una propiedad ordinaria, así que un servicio puede aplicar cimRequired a las cargas y un modo más ligero a los documentos que generó él mismo
El códec en cuestión también cambia el panorama de riesgo. Los streams JPXDecode llevan conteos de tiles y componentes que manejan asignaciones directamente, mientras que las imágenes JBIG2 a menudo dependen de un stream /JBIG2Globals compartido por varias páginas. Un sandbox que enviara solo el stream por imagen decodificaría esas páginas mal o no las decodificaría, razón por la cual los segmentos globales viajan al worker junto con cada imagen
El aislamiento de códecs, los presupuestos de decodificación y los límites estructurales del parser viven todos en un componente VCL nativo, y el único archivo extra que desplegar es el ejecutable del worker. Las notas de configuración, la compilación del worker para Win32 y Win64, y una descarga de prueba están en la página del componente HotPDF para Delphi y C++Builder