Article technique

HotPDF : isoler les codecs image PDF en processus worker

Un service Delphi qui enveloppe l'extraction d'images dans un try..except peut paraître parfaitement sain dans son journal : un EAccessViolation est intercepté, l'envoi est marqué comme mauvais, et la tâche suivante démarre. Quelques minutes plus tard, une requête sans rapport peut mourir avec un EInvalidPointer en libérant une liste de chaînes. Les deux événements sont liés. Un décodeur JPEG 2000 ou JBIG2 qui a écrit au-delà de la fin d'un tampon avant que sa faute ne survienne a déjà endommagé le tas, et intercepter l'exception restaure le flux de contrôle en laissant ce dégât exactement où il est. De la mémoire à laquelle on ne peut plus se fier ne peut qu'être jetée, et l'unité de mémoire que Windows permet de jeter proprement est un processus

Pourquoi un try..except autour du décodeur ne suffit pas

Un codec d'image est la partie d'un lecteur PDF qui fait tourner la machine à états la plus compliquée sur les données les moins vérifiées. Au moment où les octets atteignent un décodeur JPEG 2000 ou JBIG2, la table de références croisées a été analysée, l'objet image résolu et la chaîne de filtres déroulée. Ce qui reste est un flux de code brut qui annonce combien de tuiles, combien de composants et combien de bits par échantillon il contient. Un mauvais nombre à cet endroit n'est pas une erreur de syntaxe que l'analyseur peut rejeter. Il devient une taille d'allocation, une borne de boucle ou un indice de tableau à l'intérieur d'une boucle de décodage serrée

Les budgets en octets couvrent une partie du problème, et un chemin d'ingestion devrait de toute façon en avoir. HotPDF borne l'expansion avec DecodeBudgetBytes et DocumentDecodeBudgetBytes, et borne les chaînes de filtres avec DecodeFilterLimit et DecodePipelineDepthLimit ; le raisonnement derrière ces plafonds se trouve dans le décodage borné pour les filtres imbriqués et les bombes PDF. Un budget répond à une seule question : combien de sortie est autorisée. Il ne dit rien d'un décodeur qui déclenche une faute après avoir écrit une poignée d'octets au mauvais endroit

La faute qu'on intercepte est, d'une certaine façon, le pire résultat. Un plantage non géré arrête au moins le processus. Une faute interceptée le laisse servir des requêtes sur un tas corrompu, et la défaillance qui finit par survenir porte une pile d'appels qui ne pointe nulle part près du PDF qui l'a causée

Déplacer DCTDecode, JPXDecode et JBIG2Decode dans un processus worker

HotPDF peut faire tourner les trois filtres d'image à haut risque, DCTDecode, JPXDecode et JBIG2Decode, dans un processus worker de courte durée, HotPDFCodecWorker.exe, au lieu de le faire dans votre application. L'unité HPDFCodecIsolation les nomme hckDCT, hckJPX et hckJBIG2. Flate, LZW, RunLength, ASCII85 et CCITT restent dans le processus : ces décodeurs ont un état simple, et les budgets de décodage sont le bon outil pour eux

Chaque requête obtient un processus neuf. L'hôte crée une projection de mémoire partagée au nom aléatoire, écrit un THPDFCodecSharedHeader fixe suivi du flux de code compressé et, pour JBIG2, des segments globaux, puis démarre le worker suspendu, le place dans un Job Object Windows et seulement alors le laisse tourner. Le job autorise exactement un processus actif, si bien qu'un décodeur compromis ne peut pas engendrer d'enfant, et il est créé avec kill-on-close, si bien que le worker ne peut pas survivre au handle du job. Les pixels décodés reviennent en BGR 24 bits dans la même projection, avec un mot d'état

Diagramme d'architecture de l'isolation de codecs HotPDF montrant un hôte Delphi VCL échangeant une projection de mémoire partagée avec un processus worker jetable pour des images DCTDecode, JPXDecode et JBIG2Decode
L'hôte écrit le flux de code compressé dans une projection de mémoire partagée bornée, un worker jetable le décode sous les plafonds du job object, et seuls les pixels plus un mot d'état font le chemin retour

L'activer demande quatre propriétés sur THotPDF. Les appels d'image restent ceux que vous utilisez déjà :

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;            // ne jamais décoder ces codecs dans le processus
    Pdf.CodecWorkerExecutable := '';                  // '' = à côté de l'EXE hôte
    Pdf.CodecWorkerTimeoutMilliseconds := 5000;       // 1..600000, sinon ERangeError
    Pdf.CodecWorkerMemoryLimitBytes := 256 * 1024 * 1024; // 0 ou >= 64 MiB
    Pdf.DecodeBudgetBytes := 128 * 1024 * 1024;

    if Pdf.LoadFromFile(FileName) > 0 then            // renvoie le nombre de pages
      for I := 0 to Pdf.GetLoadedImageCount - 1 do
      begin
        Bmp := Pdf.ExtractLoadedImage(I);
        try
          // Lisez le verdict tout de suite : il décrit la dernière requête seulement
          if Pdf.GetLastCodecWorkerInfo(Info) then
            LogCodecOutcome(FileName, I, Info);
          if Bmp <> nil then
            StoreImage(FileName, I, Bmp);             // votre propre code
        finally
          Bmp.Free;
        end;
      end;
  finally
    Pdf.Free;
  end;
