Technisch artikel

PDF-beeldcodecs isoleren in workerprocessen met HotPDF

Een Delphi-service die beeldextractie in een try..except wikkelt, kan er in zijn log perfect gezond uitzien: een EAccessViolation wordt afgevangen, de upload wordt als slecht gemarkeerd, en de volgende job begint. Minuten later kan een ongerelateerd verzoek sterven met EInvalidPointer bij het vrijgeven van een stringlist. De twee gebeurtenissen hangen samen. Een JPEG 2000- of JBIG2-decoder die voorbij het einde van een buffer schreef voordat hij faalde, heeft de heap al beschadigd, en het afvangen van de exception herstelt de controleflow terwijl die schade precies daar blijft liggen. Geheugen dat u niet kunt vertrouwen, kunt u alleen weggooien, en de eenheid van geheugen die Windows u schoon laat weggooien is een proces

Waarom een try..except om de decoder niet genoeg is

Een image codec is het deel van een PDF-lezer dat de meest gecompliceerde toestandsmachine over de slechtst gecontroleerde data laat draaien. Tegen de tijd dat bytes een JPEG 2000- of JBIG2-decoder bereiken, is de cross-reference tabel geparseerd, is het beeldobject herleid en is de filterketen uitgepakt. Wat overblijft is een kale codestream die aankondigt hoeveel tiles, hoeveel componenten en hoeveel bits per sample hij bevat. Een verkeerd getal daar is geen syntaxfout die de parser kan afwijzen. Het wordt een allocatiegrootte, een lusgrens of een array-index binnen een strakke decodelus

Bytebudgetten dekken een deel hiervan, en een intakelus zou ze toch moeten hebben. HotPDF begrenst expansie met DecodeBudgetBytes en DocumentDecodeBudgetBytes, en filterketens met DecodeFilterLimit en DecodePipelineDepthLimit; de redenering achter die plafonds staat in begrensd decoderen voor geneste filters en PDF-bommen. Een budget beantwoordt één vraag: hoeveel uitvoer is toegestaan. Over een decoder die faalt nadat hij een handjevol bytes op de verkeerde plek schreef, zegt hij niets

De fout die wel wordt afgevangen is op een manier nog het slechtste resultaat. Een onafgevangen crash stopt op zijn minst het proces. Een afgevangen laat het doorlopen en verzoeken blijven bedienen bovenop een gecorrumpeerde heap, en de uiteindelijke storing draagt een stack trace die nergens in de richting van de PDF wijst die hem veroorzaakte

DCTDecode, JPXDecode en JBIG2Decode naar een workerproces verhuizen

HotPDF kan de drie hoog-risico-beeldfilters, DCTDecode, JPXDecode en JBIG2Decode, in een kortlevend workerproces, HotPDFCodecWorker.exe, draaien in plaats van binnen uw applicatie. De unit HPDFCodecIsolation benoemt ze als hckDCT, hckJPX en hckJBIG2. Flate, LZW, RunLength, ASCII85 en CCITT blijven in-process: die decoders hebben eenvoudige toestand, en de decodebudgetten zijn het juiste gereedschap voor ze

Elke aanvraag krijgt een fris proces. De host maakt één shared-memory mapping met een willekeurige naam, schrijft een vaste THPDFCodecSharedHeader gevolgd door de gecomprimeerde codestream en, voor JBIG2, de globale segmenten, start daarna de worker geschorst, zet hem in een Windows Job Object en pas dan laat hij hem draaien. De job staat exact één actief proces toe, dus een gecompromitteerde decoder kan geen kind spawnen, en hij wordt aangemaakt met kill-on-close, dus de worker kan de job-handle niet overleven. Gedecodeerde pixels komen als 24-bit BGR terug in dezelfde mapping, samen met een statuswoord

Architectuurdiagram van HotPDF-codecisolatie met een Delphi VCL-host die een shared-memory mapping uitwisselt met een wegwerpbaar werkproces voor DCTDecode-, JPXDecode- en JBIG2Decode-afbeeldingen
De host schrijft de gecomprimeerde codestream in een begrensde shared-memory map, een wegwerpbare worker decodeert hem onder job-object-plafonds, en alleen pixels plus een statuswoord reizen terug

Aanzetten kost vier properties op THotPDF. De beeldaanroepen blijven precies degene die u al gebruikt:

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;            // decodeer deze nooit in-process
    Pdf.CodecWorkerExecutable := '';                  // '' = naast de host-EXE
    Pdf.CodecWorkerTimeoutMilliseconds := 5000;       // 1..600000, anders ERangeError
    Pdf.CodecWorkerMemoryLimitBytes := 256 * 1024 * 1024; // 0 of >= 64 MiB
    Pdf.DecodeBudgetBytes := 128 * 1024 * 1024;

    if Pdf.LoadFromFile(FileName) > 0 then            // geeft het pagina-aantal terug
      for I := 0 to Pdf.GetLoadedImageCount - 1 do
      begin
        Bmp := Pdf.ExtractLoadedImage(I);
        try
          // Lees het oordeel meteen: het beschrijft alleen de laatste aanvraag
          if Pdf.GetLastCodecWorkerInfo(Info) then
            LogCodecOutcome(FileName, I, Info);
          if Bmp <> nil then
            StoreImage(FileName, I, Bmp);             // uw eigen code
        finally
          Bmp.Free;
        end;
      end;
  finally
    Pdf.Free;
  end;
