Technischer Artikel

CMS-Signaturen in Delphi parsen: DER-Grenzen und OID-Bögen

Kodieren Sie die OID 2.999.3 so, wie ein schneller DER-Helfer es oft tut, mit den ersten beiden Bögen in einem Byte gepackt, und der Dekoder meldet 1.15.3 zurück. Zwei weitere Fehler beim CMS-Lesen verhalten sich genauso: eine Zertifikatsanzahl, die die Bytes des Nachbarn mitverschluckt, und ein Signer, der über eine Seriennummer aus dem falschen Feld gematcht wird. In der PDF Library for Delphi (PDFlibPas) geht der Signatur-Reader das CMS in /Contents als puren DER durch, begrenzt jeden verschachtelten Lesevorgang durch sein Elternelement, schneidet das Padding an der vom CMS deklarierten Länge ab und kodiert den kombinierten ersten OID-Bogen Base-128

Ganz schön viel Code braucht die Leseseite einer Signatur. Long-Term-Validation muss das Signaturzertifikat und seine Issuer aus einer bestehenden Signatur herausziehen, bevor sie überhaupt Sperrdaten nachladen kann. Ein Prüfbericht muss sagen, wer unterschrieben hat. Ein Lazarus-Build unter Linux hat keine Windows-Message-Funktionen als Rückfallebene, weil die Plattform-CMS-Aufrufe außerhalb von Windows auf Fehler gestubbt sind — deshalb macht PDFlibPas diesen Durchlauf in purem Pascal und verzichtet komplett auf CryptoAPI

Signaturzertifikate aus einer signierten PDF lesen

Fünf TPDFlib-Methoden decken die komplette Leseseite ab, und jede nimmt InputFile, Password, FieldName. Jeder Aufruf öffnet die Datei schreibgeschützt, antwortet und schließt sie wieder — es gibt also keinen Dokumentzustand zu verwalten. GetSignatureEmbeddedCertificateCount und GetSignatureEmbeddedCertificateDER zählen das CMS-Zertifikats-Set in Kodierreihenfolge durch. GetSignatureSignerCertificateDER liefert das Zertifikat, das ein bestimmtes SignerInfo erzeugt hat. GetSignatureCertificateChainLength und GetSignatureCertificateChainDER laufen von diesem Signer hinauf zum entferntesten Issuer, den die Signatur mitbringt. Alle Indizes sind nullbasiert

Die Ergebnisse kommen als AnsiString zurück, und Sie sollten sie auch so halten. Ein DER-Blob, der durch string oder eine TStrings geschoben wird, geht durch eine Zeichensatzkonvertierung, und die Bytes, die hinten wieder herauskommen, parsen nicht mehr. Deshalb hält die Bibliothek Zertifikatslisten auch als Arrays von AnsiString und liefert URL-Listen als Text mit einer Adresse pro Zeile: Adressen sind reines ASCII und überleben die Konvertierung, Zertifikatsbytes nicht

uses
  SysUtils, Classes, PDFlibrary, PDFlibEnterprise;

procedure SaveDer(const FileName: string; const Der: AnsiString);
var
  Fs: TFileStream;
begin
  Fs := TFileStream.Create(FileName, fmCreate);
  try
    if Der <> '' then
      Fs.WriteBuffer(Der[1], Length(Der));
  finally
    Fs.Free;
  end;
end;

const
  Src = 'contract-signed.pdf';
  Field = 'Signature1';
var
  Pdf: TPDFlibEnterprise;
  Count, ChainLen, I: Integer;
  SignerDer, LastDer: AnsiString;
