Article technique

Politique ECDSA et EdDSA ISO/TS 32002 avec PDFium en Delphi

Une clé P-256 peut signer un condensé SHA-512 et les mathématiques n'y verront pas d'objection. ECDSA tronque le hachage aux 256 bits les plus à gauche, la signature se vérifie, et un vérificateur CMS rapporte la valeur de signature comme intacte. ISO/TS 32002, l'extension du PDF 2.0 qui a apporté les signatures à courbes elliptiques et EdDSA dans le PDF, ne permet pas cet appariement, parce qu'elle lie chaque courbe aux largeurs de condensé qu'elle peut porter. La même facture signée peut donc passer un contrôle cryptographique sur une machine et échouer sur un validateur qui applique le profil d'algorithmes du PDF 2.0, et les deux verdicts sont justes sur la question que chacun a posée

Les paires courbe et condensé qu'accepte ISO/TS 32002

ISO/TS 32002 accepte six courbes ECDSA et deux schémas EdDSA. Le PDFium Component vérifie chaque signature PDF contre ce profil et rapporte le verdict dans TPadesSignatureValidation.AlgorithmPolicyStatus, indexé par l'OID de courbe dans le certificat du signataire. Les courbes NIST sont strictes : le condensé doit avoir la même largeur en bits que la courbe, dans la famille SHA-2 ou SHA-3. Les courbes Brainpool r1 sont plus souples et acceptent leur propre largeur ou n'importe quoi de plus large :

  • P-256 (1.2.840.10045.3.1.7) : SHA-256 ou SHA3-256 seulement
  • P-384 (1.3.132.0.34) : SHA-384 ou SHA3-384 seulement
  • P-521 (1.3.132.0.35) : SHA-512 ou SHA3-512 seulement
  • brainpoolP256r1 (1.3.36.3.3.2.8.1.1.7) : tout condensé SHA-2 ou SHA-3 de 256 à 512 bits
  • brainpoolP384r1 (1.3.36.3.3.2.8.1.1.11) : SHA-2 / SHA-3 de 384 ou 512 bits
  • brainpoolP512r1 (1.3.36.3.3.2.8.1.1.13) : SHA-512 ou SHA3-512 seulement
Matrice du profil d'algorithmes ISO TS 32002 dans PDFium Component : P-256, P-384 et P-521 n'acceptent que les largeurs de condensé correspondantes, brainpoolP256r1 accepte de 256 à 512 bits, brainpoolP384r1 accepte 384 et 512, Ed25519 et Ed448 déclarent SHA-512 et SHAKE256 avec longueur 512, et les désaccords lèvent ppeiSignatureAlgorithmMismatch tandis que les courbes hors profil renvoient pcsUnsupported
Six courbes ECDSA et deux schémas EdDSA peuvent passer, et chaque courbe est liée aux largeurs de condensé qu'elle peut porter ; tout le reste est invalide ou non pris en charge, jamais accepté en silence

L'asymétrie attrape les outils de signature qui choisissent un condensé et le réutilisent pour chaque clé. SHA-512 partout paraît le choix prudent, et sur brainpoolP256r1 il est accepté. Sur P-256 la configuration identique produit pcsInvalid : la courbe est dans le profil, le condensé est fort, et l'appariement reste quand même hors de la table. Une clé sur une courbe que le profil ne nomme jamais, comme brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) ou secp256k1 (1.3.132.0.10), atterrit dans un autre seau. Tant que son condensé déclaré et son algorithme de signature sont d'accord, elle obtient pcsUnsupported

EdDSA ne laisse aucun choix, seulement des règles d'encodage

Ed25519 et Ed448 n'ont pas de paramètre de courbe ni d'option de condensé, si bien que chaque règle que le PDFium Component leur applique concerne la façon dont le CMS déclare l'algorithme. La RFC 8419 fixe le condensé. Un SignerInfo Ed25519 déclare SHA-512 (2.16.840.1.101.3.4.2.3) comme digestAlgorithm avec le champ paramètres absent. Un SignerInfo Ed448 qui porte des attributs signés, comme le fait toute signature PAdES, déclare id-shake256-len (2.16.840.1.101.3.4.2.18) avec un paramètre INTEGER de exactement 512. La RFC 8410 ajoute que l'AlgorithmIdentifier de signature (1.3.101.112 pour Ed25519, 1.3.101.113 pour Ed448) et l'AlgorithmIdentifier de clé publique du certificat ne portent aucun paramètre du tout

