Technischer Artikel

Digitale PDF-Signaturen in Delphi mit HotPDF verifizieren

Ein handgebauter PDF-Signatur-Verifizierer kann jede korrekt signierte Datei zurückweisen, die er bekommt, während er jedes Byte korrekt liest. Er zieht den CMS-Blob aus /Contents, findet die Signed-Attribute, hasht sie exakt so, wie sie gespeichert sind, und der RSA-Vergleich scheitert. Das Dokument ist in Ordnung. Der Ärger sitzt auf einem Byte: Im SignerInfo tragen die Attribute das Tag [0] IMPLICIT, ihr erstes Byte ist also 0xA0, während RFC 5652 §5.4 sagt, der Signierer habe die Signatur über denselben Inhalt in der Kodierung als DER SET OF berechnet, dessen erstes Byte 0x31 ist. Tauscht man dieses Byte vor dem Hashen, werden die „gefälschten“ Signaturen gültig

Diese Tag-Diskrepanz ist die erste von mehreren Stellen, an denen eine PDF-Signaturprüfung kippen kann, und die anderen sind weniger offensichtlich. Eine Signatur kann mathematisch perfekt sein auf einer Datei, die nach dem Signieren bearbeitet wurde. Sie kann perfekt sein auf einem Dokument, das ein Angreifer mit einem selbst gemachten Zertifikat neu signiert hat. Eine Vertragspartei schickt einen signierten Vertrag zurück, Ihr Workflow muss ihn ablegen, und jemand fragt: Ist das das Dokument, das Sie geschickt haben, Byte für Byte, signiert mit dem Zertifikat, für das es sich ausgibt? Wie man diese Signaturen überhaupt erzeugt, behandelt der Begleitartikel zum Erzeugen von PAdES-Signaturen in Delphi; dieser läuft in die andere Richtung und startet bei einer Datei, die schon signiert ankommt

Wo die signierten Bytes in einer PDF-Datei liegen

Eine PDF-Signatur schützt Byte-Bereiche der Datei auf der Platte, und HotPDF verifiziert gegen genau diese Bytes. ISO 32000-1 §12.8.1 legt einen CMS-SignedData-Container (RFC 5652) in den /Contents-Eintrag des Signature-Dictionary und daneben ein /ByteRange-Array, das die Regionen benennt, die die Signatur abdeckt. In der Praxis hält das Array zwei Offset-Länge-Paare: alles von Offset 0 bis zur /Contents-Hex-Zeichenkette und alles danach. Eine Signatur kann ihren eigenen Wert nicht abdecken, daher wird die Datei um dieses Loch herum gehasht

Die Konsequenz für jeden Verifizierer ist kompromisslos. Sie müssen das serialisierte Original hashen. Ein geparstes Objektmodell nützt hier nichts, denn schon das Zurückschreiben eines unangetasteten Dokuments produziert andere Bytes. HotPDF liest daher die Quelldatei, aus der das Dokument geladen wurde, oder einen TStream mit rohen Bytes, den Sie liefern, und hasht nie seine Speicherdarstellung

Diagramm: HotPDF verifiziert eine signierte PDF in Delphi, indem es die zwei ByteRange-Segmente der Quelldatei um das Contents-Loch neu hasht, während das geparste In-Memory-Modell nie gehasht wird, weil Reserialisierung Bytes ändert
Die Verifikation hasht die beiden ByteRange-Segmente der Quellbytes exakt wie serialisiert; ein geparstes In-Memory-Modell ist nutzlos, denn selbst ein unverändertes Dokument ergibt bei Reserialisierung andere Bytes

Das Loch selbst verdient Misstrauen. Bytes außerhalb der signierten Bereiche sind Bytes, die ein Reader trotzdem parst, und eine Lücke, die etwas anderes enthält als den Signaturwert, ist die Öffnung für eine Signature-Wrapping-Attacke. HotPDF prüft, dass /ByteRange bei Offset 0 beginnt, dass das zweite Segment nach dem Ende des ersten beginnt, dass beide innerhalb der Datei bleiben und dass die Lücke nichts enthält außer den Hex-Ziffern des eigenen /Contents dieser Signatur, optional mit dessen <- und >-Begrenzern. Eine Datei, die daran scheitert, liefert svInvalidByteRange, selbst wenn die CMS-Mathematik durchgegangen wäre