begin
  Pdf := TPDFlibEnterprise.Create;
  try
    Count := Pdf.GetSignatureEmbeddedCertificateCount(Src, '', Field);
    WriteLn(Field, ': ', Count, ' certificate(s) in the CMS');
    for I := 0 to Count - 1 do
      SaveDer(Format('embedded-%d.cer', [I]),
        Pdf.GetSignatureEmbeddedCertificateDER(Src, '', Field, I));

    SignerDer := Pdf.GetSignatureSignerCertificateDER(Src, '', Field, 0);
    if SignerDer = '' then
      raise Exception.CreateFmt('%s: signer certificate missing or not matched', [Field]);
    SaveDer('signer.cer', SignerDer);

    ChainLen := Pdf.GetSignatureCertificateChainLength(Src, '', Field, 0);
    for I := 0 to ChainLen - 1 do
      SaveDer(Format('chain-%d.cer', [I]),
        Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, I));
    if ChainLen > 0 then
    begin
      // der letzte Kettenlink kann noch einen Issuer haben, den die Signatur nicht eingebettet hat
      LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
      WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
    end;
  finally
    Pdf.Free;
  end;
end;

Zwei Ergebnisse in diesem Programm sind leicht zu missdeuten. Eine 0 sagt für sich genommen sehr wenig aus: Ein fehlendes Feld, ein falsches Passwort, ein Blob, der kein DER ist, und ein SignedData, das das optionale Zertifikats-Set schlicht weglässt, liefern alle 0 oder einen leeren String zurück. Loggen Sie den Feldnamen neben der Zahl mit, wie das Beispiel es tut, sonst debuggen Sie am Ende die falsche Datei. Das zweite ist die Kettenlänge. Der Kettenbauer nutzt nur Zertifikate, die in der Signatur eingebettet sind, also ist eine Kette, die vor einem selbst ausgestellten Root endet, normal. Signieren Sie eine Datei mit unserem Demo-Zertifikat, das eine Test-CA ausstellt, und GetSignatureCertificateChainLength liefert 1, weil diese CA nicht im CMS sitzt. Den nächsten Hop liefern die Adressen, die GetCertificateIssuerURLs meldet — ein Aufruf, der wie der Rest der Long-Term-Validation-API zur Enterprise Edition gehört

Der Signer-Match selbst behandelt beide Formen von SignerIdentifier, die RFC 5652 §5.3 erlaubt. issuerAndSerialNumber ist die, die jeder testet. Die [0] subjectKeyIdentifier-Form, ein implizit getaggter OCTET STRING mit Tag $80, ist der Zweig, den handgeschriebene Reader am häufigsten vergessen, und Signer, die sich über den Key-Identifier identifizieren, geben ihn tatsächlich aus. Wenn die Issuer-und-Seriennummer-Form verwendet wird, müssen beide Hälften matchen: Eine Seriennummer ist nur innerhalb eines Issuers eindeutig, ein Match allein über die Seriennummer kann also bei einem Zertifikat einer anderen CA landen

Wie viel von /Contents ist überhaupt das CMS?

Nur der Präfix, den die äußere SEQUENCE abdeckt, gehört zum CMS, und PLTrimCMSPadding in Unit PDFlibCMSRead schneidet alles dahinter ab. Der Grund ist die Reihenfolge. ISO 32000-1 §12.8.1 verlangt, dass das /ByteRange feststeht, bevor der Signaturwert existiert, also reserviert ein Signer den /Contents-Hex-String vorab, bemisst ihn großzügig und füllt den ungenutzten Schwanz mit Nullen, sobald das CMS feststeht. Eine typische signierte Datei trägt daher eine Reihe nachlaufender Nullen hinter dem CMS, so lang wie das, was der Signer überreserviert hat

PLTrimCMSPadding liest das erste TLV, verlangt Tag $30 und gibt die Bytes bis zum Ende dieses Elements zurück. Füttern Sie es mit 30 03 02 01 00 00 00 00, bekommen Sie die ersten fünf Bytes zurück; füttern Sie es mit 'not der', kommt ein leerer String heraus. Diese oberste Ebene ist der einzige Ort, an dem nachlaufende Bytes legal sind. Eine strenge Regel, das Element müsse den ganzen Buffer konsumieren, würde gewöhnliche signierte Dateien abweisen, während eine lasche Regel „was übrig bleibt, ist egal“ auf jeder Tiefe genau dazu führt, dass verschachtelte Felder Bytes lesen, die ihnen nicht gehören

