Articolo tecnico

Parsing delle firme CMS in Delphi: limiti DER e archi OID

Specifica l'OID 2.999.3 come spesso fa una helper DER scritta in fretta, con i primi due archi compressi in un solo byte, e il decoder restituisce 1.15.3. Due altri errori tipici della lettura del CMS si comportano allo stesso modo: un conteggio certificati che ingoia i byte del vicino e un firmatario abbinato a un numero di seriale letto dal campo sbagliato. In PDF Library for Delphi (PDFlibPas) il lettore delle firme percorre il CMS in /Contents come DER puro, limita ogni lettura annidata al suo elemento padre, taglia il padding alla lunghezza che il CMS dichiara e codifica in base-128 il primo arco OID combinato

Moltissimo codice ha bisogno del lato lettura di una firma. La long-term validation deve estrarre il certificato del firmatario e i suoi issuer da una firma esistente prima di poter recuperare i dati di revoca, e un report di audit deve dire chi ha firmato. Una build Lazarus su Linux non ha funzioni di messaggio Windows a cui appoggiarsi, perché le chiamate CMS di piattaforma sono stub che falliscono fuori da Windows: è il motivo per cui PDFlibPas fa questo percorso in Pascal puro e non usa affatto CryptoAPI

Estrarre i certificati del firmatario da un PDF firmato

Cinque metodi di TPDFlib coprono tutto il lato lettura, e ognuno prende InputFile, Password, FieldName. Ogni chiamata apre il file in sola lettura, risponde e lo richiude, quindi non c'è alcuno stato del documento da gestire. GetSignatureEmbeddedCertificateCount e GetSignatureEmbeddedCertificateDER enumerano l'insieme dei certificati CMS in ordine di codifica. GetSignatureSignerCertificateDER restituisce il certificato che ha prodotto un dato SignerInfo. GetSignatureCertificateChainLength e GetSignatureCertificateChainDER camminano da quel firmatario verso l'issuer più lontano che la firma trasporta. Tutti gli indici partono da zero

I risultati tornano come AnsiString, e conviene lasciarli così. Un blob DER instradato attraverso string o un TStrings passa per una conversione di set di caratteri, e i byte che escono dall'altro lato non sono più parsabili. È anche il motivo per cui la libreria conserva le liste di certificati come array di AnsiString e restituisce le liste di URL come testo di una riga per indirizzo: gli indirizzi sono ASCII puro e sopravvivono alla conversione, i byte dei certificati no

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
      // l'ultimo anello può avere un issuer che la firma non ha incorporato
      LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
      WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
    end;
  finally
    Pdf.Free;
  end;
end;

Due risultati di quel programma si leggono male senza accorgersene. Un conteggio di 0 da solo non dice quasi nulla: un campo mancante, una password sbagliata, un blob che non è DER e un SignedData che semplicemente omette l'insieme opzionale dei certificati tornano tutti come 0 o stringa vuota. Logga il nome del campo accanto al numero, come fa l'esempio, o finirai per fare debug sul file sbagliato. Il secondo risultato delicato è la lunghezza della catena. Il costruttore di catena usa solo i certificati incorporati nella firma, quindi una catena che si ferma prima di una root auto-rilasciata è la norma. Firma un file con il nostro certificato demo, emesso da una root di test, e GetSignatureCertificateChainLength restituisce 1 perché quella root non è nel CMS. L'hop successivo arriva dagli indirizzi che GetCertificateIssuerURLs riporta, una chiamata che appartiene all'edizione Enterprise insieme al resto delle API di long-term validation

Il match del firmatario gestisce entrambe le forme di SignerIdentifier che la RFC 5652 §5.3 consente. issuerAndSerialNumber è quella che tutti provano. La forma [0] subjectKeyIdentifier, una OCTET STRING con tag implicito $80, è il ramo che i lettori scritti a mano dimenticano più spesso, e i firmatari che si identificano per key identifier la emettono davvero. Quando si usa la forma issuer-e-seriale devono combaciare entrambe le metà: un numero di seriale è univoco solo dentro un issuer, quindi un match sul solo seriale può finire su un certificato di una CA diversa

Quanta parte di /Contents è davvero il CMS?

Solo il prefisso coperto dal SEQUENCE esterno, e PLTrimCMSPadding nell'unità PDFlibCMSRead taglia tutto ciò che viene dopo. La ragione è una questione di ordine. ISO 32000-1 §12.8.1 richiede che il /ByteRange sia fissato prima che il valore della firma esista, quindi un firmatario riserva in anticipo la stringa esadecimale di /Contents, la dimensiona con generosità e riempie di zeri la coda inutilizzata quando il CMS è noto. Un file firmato tipico porta quindi una sequenza di zeri dopo il CMS, lunga quanto la sovrariserva del firmatario

