Una chiave P-256 può firmare un digest SHA-512 e la matematica non alza obiezioni. ECDSA tronca l'hash ai 256 bit più a sinistra, la firma verifica, e un verifier CMS riferisce il valore della firma come intatto. ISO/TS 32002, l'estensione PDF 2.0 che ha portato firme a curva ellittica e EdDSA nel PDF, non permette quell'accoppiata, perché lega ogni curva alle larghezze di digest che può portare. La stessa fattura firmata può quindi passare un controllo criptografico su una macchina e fallire su un validator che applica il profilo algoritmico PDF 2.0, ed entrambi i verdetti sono corretti riguardo alla domanda che ciascuno ha posto
Quali coppie curva e digest accetta ISO/TS 32002
ISO/TS 32002 accetta sei curve ECDSA e due schemi EdDSA. Il PDFium Component controlla ogni firma PDF contro quel profilo e riferisce il verdetto in TPadesSignatureValidation.AlgorithmPolicyStatus, indicizzato dall'OID della curva nel certificato del firmatario. Le curve NIST sono rigide: il digest deve avere la stessa larghezza in bit della curva, dalla famiglia SHA-2 o SHA-3. Le curve Brainpool r1 sono più larghe e accettano la loro larghezza o qualsiasi cosa più larga:
- P-256 (
1.2.840.10045.3.1.7): solo SHA-256 o SHA3-256 - P-384 (
1.3.132.0.34): solo SHA-384 o SHA3-384 - P-521 (
1.3.132.0.35): solo SHA-512 o SHA3-512 - brainpoolP256r1 (
1.3.36.3.3.2.8.1.1.7): qualsiasi digest SHA-2 o SHA-3 da 256 a 512 bit - brainpoolP384r1 (
1.3.36.3.3.2.8.1.1.11): SHA-2 / SHA-3 da 384 o 512 bit - brainpoolP512r1 (
1.3.36.3.3.2.8.1.1.13): solo SHA-512 o SHA3-512
L'asimmetria becca gli strumenti di firma che scelgono un digest e lo riutilizzano per ogni chiave. SHA-512 ovunque sembra la scelta prudente, e su brainpoolP256r1 viene accettato. Su P-256 la configurazione identica produce pcsInvalid: la curva è nel profilo, il digest è forte, e l'accoppiata è comunque fuori dalla tabella. Una chiave su una curva che il profilo non nomina mai, come brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) o secp256k1 (1.3.132.0.10), atterra in un altro secchio. Finché il digest dichiarato e l'algoritmo di firma sono d'accordo, riceve pcsUnsupported
EdDSA non lascia scelte, solo regole di codifica
Ed25519 e Ed448 non hanno parametro di curva né opzione di digest, così ogni regola che il PDFium Component applica loro riguarda come il CMS dichiara l'algoritmo. RFC 8419 fissa il digest. Un SignerInfo Ed25519 dichiara SHA-512 (2.16.840.1.101.3.4.2.3) come suo digestAlgorithm con il campo parametri assente. Un SignerInfo Ed448 che porta signed attributes, come fa ogni firma PAdES, dichiara id-shake256-len (2.16.840.1.101.3.4.2.18) con un parametro INTEGER di esattamente 512. RFC 8410 aggiunge che l'AlgorithmIdentifier della firma (1.3.101.112 per Ed25519, 1.3.101.113 per Ed448) e l'AlgorithmIdentifier della chiave pubblica del certificato non portano parametri affatto
Molti codificatori ASN.1 appendo un NULL esplicito a ogni OID di algoritmo perché gli identificatori RSA hanno sempre avuto uno, e l'abitudine sopravvive quando qualcuno avvita Ed25519 su un percorso di firma esistente. La chiave sta bene. Il valore della firma sta bene. La codifica no, e il PDFium Component restituisce pcsInvalid quando un campo parametri è presente su uno dei due identificatori, quando il digest Ed25519 è qualcosa di diverso da uno SHA-512 senza parametri, o quando il digest Ed448 non è id-shake256-len con 512. Un certificato il cui OID di chiave appartiene all'altro schema EdDSA, o a qualche altro algoritmo, produce anch'esso pcsInvalid
Leggere la tripla algoritmica dal CMS
Il motore PDFium legge il dizionario della firma, ma la sua API pubblica né verifica il CMS né espone la curva del certificato del firmatario. Il livello di ispezione PAdES costruito su PDFium analizza quindi da sé il CMS SignedData (RFC 5652). InspectPadesSignatureAlgorithm legge il digestAlgorithm e lo signatureAlgorithm del primo SignerInfo, individua il certificato del firmatario nell'insieme certificates, e legge l'algoritmo della chiave e la curva dal suo SubjectPublicKeyInfo. Digest, algoritmo di firma, chiave più curva: quei tre valori sono ciò che la policy giudica
Un insieme di certificati CMS è non ordinato e di solito tiene il certificato del firmatario accanto alla sua CA emittente, ed entrambi possono essere chiavi EC su curve diverse, così prendere il primo certificato EC lascerebbe alla CA decidere quale curva il firmatario abbia suppostamente usato. Il PDFium Component confronta issuer e numero di serie da issuerAndSerialNumber byte per byte, esamina al massimo 64 certificati, e ricade su «l'unico certificato che c'è» solo quando l'insieme contiene esattamente un certificato analizzabile. Qualunque altro esito lascia vuoti i campi chiave del record
TPdf.ValidatePades esegue la policy durante il suo passaggio di conformità, prima contro il certificato trovato dentro il CMS. Poi verifica la firma con il verifier CMS della piattaforma: Windows CryptoAPI per default su Windows, oppure un verifier OpenSSL o macOS Keychain registrato attraverso ConfigureSslCmsVerifier o ConfigureKeychainCmsVerifier. Quando il verifier riferisce quale certificato ha davvero usato, la policy gira di nuovo su quel certificato e il suo risultato sostituisce il primo. TPdf.ValidatePadesTrust nell'edizione Enterprise segue lo stesso ordine costruendo anche la catena e, su richiesta, controllando la revoca. Gli input grezzi atterrano in TPadesSignatureAlgorithmInfo, che questo listato stampa per ogni firma in un file:
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;
Quei flag di solito spiegano un rifiuto prima che qualcuno apra un dump ASN.1. DigestParameterBits mostra la lunghezza Ed448, SignatureParametersPresent espone il NULL vagante, e PublicKeyParametersAreNamedCurve copre la codifica della curva trattata nella prossima sezione. Un PublicKeyAlgorithmOid vuoto significa che il certificato del firmatario non è mai stato agganciato
Perché una firma P-256 con SHA3-256 fallisce la policy?
Una firma P-256 con SHA3-256 fallisce ogni volta che il digestAlgorithm del CMS dice SHA3-256 mentre lo signatureAlgorithm dice ecdsa-with-SHA256. Ogni metà è da sola accettabile per P-256; insieme non sono d'accordo su quale hash sia stato firmato. EvaluatePadesSignatureAlgorithm mappa ogni OID di firma ECDSA, da ecdsa-with-SHA256 fino a ecdsa-with-SHA3-512, al digest che implica, lo confronta col digestAlgorithm dichiarato, e restituisce pcsInvalid a qualunque differenza prima ancora di guardare la tabella delle curve. Uno strumento di firma che sposta il suo hash a SHA3-256 ma mantiene un identificatore di firma hard-coded produce esattamente questo file, e un verifier conforme non ha modo coerente di leggerlo
EvaluatePadesSignatureAlgorithm è pubblica e prende un record semplice, così la matrice può essere inchiodata in uno unit test senza costruire un PDF. Le chiamate Assert qui sotto sono controlli di test vostri:
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 non corrispondente
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); // congrua, ma non per P-256
Info.CurveOid := '1.3.36.3.3.2.8.1.1.1'; // brainpoolP160r1
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // curva fuori dal profilo
Info.CurveOid := '1.2.840.10045.3.1.7';
Info.PublicKeyParametersAreNamedCurve := False; // parametri di curva espliciti
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);
Info.PublicKeyAlgorithmOid := ''; // certificato firmatario non trovato
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;
Il quinto caso riguarda come il certificato codifica la sua curva. RFC 5480 §2.1.1 lascia che ECParameters sia un OID di curva nominata, una curva implicita (NULL) o un set completo di parametri espliciti, e la stessa sezione restringe i certificati PKIX alla forma nominata. Il PDFium Component restituisce pcsInvalid per un certificato id-ecPublicKey con parametri mancanti, impliciti o espliciti. I parametri espliciti declinano per esteso il primo, i coefficienti e il punto base, il che lascia a un attaccante descrivere una curva che somiglia soltanto a una standard, e un checker che li accettasse dovrebbe provare che i numeri corrispondono a una curva nominata prima di fidarsi di qualunque altra cosa
Invalid, unsupported e indeterminate sono tre risposte diverse
I tre valori non validi di AlgorithmPolicyStatus portano significati diversi, e accorparli in un unico secchio «fallito» butta via l'informazione di cui un auditor ha bisogno. pcsInvalid significa che una combinazione di algoritmi riconosciuta è malformata o disallineata. Aggiunge ppeiSignatureAlgorithmMismatch a TPadesValidationResult.Issues e spinge l'IntegrityStatus aggregato a pcsInvalid, così IsCryptographicallyValid restituisce False anche quando il valore della firma CMS torna
pcsUnsupported significa che la curva o il digest stanno fuori da ciò che il profilo nomina. È un risultato di capacità, e lascia in pace IntegrityStatus. pcsIndeterminate significa che il PDFium Component si è rifiutato di indovinare: il certificato del firmatario non è stato agganciato, tipicamente un insieme di certificati con parecchi candidati e nessuna corrispondenza esatta di issuerAndSerialNumber, o il SignerInfo non è stato analizzato abbastanza in profondità da leggere i suoi algoritmi. Sul lato RSA lo stesso valore segna un digest che le suite correnti non accettano più per nuove validazioni, trattato nell'ultima sezione
EdDSA mostra perché lo stato di policy e lo stato criptografico vivono in campi separati. Su un sistema il cui verifier CMS non sa controllare Ed25519 o Ed448, CmsSignatureStatus torna pcsUnsupported mentre AlgorithmPolicyStatus può ancora essere pcsValid, calcolato dal certificato trovato nel CMS. La codifica era corretta; mancava solo il verifier. Accorpare i due costringerebbe a scegliere fra chiamare rotta una firma ben formata e chiamare buona una non controllata
Per una pipeline di intake, rifiutate in automatico su pcsInvalid e su nient'altro. Trattare pcsUnsupported come rifiuto trasforma una curva che la vostra policy non ha mai elencato in un'accusa di manomissione, e il mittente non ha modo di sistemare ciò che non si è mai rotto. Mandate i risultati unsupported e indeterminate a una persona, con gli OID da AlgorithmInfo allegati:
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, nessuna revoca
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;
Se il rifiuto arriva da Adobe Acrobat o da un validator basato su DSS invece che da questo controllo, la guida ai motivi per cui i validator rifiutano le firme PAdES percorre le altre cause comuni, dai buchi nel ByteRange a un orario di firma /M malformato
Che cosa lascia pcsValid a voi?
AlgorithmPolicyStatus = pcsValid certifica il profilo algoritmico e nient'altro: una curva approvata con un digest congruente e correttamente codificato per ECDSA e EdDSA, o un digest di una suite corrente per RSA. Per le firme RSA EvaluatePadesSignatureAlgorithm applica le suite ETSI TS 119 312. MD2, MD4 e MD5 sono pcsInvalid. SHA-1 e i digest a 112 bit (SHA-224, SHA-512/224, SHA3-224) sono pcsIndeterminate, l'esito che EN 319 102-1 usa quando un algoritmo non è più considerato affidabile e nessuna prova di esistenza precedente è stata valutata, così una firma SHA-1 conserva il suo risultato di integrità e va in revisione. Un digestAlgorithm che differisce dal digest fissato dall'OID di firma, come sha256WithRSAEncryption su un digest SHA-1, è pcsInvalid, e lo è anche un algoritmo di firma RSA su una chiave firmatario non RSA. Un certificato firmatario mancante dà pcsIndeterminate, e digest sconosciuti o OID non di firma dall'arco PKCS #1 danno pcsUnsupported
Le firme RSASSA-PSS ricevono sopra un controllo dei parametri: i parametri PSS devono essere presenti e ben formati, il loro hash deve eguagliare il digestAlgorithm dichiarato, il campo trailer deve essere 1, e una chiave di certificato con restrizioni PSS deve essere d'accordo con loro. L'articolo su RSASSA-PSS-params di RFC 4055 copre come quei parametri vengono codificati sul lato firma. La lunghezza del modulo sta fuori dalla policy, così un'applicazione che vuole un minimo di 3072 bit se lo impone da sé. SHA-1 o MD5 nel digestAlgorithm sollevano inoltre la questione separata ppeiBadDigestAlgorithm. Quando i signed attributes portano l'attributo cms-algorithm-protection di RFC 6211, i suoi due identificatori vengono confrontati con i valori del SignerInfo byte per byte, e una differenza solleva ppeiCmsAlgorithmProtectionMismatch e fallisce l'integrità; VerifyCmsAlgorithmProtection esegue quel confronto su un blob CMS grezzo
La matematica della firma, la catena dei certificati e la revoca restano a CmsSignatureStatus, CertificateTrustStatus e RevocationStatus, che arrivano dal verifier CMS. Leggete pcsValid come «il profilo algoritmico regge» e mai come «questa chiave è abbastanza robusta». Per un'applicazione Delphi che accetta fatture, contratti o pacchetti archivio firmati, l'intero assetto sta in poche righe: eseguite ValidatePadesTrust, rifiutate su ppeiSignatureAlgorithmMismatch, instradate pcsUnsupported e pcsIndeterminate a un revisore, e applicate la vostra soglia minima di dimensione chiave RSA
La stessa libreria che esegue questi controlli produce anche firme PAdES, così un team può firmare con P-384 o Ed25519 e confermare che il proprio output soddisfa il profilo ISO/TS 32002 prima che raggiunga mai un cliente. Edizioni, supporto piattaforma e pipeline di firma sono descritti nella pagina di prodotto del PDFium Component for Delphi and Lazarus