Article technique

Vérifier les signatures PDF en Delphi avec HotPDF

Un vérificateur de signatures PDF écrit à la main peut rejeter tous les fichiers correctement signés qu'on lui donne, tout en lisant chaque octet correctement. Il extrait le blob CMS de /Contents, localise les attributs signés, les hache exactement tels qu'ils sont stockés, et la comparaison RSA échoue. Le document est sain. Le problème tient à un seul octet : dans le SignerInfo, les attributs sont étiquetés [0] IMPLICIT, donc leur premier octet vaut 0xA0, alors que la RFC 5652 §5.4 précise que le signataire a calculé la signature sur le même contenu encodé en SET OF DER, dont le premier octet vaut 0x31. Remplacez cet octet avant le hachage et les signatures « falsifiées » deviennent valides

Cette divergence de tag est le premier de plusieurs endroits où une vérification de signature PDF peut dérailler, et les autres sont moins évidents. Une signature peut être mathématiquement parfaite sur un fichier modifié après la signature. Elle peut être parfaite sur un document qu'un attaquant a re-signé avec un certificat fabriqué maison. Un cocontractant renvoie un contrat signé, votre workflow doit l'archiver, et quelqu'un demande si c'est bien le document que vous avez envoyé, octet pour octet, signé par le certificat qu'il prétend. La production de ces signatures est traitée dans l'article compagnon sur la création de signatures numériques PAdES en Delphi ; celui-ci prend la direction inverse, en partant d'un fichier qui arrive déjà signé

Où vivent les octets signés dans un fichier PDF

Une signature PDF protège des plages d'octets du fichier sur disque, et HotPDF vérifie exactement ces octets-là. L'ISO 32000-1 §12.8.1 place un conteneur CMS SignedData (RFC 5652) dans l'entrée /Contents du dictionnaire de signature, avec à côté un tableau /ByteRange qui nomme les régions couvertes par la signature. En pratique, le tableau contient deux paires offset / longueur : tout ce qui va de l'offset 0 jusqu'à la chaîne hexadécimale /Contents, et tout ce qui vient après. Une signature ne peut pas couvrir sa propre valeur, donc le fichier est haché autour de ce trou

La conséquence pour tout vérificateur est sans appel. Il faut hacher l'original sérialisé. Un modèle objet parsé ne sert à rien ici, car réécrire même un document intact produit des octets différents. HotPDF relit donc le fichier source depuis lequel le document a été chargé, ou un TStream d'octets bruts que vous fournissez, et ne hache jamais sa représentation en mémoire

Diagramme de HotPDF vérifiant un PDF signé dans Delphi en re-hachant les deux segments ByteRange du fichier source autour du trou Contents, tandis que le modèle en mémoire analysé n'est jamais haché parce que la resérialisation change les octets
La vérification hache les deux segments ByteRange des octets sources exactement tels que sérialisés ; un modèle analysé en mémoire est inutilisable car re-sérialiser même un document inchangé produit des octets différents

Le trou lui-même mérite de la méfiance. Les octets hors des plages signées restent des octets qu'un lecteur peut parser, et un écart qui contient autre chose que la valeur de signature ouvre la porte à une attaque par enveloppement de signature. HotPDF vérifie que /ByteRange démarre à l'offset 0, que le second segment commence après la fin du premier, que les deux restent dans le fichier, et que le trou ne contient rien d'autre que les chiffres hexadécimaux du /Contents de cette signature, éventuellement avec ses délimiteurs < et >. Un fichier qui échoue à l'un de ces contrôles renvoie svInvalidByteRange, même quand le calcul CMS aurait réussi

Lire qui a signé avant de vérifier quoi que ce soit

GetLoadedSignatureInfo parse le dictionnaire de signature et son conteneur CMS sans hacher un seul octet du document ; c'est donc l'appel à faire quand une interface n'a besoin que d'afficher qui a signé et quand. Les champs de signature sont indexés à partir de 0 dans l'ordre des champs de formulaire, et GetLoadedSignatureFieldCount renvoie leur nombre. Un index au-delà de la fin lève une exception au lieu de renvoyer un enregistrement vide, donc bouclez sur le compte

