Articolo tecnico

Isolamento codec immagine PDF in worker con HotPDF

Un servizio Delphi che avvolge l'estrazione immagini in try..except può sembrare perfettamente sano nei suoi log: una EAccessViolation viene catturata, l'upload viene marcato come cattivo, e il job successivo parte. Minuti dopo una richiesta non correlata può morire con EInvalidPointer mentre libera una string list. I due eventi sono collegati. Un decoder JPEG 2000 o JBIG2 che ha scritto oltre la fine di un buffer prima di andare in fault ha già danneggiato l'heap, e catturare l'eccezione ripristina il flusso di controllo lasciando quel danno esattamente dov'era. La memoria di cui non vi potete fidare si può solo buttare via, e l'unità di memoria che Windows lascia buttare via pulitamente è un processo

Perché un try..except attorno al decoder non basta

Un codec immagine è la parte di un lettore PDF che esegue la macchina a stati più complicata sui dati meno controllati. Quando i byte arrivano a un decoder JPEG 2000 o JBIG2, la tabella dei riferimenti incrociati è stata analizzata, l'oggetto immagine risolto e la catena di filtri districata. Ciò che resta è un codestream grezzo che annuncia quanti tile, quanti componenti e quanti bit per campione contiene. Un numero sbagliato lì non è un errore di sintassi che il parser possa rifiutare. Diventa una dimensione di allocazione, un limite di loop o un indice di array dentro un loop di decode serrato

I budget di byte coprono parte del problema, e un percorso di intake dovrebbe averli comunque. HotPDF limita l'espansione con DecodeBudgetBytes e DocumentDecodeBudgetBytes, e le catene di filtri con DecodeFilterLimit e DecodePipelineDepthLimit; il ragionamento dietro quei tetti sta in decodifica limitata per filtri annidati e PDF bomb. Un budget risponde a una domanda: quanto output è consentito. Non ha nulla da dire su un decoder che va in fault dopo aver scritto una manciata di byte nel posto sbagliato

Il fault che viene catturato è per certi versi l'esito peggiore. Un crash non gestito almeno ferma il processo. Uno catturato lo lascia servire richieste sopra un heap corrotto, e il fallimento finale porta uno stack trace che non punta mica vicino al PDF che l'ha causato

Spostare DCTDecode, JPXDecode e JBIG2Decode in un processo worker

HotPDF può eseguire i tre filtri immagine ad alto rischio, DCTDecode, JPXDecode e JBIG2Decode, in un processo worker di breve vita, HotPDFCodecWorker.exe, invece che dentro la vostra applicazione. L'unit HPDFCodecIsolation li nomina hckDCT, hckJPX e hckJBIG2. Flate, LZW, RunLength, ASCII85 e CCITT restano in-process: quei decoder hanno stato semplice, e i budget di decode sono lo strumento giusto per loro

Ogni richiesta riceve un processo fresco. L'host crea una mappatura di memoria condivisa con nome casuale, scrive un THPDFCodecSharedHeader fisso seguito dal codestream compresso e, per JBIG2, dai segmenti globali, poi avvia il worker sospeso, lo colloca in un Job Object Windows e solo allora lo lascia correre. Il job consente esattamente un processo attivo, così un decoder compromesso non può generare un figlio, e viene creato con kill-on-close, così il worker non può sopravvivere all'handle del job. I pixel decodificati tornano come BGR a 24 bit nella stessa mappatura, insieme a una parola di stato

Diagramma di architettura dell'isolamento dei codec di HotPDF: un host Delphi VCL che scambia una mappatura di memoria condivisa con un processo worker monouso per le immagini DCTDecode, JPXDecode e JBIG2Decode
L'host scrive il codestream compresso in una mappa di memoria condivisa delimitata, un worker monouso la decodifica sotto i tetti del job object, e solo i pixel più una parola di stato viaggiano indietro

Attivarlo richiede quattro proprietà su THotPDF. Le chiamate immagine restano le stesse che usate già:

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;            // non decodificare mai questi in-process
    Pdf.CodecWorkerExecutable := '';                  // '' = accanto all'EXE host
    Pdf.CodecWorkerTimeoutMilliseconds := 5000;       // 1..600000, altrimenti ERangeError
    Pdf.CodecWorkerMemoryLimitBytes := 256 * 1024 * 1024; // 0 oppure >= 64 MiB
    Pdf.DecodeBudgetBytes := 128 * 1024 * 1024;

    if Pdf.LoadFromFile(FileName) > 0 then            // restituisce il numero di pagine
      for I := 0 to Pdf.GetLoadedImageCount - 1 do
      begin
        Bmp := Pdf.ExtractLoadedImage(I);
        try
          // Leggete il verdetto subito: descrive solo l'ultima richiesta
          if Pdf.GetLastCodecWorkerInfo(Info) then
            LogCodecOutcome(FileName, I, Info);
          if Bmp <> nil then
            StoreImage(FileName, I, Bmp);             // codice vostro
        finally
          Bmp.Free;
        end;
      end;
  finally
    Pdf.Free;
  end;
