Una llave P-256 puede firmar un digest SHA-512 y la matemática no objecta. ECDSA trunca el hash a los 256 bits más a la izquierda, la firma verifica, y un verificador CMS reporta el valor de la firma como intacto. ISO/TS 32002, la extensión de PDF 2.0 que trajo firmas de curva elíptica y EdDSA al PDF, no permite ese emparejamiento, porque ata cada curva a los anchos de digest que puede llevar. La misma factura firmada puede por lo tanto pasar un chequeo criptográfico en una máquina y fallar en un validador que aplica el perfil de algoritmos de PDF 2.0, y ambos veredictos son correctos sobre la pregunta que cada uno hizo
Qué pares de curva y digest acepta ISO/TS 32002
ISO/TS 32002 acepta seis curvas ECDSA y dos esquemas EdDSA. El PDFium Component chequea cada firma PDF contra ese perfil y reporta el veredicto en TPadesSignatureValidation.AlgorithmPolicyStatus, indexado por el OID de curva del certificado firmante. Las curvas NIST son estrictas: el digest debe tener el mismo ancho de bits que la curva, de la familia SHA-2 o SHA-3. Las curvas Brainpool r1 son más flexibles y aceptan su propio ancho o cualquier cosa más ancha:
- P-256 (
1.2.840.10045.3.1.7): solo SHA-256 o SHA3-256 - P-384 (
1.3.132.0.34): solo SHA-384 o SHA3-384 - P-521 (
1.3.132.0.35): solo SHA-512 o SHA3-512 - brainpoolP256r1 (
1.3.36.3.3.2.8.1.1.7): cualquier digest SHA-2 o SHA-3 de 256 a 512 bits - brainpoolP384r1 (
1.3.36.3.3.2.8.1.1.11): SHA-2 / SHA-3 de 384 o 512 bits - brainpoolP512r1 (
1.3.36.3.3.2.8.1.1.13): solo SHA-512 o SHA3-512
La asimetría atrapa a las herramientas de firma que eligen un digest y lo reusan para cada llave. SHA-512 en todas partes parece la elección prudente, y en brainpoolP256r1 se acepta. En P-256 la configuración idéntica produce pcsInvalid: la curva está en el perfil, el digest es fuerte, y el emparejamiento igual queda fuera de la tabla. Una llave en una curva que el perfil nunca nombra, como brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) o secp256k1 (1.3.132.0.10), cae en un balde distinto. Mientras su digest declarado y su algoritmo de firma concuerden, recibe pcsUnsupported
EdDSA no deja elecciones, solo reglas de codificación
Ed25519 y Ed448 no tienen parámetro de curva ni opción de digest, así que cada regla que el PDFium Component les aplica concierne a cómo el CMS declara el algoritmo. RFC 8419 fija el digest. Un SignerInfo Ed25519 declara SHA-512 (2.16.840.1.101.3.4.2.3) como su digestAlgorithm con el campo de parámetros ausente. Un SignerInfo Ed448 que lleva signed attributes, como toda firma PAdES lleva, declara id-shake256-len (2.16.840.1.101.3.4.2.18) con un parámetro INTEGER de exactamente 512. RFC 8410 agrega que el AlgorithmIdentifier de la firma (1.3.101.112 para Ed25519, 1.3.101.113 para Ed448) y el AlgorithmIdentifier de la llave pública del certificado no llevan parámetro alguno
Muchos encoders ASN.1 agregan un NULL explícito a cada OID de algoritmo porque los identificadores RSA siempre tuvieron uno, y el hábito sobrevive cuando alguien le enchufa Ed25519 a una ruta de firma existente. La llave está bien. El valor de la firma está bien. La codificación no, y el PDFium Component devuelve pcsInvalid cuando un campo de parámetros está presente en cualquiera de los dos identificadores, cuando el digest Ed25519 es cualquier cosa distinta de un SHA-512 sin parámetros, o cuando el digest Ed448 no es id-shake256-len con 512. Un certificado cuyo OID de llave pertenece al otro esquema EdDSA, o a algún otro algoritmo, también da pcsInvalid
Leer la tripleta de algoritmos del CMS
El motor PDFium lee el diccionario de firma, pero su API pública ni verifica el CMS ni expone la curva del certificado firmante. La capa de inspección PAdES construida sobre PDFium parsea entonces por su cuenta el CMS SignedData (RFC 5652). InspectPadesSignatureAlgorithm lee el digestAlgorithm y el signatureAlgorithm del primer SignerInfo, localiza el certificado firmante en el set certificates, y lee el algoritmo de llave y la curva de su SubjectPublicKeyInfo. Digest, algoritmo de firma, llave más curva: esos tres valores son los que la política juzga
Un set de certificados CMS es desordenado y usualmente carga el certificado firmante junto a su CA emisora, y ambos pueden ser llaves EC en curvas distintas, así que tomar el primer certificado EC dejaría que la CA decidiera qué curva usó supuestamente el firmante. El PDFium Component hace match del emisor y número de serie de issuerAndSerialNumber byte por byte, examina a lo más 64 certificados, y cae a "el único certificado que hay" solo cuando el set carga exactamente un certificado parseable. Cualquier otro resultado deja los campos de llave del record vacíos
TPdf.ValidatePades corre la política durante su pasada de conformidad, primero contra el certificado encontrado dentro del CMS. Luego verifica la firma con el verificador CMS de la plataforma: Windows CryptoAPI por default en Windows, o un verificador OpenSSL o macOS Keychain registrado a través de ConfigureSslCmsVerifier o ConfigureKeychainCmsVerifier. Cuando el verificador reporta qué certificado usó realmente, la política corre de nuevo sobre ese certificado y su resultado reemplaza al primero. TPdf.ValidatePadesTrust en la edición Enterprise sigue el mismo orden mientras además construye la cadena y, a pedido, chequea revocación. Las entradas crudas terminan en TPadesSignatureAlgorithmInfo, que este listado imprime para cada firma de un archivo:
uses
PDFium, FPdfPades;
const
StatusNames: array[TPadesCryptoStatus] of string =
('not checked', 'valid', 'invalid', 'unsupported', 'indeterminate');
var
Pdf: TPdf;
R: TPadesValidationResult;
A: TPadesSignatureAlgorithmInfo;
I: Integer;
begin
Pdf := TPdf.Create(nil);
try
Pdf.FileName := 'invoice-ecdsa-signed.pdf';
Pdf.Active := True;
R := Pdf.ValidatePades;
for I := 0 to Length(R.Signatures) - 1 do
begin
A := R.Signatures[I].AlgorithmInfo;
Writeln('Signature ', I);
Writeln(' digestAlgorithm : ', string(A.DigestAlgorithmOid),
' params=', A.DigestParametersPresent, ' bits=', A.DigestParameterBits);
Writeln(' signatureAlgorithm : ', string(A.SignatureAlgorithmOid),
' params=', A.SignatureParametersPresent);
Writeln(' public key / curve : ', string(A.PublicKeyAlgorithmOid),
' / ', string(A.CurveOid),
' namedCurve=', A.PublicKeyParametersAreNamedCurve);
Writeln(' policy : ',
StatusNames[R.Signatures[I].AlgorithmPolicyStatus]);
end;
if ppeiSignatureAlgorithmMismatch in R.Issues then
Writeln('At least one signature violates the ISO/TS 32002 profile');
finally
Pdf.Free;
end;
end;
Esos flags usualmente explican un rechazo antes de que alguien abra un volcado ASN.1. DigestParameterBits muestra el largo Ed448, SignatureParametersPresent expone el NULL suelto, y PublicKeyParametersAreNamedCurve cubre la codificación de curva discutida en la siguiente sección. Un PublicKeyAlgorithmOid vacío significa que el certificado firmante nunca quedó fijado
¿Por qué una firma P-256 con SHA3-256 falla la política?
Una firma P-256 con SHA3-256 falla siempre que el digestAlgorithm del CMS dice SHA3-256 mientras el signatureAlgorithm dice ecdsa-with-SHA256. Cada mitad es aceptable para P-256 por separado; juntas discrepan sobre qué hash se firmó. EvaluatePadesSignatureAlgorithm mapea cada OID de firma ECDSA, de ecdsa-with-SHA256 a ecdsa-with-SHA3-512, al digest que implica, lo compara con el digestAlgorithm declarado, y devuelve pcsInvalid ante cualquier diferencia antes de mirar la tabla de curvas. Una herramienta de firma que mueve su hash a SHA3-256 pero conserva un identificador de firma hard-codeado produce exactamente este archivo, y un verificador conforme no tiene forma consistente de leerlo
EvaluatePadesSignatureAlgorithm es pública y toma un record simple, así que la matriz puede fijarse en un unit test sin construir un PDF. Las llamadas Assert de abajo son chequeos de test suyos:
var
Info: TPadesSignatureAlgorithmInfo;
begin
Info := Default(TPadesSignatureAlgorithmInfo);
Info.Family := psafEcdsa;
Info.PublicKeyAlgorithmOid := '1.2.840.10045.2.1'; // id-ecPublicKey
Info.PublicKeyParametersPresent := True;
Info.PublicKeyParametersAreNamedCurve := True;
Info.CurveOid := '1.2.840.10045.3.1.7'; // P-256
Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.8'; // SHA3-256
Info.SignatureAlgorithmOid := '2.16.840.1.101.3.4.3.10'; // ecdsa-with-SHA3-256
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsValid);
Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.2'; // ecdsa-with-SHA256
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid); // el digest no coincide
Info.DigestAlgorithmOid := '2.16.840.1.101.3.4.2.3'; // SHA-512
Info.SignatureAlgorithmOid := '1.2.840.10045.4.3.4'; // ecdsa-with-SHA512
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid); // congruente, pero no para P-256
Info.CurveOid := '1.3.36.3.3.2.8.1.1.1'; // brainpoolP160r1
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // curva fuera del perfil
Info.CurveOid := '1.2.840.10045.3.1.7';
Info.PublicKeyParametersAreNamedCurve := False; // parámetros de curva explícitos
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);
Info.PublicKeyAlgorithmOid := ''; // certificado firmante no encontrado
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;
El quinto caso va de cómo el certificado codifica su curva. RFC 5480 §2.1.1 deja que ECParameters sea un OID de curva nombrada, una curva implícita (NULL) o un set completo de parámetros explícitos, y la misma sección restringe los certificados PKIX a la forma nombrada. El PDFium Component devuelve pcsInvalid para un certificado id-ecPublicKey con parámetros ausentes, implícitos o explícitos. Los parámetros explícitos especifican el primo, los coeficientes y el punto base, lo que le permite a un atacante describir una curva que meramente se parece a una estándar, y un chequeador que los aceptara tendría que probar que los números coinciden con una curva nombrada antes de confiar en cualquier otra cosa
Inválido, no soportado e indeterminado son tres respuestas distintas
Los tres valores no válidos de AlgorithmPolicyStatus cargan significados distintos, y colapsarlos en un solo balde de "falló" tira la información que un auditor necesita. pcsInvalid significa que una combinación de algoritmos reconocida está malformada o desajustada. Agrega ppeiSignatureAlgorithmMismatch a TPadesValidationResult.Issues y lleva el IntegrityStatus agregado a pcsInvalid, así que IsCryptographicallyValid devuelve False incluso cuando el valor de la firma CMS cuadra
pcsUnsupported significa que la curva o el digest está fuera de lo que el perfil nombra. Ese es un resultado de capacidad, y deja IntegrityStatus tranquilo. pcsIndeterminate significa que el PDFium Component se negó a adivinar: el certificado firmante no pudo fijarse, típicamente un set de certificados con varios candidatos y sin match exacto de issuerAndSerialNumber, o el SignerInfo no pudo parsearse lo suficiente para leer sus algoritmos. Del lado RSA el mismo valor marca un digest que las suites actuales ya no aceptan para validaciones nuevas, cubierto en la última sección
EdDSA muestra por qué el estado de política y el estado criptográfico viven en campos separados. En un sistema cuyo verificador CMS no puede chequear Ed25519 ni Ed448, CmsSignatureStatus vuelve pcsUnsupported mientras AlgorithmPolicyStatus puede seguir siendo pcsValid, calculado desde el certificado encontrado en el CMS. La codificación era correcta; solo faltó el verificador. Fusionar los dos forzaría una elección entre llamar rota una firma bien formada y llamar buena una sin chequear
Para una pipeline de intake, rechace automáticamente ante pcsInvalid y nada más. Tratar pcsUnsupported como rechazo convierte una curva que su política nunca listó en una acusación de manipulación, y el remitente no tiene forma de arreglar lo que nunca estuvo roto. Mande los resultados no soportados e indeterminados a una persona, con los OIDs de AlgorithmInfo adjuntos:
var
Pdf: TPdf;
Options: TPadesTrustValidationOptions;
R: TPadesValidationResult;
S: TPadesSignatureValidation;
I: Integer;
begin
Pdf := TPdf.Create(nil);
try
Pdf.FileName := 'invoice-ecdsa-signed.pdf';
Pdf.Active := True;
Options := TPadesTrustValidationOptions.Default; // offline, sin revocación
R := Pdf.ValidatePadesTrust(Options);
for I := 0 to Length(R.Signatures) - 1 do
begin
S := R.Signatures[I];
if S.IsDocumentTimeStamp then
Continue;
case S.AlgorithmPolicyStatus of
pcsInvalid: Writeln(I, ': reject, algorithm combination is invalid');
pcsUnsupported: Writeln(I, ': manual review, algorithm outside the profile: ',
string(S.AlgorithmInfo.SignatureAlgorithmOid), ' / ',
string(S.AlgorithmInfo.CurveOid));
pcsIndeterminate: Writeln(I, ': manual review, signer not identified or digest no longer accepted');
pcsValid:
if S.AlgorithmInfo.Family = psafRsa then
Writeln(I, ': RSA digest suite accepted, check key size yourself')
else
Writeln(I, ': EC/EdDSA profile satisfied');
end;
if (S.CmsSignatureStatus = pcsUnsupported) and
(S.AlgorithmPolicyStatus = pcsValid) then
Writeln(I, ': encoding conforms, but no verifier here can check this algorithm');
end;
Writeln('Cryptographically valid: ', R.IsCryptographicallyValid);
finally
Pdf.Free;
end;
end;
Si el rechazo viene de Adobe Acrobat o de un validador basado en DSS en lugar de este chequeo, la guía de por qué los validadores rechazan firmas PAdES recorre las otras causas comunes, desde huecos de ByteRange hasta un /M con hora de firma malformado
¿Qué le deja a usted pcsValid?
AlgorithmPolicyStatus = pcsValid certifica el perfil de algoritmos y nada más: una curva aprobada con un digest congruente y correctamente codificado para ECDSA y EdDSA, o un digest de una suite actual para RSA. Para firmas RSA EvaluatePadesSignatureAlgorithm aplica las suites de ETSI TS 119 312. MD2, MD4 y MD5 son pcsInvalid. SHA-1 y los digests de 112 bits (SHA-224, SHA-512/224, SHA3-224) son pcsIndeterminate, el resultado que EN 319 102-1 usa cuando un algoritmo ya no se considera confiable y no se evaluó prueba de existencia previa, así que una firma SHA-1 conserva su resultado de integridad y va a revisión. Un digestAlgorithm que difiere del digest fijado por el OID de firma, como sha256WithRSAEncryption sobre un digest SHA-1, es pcsInvalid, y también lo es un algoritmo de firma RSA sobre una llave de firmante no RSA. Un certificado firmante ausente da pcsIndeterminate, y digests desconocidos u OIDs que no son de firma del arco PKCS #1 dan pcsUnsupported
Las firmas RSASSA-PSS reciben un chequeo de parámetros además: los parámetros PSS deben estar presentes y bien formados, su hash debe ser igual al digestAlgorithm declarado, el campo trailer debe ser 1, y una llave de certificado restringida a PSS debe concordar con ellos. El artículo de RSASSA-PSS-params de RFC 4055 cubre cómo se codifican esos parámetros del lado de firma. El largo del módulo está fuera de la política, así que una aplicación que quiere un piso de 3072 bits lo impone ella misma. SHA-1 o MD5 en el digestAlgorithm también levanta el issue aparte ppeiBadDigestAlgorithm. Cuando los signed attributes cargan el atributo cms-algorithm-protection de RFC 6211, sus dos identificadores se comparan con los valores del SignerInfo byte por byte, y una diferencia levanta ppeiCmsAlgorithmProtectionMismatch y falla la integridad; VerifyCmsAlgorithmProtection corre esa comparación sobre un blob CMS crudo
La matemática de la firma, la cadena de certificados y la revocación quedan con CmsSignatureStatus, CertificateTrustStatus y RevocationStatus, que vienen del verificador CMS. Lea pcsValid como "el perfil de algoritmos se cumple" y nunca como "esta llave es suficientemente fuerte". Para una aplicación Delphi que acepta facturas, contratos o paquetes de archivo firmados, la configuración completa cabe en pocas líneas: corra ValidatePadesTrust, rechace ante ppeiSignatureAlgorithmMismatch, derive pcsUnsupported y pcsIndeterminate a un revisor, y aplique su propio piso de tamaño de llave RSA
La misma biblioteca que corre estos chequeos también produce firmas PAdES, así que un equipo puede firmar con P-384 o Ed25519 y confirmar que su propia salida satisface el perfil ISO/TS 32002 antes de que llegue a un cliente. Las ediciones, el soporte de plataformas y el pipeline de firma están descritos en la página de producto del PDFium Component for Delphi and Lazarus