Technisch artikel

ISO/TS 32002-beleid voor ECDSA en EdDSA in PDFium Delphi

Een P-256-sleutel kan een SHA-512-digest ondertekenen en de wiskunde protesteert niet. ECDSA kapt de hash af tot de linker 256 bits, de handtekening verifieert, en een CMS-verifier meldt de handtekeningswaarde als intact. ISO/TS 32002, de PDF 2.0-extensie die elliptic-curve- en EdDSA-handtekeningen in PDF bracht, staat die koppeling niet toe, want hij bindt elke curve aan de digest-breedtes die hij mag voeren. Dezelfde ondertekende factuur kan dus op de ene machine een cryptografische check passeren en op een validator die het PDF 2.0-algoritmeprofiel toepast falen, en beide uitspraken zijn correct over de vraag die elk stelde

Welke curve- en digest-paren ISO/TS 32002 accepteert

ISO/TS 32002 accepteert zes ECDSA-curven en twee EdDSA-schema's. PDFium Component checkt elke PDF-handtekening tegen dat profiel en meldt het oordeel in TPadesSignatureValidation.AlgorithmPolicyStatus, gekeyd op de curve-OID in het ondertekenaarscertificaat. De NIST-curven zijn streng: de digest moet dezelfde bitbreedte hebben als de curve, uit de SHA-2- of de SHA-3-familie. De Brainpool r1-curven zijn soepeler en accepteren hun eigen breedte of alles wat breder is:

  • P-256 (1.2.840.10045.3.1.7): alleen SHA-256 of SHA3-256
  • P-384 (1.3.132.0.34): alleen SHA-384 of SHA3-384
  • P-521 (1.3.132.0.35): alleen SHA-512 of SHA3-512
  • brainpoolP256r1 (1.3.36.3.3.2.8.1.1.7): elke SHA-2- of SHA-3-digest van 256 tot 512 bits
  • brainpoolP384r1 (1.3.36.3.3.2.8.1.1.11): SHA-2 / SHA-3 van 384 of 512 bits
  • brainpoolP512r1 (1.3.36.3.3.2.8.1.1.13): alleen SHA-512 of SHA3-512
Matrix van het ISO TS 32002-algoritmeprofiel in PDFium Component: P-256, P-384 en P-521 accepteren alleen matchende digest-breedtes, brainpoolP256r1 accepteert 256 tot 512 bits, brainpoolP384r1 accepteert 384 en 512, Ed25519 en Ed448 declareren SHA-512 en SHAKE256 met lengte 512, en mismatches geven ppeiSignatureAlgorithmMismatch terwijl curven buiten het profiel pcsUnsupported teruggeven
Zes ECDSA-curven en twee EdDSA-schema's kunnen passeren, en elke curve is gebonden aan de digest-breedtes die hij mag voeren; alles daarbuiten is ongeldig of niet-ondersteund, nooit stilletjes geaccepteerd

De asymmetrie trapt onderteken-tools die één digest kiezen en hem bij elke sleutel hergebruiken. Overal SHA-512 lijkt de voorzichtige keuze, en op brainpoolP256r1 wordt hij geaccepteerd. Op P-256 levert identieke configuratie pcsInvalid op: de curve zit in het profiel, de digest is sterk, en toch ligt het paar buiten de tabel. Een sleutel op een curve die het profiel nooit noemt, zoals brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) of secp256k1 (1.3.132.0.10), belandt in een andere categorie. Zolang zijn gedeclareerde digest en signature-algoritme met elkaar akkoord zijn, krijgt hij pcsUnsupported

EdDSA laat geen keuzes over, alleen coderingsregels

Ed25519 en Ed448 hebben geen curve-parameter en geen digest-optie, dus elke regel die PDFium Component op ze toepast gaat over hoe de CMS het algoritme declareert. RFC 8419 legt de digest vast. Een Ed25519-SignerInfo declareert SHA-512 (2.16.840.1.101.3.4.2.3) als zijn digestAlgorithm met het parametersveld afwezig. Een Ed448-SignerInfo die signed attributes draagt — wat elke PAdES-handtekening heeft — declareert id-shake256-len (2.16.840.1.101.3.4.2.18) met een INTEGER-parameter van exact 512. RFC 8410 voegt daar aan toe dat de signature-AlgorithmIdentifier (1.3.101.112 voor Ed25519, 1.3.101.113 voor Ed448) en de AlgorithmIdentifier van de publieke sleutel in het certificaat helemaal geen parameters dragen

