Una clave P-256 puede firmar un digest SHA-512 y las matemáticas no se quejarán. 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 las firmas de curva elíptica y EdDSA a PDF, no permite ese emparejamiento, porque ata cada curva a los anchos de digest que puede llevar. La misma factura firmada puede así pasar una comprobación criptográfica en una máquina y suspender en un validador que aplica el perfil de algoritmos de PDF 2.0, y ambos veredictos son correctos respecto a la pregunta que cada uno hizo
Qué pares curva-digest acepta ISO/TS 32002
ISO/TS 32002 acepta seis curvas ECDSA y dos esquemas EdDSA. El PDFium Component comprueba cada firma PDF contra ese perfil y reporta el veredicto en TPadesSignatureValidation.AlgorithmPolicyStatus, claveado por el OID de curva del certificado del firmante. Las curvas NIST son estrictas: el digest debe tener el mismo ancho de bits que la curva, de la familia SHA-2 o de la SHA-3. Las curvas Brainpool r1 son más laxas 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 caza a las herramientas de firma que eligen un digest y lo reutilizan para todas las claves. 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 sigue fuera de la tabla. Una clave sobre 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 otro cubo. Mientras su digest declarado y su algoritmo de firma concuerden, recibe pcsUnsupported
EdDSA no deja opciones, solo reglas de codificación
Ed25519 y Ed448 no tienen parámetro de curva ni opción de digest, así que toda 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 lleva toda firma PAdES, declara id-shake256-len (2.16.840.1.101.3.4.2.18) con un parámetro INTEGER de exactamente 512. RFC 8410 añade que el AlgorithmIdentifier de la firma (1.3.101.112 para Ed25519, 1.3.101.113 para Ed448) y el AlgorithmIdentifier de la clave pública del certificado no llevan parámetro alguno
Muchos codificadores ASN.1 añaden un NULL explícito a cada OID de algoritmo porque los identificadores RSA siempre lo han llevado, y el hábito sobrevive cuando alguien enchufa Ed25519 a una ruta de firma existente. La clave está bien. El valor de la firma está bien. La codificación no, y el PDFium Component devuelve pcsInvalid cuando hay campo de parámetros en cualquiera de los dos identificadores, cuando el digest Ed25519 es cualquier cosa distinta de SHA-512 sin parámetros, o cuando el digest Ed448 no es id-shake256-len con 512. Un certificado cuyo OID de clave pertenece al otro esquema EdDSA, o a otro algoritmo, también da pcsInvalid
Leer el trío 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 del firmante. La capa de inspección PAdES construida sobre PDFium parsea por tanto el CMS SignedData (RFC 5652) por su cuenta. InspectPadesSignatureAlgorithm lee el digestAlgorithm y el signatureAlgorithm del primer SignerInfo, localiza el certificado del firmante en el conjunto certificates y lee el algoritmo de clave y la curva de su SubjectPublicKeyInfo. Digest, algoritmo de firma, clave más curva: esos tres valores son los que juzga la política
Un conjunto de certificados CMS no tiene orden y suele llevar el certificado del firmante al lado de su CA emisora, y ambos pueden ser claves 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 empareja issuer y número de serie de issuerAndSerialNumber byte a byte, examina como mucho 64 certificados y solo recurre a "el único certificado que hay" cuando el conjunto contiene exactamente un certificado parseable. Cualquier otro resultado deja los campos de clave del record vacíos
TPdf.ValidatePades ejecuta la política durante su pasada de conformidad, primero contra el certificado encontrado dentro del CMS. Después verifica la firma con el verificador CMS de la plataforma: Windows CryptoAPI por defecto en Windows, o un verificador OpenSSL o Keychain de macOS registrado mediante ConfigureSslCmsVerifier o ConfigureKeychainCmsVerifier. Cuando el verificador reporta qué certificado usó realmente, la política corre otra vez sobre ese certificado y su resultado sustituye al primero. TPdf.ValidatePadesTrust en la edición Enterprise sigue el mismo orden mientras además construye la cadena y, si se le pide, comprueba la revocación. Las entradas crudas acaban 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 suelen explicar un rechazo antes de que nadie abra un dump ASN.1. DigestParameterBits muestra la longitud Ed448, SignatureParametersPresent destapa el NULL colado, y PublicKeyParametersAreNamedCurve cubre la codificación de curva de la sección siguiente. Un PublicKeyAlgorithmOid vacío significa que el certificado del firmante nunca quedó fijado
¿Por qué una firma P-256 con SHA3-256 suspende 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 por separado es aceptable para P-256; 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 clavado en el código produce exactamente este archivo, y un verificador conforme no tiene forma consistente de leerlo
EvaluatePadesSignatureAlgorithm es público y toma un record plano, así que la matriz puede fijarse en un test unitario sin construir un PDF. Las llamadas Assert de abajo son comprobaciones de tu propio test:
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); // digest que no cuadra
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; // explicit curve parameters
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsInvalid);
Info.PublicKeyAlgorithmOid := ''; // signer certificate not found
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 con nombre, una curva implícita (NULL) o un juego de parámetros explícito completo, y la misma sección restringe los certificados PKIX a la forma con nombre. El PDFium Component devuelve pcsInvalid para un certificado id-ecPublicKey con parámetros ausentes, implícitos o explícitos. Los parámetros explícitos deletrean el primo, los coeficientes y el punto base, lo que permite a un atacante describir una curva que solo se parece a una estándar, y un comprobador que los aceptara tendría que demostrar que los números coinciden con una curva con nombre antes de fiarse de nada más
Invalid, unsupported e indeterminate son tres respuestas distintas
Los tres valores no válidos de AlgorithmPolicyStatus llevan significados distintos, y colapsarlos en un único cubo de "fallido" tira la información que un auditor necesita. pcsInvalid significa que una combinación de algoritmos reconocida está malformada o desajustada. Añade ppeiSignatureAlgorithmMismatch a TPadesValidationResult.Issues y lleva el IntegrityStatus agregado a pcsInvalid, así que IsCryptographicallyValid devuelve False incluso cuando el valor de la firma CMS verifica
pcsUnsupported significa que la curva o el digest quedan fuera de lo que el perfil nombra. Es un resultado de capacidad, y deja IntegrityStatus tranquilo. pcsIndeterminate significa que el PDFium Component se negó a adivinar: no se pudo fijar el certificado del firmante, típicamente un conjunto de certificados con varios candidatos y sin coincidencia exacta de issuerAndSerialNumber, o el SignerInfo no se pudo parsear lo suficiente para leer sus algoritmos. En el 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 sabe comprobar Ed25519 o Ed448, CmsSignatureStatus vuelve pcsUnsupported mientras AlgorithmPolicyStatus puede seguir siendo pcsValid, calculado a partir del certificado hallado en el CMS. La codificación era correcta; solo faltaba el verificador. Fusionarlos obligaría a elegir entre llamar rota a una firma bien formada o llamar buena a una sin comprobar
Para un pipeline de admisión, rechaza automáticamente con pcsInvalid y con nada más. Tratar pcsUnsupported como rechazo convierte una curva que tu política nunca listó en una acusación de manipulación, y el remitente no tiene forma de arreglar lo que nunca estuvo roto. Manda los resultados unsupported e indeterminate 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 esta comprobación, la guía de por qué los validadores rechazan firmas PAdES recorre las demás causas habituales, desde huecos en el ByteRange hasta un /M de hora de firma malformado
¿Qué deja pcsValid en tus manos?
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 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 usa EN 319 102-1 cuando un algoritmo ya no se considera fiable 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 discrepa 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 clave de firmante no RSA. Un certificado de 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 además una comprobación de parámetros: los parámetros PSS deben estar presentes y bien formados, su hash debe igualar el digestAlgorithm declarado, el campo trailer debe ser 1, y una clave de certificado restringida a PSS debe concordar con ellos. El artículo sobre RSASSA-PSS-params del RFC 4055 cubre cómo se codifican esos parámetros en el lado de firma. La longitud del módulo queda fuera de la política, así que una aplicación que quiera un suelo de 3072 bits se lo impone ella misma. SHA-1 o MD5 en el digestAlgorithm levantan además el issue separado ppeiBadDigestAlgorithm. Cuando los signed attributes llevan el atributo cms-algorithm-protection del RFC 6211, sus dos identificadores se comparan con los valores del SignerInfo byte a byte, y una diferencia levanta ppeiCmsAlgorithmProtectionMismatch y fracasa la integridad; VerifyCmsAlgorithmProtection ejecuta esa comparación sobre un blob CMS crudo
La matemática de la firma, la cadena de certificados y la revocación se quedan con CmsSignatureStatus, CertificateTrustStatus y RevocationStatus, que vienen del verificador CMS. Lee pcsValid como "el perfil de algoritmos se sostiene" y nunca como "esta clave es suficientemente fuerte". Para una aplicación Delphi que acepta facturas, contratos o paquetes de archivo firmados, todo el montaje cabe en unas líneas: ejecuta ValidatePadesTrust, rechaza con ppeiSignatureAlgorithmMismatch, enruta pcsUnsupported y pcsIndeterminate a un revisor, y aplica tu propio suelo de tamaño de clave RSA
La misma biblioteca que ejecuta estas comprobaciones produce también 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 nunca a un cliente. Ediciones, soporte de plataformas y el pipeline de firma están descritos en la página de producto de PDFium Component for Delphi and Lazarus