Codifique o OID 2.999.3 do jeito que um helper DER apressado costuma fazer, com os dois primeiros arcos empacotados em um só byte, e o decoder devolve 1.15.3. Dois outros erros de leitura de CMS se comportam do mesmo jeito: uma contagem de certificados que engole bytes de um vizinho e um match de signer feito com um número de série lido do campo errado. Na PDF Library for Delphi (PDFlibPas), o leitor de assinaturas caminha pelo CMS em /Contents como DER puro, limita cada leitura aninhada pelo elemento pai, apara o padding no comprimento que o CMS declara e codifica em base-128 o primeiro arco OID combinado
Muito código precisa do lado de leitura de uma assinatura. A validação de longo prazo precisa puxar o certificado do signer e os emissores dele de uma assinatura existente antes de buscar dados de revogação. Um relatório de auditoria precisa dizer quem assinou. Um build Lazarus no Linux não tem funções de mensagem do Windows para onde cair, porque as chamadas de CMS da plataforma viram falha fora do Windows, e é por isso que o PDFlibPas faz essa caminhada em Pascal puro e não usa CryptoAPI nenhuma
Lendo os certificados do signer de um PDF assinado
Cinco métodos do TPDFlib cobrem todo o lado de leitura, e cada um recebe InputFile, Password, FieldName. Toda chamada abre o arquivo em modo somente leitura, responde e fecha de novo, então não há estado de documento para gerenciar. GetSignatureEmbeddedCertificateCount e GetSignatureEmbeddedCertificateDER enumeram o conjunto de certificados do CMS na ordem de encoding. O GetSignatureSignerCertificateDER retorna o certificado que produziu um dado SignerInfo. O GetSignatureCertificateChainLength e o GetSignatureCertificateChainDER caminham desse signer até o emissor mais distante que a assinatura carrega. Todos os índices são zero-based
Os resultados voltam como AnsiString, e o ideal é mantê-los assim. Um blob DER que passa por string ou por um TStrings atravessa uma conversão de conjunto de caracteres, e os bytes que saem do outro lado não parseiam mais. É também por isso que a biblioteca mantém as listas de certificados como arrays de AnsiString e retorna listas de URLs como texto de uma por linha: endereços são ASCII puro e sobrevivem à conversão, bytes de certificado não
uses
SysUtils, Classes, PDFlibrary, PDFlibEnterprise;
procedure SaveDer(const FileName: string; const Der: AnsiString);
var
Fs: TFileStream;
begin
Fs := TFileStream.Create(FileName, fmCreate);
try
if Der <> '' then
Fs.WriteBuffer(Der[1], Length(Der));
finally
Fs.Free;
end;
end;
const
Src = 'contract-signed.pdf';
Field = 'Signature1';
var
Pdf: TPDFlibEnterprise;
Count, ChainLen, I: Integer;
SignerDer, LastDer: AnsiString;
begin
Pdf := TPDFlibEnterprise.Create;
try
Count := Pdf.GetSignatureEmbeddedCertificateCount(Src, '', Field);
WriteLn(Field, ': ', Count, ' certificate(s) in the CMS');
for I := 0 to Count - 1 do
SaveDer(Format('embedded-%d.cer', [I]),
Pdf.GetSignatureEmbeddedCertificateDER(Src, '', Field, I));
SignerDer := Pdf.GetSignatureSignerCertificateDER(Src, '', Field, 0);
if SignerDer = '' then
raise Exception.CreateFmt('%s: signer certificate missing or not matched', [Field]);
SaveDer('signer.cer', SignerDer);
ChainLen := Pdf.GetSignatureCertificateChainLength(Src, '', Field, 0);
for I := 0 to ChainLen - 1 do
SaveDer(Format('chain-%d.cer', [I]),
Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, I));
if ChainLen > 0 then
begin
// o último elo ainda pode ter um emissor que a assinatura não embutiu
LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
end;
finally
Pdf.Free;
end;
end;
Dois resultados desse programa são fáceis de interpretar errado. Uma contagem de 0 sozinha não diz quase nada: campo ausente, senha errada, um blob que não é DER e um SignedData que simplesmente omite o conjunto opcional de certificados todos voltam como 0 ou string vazia. Registre o nome do campo junto do número, como o exemplo faz, ou você vai acabar depurando o arquivo errado. O segundo é o comprimento da cadeia. O construtor de cadeia usa só os certificados embutidos na assinatura, então uma cadeia que para antes de uma raiz autoemitida é normal. Assine um arquivo com o certificado de demonstração, emitido por uma raiz de teste, e o GetSignatureCertificateChainLength retorna 1 porque essa raiz não está no CMS. O próximo salto vem dos endereços que o GetCertificateIssuerURLs reporta, uma chamada que pertence à edição Enterprise junto com o resto da API de validação de longo prazo
O match de signer em si cobre as duas formas de SignerIdentifier que o RFC 5652 §5.3 permite. O issuerAndSerialNumber é a forma que todo mundo testa. A forma [0] subjectKeyIdentifier, uma OCTET STRING com tag implícita de valor $80, é o ramo que leitores escritos à mão mais esquecem, e signers que se identificam por key identifier de fato a emitem. Quando a forma issuer-and-serial é usada, as duas metades precisam casar: um número de série só é único dentro de um emissor, então casar apenas pelo número de série pode acabar num certificado de outra CA
Quanto de /Contents é realmente o CMS?
Só o prefixo coberto pelo SEQUENCE externo, e o PLTrimCMSPadding da unit PDFlibCMSRead corta tudo que vem depois. O motivo é a ordem das operações. A ISO 32000-1 §12.8.1 exige que a /ByteRange fique fixa antes de o valor da assinatura existir, então o signer reserva a hex string de /Contents de antemão, dimensiona com folga e enche a cauda não usada com zeros quando o CMS já é conhecido. Um arquivo assinado típico carrega, por isso, uma sequência de zeros depois do CMS, tão longa quanto o que o signer reservou a mais
O PLTrimCMSPadding lê o primeiro TLV, exige tag $30 e retorna os bytes até o fim desse elemento. Alimente com 30 03 02 01 00 00 00 00 e você recebe os cinco primeiros bytes de volta; alimente com 'not der' e recebe uma string vazia. Esse nível de topo é o único lugar onde bytes no fim são legais. Uma regra rigorosa de que o elemento precisa consumir o buffer inteiro rejeitaria arquivos assinados comuns, enquanto uma regra frouxa de "o que sobrar está ok" aplicada em toda profundidade é exatamente como campos aninhados acabam lendo bytes que não são deles
Por que um leitor DER precisa do offset de fim do pai?
Porque um elemento aninhado só é válido se terminar dentro do pai dele, e checar contra o fim do buffer não prova isso. O DERReadTLV no PDFlibASN1 limita cada elemento pela string inteira, rejeita comprimentos que passariam do fim e faz a aritmética como uma subtração, para que um comprimento de quatro bytes forjado de $7FFFFFFF não consiga tornar a checagem negativa num wrap. Isso é memory safety. Não diz nada sobre se o elemento pertence ao lugar onde foi encontrado
Imagine um SignerInfo cujo issuerAndSerialNumber declara 40 bytes enquanto o issuer Name dentro dele alega 60. Cada byte continua no buffer, então um leitor limitado pelo buffer aceita o Name, lê o "número de série" do algoritmo de digest que vem depois e compara esse par com os certificados embutidos. Nada falha. Às vezes a comparação até tem sucesso, contra o certificado errado
O caminhador de CMS do PDFlibPas carrega a posição de fim do pai para dentro de cada leitura, do ContentInfo (RFC 5652 §3) passando pelo wrapper [0] EXPLICIT, pelos campos do SignedData (§5.1), por cada SignerInfo e o identifier dele, até os campos do tbsCertificate que ele lê ao casar um signer. Se você escrever o seu próprio caminhador em cima do DERReadTLV público, para um token de timestamp ou uma resposta OCSP, o mesmo padrão cabe em uma dúzia de linhas:
uses
PDFlibASN1;
// Uma leitura de filho, recusada se o filho terminaria além do pai.
function ReadChild(const Data: AnsiString; ParentEnd: Integer;
var Offset: Integer; out Tag: Byte; out Start, Len: Integer): Boolean;
begin
Result := False;
if (Offset < 1) or (Offset >= ParentEnd) then
Exit; // nada sobrou dentro do pai
if not DERReadTLV(Data, Offset, Tag, Start, Len) then
Exit;
Result := Offset <= ParentEnd; // Offset agora fica um além do filho
end;
// Conta os membros SEQUENCE de um SET OF cujo conteúdo vai
// de Data[SetStart .. SetEnd - 1]. Para no primeiro membro que estourar.
function CountSequences(const Data: AnsiString; SetStart, SetEnd: Integer): Integer;
var
Offset, Start, Len: Integer;
Tag: Byte;
begin
Result := 0;
Offset := SetStart;
while Offset < SetEnd do
begin
if not ReadChild(Data, SetEnd, Offset, Tag, Start, Len) then
Break; // sem resync: o alinhamento se perdeu
if Tag = $30 then
Inc(Result);
end;
end;
Repare no Break. Dentro do conjunto de certificados e do conjunto de signerInfos, o PLExtractCMSCertificates faz a mesma coisa: um elemento que passa do fim do conjunto interrompe o loop, e a função retorna os certificados que já tinha aceitado. Ela nunca cola os bytes de crls ou signerInfos seguintes no último certificado. Pular o elemento ruim e continuar é tentador, e é a decisão errada. Uma vez que um comprimento declarado está errado, o leitor não sabe mais onde o próximo elemento começa, e qualquer "recuperação" é um chute sobre qual byte parece uma tag. Com o loop parado, um conjunto cujo segundo certificado estoura por um único byte produz contagem 1 e os bytes do primeiro certificado exatamente como codificados
Como 2.999.3 pode sair como 1.15.3?
Os dois primeiros arcos de um OID se combinam num único subidentifier, e esse subidentifier é codificado em base-128 como qualquer outro arco — não é um byte único. A X.690 §8.19.4 define o valor como 40 * arc1 + arc2. Um encoder que grava esse valor com Byte(...) está correto até 127, que é o 2.47. Para 2.999 a soma é 1079, um cast para byte guarda 55, e 55 decodifica como 1.15. O identifier passa a nomear outro ramo da árvore e nada reclama. Valores de 128 a 255 quebram de outro jeito: o cast emite um byte com o bit de continuação ligado, e o decoder engole o próximo arco dentro dele
O atalho sobrevive tanto tempo em código real porque a maioria dos identifiers de PKI nunca chega na fronteira. Tudo abaixo de 1.2.840, 2.5.29 e 0.4.0 tem um primeiro valor combinado bem abaixo de 128, então uma suíte de teste construída só com OIDs comuns de assinatura nunca exercita o segundo byte. Só os arcos joint-iso-itu-t a partir de 2.48 cruzam a linha. No PDFlibPas uma única função, a DER_OID, serve ao encoder de signed attributes, à busca dentro do DERFindExtensionByOID e à checagem de content-type do SignedData, então escrita e busca não podem divergir. Vetores de teste pertencem aos dois lados da fronteira:
uses
SysUtils, PDFlibASN1;
function Hex(const S: AnsiString): string;
var
I: Integer;
begin
Result := '';
for I := 1 to Length(S) do
Result := Result + IntToHex(Byte(S[I]), 2) + ' ';
Result := Trim(Result);
end;
procedure Check(const Oid, Expected: AnsiString);
begin
if Hex(DER_OID(Oid)) <> Expected then
WriteLn('MISMATCH ', Oid, ': ', Hex(DER_OID(Oid)), ' expected ', Expected)
else
WriteLn('ok ', Oid);
end;
begin
Check('2.47.1', '06 02 7F 01'); // último valor de um byte
Check('2.48.1', '06 03 81 00 01'); // primeiro valor de dois bytes
Check('2.999.3', '06 03 88 37 03'); // um cast para Byte dá 1.15.3
Check('2.5.29.14', '06 03 55 1D 0E');
Check('1.2.840.113549.1.7.2', '06 09 2A 86 48 86 F7 0D 01 07 02');
end.
Tem mais um overflow escondido na mesma linha de aritmética. O DER_OID converte os arcos para Int64, então um segundo arco legal pode ser tão grande quanto Int64.MaxValue, e somar 80 para arc1 = 2 faz overflow num inteiro de 64 bits com sinal. O valor combinado fica, por isso, num UInt64, que carrega Int64.MaxValue + 80 sem dar wrap. Ninguém emite OIDs desse tamanho, mas uma string forjada ainda pode pedir um. O buffer temporário de dez bytes no DER_OID guarda os dez grupos de 7 bits que um valor de 64 bits pode precisar, então até 2.9223372036854775807 codifica para um subidentifier de dez bytes em vez de dar wrap
O que o caminhador de CMS aceita e onde a verificação fica
O PDFlibCMSRead retorna bytes que estão onde o RFC 5652 diz que devem estar, e esse é o trabalho inteiro dele. Ele não verifica valor de assinatura, digest nem período de validade. O caminhador aceita só DER: o DERReadTLV recusa comprimentos indefinidos e números de tag multibyte, então um CMS em BER vindo de um signer fora do padrão reporta zero certificados. Preferimos isso a um parse parcial de BER. Na prática, a pista é um byte de comprimento $80 logo depois da tag externa $30, que é como começa um SEQUENCE de comprimento indefinido
Attribute certificates e as outras alternativas de CertificateChoices são puladas ao caminhar pelo conjunto de certificados, porque só a alternativa Certificate simples é um certificado X.509 que a construção de cadeia e as buscas de revogação conseguem usar. Tudo que é criptográfico fica com o código que é dono disso, que começa pelas checagens de cobertura de bytes em assinatura PAdES e validação de ByteRange no Delphi e continua com classificar o que mudou depois que um PDF foi assinado. O mesmo hábito de desconfiar de comprimentos declarados atravessa endurecer um parser de PDF em Pascal contra arquivos maliciosos
A extração de certificados, a construção de cadeia e as chamadas de validação de longo prazo mostradas acima fazem parte da losLab PDF Library for Delphi, que roda em Delphi, C++Builder e Lazarus, então o mesmo código de leitura de assinaturas funciona num serviço Windows e num build Linux