PDFlibPas PLTrimCMSPadding liest das erste TLV des reservierten /Contents-Hex-Strings, verlangt Tag $30 und schneidet das Null-Padding an der Länge, die die äußere SEQUENCE deklariert; beginnt der Buffer nicht mit einer wohlgeformten SEQUENCE, kommt ein leeres Ergebnis zurück
Nachlaufende Bytes sind nur auf der obersten Ebene legal, wo der reservierte Slot für /ByteRange fest bleiben muss — tiefere Lesevorgänge bekommen stattdessen die Elternelement-Regel

Warum braucht ein DER-Reader das End-Offset des Elternelements?

Weil ein verschachteltes Element nur gültig ist, wenn es innerhalb seines Elternelements endet, und eine Prüfung gegen das Ende des Buffers das nicht beweist. DERReadTLV in PDFlibASN1 begrenzt jedes Element gegen den gesamten String, weist Längen zurück, die über das Ende hinauslaufen würden, und macht die Arithmetik als Subtraktion, sodass eine gefälschte Vier-Byte-Länge von $7FFFFFFF die Prüfung nicht negativ überlaufen lassen kann. Das ist Memory Safety. Darüber, ob das Element dorthin gehört, wo es gefunden wurde, sagt das nichts

Stellen Sie sich ein SignerInfo vor, dessen issuerAndSerialNumber 40 Bytes deklariert, während der Issuer Name darin 60 beansprucht. Jedes Byte liegt weiterhin im Buffer, also akzeptiert ein bufferbegrenzter Reader den Name, liest dann die „Seriennummer“ aus dem Digest-Algorithmus, der folgt, und vergleicht dieses Paar dann gegen die eingebetteten Zertifikate. Nichts schlägt fehl. Manchmal geht der Vergleich sogar bei dem falschen Zertifikat auf

PDFlibPas begrenzt jeden verschachtelten DER-Lesevorgang durch sein Elternelement: Ein 60-Byte-Issuer-Name innerhalb eines 40-Byte-issuerAndSerialNumber wird vom alten bufferbegrenzten DERReadTLV akzeptiert, der dann die Seriennummer aus digestAlgorithm liest, während ReadTLVWithin jedes Element zurückweist, das hinter ParentEnd endet
Innerhalb des Buffers ist Memory Safety, innerhalb des Elternelements ist Korrektheit — PDFlibPas reicht das Parent-End-Offset durch jede CMS-Ebene durch, damit eine feindliche Länge keine Nachbar-Bytes ausleihen kann

Der CMS-Walker von PDFlibPas trägt die Endposition des Elternelements in jeden Lesevorgang hinein, von ContentInfo (RFC 5652 §3) über den [0] EXPLICIT-Wrapper und die SignedData-Felder (§5.1) bis zu jedem SignerInfo mit seinem Identifier, und hinunter zu den tbsCertificate-Feldern, die beim Signer-Abgleich gelesen werden. Wenn Sie auf dem öffentlichen DERReadTLV Ihren eigenen Walker schreiben, etwa für einen Timestamp-Token oder eine OCSP-Antwort, ist dasselbe Muster ein Dutzend Zeilen:

uses
  PDFlibASN1;

// Ein einziger Kind-Lesevorgang, abgewiesen, wenn das Kind hinter dem Elternelement enden würde.
function ReadChild(const Data: AnsiString; ParentEnd: Integer;
  var Offset: Integer; out Tag: Byte; out Start, Len: Integer): Boolean;
begin
  Result := False;
  if (Offset < 1) or (Offset >= ParentEnd) then
    Exit;                          // nichts mehr im Elternelement übrig
  if not DERReadTLV(Data, Offset, Tag, Start, Len) then
    Exit;
  Result := Offset <= ParentEnd;  // Offset steht jetzt eins hinter dem Kind
