Skip to content
← Tous les articles
· Delta1 Labs Strong NamingGlass

Ce que prouve vraiment une signature de nom fort

Un PublicKeyToken dans une référence d’assembly ressemble à un sceau anti-altération et à un tampon d’éditeur, mais il n’est ni l’un ni l’autre. Voici exactement ce que Glass.NET lit dans la table Assembly et le tas #Blob pour afficher la clé publique, dériver le jeton de 8 octets et distinguer un assembly entièrement signé d’un assembly à signature différée, et pourquoi, sur le .NET moderne, la signature n’est jamais vérifiée au chargement.

Vous ouvrez un assembly dans Glass.NET et la ligne d’identité affiche MyLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a5b2c8d4e6f70819. Il est tentant de lire ce jeton comme deux garanties à la fois : que les octets n’ont pas été modifiés depuis que l’éditeur les a compilés, et que l’éditeur est bien celui qu’il prétend être. Un nom fort n’est ni l’un ni l’autre. C’est une étiquette d’identité de forme cryptographique, et comprendre ce qu’il affirme exactement — et ce qu’il n’affirme pas — est une courte visite de la table Assembly, du tas #Blob et d’un unique hachage SHA-1.

La vraie question

Deux faits distincts se cachent derrière ce seul jeton. Le premier est la dérivation : d’où viennent ces huit octets, et de quoi sont-ils l’empreinte ? Le second est l’application : lorsque le runtime charge cet assembly, quelque chose vérifie-t-il réellement une signature par rapport à ces octets ? La plupart de la confusion autour des noms forts vient du fait de supposer que la réponse à la seconde question est « oui, toujours ». Sur le .NET moderne, c’est « non, jamais ». Glass répond aux deux questions à partir des seules métadonnées, et prend soin de ne pas exagérer la seconde.

D’où vient le jeton

Un assembly à nom fort stocke sa clé publique complète dans le manifeste. En syntaxe de style ILDASM, l’assembly qui la définit ressemble à ceci :

.assembly MyLib
{
  .publickey = (00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00
                00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 ... )
  .hash algorithm 0x00008004
  .ver 1:0:0:0
}

Ce blob .publickey est la vraie clé : une structure de clé publique SNK qui commence par un en-tête et le marqueur ASCII RSA1. Elle réside dans le tas #Blob et est pointée par la colonne PublicKey de la table Assembly à une seule ligne. Un assembly qui référence MyLib ne répète pas la clé entière ; il ne stocke que le jeton de 8 octets :

.assembly extern MyLib
{
  .publickeytoken = (A5 B2 C8 D4 E6 F7 08 19)
  .ver 1:0:0:0
}

Le jeton est un hachage de la clé, calculé de la même façon partout :

using System.Security.Cryptography;

static string PublicKeyToken(byte[] fullPublicKey)
{
    byte[] hash  = SHA1.HashData(fullPublicKey); // 20 bytes
    byte[] token = hash[^8..];                   // last 8 bytes
    Array.Reverse(token);                        // stored little-endian, shown reversed
    return Convert.ToHexString(token).ToLowerInvariant();
}

Prenez le SHA-1 de tout le blob de clé publique, gardez les huit derniers octets, inversez-les et imprimez-les en hexadécimal. C’est tout l’algorithme. Cela veut dire que le jeton est une empreinte tronquée : il épingle un assembly à une clé publique de façon compacte, pour qu’une référence puisse nommer la clé exacte avec laquelle une dépendance a dû être compilée sans trimballer 160 octets de module RSA. Quand le runtime lie MyLib, il recalcule le jeton de la clé publique du candidat et le compare à celui de la référence. Cette comparaison est une correspondance d’identité, rien de plus.

Identité : d’où vient le jetonblob .publickeyclé RSA1 complète, tas #BlobSHA-1hachage de 20 octets8 derniers octets, inversésPublicKeyToken=a5b2c8d4e6f70819La liaison compare les jetons → même clé d’éditeur. Identité seule.Intégrité : la signature est-elle vérifiée ?StrongNameSignaturesignature RSA sur le hachage de l’image.NET Frameworkvérifiée au chargement(pleine confiance peut sauter).NET 5+ / .NET CoreNON vérifiée au chargementliaison d’identité seuleNe prouve PASl’authenticité de l’éditeur(pas de CA ; clé auto-générée)l’intégrité sur le .NET moderne
Le jeton est une empreinte SHA-1 de la clé publique utilisée pour la liaison d’identité ; la signature, à part, n’est vérifiée que sur .NET Framework, donc un nom fort ne prouve ni l’authenticité ni, sur le .NET moderne, l’intégrité.

Ce que Glass lit, et ce qu’il refuse d’affirmer

Quand vous chargez un assembly, Glass lit la ligne de la table Assembly, extrait le blob PublicKey de #Blob et exécute exactement le hachage ci-dessus pour vous afficher le jeton sur la ligne d’identité : il ne fait pas confiance au jeton qu’une référence prétend, il le dérive de la clé réellement présente. Dépliez le nœud Assembly et la clé publique complète est là dans la vue de métadonnées, étiquetée RSA1, avec la valeur AssemblyFlags à côté pour que vous voyiez le bit PublicKey (0x0001) qui marque le blob comme une vraie clé et non comme un jeton.