Beaucoup d'encodeurs ASN.1 ajoutent un NULL explicite à chaque OID d'algorithme parce que les identifiants RSA en ont toujours eu un, et l'habitude survit quand quelqu'un greffe Ed25519 sur un chemin de signature existant. La clé est bonne. La valeur de signature est bonne. L'encodage ne l'est pas, et le PDFium Component renvoie pcsInvalid quand un champ paramètres est présent sur l'un ou l'autre identifiant, quand le condensé Ed25519 est autre chose que du SHA-512 sans paramètres, ou quand le condensé Ed448 n'est pas id-shake256-len avec 512. Un certificat dont l'OID de clé appartient à l'autre schéma EdDSA, ou à un autre algorithme, donne aussi pcsInvalid

Lire le triple d'algorithmes dans le CMS

Le moteur PDFium lit le dictionnaire de signature, mais son API publique ne vérifie ni le CMS ni n'expose la courbe du certificat du signataire. La couche d'inspection PAdES construite sur PDFium analyse donc le SignedData CMS (RFC 5652) par elle-même. InspectPadesSignatureAlgorithm lit la digestAlgorithm et la signatureAlgorithm du premier SignerInfo, localise le certificat du signataire dans l'ensemble certificates, et lit l'algorithme de clé et la courbe depuis son SubjectPublicKeyInfo. Condensé, algorithme de signature, clé plus courbe : ces trois valeurs sont ce que la politique juge

Un ensemble de certificats CMS est sans ordre et porte habituellement le certificat du signataire à côté de sa CA émettrice, et les deux peuvent être des clés EC sur des courbes différentes, si bien que prendre le premier certificat EC laisserait la CA décider de la courbe que le signataire aurait utilisée. Le PDFium Component apparie l'émetteur et le numéro de série de issuerAndSerialNumber octet par octet, examine au plus 64 certificats, et ne retombe sur "le seul certificat qu'il y a" que quand l'ensemble porte exactement un certificat analysable. Tout autre résultat laisse les champs de clé de l'enregistrement vides

Comment le PDFium Component inspecte un triple d'algorithmes de signature PDF : InspectPadesSignatureAlgorithm lit la digestAlgorithm et la signatureAlgorithm du premier SignerInfo dans le CMS, épingle le certificat du signataire par une correspondance exacte d'issuerAndSerialNumber parmi au plus 64 candidats, lit le SubjectPublicKeyInfo pour la courbe, et EvaluatePadesSignatureAlgorithm renvoie l'AlgorithmPolicyStatus
PDFium lui-même ne vérifie ni le CMS ni n'expose la courbe du signataire, si bien que la couche PAdES analyse le SignedData et garde chaque OID brut dans l'enregistrement pour un rejet explicable

TPdf.ValidatePades fait tourner la politique pendant sa passe de conformité, d'abord contre le certificat trouvé à l'intérieur du CMS. Il vérifie ensuite la signature avec le vérificateur CMS de la plate-forme : Windows CryptoAPI par défaut sur Windows, ou un vérificateur OpenSSL ou macOS Keychain enregistré via ConfigureSslCmsVerifier ou ConfigureKeychainCmsVerifier. Quand le vérificateur rapporte quel certificat il a réellement utilisé, la politique tourne encore sur ce certificat et son résultat remplace le premier. TPdf.ValidatePadesTrust dans l'édition Enterprise suit le même ordre tout en construisant aussi la chaîne et, sur demande, en vérifiant la révocation. Les entrées brutes finissent dans TPadesSignatureAlgorithmInfo, que ce listing imprime pour chaque signature d'un fichier :

uses
  PDFium, FPdfPades;

const
  StatusNames: array[TPadesCryptoStatus] of string =
    ('not checked', 'valid', 'invalid', 'unsupported', 'indeterminate');

