Artículo técnico

Chequeos de política ISO/TS 32002 ECDSA y EdDSA en PDFium

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
Matriz del perfil de algoritmos ISO TS 32002 en PDFium Component: P-256, P-384 y P-521 aceptan solo anchos de digest coincidentes, brainpoolP256r1 acepta 256 a 512 bits, brainpoolP384r1 acepta 384 y 512, Ed25519 y Ed448 declaran SHA-512 y SHAKE256 con largo 512, y los desajustes levantan ppeiSignatureAlgorithmMismatch mientras las curvas fuera del perfil devuelven pcsUnsupported
Seis curvas ECDSA y dos esquemas EdDSA pueden pasar, y cada curva está atada a los anchos de digest que puede llevar; todo lo demás es inválido o no soportado, jamás aceptado en silencio

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

Cómo el PDFium Component inspecciona la tripleta de algoritmos de una firma PDF: InspectPadesSignatureAlgorithm lee el digestAlgorithm y el signatureAlgorithm del primer SignerInfo del CMS, fija el certificado firmante vía un match exacto de issuerAndSerialNumber entre a lo más 64 candidatos, lee el SubjectPublicKeyInfo para la curva, y EvaluatePadesSignatureAlgorithm devuelve el AlgorithmPolicyStatus
PDFium por sí solo ni verifica el CMS ni expone la curva del firmante, así que la capa PAdES parsea el SignedData y guarda cada OID crudo en el registro para un rechazo explicable

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

Camino de decisión de EvaluatePadesSignatureAlgorithm en PDFium Component: un desajuste de digest fija pcsInvalid y ppeiSignatureAlgorithmMismatch, una curva nombrada fuera del perfil ISO TS 32002 como brainpoolP160r1 fija pcsUnsupported, un certificado firmante que no se puede fijar fija pcsIndeterminate, y la rama RSA aplica los suites de digest ETSI TS 119 312, con el tamaño de llave todavía en manos de la aplicación
Los tres estados no válidos significan cosas distintas: inválido es prueba de una combinación rota, no soportado es un resultado de capacidad, e indeterminado significa que el código se negó a adivinar

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