PLTrimCMSPadding legge il primo TLV, richiede il tag $30 e restituisce i byte fino alla fine di quell'elemento. Passagli 30 03 02 01 00 00 00 00 e riavrai i primi cinque byte; passagli 'not der' e otterrai una stringa vuota. Questo livello più alto è l'unico posto dove i byte finali sono legali. Una regola severa che richiede all'elemento di consumare tutto il buffer rigetterebbe i file firmati normali, mentre una regola permissiva del tipo «ciò che resta va bene» applicata a ogni profondità è esattamente il modo in cui i campi annidati finiscono per leggere byte che non possiedono

PDFlibPas PLTrimCMSPadding legge il primo TLV della stringa esadecimale di /Contents riservata, richiede il tag $30 e taglia il padding di zeri alla lunghezza che il SEQUENCE esterno dichiara, e restituisce un risultato vuoto quando il buffer non inizia con un SEQUENCE ben formato
I byte finali sono legali solo al livello più alto, dove lo slot riservato deve restare fisso per /ByteRange — le letture più profonde seguono la regola del limite al padre

Perché un lettore DER ha bisogno dell'offset di fine del padre?

Perché un elemento annidato è valido solo se finisce dentro il suo padre, e il controllo contro la fine del buffer non lo dimostra. DERReadTLV in PDFlibASN1 limita ogni elemento rispetto all'intera stringa, rifiuta le lunghezze che supererebbero la fine e fa il calcolo come una sottrazione, così una lunghezza costruita ad hoc di quattro byte come $7FFFFFFF non può ribaltare il controllo nel negativo. Quella è memory safety. Non dice nulla sul fatto che l'elemento stia davvero dove è stato trovato

Immagina un SignerInfo il cui issuerAndSerialNumber dichiara 40 byte mentre la issuer Name al suo interno ne rivendica 60. Ogni byte è ancora nel buffer, quindi un lettore limitato al buffer accetta la Name, poi legge il «numero di seriale» dall'algoritmo di digest che segue, e infine confronta quella coppia con i certificati incorporati. Nulla fallisce. A volte il confronto riesce perfino con il certificato sbagliato

PDFlibPas limita ogni lettura DER annidata al suo elemento padre: una issuer Name da 60 byte dentro un issuerAndSerialNumber da 40 byte viene accettata da una lettura limitata al buffer, che poi legge il numero di seriale da digestAlgorithm, mentre ReadTLVWithin rifiuta qualsiasi elemento che finisca oltre ParentEnd
Dentro il buffer è memory safety, dentro il padre è correttezza — PDFlibPas fa passare l'offset di fine del padre attraverso ogni livello del CMS così una lunghezza ostile non può prendere in prestito i byte del vicino

Il walker CMS di PDFlibPas porta la posizione di fine del padre in ogni lettura, da ContentInfo (RFC 5652 §3) attraverso il wrapper [0] EXPLICIT, i campi SignedData (§5.1), ogni SignerInfo e il suo identificatore, fino ai campi tbsCertificate che legge quando abbina un firmatario. Se scrivi il tuo walker sopra la DERReadTLV pubblica, per un timestamp token o una risposta OCSP, lo stesso schema sta in una dozzina di righe:

uses
  PDFlibASN1;

// Una lettura di un figlio, rifiutata se il figlio finirebbe oltre il padre.
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;                          // niente più spazio dentro il padre
  if not DERReadTLV(Data, Offset, Tag, Start, Len) then
    Exit;
  Result := Offset <= ParentEnd;  // Offset ora sta uno oltre il figlio
end;

// Conta i membri SEQUENCE di un SET OF il cui contenuto copre
// Data[SetStart .. SetEnd - 1]. Si ferma al primo membro che sfora.
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;                       // nessun resync: l'allineamento è perso
    if Tag = $30 then
      Inc(Result);
  end;
end;

Nota il Break. Dentro l'insieme dei certificati e l'insieme signerInfos, PLExtractCMSCertificates fa la stessa cosa: un elemento che sfora la fine dell'insieme ferma il ciclo, e la funzione restituisce i certificati che aveva già accettato. Non incolla mai i byte seguenti di crls o signerInfos sull'ultimo certificato. Saltare l'elemento difettoso e andare avanti è allettante, ed è la scelta sbagliata. Quando una lunghezza dichiarata è sbagliata, il lettore non sa più dove inizia l'elemento successivo, e qualsiasi «recupero» è un'ipotesi su quale byte assomigli a un tag. Con il ciclo fermo, un insieme il cui secondo certificato sfora di un solo byte produce un conteggio di 1 e i byte del primo certificato esattamente come codificati

