Artículo técnico

Aísle códecs de imagen PDF en procesos worker con HotPDF

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

Diagrama de arquitectura del aislamiento de códecs de HotPDF que muestra un host VCL de Delphi intercambiando una asignación de memoria compartida con un proceso worker desechable para imágenes DCTDecode, JPXDecode y JBIG2Decode
El host escribe el codestream comprimido en un mapa de memoria compartida acotado, un worker desechable lo decodifica bajo techos del job object, y solo viajan de vuelta los píxeles más 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

Comparación de los valores de CodecIsolationMode en HotPDF que muestra el comportamiento de cimDisabled, cimAutomatic y cimRequired cuando falta el ejecutable del worker de códecs
Solo cimAutomatic recurre a la decodificación en el proceso, informado como cwsUnavailable, mientras que cimRequired rechaza el recurso; los crashes y los timeouts son fallos en ambos modos

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: cwsUnavailable y cwsLaunchFailed. 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: cwsDecodeFailed y cwsOutputLimit. 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, cwsCrashed y cwsProtocolError. 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

Tres techos en cada decodificación aislada de HotPDF: timeout del worker, límite de memoria del Job Object y el límite de salida derivado recortado por DecodeBudgetBytes
La validación estricta de tiempo y memoria más un techo de salida de píxeles derivado significan que las decodificaciones sobredimensionadas o colgadas terminan dentro del worker como códigos de estado, no dentro de vuestro proceso

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