Uma chave P-256 pode assinar um digest SHA-512 e a matemática não objeta. O ECDSA trunca o hash para os 256 bits mais à esquerda, a assinatura verifica, e um verificador CMS reporta o valor da assinatura como intacto. A ISO/TS 32002, a extensão do PDF 2.0 que trouxe assinaturas de curva elíptica e EdDSA para o PDF, não permite esse pareamento, porque ela liga cada curva às larguras de digest que ela pode carregar. A mesma nota fiscal assinada pode então passar numa checagem criptográfica numa máquina e falhar num validador que aplica o profile de algoritmos do PDF 2.0, e os dois vereditos estão certos sobre a pergunta que cada um fez
Quais pares de curva e digest a ISO/TS 32002 aceita
A ISO/TS 32002 aceita seis curvas ECDSA e dois esquemas EdDSA. O PDFium Component checa toda assinatura PDF contra esse profile e reporta o veredito em TPadesSignatureValidation.AlgorithmPolicyStatus, indexado pelo OID de curva no certificado do signatário. As curvas NIST são estritas: o digest precisa ter a mesma largura em bits da curva, da família SHA-2 ou SHA-3. As curvas Brainpool r1 são mais folgadas e aceitam a própria largura delas ou qualquer coisa mais larga:
- P-256 (
1.2.840.10045.3.1.7): apenas SHA-256 ou SHA3-256 - P-384 (
1.3.132.0.34): apenas SHA-384 ou SHA3-384 - P-521 (
1.3.132.0.35): apenas SHA-512 ou SHA3-512 - brainpoolP256r1 (
1.3.36.3.3.2.8.1.1.7): qualquer digest SHA-2 ou SHA-3 de 256 a 512 bits - brainpoolP384r1 (
1.3.36.3.3.2.8.1.1.11): SHA-2 / SHA-3 de 384 ou 512 bits - brainpoolP512r1 (
1.3.36.3.3.2.8.1.1.13): apenas SHA-512 ou SHA3-512
A assimetria pega ferramentas de assinatura que escolhem um digest e o reutilizam para toda chave. SHA-512 em todo lugar parece a escolha cautelosa, e em brainpoolP256r1 é aceito. Em P-256 a configuração idêntica produz pcsInvalid: a curva está no profile, o digest é forte, e mesmo assim o pareamento está fora da tabela. Uma chave numa curva que o profile nunca nomeia, como brainpoolP160r1 (1.3.36.3.3.2.8.1.1.1) ou secp256k1 (1.3.132.0.10), cai num balde diferente. Enquanto o digest declarado e o algoritmo de assinatura dela concordarem, ela recebe pcsUnsupported
EdDSA não deixa escolhas, só regras de encoding
Ed25519 e Ed448 não têm parâmetro de curva nem opção de digest, então toda regra que o PDFium Component aplica a eles diz respeito a como o CMS declara o algoritmo. A RFC 8419 fixa o digest. Um SignerInfo Ed25519 declara SHA-512 (2.16.840.1.101.3.4.2.3) como o digestAlgorithm dele com o campo de parâmetros ausente. Um SignerInfo Ed448 que carrega signed attributes, o que toda assinatura PAdES carrega, declara id-shake256-len (2.16.840.1.101.3.4.2.18) com um parâmetro INTEGER de exatamente 512. A RFC 8410 acrescenta que o AlgorithmIdentifier da assinatura (1.3.101.112 para Ed25519, 1.3.101.113 para Ed448) e o AlgorithmIdentifier da chave pública do certificado não carregam parâmetro algum
Muitos codificadores ASN.1 anexam um NULL explícito a todo OID de algoritmo porque identificadores RSA sempre tiveram um, e o hábito sobrevive quando alguém encaixa Ed25519 num caminho de assinatura existente. A chave está boa. O valor da assinatura está bom. O encoding não está, e o PDFium Component devolve pcsInvalid quando um campo de parâmetros está presente em qualquer um dos identificadores, quando o digest Ed25519 é qualquer coisa diferente de SHA-512 sem parâmetros, ou quando o digest Ed448 não é id-shake256-len com 512. Um certificado cujo OID de chave pertence ao outro esquema EdDSA, ou a algum outro algoritmo, também rende pcsInvalid
Lendo o triplo de algoritmos do CMS
O motor PDFium lê o dicionário de assinatura, mas a API pública dele nem verifica o CMS nem expõe a curva do certificado do signatário. A camada de inspeção PAdES construída sobre o PDFium portanto faz o parsing do CMS SignedData (RFC 5652) por conta própria. InspectPadesSignatureAlgorithm lê o digestAlgorithm e o signatureAlgorithm do primeiro SignerInfo, localiza o certificado do signatário no conjunto certificates e lê o algoritmo e a curva da chave do SubjectPublicKeyInfo dele. Digest, algoritmo de assinatura, chave mais curva: esses três valores são o que a política julga
Um conjunto de certificados CMS é sem ordem e normalmente guarda o certificado do signatário ao lado da CA emissora dele, e ambos podem ser chaves EC em curvas diferentes, então pegar o primeiro certificado EC deixaria a CA decidir qual curva o signatário supostamente usou. O PDFium Component casa o emissor e o número de série do issuerAndSerialNumber byte a byte, examina no máximo 64 certificados e só cai para "o único certificado que existe" quando o conjunto tem exatamente um certificado parseável. Qualquer outro resultado deixa os campos de chave do record vazios
TPdf.ValidatePades roda a política durante o passe de conformidade dele, primeiro contra o certificado achado dentro do CMS. Ele então verifica a assinatura com o verificador CMS da plataforma: Windows CryptoAPI por padrão no Windows, ou um verificador OpenSSL ou macOS Keychain registrado via ConfigureSslCmsVerifier ou ConfigureKeychainCmsVerifier. Quando o verificador reporta qual certificado realmente usou, a política roda de novo sobre esse certificado e o resultado dela substitui o primeiro. TPdf.ValidatePadesTrust na edição Enterprise segue a mesma ordem enquanto também constrói a cadeia e, a pedido, checa revogação. As entradas brutas acabam em TPadesSignatureAlgorithmInfo, que esta listagem imprime para cada assinatura num arquivo:
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;
Essas flags costumam explicar uma rejeição antes de qualquer um abrir um dump ASN.1. DigestParameterBits mostra o comprimento do Ed448, SignatureParametersPresent expõe o NULL solto, e PublicKeyParametersAreNamedCurve cobre o encoding de curva discutido na próxima seção. Um PublicKeyAlgorithmOid vazio significa que o certificado do signatário nunca foi fixado
Por que uma assinatura P-256 com SHA3-256 falha na política?
Uma assinatura P-256 com SHA3-256 falha sempre que o digestAlgorithm do CMS diz SHA3-256 enquanto o signatureAlgorithm diz ecdsa-with-SHA256. Cada metade sozinha é aceitável para P-256; juntas elas discordam sobre qual hash foi assinado. EvaluatePadesSignatureAlgorithm mapeia cada OID de assinatura ECDSA, de ecdsa-with-SHA256 a ecdsa-with-SHA3-512, para o digest que implica, compara com o digestAlgorithm declarado e devolve pcsInvalid diante de qualquer diferença antes de olhar a tabela de curvas. Uma ferramenta de assinatura que move o hash dela para SHA3-256 mas mantém um identificador de assinatura fixo no código produz exatamente esse arquivo, e um verificador conforme não tem jeito consistente de lê-lo
EvaluatePadesSignatureAlgorithm é público e recebe um record simples, então a matriz pode ser fixada num teste de unidade sem construir um PDF. As chamadas Assert abaixo são checagens de teste suas:
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 não bate
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, mas não para P-256
Info.CurveOid := '1.3.36.3.3.2.8.1.1.1'; // brainpoolP160r1
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsUnsupported); // curva fora do profile
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 do signatário não encontrado
Assert(EvaluatePadesSignatureAlgorithm(Info) = pcsIndeterminate);
end;
O quinto caso é sobre como o certificado codifica a curva dele. A RFC 5480 §2.1.1 deixa ECParameters ser um OID de curva nomeada, uma curva implícita (NULL) ou um conjunto completo de parâmetros explícitos, e a mesma seção restringe certificados PKIX à forma nomeada. O PDFium Component devolve pcsInvalid para um certificado id-ecPublicKey com parâmetros ausentes, implícitos ou explícitos. Parâmetros explícitos soletram o primo, os coeficientes e o ponto base, o que deixa um atacante descrever uma curva que apenas se parece com uma padrão, e um verificador que os aceitasse teria de provar que os números batem com uma curva nomeada antes de confiar em qualquer outra coisa
Inválido, não suportado e indeterminado são três respostas diferentes
Os três valores não válidos de AlgorithmPolicyStatus carregam significados diferentes, e colapsá-los num único balde "falhou" joga fora a informação de que um auditor precisa. pcsInvalid significa que uma combinação de algoritmos reconhecida está malformada ou divergente. Ele acrescenta ppeiSignatureAlgorithmMismatch a TPadesValidationResult.Issues e empurra o IntegrityStatus agregado para pcsInvalid, então IsCryptographicallyValid devolve False mesmo quando o valor da assinatura CMS confere
pcsUnsupported significa que a curva ou o digest está fora do que o profile nomeia. Esse é um resultado de capacidade, e ele deixa IntegrityStatus em paz. pcsIndeterminate significa que o PDFium Component se recusou a chutar: o certificado do signatário não pôde ser fixado, tipicamente um conjunto de certificados com vários candidatos e nenhuma correspondência exata de issuerAndSerialNumber, ou o SignerInfo não pôde ser parseado o suficiente para ler os algoritmos dele. Do lado RSA o mesmo valor marca um digest que as suítes atuais não aceitam mais para validações novas, coberto na última seção
EdDSA mostra por que o status de política e o status criptográfico moram em campos separados. Num sistema cujo verificador CMS não sabe checar Ed25519 ou Ed448, CmsSignatureStatus volta pcsUnsupported enquanto AlgorithmPolicyStatus pode ainda ser pcsValid, calculado a partir do certificado achado no CMS. O encoding estava correto; só faltou o verificador. Fundir os dois forçaria uma escolha entre chamar uma assinatura bem-formada de quebrada e chamar uma não checada de boa
Para um pipeline de intake, rejeite automaticamente no pcsInvalid e em nada mais. Tratar pcsUnsupported como rejeição transforma uma curva que a sua política nunca listou numa acusação de adulteração, e o remetente não tem como consertar o que nunca esteve quebrado. Mande resultados unsupported e indeterminate para uma pessoa, com os OIDs de AlgorithmInfo anexados:
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, sem revogação
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;
Se a rejeição vem do Adobe Acrobat ou de um validador baseado em DSS em vez desta checagem, o guia sobre por que validadores rejeitam assinaturas PAdES percorre as outras causas comuns, de buracos no ByteRange a um tempo de assinatura /M malformado
O que o pcsValid deixa por sua conta?
AlgorithmPolicyStatus = pcsValid certifica o profile de algoritmos e nada mais: uma curva aprovada com um digest congruente e corretamente codificado para ECDSA e EdDSA, ou um digest de uma suíte atual para RSA. Para assinaturas RSA o EvaluatePadesSignatureAlgorithm aplica as suítes da ETSI TS 119 312. MD2, MD4 e MD5 são pcsInvalid. SHA-1 e os digests de 112 bits (SHA-224, SHA-512/224, SHA3-224) são pcsIndeterminate, o resultado que a EN 319 102-1 usa quando um algoritmo não é mais considerado confiável e nenhuma prova de existência anterior foi avaliada, então uma assinatura SHA-1 mantém o resultado de integridade dela e vai para revisão. Um digestAlgorithm que difere do digest fixado pelo OID da assinatura, como sha256WithRSAEncryption sobre um digest SHA-1, é pcsInvalid, e um algoritmo de assinatura RSA numa chave de signatário não RSA também. Um certificado de signatário ausente dá pcsIndeterminate, e digests desconhecidos ou OIDs que não são de assinatura vindos do arco PKCS #1 dão pcsUnsupported
Assinaturas RSASSA-PSS ganham uma checagem de parâmetros por cima: os parâmetros PSS precisam estar presentes e bem formados, o hash deles precisa ser igual ao digestAlgorithm declarado, o campo trailer precisa ser 1, e uma chave de certificado restrita a PSS precisa concordar com eles. O artigo sobre RSASSA-PSS-params da RFC 4055 cobre como esses parâmetros são codificados no lado da assinatura. O comprimento do módulo está fora da política, então uma aplicação que quer um piso de 3072 bits o impõe por conta própria. SHA-1 ou MD5 no digestAlgorithm também levanta a issue separada ppeiBadDigestAlgorithm. Quando os signed attributes carregam o atributo cms-algorithm-protection da RFC 6211, os dois identificadores dele são comparados com os valores do SignerInfo byte a byte, e uma diferença levanta ppeiCmsAlgorithmProtectionMismatch e derruba a integridade; VerifyCmsAlgorithmProtection roda essa comparação sobre um blob CMS bruto
A matemática da assinatura, a cadeia de certificados e a revogação ficam com CmsSignatureStatus, CertificateTrustStatus e RevocationStatus, que vêm do verificador CMS. Leia pcsValid como "o profile de algoritmos se sustenta" e nunca como "esta chave é forte o bastante". Para uma aplicação Delphi que aceita notas fiscais, contratos ou pacotes de arquivamento assinados, o arranjo inteiro cabe em poucas linhas: rode ValidatePadesTrust, rejeite no ppeiSignatureAlgorithmMismatch, encaminhe pcsUnsupported e pcsIndeterminate a um revisor e imponha o seu próprio piso de tamanho de chave RSA
A mesma biblioteca que roda essas checagens também produz assinaturas PAdES, então um time pode assinar com P-384 ou Ed25519 e confirmar que a própria saída dele satisfaz o profile da ISO/TS 32002 antes de ela chegar a um cliente. Edições, suporte a plataformas e o pipeline de assinatura estão descritos na página de produto do PDFium Component para Delphi e Lazarus