Lesen, wer signiert hat, bevor irgendetwas geprüft wird

GetLoadedSignatureInfo parst das Signature-Dictionary und seinen CMS-Container, ohne ein einziges Dokument-Byte zu hashen, also der Aufruf für den Fall, dass eine UI nur zeigen will, wer wann signiert hat. Signaturfelder werden ab 0 in Formularfeld-Reihenfolge indexiert, und GetLoadedSignatureFieldCount liefert ihre Anzahl. Ein Index hinter dem Ende wirft eine Ausnahme, statt einen leeren Record zurückzugeben, also loopen Sie über den Zähler

Der zurückgegebene THPDFSignatureInfo-Record trägt den Feldnamen, den /SubFilter, den Common Name des Signer-Zertifikats, Subject- und Issuer-DN, die Seriennummer in Hex, die Gültigkeitstage des Zertifikats und die Signierzeit, genommen aus dem Signed-Attribute, falls vorhanden, sonst aus dem /M-Eintrag des Dictionary. Er meldet außerdem die Digest- und Public-Key-Algorithmusnamen, die Strings /Reason, /Location und /ContactInfo sowie CertificateTimeValidity, das eine Signierzeit markiert, die außerhalb des Gültigkeitsfensters des Zertifikats liegt. Status bleibt svNotVerified: geparst, nicht geprüft. Die Signatur-API liegt hinter dem Compiler-Guard für Delphi 2009 und neuer

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;

Die kryptografische Prüfung mit VerifyLoadedSignatureEx fahren

VerifyLoadedSignatureEx läuft die volle Prüfung für ein dateigeladenes Dokument und liefert den gefüllten Info-Record im selben Aufruf. Es öffnet die Quelldatei erneut, validiert den /ByteRange, hasht die zwei Segmente mit dem Digest-Algorithmus des SignerInfo, vergleicht das Ergebnis mit dem Signed-Attribute messageDigest und verifiziert dann den Signaturwert über die DER-SET OF-Form der Signed-Attribute mit dem Public Key des eingebetteten Signer-Zertifikats. Trägt eine Signatur keine Signed-Attribute, läuft stattdessen eine RSA- oder ECDSA-Prüfung direkt über den Dokument-Hash

Die Algorithmus-Abdeckung folgt dem, was Signing-Werkzeuge tatsächlich emittieren. Digests umfassen SHA-1, SHA-256, SHA-384, SHA-512, die SHA-3-Familie und SHAKE256. Signaturen können RSA mit PKCS#1-v1.5- oder PSS-Padding sein, ECDSA auf benannten Kurven, oder Ed25519 und Ed448. Die ECDSA-Verifikation nutzt den Windows-CNG-Provider, und Ed25519 und Ed448 gehen über einen Plattform-Provider, der auf Windows CNG oder einer OpenSSL-Bibliothek sitzt, daher ist auf einer Maschine, auf der sich der nötige Provider nicht laden lässt, das Ergebnis svUnsupportedAlgorithm oder svCryptoProviderError statt eines Urteils über die Datei. VerifyLoadedSignatureWithOptions nimmt einen THPDFCMSVerifyOptions-Record, wenn Sie auf eine konkrete OpenSSL-Bibliothek zeigen oder Ihren eigenen THPDFSignatureProvider einstecken wollen

Pipeline von VerifyLoadedSignatureEx in HotPDF für Delphi: Quelldatei erneut öffnen, die ByteRange-Segmente hashen, mit dem CMS-Signed-Attribute messageDigest vergleichen, dann die Signatur mit dem Public Key des Signer-Zertifikats verifizieren, mit den Ergebnissen svValid, svDigestMismatch oder svSignatureInvalid
VerifyLoadedSignatureEx hasht die ByteRange-Segmente neu, vergleicht sie mit dem Signed-Attribute messageDigest und verifiziert die Signatur über den DER SET der Signed-Attribute, bevor es svValid oder einen konkreten Fehlerstatus meldet
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;

