Technischer Artikel

ISO/TS-32002-Checks für ECDSA und EdDSA in PDFium Delphi

Ein P-256-Key kann einen SHA-512-Digest signieren, und die Mathematik wird nicht widersprechen. ECDSA stutzt den Hash auf die linken 256 Bits, die Signatur verifiziert, und ein CMS-Verifizierer meldet den Signaturwert als intakt. ISO/TS 32002, die PDF-2.0-Erweiterung, die Elliptic-Curve- und EdDSA-Signaturen ins PDF brachte, erlaubt diese Paarung nicht, denn sie bindet jede Kurve an die Digest-Breiten, die sie tragen darf. Dieselbe signierte Rechnung kann deshalb auf einer Maschine eine kryptografische Prüfung bestehen und bei einem Validator scheitern, der das PDF-2.0-Algorithmenprofil anwendet, und beide Urteile sind korrekt bezüglich der Frage, die jeweils gestellt wurde

Welche Kurve-und-Digest-Paare ISO/TS 32002 akzeptiert

ISO/TS 32002 akzeptiert sechs ECDSA-Kurven und zwei EdDSA-Schemata. Die PDFium Component prüft jede PDF-Signatur gegen dieses Profil und meldet das Urteil in TPadesSignatureValidation.AlgorithmPolicyStatus, geschlüsselt über die Kurven-OID im Signer-Zertifikat. Die NIST-Kurven sind streng: Der Digest muss dieselbe Bitbreite wie die Kurve haben, aus der SHA-2- oder der SHA-3-Familie. Die Brainpool-r1-Kurven sind großzügiger und akzeptieren die eigene Breite oder alles breitere:

  • P-256 (1.2.840.10045.3.1.7): nur SHA-256 oder SHA3-256
  • P-384 (1.3.132.0.34): nur SHA-384 oder SHA3-384
  • P-521 (1.3.132.0.35): nur SHA-512 oder SHA3-512
  • brainpoolP256r1 (1.3.36.3.3.2.8.1.1.7): jeder SHA-2- oder SHA-3-Digest von 256 bis 512 Bits
  • brainpoolP384r1 (1.3.36.3.3.2.8.1.1.11): 384- oder 512-Bit-SHA-2 / SHA-3
  • brainpoolP512r1 (1.3.36.3.3.2.8.1.1.13): nur SHA-512 oder SHA3-512
Matrix des ISO-TS-32002-Algorithmenprofils in PDFium Component: P-256, P-384 und P-521 akzeptieren nur passende Digest-Breiten, brainpoolP256r1 akzeptiert 256 bis 512 Bits, brainpoolP384r1 384 und 512, Ed25519 und Ed448 deklarieren SHA-512 und SHAKE256 mit Länge 512, und Diskrepanzen werfen ppeiSignatureAlgorithmMismatch, während Kurven außerhalb des Profils pcsUnsupported liefern
Sechs ECDSA-Kurven und zwei EdDSA-Schemata können bestehen, und jede Kurve ist an die Digest-Breiten gebunden, die sie tragen darf; alles andere ist invalid oder unsupported, nie stillschweigend akzeptiert

Die Asymmetrie erwischt Signier-Tools, die einen Digest wählen und ihn für jeden Key wiederverwenden. SHA-512 überall sieht nach der vorsichtigen Wahl aus, und auf brainpoolP256r1 wird sie akzeptiert. Auf P-256 produziert dieselbe Konfiguration pcsInvalid: Die Kurve ist im Profil, der Digest ist stark, und die Paarung liegt trotzdem außerhalb der Tabelle. Ein Key auf einer Kurve, die das Profil nie nennt, etwa brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) oder secp256k1 (1.3.132.0.10), landet in einem anderen Eimer. Solange sich sein deklarierter Digest und sein Signaturalgorithmus vertragen, bekommt es pcsUnsupported

EdDSA lässt keine Entscheidungen zu, nur Kodierungsregeln

