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