Um verificador de assinaturas PDF escrito à mão pode rejeitar todo arquivo corretamente assinado que receber enquanto lê cada byte corretamente. Ele tira o blob CMS do /Contents, localiza os atributos assinados, os hasheia exatamente como estão guardados, e a comparação RSA falha. O documento está bem. O problema é um byte: dentro do SignerInfo os atributos são marcados [0] IMPLICIT, então o primeiro byte deles é 0xA0, enquanto a RFC 5652 §5.4 diz que o signatário calculou a assinatura sobre o mesmo conteúdo codificado como um SET OF DER, cujo primeiro byte é 0x31. Troque esse byte antes de hashear e as assinaturas "falsificadas" viram válidas
Essa divergência de tag é o primeiro de vários lugares em que uma checagem de assinatura PDF pode dar errado, e os outros são menos óbvios. Uma assinatura pode ser matematicamente perfeita num arquivo que foi editado depois de assinado. Pode ser perfeita num documento que um atacante re-assinou com um certificado feito por ele mesmo. Uma contraparte devolve um contrato assinado, seu fluxo de trabalho precisa arquivá-lo, e alguém pergunta se este é o documento que você enviou, byte por byte, assinado pelo certificado que ele alega. Produzir essas assinaturas em primeiro lugar está coberto em o artigo companheiro sobre criar assinaturas digitais PAdES no Delphi; este corre na direção contrária, partindo de um arquivo que chega já assinado
Onde os bytes assinados vivem num arquivo PDF
Uma assinatura PDF protege intervalos de bytes do arquivo em disco, e o HotPDF verifica contra exatamente esses bytes. A ISO 32000-1 §12.8.1 põe um contêiner CMS SignedData (RFC 5652) na entrada /Contents do dicionário de assinatura e um array /ByteRange ao lado nomeando as regiões que a assinatura cobre. Na prática o array guarda dois pares de offset e comprimento: tudo do offset 0 até a string hex do /Contents, e tudo depois dela. Uma assinatura não pode cobrir o próprio valor dela, então o arquivo é hasheado em torno desse buraco
A consequência para qualquer verificador é dura. Você precisa hashear o original serializado. Um modelo de objetos analisado não serve aqui, porque escrever de volta mesmo um documento intocado produz bytes diferentes. O HotPDF, portanto, lê o arquivo de origem de que o documento foi carregado, ou um TStream de bytes brutos que você fornecer, e nunca hasheia a representação dele em memória
O buraco em si merece desconfiança. Bytes fora dos intervalos assinados são bytes que um leitor ainda pode analisar, e um vão que guarde qualquer coisa além do valor da assinatura é a brecha para um ataque de signature wrapping. O HotPDF confere que o /ByteRange começa no offset 0, que o segundo segmento começa depois de o primeiro terminar, que ambos ficam dentro do arquivo, e que o vão não contém nada além dos dígitos hex do próprio /Contents desta assinatura, opcionalmente com os delimitadores < e > dele. Um arquivo que falhe em qualquer dessas devolve svInvalidByteRange, mesmo quando a matemática do CMS teria passado
Lendo quem assinou antes de checar qualquer coisa
GetLoadedSignatureInfo analisa o dicionário de assinatura e o contêiner CMS dele sem hashear um único byte do documento, então é a chamada a fazer quando uma UI só precisa mostrar quem assinou e quando. Campos de assinatura são indexados a partir de 0 na ordem de campos de formulário, e GetLoadedSignatureFieldCount devolve quantos são. Um índice além do fim lança exceção em vez de devolver um registro vazio, então faça loop pela contagem
O registro THPDFSignatureInfo devolvido carrega o nome do campo, o /SubFilter, o common name do certificado do signatário, os distinguished names de subject e issuer, o número de série em hex, as datas de validade do certificado e o horário de assinatura, tirado do atributo assinado quando presente e, em caso contrário, da entrada /M do dicionário. Ele também reporta os nomes dos algoritmos de digest e de chave pública, as strings /Reason, /Location e /ContactInfo, e o CertificateTimeValidity, que marca um horário de assinatura que cai fora da janela de validade do certificado. O Status fica em svNotVerified: analisado, não conferido. A API de assinaturas fica atrás do guard de compilador do Delphi 2009 e posteriores
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;
Rodando a checagem criptográfica com VerifyLoadedSignatureEx
VerifyLoadedSignatureEx roda a checagem completa para um documento carregado de arquivo e devolve o registro de informações preenchido na mesma chamada. Ele reabre o arquivo de origem, valida o /ByteRange, hasheia os dois segmentos com o algoritmo de digest do SignerInfo, compara o resultado com o atributo assinado messageDigest e então verifica o valor da assinatura sobre a forma SET OF DER dos atributos assinados usando a chave pública do certificado do signatário embutido. Quando uma assinatura não carrega atributos assinados, uma checagem RSA ou ECDSA corre direto sobre o hash do documento
A cobertura de algoritmos segue o que as ferramentas de assinatura realmente emitem. Digests incluem SHA-1, SHA-256, SHA-384, SHA-512, a família SHA-3 e SHAKE256. Assinaturas podem ser RSA com padding PKCS#1 v1.5 ou PSS, ECDSA em curvas nomeadas, ou Ed25519 e Ed448. A verificação ECDSA usa o provider CNG do Windows, e Ed25519 e Ed448 passam por um provider de plataforma apoiado no CNG do Windows ou numa biblioteca OpenSSL, então numa máquina em que o provider necessário não pode ser carregado o resultado é svUnsupportedAlgorithm ou svCryptoProviderError em vez de um veredito sobre o arquivo. O VerifyLoadedSignatureWithOptions aceita um registro THPDFCMSVerifyOptions quando você precisa apontar para uma biblioteca OpenSSL específica ou pluguar o seu próprio 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;
Dois detalhes de análise explicam falhas que parecem misteriosas de fora. O primeiro é o re-tag do parágrafo de abertura: o HotPDF hasheia os atributos assinados com o byte inicial deles reescrito para 0x31, exatamente como a RFC 5652 §5.4 prescreve. O segundo é padding. Ferramentas de assinatura reservam um orçamento fixo de bytes para o /Contents antes de a assinatura existir e enchem o resto não usado com zeros, então o verificador poda o blob decodificado para o comprimento real da SEQUENCE DER externa dele antes de percorrê-lo. Uma sequência de zeros no fim do /Contents é normal. A mesma família de perigos de análise ASN.1, vista do lado da importação de certificados, é o assunto de o artigo sobre hardening de segurança PKCS#12 e ASN.1 no Delphi
Algumas checagens mais estritas correm pelo caminho. O algoritmo de digest no SignerInfo tem que concordar com a lista de digests do SignedData, com o identificador de algoritmo de assinatura e com qualquer atributo de proteção de algoritmo CMS, em caso contrário o status é svDigestAlgorithmMismatch. Os atributos assinados devem conter exatamente um atributo content-type que case com o conteúdo assinado, em caso contrário svMalformed. Quando o CMS carrega um timestamp de assinatura RFC 3161 embutido, esse token é verificado contra o valor da assinatura e reportado em Info.Timestamp; um timestamp de documento ETSI.RFC3161 é verificado contra os intervalos de bytes hasheados da mesma forma
O que o svValid realmente prova?
svValid significa duas coisas: os bytes nomeados pelo /ByteRange dão hash igual ao valor que o signatário assinou, e essa assinatura verifica sob a chave pública do certificado embutido no contêiner CMS. Integridade de bytes mais ligação de chave. Não diz nada sobre quem é o dono dessa chave. Um atacante que edita um contrato e o re-assina com um certificado autogerado recebe svValid, porque a matemática é internamente consistente, e o campo SignerName mostrará o nome que o atacante digitou no certificado
CoversWholeDocument cobre uma segunda lacuna. Atualizações incrementais do PDF deixam um escritor anexar conteúdo depois de uma assinatura sem quebrá-la, o que é por design e é como fluxos de múltiplas assinaturas operam. A flag é calculada durante a verificação e só é verdadeira quando os dois segmentos mais o vão do /Contents cobrem o arquivo inteiro. SignedRevisionLength dá o tamanho do prefixo assinado e UnsignedTrailingBytes o número de bytes acrescentados depois dele. Para um arquivo que declara uma revisão assinada de 48.000 bytes dentro de um arquivo de 52.300 bytes, UnsignedTrailingBytes é 4.300 e CoversWholeDocument é false
Um pipeline de ingestão de arquivo morto não deveria aceitar svValid com CoversWholeDocument false por si só. Rode AnalyzeLoadedSignatureRevisions primeiro: ele classifica toda revisão anexada depois da assinatura selecionada, lista os nomes de campos alterados em ChangedFieldNames e reporta se as mudanças respeitam as permissões DocMDP e FieldMDP que o signatário definiu, por meio de DocMDPCompliant e FieldMDPCompliant. Uma assinatura posterior acrescentada num campo de assinatura vazio é rotina. Uma revisão que reescreve objetos de página não é, e o ChangeKinds da análise é o que separa esses dois casos
Conferindo o signatário contra as suas próprias âncoras de confiança
Confiança é uma chamada separada no HotPDF, e essa divisão é o padrão certo. VerifyLoadedSignatureWithTrust primeiro roda a mesma verificação de byte range, devolvendo cvsSignatureInvalid se ela falhar, e então constrói um caminho de certificados do signatário até as âncoras que você passar em THPDFCertificateValidationOptions.TrustAnchors. Ele avalia evidência de revogação pelo caminho: respostas OCSP e CRLs guardadas nos dicionários DSS e /VRI do documento são coletadas automaticamente, e quaisquer que você fornecer em OCSPResponses ou CRLs entram no mesmo bolo
uses
System.IOUtils;
var
Options: THPDFCertificateValidationOptions;
Info: THPDFSignatureInfo;
Trust: THPDFCertificateValidationStatus;
begin
Options := THPDFCertificateValidationOptions.Default;
SetLength(Options.TrustAnchors, 1);
// Certificado raiz codificado em DER; converta arquivos PEM antes de carregar
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;
O modo de revogação é uma escolha de política. rvmBestEffort usa a evidência que estiver disponível e continua quando não acha nenhuma, enquanto rvmRequire transforma evidência ausente em cvsRevocationUnknown. Para contratos que serão auditados anos depois, rvmRequire é a configuração mais segura, desde que os seus signatários embutam dados OCSP ou CRL na hora de assinar; sem essa evidência no arquivo, todo documento volta cvsRevocationUnknown
Por que documentos carregados de stream devolvem svSourceUnavailable?
As chamadas apoiadas em arquivo, ou seja, o VerifyLoadedSignature de um argumento, o VerifyLoadedSignatureEx e o VerifyLoadedSignatureWithTrust apoiado em arquivo, precisam que o componente lembre de qual arquivo o documento veio. Um documento carregado com LoadFromStream não tem nome de arquivo para reabrir. O mesmo vale depois do reload de senha usado para documentos criptografados, descrito em o artigo sobre criptografia PDF AES-256 no Delphi, porque o componente derruba a referência dele ao arquivo de origem assim que descriptografa o documento. Nos dois casos as sobrecargas apoiadas em arquivo devolvem svSourceUnavailable e não chutam
As sobrecargas com TStream recebem os bytes brutos originais de onde você os guardou: um arquivo, um buffer de memória, um blob de banco de dados. A posição do stream é restaurada depois do hashing, então o mesmo stream pode ser passado a vários índices de assinatura em sequência. O VerifyAllLoadedSignatures, que devolve true só quando existe ao menos um campo de assinatura e todo campo verifica como svValid, passa pelo caminho apoiado em arquivo, então num documento carregado de stream ele devolve false não importa o que as assinaturas contenham. Faça o loop pela sobrecarga de stream em vez disso
function AllSignaturesValid(Pdf: THotPDF; Src: TStream): Boolean;
// Helper para o leitor acrescentar: um equivalente baseado em stream do
// VerifyAllLoadedSignatures para documentos carregados com 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;
Verificação de byte range, construção de caminho por âncoras de confiança, assinatura PAdES e criptografia AES-256 vivem na mesma biblioteca VCL nativa para Delphi e C++Builder, com hash RSA e checagens de padding feitos em código Pascal; edições, versões de IDE suportadas e a lista maior de funcionalidades estão na página de produto do HotPDF Delphi Component