Article technique

Lire les signatures CMS en Delphi : bornes DER et arcs OID

Encodez l'OID 2.999.3 comme le fait souvent un helper DER pressé, avec les deux premiers arcs entassés dans un seul octet, et le décodeur vous rend 1.15.3. Deux autres bévues de lecture du CMS se comportent pareil : un compte de certificats qui avale les octets du voisin, et un signataire apparié sur un numéro de série lu dans le mauvais champ. Dans PDF Library for Delphi (PDFlibPas), le lecteur de signature parcourt le CMS de /Contents en DER pur, borne chaque lecture imbriquée par son élément parent, rogne le bourrage à la longueur que le CMS déclare et encode en base-128 le premier arc OID combiné

Pas mal de code a besoin du côté lecture d'une signature. Une validation à long terme doit sortir le certificat du signataire et ses émetteurs d'une signature existante avant d'aller chercher la moindre donnée de révocation. Un rapport d'audit doit dire qui a signé. Un build Lazarus sous Linux n'a aucune fonction de message Windows sur laquelle retomber, car les appels CMS de la plateforme sont bouchés pour échouer hors de Windows — c'est pourquoi PDFlibPas fait cette promenade en Pascal pur et sans aucun recours à CryptoAPI

Lire les certificats du signataire dans un PDF signé

Cinq méthodes de TPDFlib couvrent tout le côté lecture, et chacune prend InputFile, Password, FieldName. Chaque appel ouvre le fichier en lecture seule, répond, et le referme, donc il n'y a aucun état de document à gérer. GetSignatureEmbeddedCertificateCount et GetSignatureEmbeddedCertificateDER énumèrent le jeu de certificats du CMS dans l'ordre d'encodage. GetSignatureSignerCertificateDER renvoie le certificat qui a produit un SignerInfo donné. GetSignatureCertificateChainLength et GetSignatureCertificateChainDER remontent du signataire vers l'émetteur le plus lointain que porte la signature. Tous les index partent de zéro

Les résultats reviennent en AnsiString, et vous avez intérêt à les garder ainsi. Un blob DER poussé dans string ou un TStrings traverse une conversion de jeu de caractères, et les octets qui en ressortent ne sont plus lisibles. C'est aussi pourquoi la bibliothèque garde les listes de certificats sous forme de tableaux de AnsiString et renvoie les listes d'URL en texte à une adresse par ligne : les adresses sont de l'ASCII pur et survivent à la conversion, les octets de certificats non

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
      // le dernier maillon peut encore avoir un émetteur que la signature n'a pas embarqué
      LastDer := Pdf.GetSignatureCertificateChainDER(Src, '', Field, 0, ChainLen - 1);
      WriteLn('Issuer locations: ', Pdf.GetCertificateIssuerURLs(LastDer));
    end;
  finally
    Pdf.Free;
  end;
end;

Deux résultats de ce programme se laissent facilement mal lire. Un compte à 0 ne dit presque rien à lui seul : un champ absent, un mot de passe erroné, un blob qui n'est pas du DER et un SignedData qui omet simplement le jeu de certificats optionnel reviennent tous comme 0 ou chaîne vide. Journalisez le nom du champ à côté du nombre, comme le fait l'exemple, sinon vous déboguerez le mauvais fichier. Le second cas sensible, c'est la longueur de chaîne. Le constructeur de chaîne n'utilise que les certificats embarqués dans la signature, donc une chaîne qui s'arrête avant une racine auto-émise est un cas normal. Signez un fichier avec notre certificat de démo, émis par une racine de test, et GetSignatureCertificateChainLength renvoie 1 parce que cette racine n'est pas dans le CMS. Le prochain saut vient des adresses que GetCertificateIssuerURLs rapporte, un appel qui appartient à l'édition Enterprise avec le reste de l'API de validation à long terme

L'appariement du signataire lui-même gère les deux formes de SignerIdentifier que le RFC 5652 §5.3 autorise. issuerAndSerialNumber est celle que tout le monde teste. La forme [0] subjectKeyIdentifier, un OCTET STRING taggé implicite avec le tag $80, est la branche que les lecteurs écrits à la main oublient le plus souvent, et les signataires qui s'identifient par key identifier l'émettent bel et bien. Quand la forme émetteur-plus-numéro-de-série est utilisée, les deux moitiés doivent correspondre : un numéro de série n'est unique qu'au sein d'un seul émetteur, donc un appariement sur le seul numéro peut tomber sur un certificat d'une autre CA

Quelle partie de /Contents est réellement le CMS ?

Seul le préfixe couvert par le SEQUENCE externe, et PLTrimCMSPadding de l'unité PDFlibCMSRead coupe tout ce qui suit. La raison tient à l'ordre des choses. ISO 32000-1 §12.8.1 exige que le /ByteRange soit figé avant que la valeur de signature existe, donc un signataire réserve la chaîne hexadécimale /Contents dès le départ, la dimensionne large, et remplit la queue inutilisée de zéros une fois le CMS connu. Un fichier signé typique transporte donc une suite de zéros traînants après le CMS, aussi longue que ce que le signataire a sur-réservé

