Artículo técnico

Verificar firmas digitales de PDF en Delphi con HotPDF

Un verificador de firmas PDF hecho a mano puede rechazar todos los ficheros correctamente firmados que reciba mientras lee cada byte correctamente. Saca el blob CMS de /Contents, localiza los atributos firmados, les calcula el hash exactamente como están almacenados, y la comparación RSA falla. El documento está bien. El problema es un byte: dentro del SignerInfo los atributos van etiquetados [0] IMPLICIT, así que su primer byte es 0xA0, mientras que el RFC 5652 §5.4 dice que el firmante calculó la firma sobre el mismo contenido codificado como un SET OF DER, cuyo primer byte es 0x31. Cambia ese byte antes de hashear y las firmas "falsificadas" se vuelven válidas

Ese desajuste de tag es el primero de varios sitios donde una comprobación de firma PDF puede torcerse, y los demás son menos obvios. Una firma puede ser matemáticamente perfecta en un fichero que se editó después de firmar. Puede ser perfecta en un documento que un atacante re-firmó con un certificado de fabricación propia. Una contraparte devuelve un contrato firmado, tu flujo de trabajo tiene que archivarlo, y alguien pregunta si este es el documento que enviaste, byte a byte, firmado por el certificado que dice. Producir esas firmas en primer lugar está tratado en el artículo compañero sobre crear firmas digitales PAdES en Delphi; este va en la dirección contraria, partiendo de un fichero que llega ya firmado

Dónde viven los bytes firmados en un fichero PDF

Una firma PDF protege rangos de bytes del fichero en disco, y HotPDF verifica contra exactamente esos bytes. ISO 32000-1 §12.8.1 pone un contenedor CMS SignedData (RFC 5652) en la entrada /Contents del diccionario de firma y un array /ByteRange al lado nombrando las regiones que cubre la firma. En la práctica el array lleva dos parejas de offset y longitud: todo desde el offset 0 hasta la cadena hexadecimal de /Contents, y todo lo que va después. Una firma no puede cubrir su propio valor, así que el fichero se hashea alrededor de ese agujero

La consecuencia para cualquier verificador es tajante. Hay que hashear el original serializado. Un modelo de objetos parseado no sirve aquí, porque volver a escribir incluso un documento intacto produce bytes distintos. Por eso HotPDF lee el fichero fuente del que se cargó el documento, o un TStream de bytes en bruto que tú suministres, y nunca hashea su representación en memoria

Diagrama de HotPDF verificando un PDF firmado en Delphi al recalcular el hash de los dos segmentos de ByteRange del fichero fuente alrededor del agujero de Contents, mientras que el modelo parseado en memoria nunca se hashea porque re-serializar cambia los bytes
La verificación hashea los dos segmentos de ByteRange de los bytes fuente tal como están serializados; un modelo parseado en memoria no sirve porque re-serializar incluso un documento sin cambios produce bytes distintos

El agujero en sí merece sospecha. Los bytes fuera de los rangos firmados son bytes que un lector puede seguir parseando, y un hueco que contenga cualquier cosa aparte del valor de la firma es la puerta de entrada de un ataque de signature wrapping. HotPDF comprueba que /ByteRange empieza en el offset 0, que el segundo segmento comienza después de que termine el primero, que ambos se quedan dentro del fichero, y que el hueco no contiene nada salvo los dígitos hexadecimales del /Contents de esta misma firma, opcionalmente con sus delimitadores < y >. Un fichero que falle cualquiera de esas comprobaciones devuelve svInvalidByteRange, aunque las matemáticas del CMS hubieran pasado

Leer quién firmó antes de comprobar nada

GetLoadedSignatureInfo parsea el diccionario de firma y su contenedor CMS sin hashear un solo byte del documento, así que es la llamada a hacer cuando una UI solo necesita mostrar quién firmó y cuándo. Los campos de firma se indexan desde 0 en orden de campos de formulario, y GetLoadedSignatureFieldCount devuelve cuántos hay. Un índice pasado el final eleva una excepción en lugar de devolver un registro vacío, así que itera sobre el conteo