Ed25519 und Ed448 haben keinen Kurvenparameter und keine Digest-Option; jede Regel, die die PDFium Component auf sie anwendet, betrifft also, wie das CMS den Algorithmus deklariert. RFC 8419 legt den Digest fest. Ein Ed25519-SignerInfo deklariert SHA-512 (2.16.840.1.101.3.4.2.3) als sein digestAlgorithm, mit abwesendem Parameters-Feld. Ein Ed448-SignerInfo, der signierte Attribute trägt, was jede PAdES-Signatur tut, deklariert id-shake256-len (2.16.840.1.101.3.4.2.18) mit einem INTEGER-Parameter von exakt 512. RFC 8410 ergänzt, dass die Signatur-AlgorithmIdentifier (1.3.101.112 für Ed25519, 1.3.101.113 für Ed448) und die Public-Key-AlgorithmIdentifier des Zertifikats überhaupt keine Parameter tragen

Viele ASN.1-Encoder hängen an jeden Algorithmus-OID ein explizites NULL an, weil RSA-Identifikatoren immer eines hatten, und die Gewohnheit überlebt, wenn jemand Ed25519 auf einen bestehenden Signierpfad aufpropft. Der Key ist in Ordnung. Der Signaturwert ist in Ordnung. Die Kodierung ist es nicht, und die PDFium Component gibt pcsInvalid zurück, wenn ein Parameters-Feld auf einem der beiden Identifikatoren steht, wenn der Ed25519-Digest irgendetwas anderes als parameterfreies SHA-512 ist, oder wenn der Ed448-Digest nicht id-shake256-len mit 512 ist. Ein Zertifikat, dessen Key-OID zum anderen EdDSA-Schema gehört oder zu irgendeinem anderen Algorithmus, liefert ebenfalls pcsInvalid

Das Algorithmus-Tripel aus dem CMS lesen

Die PDFium-Engine liest das Signatur-Dictionary, aber ihre öffentliche API verifiziert weder das CMS noch legt sie die Kurve des Signer-Zertifikats offen. Die auf PDFium aufgebaute PAdES-Inspektions-Schicht parst deshalb die CMS-SignedData (RFC 5652) selbst. InspectPadesSignatureAlgorithm liest digestAlgorithm und signatureAlgorithm des ersten SignerInfo, ortet das Signer-Zertifikat in der certificates-Menge und liest Key-Algorithmus und Kurve aus dessen SubjectPublicKeyInfo. Digest, Signaturalgorithmus, Key plus Kurve: Diese drei Werte sind es, die die Policy richtet

Eine CMS-Zertifikatsmenge ist ungeordnet und hält üblicherweise das Signer-Zertifikat neben seiner ausstellenden CA, und beide können EC-Keys auf verschiedenen Kurven sein; sonst würde der Griff zum ersten EC-Zertifikat die CA entscheiden lassen, welche Kurve der Signer angeblich genutzt hat. Die PDFium Component gleicht Issuer und Seriennummer aus issuerAndSerialNumber Byte für Byte ab, untersucht höchstens 64 Zertifikate und fällt nur dann auf „das einzige Zertifikat, das es gibt“ zurück, wenn die Menge genau ein parsebares Zertifikat enthält. Jedes andere Ergebnis lässt die Key-Felder des Records leer

Wie PDFium Component ein PDF-Signatur-Algorithmus-Tripel inspiziert: InspectPadesSignatureAlgorithm liest digestAlgorithm und signatureAlgorithm des ersten SignerInfo im CMS, pinnt das Signer-Zertifikat über einen exakten issuerAndSerialNumber-Match unter höchstens 64 Kandidaten, liest die SubjectPublicKeyInfo für die Kurve, und EvaluatePadesSignatureAlgorithm liefert den AlgorithmPolicyStatus
PDFium selbst verifiziert weder das CMS noch legt es die Signer-Kurve offen, also parst die PAdES-Schicht das SignedData und behält jede rohe OID im Record für eine erklärbare Zurückweisung