end;

Als een geïsoleerde decode mislukt, geeft ExtractLoadedImage nil terug, dus de controle Bmp <> nil draagt hier echt gewicht. GetLastCodecWorkerInfo geeft False terug als er geen worker-aanvraag is geregistreerd, wat u ziet bij een Flate-gecomprimeerd beeld of met cimDisabled

Twee deploymentdetails veroorzaken het meeste gedoe. Een lege CodecWorkerExecutable herleidt naar HotPDFCodecWorker.exe in de map van ParamStr(0). Een niet-lege waarde gaat door ExpandFileName, wat betekent dat een relatief pad tegen de huidige map wordt herleid. Voor een Windows-service is die map meestal System32, dus 'bin\HotPDFCodecWorker.exe' werkt vanuit de IDE en faalt na installatie. Het andere detail is bitness: het buildscript van de worker produceert aparte Win32- en Win64-binary's, en degene die u meelevert moet matchen met de architectuur van het hostproces

Automatisch of vereist: wat gebeurt er als de worker ontbreekt?

De drie waarden van THPDFCodecIsolationMode beantwoorden één vraag: wat te doen als de worker helemaal niet bruikbaar is. cimDisabled probeert het nooit en decodeert alles in-process. cimAutomatic, de standaard, gebruikt de worker als HotPDFCodecWorker.exe bestaat en valt terug op in-process decoderen als het bestand er niet is, geregistreerd als cwsUnavailable. cimRequired weigert de terugval; een ontbrekende worker betekent dat het beeld niet wordt gedecodeerd

De terugval is nauwer dan hij eerst lijkt, en die nauwheid is bewust. Alleen een ontbrekend uitvoerbaar bestand valt terug. Bestaat het bestand wel maar faalt CreateProcess, doorgaans omdat een endpoint-securityproduct hem blokkeert, dan is het resultaat cwsLaunchFailed en wordt het beeld niet gedecodeerd, ook onder cimAutomatic. Een worker die startte en toen crashte, de timeout haalde of een limiet overschreed, wordt in geen van beide modi in-process opnieuw geprobeerd. Een bestand dat net de worker doodde opnieuw in uw eigen proces proberen, geeft de aanvaller een tweede poging op precies het doel waarvoor de worker er was

Vergelijking van CodecIsolationMode-waarden in HotPDF met het gedrag van cimDisabled, cimAutomatic en cimRequired wanneer de codec worker-executable ontbreekt
Alleen cimAutomatic valt terug op in-process decoderen, gemeld als cwsUnavailable, terwijl cimRequired de terugval weigert; crashes en timeouts zijn in beide modi een mislukking

Zet voor alles wat uploads, mailbijlagen of partnerdrops leest, cimRequired. De standaardmodus heeft een valkuil die pas na deployment opduikt: een installer die de worker vergeet produceert een server die elk beeld correct extraheert, elke functionele test haalt, en bij elk verzoek de codecs binnen de host draait. Niets lijkt stuk. cimAutomatic is redelijk voor een desktopviewer die bestanden opent die de gebruiker al vertrouwt, waar een ontbrekende worker moet degraderen in plaats van het product te stoppen. cimRequired zet bovendien ProgressiveJPEGScanDecoding uit, het scan-voor-scan pad voor progressieve JPEG, omdat dat pad in de host decodeert

Een opstartcontrole maakt van een vergeten worker een directe, harde mislukking. HPDFResolveCodecWorkerExecutable is publiek in HPDFCodecIsolation en past dezelfde herleidingsregel toe als de component:

// Een opstartcontrole die u zelf toevoegt: weiger te starten zonder de 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;

THPDFCodecWorkerStatus lezen

THPDFCodecWorkerInfo draagt Status, ProcessId, ExitCode, ElapsedMilliseconds en een ErrorMessage van de hostkant mee. De statuswaarden zijn cwsNotRun, cwsSucceeded, cwsUnavailable, cwsLaunchFailed, cwsTimedOut, cwsCrashed, cwsDecodeFailed, cwsProtocolError en cwsOutputLimit, en ze sorteren in drie operationele groepen

  • Deployment: cwsUnavailable en cwsLaunchFailed. De worker ontbreekt, wordt geblokkeerd of kon niet binnen zijn job worden gestart. Bel wie de server beheert; het document zelf kan prima in orde zijn
  • Document: cwsDecodeFailed en cwsOutputLimit. De codestream is misvormd of groter dan uw beleid toestaat. Het bestand afwijzen is het juiste antwoord
  • Inperking: cwsTimedOut, cwsCrashed en cwsProtocolError. Een vastloper, een dode worker, of een antwoord waarvan de header niet matcht met de protocolversie of waarvan de beweerde geometrie niet klopt. Dit zijn de gebeurtenissen waarvoor de procesgrens bestaat, en het bestand verdient quarantaine in plaats van een kale afwijzing