El registro THPDFSignatureInfo devuelto lleva el nombre del campo, el /SubFilter, el common name del certificado del firmante, los distinguished names de subject e issuer, el número de serie en hexadecimal, las fechas de validez del certificado y la hora de firma, tomada del atributo firmado cuando está presente y en su defecto de la entrada /M del diccionario. También reporta los nombres del algoritmo de digest y de clave pública, las cadenas /Reason, /Location y /ContactInfo, y CertificateTimeValidity, que marca una hora de firma que cae fuera de la ventana de validez del certificado. Status se queda en svNotVerified: parseado, no comprobado. La API de firma está tras el guard de compilador de Delphi 2009 en adelante

var
  Pdf: THotPDF;
  Info: THPDFSignatureInfo;
  I: Integer;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.LoadFromFile('signed-contract.pdf');
    for I := 0 to Pdf.GetLoadedSignatureFieldCount - 1 do
    begin
      Info := Pdf.GetLoadedSignatureInfo(I);
      Writeln('Field:     ', Info.FieldName);
      Writeln('Signer:    ', Info.SignerName);
      Writeln('Issuer:    ', Info.IssuerDN);
      Writeln('Key/hash:  ', Info.PublicKeyAlgorithm, ' / ', Info.HashAlgorithm);
      Writeln('SubFilter: ', Info.SubFilter);
      if Info.CertificateTimeValidity = stvSigningTimeOutsideCertificate then
        Writeln('Signing time is outside the certificate validity period');
    end;
  finally
    Pdf.Free;
  end;
end;

Ejecutar la comprobación criptográfica con VerifyLoadedSignatureEx

VerifyLoadedSignatureEx ejecuta la comprobación completa para un documento cargado de fichero y devuelve el registro de información rellenado en la misma llamada. Reabre el fichero fuente, valida el /ByteRange, hashea los dos segmentos con el algoritmo de digest del SignerInfo, compara el resultado con el atributo firmado messageDigest y después verifica el valor de la firma sobre la forma SET OF DER de los atributos firmados usando la clave pública del certificado del firmante incrustado. Cuando una firma no lleva atributos firmados, una comprobación RSA o ECDSA corre directamente sobre el hash del documento

La cobertura de algoritmos sigue lo que las herramientas de firma emiten de verdad. Los digests incluyen SHA-1, SHA-256, SHA-384, SHA-512, la familia SHA-3 y SHAKE256. Las firmas pueden ser RSA con padding PKCS#1 v1.5 o PSS, ECDSA sobre curvas con nombre, o Ed25519 y Ed448. La verificación ECDSA usa el proveedor CNG de Windows, y Ed25519 y Ed448 van por un proveedor de plataforma respaldado por Windows CNG o una biblioteca OpenSSL, así que en una máquina donde el proveedor necesario no se pueda cargar el resultado es svUnsupportedAlgorithm o svCryptoProviderError en lugar de un veredicto sobre el fichero. VerifyLoadedSignatureWithOptions acepta un registro THPDFCMSVerifyOptions cuando necesitas apuntar a una biblioteca OpenSSL concreta o enchufar tu propio THPDFSignatureProvider

Pipeline de VerifyLoadedSignatureEx en HotPDF para Delphi: reabrir el fichero fuente, hashear los segmentos de ByteRange, comparar con el atributo firmado messageDigest del CMS y verificar después la firma con la clave pública del certificado del firmante, produciendo svValid, svDigestMismatch o svSignatureInvalid
VerifyLoadedSignatureEx recalcula el hash de los segmentos de ByteRange, los compara con el atributo firmado messageDigest y verifica la firma sobre el SET DER de atributos firmados antes de reportar svValid o un estado de fallo concreto
var
  Status: THPDFSignatureVerifyStatus;
  Info: THPDFSignatureInfo;
begin
  Status := Pdf.VerifyLoadedSignatureEx(0, Info);
  case Status of
    svValid:
      if Info.CoversWholeDocument then
        Writeln('Valid; signature covers the whole file')
      else
        Writeln('Valid; ', Info.UnsignedTrailingBytes,
          ' bytes were appended after signing');
    svDigestMismatch:
      Writeln('Document bytes changed after signing');
    svSignatureInvalid:
      Writeln('Hash matches, signature value does not verify');
    svInvalidByteRange:
      Writeln('ByteRange is malformed or the gap holds extra bytes');
    svDigestAlgorithmMismatch:
      Writeln('CMS digest algorithm identifiers disagree');
    svUnsupportedAlgorithm, svCryptoProviderError:
      Writeln('Cannot evaluate this key or digest here');
    svMalformed:
      Writeln('CMS container could not be parsed');
    svSourceUnavailable:
      Writeln('No source bytes; use the TStream overload');
  else
    Writeln('Status ', Ord(Status));
  end;