L'enregistrement THPDFSignatureInfo renvoyé porte le nom du champ, le /SubFilter, le nom commun du certificat du signataire, les DN du sujet et de l'émetteur, le numéro de série en hexadécimal, les dates de validité du certificat et l'heure de signature, prise dans l'attribut signé quand il existe et sinon dans l'entrée /M du dictionnaire. Il indique aussi les noms des algorithmes de hachage et de clé publique, les chaînes /Reason, /Location et /ContactInfo, et CertificateTimeValidity, qui signale une heure de signature hors de la fenêtre de validité du certificat. Status reste à svNotVerified : parsé, pas contrôlé. L'API de signature se trouve derrière la garde de compilation Delphi 2009 et ultérieur

var
  Pdf: THotPDF;
  Info: THPDFSignatureInfo;
  I: Integer;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.LoadFromFile('signed-contract.pdf');
    for I := 0 to Pdf.GetLoadedSignatureFieldCount - 1 do
    begin
      Info := Pdf.GetLoadedSignatureInfo(I);
      Writeln('Field:     ', Info.FieldName);
      Writeln('Signer:    ', Info.SignerName);
      Writeln('Issuer:    ', Info.IssuerDN);
      Writeln('Key/hash:  ', Info.PublicKeyAlgorithm, ' / ', Info.HashAlgorithm);
      Writeln('SubFilter: ', Info.SubFilter);
      if Info.CertificateTimeValidity = stvSigningTimeOutsideCertificate then
        Writeln('Signing time is outside the certificate validity period');
    end;
  finally
    Pdf.Free;
  end;
end;

Lancer le contrôle cryptographique avec VerifyLoadedSignatureEx

VerifyLoadedSignatureEx exécute le contrôle complet pour un document chargé depuis un fichier et renvoie l'enregistrement d'informations rempli dans le même appel. Il rouvre le fichier source, valide /ByteRange, hache les deux segments avec l'algorithme de hachage du SignerInfo, compare le résultat à l'attribut signé messageDigest, puis vérifie la valeur de signature sur la forme SET OF DER des attributs signés avec la clé publique du certificat de signataire embarqué. Quand une signature ne porte aucun attribut signé, un contrôle RSA ou ECDSA s'exécute directement sur le hachage du document

La couverture des algorithmes suit ce que les outils de signature émettent réellement. Côté hachage : SHA-1, SHA-256, SHA-384, SHA-512, la famille SHA-3 et SHAKE256. Côté signature : RSA avec padding PKCS#1 v1.5 ou PSS, ECDSA sur courbes nommées, ou Ed25519 et Ed448. La vérification ECDSA passe par le fournisseur CNG de Windows, et Ed25519 et Ed448 par un fournisseur de plateforme adossé à CNG ou à une bibliothèque OpenSSL ; sur une machine où le fournisseur requis ne peut pas être chargé, le résultat est svUnsupportedAlgorithm ou svCryptoProviderError plutôt qu'un verdict sur le fichier. VerifyLoadedSignatureWithOptions accepte un enregistrement THPDFCMSVerifyOptions quand vous devez pointer vers une bibliothèque OpenSSL précise ou brancher votre propre THPDFSignatureProvider

Pipeline de VerifyLoadedSignatureEx dans HotPDF pour Delphi : rouvrir le fichier source, hacher les segments ByteRange, comparer avec l'attribut signé messageDigest du CMS, puis vérifier la signature avec la clé publique du certificat du signataire, pour produire svValid, svDigestMismatch ou svSignatureInvalid
VerifyLoadedSignatureEx re-hache les segments ByteRange, les compare à l'attribut signé messageDigest et vérifie la signature sur le SET DER des attributs signés avant de renvoyer svValid ou un statut d'échec précis
var
  Status: THPDFSignatureVerifyStatus;
  Info: THPDFSignatureInfo;
begin
  Status := Pdf.VerifyLoadedSignatureEx(0, Info);
  case Status of
    svValid:
      if Info.CoversWholeDocument then
        Writeln('Valid; signature covers the whole file')
      else
        Writeln('Valid; ', Info.UnsignedTrailingBytes,
          ' bytes were appended after signing');
    svDigestMismatch:
      Writeln('Document bytes changed after signing');
    svSignatureInvalid:
      Writeln('Hash matches, signature value does not verify');
    svInvalidByteRange:
      Writeln('ByteRange is malformed or the gap holds extra bytes');
    svDigestAlgorithmMismatch:
      Writeln('CMS digest algorithm identifiers disagree');
    svUnsupportedAlgorithm, svCryptoProviderError:
      Writeln('Cannot evaluate this key or digest here');
    svMalformed:
      Writeln('CMS container could not be parsed');
    svSourceUnavailable:
      Writeln('No source bytes; use the TStream overload');
  else
    Writeln('Status ', Ord(Status));
  end;