end;

// Zählt die SEQUENCE-Mitglieder eines SET OF, dessen Inhalt sich über
// Data[SetStart .. SetEnd - 1] erstreckt. Stoppt beim ersten Mitglied, das überläuft.
function CountSequences(const Data: AnsiString; SetStart, SetEnd: Integer): Integer;
var
  Offset, Start, Len: Integer;
  Tag: Byte;
begin
  Result := 0;
  Offset := SetStart;
  while Offset < SetEnd do
  begin
    if not ReadChild(Data, SetEnd, Offset, Tag, Start, Len) then
      Break;                       // kein Resync: die Ausrichtung ist weg
    if Tag = $30 then
      Inc(Result);
  end;
end;

Beachten Sie das Break. Innerhalb des Zertifikats-Sets und des signerInfos-Sets macht PLExtractCMSCertificates dasselbe: Ein Element, das über das Set-Ende hinausläuft, stoppt die Schleife, und die Funktion gibt die bereits akzeptierten Zertifikate zurück. Sie klebt die folgenden crls- oder signerInfos-Bytes nie an das letzte Zertifikat an. Das schlechte Element zu überspringen und weiterzumachen ist verlockend und die falsche Entscheidung. Sobald eine deklarierte Länge falsch ist, weiß der Reader nicht mehr, wo das nächste Element beginnt, und jede „Wiederherstellung“ ist ein Ratespiel, welches Byte wie ein Tag aussieht. Mit angehaltener Schleife liefert ein Set, dessen zweites Zertifikat um ein einziges Byte überläuft, eine Anzahl von 1 und die Bytes des ersten Zertifikats exakt so, wie sie kodiert wurden

Wie kann 2.999.3 als 1.15.3 herauskommen?

Die ersten beiden Bögen einer OID verschmelzen zu einem Subidentifier, und dieser Subidentifier wird wie jeder andere Bogen Base-128 kodiert — er ist kein einzelnes Byte. X.690 §8.19.4 definiert den Wert als 40 * arc1 + arc2. Ein Encoder, der ihn mit Byte(...) schreibt, ist bis 127 korrekt, was 2.47 entspricht. Bei 2.999 ist die Summe 1079, ein Byte-Cast behält 55, und 55 dekodiert als 1.15. Der Identifier benennt jetzt einen anderen Zweig des Baums, und niemand beschwert sich. Werte von 128 bis 255 brechen anders: Der Cast gibt ein Byte mit gesetztem Continuation-Bit aus, und der Dekoder schluckt den nächsten Bogen hinein

Der Shortcut überlebt im realen Code so lange, weil die meisten PKI-Identifier die Grenze nie erreichen. Alles unter 1.2.840, 2.5.29 und 0.4.0 hat einen kombinierten ersten Wert, der deutlich unter 128 liegt, also übt eine Testsuite, die nur aus üblichen Signatur-OIDs besteht, das zweite Byte nie aus. Nur die joint-iso-itu-t-Bögen ab 2.48 aufwärts überqueren die Linie. In PDFlibPas bedient eine einzige Funktion, DER_OID, den Encoder für signed attributes, das Lookup in DERFindExtensionByOID und die SignedData-Content-Type-Prüfung, sodass Schreiben und Matching nicht auseinanderdriften können. Testvektoren gehören auf beide Seiten der Grenze:

uses
  SysUtils, PDFlibASN1;

function Hex(const S: AnsiString): string;
var
  I: Integer;
begin
  Result := '';
  for I := 1 to Length(S) do
    Result := Result + IntToHex(Byte(S[I]), 2) + ' ';
  Result := Trim(Result);
end;

procedure Check(const Oid, Expected: AnsiString);
begin
  if Hex(DER_OID(Oid)) <> Expected then
    WriteLn('MISMATCH ', Oid, ': ', Hex(DER_OID(Oid)), ' expected ', Expected)
  else
    WriteLn('ok       ', Oid);