end;

Dos detalles de parseo explican fallos que desde fuera parecen misteriosos. El primero es el re-tag del párrafo inicial: HotPDF hashea los atributos firmados con su byte inicial reescrito a 0x31, exactamente como prescribe el RFC 5652 §5.4. El segundo es el padding. Las herramientas de firma reservan un presupuesto fijo de bytes para /Contents antes de que exista la firma y rellenan la cola sin usar con ceros, así que el verificador recorta el blob decodificado a la longitud real de su SEQUENCE DER exterior antes de recorrerlo. Una tirada de ceros finales en /Contents es normal. La misma familia de peligros de parseo ASN.1, vista desde el lado de importación de certificados, es el tema del artículo sobre endurecimiento de seguridad PKCS#12 y ASN.1 en Delphi

Algunas comprobaciones más estrictas corren por el camino. El algoritmo de digest del SignerInfo tiene que coincidir con la lista de digests del SignedData, con el identificador del algoritmo de firma y con cualquier atributo de protección de algoritmos del CMS; si no, el estado es svDigestAlgorithmMismatch. Los atributos firmados deben contener exactamente un atributo content-type que coincida con el contenido firmado; si no, svMalformed. Cuando el CMS lleva una marca de tiempo de firma RFC 3161 incrustada, ese token se verifica contra el valor de la firma y se reporta en Info.Timestamp; una marca de tiempo de documento ETSI.RFC3161 se verifica contra los rangos de bytes hasheados de la misma manera

¿Qué prueba svValid en realidad?

svValid significa dos cosas: los bytes nombrados por el /ByteRange hashean al valor que firmó el firmante, y esa firma verifica bajo la clave pública del certificado incrustado en el contenedor CMS. Integridad de bytes más vínculo de clave. No dice nada sobre quién posee esa clave. Un atacante que edita un contrato y lo re-firma con un certificado autogenerado obtiene svValid, porque las matemáticas son internamente coherentes, y el campo SignerName mostrará el nombre que el atacante escribió en el certificado

CoversWholeDocument cubre un segundo hueco. Las actualizaciones incrementales del PDF permiten a un escritor añadir contenido después de una firma sin romperla, lo cual es de diseño y así funcionan los flujos de firma múltiple. El flag se calcula durante la verificación y solo es verdadero cuando ambos segmentos más el hueco del /Contents cubren el fichero entero. SignedRevisionLength da el tamaño del prefijo firmado y UnsignedTrailingBytes el número de bytes añadidos después. Para un fichero que declara una revisión firmada de 48.000 bytes dentro de un fichero de 52.300, UnsignedTrailingBytes vale 4.300 y CoversWholeDocument es falso

Diagrama de alcance de lo que garantiza svValid en la verificación de firmas de HotPDF: integridad de bytes del ByteRange y vínculo de clave, mientras que el recorrido de cadena, la revocación y los almacenes de confianza pertenecen a una comprobación de confianza aparte, y CoversWholeDocument marca actualizaciones incrementales añadidas
svValid significa integridad de bytes más vínculo de clave y nada más; el recorrido de cadena, la revocación y los anclajes de confianza pertenecen a una comprobación de confianza aparte, y CoversWholeDocument=false señala bytes añadidos tras la firma

Un pipeline de ingesta de archivo no debería aceptar por sí solo un svValid con CoversWholeDocument falso. Ejecuta antes AnalyzeLoadedSignatureRevisions: clasifica cada revisión añadida después de la firma seleccionada, lista los nombres de campos cambiados en ChangedFieldNames y reporta si los cambios respetan los permisos DocMDP y FieldMDP que fijó el firmante, mediante DocMDPCompliant y FieldMDPCompliant. Una firma posterior añadida en un campo de firma vacío es rutina. Una revisión que reescribe objetos de página no lo es, y los ChangeKinds del análisis son lo que distingue esos dos casos

