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
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
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.
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