TPdf.ValidatePades lässt die Policy während seines Compliance-Durchlaufs laufen, zuerst gegen das im CMS gefundene Zertifikat. Danach verifiziert es die Signatur mit dem CMS-Verifizierer der Plattform: unter Windows standardmäßig die Windows CryptoAPI, oder ein über ConfigureSslCmsVerifier oder ConfigureKeychainCmsVerifier registrierter OpenSSL- bzw. macOS-Keychain-Verifizierer. Meldet der Verifizierer, welches Zertifikat er tatsächlich benutzt hat, läuft die Policy erneut über dieses Zertifikat, und ihr Ergebnis ersetzt das erste. TPdf.ValidatePadesTrust in der Enterprise-Edition folgt derselben Reihenfolge und baut dabei auch die Kette auf und prüft auf Wunsch die Revocation. Die rohen Eingaben landen in TPadesSignatureAlgorithmInfo, das dieses Listing für jede Signatur in einer Datei ausgibt:

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;

Diese Flags erklären eine Zurückweisung üblicherweise, bevor jemand ein ASN.1-Dump öffnet. DigestParameterBits zeigt die Ed448-Länge, SignatureParametersPresent legt das fremde NULL offen, und PublicKeyParametersAreNamedCurve deckt die Kurven-Kodierung ab, die im nächsten Abschnitt besprochen wird. Ein leeres PublicKeyAlgorithmOid heißt, das Signer-Zertifikat wurde nie festgenagelt

Warum scheitert eine P-256-Signatur mit SHA3-256 an der Policy?

Eine P-256-Signatur mit SHA3-256 scheitert immer dann, wenn der CMS-digestAlgorithm SHA3-256 sagt, während der signatureAlgorithm ecdsa-with-SHA256 sagt. Jede Hälfte ist für P-256 allein akzeptabel; zusammen sind sie sich uneinig, welcher Hash signiert wurde. EvaluatePadesSignatureAlgorithm mappt jede ECDSA-Signatur-OID, von ecdsa-with-SHA256 bis ecdsa-with-SHA3-512, auf den Digest, den sie impliziert, vergleicht ihn mit dem deklarierten digestAlgorithm und gibt bei jeder Diskrepanz pcsInvalid zurück, noch bevor es die Kurventabelle ansieht. Ein Signier-Tool, das seinen Hash auf SHA3-256 umstellt, aber eine hart kodierte Signatur-Identifikation behält, produziert exakt diese Datei, und ein konformer Verifizierer hat keinen konsistenten Weg, sie zu lesen

EvaluatePadesSignatureAlgorithm ist öffentlich und nimmt einen schlichten Record, so lässt sich die Matrix in einem Unit-Test festnageln, ohne ein PDF zu bauen. Die Assert-Aufrufe unten sind Ihre eigenen Testprüfungen:

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-Diskrepanz

  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);  // kongruent, aber nicht für P-256

  Info.CurveOid := '1.3.36.3.3.2.8.1.1.1';                 // brainpoolP160r1
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // Kurve außerhalb des Profils

  Info.CurveOid := '1.2.840.10045.3.1.7';
  Info.PublicKeyParametersAreNamedCurve := False;          // explizite Kurvenparameter
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);

  Info.PublicKeyAlgorithmOid := '';                        // Signer-Zertifikat nicht gefunden
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;

Der fünfte Fall dreht sich darum, wie das Zertifikat seine Kurve kodiert. RFC 5480 §2.1.1 lässt ECParameters eine benannte Kurven-OID, eine implizite Kurve (NULL) oder ein vollständiger expliziter Parametersatz sein, und dieselbe Stelle schränkt PKIX-Zertifikate auf die benannte Form ein. Die PDFium Component gibt pcsInvalid für ein id-ecPublicKey-Zertifikat mit fehlenden, impliziten oder expliziten Parametern zurück. Explizite Parameter buchstabieren Primzahl, Koeffizienten und Basispunkt; das erlaubt einem Angreifer, eine Kurve zu beschreiben, die bloß einer Standardkurve ähnelt, und ein Prüfer, der sie akzeptierte, müsste erst beweisen, dass die Zahlen zu einer benannten Kurve passen, bevor er irgendetwas anderem vertraut