end;

Deux détails de parsing expliquent des échecs qui paraissent mystérieux de l'extérieur. Le premier est le re-tag du paragraphe d'ouverture : HotPDF hache les attributs signés avec leur octet de tête réécrit en 0x31, exactement comme la RFC 5652 §5.4 le prescrit. Le second est le remplissage. Les outils de signature réservent un budget d'octets fixe pour /Contents avant que la signature existe et comblent la fin inutilisée avec des zéros ; le vérificateur tronque donc le blob décodé à la longueur réelle de sa SEQUENCE DER externe avant de le parcourir. Une série de zéros en fin de /Contents est normale. La même famille de pièges de parsing ASN.1, vue du côté de l'import de certificats, fait l'objet de l'article sur le durcissement sécurité PKCS#12 et ASN.1 en Delphi

Quelques contrôles plus stricts s'exécutent au passage. L'algorithme de hachage du SignerInfo doit concorder avec la liste de hachages du SignedData, l'identifiant d'algorithme de signature et tout attribut CMS de protection des algorithmes, sinon le statut est svDigestAlgorithmMismatch. Les attributs signés doivent contenir exactement un attribut content-type correspondant au contenu signé, sinon svMalformed. Quand le CMS embarque un horodatage de signature RFC 3161, ce jeton est vérifié par rapport à la valeur de signature et rapporté dans Info.Timestamp ; un horodatage de document ETSI.RFC3161 est vérifié de la même manière par rapport aux plages d'octets hachées

Que prouve réellement svValid ?

svValid signifie deux choses : les octets nommés par /ByteRange donnent le hachage que le signataire a signé, et cette signature se vérifie avec la clé publique du certificat embarqué dans le conteneur CMS. Intégrité des octets plus liaison à la clé. Cela ne dit rien sur le propriétaire de cette clé. Un attaquant qui modifie un contrat et le re-signe avec un certificat auto-généré obtient svValid, parce que le calcul est cohérent en interne, et le champ SignerName affichera le nom que l'attaquant a tapé dans le certificat

CoversWholeDocument couvre une seconde faille. Les mises à jour incrémentales PDF permettent à un éditeur d'ajouter du contenu après une signature sans la casser, ce qui est voulu et c'est ainsi que fonctionnent les workflows multi-signatures. Le drapeau est calculé pendant la vérification et n'est vrai que si les deux segments plus le trou /Contents couvrent tout le fichier. SignedRevisionLength donne la taille du préfixe signé et UnsignedTrailingBytes le nombre d'octets ajoutés après. Pour un fichier qui déclare une révision signée de 48 000 octets dans un fichier de 52 300 octets, UnsignedTrailingBytes vaut 4 300 et CoversWholeDocument est faux

Diagramme de périmètre de ce que svValid garantit dans la vérification de signatures HotPDF : intégrité des octets du ByteRange et liaison à la clé, tandis que le parcours de chaîne, la révocation et les magasins de confiance relèvent d'un contrôle de confiance séparé et que CoversWholeDocument signale les mises à jour incrémentales ajoutées
svValid signifie intégrité des octets plus liaison à la clé et rien de plus ; le parcours de chaîne, la révocation et les ancres de confiance relèvent d'un contrôle de confiance séparé, et CoversWholeDocument=false signale des octets ajoutés après la signature

Un pipeline d'ingestion d'archives ne devrait pas accepter svValid avec CoversWholeDocument à faux sans autre examen. Lancez d'abord AnalyzeLoadedSignatureRevisions : il classe chaque révision ajoutée après la signature sélectionnée, liste les noms des champs modifiés dans ChangedFieldNames et indique si les changements respectent les permissions DocMDP et FieldMDP posées par le signataire, via DocMDPCompliant et FieldMDPCompliant. Une signature ultérieure ajoutée dans un champ de signature vide, c'est la routine. Une révision qui réécrit des objets de page ne l'est pas, et c'est ChangeKinds dans l'analyse qui distingue ces deux cas