PLTrimCMSPadding lit le premier TLV, exige le tag $30, et renvoie les octets jusqu'à la fin de cet élément. Passez-lui 30 03 02 01 00 00 00 00 et vous récupérez les cinq premiers octets ; passez-lui 'not der' et vous récupérez une chaîne vide. Ce niveau supérieur est le seul endroit où des octets traînants sont légaux. Une règle stricte qui exigerait que l'élément consomme tout le tampon rejetterait les fichiers signés ordinaires, tandis qu'une règle laxiste du genre « tout reste est bon » appliquée à chaque profondeur, c'est exactement comme ça que des champs imbriqués finissent par lire des octets qui ne leur appartiennent pas

PDFlibPas PLTrimCMSPadding lit le premier TLV de la chaîne hexadécimale /Contents réservée, exige le tag $30 et coupe le bourrage de zéros à la longueur que le SEQUENCE externe déclare, et renvoie un résultat vide quand le tampon ne commence pas par un SEQUENCE bien formé
Les octets traînants ne sont légaux qu'au niveau supérieur, là où l'emplacement réservé doit rester figé pour /ByteRange — les lectures plus profondes héritent de la règle bornée par le parent

Pourquoi un lecteur DER a-t-il besoin du décalage de fin du parent ?

Parce qu'un élément imbriqué n'est valide que s'il se termine à l'intérieur de son parent, et qu'une vérification contre la fin du tampon ne le prouve pas. DERReadTLV dans PDFlibASN1 borne chaque élément par la chaîne entière, refuse les longueurs qui dépasseraient la fin, et fait l'arithmétique par une soustraction pour qu'une longueur fourbe de quatre octets comme $7FFFFFFF ne puisse pas faire basculer le contrôle en négatif. Ça, c'est de la sûreté mémoire. Cela ne dit rien sur la question de savoir si l'élément est à sa place

Imaginez un SignerInfo dont issuerAndSerialNumber déclare 40 octets alors que le Name de l'émetteur qu'il contient en réclame 60. Chaque octet est toujours dans le tampon, donc un lecteur borné par le tampon accepte le Name, lit ensuite le « numéro de série » dans l'algorithme de condensat qui suit, puis compare cette paire aux certificats embarqués. Rien n'échoue. Il arrive même que la comparaison réussisse contre le mauvais certificat

PDFlibPas borne chaque lecture DER imbriquée par son élément parent : un Name d'émetteur de 60 octets dans un issuerAndSerialNumber de 40 octets est accepté par l'ancien DERReadTLV borné au tampon, qui lit ensuite le numéro de série dans digestAlgorithm, tandis que ReadTLVWithin refuse tout élément finissant après ParentEnd
Dans le tampon, c'est de la sûreté mémoire ; dans le parent, c'est de la justesse — PDFlibPas fait passer le décalage de fin du parent à chaque niveau du CMS pour qu'une longueur hostile ne puisse pas emprunter les octets du voisin

Le parcours CMS de PDFlibPas transporte la position de fin du parent dans chaque lecture, de ContentInfo (RFC 5652 §3) au wrapper [0] EXPLICIT, aux champs de SignedData (§5.1), à chaque SignerInfo et à son identifiant, jusqu'aux champs tbsCertificate lus lors de l'appariement d'un signataire. Si vous écrivez votre propre parcours par-dessus le DERReadTLV public, pour un jeton d'horodatage ou une réponse OCSP, le même motif tient en une douzaine de lignes :

uses
  PDFlibASN1;

// Une lecture d'enfant, refusée si l'enfant finissait après son parent.
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;                          // plus rien à lire dans le parent
  if not DERReadTLV(Data, Offset, Tag, Start, Len) then
    Exit;
  Result := Offset <= ParentEnd;  // Offset est à présent un cran après l'enfant
end;

// Compte les membres SEQUENCE d'un SET OF dont le contenu s'étend
// sur Data[SetStart .. SetEnd - 1]. S'arrête au premier membre qui déborde.
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;                       // pas de resynchronisation : l'alignement est perdu
    if Tag = $30 then
      Inc(Result);
  end;
end;

Notez le Break. Dans le jeu de certificats et le jeu signerInfos, PLExtractCMSCertificates fait la même chose : un élément qui dépasse la fin du jeu arrête la boucle, et la fonction renvoie les certificats déjà acceptés. Elle ne colle jamais les octets crls ou signerInfos suivants au dernier certificat. Sauter l'élément fautif et continuer est tentant, et c'est le mauvais choix. Dès qu'une longueur déclarée est fausse, le lecteur ne sait plus où commence l'élément suivant, et toute « reprise » est un pari sur quel octet ressemble à un tag. Boucle arrêtée, un jeu dont le second certificat déborde d'un seul octet donne un compte de 1 et les octets du premier certificat exactement tels qu'encodés