Veel ASN.1-encoders plakken een expliciete NULL achter elke algoritme-OID, want RSA-identifiers hebben er altijd al één gehad, en de gewoonte overleeft het wanneer iemand Ed25519 op een bestaand ondertekenpad plakt. De sleutel is goed. De handtekeningswaarde is goed. De codering is het niet, en PDFium Component geeft pcsInvalid terug wanneer er op een van beide identifiers een parametersveld staat, wanneer de Ed25519-digest iets anders is dan parameterloze SHA-512, of wanneer de Ed448-digest niet id-shake256-len met 512 is. Een certificaat waarvan de sleutel-OID bij het andere EdDSA-schema hoort, of bij een ander algoritme, levert eveneens pcsInvalid op

Het algoritme-drietal uit de CMS lezen

De PDFium-engine leest het signature-dictionary, maar zijn publieke API verifieert de CMS niet en toont de curve van het ondertekenaarscertificaat niet. De op PDFium gebouwde PAdES-inspectielaag parst daarom de CMS SignedData (RFC 5652) zelf. InspectPadesSignatureAlgorithm leest de digestAlgorithm en signatureAlgorithm van de eerste SignerInfo, zoekt het ondertekenaarscertificaat in de certificates-verzameling en leest het sleutelalgoritme en de curve uit zijn SubjectPublicKeyInfo. Digest, signature-algoritme, sleutel plus curve: die drie waarden zijn wat het beleid beoordeelt

Een CMS-certificaatverzameling is ongeordend en houdt meestal het ondertekenaarscertificaat naast zijn uitgevende CA bij, en beide kunnen EC-sleutels op verschillende curven zijn, dus de eerste EC-certificaat pakken zou de CA laten beslissen welke curve de ondertekenaar volgens jou gebruikte. PDFium Component matcht issuer en serienummer uit issuerAndSerialNumber byte voor byte, bekijkt hoogstens 64 certificaten en valt alleen terug op "het enige certificaat dat er is" wanneer de verzameling exact één parseerbaar certificaat bevat. Elke andere uitkomst laat de sleutelvelden van het record leeg

Hoe de PDFium Component een PDF-handtekening-algoritmedrietal inspecteert: InspectPadesSignatureAlgorithm leest de digestAlgorithm en signatureAlgorithm van de eerste SignerInfo in de CMS, pint het ondertekenaarcertificaat vast via een exacte issuerAndSerialNumber-match onder hooguit 64 kandidaten, leest de SubjectPublicKeyInfo voor de curve, en EvaluatePadesSignatureAlgorithm geeft de AlgorithmPolicyStatus terug
PDFium zelf verifieert de CMS niet en legt de ondertekenaar-curve niet bloot, dus de PAdES-laag parseert de SignedData en houdt elke ruwe OID in het record vast voor een verklaarbare afwijzing

TPdf.ValidatePades draait het beleid tijdens zijn compliance-pass, eerst tegen het certificaat dat in de CMS gevonden wordt. Daarna verifieert hij de handtekening met de CMS-verifier voor het platform: standaard Windows CryptoAPI op Windows, of een OpenSSL- of macOS Keychain-verifier geregistreerd via ConfigureSslCmsVerifier of ConfigureKeychainCmsVerifier. Wanneer de verifier meldt welk certificaat hij echt gebruikte, draait het beleid nog een keer op dat certificaat en vervangt zijn resultaat het eerste. TPdf.ValidatePadesTrust in de Enterprise-editie volgt dezelfde volgorde en bouwt daarbij ook de keten op en checkt op verzoek de revocatie. De rauwe inputs belanden in TPadesSignatureAlgorithmInfo, dat deze listing voor elke handtekening in een bestand print:

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;

Die flags leggen meestal al uit waarom iets wordt geweigerd voordat iemand een ASN.1-dump opent. DigestParameterBits toont de Ed448-lengte, SignatureParametersPresent legt de verdwaalde NULL bloot, en PublicKeyParametersAreNamedCurve dekt de curve-codering die in de volgende sectie wordt besproken. Een lege PublicKeyAlgorithmOid betekent dat het ondertekenaarscertificaat nooit is vastgepind

Waarom zakt een P-256-handtekening met SHA3-256 door het beleid?