Zwei Parsing-Details erklären Scheitern, das von außen rätselhaft aussieht. Das erste ist das Umetikettieren aus dem Einleitungsabsatz: HotPDF hasht die Signed-Attribute mit ihrem führenden Byte umgeschrieben auf 0x31, genau wie RFC 5652 §5.4 es vorschreibt. Das zweite ist Padding. Signing-Werkzeuge reservieren ein festes Byte-Budget für /Contents, bevor die Signatur existiert, und füllen den ungenutzten Schwanz mit Nullen, daher stutzt der Verifizierer den dekodierten Blob auf die echte Länge seiner äußeren DER-SEQUENCE, bevor er ihn durchläuft. Eine Folge von Nullen am Ende von /Contents ist normal. Dieselbe Familie von ASN.1-Parsing-Gefahren, gesehen von der Zertifikatsimport-Seite, ist Thema des Artikels zu PKCS#12- und ASN.1-Security-Hardening in Delphi

Ein paar strengere Prüfungen laufen unterwegs. Der Digest-Algorithmus im SignerInfo muss mit der SignedData-Digest-Liste übereinstimmen, mit dem Signaturalgorithmus-Identifikator und jedem CMS-Algorithmusprotektions-Attribut, sonst ist der Status svDigestAlgorithmMismatch. Die Signed-Attribute müssen genau ein content-type-Attribut enthalten, das zum signierten Inhalt passt, sonst svMalformed. Trägt das CMS einen eingebetteten RFC-3161-Signatur-Zeitstempel, wird dieses Token gegen den Signaturwert verifiziert und in Info.Timestamp gemeldet; ein ETSI.RFC3161-Dokument-Zeitstempel wird ebenso gegen die gehashten Byte-Bereiche verifiziert

Was beweist svValid eigentlich?

svValid heißt zweierlei: Die Bytes, die der /ByteRange benennt, hashen auf den Wert, den der Signierer signiert hat, und diese Signatur verifiziert unter dem Public Key des Zertifikats, das im CMS-Container eingebettet ist. Byte-Integrität plus Schlüsselbindung. Es sagt nichts darüber, wem dieser Schlüssel gehört. Ein Angreifer, der einen Vertrag bearbeitet und ihn mit einem selbst erzeugten Zertifikat neu signiert, bekommt svValid, denn die Mathematik ist in sich konsistent, und im Feld SignerName steht, welchen Namen der Angreifer auch immer ins Zertifikat getippt hat

CoversWholeDocument deckt eine zweite Lücke ab. Inkrementelle Updates in PDF erlauben einem Writer, nach einer Signatur Content anzuhängen, ohne sie zu brechen, das ist gewollt und so funktionieren Multi-Signatur-Workflows. Das Flag wird während der Verifikation berechnet und ist nur true, wenn beide Segmente plus die /Contents-Lücke die ganze Datei spannen. SignedRevisionLength gibt die Größe des signierten Präfixes an, UnsignedTrailingBytes die Zahl der danach angehängten Bytes. Für eine Datei, die eine 48.000-Byte-Signaturrevision innerhalb einer 52.300-Byte-Datei deklariert, ist UnsignedTrailingBytes 4.300 und CoversWholeDocument false

Scope-Diagramm dessen, was svValid in der HotPDF-Signaturverifikation garantiert: ByteRange-Byte-Integrität und Schlüsselbindung, während Chain-Walking, Revocation und Trust-Stores zu einer separaten Trust-Prüfung gehören und CoversWholeDocument angehängte inkrementelle Updates markiert
svValid heißt Byte-Integrität plus Schlüsselbindung und nichts weiter; Chain-Walking, Revocation und Trust-Anchoren gehören zu einer separaten Trust-Prüfung, und CoversWholeDocument=false signalisiert nach dem Signieren angehängte Bytes

Eine Archiv-Eingangs-Pipeline sollte svValid mit CoversWholeDocument false nicht allein akzeptieren. Fahren Sie zuerst AnalyzeLoadedSignatureRevisions: Es klassifiziert jede nach der gewählten Signatur angehängte Revision, listet geänderte Feldnamen in ChangedFieldNames und meldet über DocMDPCompliant und FieldMDPCompliant, ob die Änderungen die DocMDP- und FieldMDP-Berechtigungen respektieren, die der Signierer gesetzt hat. Eine spätere Signatur in einem leeren Signaturfeld ist Routine. Eine Revision, die Seitenobjekte umschreibt, ist das nicht, und ChangeKinds in der Analyse ist es, was diese beiden Fälle trennt