var
  Pdf: TPdf;
  R: TPadesValidationResult;
  A: TPadesSignatureAlgorithmInfo;
  I: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := 'invoice-ecdsa-signed.pdf';
    Pdf.Active := True;
    R := Pdf.ValidatePades;
    for I := 0 to Length(R.Signatures) - 1 do
    begin
      A := R.Signatures[I].AlgorithmInfo;
      Writeln('Signature ', I);
      Writeln('  digestAlgorithm    : ', string(A.DigestAlgorithmOid),
        '  params=', A.DigestParametersPresent, ' bits=', A.DigestParameterBits);
      Writeln('  signatureAlgorithm : ', string(A.SignatureAlgorithmOid),
        '  params=', A.SignatureParametersPresent);
      Writeln('  public key / curve : ', string(A.PublicKeyAlgorithmOid),
        ' / ', string(A.CurveOid),
        '  namedCurve=', A.PublicKeyParametersAreNamedCurve);
      Writeln('  policy             : ',
        StatusNames[R.Signatures[I].AlgorithmPolicyStatus]);
    end;
    if ppeiSignatureAlgorithmMismatch in R.Issues then
      Writeln('At least one signature violates the ISO/TS 32002 profile');
  finally
    Pdf.Free;
  end;
end;

Ces drapeaux expliquent d'habitude un rejet avant que quiconque n'ouvre un dump ASN.1. DigestParameterBits montre la longueur Ed448, SignatureParametersPresent expose le NULL égaré, et PublicKeyParametersAreNamedCurve couvre l'encodage de courbe discuté dans la section suivante. Un PublicKeyAlgorithmOid vide signifie que le certificat du signataire n'a jamais été épinglé

Pourquoi une signature P-256 avec SHA3-256 échoue-t-elle à la politique ?

Une signature P-256 avec SHA3-256 échoue chaque fois que la digestAlgorithm du CMS dit SHA3-256 pendant que la signatureAlgorithm dit ecdsa-with-SHA256. Chaque moitié est acceptable pour P-256 à elle seule ; ensemble elles ne sont pas d'accord sur quel hachage a été signé. EvaluatePadesSignatureAlgorithm mappe chaque OID de signature ECDSA, de ecdsa-with-SHA256 à ecdsa-with-SHA3-512, vers le condensé qu'il implique, compare cela avec la digestAlgorithm déclarée, et renvoie pcsInvalid à toute différence avant de regarder la table de courbes. Un outil de signature qui déplace son hachage vers SHA3-256 mais garde un identifiant de signature codé en dur produit exactement ce fichier, et un vérificateur conforme n'a aucun moyen cohérent de le lire

EvaluatePadesSignatureAlgorithm est public et prend un enregistrement simple, si bien que la matrice peut être épinglée dans un test unitaire sans construire un PDF. Les appels Assert ci-dessous sont vos propres vérifications de test :

var
  Info: TPadesSignatureAlgorithmInfo;
begin
  Info := Default(TPadesSignatureAlgorithmInfo);
  Info.Family := psafEcdsa;
  Info.PublicKeyAlgorithmOid := '1.2.840.10045.2.1';       // id-ecPublicKey
  Info.PublicKeyParametersPresent := True;
  Info.PublicKeyParametersAreNamedCurve := True;
  Info.CurveOid := '1.2.840.10045.3.1.7';                  // P-256
  Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.8';     // SHA3-256
  Info.SignatureAlgorithmOid := '2.16.840.1.101.3.4.3.10'; // ecdsa-with-SHA3-256
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsValid);

  Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.2';     // ecdsa-with-SHA256
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);  // digest en désaccord

  Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.3';     // SHA-512
  Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.4';     // ecdsa-with-SHA512
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);  // congru, mais pas pour P-256

  Info.CurveOid := '1.3.36.3.3.2.8.1.1.1';                 // brainpoolP160r1
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // courbe hors du profil

  Info.CurveOid := '1.2.840.10045.3.1.7';
  Info.PublicKeyParametersAreNamedCurve := False;          // paramètres de courbe explicites
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);

  Info.PublicKeyAlgorithmOid := '';                        // certificat du signataire non trouvé
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;