Een P-256-handtekening met SHA3-256 faalt telkens wanneer de CMS-digestAlgorithm SHA3-256 zegt terwijl de signatureAlgorithm ecdsa-with-SHA256 zegt. Elke helft is op zichzelf acceptabel voor P-256; samen zijn ze het oneens over welke hash er werd ondertekend. EvaluatePadesSignatureAlgorithm mapt elke ECDSA-signature-OID, van ecdsa-with-SHA256 tot ecdsa-with-SHA3-512, op de digest die hij impliceert, vergelijkt die met de gedeclareerde digestAlgorithm en geeft pcsInvalid terug bij elk verschil nog voordat hij naar de curvetabel kijkt. Een onderteken-tool die zijn hash naar SHA3-256 verplaatst maar een hardgecodeerde signature-identifier vasthoudt, produceert exact dit bestand, en een conforme verifier heeft geen consistente manier om hem te lezen

EvaluatePadesSignatureAlgorithm is publiek en neemt een kaal record, dus de matrix kan in een unittest worden vastgepind zonder een PDF te bouwen. De Assert-aanroepen hieronder zijn je eigen testchecks:

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 matcht niet

  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);  // congruent, maar niet voor P-256

  Info.CurveOid := '1.3.36.3.3.2.8.1.1.1';                 // brainpoolP160r1
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // curve buiten het profiel

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

  Info.PublicKeyAlgorithmOid := '';                        // ondertekenaarscertificaat niet gevonden
  Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;

Het vijfde geval gaat over hoe het certificaat zijn curve codeert. RFC 5480 §2.1.1 laat ECParameters een named curve-OID zijn, een impliciete curve (NULL) of een volledige expliciete parameterset, en dezelfde sectie beperkt PKIX-certificaten tot de named-vorm. PDFium Component geeft pcsInvalid terug voor een id-ecPublicKey-certificaat met ontbrekende, impliciete of expliciete parameters. Expliciete parameters spellen de priemgetallen, coëfficiënten en het basispunt uit, wat een aanvaller in staat stelt een curve te beschrijven die alleen maar lijkt op een standaardcurve, en een checker die ze zou accepteren moet eerst bewijzen dat de getallen op een named curve uitkomen voordat hij iets anders vertrouwt

Invalid, unsupported en indeterminate zijn drie verschillende antwoorden

De drie niet-geldige waarden van AlgorithmPolicyStatus dragen verschillende betekenissen, en ze samenvouwen tot één "failed"-categorie gooit de informatie weg die een auditor nodig heeft. pcsInvalid betekent dat een herkende algoritme-combinatie misvormd of niet congruent is. Hij voegt ppeiSignatureAlgorithmMismatch toe aan TPadesValidationResult.Issues en duwt de aggregaat-IntegrityStatus naar pcsInvalid, dus IsCryptographicallyValid geeft False terug zelfs wanneer de CMS-handtekeningswaarde klopt

pcsUnsupported betekent dat de curve of digest buiten valt wat het profiel noemt. Dat is een capabiliteitsuitspraak en hij laat IntegrityStatus met rust. pcsIndeterminate betekent dat PDFium Component weigerde te gokken: het ondertekenaarscertificaat kon niet worden vastgepind, typisch een certificaatverzameling met meerdere kandidaten en geen exacte issuerAndSerialNumber-match, of de SignerInfo kon niet ver genoeg worden geparsed om zijn algoritmes te lezen. Aan de RSA-kant markeert dezelfde waarde een digest die huidige suites niet langer accepteren voor nieuwe validaties, zoals behandeld in de laatste sectie

EdDSA laat zien waarom de beleidsstatus en de cryptografische status in aparte velden wonen. Op een systeem waarvan de CMS-verifier Ed25519 of Ed448 niet kan checken, komt CmsSignatureStatus terug als pcsUnsupported terwijl AlgorithmPolicyStatus nog steeds pcsValid kan zijn, berekend uit het certificaat dat in de CMS gevonden werd. De codering was correct; alleen de verifier ontbrak. De twee samenvoegen zou dwingen te kiezen tussen een goed geformuleerde handtekening kapot noemen en een ongecheckte goedkeuren

Beslispad van EvaluatePadesSignatureAlgorithm in PDFium Component: een digest-mismatch zet pcsInvalid en ppeiSignatureAlgorithmMismatch, een named curve buiten het ISO TS 32002-profiel zoals brainpoolP160r1 zet pcsUnsupported, een ondertekenaarscertificaat dat niet vastgepind kan worden zet pcsIndeterminate, en de RSA-tak past de ETSI TS 119 312 digest-suites toe, waarbij de sleutelgrootte nog bij de toepassing ligt
De drie niet-geldige statussen betekenen verschillende dingen: invalid is het bewijs van een kapotte combinatie, unsupported is een capabiliteitsuitspraak, en indeterminate betekent dat de code weigerde te gokken