Comprobar el firmante contra tus propios anclajes de confianza

La confianza es una llamada aparte en HotPDF, y esa separación es la opción por defecto correcta. VerifyLoadedSignatureWithTrust ejecuta primero la misma verificación de byte-range y devuelve cvsSignatureInvalid si falla, y después construye una ruta de certificados desde el firmante hasta los anclajes que pases en THPDFCertificateValidationOptions.TrustAnchors. Evalúa por el camino la evidencia de revocación: las respuestas OCSP y las CRL guardadas en los diccionarios DSS y /VRI del documento se recogen automáticamente, y las que suministres en OCSPResponses o CRLs se añaden al conjunto

uses
  System.IOUtils;

var
  Options: THPDFCertificateValidationOptions;
  Info: THPDFSignatureInfo;
  Trust: THPDFCertificateValidationStatus;
begin
  Options := THPDFCertificateValidationOptions.Default;
  SetLength(Options.TrustAnchors, 1);
  // Certificado raíz codificado en DER; convierte los ficheros PEM antes de cargar
  Options.TrustAnchors[0] := TFile.ReadAllBytes('company-root.cer');
  Options.RevocationMode := rvmBestEffort;

  Trust := Pdf.VerifyLoadedSignatureWithTrust(0, Options, Info);
  if Trust = cvsTrusted then
    Writeln('Signed by a certificate chaining to our root')
  else
    Writeln('Not trusted: ', Info.CertificateValidation.Issue);
end;

El modo de revocación es una decisión de política. rvmBestEffort usa la evidencia disponible y sigue adelante cuando no encuentra ninguna, mientras que rvmRequire convierte la evidencia ausente en cvsRevocationUnknown. Para contratos que se auditarán años después, rvmRequire es el ajuste más seguro, siempre que tus firmantes incrusten datos OCSP o CRL en el momento de firmar; sin esa evidencia en el fichero, todos los documentos vuelven cvsRevocationUnknown

¿Por qué los documentos cargados de stream devuelven svSourceUnavailable?

Las llamadas respaldadas por fichero, es decir el VerifyLoadedSignature de un argumento, el VerifyLoadedSignatureEx y el VerifyLoadedSignatureWithTrust de fichero, necesitan que el componente recuerde de qué fichero vino el documento. Un documento cargado con LoadFromStream no tiene nombre de fichero que reabrir. Lo mismo pasa tras la recarga con contraseña que se usa para documentos cifrados, descrita en el artículo sobre cifrado PDF AES-256 en Delphi, porque el componente suelta su referencia al fichero fuente en cuanto ha descifrado el documento. En ambos casos las sobrecargas respaldadas por fichero devuelven svSourceUnavailable y no adivinan

Las sobrecargas con TStream toman los bytes originales en bruto de donde los hayas guardado: un fichero, un búfer en memoria, un blob de base de datos. La posición del stream se restaura tras el hasheo, así que el mismo stream puede pasarse a varios índices de firma a su vez. VerifyAllLoadedSignatures, que devuelve verdadero solo cuando existe al menos un campo de firma y cada campo verifica como svValid, va por el camino respaldado por fichero, así que sobre un documento cargado de stream devuelve falso sea lo que sea lo que contengan las firmas. Itera en su lugar sobre la sobrecarga de stream

function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Ayudante para que añada el lector: un equivalente basado en stream de
// VerifyAllLoadedSignatures para documentos cargados con LoadFromStream
var
  I, Count: Integer;
  Info: THPDFSignatureInfo;
begin
  Count := Pdf.GetLoadedSignatureFieldCount;
  Result := Count > 0;
  for I := 0 to Count - 1 do
    if Pdf.VerifyLoadedSignature(I, Src, Info) <> svValid then
    begin
      Writeln(Info.FieldName, ': status ', Ord(Info.Status));
      Exit(False);
    end;
end;

La verificación de byte-range, la construcción de rutas a anclajes de confianza, la firma PAdES y el cifrado AES-256 viven todos en la misma biblioteca VCL nativa para Delphi y C++Builder, con el hasheo y las comprobaciones de padding RSA hechos en código Pascal; las ediciones, las versiones de IDE soportadas y la lista de características más amplia están en la página de producto del HotPDF Delphi Component