Le cinquième cas concerne comment le certificat encode sa courbe. La RFC 5480, section 2.1.1, laisse ECParameters être un OID de courbe nommée, une courbe implicite (NULL) ou un jeu complet de paramètres explicites, et la même section restreint les certificats PKIX à la forme nommée. Le PDFium Component renvoie pcsInvalid pour un certificat id-ecPublicKey avec paramètres manquants, implicites ou explicites. Les paramètres explicites épellent le nombre premier, les coefficients et le point de base, ce qui laisse un attaquant décrire une courbe qui ne fait que ressembler à une courbe standard, et un contrôleur qui les accepterait devrait prouver que les nombres correspondent à une courbe nommée avant de faire confiance à quoi que ce soit d'autre

Invalide, non pris en charge et indéterminé sont trois réponses différentes

Les trois valeurs non valides de AlgorithmPolicyStatus portent des sens différents, et les réduire à un seul seau "échoué" jette l'information dont un auditeur a besoin. pcsInvalid signifie qu'une combinaison d'algorithmes reconnue est malformée ou en désaccord. Elle ajoute ppeiSignatureAlgorithmMismatch à TPadesValidationResult.Issues et pousse l'IntegrityStatus agrégé à pcsInvalid, si bien que IsCryptographicallyValid renvoie False même quand la valeur de signature CMS se vérifie

pcsUnsupported signifie que la courbe ou le condensé est hors de ce que le profil nomme. C'est un résultat de capacité, et il laisse IntegrityStatus tranquille. pcsIndeterminate signifie que le PDFium Component a refusé de deviner : le certificat du signataire n'a pas pu être épinglé, typiquement un ensemble de certificats avec plusieurs candidats et aucune correspondance exacte d'issuerAndSerialNumber, ou le SignerInfo n'a pas pu être analysé assez loin pour lire ses algorithmes. Côté RSA, la même valeur marque un condensé que les suites courantes n'acceptent plus pour de nouvelles validations, couvert dans la dernière section

EdDSA montre pourquoi le statut de politique et le statut cryptographique vivent dans des champs séparés. Sur un système dont le vérificateur CMS ne peut pas vérifier Ed25519 ou Ed448, CmsSignatureStatus revient en pcsUnsupported pendant que AlgorithmPolicyStatus peut encore être pcsValid, calculé depuis le certificat trouvé dans le CMS. L'encodage était correct ; seul le vérificateur manquait. Fusionner les deux forcerait un choix entre déclarer cassée une signature bien formée et déclarer bonne une non vérifiée

Chemin de décision de EvaluatePadesSignatureAlgorithm dans PDFium Component : un désaccord de condensé règle pcsInvalid et ppeiSignatureAlgorithmMismatch, une courbe nommée hors du profil ISO TS 32002 comme brainpoolP160r1 règle pcsUnsupported, un certificat de signataire impossible à épingler règle pcsIndeterminate, et la branche RSA applique les suites de condensés ETSI TS 119 312, la taille de clé restant à l'application
Les trois statuts non valides signifient des choses différentes : invalide est la preuve d'une combinaison cassée, non pris en charge est un résultat de capacité, et indéterminé signifie que le code a refusé de deviner

Pour un pipeline d'entrée, rejetez automatiquement sur pcsInvalid et rien d'autre. Traiter pcsUnsupported comme un rejet transforme une courbe que votre politique n'a jamais listée en accusation de falsification, et l'expéditeur n'a aucun moyen de réparer ce qui n'a jamais été cassé. Envoyez les résultats non pris en charge et indéterminés à un humain, avec les OID de AlgorithmInfo joints :

var
  Pdf: TPdf;
  Options: TPadesTrustValidationOptions;
  R: TPadesValidationResult;
  S: TPadesSignatureValidation;
  I: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := 'invoice-ecdsa-signed.pdf';
    Pdf.Active := True;
    Options := TPadesTrustValidationOptions.Default; // hors ligne, sans révocation
    R := Pdf.ValidatePadesTrust(Options);
    for I := 0 to Length(R.Signatures) - 1 do
    begin
      S := R.Signatures[I];
      if S.IsDocumentTimeStamp then
        Continue;
      case S.AlgorithmPolicyStatus of
        pcsInvalid:       Writeln(I, ': reject, algorithm combination is invalid');
        pcsUnsupported:   Writeln(I, ': manual review, algorithm outside the profile: ',
                            string(S.AlgorithmInfo.SignatureAlgorithmOid), ' / ',
                            string(S.AlgorithmInfo.CurveOid));
        pcsIndeterminate: Writeln(I, ': manual review, signer not identified or digest no longer accepted');
        pcsValid:
          if S.AlgorithmInfo.Family = psafRsa then
            Writeln(I, ': RSA digest suite accepted, check key size yourself')
          else
            Writeln(I, ': EC/EdDSA profile satisfied');
      end;
      if (S.CmsSignatureStatus = pcsUnsupported) and
         (S.AlgorithmPolicyStatus = pcsValid) then
        Writeln(I, ': encoding conforms, but no verifier here can check this algorithm');
    end;
    Writeln('Cryptographically valid: ', R.IsCryptographicallyValid);
  finally
    Pdf.Free;
  end;