Het onderscheid tussen cwsDecodeFailed en cwsCrashed is het kennen waard wanneer u de cijfers leest. Delphi maakt van de meeste access violations exceptions, en de worker vangt exceptions rond de decoder af en meldt ze als mislukte decode. cwsCrashed betekent dat het workerproces eindigde met een exitcode ongelijk aan nul, wat gebeurt wanneer de fout te ernstig was om nog een exceptionhandler te laten draaien. ExitCode is een Cardinal, dus formatteer hem met %u of als hex; $C0000005 met %d afgedrukt wordt een negatief getal waar niemand correct op zoekt

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

De worker onderdrukt ook de Windows-foutdialoog voor zichzelf, dus een crash op een onbeheerde server toont zich in dit log in plaats van als een modaal venster dat wacht tot iemand OK klikt op een machine waar niemand naar kijkt

De drie plafonds op elke geïsoleerde decode

Elke geïsoleerde decode draait onder een tijdlimiet, een geheugenlimiet en een uitvoerlimiet, en de status vertelt u welke hem beëindigde. CodecWorkerTimeoutMilliseconds staat standaard op 10.000 en accepteert 1 tot 600.000; alles buiten dat bereik gooit bij toewijzing een ERangeError in plaats van afgekapt te worden. Bij een timeout beëindigt de host de hele job en meldt cwsTimedOut. CodecWorkerMemoryLimitBytes staat standaard op 536.870.912 bytes en moet nul zijn — geen plafond — of ten minste 67.108.864 bytes; hij wordt een committed-memory limiet per proces op het Job Object

De uitvoerlimiet is afgeleid. HotPDF berekent de bytes die het gedecodeerde beeld zou moeten kosten uit de gevraagde doelgrootte, de gevraagde regio of de beeldgeometrie die de PDF aankondigt, op drie bytes per pixel, en begrenst dat cijfer vervolgens op DecodeBudgetBytes als er een budget is gezet. De gedeelde mapping wordt op dat cijfer gemeten, dus de worker heeft geen ruimte om er voorbij te schrijven. Stel dat een scan 10.000 bij 10.000 pixels aankondigt: dat is 300.000.000 bytes aan BGR-uitvoer, meer dan de standaard DecodeBudgetBytes van 268.435.456 bytes, dus de limiet wordt 256 MiB en de decode eindigt met cwsOutputLimit

De host vertrouwt de grootte die de worker terugmeldt ook niet. Een antwoord wordt alleen geaccepteerd als zijn breedte keer hoogte keer drie gelijk is aan het byteaantal dat hij beweert, en dat aantal past zowel in de eigen uitvoerlimiet van de host als in de mapping. Een gesubverteerde worker kan elke waarde in de header schrijven; een mismatch wordt gemeld als cwsProtocolError en er worden geen pixels gekopieerd

Drie plafonds op elke geïsoleerde HotPDF-decode: werker-timeout, Job Object-geheugenlimiet en de afgeleide uitvoerlimiet begrensd door DecodeBudgetBytes
Strikte timeout- en geheugenvalidatie plus een afgeleid plafond voor pixeluitvoer betekenen dat te grote of vastlopende decodes eindigen binnen de worker als statuscodes, niet binnen je eigen proces

Houd het geheugenplafond ruim boven de uitvoerlimiet. Met de instellingen uit het eerste voorbeeld laat een uitvoerbudget van 128 MiB binnen een procesplafond van 256 MiB ruimte over voor de gecomprimeerde invoer en de eigen working set van de decoder. Zet de twee dicht bij elkaar en grote legitieme scans beginnen binnen de worker te falen om redenen die niets met vijandige invoer te maken hebben

Wat de procesgrens kost

Per geïsoleerd beeld een proces starten kost tijd, en een document met enkele honderden gescande JPEG-pagina's voelt dat. Bij een onbeheerde batchconverter verdwijnt die kost in het nachtelijke venster en is de inperking de reden dat de job bestaat. Een interactieve viewer die bestanden toont die de gebruiker al vertrouwt, is een ander geval; daar is cimAutomatic, of cimDisabled voor een bekend intern archief, een redelijke keuze. CodecIsolationMode is een gewone property, dus één service kan cimRequired op uploads toepassen en een lichtere modus op documenten die hij zelf genereerde

Ook de codec in kwestie verandert het risicobeeld. JPXDecode-streams dragen tile- en componenttellingen die allocaties rechtstreeks aanjagen, terwijl JBIG2-beelden vaak afhangen van een /JBIG2Globals-stream die meerdere pagina's delen. Een sandbox die alleen de per-beeld-stream meeleverde, zou die pagina's verkeerd of helemaal niet decoderen, en daarom reizen de globale segmenten samen met elk beeld naar de worker

Codec-isolatie, decodebudgetten en de structurele limieten van de parser zitten in één native VCL-component, en het enige extra bestand om te deployen is de worker-executable. Installatienotities, de worker-build voor Win32 en Win64 en een proefdownload staan op de HotPDF-componentpagina voor Delphi en C++Builder