La partie sur laquelle Glass reste délibérément silencieux est la vérification. Il y a un second artefact dans le PE que l’on confond avec la clé : la signature de nom fort, une signature RSA sur un hachage de l’image, stockée dans une région réservée que pointe le répertoire de données StrongNameSignature de l’en-tête CLI. Glass vous montrera que la région existe et sa taille. Il ne vous dira pas que la signature est « valide » comme s’il s’agissait d’un verdict de confiance, car sur le runtime qui intéresse la plupart des lecteurs, cette question n’est jamais posée.

Ce qu’un nom fort ne prouve pas

Deux lacunes indépendantes, et Glass expose les preuves des deux.

Il ne prouve pas qui est l’éditeur. Une clé de nom fort est auto-générée — sn -k en produit une en une seconde —, sans autorité de certification, sans identité et sans révocation. N’importe qui peut forger une clé et donner un nom fort à un assembly avec elle. Le jeton vous dit que deux assemblies ont été signés avec la même clé ; il ne vous dit rien sur à qui appartient cette clé. (Authenticode, qui lie une signature à un certificat X.509 émis à une organisation nommée, est l’artefact qui porte l’identité de l’éditeur : une signature distincte que Glass signale à part.)

Sur le .NET moderne, il ne prouve pas l’intégrité. .NET Framework vérifiait la signature de nom fort au chargement d’un assembly hors du GAC, même si un hôte en pleine confiance pouvait désactiver cela via le contournement de nom fort. .NET Core et .NET 5+ ont supprimé entièrement la vérification au chargement : le nom fort ne sert qu’à calculer l’identité et à lier les références. Un attaquant qui retire la signature, modifie l’IL et laisse la clé publique en place produit un assembly qui se charge quand même et annonce toujours le jeton d’origine, car rien ne recalcule la signature. C’est pourquoi Glass étiquette le jeton comme identité et laisse l’intégrité à Authenticode et à votre propre hachage de fichiers.

Les assemblies à signature différée paraissent signés sans l’être

Il existe un troisième état qui mérite d’être reconnu, et c’est là que commence la plupart de la confusion « est-ce signé ? ». Un assembly à signature différée porte la vraie clé publique — il a donc un jeton et annonce une identité complète — mais sa région de signature est réservée et à zéro, pour être remplie plus tard par qui détient la clé privée :

# Developer builds with the public key only; signature space is reserved
csc /delaysign+ /keyfile:public-only.snk MyLib.cs
# Later, the release gatekeeper completes it with the private key
sn -R MyLib.dll full-keypair.snk

Glass lit le répertoire StrongNameSignature, voit une clé publique non vide associée à un blob de signature entièrement à zéro et signale l’assembly comme à signature différée plutôt que signé. Cette distinction compte : un assembly à signature différée sur .NET Framework échouerait à la vérification (ou aurait besoin d’un enregistrement de contournement), alors que sur le .NET moderne il se charge sans souci précisément parce que rien ne vérifie — une démonstration éclatante que « a un jeton » et « a une signature vérifiée » sont des faits sans rapport.

Mises en garde

La dérivation du jeton est fixée à SHA-1 quelle que soit la clé de signature ; une clé RSA de 2048 bits et les clés plus récentes de style ECMA se réduisent toutes deux à un jeton SHA-1 de 8 octets, donc la résistance aux collisions du jeton n’est pas celle de la clé. Glass calcule et compare les jetons, il ne tente pas de vérifier cryptographiquement le blob de signature, car un résultat « signature valide » impliquerait une garantie au chargement que les runtimes modernes n’offrent pas et serait trompeur à imprimer. Et une correspondance de jeton lors de la liaison n’est appliquée que lorsque la référence a réellement enregistré un jeton : une référence compilée contre un MyLib non signé enregistre un PublicKeyToken vide, et Glass affiche cette identité vide plutôt que d’en inventer une.

À retenir

Un jeton de clé publique de nom fort est une empreinte SHA-1 d’une clé publique auto-générée, stockée entière dans l’assembly qui la possède et sous forme de huit octets dans tout ce qui la référence. Il lie les références à une clé, ce qui est une garantie d’identité réelle et utile. Ce n’est pas un certificat d’éditeur et, sur .NET Core et .NET 5+, ce n’est pas un sceau anti-altération : la signature qu’il implique n’est jamais vérifiée au chargement. Glass.NET lit la clé, dérive le jeton honnêtement, distingue signé de signature différée et s’arrête exactement là où s’arrêtent les garanties des métadonnées, pour que vous lisiez l’identité pour ce qu’elle est et que vous vous tourniez vers Authenticode et votre propre hachage pour l’intégrité qu’elle n’a jamais été conçue pour porter.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.