Invalid, unsupported und indeterminate sind drei verschiedene Antworten

Die drei Nicht-valid-Werte von AlgorithmPolicyStatus tragen verschiedene Bedeutungen, und sie in einen einzigen „failed“-Eimer zu kippen, wirft die Information weg, die ein Auditor braucht. pcsInvalid heißt, eine erkannte Algorithmuskombination ist missgestaltet oder unpassend. Es fügt ppeiSignatureAlgorithmMismatch zu TPadesValidationResult.Issues hinzu und treibt den aggregierten IntegrityStatus auf pcsInvalid, sodass IsCryptographicallyValid False zurückgibt, selbst wenn der CMS-Signaturwert in Ordnung geht

pcsUnsupported heißt, die Kurve oder der Digest liegt außerhalb dessen, was das Profil nennt. Das ist ein Capability-Ergebnis, und es lässt IntegrityStatus in Ruhe. pcsIndeterminate heißt, die PDFium Component hat sich geweigert zu raten: Das Signer-Zertifikat ließ sich nicht festnageln, typischerweise eine Zertifikatsmenge mit mehreren Kandidaten und ohne exakte issuerAndSerialNumber-Übereinstimmung, oder das SignerInfo ließ sich nicht weit genug parsen, um seine Algorithmen zu lesen. Auf der RSA-Seite markiert derselbe Wert einen Digest, den aktuelle Suiten für neue Validierungen nicht mehr akzeptieren, behandelt im letzten Abschnitt

EdDSA zeigt, warum der Policy-Status und der kryptografische Status in getrennten Feldern wohnen. Auf einem System, dessen CMS-Verifizierer Ed25519 oder Ed448 nicht prüfen kann, kommt CmsSignatureStatus als pcsUnsupported zurück, während AlgorithmPolicyStatus noch pcsValid sein kann, berechnet aus dem im CMS gefundenen Zertifikat. Die Kodierung war korrekt; es fehlte nur der Verifizierer. Beide zusammenzulegen würde eine Wahl erzwingen zwischen „eine wohlgeformte Signatur kaputt nennen“ und „eine ungeprüfte gut heißen“

Entscheidungspfad von EvaluatePadesSignatureAlgorithm in PDFium Component: Eine Digest-Diskrepanz setzt pcsInvalid und ppeiSignatureAlgorithmMismatch, eine benannte Kurve außerhalb des ISO-TS-32002-Profils wie brainpoolP160r1 setzt pcsUnsupported, ein nicht festnagelbares Signer-Zertifikat setzt pcsIndeterminate, und der RSA-Zweig wendet die ETSI-TS-119-312-Digest-Suiten an, während die Schlüsselgröße weiter der Anwendung überlassen bleibt
Die drei Nicht-valid-Status bedeuten Verschiedenes: invalid ist der Beweis einer kaputten Kombination, unsupported ein Capability-Ergebnis, und indeterminate heißt, der Code hat sich geweigert zu raten

Für eine Annahme-Pipeline: Lehnen Sie automatisch bei pcsInvalid ab und bei nichts anderem. pcsUnsupported als Zurückweisung zu behandeln, macht aus einer Kurve, die Ihre Policy nie gelistet hat, einen Manipulationsvorwurf, und der Absender hat keine Möglichkeit, etwas zu reparieren, das nie kaputt war. Schicken Sie unsupported- und indeterminate-Ergebnisse an einen Menschen, mit den OIDs aus AlgorithmInfo im Anhang:

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; // offline, keine Revocation
    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;

Kommt die Zurückweisung stattdessen von Adobe Acrobat oder einem DSS-basierten Validator, geht der Leitfaden dazu, warum Validator PAdES-Signaturen ablehnen die übrigen häufigen Ursachen durch, von ByteRange-Lücken bis zu einer missgestalteten /M-Signierzeit

