Article technique

DocMDP PDFium : le /P d’un widget n’est pas une propriété

Le graphe de rôles de révisions derrière TPdf.AnalyzeSignatureRevisions dans PDFium Component sépare les arêtes de navigation des arêtes de charge possédée, si bien qu’une véritable édition de contenu de page n’est jamais notée comme changement d’annotation permis sous DocMDP P=3. Le piège qu’il évite est facile à rencontrer : la référence inverse /P du widget de signature vers sa page ressemble à toute autre référence indirecte, et un graphe de rôles qui la traite comme de la propriété laisse le contenu de page passer pour une annotation. Le scénario paraît inoffensif sur le papier. Un contrat certifié autorise les annotations, la partie adverse ajoute une sauvegarde incrémentale, et un analyseur naïf déclare chaque changement ultérieur permis. Puis quelqu’un compare les pages rendues et le montant du paiement en page 2 a changé

Cet article est la suite du point de vue de l’attaquant à la vue d’ensemble de l’analyse des changements de révisions après signature ; il saute les bases de la reconstruction de révisions et de la notation DocMDP pour aller droit au graphe d’objets : comment la propriété est modélisée, pourquoi la direction d’une arête décide d’un verdict de sécurité, et comment auditer votre propre logique d’acceptation

Comment une édition de page peut-elle passer pour un changement d’annotation sous DocMDP P=3 ?

Une édition de page passe quand le graphe de rôles suit chaque référence indirecte d’un dictionnaire comme si l’objet référencé appartenait à celui qui le référence, parce que le widget de signature pointe en retour vers sa page. Un dictionnaire d’annotation porte /P, une référence indirecte vers l’objet page sur lequel il se trouve (ISO 32000-1 §12.5.2). Cette entrée est un indice de navigation. Le widget ne possède pas la page ; c’est la page qui possède le widget via son tableau /Annots

L’analyseur attribue à chaque objet un ensemble de bits de rôle avant de noter les changements ultérieurs : page, annotation, formulaire et matériel de validation. Les objets racines tirent leur rôle de leur propre dictionnaire, et le rôle se propage ensuite à tout ce qu’ils référencent. Dans une propagation naïve, la chaîne se déroule ainsi :

  1. Le widget de signature est un /Subtype /Widget avec /FT /Sig, donc il reçoit le rôle d’annotation
  2. Le /P du widget pousse le rôle d’annotation sur le dictionnaire de page, qui possède déjà le rôle de page
  3. La page pousse les deux rôles dans /Contents, /Resources et, via /Parent, vers le haut dans l’arbre Pages et vers chaque page sœur
  4. Un dictionnaire de flux de contenu tel que << /Length 812 >> n’a pas de /Type, donc un classifieur qui retombe sur les bits de rôle et teste le rôle d’annotation avant le rôle de page l’étiquette comme annotation
Diagramme PDFium Component d’un graphe de rôles DocMDP naïf où une référence inverse /P de widget de signature pousse le rôle d’annotation sur le dictionnaire de page, la page le propage via /Contents vers un flux de contenu sans entrée /Type, le classifieur sort prckAnnotation et la notation P=3 retourne prdAllowed
Un graphe de rôles qui traite chaque référence indirecte comme de la propriété laisse l’entrée /P du widget pousser le rôle d’annotation sur la page, si bien qu’une véritable édition de page ressort comme changement d’annotation permis

Le flux de contenu modifié ressort donc comme prckAnnotation. Selon ISO 32000-1 §12.8.2.2, DocMDP P=3 permet les changements d’annotation, donc la décision est prdAllowed et le rapport se résume en prasAllowed. Le même fichier sous P=2 est rejeté, mais seulement par coïncidence : P=2 interdit les changements d’annotation, donc le flux mal étiqueté est refusé pour la mauvaise raison. Une boucle de propagation à nombre de passes fixe ajoute une seconde faiblesse. Une charge atteinte via un tableau indirect, ou via une longue chaîne dont les numéros d’objets vont en reculant, pourrait ne jamais recevoir de rôle du tout

Pourquoi un validateur de signature doit-il demander qui possède un objet ?

Un validateur de signature doit demander qui possède un objet parce que les mises à jour incrémentales du PDF (ISO 32000-1 §7.5.6) permettent à quiconque d’ajouter une révision qui redéfinit un numéro d’objet existant, et le corps redéfini n’annonce pas ce qu’il est. La signature se vérifie toujours, puisqu’elle ne couvre que les octets de sa propre révision. Toute défense contre la manipulation post-signature dépend donc de la mise en correspondance de chaque objet changé avec la structure qui l’utilise, puis de la question de savoir si le signataire a permis à cette structure de changer

