Artykuł techniczny

Polityka ECDSA i EdDSA wg ISO/TS 32002 w Delphi

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
Macierz profilu algorytmicznego ISO TS 32002 w PDFium Component: P-256, P-384 i P-521 przyjmują tylko pasujące szerokości digestu, brainpoolP256r1 przyjmuje 256 do 512 bitów, brainpoolP384r1 przyjmuje 384 i 512, Ed25519 i Ed448 deklarują SHA-512 i SHAKE256 z długością 512, a rozjazdy podnoszą ppeiSignatureAlgorithmMismatch, podczas gdy krzywe poza profilem zwracają pcsUnsupported
Przejść może sześć krzywych ECDSA i dwa schematy EdDSA, a każda krzywa jest związana z szerokościami digestu, które może nieść; wszystko inne jest invalid albo unsupported, nigdy po cichu przyjęte

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

Jak PDFium Component inspekcjonuje trójkę algorytmiczną podpisu PDF: InspectPadesSignatureAlgorithm czyta digestAlgorithm i signatureAlgorithm pierwszego SignerInfo w CMS, przypina certyfikat podpisującego przez dokładne dopasowanie issuerAndSerialNumber wśród co najwyżej 64 kandydatów, czyta SubjectPublicKeyInfo dla krzywej, a EvaluatePadesSignatureAlgorithm zwraca AlgorithmPolicyStatus
Sam PDFium ani nie weryfikuje CMS, ani nie wystawia krzywej podpisującego, więc warstwa PAdES parsuje SignedData i trzyma każdy surowy OID w rekordzie, żeby odrzucenie dawało się wyjaśnić

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

Ścieżka decyzyjna EvaluatePadesSignatureAlgorithm w PDFium Component: rozjazd digestu ustawia pcsInvalid i ppeiSignatureAlgorithmMismatch, nazwana krzywa poza profilem ISO TS 32002 taka jak brainpoolP160r1 ustawia pcsUnsupported, certyfikat podpisującego, którego nie da się przypiąć, ustawia pcsIndeterminate, a gałąź RSA stosuje zestawy digestów ETSI TS 119 312, z rozmiarem klucza nadal po stronie aplikacji
Trzy statusy spoza valid znaczą różne rzeczy: invalid jest dowodem połamanej kombinacji, unsupported jest wynikiem o możliwościach, a indeterminate znaczy, że kod odmówił zgadywania

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