Den Signierer gegen die eigenen Trust-Anchoren prüfen

Trust ist in HotPDF ein separater Aufruf, und diese Trennung ist die richtige Default-Wahl. VerifyLoadedSignatureWithTrust fährt zuerst dieselbe Byte-Range-Verifikation und liefert cvsSignatureInvalid, wenn sie scheitert, und baut dann einen Zertifikatspfad vom Signierer zu den Anchoren, die Sie in THPDFCertificateValidationOptions.TrustAnchors übergeben. Unterwegs wertet es Revocation-Nachweise aus: OCSP-Responses und CRLs aus dem DSS und den /VRI-Dictionarys des Dokuments werden automatisch gesammelt, und welche, die Sie in OCSPResponses oder CRLs liefern, kommen in denselben Pool

uses
  System.IOUtils;

var
  Options: THPDFCertificateValidationOptions;
  Info: THPDFSignatureInfo;
  Trust: THPDFCertificateValidationStatus;
begin
  Options := THPDFCertificateValidationOptions.Default;
  SetLength(Options.TrustAnchors, 1);
  // DER-kodiertes Root-Zertifikat; PEM-Dateien vor dem Laden konvertieren
  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;

Der Revocation-Mode ist eine Politik-Entscheidung. rvmBestEffort nutzt, welcher Nachweis eben da ist, und macht weiter, wenn keiner gefunden wird, während rvmRequire aus fehlendem Nachweis ein cvsRevocationUnknown macht. Für Verträge, die Jahre später auditiert werden, ist rvmRequire die sicherere Einstellung, vorausgesetzt, Ihre Signierer betten bei der Signatur OCSP- oder CRL-Daten ein; ohne diese Nachweise in der Datei kommt jedes Dokument als cvsRevocationUnknown zurück

Warum liefern stream-geladene Dokumente svSourceUnavailable?

Die dateibasierten Aufrufe, also das ein-Argument-VerifyLoadedSignature, VerifyLoadedSignatureEx und das dateibasierte VerifyLoadedSignatureWithTrust, brauchen, dass sich die Component merkt, aus welcher Datei das Dokument stammt. Ein mit LoadFromStream geladenes Dokument hat keinen Dateinamen zum Wiederöffnen. Dasselbe gilt nach dem Passwort-Reload für verschlüsselte Dokumente, beschrieben im Artikel zur AES-256-PDF-Verschlüsselung in Delphi, denn die Component wirft ihre Referenz auf die Quelldatei weg, sobald sie das Dokument entschlüsselt hat. In beiden Fällen liefern die dateibasierten Überladungen svSourceUnavailable und raten nicht

Die TStream-Überladungen nehmen die Originalbytes von dort, wo Sie sie aufbewahren: eine Datei, ein Speicherpuffer, ein Datenbank-Blob. Die Position des Streams wird nach dem Hashen wiederhergestellt, also kann derselbe Stream nacheinander an mehrere Signaturindizes gehen. VerifyAllLoadedSignatures, das nur true liefert, wenn mindestens ein Signaturfeld existiert und jedes Feld als svValid verifiziert, geht den dateibasierten Weg, daher liefert es auf einem stream-geladenen Dokument false, was auch immer die Signaturen enthalten. Loopen Sie stattdessen über die Stream-Überladung

function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Helper für den Reader, selbst zu ergänzen: ein stream-basiertes Pendant zu
// VerifyAllLoadedSignatures für mit LoadFromStream geladene Dokumente
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-Verifikation, Trust-Anchor-Pfadbau, PAdES-Signierung und AES-256-Verschlüsselung leben in derselben nativen VCL-Bibliothek für Delphi und C++Builder, mit RSA-Hashing und Padding-Prüfungen in Pascal-Code; Editionen, unterstützte IDE-Versionen und die breitere Featureliste stehen auf der HotPDF-Delphi-Component-Produktseite