end;

Quando un decode isolato fallisce, ExtractLoadedImage restituisce nil, quindi il controllo Bmp <> nil qui pesa davvero. GetLastCodecWorkerInfo restituisce False quando nessuna richiesta al worker è stata registrata, ed è ciò che vedete per un'immagine compressa Flate o con cimDisabled

Due dettagli di deployment causano la maggior parte dei guai. Un CodecWorkerExecutable vuoto si risolve in HotPDFCodecWorker.exe nella directory di ParamStr(0). Un valore non vuoto passa per ExpandFileName, il che significa che un percorso relativo si risolve contro la directory corrente. Per un servizio Windows quella directory di solito è System32, quindi 'bin\HotPDFCodecWorker.exe' funziona dall'IDE e fallisce dopo l'installazione. L'altro dettaglio è la bitness: lo script di build del worker produce binari Win32 e Win64 separati, e quello che distribuite deve corrispondere all'architettura del processo host

Automatic o required: che cosa accade quando il worker manca?

I tre valori di THPDFCodecIsolationMode rispondono a una sola domanda, cioè che cosa fare quando il worker non può proprio essere usato. cimDisabled non lo tenta mai e decodifica tutto in-process. cimAutomatic, il default, usa il worker quando HotPDFCodecWorker.exe esiste e ricade sulla decodifica in-process quando il file non c'è, registrando cwsUnavailable. cimRequired rifiuta il fallback; un worker mancante significa che l'immagine non viene decodificata

Il fallback è più stretto di quanto sembri a prima vista, e la strettezza è deliberata. Soltanto un eseguibile mancante fa fallback. Se il file esiste ma CreateProcess fallisce, tipicamente perché un prodotto di security endpoint lo blocca, il risultato è cwsLaunchFailed e l'immagine non viene decodificata, anche sotto cimAutomatic. Un worker partito e poi andato in crash, scaduto o sopra un limite non viene mai ritentato in-process in nessuna delle due modalità. Ritentare dentro il vostro processo un file che ha appena ucciso il worker consegnerebbe all'attaccante un secondo tentativo proprio sul bersaglio che il worker era lì a proteggere

Confronto dei valori di CodecIsolationMode in HotPDF con i comportamenti di cimDisabled, cimAutomatic e cimRequired quando il worker dei codec non riesce ad avviarsi
Solo cimAutomatic ricade sulla decodifica in-process, riportata come cwsUnavailable, mentre cimRequired rifiuta il fallback; crash e timeout sono fallimenti in entrambe le modalità

Per qualsiasi cosa legga upload, allegati di posta o drop di partner, impostate cimRequired. La modalità di default ha una trappola che si vede solo dopo il deployment: un installer che dimentica il worker produce un server che estrae ogni immagine correttamente, passa ogni test funzionale, ed esegue i codec dentro l'host a ogni singola richiesta. Nulla sembra rotto. cimAutomatic è ragionevole per un viewer desktop che apre file che l'utente ha già, dove un worker mancante dovrebbe degradare invece di fermare il prodotto. cimRequired spegne anche ProgressiveJPEGScanDecoding, il percorso JPEG progressivo scan per scan, perché quel percorso decodifica nell'host

Un controllo all'avvio trasforma un worker dimenticato in un fallimento immediato e rumoroso. HPDFResolveCodecWorkerExecutable è pubblica in HPDFCodecIsolation e applica la stessa regola di risoluzione del componente:

// Un controllo all'avvio che aggiungete voi: rifiutarsi di partire senza il 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;

Leggere THPDFCodecWorkerStatus

THPDFCodecWorkerInfo porta Status, ProcessId, ExitCode, ElapsedMilliseconds e un ErrorMessage lato host. I valori di stato sono cwsNotRun, cwsSucceeded, cwsUnavailable, cwsLaunchFailed, cwsTimedOut, cwsCrashed, cwsDecodeFailed, cwsProtocolError e cwsOutputLimit, e si ordinano in tre gruppi operativi

  • Deployment: cwsUnavailable e cwsLaunchFailed. Il worker manca, è bloccato, o non è riuscito a partire dentro il suo job. Chiamate chi possiede il server; il documento stesso può stare a posto
  • Documento: cwsDecodeFailed e cwsOutputLimit. Il codestream è malformato o più grande di quanto la vostra policy permetta. Rifiutare il file è la risposta corretta
  • Contenimento: cwsTimedOut, cwsCrashed e cwsProtocolError. Un blocco, un worker morto, o una risposta il cui header non corrisponde alla versione del protocollo o la cui geometria dichiarata non torna. Sono gli eventi per cui esiste il confine di processo, e il file merita la quarantena invece di un rifiuto semplice

