Een eigenhandig geschreven PDF-handtekeningverificateur kan elk correct ondertekend bestand dat hij krijgt weigeren terwijl hij elke byte correct leest. Hij vist de CMS-blob uit /Contents, vindt de signed attributes, hasht ze exact zoals ze zijn opgeslagen, en de RSA-vergelijking faalt. Het document is prima. Het probleem is één byte: binnen de SignerInfo zijn de attributen getagd als [0] IMPLICIT, dus hun eerste byte is 0xA0, terwijl RFC 5652 §5.4 zegt dat de ondertekenaar de handtekening berekende over dezelfde content gecodeerd als een DER SET OF, waarvan de eerste byte 0x31 is. Wissel die byte vóór het hashen en de "vervalste" handtekeningen worden plotseling geldig
Die tag-mismatch is de eerste van verschillende plekken waar een PDF-handtekeningcontrole mis kan gaan, en de andere zijn minder voor de hand liggend. Een handtekening kan wiskundig perfect zijn op een bestand dat na het ondertekenen is bewerkt. Hij kan perfect zijn op een document dat een aanvaller opnieuw heeft ondertekend met een eigen certificaat. Een tegenpartij stuurt een ondertekend contract terug, je workflow moet hem archiveren, en iemand vraagt of dit het document is dat je hebt verzonden, byte voor byte, ondertekend door het certificaat waarop hij claimt. Het zelf produceren van die handtekeningen staat in het zusterartikel over het maken van PAdES-digitale handtekeningen in Delphi; dit artikel loopt de andere kant op, vertrekkend bij een bestand dat al ondertekend binnenkomt
Waar de ondertekende bytes in een PDF-bestand wonen
Een PDF-handtekening beschermt byteranges van het bestand op schijf, en HotPDF verifieert tegen exact die bytes. ISO 32000-1 §12.8.1 stopt een CMS SignedData-container (RFC 5652) in de /Contents-entry van de signature dictionary en zet er een /ByteRange-array naast die de gebieden benoemt die de handtekening dekt. In de praktijk bevat de array twee offset- en lengteparen: alles vanaf offset 0 tot aan de /Contents-hexstring, en alles daarna. Een handtekening kan zijn eigen waarde niet dekken, dus het bestand wordt rond dat gat gehasht
De consequentie voor elke verificateur is bot. Je moet de geserialiseerde originalen hashen. Een geparsed objectmodel is hier nutteloos, want zelfs een onaangeroerd document er weer uit schrijven produceert andere bytes. HotPDF leest daarom het bronbestand waarvan het document werd geladen, of een TStream met rauwe bytes die je aanlevert, en hasht nooit zijn in-memory weergave
Het gat zelf verdient wantrouwen. Bytes buiten de ondertekende bereiken zijn bytes die een reader nog kan parsen, en een gat dat iets anders bevat dan de handtekeningwaarde is de opening voor een signature-wrapping-aanval. HotPDF controleert dat /ByteRange op offset 0 begint, dat het tweede segment begint nadat het eerste eindigt, dat beide binnen het bestand blijven, en dat het gat niets bevat dan de hexadecimale cijfers van de eigen /Contents van deze handtekening, eventueel met zijn <- en >-scheidingstekens. Een bestand dat daarbij faalt geeft svInvalidByteRange terug, ook als de CMS-wiskunde er door was gekomen
Lezen wie er tekende voordat je iets controleert
GetLoadedSignatureInfo parst de signature dictionary en zijn CMS-container zonder ook maar één documentbyte te hashen, dus het is de aanroep voor een UI die alleen hoeft te tonen wie er tekende en wanneer. Handtekeningvelden worden geïndexeerd vanaf 0 in formulierveldvolgorde, en GetLoadedSignatureFieldCount geeft terug hoeveel er zijn. Een index voorbij het einde roept een exceptie op in plaats van een leeg record terug te geven, dus loop op het aantal
Het teruggegeven record THPDFSignatureInfo draagt de veldnaam, /SubFilter, de common name van het ondertekenaarscertificaat, de subject- en issuer-DN's, het serienummer in hex, de geldigheidsdatums van het certificaat en de ondertekentijd, gehaald uit het signed attribute als dat aanwezig is en anders uit de /M-entry van de dictionary. Hij meldt ook de digest- en public-key-algoritmenamen, de strings /Reason, /Location en /ContactInfo, en CertificateTimeValidity, dat een ondertekentijd aanvlagt die buiten de geldigheidsperiode van het certificaat valt. Status blijft svNotVerified: geparsd, niet gecontroleerd. De handtekening-API zit achter de compilervlag voor Delphi 2009 en later
var
Pdf: THotPDF;
Info: THPDFSignatureInfo;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
Pdf.LoadFromFile('signed-contract.pdf');
for I := 0 to Pdf.GetLoadedSignatureFieldCount - 1 do
begin
Info := Pdf.GetLoadedSignatureInfo(I);
Writeln('Field: ', Info.FieldName);
Writeln('Signer: ', Info.SignerName);
Writeln('Issuer: ', Info.IssuerDN);
Writeln('Key/hash: ', Info.PublicKeyAlgorithm, ' / ', Info.HashAlgorithm);
Writeln('SubFilter: ', Info.SubFilter);
if Info.CertificateTimeValidity = stvSigningTimeOutsideCertificate then
Writeln('Signing time is outside the certificate validity period');
end;
finally
Pdf.Free;
end;
end;
De cryptografische controle draaien met VerifyLoadedSignatureEx
VerifyLoadedSignatureEx draait de volledige controle voor een vanuit een bestand geladen document en geeft het gevulde inforecord in dezelfde aanroep terug. Hij heropent het bronbestand, valideert /ByteRange, hasht de twee segmenten met het digest-algoritme van de SignerInfo, vergelijkt het resultaat met het signed attribute messageDigest en verifieert daarna de handtekeningwaarde over de DER SET OF-vorm van de signed attributes met de public key van het ingesloten ondertekenaarscertificaat. Draagt een handtekening geen signed attributes, dan loopt een RSA- of ECDSA-controle direct over de documenthash
De algoritmendekking volgt wat ondertekentools werkelijk uitzenden. Digests omvatten SHA-1, SHA-256, SHA-384, SHA-512, de SHA-3-familie en SHAKE256. Handtekeningen kunnen RSA met PKCS#1 v1.5- of PSS-padding zijn, ECDSA op benoemde curves, of Ed25519 en Ed448. ECDSA-verificatie gebruikt de Windows CNG-provider, en Ed25519 en Ed448 lopen via een platformprovider die achter Windows CNG of een OpenSSL-bibliotheek zit, dus op een machine waar de benodigde provider niet kan worden geladen is het resultaat svUnsupportedAlgorithm of svCryptoProviderError in plaats van een oordeel over het bestand. VerifyLoadedSignatureWithOptions accepteert een record THPDFCMSVerifyOptions als je naar een specifieke OpenSSL-bibliotheek moet wijzen of je eigen THPDFSignatureProvider wilt inpluggen
var
Status: THPDFSignatureVerifyStatus;
Info: THPDFSignatureInfo;
begin
Status := Pdf.VerifyLoadedSignatureEx(0, Info);
case Status of
svValid:
if Info.CoversWholeDocument then
Writeln('Valid; signature covers the whole file')
else
Writeln('Valid; ', Info.UnsignedTrailingBytes,
' bytes were appended after signing');
svDigestMismatch:
Writeln('Document bytes changed after signing');
svSignatureInvalid:
Writeln('Hash matches, signature value does not verify');
svInvalidByteRange:
Writeln('ByteRange is malformed or the gap holds extra bytes');
svDigestAlgorithmMismatch:
Writeln('CMS digest algorithm identifiers disagree');
svUnsupportedAlgorithm, svCryptoProviderError:
Writeln('Cannot evaluate this key or digest here');
svMalformed:
Writeln('CMS container could not be parsed');
svSourceUnavailable:
Writeln('No source bytes; use the TStream overload');
else
Writeln('Status ', Ord(Status));
end;
end;
Twee parseerdetails verklaren misluktingen die van buiten mysterieus ogen. Het eerste is de retagging uit de openingsalinea: HotPDF hasht de signed attributes met hun leading byte herschreven naar 0x31, precies zoals RFC 5652 §5.4 voorschrijft. Het tweede is padding. Ondertekentools reserveren een vaste bytebudget voor /Contents voordat de handtekening bestaat en vullen de ongebruikte staart met nullen, dus de verificateur knipt de gedecodeerde blob bij naar de echte lengte van zijn buitenste DER SEQUENCE voordat hij erin afdaalt. Een reeks nullen aan het eind van /Contents is normaal. Dezelfde familie van ASN.1-parseergevaren, bekeken vanaf de certificaatimportkant, is het onderwerp van het artikel over PKCS#12- en ASN.1-security hardening in Delphi
Een paar strengere controles lopen onderweg mee. Het digest-algoritme in de SignerInfo moet overeenkomen met de digestlijst van de SignedData, de signature-algoritme-identificator en elk CMS algorithm-protection-attribuut, anders is de status svDigestAlgorithmMismatch. De signed attributes moeten exact één content-type-attribuut bevatten dat matcht met de ondertekende content, anders svMalformed. Draagt de CMS een ingesloten RFC 3161-signature timestamp, dan wordt dat token tegen de handtekeningwaarde gecontroleerd en gemeld in Info.Timestamp; een documenttimestamp ETSI.RFC3161 wordt op dezelfde manier tegen de gehashte byteranges gecontroleerd
Wat bewijst svValid eigenlijk?
svValid betekent twee dingen: de bytes die /ByteRange benoemt hashen naar de waarde die de ondertekenaar ondertekende, en die handtekening verifieert onder de public key van het certificaat dat in de CMS-container is ingesloten. Byte-integriteit plus sleutelbinding. Hij zegt niets over wie die sleutel bezit. Een aanvaller die een contract bewerkt en het opnieuw ondertekent met een zelfgegenereerd certificaat krijgt svValid, want de wiskunde is intern consistent, en het veld SignerName toont gewoon de naam die de aanvaller in het certificaat typte
CoversWholeDocument dekt een tweede gat. PDF-incrementele updates laten een writer content ná een handtekening toevoegen zonder haar te breken, wat ontwerp is en hoe workflows met meerdere handtekeningen werken. De vlag wordt tijdens de verificatie berekend en is alleen waar als beide segmenten plus het /Contents-gat het hele bestand bespannen. SignedRevisionLength geeft de grootte van het ondertekende voorvoegsel en UnsignedTrailingBytes het aantal bytes dat er na kwam. Voor een bestand dat een ondertekende revisie van 48.000 bytes claimt binnen een bestand van 52.300 bytes, is UnsignedTrailingBytes 4.300 en is CoversWholeDocument false
Een archiefintake-pipeline hoort svValid met CoversWholeDocument false niet op zichzelf te accepteren. Draai eerst AnalyzeLoadedSignatureRevisions: die classificeert elke revisie die na de gekozen handtekening werd toegevoegd, somt gewijzigde veldnamen op in ChangedFieldNames en meldt of de wijzigingen de DocMDP- en FieldMDP-machtigingen respecteren die de ondertekenaar instelde, via DocMDPCompliant en FieldMDPCompliant. Een latere handtekening in een leeg handtekeningveld is routine. Een revisie die paginaobjecten herschrijft is dat niet, en ChangeKinds in de analyse is wat die twee gevallen uit elkaar houdt
De ondertekenaar toetsen aan je eigen trust anchors
Vertrouwen is een aparte aanroep in HotPDF, en die splitsing is de juiste standaard. VerifyLoadedSignatureWithTrust draait eerst dezelfde byte-range-verificatie en geeft cvsSignatureInvalid terug als die faalt, en bouwt daarna een certificaatpad van de ondertekenaar naar de anchors die je in THPDFCertificateValidationOptions.TrustAnchors aanlevert. Hij evalueert onderweg revocatiebewijs: OCSP-responses en CRL's die in de DSS- en /VRI-dictionaries van het document staan worden automatisch verzameld, en alles wat je in OCSPResponses of CRLs aanlevert komt bij de voorraad
uses
System.IOUtils;
var
Options: THPDFCertificateValidationOptions;
Info: THPDFSignatureInfo;
Trust: THPDFCertificateValidationStatus;
begin
Options := THPDFCertificateValidationOptions.Default;
SetLength(Options.TrustAnchors, 1);
// DER-gecodeerd rootcertificaat; converteer PEM-bestanden vóór het laden
Options.TrustAnchors[0] := TFile.ReadAllBytes('company-root.cer');
Options.RevocationMode := rvmBestEffort;
Trust := Pdf.VerifyLoadedSignatureWithTrust(0, Options, Info);
if Trust = cvsTrusted then
Writeln('Signed by a certificate chaining to our root')
else
Writeln('Not trusted: ', Info.CertificateValidation.Issue);
end;
De revocatiemodus is een beleidskeuze. rvmBestEffort gebruikt welk bewijs er maar is en gaat door als er niets wordt gevonden, terwijl rvmRequire ontbrekend bewijs omzet in cvsRevocationUnknown. Voor contracten die jaren later worden geauditeerd, is rvmRequire de veiligere instelling, op voorwaarde dat je ondertekenaars OCSP- of CRL-data bij het ondertekenen insluiten; zonder dat bewijs in het bestand komt elk document terug als cvsRevocationUnknown
Waarom geven vanuit een stream geladen documenten svSourceUnavailable?
De bestandsgebonden aanroepen, dus de eenargument-VerifyLoadedSignature, VerifyLoadedSignatureEx en de bestandsgebonden VerifyLoadedSignatureWithTrust, vragen de component om te onthouden uit welk bestand het document kwam. Een document dat met LoadFromStream werd geladen heeft geen bestandsnaam om te heropenen. Hetzelfde geldt na het herladen met wachtwoord dat voor versleutelde documenten wordt gebruikt, beschreven in het artikel over AES-256-PDF-encryptie in Delphi, want de component laat zijn verwijzing naar het bronbestand vallen zodra hij het document heeft ontsleuteld. In beide gevallen geven de bestandsgebonden overloads svSourceUnavailable terug en gissen niet
De TStream-overloads nemen de originele rauwe bytes van waar je ze ook bewaarde: een bestand, een geheugenbuffer, een database-blob. De positie van de stream wordt na het hashen hersteld, dus dezelfde stream kan achter elkaar naar verschillende handtekeningindexen worden doorgegeven. VerifyAllLoadedSignatures, die alleen true teruggeeft als er ten minste één handtekeningveld bestaat en elk veld als svValid verifieert, loopt via het bestandsgebonden pad, dus op een vanuit een stream geladen document geeft hij false terug wat de handtekeningen ook bevatten. Loop in plaats daarvan over de stream-overload
function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Helper die de lezer zelf toevoegt: een stream-gebaseerd equivalent van
// VerifyAllLoadedSignatures voor documenten geladen met LoadFromStream
var
I, Count: Integer;
Info: THPDFSignatureInfo;
begin
Count := Pdf.GetLoadedSignatureFieldCount;
Result := Count > 0;
for I := 0 to Count - 1 do
if Pdf.VerifyLoadedSignature(I, Src, Info) <> svValid then
begin
Writeln(Info.FieldName, ': status ', Ord(Info.Status));
Exit(False);
end;
end;
Byte-range-verificatie, het bouwen van vertrouwenspaden naar trust anchors, PAdES-ondertekening en AES-256-encryptie wonen allemaal in dezelfde native VCL-bibliotheek voor Delphi en C++Builder, met RSA-hashing en paddingcontroles in Pascal-code; edities, ondersteunde IDE-versies en de bredere functielijst staan op de productpagina van HotPDF Delphi Component