end;

begin
  Check('2.47.1',               '06 02 7F 01');     // letzter Ein-Byte-Wert
  Check('2.48.1',               '06 03 81 00 01');  // erster Zwei-Byte-Wert
  Check('2.999.3',              '06 03 88 37 03');  // ein Byte-Cast liefert 1.15.3
  Check('2.5.29.14',            '06 03 55 1D 0E');
  Check('1.2.840.113549.1.7.2', '06 09 2A 86 48 86 F7 0D 01 07 02');
end.
PDFlibPas DER_OID kombiniert die ersten beiden OID-Bögen als 40 * arc1 + arc2 und kodiert die Summe Base-128 in einem UInt64, sodass 2.999.3 als 06 03 88 37 03 herauskommt, während ein Byte-Cast 55 behielte und den Identifier lautlos als 1.15.3 dekodierte
Die meisten PKI-Bögen erreichen die Grenze nie, deshalb fällt ein Byte-großer Shortcut nicht auf — die joint-iso-itu-t-Bögen ab 2.48 aufwärts brauchen zwei Bytes, also gehören Testvektoren auf beide Seiten dieser Linie

In derselben arithmetischen Zeile versteckt sich noch ein Überlauf. DER_OID parst Bögen in Int64, ein legaler zweiter Bogen kann also so groß wie Int64.MaxValue sein, und plus 80 für arc1 = 2 läuft ein vorzeichenbehafteter 64-Bit-Integer über. Der kombinierte Wert liegt deshalb in einem UInt64, der Int64.MaxValue + 80 ohne Wrap-around trägt. Niemand vergibt OIDs in dieser Größe, aber ein konstruierter String kann trotzdem einen anfordern. Der Zehn-Byte-Scratch-Buffer in DER_OID fasst die zehn 7-Bit-Gruppen, die ein 64-Bit-Wert brauchen kann, also kodiert selbst 2.9223372036854775807 zu einem zehnbyteigen Subidentifier, statt zu überlaufen

Was der CMS-Walker akzeptiert, und wo die Verifizierung wohnt

PDFlibCMSRead gibt die Bytes zurück, die laut RFC 5652 dort sitzen sollten, und das ist sein kompletter Job. Es prüft keinen Signaturwert, keinen Digest und keine Gültigkeitsdauer. Der Walker akzeptiert nur DER: DERReadTLV weist indefinite lengths und mehrbytige Tag-Nummern zurück, also meldet ein BER-kodiertes CMS von einem nicht konformen Signer null Zertifikate. Uns ist das lieber als ein Teil-Parse von BER. In der Praxis ist das Erkennungszeichen ein Längenbyte von $80 direkt hinter dem äußeren $30-Tag, so beginnt eine SEQUENCE mit indefinite length

Attributzertifikate und die anderen CertificateChoices-Alternativen werden beim Durchlauf durch das Zertifikats-Set übersprungen, weil nur die plain-Certificate-Alternative ein X.509-Zertifikat ist, mit dem Kettenaufbau und Sperr-lookups etwas anfangen können. Alles Kryptografische bleibt bei dem Code, dem es gehört — das beginnt mit den Byte-Abdeckungsprüfungen in PAdES-Signierung und ByteRange-Validierung in Delphi und geht weiter mit dem Einordnen, was sich nach dem Signieren einer PDF geändert hat. Dasselbe Misstrauen gegen deklarierte Längen zieht sich durch das Härten eines Pascal-PDF-Parsers gegen bösartige Dateien

Die oben gezeigten Aufrufe für Zertifikatsextraktion, Kettenaufbau und Long-Term-Validation sind Teil der losLab PDF Library for Delphi, die unter Delphi, C++Builder und Lazarus läuft, sodass derselbe Signatur-Lese-Code in einem Windows-Dienst und in einem Linux-Build funktioniert