Artigo Técnico

Assinatura CMS no Delphi: limites DER e arcos de OID

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

O PLTrimCMSPadding do PDFlibPas lê o primeiro TLV da hex string reservada de /Contents, exige a tag $30 e corta o padding de zeros no comprimento que o SEQUENCE externo declara, e retorna resultado vazio quando o buffer não começa com um SEQUENCE bem formado
Bytes no fim são legais só no nível de topo, onde o slot reservado precisa ficar fixo por causa da /ByteRange — leituras mais fundas recebem a regra limitada pelo pai

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 PDFlibPas limita toda leitura DER aninhada pelo elemento pai dela: um issuer Name de 60 bytes dentro de um issuerAndSerialNumber de 40 bytes é aceito pelo antigo DERReadTLV limitado pelo buffer, que então lê o número de série do digestAlgorithm, enquanto o ReadTLVWithin recusa qualquer elemento que termine depois do ParentEnd
Dentro do buffer é memory safety, dentro do pai é correção — o PDFlibPas costura o offset de fim do pai por todo nível do CMS para que um comprimento hostil não pegue bytes emprestados de um vizinho

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.
O DER_OID do PDFlibPas combina os dois primeiros arcos do OID como 40 * arc1 + arc2 e codifica a soma em base-128 num UInt64, então 2.999.3 vira 06 03 88 37 03, enquanto um cast para Byte guardaria 55 e decodificaria silenciosamente o identifier como 1.15.3
A maioria dos arcos de PKI nunca chega na fronteira, e é por isso que um atalho do tamanho de um byte passa despercebido — os arcos joint-iso-itu-t de 2.48 para cima precisam de dois bytes, então vetores de teste pertencem aos dois lados dessa linha

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