La linea tra cwsDecodeFailed e cwsCrashed vale la pena conoscerla quando leggete i numeri. Delphi trasforma la maggior parte delle access violation in eccezioni, e il worker cattura le eccezioni attorno al decoder e le riporta come decode fallito. cwsCrashed significa che il processo worker è finito con un exit code diverso da zero, il che accade quando il fault era abbastanza severo che nessun gestore di eccezioni ha fatto in tempo a girare. ExitCode è un Cardinal, quindi formattatelo con %u o come esadecimale; $C0000005 stampato con %d diventa un numero negativo che nessuno cerca correttamente

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);   // codice vostro
    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]));          // codice vostro
  else
    RejectDocument(FileName, Info.ErrorMessage);                  // codice vostro
  end;
end;

Il worker sopprime anche la finestra di dialogo dei fault di Windows per se stesso, così un crash su un server non presidiato appare in questo log invece che come una finestra modale in attesa che qualcuno clicchi OK su una macchina che nessuno guarda

I tre tetti su ogni decode isolato

Ogni decode isolato gira sotto un limite di tempo, un limite di memoria e un limite di output, e lo stato vi dice quale lo ha chiuso. CodecWorkerTimeoutMilliseconds vale 10.000 di default e accetta da 1 a 600.000; qualsiasi cosa fuori da quell'intervallo solleva ERangeError all'assegnazione invece di essere limitato. Al timeout l'host termina l'intero job e riporta cwsTimedOut. CodecWorkerMemoryLimitBytes vale 536.870.912 byte di default e deve essere zero, cioè nessun tetto, o almeno 67.108.864 byte; diventa un limite di memoria commit per processo sul Job Object

Il limite di output è derivato. HotPDF calcola i byte che l'immagine decodificata dovrebbe richiedere dalla dimensione target richiesta, dalla regione richiesta o dalla geometria immagine dichiarata nel PDF, a tre byte per pixel, e poi limita quel valore a DecodeBudgetBytes quando un budget è impostato. La mappatura condivisa viene dimensionata su quel valore, così il worker non ha spazio per scrivere oltre. Immaginate una scansione che dichiara 10.000 per 10.000 pixel: sono 300.000.000 byte di output BGR, più dei 268.435.456 byte di default di DecodeBudgetBytes, quindi il limite diventa 256 MiB e il decode finisce con cwsOutputLimit

L'host non si fida nemmeno della dimensione che il worker riporta indietro. Una risposta viene accettata solo se la sua larghezza per altezza per tre è uguale al conteggio di byte che dichiara, e quel conteggio entra sia nel limite di output dell'host sia nella mappatura. Un worker compromesso può scrivere qualsiasi valore nell'header; una mancata corrispondenza viene riportata come cwsProtocolError e nessun pixel viene copiato

Tre limiti massimi su ogni decodifica isolata di HotPDF: timeout del worker, limite di memoria del Job Object e limite di output derivato vincolato da DecodeBudgetBytes
Validazione rigorosa di timeout e memoria più un tetto derivato sull'output in pixel significano che le decodifiche sovradimensionate o bloccate finiscono dentro il worker come codici di stato, non dentro il vostro processo

Tenete il limite di memoria comodamente sopra il limite di output. Con le impostazioni del primo esempio, un budget di output di 128 MiB dentro un tetto di processo di 256 MiB lascia spazio all'input compresso e al working set del decoder. Impostateli vicini e le grandi scansioni legittime iniziano a fallire dentro il worker per ragioni che non c'entrano nulla con input ostili

Che cosa costa il confine di processo

Avviare un processo per ogni immagine isolata costa tempo, e un documento con alcune centinaia di pagine JPEG scansionate lo farà sentire. Su un convertitore batch non presidiato quel costo sparisce nella finestra notturna e il contenimento è la ragione per cui il job esiste. Un viewer interattivo che mostra file di cui l'utente già si fida è un caso diverso; lì cimAutomatic, o cimDisabled per un archivio interno noto, è una scelta equa. CodecIsolationMode è una proprietà ordinaria, quindi un solo servizio può applicare cimRequired agli upload e una modalità più leggera ai documenti che ha generato da sé

Anche il codec in questione cambia il quadro del rischio. Gli stream JPXDecode portano conteggi di tile e componenti che pilotano le allocazioni direttamente, mentre le immagini JBIG2 dipendono spesso da uno stream /JBIG2Globals condiviso da più pagine. Una sandbox che spediscesse solo lo stream per immagine decodificherebbe quelle pagine male o per niente, ed è per questo che i segmenti globali viaggiano nel worker insieme a ogni immagine

Isolamento dei codec, budget di decode e limiti strutturali del parser vivono tutti in un solo componente VCL nativo, e l'unico file extra da distribuire è l'eseguibile del worker. Note di setup, la build del worker per Win32 e Win64 e un download di prova sono sulla pagina del componente HotPDF per Delphi e C++Builder