Klucz P-256 może podpisać digest SHA-512 i matematyka nie zaprotestuje. ECDSA ucina hash do skrajnie lewych 256 bitów, podpis się weryfikuje, a weryfikator CMS zgłasza wartość podpisu jako nietkniętą. ISO/TS 32002 — rozszerzenie PDF 2.0, które wciągnęło podpisy na krzywych eliptycznych i EdDSA do PDF — nie dopuszcza tej pary, bo wiąże każdą krzywą z szerokościami digestu, które może nieść. Ta sama podpisana faktura może więc przejść kontrolę kryptograficzną na jednej maszynie i paść na walidatorze stosującym profil algorytmiczny PDF 2.0, i oba werdykty są poprawne wobec pytań, o które każdy z nich pytał
Które pary krzywa-digest ISO/TS 32002 przyjmuje
ISO/TS 32002 przyjmuje sześć krzywych ECDSA i dwa schematy EdDSA. PDFium Component sprawdza każdy podpis PDF względem tego profilu i zgłasza werdykt w TPadesSignatureValidation.AlgorithmPolicyStatus, kluczowanym OID-em krzywej z certyfikatu podpisującego. Krzywe NIST są surowe: digest musi mieć tę samą szerokość w bitach co krzywa, z rodziny SHA-2 albo SHA-3. Krzywe Brainpool r1 są łagodniejsze i przyjmują własną szerokość albo cokolwiek szerszego:
- P-256 (
1.2.840.10045.3.1.7): tylko SHA-256 albo SHA3-256 - P-384 (
1.3.132.0.34): tylko SHA-384 albo SHA3-384 - P-521 (
1.3.132.0.35): tylko SHA-512 albo SHA3-512 - brainpoolP256r1 (
1.3.36.3.3.2.8.1.1.7): dowolny digest SHA-2 albo SHA-3 od 256 do 512 bitów - brainpoolP384r1 (
1.3.36.3.3.2.8.1.1.11): SHA-2 / SHA-3 o 384 lub 512 bitach - brainpoolP512r1 (
1.3.36.3.3.2.8.1.1.13): tylko SHA-512 albo SHA3-512
Asymetria łapie narzędzia podpisujące, które wybiorą jeden digest i użyją go dla każdego klucza. SHA-512 wszędzie wygląda na ostrożny wybór i na brainpoolP256r1 jest przyjmowany. Na P-256 identyczna konfiguracja produkuje pcsInvalid: krzywa jest w profilu, digest jest mocny, a para i tak siedzi poza tabelą. Klucz na krzywej, której profil nigdy nie nazywa — takiej jak brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) albo secp256k1 (1.3.132.0.10) — ląduje w innym wiadrze. Dopóki zadeklarowany digest i algorytm podpisu się zgadzają, dostaje pcsUnsupported
EdDSA nie zostawia wyborów, tylko reguły kodowania
Ed25519 i Ed448 nie mają parametru krzywej ani opcji digestu, więc każda reguła, którą PDFium Component wobec nich stosuje, dotyczy tego, jak CMS deklaruje algorytm. RFC 8419 ustala digest. SignerInfo Ed25519 deklaruje SHA-512 (2.16.840.1.101.3.4.2.3) jako swój digestAlgorithm z nieobecnym polem parametrów. SignerInfo Ed448, który niesie podpisane atrybuty — a niesie je każdy podpis PAdES — deklaruje id-shake256-len (2.16.840.1.101.3.4.2.18) z parametrem INTEGER równym dokładnie 512. RFC 8410 dorzuca, że AlgorithmIdentifier podpisu (1.3.101.112 dla Ed25519, 1.3.101.113 dla Ed448) i AlgorithmIdentifier klucza publicznego certyfikatu nie niosą żadnych parametrów
Wiele enkoderów ASN.1 dokleja jawne NULL do każdego OID-a algorytmu, bo identyfikatory RSA zawsze jeden miały, i nawyk przeżywa, gdy ktoś dobudowuje Ed25519 do istniejącej ścieżki podpisującej. Klucz jest w porządku. Wartość podpisu jest w porządku. Kodowanie nie jest, a PDFium Component zwraca pcsInvalid, gdy pole parametrów jest obecne na którymkolwiek z identyfikatorów, gdy digest Ed25519 jest czymkolwiek innym niż SHA-512 bez parametrów albo gdy digest Ed448 nie jest id-shake256-len z 512. Certyfikat, którego OID klucza należy do drugiego schematu EdDSA albo do innego algorytmu, też daje pcsInvalid
Wyczytywanie trójki algorytmicznej z CMS
Silnik PDFium czyta słownik podpisu, ale jego publiczne API ani nie weryfikuje CMS, ani nie wystawia krzywej certyfikatu podpisującego. Warstwa inspekcji PAdES zbudowana na PDFium parsuje więc CMS SignedData (RFC 5652) na własną rękę. InspectPadesSignatureAlgorithm czyta digestAlgorithm i signatureAlgorithm pierwszego SignerInfo, odnajduje certyfikat podpisującego w zbiorze certificates i czyta algorytm klucza oraz krzywą z jego SubjectPublicKeyInfo. Digest, algorytm podpisu, klucz plus krzywa: te trzy wartości są tym, co ocenia polityka
Zbiór certyfikatów CMS jest nieuporządkowany i zwykle trzyma certyfikat podpisującego obok wydającego go CA, a oba mogą być kluczami EC na różnych krzywych, więc wzięcie pierwszego napotkanego certyfikatu EC pozwoliłoby CA zdecydować, po której krzywej podobno podpisywał podpisujący. PDFium Component dopasowuje wystawcę i numer seryjny z issuerAndSerialNumber bajt po bajcie, ogląda co najwyżej 64 certyfikaty i cofa się do „jedynego certyfikatu, jaki tam jest” tylko wtedy, gdy zbiór trzyma dokładnie jeden parseowalny certyfikat. Jakikolwiek inny wynik zostawia pola kluczowe rekordu puste
TPdf.ValidatePades puszcza politykę w ramach swojego przebiegu zgodności, najpierw względem certyfikatu znalezionego wewnątrz CMS. Potem weryfikuje podpis weryfikatorem CMS dla platformy: Windows CryptoAPI domyślnie na Windows albo weryfikator OpenSSL lub macOS Keychain zarejestrowany przez ConfigureSslCmsVerifier albo ConfigureKeychainCmsVerifier. Gdy weryfikator zgłosi, którego certyfikatu faktycznie użył, polityka biegnie drugi raz na tym certyfikacie i jej wynik zastępuje pierwszy. TPdf.ValidatePadesTrust w edycji Enterprise idzie tą samą kolejnością, budując przy okazji łańcuch i, na życzenie, sprawdzając unieważnienia. Surowe wejścia lądują w TPadesSignatureAlgorithmInfo, który ten listing wypisuje dla każdego podpisu w pliku:
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;
Te flagi zwykle wyjaśniają odrzucenie, zanim ktokolwiek otworzy zrzut ASN.1. DigestParameterBits pokazuje długość Ed448, SignatureParametersPresent wystawia zabłąkany NULL, a PublicKeyParametersAreNamedCurve pokrywa kodowanie krzywej omówione w następnej sekcji. Pusty PublicKeyAlgorithmOid znaczy, że certyfikat podpisującego nie został nigdy przypięty
Dlaczego podpis P-256 z SHA3-256 wywala politykę?
Podpis P-256 z SHA3-256 pada za każdym razem, gdy CMS digestAlgorithm mówi SHA3-256, podczas gdy signatureAlgorithm mówi ecdsa-with-SHA256. Każda połowa osobno jest akceptowalna dla P-256; razem nie zgadzają się co do tego, który hash był podpisany. EvaluatePadesSignatureAlgorithm mapuje każdy OID podpisu ECDSA, od ecdsa-with-SHA256 do ecdsa-with-SHA3-512, na implikowany przez niego digest, porównuje z zadeklarowanym digestAlgorithm i zwraca pcsInvalid przy każdej różnicy, zanim zajrzy do tabeli krzywych. Narzędzie podpisujące, które przeniosło hash na SHA3-256, a zostawiło zaszyty na twardo identyfikator podpisu, produkuje dokładnie taki plik, a poprawny weryfikator nie ma spójnego sposobu, by go czytać
EvaluatePadesSignatureAlgorithm jest publiczny i biera zwykły rekord, więc macierz można przypiąć w teście jednostkowym bez budowania PDF. Wywołania Assert poniżej to twoje własne kontrole testowe:
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); // rozjazd digestu
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); // zgrane, ale nie dla P-256
Info.CurveOid := '1.3.36.3.3.2.8.1.1.1'; // brainpoolP160r1
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // krzywa poza profilem
Info.CurveOid := '1.2.840.10045.3.1.7';
Info.PublicKeyParametersAreNamedCurve := False; // jawne parametry krzywej
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);
Info.PublicKeyAlgorithmOid := ''; // certyfikat podpisującego nie znaleziony
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;
Piąty przypadek dotyczy tego, jak certyfikat koduje swoją krzywą. RFC 5480 §2.1.1 pozwala, by ECParameters było OID-em nazwanej krzywej, krzywą niejawną (NULL) albo pełnym jawnym zestawem parametrów, i ta sama sekcja ogranicza certyfikaty PKIX do formy nazwanej. PDFium Component zwraca pcsInvalid dla certyfikatu id-ecPublicKey z parametrami brakującymi, niejawnymi albo jawnymi. Jawne parametry rozpisują liczbę pierwszą, współczynniki i punkt bazowy, co pozwala atakującemu opisać krzywą, która jedynie przypomina standardową, a kontroler, który by je przyjął, musiałby udowodnić, że liczby zgadzają się z nazwaną krzywą, zanim zaufa czemukolwiek innemu
Invalid, unsupported i indeterminate to trzy różne odpowiedzi
Trzy nieważne wartości AlgorithmPolicyStatus niosą różne znaczenia, a zlanie ich w jedno wiadro „nie przeszło” wyrzuca informację, której potrzebuje audytor. pcsInvalid znaczy, że rozpoznana kombinacja algorytmów jest zniekształcona albo rozjechana. Dodaje ppeiSignatureAlgorithmMismatch do TPadesValidationResult.Issues i popycha zagregowany IntegrityStatus do pcsInvalid, więc IsCryptographicallyValid zwraca False nawet, gdy wartość podpisu CMS się broni
pcsUnsupported znaczy, że krzywa albo digest są poza tym, co nazywa profil. To wynik o możliwościach i zostawia IntegrityStatus w spokoju. pcsIndeterminate znaczy, że PDFium Component odmówił zgadywania: certyfikatu podpisującego nie dało się przypiąć — typowo zbiór certyfikatów z kilkoma kandydatami i bez dokładnego dopasowania issuerAndSerialNumber — albo SignerInfo nie dało się sparsować na tyle głęboko, by przeczytać jego algorytmy. Po stronie RSA ta sama wartość oznacza digest, którego obecne zestawy nie przyjmują już dla nowych walidacji — omówione w ostatniej sekcji
EdDSA pokazuje, dlaczego status polityki i status kryptograficzny mieszkają w osobnych polach. Na systemie, którego weryfikator CMS nie umie sprawdzić Ed25519 ani Ed448, CmsSignatureStatus wraca jako pcsUnsupported, podczas gdy AlgorithmPolicyStatus może nadal być pcsValid, policzony z certyfikatu znalezionego w CMS. Kodowanie było poprawne; brakowało tylko weryfikatora. Zlanie obu zmuszałoby do wyboru między ogłoszeniem poprawnego podpisu za złamany a ogłoszeniem niesprawdzonego za dobry
W potoku przyjmującym odrzucaj automatycznie na pcsInvalid i na niczym innym. Traktowanie pcsUnsupported jako odrzucenia zamienia krzywą, której twoja polityka nigdy nie wpisała na listę, w oskarżenie o manipulację, a nadawca nie ma jak naprawić czegoś, co nigdy nie było połamane. Wyniki unsupported i indeterminate kieruj do człowieka, z OID-ami z AlgorithmInfo w załączeniu:
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, bez unieważnień
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;
Jeśli odrzucenie przyszło z Adobe Acrobata albo walidatora opartego o DSS, a nie z tej kontroli, przewodnik dlaczego walidatory odrzucają podpisy PAdES przechodzi przez inne częste przyczyny, od luk w ByteRange po zniekształcony czas podpisu /M
Co pcsValid zostawia tobie?
AlgorithmPolicyStatus = pcsValid poświadcza profil algorytmiczny i nic ponadto: zaakceptowaną krzywą z zgranym, poprawnie zakodowanym digestem dla ECDSA i EdDSA albo digest z aktualnego zestawu dla RSA. Dla podpisów RSA EvaluatePadesSignatureAlgorithm stosuje zestawy ETSI TS 119 312. MD2, MD4 i MD5 to pcsInvalid. SHA-1 i digesty 112-bitowe (SHA-224, SHA-512/224, SHA3-224) to pcsIndeterminate — wynik, którego EN 319 102-1 używa, gdy algorytm nie jest już uważany za niezawodny, a dowód wcześniejszego istnienia nie został oceniony — więc podpis SHA-1 zachowuje swój wynik integralności i idzie do ręcznego przeglądu. digestAlgorithm różniący się od digestu ustalonego przez OID podpisu, jak sha256WithRSAEncryption na digescie SHA-1, to pcsInvalid, i algorytm podpisu RSA na nie-RSA-owym kluczu podpisującego też. Brakujący certyfikat podpisującego daje pcsIndeterminate, a nieznane digesty albo OID-y spoza podpisowych z łuku PKCS #1 dają pcsUnsupported
Podpisy RSASSA-PSS dostają do tego kontrolę parametrów: parametry PSS muszą być obecne i poprawnie uformowane, ich hash musi równać się zadeklarowanemu digestAlgorithm, pole trailer musi mieć 1, a klucz certyfikatu ograniczony do PSS musi się z nimi zgadzać. Artykuł RFC 4055 RSASSA-PSS-params pokrywa, jak te parametry są kodowane po stronie podpisującej. Długość modulusa jest poza polityką, więc aplikacja, która chce podłogi 3072 bitów, wymusza ją sama. SHA-1 albo MD5 w digestAlgorithm podnosi też osobny problem ppeiBadDigestAlgorithm. Gdy podpisane atrybuty niosą atrybut cms-algorithm-protection z RFC 6211, jego dwa identyfikatory są porównywane z wartościami SignerInfo bajt po bajcie, a różnica podnosi ppeiCmsAlgorithmProtectionMismatch i wywala integralność; VerifyCmsAlgorithmProtection puszcza to porównanie na surowym blobie CMS
Matematyka podpisu, łańcuch certyfikatów i unieważnienia zostają przy CmsSignatureStatus, CertificateTrustStatus i RevocationStatus, które pochodzą z weryfikatora CMS. Czytaj pcsValid jako „profil algorytmiczny się broni” i nigdy jako „ten klucz jest wystarczająco mocny”. Dla aplikacji Delphi przyjmującej podpisane faktury, umowy albo paczki archiwalne cała konfiguracja mieści się w kilku liniach: puść ValidatePadesTrust, odrzucaj na ppeiSignatureAlgorithmMismatch, kieruj pcsUnsupported i pcsIndeterminate do recenzenta i wymuś własną podłogę rozmiaru klucza RSA
Ta sama biblioteka, która puszcza te kontrole, produkuje też podpisy PAdES, więc zespół może podpisywać P-384 albo Ed25519 i potwierdzić, że własne wyjście spełnia profil ISO/TS 32002, nim w ogóle dotrze do klienta. Edycje, wsparcie platform i potok podpisujący są opisane na stronie produktu PDFium Component for Delphi and Lazarus