Plusieurs classes d’attaques publiées opèrent exactement dans cet interstice. Les attaques par sauvegarde incrémentale ajoutent une révision qui remplace le contenu de page et comptent sur un vérificateur qui ne contrôle que la plage d’octets signée. Les shadow attacks plantent du contenu caché avant la signature et l’activent ensuite avec un petit changement à l’air innocent. Les attaques sur documents certifiés abusent du fait que P=2 et P=3 permettent explicitement certaines éditions ultérieures, puis déguisent une édition interdite en édition permise. Un vérificateur qui classe les objets par étiquettes telles que /Type /Annot, ou par n’importe quel chemin de référence qui tombe dessus, est exposé à la troisième classe : il suffit à l’attaquant d’une structure permise qui puisse atteindre la structure interdite

Voilà pourquoi la question n’est pas de savoir quels objets ont changé mais qui les possède. Un flux de contenu atteint depuis une page via /Contents est du contenu de page, quoi que d’autre pointe vers lui. Une annotation qui pointe en retour vers la page via /P dit où l’annotation réside, pas ce qu’elle possède

Comment PDFium Component modélise-t-il la propriété ?

PDFium Component traite les références inverses comme de la navigation, les tient hors de la propagation des rôles, et décide quelles clés comptent comme navigation d’après le rôle structurel du dictionnaire qui les porte, pas d’après le seul nom de clé. La table résume les clés de navigation qui ne portent aucune propriété

Dictionnaire propriétaireClés traitées comme navigationRéférence de spéc
Nœud Page ou Pages/Parent, /Kids, /AnnotsISO 32000-1 §7.7.3
Annotation ou widget/PISO 32000-1 §12.5.2
Dictionnaire widget ou champ/ParentISO 32000-1 §12.7.3
Graphe d’objets PDFium Component séparant les arêtes de charge possédée comme /Contents et /Annots, qui propagent les rôles de page et d’annotation, des arêtes de navigation comme le /P de widget, qui ne portent aucun rôle, avec les clés de navigation par dictionnaire propriétaire et prckPageContent maintenu sur le flux de contenu même sous un /Type forgé
PDFium Component tient les références inverses hors de la propagation des rôles : les rôles ne voyagent que par la véritable propriété, si bien que le flux de contenu reste du contenu de page et que l’indice /P ne décide de rien

Filtrer par nom de clé globalement aurait créé un nouveau trou. Une ressource de police ou XObject peut légitimement s’appeler /P, /Parent ou /Annots, et un dictionnaire /Resources qui retirerait son entrée /P de la propagation laisserait un attaquant cacher un XObject possédé par la page derrière un nom de ressource innocent. Le filtre de navigation ne s’applique que lorsque le dictionnaire propriétaire est réellement une page, un nœud Pages, une annotation, un widget ou un champ. Si l’un de ces dictionnaires porte une clé de navigation dupliquée, par exemple deux entrées /P dans un widget, l’analyseur ne devine pas quelle copie une visionneuse utiliserait ; la construction des rôles échoue et la signature devient Indeterminate

Plusieurs règles supplémentaires ferment les autres routes de réétiquetage :

  • Les nœuds Pages sont des racines de rôle page à part entière, donc les ressources héritées de l’arbre Pages (ISO 32000-1 §7.7.3.4) entrent en contexte page par la vraie propriété, pas par une remontée /Parent depuis une page fille
  • Un rôle annotation ou formulaire qui arrive sur un dictionnaire catalog, nœud Pages, page, annotation ou champ s’y arrête, parce que ces objets structurels établissent leurs propres rôles et qu’un rôle de charge entrant ne doit pas les écraser
  • Le rôle page fait autorité pendant la classification : un objet possédé par la page est prckPageContent même si une révision ultérieure le réécrit avec un /FT falsifié, une étiquette /Type /Annot, ou le partage avec un flux d’apparence
  • Un Form XObject utilisé seulement comme apparence de champ ou d’annotation garde sa catégorie formulaire ou annotation, donc la régénération ordinaire d’apparence après un remplissage de formulaire reste notée sous les règles de permission normales
  • Un widget sans son propre /FT résout le type de champ hérité par la chaîne /Parent, et une chaîne insoluble fait échouer la construction des rôles au lieu de retomber sur annotation
  • Les bits de rôle de chaque révision ultérieure sont fusionnés dans les rôles de la révision couverte, donc une mise à jour postérieure ne peut pas effacer une relation de propriété page antérieure en détachant d’abord un flux puis en l’éditant ensuite

Point fixe au lieu d’un nombre de passes fixé