end;

Quand un décodage isolé échoue, ExtractLoadedImage renvoie nil, si bien que le test Bmp <> nil porte ici un vrai poids. GetLastCodecWorkerInfo renvoie False quand aucune requête worker n'a été enregistrée, ce qu'on voit pour une image compressée en Flate ou avec cimDisabled

Deux détails de déploiement causent la plupart des ennuis. Un CodecWorkerExecutable vide se résout en HotPDFCodecWorker.exe dans le répertoire de ParamStr(0). Une valeur non vide passe par ExpandFileName, ce qui fait qu'un chemin relatif se résout par rapport au répertoire courant. Pour un service Windows, ce répertoire est généralement System32, donc 'bin\HotPDFCodecWorker.exe' fonctionne depuis l'IDE et échoue après installation. L'autre détail est le bitness : le script de build du worker produit des binaires Win32 et Win64 séparés, et celui que vous livrez doit correspondre à l'architecture du processus hôte

Automatique ou requis : que se passe-t-il quand le worker est absent ?

Les trois valeurs de THPDFCodecIsolationMode répondent à une seule question, à savoir quoi faire quand le worker est inutilisable. cimDisabled ne l'essaie jamais et décode tout dans le processus. cimAutomatic, la valeur par défaut, utilise le worker quand HotPDFCodecWorker.exe existe et revient au décodage dans le processus quand le fichier n'est pas là, en enregistrant cwsUnavailable. cimRequired refuse le repli ; un worker manquant signifie que l'image n'est pas décodée

Le repli est plus étroit qu'il n'y paraît, et cet étroitement est délibéré. Seul un exécutable manquant déclenche le repli. Si le fichier existe mais que CreateProcess échoue, typiquement parce qu'un produit de sécurité d'endpoint le bloque, le résultat est cwsLaunchFailed et l'image n'est pas décodée, même sous cimAutomatic. Un worker qui a démarré puis planté, expiré ou dépassé une limite n'est jamais retenté dans le processus, dans aucun des deux modes. Retenter dans votre propre processus un fichier qui vient de tuer le worker offrirait à l'attaquant une deuxième tentative sur précisément la cible que le worker était là pour protéger

Comparaison des valeurs de CodecIsolationMode dans HotPDF montrant le comportement de cimDisabled, cimAutomatic et cimRequired quand l'exécutable worker de codec est absent
Seul cimAutomatic revient au décodage dans le processus, signalé par cwsUnavailable, tandis que cimRequired refuse le repli ; plantages et dépassements de délai sont des échecs dans les deux modes

Pour tout ce qui lit des envois, des pièces jointes de messagerie ou des dépôts partenaires, réglez cimRequired. Le mode par défaut cache un piège qui n'apparaît qu'après le déploiement : un installateur qui oublie le worker produit un serveur qui extrait chaque image correctement, passe tous les tests fonctionnels et fait tourner les codecs dans l'hôte à chaque requête. Rien ne paraît cassé. cimAutomatic est raisonnable pour une visionneuse de bureau ouvrant des fichiers que l'utilisateur possède déjà, où un worker manquant devrait dégrader plutôt qu'arrêter le produit. cimRequired désactive aussi ProgressiveJPEGScanDecoding, le chemin JPEG progressif scan par scan, car ce chemin décode dans l'hôte

Une vérification au démarrage transforme un worker oublié en échec immédiat et bruyant. HPDFResolveCodecWorkerExecutable est publique dans HPDFCodecIsolation et applique la même règle de résolution que le composant :

// Une vérification au démarrage que vous ajoutez vous-même : refuser de démarrer sans le 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;

Lire THPDFCodecWorkerStatus

THPDFCodecWorkerInfo porte Status, ProcessId, ExitCode, ElapsedMilliseconds et un ErrorMessage côté hôte. Les valeurs de statut sont cwsNotRun, cwsSucceeded, cwsUnavailable, cwsLaunchFailed, cwsTimedOut, cwsCrashed, cwsDecodeFailed, cwsProtocolError et cwsOutputLimit, et elles se trient en trois groupes opérationnels

  • Déploiement : cwsUnavailable et cwsLaunchFailed. Le worker est absent, bloqué, ou n'a pas pu démarrer dans son job. Appelez celui qui gère le serveur ; le document lui-même est peut-être bon
  • Document : cwsDecodeFailed et cwsOutputLimit. Le flux de code est malformé ou plus gros que ce que votre politique autorise. Rejeter le fichier est la bonne réponse
  • Confinement : cwsTimedOut, cwsCrashed et cwsProtocolError. Un blocage, un worker mort, ou une réponse dont l'en-tête ne correspond pas à la version du protocole ou dont la géométrie annoncée ne tient pas debout. Ce sont les événements pour lesquels la frontière de processus existe, et le fichier mérite une quarantaine plutôt qu'un simple rejet