Comment 2.999.3 peut-il ressortir en 1.15.3 ?

Les deux premiers arcs d'un OID se combinent en un seul sous-identifiant, et ce sous-identifiant est encodé en base-128 comme tous les autres arcs — ce n'est pas un octet unique. X.690 §8.19.4 définit la valeur comme 40 * arc1 + arc2. Un encodeur qui l'écrit avec un Byte(...) est correct jusqu'à 127, soit 2.47. Pour 2.999 la somme fait 1079, un cast en octet garde 55, et 55 se décode en 1.15. L'identifiant nomme à présent une autre branche de l'arbre et personne ne s'en plaint. Les valeurs de 128 à 255 cassent autrement : le cast émet un octet avec le bit de continuation posé, et le décodeur avale l'arc suivant dedans

Le raccourci survit si longtemps dans le code réel parce que la plupart des identifiants PKI n'atteignent jamais la frontière. Tout ce qui est sous 1.2.840, 2.5.29 et 0.4.0 a une première valeur combinée bien en dessous de 128, donc une suite de tests bâtie uniquement sur des OID de signature courants ne sollicite jamais le second octet. Seuls les arcs joint-iso-itu-t à partir de 2.48 franchissent la ligne. Dans PDFlibPas, une seule fonction, DER_OID, sert l'encodeur des attributs signés, la recherche dans DERFindExtensionByOID et le contrôle du content-type SignedData, si bien que l'écriture et l'appariement ne peuvent pas diverger. Les vecteurs de test ont leur place des deux côtés de la frontière :

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');     // dernière valeur sur un octet
  Check('2.48.1',               '06 03 81 00 01');  // première valeur sur deux octets
  Check('2.999.3',              '06 03 88 37 03');  // un cast en Byte donne 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.
PDFlibPas DER_OID combine les deux premiers arcs d'OID en 40 * arc1 + arc2 et encode la somme en base-128 dans un UInt64, si bien que 2.999.3 devient 06 03 88 37 03, tandis qu'un cast en Byte garderait 55 et décoderait l'identifiant en 1.15.3
La plupart des arcs PKI n'atteignent jamais la frontière, d'où le passage inaperçu du raccourci sur un octet — les arcs joint-iso-itu-t à partir de 2.48 ont besoin de deux octets, donc les vecteurs de test ont leur place des deux côtés de cette ligne

Il y a un autre débordement tapi dans la même ligne d'arithmétique. DER_OID parse les arcs en Int64, donc un second arc légal peut monter jusqu'à Int64.MaxValue, et ajouter 80 pour arc1 = 2 fait déborder un entier signé 64 bits. La valeur combinée est donc portée dans un UInt64, qui porte Int64.MaxValue + 80 sans boucler — personne n'émet d'OID aussi grands, mais une chaîne forgée peut toujours en réclamer un. Le tampon de travail de dix octets dans DER_OID contient les dix groupes de 7 bits dont une valeur 64 bits peut avoir besoin, si bien que même 2.9223372036854775807 s'encode en un sous-identifiant de dix octets au lieu de boucler

Ce que le parcours CMS accepte, et où vit la vérification

PDFlibCMSRead renvoie des octets qui se trouvent là où RFC 5652 dit qu'ils doivent être, et c'est tout son travail. Il ne vérifie ni valeur de signature, ni condensat, ni période de validité. Le parcours n'accepte que du DER : DERReadTLV refuse les longueurs indéfinies et les numéros de tag multi-octets, donc un CMS encodé en BER venant d'un signataire non conforme rapporte zéro certificat. Nous préférons ça à une analyse partielle du BER. En pratique, l'indice révélateur est un octet de longueur $80 juste après le tag externe $30, car c'est ainsi qu'un SEQUENCE à longueur indéfinie commence

Les certificats d'attributs et les autres alternatives de CertificateChoices sont sautés pendant la traversée du jeu de certificats, puisque seule l'alternative Certificate ordinaire est un certificat X.509 exploitable par la construction de chaîne et les recherches de révocation. Tout ce qui est cryptographique reste entre les mains du code qui en est propriétaire, ce qui commence par les contrôles de couverture d'octets dans signature PAdES et validation du ByteRange en Delphi et se poursuit avec la classification de ce qui a changé après la signature d'un PDF. La même habitude de se méfier des longueurs déclarées traverse le durcissement d'un parseur PDF Pascal contre les fichiers malveillants

L'extraction de certificats, la construction de chaîne et les appels de validation à long terme montrés plus haut font partie de losLab PDF Library for Delphi, qui tourne sous Delphi, C++Builder et Lazarus, donc le même code de lecture de signatures marche dans un service Windows et dans un build Linux