Was bleibt bei pcsValid für Sie?

AlgorithmPolicyStatus = pcsValid bescheinigt das Algorithmenprofil und nichts weiter: eine genehmigte Kurve mit einem kongruenten, korrekt kodierten Digest für ECDSA und EdDSA, oder einen Digest aus einer aktuellen Suite für RSA. Für RSA-Signaturen wendet EvaluatePadesSignatureAlgorithm die ETSI-TS-119-312-Suiten an. MD2, MD4 und MD5 sind pcsInvalid. SHA-1 und die 112-Bit-Digests (SHA-224, SHA-512/224, SHA3-224) sind pcsIndeterminate, das Ergebnis, das EN 319 102-1 verwendet, wenn ein Algorithmus nicht mehr als zuverlässig gilt und kein Nachweis früherer Existenz ausgewertet wurde; eine SHA-1-Signatur behält also ihr Integritätsergebnis und geht zur Prüfung. Ein digestAlgorithm, der nicht dem Digest entspricht, den die Signatur-OID festlegt, etwa sha256WithRSAEncryption über einem SHA-1-Digest, ist pcsInvalid, und ein RSA-Signaturalgorithmus auf einem Nicht-RSA-Signer-Key ebenso. Ein fehlendes Signer-Zertifikat ergibt pcsIndeterminate, und unbekannte Digests oder Nicht-Signatur-OIDs aus dem PKCS-#1-Arc ergeben pcsUnsupported

RSASSA-PSS-Signaturen bekommen eine Parameterprüfung obendrauf: Die PSS-Parameter müssen vorhanden und wohlgeformt sein, ihr Hash muss dem deklarierten digestAlgorithm entsprechen, das Trailer-Feld muss 1 sein, und ein PSS-restringierter Zertifikats-Key muss mit ihnen übereinstimmen. Der RFC-4055-RSASSA-PSS-params-Artikel beschreibt, wie diese Parameter auf der Signierseite kodiert werden. Die Modulus-Länge liegt außerhalb der Policy; eine Anwendung, die eine 3072-Bit-Untergrenze will, setzt sie selbst durch. SHA-1 oder MD5 im digestAlgorithm hebt zusätzlich das separate Issue ppeiBadDigestAlgorithm heraus. Tragen die signierten Attribute das RFC-6211-cms-algorithm-protection-Attribut, werden seine beiden Identifikatoren Byte für Byte mit den SignerInfo-Werten verglichen; eine Diskrepanz hebt ppeiCmsAlgorithmProtectionMismatch aus und lässt die Integrität scheitern. VerifyCmsAlgorithmProtection führt diesen Vergleich über einen rohen CMS-Blob aus

Die Signaturmathematik, die Zertifikatskette und die Revocation bleiben bei CmsSignatureStatus, CertificateTrustStatus und RevocationStatus, die vom CMS-Verifizierer kommen. Lesen Sie pcsValid als „das Algorithmenprofil hält“ und nie als „dieser Key ist stark genug“. Für eine Delphi-Anwendung, die signierte Rechnungen, Verträge oder Archivpakete annimmt, passt das ganze Setup in ein paar Zeilen: ValidatePadesTrust laufen lassen, bei ppeiSignatureAlgorithmMismatch ablehnen, pcsUnsupported und pcsIndeterminate an einen Prüfer routen, und die eigene RSA-Key-Size-Untergrenze anwenden

Dieselbe Bibliothek, die diese Prüfungen ausführt, erzeugt auch PAdES-Signaturen; ein Team kann also mit P-384 oder Ed25519 signieren und bestätigen, dass seine eigene Ausgabe das ISO/TS-32002-Profil erfüllt, bevor sie je einen Kunden erreicht. Editionen, Plattformunterstützung und die Signier-Pipeline beschreibt die PDFium Component for Delphi and Lazarus-Produktseite