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