Artículo técnico

Firmas CMS en Delphi: límites DER y arcos de OID

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

PLTrimCMSPadding de PDFlibPas lee el primer TLV del hex string reservado de /Contents, exige el tag $30 y corta el padding de ceros en la longitud que declara el SEQUENCE externo, y devuelve un resultado vacío cuando el buffer no arranca con un SEQUENCE bien formado
Los bytes sobrantes solo son legales en el nivel superior, donde el slot reservado debe quedar fijo para /ByteRange — las lecturas más profundas reciben en cambio la regla de acotación por el padre

¿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

PDFlibPas acota cada lectura DER anidada por su elemento padre: un issuer Name de 60 bytes dentro de un issuerAndSerialNumber de 40 bytes es aceptado por una lectura acotada por el buffer, que luego lee el número de serie desde digestAlgorithm, mientras que ReadTLVWithin rechaza todo elemento que termine más allá de ParentEnd
Dentro del buffer es memory safety, dentro del padre es corrección — PDFlibPas hace pasar el offset de fin del padre por cada nivel del CMS para que una longitud hostil no pueda pedirle prestados los bytes del vecino

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.
DER_OID de PDFlibPas combina los primeros dos arcos del OID como 40 * arc1 + arc2 y codifica la suma en base-128 dentro de un UInt64, así que 2.999.3 se vuelve 06 03 88 37 03, mientras que un cast a Byte conservaría 55 y decodificaría el identificador en silencio como 1.15.3
La mayoría de los arcos de PKI nunca llega a la frontera, por eso un atajo del tamaño de un byte pasa desapercibido — los arcos joint-iso-itu-t desde 2.48 para arriba necesitan dos bytes, así que los vectores de test pertenecen a ambos lados de esa línea

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