end;

Si le rejet vient d'Adobe Acrobat ou d'un validateur basé DSS plutôt que de ce contrôle, le guide des raisons pour lesquelles les validateurs rejettent des signatures PAdES passe en revue les autres causes courantes, des trous de ByteRange à un temps de signature /M malformé

Qu'est-ce que pcsValid vous laisse ?

AlgorithmPolicyStatus = pcsValid certifie le profil d'algorithmes et rien de plus : une courbe approuvée avec un condensé congruent et correctement encodé pour ECDSA et EdDSA, ou un condensé d'une suite courante pour RSA. Pour les signatures RSA, EvaluatePadesSignatureAlgorithm applique les suites ETSI TS 119 312. MD2, MD4 et MD5 sont pcsInvalid. SHA-1 et les condensés 112 bits (SHA-224, SHA-512/224, SHA3-224) sont pcsIndeterminate, l'issue qu'utilise EN 319 102-1 quand un algorithme n'est plus considéré fiable et qu'aucune preuve d'existence antérieure n'a été évaluée, si bien qu'une signature SHA-1 garde son résultat d'intégrité et part en revue. Une digestAlgorithm qui diffère du condensé fixé par l'OID de signature, comme sha256WithRSAEncryption sur un condensé SHA-1, est pcsInvalid, et un algorithme de signature RSA sur une clé de signataire non RSA l'est aussi. Un certificat de signataire manquant donne pcsIndeterminate, et des condensés inconnus ou des OID hors signature de l'arc PKCS #1 donnent pcsUnsupported

Les signatures RSASSA-PSS obtiennent en plus un contrôle de paramètres : les paramètres PSS doivent être présents et bien formés, leur hachage doit égaler la digestAlgorithm déclarée, le champ trailer doit être 1, et une clé de certificat restreinte PSS doit être d'accord avec eux. L'article RFC 4055 sur RSASSA-PSS-params couvre comment ces paramètres sont encodés côté signature. La longueur de module est hors de la politique, si bien qu'une application qui veut un plancher de 3072 bits le fait respecter elle-même. SHA-1 ou MD5 dans la digestAlgorithm lève aussi le problème séparé ppeiBadDigestAlgorithm. Quand les attributs signés portent l'attribut cms-algorithm-protection de la RFC 6211, ses deux identifiants sont comparés aux valeurs du SignerInfo octet par octet, et une différence lève ppeiCmsAlgorithmProtectionMismatch et fait échouer l'intégrité ; VerifyCmsAlgorithmProtection exécute cette comparaison sur un blob CMS brut

Les mathématiques de signature, la chaîne de certificats et la révocation restent avec CmsSignatureStatus, CertificateTrustStatus et RevocationStatus, qui viennent du vérificateur CMS. Lisez pcsValid comme "le profil d'algorithmes tient" et jamais comme "cette clé est assez forte". Pour une application Delphi qui accepte des factures signées, des contrats ou des paquets d'archive, toute la mise en place tient en quelques lignes : lancez ValidatePadesTrust, rejetez sur ppeiSignatureAlgorithmMismatch, routez pcsUnsupported et pcsIndeterminate vers un relecteur, et appliquez votre propre plancher de taille de clé RSA

La même bibliothèque qui exécute ces contrôles produit aussi des signatures PAdES, si bien qu'une équipe peut signer avec P-384 ou Ed25519 et confirmer que sa propre sortie satisfait le profil ISO/TS 32002 avant qu'elle n'atteigne jamais un client. Éditions, support de plates-formes et pipeline de signature sont décrits sur la page produit du PDFium Component for Delphi and Lazarus