Artículo técnico

Verificar firmas digitales PDF en Delphi con HotPDF

Un verificador de firmas PDF hecho a mano puede rechazar cada archivo correctamente firmado que recibe mientras lee cada byte correctamente. Extrae el blob CMS de /Contents, ubica los atributos firmados, los hashea 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 están etiquetados [0] IMPLICIT, así que su primer byte es 0xA0, mientras que 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. Cambie ese byte antes de hashear y las firmas "falsificadas" se vuelven válidas

Ese desajuste de etiqueta es el primero de varios lugares donde una comprobación de firma PDF puede salir mal, y los otros son menos obvios. Una firma puede ser matemáticamente perfecta sobre un archivo que se editó después de firmar. Puede ser perfecta sobre un documento que un atacante volvió a firmar con un certificado hecho por él mismo. Una contraparte devuelve un contrato firmado, su flujo de trabajo tiene que archivarlo, y alguien pregunta si este es el documento que usted envió, byte por byte, firmado por el certificado que afirma. Producir esas firmas en primer lugar se cubre en el artículo complementario sobre crear firmas digitales PAdES en Delphi; este corre en la dirección opuesta, partiendo de un archivo que llega ya firmado

Dónde viven los bytes firmados en un archivo PDF

Una firma PDF protege rangos de bytes del archivo en disco, y HotPDF verifica exactamente contra 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 arreglo /ByteRange a su lado que nombra las regiones que la firma cubre. En la práctica el arreglo contiene dos pares de offset y longitud: todo desde el offset 0 hasta el string hexadecimal de /Contents, y todo lo que viene después. Una firma no puede cubrir su propio valor, así que el archivo se hashea alrededor de ese hueco

La consecuencia para cualquier verificador es contundente. Debe hashear el original serializado. Un modelo de objetos parseado no sirve aquí, porque escribir de vuelta incluso un documento sin tocar produce bytes distintos. HotPDF lee por lo tanto el archivo fuente desde el que se cargó el documento, o un TStream de bytes crudos que usted suministra, 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 ByteRange del archivo de origen alrededor del hueco de Contents, mientras el modelo analizado en memoria nunca se somete a hash porque volver a serializar cambia los bytes
La verificación calcula el hash de los dos segmentos ByteRange de los bytes de origen exactamente como fueron serializados; un modelo analizado en memoria es inútil porque volver a serializar incluso un documento sin cambios produce bytes distintos

El hueco en sí merece sospecha. Los bytes fuera de los rangos firmados son bytes que un lector igual puede parsear, y un hueco que contiene cualquier cosa además del valor de la firma es la puerta para un ataque de envoltura de firma. HotPDF comprueba que /ByteRange arranque en el offset 0, que el segundo segmento empiece después de que termina el primero, que ambos queden dentro del archivo, y que el hueco no contenga nada más que los dígitos hexadecimales del propio /Contents de esta firma, opcionalmente con sus delimitadores < y >. Un archivo que falla cualquiera de esas devuelve svInvalidByteRange, aun cuando la matemática del CMS hubiera 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 interfaz solo necesita mostrar quién firmó y cuándo. Los campos de firma se indexan desde 0 en el orden de los campos del formulario, y GetLoadedSignatureFieldCount devuelve cuántos hay. Un índice más allá del final lanza una excepción en lugar de devolver un registro vacío, así que itere sobre el conteo

El registro THPDFSignatureInfo devuelto lleva el nombre del campo, el /SubFilter, el nombre común del certificado del firmante, los nombres distinguidos del sujeto y del emisor, 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, si no, de la entrada /M del diccionario. También reporta los nombres de los algoritmos 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 firmas está detrás de la guarda de compilador de Delphi 2009 y posteriores

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 corre la comprobación completa para un documento cargado desde archivo y devuelve el registro de información poblado en la misma llamada. Reabre el archivo fuente, valida /ByteRange, hashea los dos segmentos con el algoritmo de digest del SignerInfo, compara el resultado con el atributo firmado messageDigest y luego 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 realmente emiten. Los digests incluyen SHA-1, SHA-256, SHA-384, SHA-512, la familia SHA-3 y SHAKE256. Las firmas pueden ser RSA con relleno 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 pasan por un proveedor de plataforma respaldado por CNG de Windows o una biblioteca OpenSSL, así que en una máquina donde el proveedor necesario no se puede cargar el resultado es svUnsupportedAlgorithm o svCryptoProviderError en lugar de un veredicto sobre el archivo. VerifyLoadedSignatureWithOptions acepta un registro THPDFCMSVerifyOptions cuando necesita apuntar a una biblioteca OpenSSL específica o enchufar su propio THPDFSignatureProvider