Contrôler le signataire avec vos propres ancres de confiance

La confiance fait l'objet d'un appel distinct dans HotPDF, et cette séparation est le bon choix par défaut. VerifyLoadedSignatureWithTrust lance d'abord la même vérification de plages d'octets, renvoie cvsSignatureInvalid si elle échoue, puis construit un chemin de certification du signataire jusqu'aux ancres que vous passez dans THPDFCertificateValidationOptions.TrustAnchors. Il évalue au passage les preuves de révocation : les réponses OCSP et les CRL stockées dans les dictionnaires DSS et /VRI du document sont collectées automatiquement, et celles que vous fournissez dans OCSPResponses ou CRLs s'ajoutent au lot

uses
  System.IOUtils;

var
  Options: THPDFCertificateValidationOptions;
  Info: THPDFSignatureInfo;
  Trust: THPDFCertificateValidationStatus;
begin
  Options := THPDFCertificateValidationOptions.Default;
  SetLength(Options.TrustAnchors, 1);
  // Certificat racine encodé en DER ; convertissez les fichiers PEM avant le chargement
  Options.TrustAnchors[0] := TFile.ReadAllBytes('company-root.cer');
  Options.RevocationMode := rvmBestEffort;

  Trust := Pdf.VerifyLoadedSignatureWithTrust(0, Options, Info);
  if Trust = cvsTrusted then
    Writeln('Signed by a certificate chaining to our root')
  else
    Writeln('Not trusted: ', Info.CertificateValidation.Issue);
end;

Le mode de révocation est un choix de politique. rvmBestEffort utilise les preuves disponibles et continue quand il n'en trouve aucune, tandis que rvmRequire transforme une preuve manquante en cvsRevocationUnknown. Pour des contrats qui seront audités des années plus tard, rvmRequire est le réglage le plus sûr, à condition que vos signataires embarquent des données OCSP ou CRL au moment de signer ; sans ces preuves dans le fichier, chaque document ressort en cvsRevocationUnknown

Pourquoi les documents chargés depuis un flux renvoient-ils svSourceUnavailable ?

Les appels adossés au fichier, c'est-à-dire VerifyLoadedSignature à un argument, VerifyLoadedSignatureEx et la variante fichier de VerifyLoadedSignatureWithTrust, ont besoin que le composant se souvienne du fichier d'origine du document. Un document chargé avec LoadFromStream n'a pas de nom de fichier à rouvrir. Il en va de même après le rechargement par mot de passe utilisé pour les documents chiffrés, décrit dans l'article sur le chiffrement PDF AES-256 en Delphi, parce que le composant abandonne sa référence au fichier source une fois le document déchiffré. Dans les deux cas, les surcharges fichier renvoient svSourceUnavailable et ne devinent rien

Les surcharges TStream prennent les octets bruts d'origine là où vous les avez gardés : un fichier, un tampon mémoire, un blob de base de données. La position du flux est restaurée après le hachage, donc le même flux peut être passé à plusieurs index de signature à la suite. VerifyAllLoadedSignatures, qui ne renvoie vrai que si au moins un champ de signature existe et que chaque champ se vérifie en svValid, passe par le chemin fichier ; sur un document chargé depuis un flux, il renvoie donc faux quoi que contiennent les signatures. Bouclez plutôt sur la surcharge flux

function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Helper à ajouter côté lecteur : un équivalent sur flux de
// VerifyAllLoadedSignatures pour les documents chargés avec LoadFromStream
var
  I, Count: Integer;
  Info: THPDFSignatureInfo;
begin
  Count := Pdf.GetLoadedSignatureFieldCount;
  Result := Count > 0;
  for I := 0 to Count - 1 do
    if Pdf.VerifyLoadedSignature(I, Src, Info) <> svValid then
    begin
      Writeln(Info.FieldName, ': status ', Ord(Info.Status));
      Exit(False);
    end;
end;

La vérification des plages d'octets, la construction de chemins vers les ancres de confiance, la signature PAdES et le chiffrement AES-256 vivent tous dans la même bibliothèque VCL native pour Delphi et C++Builder, avec le hachage RSA et les contrôles de padding réalisés en code Pascal ; les éditions, les versions d'IDE prises en charge et la liste complète des fonctionnalités sont sur la page produit du HotPDF Delphi Component