Un servicio Delphi que envuelve la extracción de imágenes en un try..except puede parecer perfectamente sano en su log: un EAccessViolation se captura, la subida se marca como mala y el siguiente trabajo arranca. Minutos después una petición sin relación puede morir con un EInvalidPointer al liberar 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 buffer antes de fallar ya ha dañado 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 podéis confiar solo se puede tirar, y la unidad de memoria que Windows os 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 comprobados. Para cuando los bytes llegan a un decodificador JPEG 2000 o JBIG2, la tabla de referencias cruzadas está parseada, el objeto de imagen resuelto y la cadena de filtros desenvuelta. Lo que queda es un codestream en bruto 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 array 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 a 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 sitio equivocado
El fallo que sí se captura es, en algunos sentidos, el peor desenlace. Un crash no manejado al menos detiene el proceso. Uno capturado le permite seguir sirviendo peticiones sobre un heap corrompido, y el fallo final lleva un stack trace que no apunta ni de lejos al 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 vida corta, HotPDFCodecWorker.exe, en lugar de dentro de vuestra aplicación. La unidad HPDFCodecIsolation los nombra hckDCT, hckJPX y hckJBIG2. Flate, LZW, RunLength, ASCII85 y CCITT se quedan en el proceso: esos decodificadores tienen un estado simple, y los presupuestos de decodificación son la herramienta adecuada para ellos
Cada petición recibe un proceso fresco. El host crea una única asignación de memoria compartida de nombre aleatorio, escribe una THPDFCodecSharedHeader fija seguida del codestream comprimido y, para JBIG2, los segmentos globales, luego arranca el worker suspendido, lo coloca en un Job Object de Windows y solo entonces lo deja correr. El job permite exactamente un proceso activo, así que un decodificador comprometido no puede engendrar un hijo, y se crea con kill-on-close, así que el worker no puede sobrevivir al handle del job. Los píxeles decodificados vuelven como BGR de 24 bits en la misma asignación, junto con una palabra de estado
Activarlo lleva cuatro propiedades sobre THotPDF. Las llamadas de imagen siguen siendo las que ya usáis:
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 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
// Leed el veredicto enseguida: describe solo la petición más reciente
if Pdf.GetLastCodecWorkerInfo(Info) then
LogCodecOutcome(FileName, I, Info);
if Bmp <> nil then
StoreImage(FileName, I, Bmp); // código vuestro
finally
Bmp.Free;
end;
end;
finally
Pdf.Free;
end;
end;
Cuando una decodificación aislada falla, ExtractLoadedImage devuelve nil, así que la comprobación Bmp <> nil lleva peso real aquí. GetLastCodecWorkerInfo devuelve False cuando no se registró ninguna petición al worker, que es lo que veis con una imagen comprimida con Flate o con cimDisabled
Dos detalles de despliegue causan la mayor parte del problema. Un CodecWorkerExecutable vacío 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, de modo que 'bin\HotPDFCodecWorker.exe' funciona desde el IDE y falla tras la instalación. El otro detalle es la bitness: el script de build del worker produce binarios Win32 y Win64 separados, y el que distribuyáis debe coincidir con la arquitectura del proceso host
Automático o requerido: ¿qué pasa cuando falta el worker?
Los tres valores de THPDFCodecIsolationMode responden a una única pregunta: qué hacer cuando el worker no se puede usar en absoluto. cimDisabled nunca lo intenta y decodifica todo en el proceso. cimAutomatic, el valor por defecto, usa el worker cuando HotPDFCodecWorker.exe existe y recurre a la decodificación en el proceso cuando el fichero no está, registrando cwsUnavailable. cimRequired rechaza el recurso; un worker ausente significa que la imagen no se decodifica
El recurso es más estrecho de lo que parece a primera vista, y la estrechez es deliberada. Solo un ejecutable ausente recurre. Si el fichero 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 crasheó, superó el tiempo o excedió un límite nunca se reintenta en el proceso en ninguno de los dos modos. Reintentar en vuestro propio proceso un fichero que acaba de matar al worker sería entregar al atacante un segundo intento sobre exactamente el objetivo que el worker estaba allí para proteger
Para cualquier cosa que lea subidas, adjuntos de correo o depósitos de socios, poned cimRequired. El modo por defecto tiene una trampa que solo aparece tras el despliegue: un instalador que olvida el worker produce un servidor que extrae cada imagen correctamente, pasa todos los tests funcionales y ejecuta los códecs dentro del host en cada petición. Nada parece roto. cimAutomatic es razonable para un visor de escritorio que abre ficheros que el usuario ya tiene, donde un worker ausente debería degradarse en lugar de detener el producto. cimRequired también apaga ProgressiveJPEGScanDecoding, la ruta de JPEG progresivo escaneo a escaneo, porque esa ruta decodifica en el host
Una comprobación de arranque convierte un worker olvidado en un fallo inmediato y ruidoso. HPDFResolveCodecWorkerExecutable es pública en HPDFCodecIsolation y aplica la misma regla de resolución que el componente:
// Una comprobación de arranque que añadís vosotros: 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 arrancarse dentro de su job. Llamad a quien gestione el servidor; el documento en sí puede estar bien - Documento:
cwsDecodeFailedycwsOutputLimit. El codestream está malformado o es más grande de lo que vuestra política permite. Rechazar el fichero es la respuesta correcta - Contención:
cwsTimedOut,cwsCrashedycwsProtocolError. Un cuelgue, un worker muerto, o una respuesta cuya cabecera 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 fichero merece cuarentena en lugar de un rechazo simple
La frontera entre cwsDecodeFailed y cwsCrashed merece conocerse cuando leáis los números. Delphi convierte la mayoría de las violaciones de acceso en excepciones, y el worker captura las excepciones alrededor del decodificador y las informa como decodificación fallida. cwsCrashed significa que el proceso worker terminó con un código de salida distinto de cero, lo que pasa cuando el fallo fue lo bastante grave como para que ningún manejador de excepciones llegara a ejecutarse. ExitCode es un Cardinal, así que formateadlo 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); // código vuestro
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])); // código vuestro
else
RejectDocument(FileName, Info.ErrorMessage); // código vuestro
end;
end;
El worker también suprime para sí mismo el diálogo de fallos de Windows, así que un crash en un servidor desatendido aparece en este log en lugar de aparecer como una caja modal esperando que alguien pulse Aceptar en una máquina que nadie mira
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 os dice cuál la terminó. CodecWorkerTimeoutMilliseconds vale 10.000 por defecto y acepta de 1 a 600.000; cualquier cosa fuera de ese rango lanza ERangeError en la asignación en lugar de recortarse. En un timeout el host termina el job entero e informa cwsTimedOut. CodecWorkerMemoryLimitBytes vale 536.870.912 bytes por defecto y debe ser cero, es decir 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 al DecodeBudgetBytes cuando hay presupuesto. La asignación compartida se dimensiona con esa cifra, así que el worker no tiene espacio para escribir más allá. Suponed que un escaneo declara 10.000 por 10.000 píxeles: son 300.000.000 bytes de salida BGR, más que el DecodeBudgetBytes por defecto de 268.435.456 bytes, así que el límite pasa a 256 MiB y la decodificación termina con cwsOutputLimit
El host tampoco confía en el tamaño que el worker informa de vuelta. Una respuesta se acepta solo si su ancho por alto por tres iguala el recuento de bytes que declara, y ese recuento cabe tanto en el límite de salida del propio host como en la asignación. Un worker subvertido puede escribir cualquier valor en la cabecera; un desfase se informa como cwsProtocolError y no se copia ningún píxel
Manted el límite de memoria holgado por encima del límite de salida. Con los ajustes del primer ejemplo, un presupuesto de salida de 128 MiB dentro de un tope de proceso de 256 MiB deja sitio para la entrada comprimida y el working set del propio decodificador. Poned los dos cerca 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 imagen aislada cuesta tiempo, y un documento con varios cientos de páginas JPEG escaneadas lo notará. En un conversor por lotes desatendido ese coste se disuelve en la ventana nocturna y la contención es la razón de ser del trabajo. Un visor interactivo que muestra ficheros en los que el usuario ya confía es otro caso; allí cimAutomatic, o cimDisabled para un archivo interno conocido, es una elección justa. CodecIsolationMode es una propiedad ordinaria, así que un mismo servicio puede aplicar cimRequired a las subidas 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 recuentos de tiles y componentes que gobiernan asignaciones directamente, mientras que las imágenes JBIG2 a menudo dependen de un stream /JBIG2Globals compartido por varias páginas. Un sandbox que distribuyera solo el stream por imagen decodificaría esas páginas mal o no las decodificaría, razón por la que 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 único componente VCL nativo, y el único fichero extra que desplegar es el ejecutable del worker. Las notas de configuración, el build 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