Pipeline de VerifyLoadedSignatureEx en HotPDF para Delphi: reabrir el archivo de origen, calcular el hash de los segmentos ByteRange, compararlo con el atributo firmado messageDigest del CMS y luego verificar la firma con la clave pública del certificado del firmante, produciendo svValid, svDigestMismatch o svSignatureInvalid
VerifyLoadedSignatureEx recalcula el hash de los segmentos ByteRange, lo compara con el atributo firmado messageDigest y verifica la firma sobre el DER SET de atributos firmados antes de reportar svValid o un estado de fallo específico
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 afuera parecen misteriosos. El primero es el reetiquetado del párrafo inicial: HotPDF hashea los atributos firmados con su byte inicial reescrito a 0x31, exactamente como prescribe RFC 5652 §5.4. El segundo es el relleno. Las herramientas de firma reservan un presupuesto fijo de bytes para /Contents antes de que la firma exista y llenan 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 corrida de ceros al final de /Contents es normal. La misma familia de riesgos de parseo ASN.1, vista desde el lado de la importación de certificados, es el tema de el artículo sobre el endurecimiento de seguridad de PKCS#12 y ASN.1 en Delphi

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

¿Qué prueba realmente svValid?

svValid significa dos cosas: los bytes nombrados por /ByteRange hashean al valor que el firmante firmó, y esa firma verifica bajo la clave pública del certificado incrustado en el contenedor CMS. Integridad de bytes más vinculación de clave. No dice nada sobre quién es dueño de esa clave. Un atacante que edita un contrato y lo vuelve a firmar con un certificado autogenerado obtiene svValid, porque la matemática es internamente consistente, y el campo SignerName mostrará el nombre que el atacante haya escrito en el certificado

CoversWholeDocument cubre una segunda brecha. Las actualizaciones incrementales de PDF permiten a un escritor agregar contenido después de una firma sin romperla, lo que es por diseño y es como funcionan los flujos de trabajo con varias firmas. La bandera se calcula durante la verificación y es verdadera solo cuando ambos segmentos más el hueco de /Contents abarcan el archivo completo. SignedRevisionLength da el tamaño del prefijo firmado y UnsignedTrailingBytes la cantidad de bytes agregados después. Para un archivo que declara una revisión firmada de 48,000 bytes dentro de un archivo de 52,300 bytes, UnsignedTrailingBytes es 4,300 y CoversWholeDocument es falso

Diagrama de alcance de lo que svValid garantiza en la verificación de firmas de HotPDF: integridad de bytes de ByteRange y vinculación de clave, mientras que el recorrido de la cadena, la revocación y los almacenes de confianza pertenecen a una comprobación de confianza separada y CoversWholeDocument señala actualizaciones incrementales anexadas
svValid significa integridad de bytes más vinculación de clave y nada más; el recorrido de la cadena, la revocación y las anclas de confianza pertenecen a una comprobación de confianza separada, y CoversWholeDocument=false señala bytes anexados después de firmar

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

Comprobar al firmante contra sus propias anclas de confianza

La confianza es una llamada aparte en HotPDF, y esa separación es el valor por defecto correcto. VerifyLoadedSignatureWithTrust corre primero la misma verificación de rango de bytes, devolviendo cvsSignatureInvalid si eso falla, y luego construye una ruta de certificados desde el firmante hasta las anclas que usted pasa en THPDFCertificateValidationOptions.TrustAnchors. Evalúa la evidencia de revocación por el camino: las respuestas OCSP y las CRL almacenadas en los diccionarios DSS y /VRI del documento se recogen automáticamente, y cualquiera que usted suministre en OCSPResponses o CRLs se agrega 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; convierta los archivos 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 que haya disponible y sigue adelante cuando no encuentra ninguna, mientras que rvmRequire convierte la evidencia faltante en cvsRevocationUnknown. Para contratos que se auditarán años después, rvmRequire es el ajuste más seguro, siempre que sus firmantes incrusten datos OCSP o CRL al momento de firmar; sin esa evidencia en el archivo, cada documento vuelve como cvsRevocationUnknown

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

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

Las sobrecargas con TStream toman los bytes crudos originales de donde sea que los haya guardado: un archivo, un buffer en memoria, un blob de base de datos. La posición del stream se restaura después de hashear, así que el mismo stream se puede pasar a varios índices de firma por turno. VerifyAllLoadedSignatures, que devuelve verdadero solo cuando existe al menos un campo de firma y todos los campos verifican como svValid, pasa por la ruta respaldada por archivo, así que en un documento cargado desde stream devuelve falso sin importar lo que contengan las firmas. Itere en cambio sobre la sobrecarga de stream

function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Helper para que el lector agregue: 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 rangos de bytes, la construcción de rutas hacia anclas 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 hashing RSA y las comprobaciones de relleno hechas en código Pascal; las ediciones, las versiones de IDE soportadas y la lista completa de funciones están en la página de producto del HotPDF Delphi Component