L’atteignabilité des rôles tourne comme une file de travail qui itère jusqu’à ce qu’aucun objet ne gagne de nouveau bit de rôle, ce qui est un véritable point fixe quelle que soit la profondeur des chaînes ou la numérotation des objets. Les tableaux indirects, comme un /Contents stocké comme objet propre, sont aussi parcourus. Chaque objet peut gagner au plus quatre bits de rôle distincts, donc la file est bornée à quatre entrées par numéro d’objet ; dépasser ce budget lève prrResourceLimitExceeded. Une référence vers un objet libre, un écart de génération ou un en-tête d’objet cassé lève prrMalformedRevisionChain, et une charge dans un flux d’objets compressé lève prrCompressedObjectUnresolved. Chacun de ces échecs se termine par prasIndeterminate, jamais par un verdict permis, et quand l’échec survient pendant la construction des rôles de la révision couverte, la signature ne rapporte aucun Changes du tout

La routine suivante liste les éditions de contenu de page qui survivent à cette analyse. Un changement prckPageContent n’est jamais noté prdAllowed : DocMDP P=1, 2 ou 3 le rend prdDisallowed, et une signature sans DocMDP le note prdSuspicious

uses
  SysUtils, TypInfo, PDFium, FPdfPades;

procedure ListPageContentEdits(const FileName: string);
const
  ShadowTag: array[Boolean] of string = (' (unreferenced shadow)', '');
var
  Pdf: TPdf;
  Report: TPadesRevisionAnalysisReport;
  Sig: TPadesSignatureRevisionAnalysis;
  Change: TPadesRevisionObjectChange;
  i, j: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := FileName;
    Pdf.Active := True;
    Report := Pdf.AnalyzeSignatureRevisions;   // enregistrement, rien à libérer
    for i := 0 to High(Report.Signatures) do
    begin
      Sig := Report.Signatures[i];
      if not (prrPageContentChanged in Sig.Risks) then
        Continue;
      Writeln(Format('Signature %d (DocMDP P=%d): page content changed',
        [Sig.SignatureIndex, Sig.DocMdpPermission]));
      for j := 0 to High(Sig.Changes) do
      begin
        Change := Sig.Changes[j];
        if Change.Kind <> prckPageContent then
          Continue;
        Writeln(Format('  revision %d  object %d %d R  %s%s',
          [Change.RevisionIndex, Change.ObjectNumber, Change.Generation,
           GetEnumName(TypeInfo(TPadesRevisionDecision), Ord(Change.Decision)),
           ShadowTag[Change.IsAuthoritative]]));
      end;
    end;
  finally
    Pdf.Free;
  end;
end;

Que se passe-t-il quand FieldMDP et une annotation partagent un objet ?

Quand le /V d’un champ et le /Contents d’une annotation pointent vers le même objet indirect, PDFium Component maintient le verrou FieldMDP en vigueur même si le changement est classé comme édition d’annotation. Le scénario se construit facilement à la main : un signataire verrouille le champ Total avec FieldMDP (ISO 32000-1 §12.8.2.4), et l’attaquant fait référencer par le /Contents d’une annotation de texte le même objet chaîne qui porte la valeur du champ. Sous P=3 l’édition d’annotation est permise, donc un analyseur qui s’arrêterait à la règle des annotations laisserait une réécriture de cette chaîne partagée changer une valeur de champ verrouillée avec un verdict permis

L’objet porte à la fois les rôles d’annotation et de formulaire, et la décision d’annotation revérifie le côté formulaire chaque fois que la signature possède une transformation FieldMDP :

  • Sous P=2 le changement d’annotation est interdit sans appel
  • Avec FieldMDP All, chaque champ est verrouillé, donc le changement partagé est prdDisallowed
  • Avec FieldMDP Include ou Exclude, l’analyseur ne peut pas retracer un scalaire partagé jusqu’à un nom de champ, donc la décision est prdIndeterminate plutôt qu’une supposition
  • Sans FieldMDP, la règle d’annotation P=3 s’applique et le changement reste permis
Schéma de décision FieldMDP PDFium Component où le /V verrouillé d’un champ Total et le /Contents d’une annotation référencent le même objet indirect, avec branchements sur DocMDP P=2, FieldMDP All, FieldMDP Include ou Exclude et absence de FieldMDP vers les verdicts prdDisallowed, prdIndeterminate ou prdAllowed pour la même édition partagée
Quand un objet indirect porte à la fois les rôles annotation et formulaire, la décision d’annotation revérifie le verrou FieldMDP, donc la même édition va de permis à interdit à indéterminé

Un détail de compte rendu importe pour le code de barrière. Le cas partagé est rapporté comme Kind = prckAnnotation avec Decision = prdIndeterminate, et prrFieldMdpUnresolved n’est ajouté au jeu de risques que pour les changements classés comme champs de formulaire. Une barrière qui cherche prrFieldMdpUnresolved en ignorant Status rate ce cas complètement

Comment le code Delphi doit-il échouer fermé sur l’analyse de révisions ?

