Codifique el OID 2.999.3 como suele hacerlo un helper DER apurado, con los primeros dos arcos empaquetados en un solo byte, y el decodificador le devuelve 1.15.3. Otros dos errores de lectura de CMS se comportan igual: un conteo de certificados que se traga los bytes del vecino, y un firmante matcheado por un número de serie leído del campo equivocado. En PDF Library for Delphi (PDFlibPas), el lector de firmas recorre el CMS de /Contents como DER puro, acota cada lectura anidada por su elemento padre, corta el padding en la longitud que el CMS declara, y codifica en base-128 el primer arco combinado del OID
Mucho código necesita el lado de lectura de una firma. La validación a largo plazo tiene que sacar el certificado del firmante y sus issuers de una firma existente antes de poder buscar data de revocación, y un reporte de auditoría tiene que decir quién firmó. Un build Lazarus sobre Linux no tiene funciones de mensajería de Windows de las cuales valerse, porque las llamadas CMS de la plataforma están stubbeadas para fallar fuera de Windows, y por eso PDFlibPas hace este recorrido en Pascal puro y no usa CryptoAPI para nada
Sacar los certificados del firmante de un PDF firmado
Cinco métodos de TPDFlib cubren el lado de lectura, y cada uno recibe InputFile, Password, FieldName. Cada llamada abre el archivo en modo solo lectura, responde y lo vuelve a cerrar, así que no hay estado de documento que administrar. GetSignatureEmbeddedCertificateCount y GetSignatureEmbeddedCertificateDER enumeran el set de certificados del CMS en orden de codificación. GetSignatureSignerCertificateDER devuelve el certificado que produjo un SignerInfo dado. GetSignatureCertificateChainLength y GetSignatureCertificateChainDER caminan desde ese firmante hacia el issuer más lejano que la firma cargue. Los índices son base 0
Los resultados regresan como AnsiString, y conviene dejarlos así: un blob DER que pasa por string o por un TStrings atraviesa una conversión de juego de caracteres, y los bytes que salen del otro lado ya no se parsean. Por eso mismo la librería mantiene las listas de certificados como arrays de AnsiString y devuelve las listas de URLs como texto de una dirección por línea: las direcciones son ASCII puro y sobreviven a la conversión, los bytes de certificados 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
// el último eslabón puede tener un issuer que la firma no embebiera
LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
end;
finally
Pdf.Free;
end;
end;
Dos resultados de ese programa se malinterpretan con facilidad. Un conteo de 0 por sí solo dice muy poco: un campo inexistente, un password equivocado, un blob que no es DER y un SignedData que simplemente omite el set opcional de certificados regresan todos como 0 o como string vacío. Registre el nombre del campo junto al número, como hace el ejemplo, o va a terminar depurando el archivo equivocado. El segundo es la longitud de cadena. El constructor de cadenas solo usa certificados embebidos en la firma, así que una cadena que se detiene antes de llegar a una raíz auto-emitida es normal. Firmar un archivo con nuestro certificado demo, que emite una raíz de test, hace que GetSignatureCertificateChainLength devuelva 1 porque esa raíz no está en el CMS. El siguiente salto llega por las direcciones que reporta GetCertificateIssuerURLs, una llamada que pertenece a la edición Enterprise junto con el resto de la API de validación a largo plazo
El match del firmante maneja las dos formas de SignerIdentifier que el RFC 5652 §5.3 permite. issuerAndSerialNumber es la que todos prueban. La forma [0] subjectKeyIdentifier, un OCTET STRING con tag implícito cuyo tag es $80, es la rama que los lectores escritos a mano olvidan con más frecuencia, y los firmantes que se identifican por key identifier sí la emiten. Cuando se usa la forma issuer-and-serial, las dos mitades tienen que coincidir: un número de serie solo es único dentro de un issuer, así que matchear solo por serie puede aterrizar en un certificado de otra CA
¿Cuánto de /Contents es en realidad el CMS?
Solo el prefijo que cubre el SEQUENCE externo, y PLTrimCMSPadding en la unidad PDFlibCMSRead corta todo lo que viene después. La razón es el orden. ISO 32000-1 §12.8.1 exige que el /ByteRange quede fijo antes de que exista el valor de la firma, así que el firmante reserva el hex string de /Contents por adelantado, lo dimensiona con generosidad y llena la cola sin usar con ceros una vez que el CMS es conocido. Un archivo firmado típico carga por eso una tira de ceros después del CMS, tan larga como lo que el firmante sobre-reservó
PLTrimCMSPadding lee el primer TLV, exige el tag $30 y devuelve los bytes hasta el final de ese elemento. Aliméntelo con 30 03 02 01 00 00 00 00 y recibe los primeros cinco bytes de vuelta; aliméntelo con 'not der' y recibe un string vacío. Ese nivel superior es el único lugar donde los bytes sobrantes son legales. Una regla estricta de que el elemento debe consumir todo el buffer rechazaría archivos firmados corrientes, mientras que una regla laxa de «lo que sobre está bien» aplicada a cada profundidad es exactamente como los campos anidados terminan leyendo bytes que no les pertenecen
¿Por qué un lector DER necesita el offset de fin del padre?
Porque un elemento anidado solo es válido si termina dentro de su padre, y chequearlo contra el final del buffer no demuestra eso. DERReadTLV en PDFlibASN1 acota cada elemento contra el string completo, rechaza longitudes que se pasarían del final, y hace la aritmética como una resta para que una longitud maliciosa de cuatro bytes como $7FFFFFFF no pueda volver negativo el chequeo. Eso es memory safety, y no dice nada sobre si el elemento pertenece donde fue encontrado
Imagine un SignerInfo cuyo issuerAndSerialNumber declara 40 bytes mientras el issuer Name que lleva adentro reclama 60. Todos los bytes siguen dentro del buffer, así que un lector acotado por el buffer acepta el Name, luego lee el «número de serie» del digest algorithm que viene después, y compara ese par contra los certificados embebidos. Nada falla. A veces la comparación hasta tiene éxito contra el certificado equivocado
El walker del CMS de PDFlibPas lleva la posición de fin del padre a cada lectura, desde el ContentInfo (RFC 5652 §3) pasando por el wrapper [0] EXPLICIT y los campos de SignedData (§5.1), cada SignerInfo y su identificador, hasta los campos de tbsCertificate que lee al matchear a un firmante. Si escribe su propio walker encima del DERReadTLV público, para un timestamp token o una respuesta OCSP, el mismo patrón son una docena de líneas:
uses
PDFlibASN1;
// Una lectura hija, rechazada si el hijo terminaría más allá de su 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; // nada queda dentro del padre
if not DERReadTLV(Data, Offset, Tag, Start, Len) then
Exit;
Result := Offset <= ParentEnd; // Offset queda un byte después del hijo
end;
// Cuenta los miembros SEQUENCE de un SET OF cuyo contenido abarca
// Data[SetStart .. SetEnd - 1]. Se detiene en el primer miembro que se pasa.
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; // sin resincronización: la alineación se perdió
if Tag = $30 then
Inc(Result);
end;
end;
Note el Break. Dentro del set de certificados y del set de signerInfos, PLExtractCMSCertificates hace lo mismo: un elemento que se pasa del fin del set corta el bucle, y la función devuelve los certificados que ya había aceptado. Nunca pega los bytes siguientes de crls o signerInfos al último certificado. Saltarse el elemento malo y seguir es tentador, y es la decisión equivocada. Una vez que una longitud declarada está mal, el lector ya no sabe dónde arranca el siguiente elemento, y cualquier «recuperación» es una adivinanza sobre qué byte parece un tag. Con el bucle cortado, un set cuyo segundo certificado se pasa por un solo byte produce un conteo de 1 y los bytes del primer certificado exactamente como fueron codificados
¿Cómo puede 2.999.3 salir como 1.15.3?
Los primeros dos arcos de un OID se combinan en un subidentificador, y ese subidentificador se codifica en base-128 como cualquier otro arco — no es un solo byte. X.690 §8.19.4 define el valor como 40 * arc1 + arc2. Un encoder que lo escribe con Byte(...) es correcto hasta 127, que es 2.47. Para 2.999 la suma es 1079, el cast a byte conserva 55, y 55 se decodifica como 1.15. El identificador pasa a nombrar otra rama del árbol y nadie se queja. Los valores de 128 a 255 fallan de otra manera: el cast emite un byte con el bit de continuación prendido, y el decodificador se traga el siguiente arco dentro de él
El atajo sobrevive tanto tiempo en código real porque la mayoría de los identificadores de PKI nunca llegan a la frontera. Todo lo que está bajo 1.2.840, 2.5.29 y 0.4.0 tiene un primer valor combinado muy por debajo de 128, así que una suite de test armada solo con OIDs de firma comunes nunca ejercita el segundo byte. Solo los arcos joint-iso-itu-t desde 2.48 para arriba cruzan la línea. En PDFlibPas una sola función, DER_OID, sirve al encoder de signed attributes, a la búsqueda dentro de DERFindExtensionByOID y al chequeo del content-type de SignedData, así que escribir y matchear no pueden divergir. Los vectores de test pertenecen a ambos lados de la frontera:
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'); // último valor de un byte
Check('2.48.1', '06 03 81 00 01'); // primer valor de dos bytes
Check('2.999.3', '06 03 88 37 03'); // un cast a Byte da 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.
Hay un desborde más escondido en la misma línea de aritmética. DER_OID parsea los arcos en Int64, así que un segundo arco legal puede ser tan grande como Int64.MaxValue, y sumar 80 para arc1 = 2 desborda un entero de 64 bits con signo. El valor combinado se guarda por eso en un UInt64, que carga Int64.MaxValue + 80 sin dar la vuelta; nadie emite OIDs tan grandes, pero un string malicioso igual puede pedir uno. El buffer de trabajo de diez bytes en DER_OID aloja los diez grupos de 7 bits que un valor de 64 bits puede necesitar, así que hasta 2.9223372036854775807 se codifica como un subidentificador de diez bytes en lugar de dar la vuelta
Lo que el walker del CMS acepta, y dónde vive la verificación
PDFlibCMSRead devuelve bytes que están donde RFC 5652 dice que deben estar, y ese es todo su trabajo. No verifica ningún valor de firma, ni digest, ni período de validez. El walker acepta solo DER: DERReadTLV rechaza longitudes indefinidas y números de tag multi-byte, así que un CMS codificado en BER que venga de un firmante fuera de estándar reporta cero certificados. Preferimos eso a un parseo parcial de BER. En la práctica la pista es un byte de longitud $80 justo después del tag $30 externo, que es con lo que arranca un SEQUENCE de longitud indefinida
Los attribute certificates y las demás alternativas de CertificateChoices se saltan al recorrer el set de certificados, porque solo la alternativa Certificate simple es un certificado X.509 que la construcción de cadenas y las búsquedas de revocación pueden usar. Todo lo criptográfico se queda con el código que lo posee, lo que arranca con los chequeos de cobertura de bytes en firma PAdES y validación de ByteRange en Delphi y sigue con clasificar qué cambió después de que se firmó un PDF. El mismo hábito de desconfiar de las longitudes declaradas atraviesa endurecer un parser de PDF en Pascal contra archivos maliciosos
La extracción de certificados, la construcción de cadenas y las llamadas de validación a largo plazo mostradas arriba son parte de losLab PDF Library for Delphi, que corre en Delphi, C++Builder y Lazarus, así que el mismo código de lectura de firmas funciona en un servicio de Windows y en un build Linux