Voor een intakepijplijn: weiger automatisch op pcsInvalid en op niets anders. pcsUnsupported als weigering behandelen maakt van een curve die je beleid nooit heeft opgevoerd een beschuldiging van manipulatie, en de afzender kan niet repareren wat nooit kapot was. Stuur unsupported- en indeterminate-resultaten naar een mens, met de OIDs uit AlgorithmInfo erbij:

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, geen revocatie
    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;

Als de weigering van Adobe Acrobat of een op DSS gebaseerde validator komt in plaats van van deze check, dan loopt de gids waarom validators PAdES-handtekeningen weigeren langs de andere veel voorkomende oorzaken, van ByteRange-gaten tot een misvormde /M-ondertekentijd

Wat laat pcsValid aan jou over?

AlgorithmPolicyStatus = pcsValid certificeert het algoritmeprofiel en niets meer: een goedgekeurde curve met een congruente, correct gecodeerde digest voor ECDSA en EdDSA, of een digest uit een actuele suite voor RSA. Voor RSA-handtekeningen past EvaluatePadesSignatureAlgorithm de ETSI TS 119 312-suites toe. MD2, MD4 en MD5 zijn pcsInvalid. SHA-1 en de 112-bit digests (SHA-224, SHA-512/224, SHA3-224) zijn pcsIndeterminate, de uitkomst die EN 319 102-1 gebruikt wanneer een algoritme niet langer als betrouwbaar geldt en geen bewijs van vroegere bestaan werd beoordeeld, dus een SHA-1-handtekening houdt zijn integriteitsuitspraak en gaat naar review. Een digestAlgorithm die verschilt van de digest die de signature-OID vastlegt, zoals sha256WithRSAEncryption over een SHA-1-digest, is pcsInvalid, en een RSA-signature-algoritme op een niet-RSA-ondertekenaarssleutel ook. Een ontbrekend ondertekenaarscertificaat geeft pcsIndeterminate, en onbekende digests of niet-signature-OIDs uit de PKCS #1-arc geven pcsUnsupported

RSASSA-PSS-handtekeningen krijgen daarbovenop een parametercheck: de PSS-parameters moeten aanwezig en goed gevormd zijn, hun hash moet gelijk zijn aan de gedeclareerde digestAlgorithm, het trailer-veld moet 1 zijn, en een PSS-beperkte certificaatsleutel moet ermee akkoord gaan. Het artikel over RFC 4055 RSASSA-PSS-params behandelt hoe die parameters aan de ondertekenkant worden gecodeerd. Moduluslengte valt buiten het beleid, dus een toepassing die een vloer van 3072 bits wil, dwingt die zelf af. SHA-1 of MD5 in de digestAlgorithm heft bovendien het aparte issue ppeiBadDigestAlgorithm op. Wanneer de signed attributes het attribuut cms-algorithm-protection uit RFC 6211 dragen, worden zijn twee identifiers byte voor byte vergeleken met de SignerInfo-waarden, en een verschil heft ppeiCmsAlgorithmProtectionMismatch op en laat integriteit falen; VerifyCmsAlgorithmProtection draait die vergelijking op een rauwe CMS-blob

De handtekeningswiskunde, de certificaatketen en revocatie blijven bij CmsSignatureStatus, CertificateTrustStatus en RevocationStatus, die uit de CMS-verifier komen. Lees pcsValid als "het algoritmeprofiel houdt stand" en nooit als "deze sleutel is sterk genoeg". Voor een Delphi-toepassing die ondertekende facturen, contracten of archiefpakketten accepteert, past de hele opzet in een paar regels: draai ValidatePadesTrust, weiger op ppeiSignatureAlgorithmMismatch, routeer pcsUnsupported en pcsIndeterminate naar een reviewer, en dwing je eigen RSA-sleutelgrootte-vloer af

Dezelfde bibliotheek die deze checks draait, produceert ook PAdES-handtekeningen, dus een team kan met P-384 of Ed25519 ondertekenen en bevestigen dat zijn eigen uitvoer aan het ISO/TS 32002-profiel voldoet voordat het ooit een klant bereikt. Edities, platformondersteuning en de ondertekenpijplijn staan beschreven op de productpagina van PDFium Component for Delphi and Lazarus