Le code Delphi ne devrait accepter un document signé que quand le statut d’analyse est prasNoLaterChanges ou prasAllowed et qu’aucun risque structurel n’est présent, et il devrait traiter prasIndeterminate et prasSuspicious comme non fiables, pas comme des avertissements à journaliser puis laisser passer. Indeterminate signifie que l’analyseur n’a pas pu prouver que les révisions ultérieures étaient permises ; pour un attaquant, une entrée qui produit de façon fiable Indeterminate est aussi utile qu’une qui produit Allowed si votre code la laisse passer. La globale AnalyzePadesSignatureRevisions prend n’importe quel TStream et le lit depuis la position 0, ce qui convient aux handlers d’upload qui n’ont jamais besoin de rendre le document

uses
  Classes, SysUtils, TypInfo, FPdfPades;

const
  // Les définitions dupliquées sont enregistrées sans dégrader Status
  BlockingRisks: TPadesRevisionRisks = [prrMalformedRevisionChain,
    prrDuplicateObjectDefinition, prrUnreferencedObjectDefinition,
    prrSignatureObjectRedefined, prrCompressedObjectUnresolved,
    prrResourceLimitExceeded];

function SignedRevisionsAcceptable(const FileName: string;
  out Reason: string): Boolean;
var
  Source: TFileStream;
  Report: TPadesRevisionAnalysisReport;
begin
  Result := False;
  Reason := '';
  Source := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
  try
    Report := AnalyzePadesSignatureRevisions(Source);
  finally
    Source.Free;
  end;
  if Report.SignatureCount = 0 then
  begin
    Reason := 'no signature anchors the analysis';
    Exit;
  end;
  if Report.Risks * BlockingRisks <> [] then
  begin
    Reason := 'structural risk in the revision chain';
    Exit;
  end;
  case Report.Status of
    prasNoLaterChanges, prasAllowed:
      Result := True;
  else
    // prasIndeterminate et prasSuspicious sont des rejets, pas des avertissements
    Reason := 'revision status ' +
      GetEnumName(TypeInfo(TPadesRevisionAnalysisStatus), Ord(Report.Status));
  end;
end;

Deux limites méritent d’être dites franchement. TPadesRevisionAnalysisReport ne dit rien de l’intégrité CMS ni de la confiance dans les certificats, donc cette barrière siège à côté de la validation cryptographique et de confiance, pas à leur place. Et un graphe de propriété correct ne rend pas P=3 sûr pour chaque flux de travail. P=3 permet réellement les annotations, et une annotation à apparence opaque peut couvrir du texte signé sans toucher le moindre flux de contenu. Si vos documents certifiés sont des contrats plutôt que des copies de révision, certifiez soit en P=2, soit routez les changements d’annotation permis vers un humain, comme dans cette aide :

function AllowedAnnotationEditsUnderP3(
  const Report: TPadesRevisionAnalysisReport): Integer;
var
  i, j: Integer;
begin
  Result := 0;
  for i := 0 to High(Report.Signatures) do
    if Report.Signatures[i].DocMdpPermission = 3 then
      for j := 0 to High(Report.Signatures[i].Changes) do
        if (Report.Signatures[i].Changes[j].Kind = prckAnnotation) and
           (Report.Signatures[i].Changes[j].Decision = prdAllowed) then
          Inc(Result);
end;

Checklist d’audit des révisions de signature

Servez-vous de cette liste pour vérifier que votre pipeline de vérification échoue fermé :

  • Revérifiez les documents P=3 avec verrous FieldMDP là où une valeur de champ et une annotation pourraient partager un objet indirect
  • N’acceptez que prasNoLaterChanges et prasAllowed ; traitez prasIndeterminate et prasSuspicious comme non fiables
  • Testez Report.Risks aussi bien que Report.Status, car prrDuplicateObjectDefinition ne change pas le statut à lui seul
  • Ne lisez pas un tableau Changes vide comme un résultat propre quand le statut de la signature est Indeterminate ; une construction de rôles échouée ne rapporte aucun changement
  • Ne comptez pas sur prrFieldMdpUnresolved seul pour attraper les problèmes FieldMDP, car le cas de l’annotation partagée ne surface que via la décision et le statut
  • Décidez si les changements d’annotation permis sous P=3 exigent une revue humaine dans votre flux de travail
  • Analysez les octets du fichier d’origine ; un document réécrit par SaveAs ne contient plus la chaîne de révisions

L’analyse de révisions est une couche d’une vérification de signature. Associez-la à l’inspection des signatures numériques PDF et des niveaux PAdES pour le dictionnaire et le niveau baseline, et à un audit plus large des risques de sécurité PDF pour le JavaScript, les actions de lancement et les fichiers embarqués. TPdf.AnalyzeSignatureRevisions, AnalyzePadesSignatureRevisions et le graphe de rôles conscient de la propriété décrit ici sont livrés dans le PDFium Component pour Delphi, C++Builder et Lazarus