Come può 2.999.3 diventare 1.15.3?

I primi due archi di un OID si combinano in un solo subidentifier, e quel subidentifier è codificato in base-128 come ogni altro arco — non è un singolo byte. X.690 §8.19.4 definisce il valore come 40 * arc1 + arc2. Un encoder che lo scrive con Byte(...) è corretto fino a 127, cioè 2.47. Per 2.999 la somma è 1079, un cast a byte conserva 55, e 55 si decodifica come 1.15. L'identificatore ora nomina un ramo diverso dell'albero e nessuno si lamenta. I valori da 128 a 255 si rompono in modo diverso: il cast emette un byte con il bit di continuazione impostato, e il decoder ingoia al suo interno l'arco successivo

La scorciatoia sopravvive a lungo nel codice reale perché la maggior parte degli identificatori PKI non raggiunge mai il confine. Tutto ciò che sta sotto 1.2.840, 2.5.29 e 0.4.0 ha un primo valore combinato ben sotto 128, quindi una suite di test costruita solo con gli OID di firma più comuni non esercita mai il secondo byte. Solo gli archi joint-iso-itu-t da 2.48 in su attraversano la linea. In PDFlibPas una sola funzione, DER_OID, serve l'encoder per i signed attributes, la ricerca dentro DERFindExtensionByOID e il controllo del content-type del SignedData, così scrittura e confronto non possono divergere. I vettori di test vanno messi su entrambi i lati del confine:

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');     // ultimo valore su un byte
  Check('2.48.1',               '06 03 81 00 01');  // primo valore su due byte
  Check('2.999.3',              '06 03 88 37 03');  // un cast a Byte dà 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 combina i primi due archi OID come 40 * arc1 + arc2 e codifica in base-128 la somma in un UInt64, così 2.999.3 diventa 06 03 88 37 03, mentre un cast a Byte conserverebbe 55 e decodificherebbe silenziosamente l'identificatore come 1.15.3
La maggior parte degli archi PKI non raggiunge mai il confine, ed è per questo che una scorciatoia su un byte passa inosservata — gli archi joint-iso-itu-t da 2.48 in su richiedono due byte, quindi i vettori di test vanno messi su entrambi i lati di quella linea

C'è un altro overflow nascosto nella stessa riga di aritmetica. DER_OID parsa gli archi in Int64, quindi un secondo arco legale può arrivare fino a Int64.MaxValue, e aggiungere 80 per arc1 = 2 fa andare in overflow un intero a 64 bit con segno. Il valore combinato è quindi tenuto in un UInt64, che porta Int64.MaxValue + 80 senza fare wrapping. Nessuno emette OID così grandi, ma una stringa costruita ad hoc può comunque richiederne uno. Il buffer di lavoro da dieci byte in DER_OID contiene i dieci gruppi a 7 bit di cui può aver bisogno un valore a 64 bit, così perfino 2.9223372036854775807 si codifica in un subidentifier di dieci byte invece di fare wrapping

Che cosa accetta il walker CMS, e dove vive la verifica

PDFlibCMSRead restituisce i byte che stanno dove la RFC 5652 dice che devono stare, e questo è tutto il suo lavoro. Non verifica alcun valore di firma, né digest, né periodo di validità. Il walker accetta solo DER: DERReadTLV rifiuta le lunghezze indefinite e i numeri di tag multi-byte, quindi un CMS codificato BER da un firmatario non conforme riporta zero certificati. È la nostra preferenza rispetto a un parse parziale del BER. In pratica il campanello d'allarme è un byte di lunghezza $80 subito dopo il tag esterno $30, che è come inizia un SEQUENCE a lunghezza indefinita

Gli attribute certificate e le altre alternative di CertificateChoices vengono saltate durante la scansione dell'insieme dei certificati, perché solo l'alternativa Certificate semplice è un certificato X.509 che la costruzione della catena e le ricerche di revoca possono usare. Tutto ciò che è crittografico resta al codice che lo possiede: inizia con i controlli di copertura dei byte descritti in firma PAdES e validazione del ByteRange in Delphi e continua con la classificazione di ciò che cambia dopo la firma di un PDF. La stessa abitudine di diffidare delle lunghezze dichiarate attraversa l'hardening di un parser PDF Pascal contro file ostili

L'estrazione dei certificati, la costruzione della catena e le chiamate di long-term validation mostrate sopra fanno parte di losLab PDF Library for Delphi, che gira su Delphi, C++Builder e Lazarus, così lo stesso codice di lettura delle firme funziona in un servizio Windows e in una build Linux