La frontière entre cwsDecodeFailed et cwsCrashed vaut qu'on la connaisse quand on lit les chiffres. Delphi transforme la plupart des violations d'accès en exceptions, et le worker intercepte les exceptions autour du décodeur et les rapporte comme décodage échoué. cwsCrashed signifie que le processus worker s'est terminé avec un code de sortie non nul, ce qui arrive quand la faute était assez sévère pour qu'aucun gestionnaire d'exception ne puisse s'exécuter. ExitCode est un Cardinal, formatez-le donc avec %u ou en hexadécimal ; $C0000005 imprimé avec %d devient un nombre négatif que personne ne recherche correctement

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

Le worker supprime aussi pour lui-même la boîte de dialogue de faute Windows, si bien qu'un plantage sur un serveur sans surveillance apparaît dans ce journal au lieu d'apparaître comme une boîte modale attendant que quelqu'un clique sur OK sur une machine que personne ne regarde

Les trois plafonds de chaque décodage isolé

Chaque décodage isolé tourne sous une limite de temps, une limite mémoire et une limite de sortie, et le statut vous dit laquelle l'a terminé. CodecWorkerTimeoutMilliseconds vaut 10 000 par défaut et accepte 1 à 600 000 ; toute valeur hors de cette plage lève ERangeError à l'affectation au lieu d'être écrêtée. Au dépassement de délai, l'hôte termine tout le job et rapporte cwsTimedOut. CodecWorkerMemoryLimitBytes vaut 536 870 912 octets par défaut et doit être zéro, c'est-à-dire sans plafond, ou au moins 67 108 864 octets ; il devient une limite de mémoire engagée par processus sur le Job Object

La limite de sortie est dérivée. HotPDF calcule les octets dont l'image décodée devrait avoir besoin à partir de la taille cible demandée, de la région demandée ou de la géométrie d'image déclarée dans le PDF, à trois octets par pixel, puis plafonne ce chiffre à DecodeBudgetBytes quand un budget est défini. La projection partagée est dimensionnée d'après ce chiffre, si bien que le worker n'a pas d'espace pour écrire au-delà. Supposez qu'une numérisation déclare 10 000 sur 10 000 pixels : cela fait 300 000 000 octets de sortie BGR, plus que les 268 435 456 octets par défaut de DecodeBudgetBytes, donc la limite devient 256 MiB et le décodage se termine avec cwsOutputLimit

L'hôte ne se fie pas non plus à la taille que le worker rapporte en retour. Une réponse n'est acceptée que si sa largeur fois hauteur fois trois égale le nombre d'octets qu'elle revendique, et que ce nombre tient à la fois dans la limite de sortie de l'hôte et dans la projection. Un worker subverti peut écrire n'importe quelle valeur dans l'en-tête ; une discordance est rapportée comme cwsProtocolError et aucun pixel n'est copié

Trois plafonds sur chaque décodage isolé HotPDF : délai du worker, limite mémoire du Job Object et limite de sortie dérivée écrêtée par DecodeBudgetBytes
Une validation stricte du délai et de la mémoire plus un plafond de sortie en pixels dérivé font que les décodages surdimensionnés ou bloqués se terminent dans le worker comme codes de statut, pas dans votre processus

Gardez la limite mémoire confortablement au-dessus de la limite de sortie. Avec les réglages du premier exemple, un budget de sortie de 128 MiB dans un plafond de processus de 256 MiB laisse la place à l'entrée compressée et au propre ensemble de travail du décodeur. Rapprochez les deux et de grandes numérisations légitimes se mettent à échouer dans le worker pour des raisons qui n'ont rien à voir avec une entrée hostile

Ce que coûte la frontière de processus

Démarrer un processus par image isolée coûte du temps, et un document avec plusieurs centaines de pages JPEG numérisées le fera sentir. Sur un convertisseur par lots sans surveillance, ce coût disparaît dans la fenêtre nocturne et le confinement est la raison d'être de la tâche. Une visionneuse interactive montrant des fichiers auxquels l'utilisateur fait déjà confiance est un autre cas ; là, cimAutomatic, ou cimDisabled pour une archive interne connue, est un choix honnête. CodecIsolationMode est une propriété ordinaire, donc un service peut appliquer cimRequired aux envois et un mode plus léger aux documents qu'il a lui-même générés

Le codec en question change aussi l'image du risque. Les flux JPXDecode portent des comptes de tuiles et de composants qui pilotent directement des allocations, tandis que les images JBIG2 dépendent souvent d'un flux /JBIG2Globals partagé par plusieurs pages. Un bac à sable qui ne livrerait que le flux par image décoderait ces pages mal ou pas du tout, voilà pourquoi les segments globaux voyagent vers le worker avec chaque image

Isolation de codecs, budgets de décodage et limites structurelles de l'analyseur vivent dans un seul composant VCL natif, et le seul fichier supplémentaire à déployer est l'exécutable worker. Notes d'installation, build du worker pour Win32 et Win64 et téléchargement d'essai sont sur la page du composant HotPDF pour Delphi et C++Builder