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