Compactage des heaps de métadonnées et renumérotation des tokens : réduire un assembly .NET après obfuscation
Le renommage laisse des chaînes et des blobs morts dans les heaps #Strings et #Blob. Comment Nebula compacte les heaps de métadonnées et renumérote les tokens, avec la disposition réelle des métadonnées, de l'IL, de la configuration et des mesures avant/après.
Renommez quelques milliers de membres et vous avez raccourci chaque identifiant de votre assembly : CalculateInvoiceTotal est devenu a, _pendingReconciliationQueue est devenu b. Vous vous attendriez à ce que le fichier rétrécisse. Ouvrez les deux builds dans un éditeur hexadécimal et, souvent, il n’en est rien : les longs noms d’origine sont toujours là, dans le heap #Strings, orphelins mais jamais supprimés. L’obfuscation a changé les chaînes vers lesquelles pointent les tables de métadonnées ; elle n’a pas récupéré les chaînes vers lesquelles elles pointaient auparavant.
Cet article traite de l’étape qui achève le travail : le compactage des heaps de métadonnées et la renumérotation des tokens. C’est la transformation la moins spectaculaire qu’exécute Nebula et, sur un gros assembly, l’une des plus mesurables : c’est la différence entre un renommage qui ne fait que masquer les noms et un renommage qui les efface aussi.
Où résident réellement les noms
Les métadonnées d’un assembly .NET sont un ensemble de tables (TypeDef, MethodDef, Field, …) plus quatre heaps que les tables indexent :
#Strings— noms d’identifiants en UTF-8 terminés par un octet nul : noms de types, de méthodes, de champs et d’espaces de noms.#US— le heap de chaînes utilisateur, qui contient les littéraux de chaîne UTF-16 que votre code charge avecldstr.#Blob— signatures, arguments d’attributs personnalisés, valeurs constantes et descripteurs de marshalling.#GUID— identifiants de version de module et apparentés.
Une ligne de MethodDef ne stocke pas son nom ; elle stocke un offset dans #Strings. Le nom "CalculateInvoiceTotal" réside une seule fois dans le heap, et chaque token qui en a besoin porte l’entier de l’offset où il commence.
Le renommage réécrit le champ Name avec un nouvel offset. La façon naïve d’obtenir cet offset est d’ajouter "a\0" à la fin de #Strings et de pointer là. Rapide, correct, et cela ne touche jamais les anciens octets. Après une passe complète de renommage, le heap contient tous les identifiants d’origine plus chaque remplacement court. Le fichier peut même grossir.
Ce que fait le compactage
Le compactage traite les heaps comme une arène gérée par un ramasse-miettes. Les étapes :
- Marquer. Parcourir chaque colonne de table qui est une référence vers un heap —
TypeDef.Name,TypeDef.Namespace,MethodDef.Name,Field.Signature, chaqueldstrvers#US, chaque#Blobd’attribut personnalisé — et enregistrer quels offsets sont réellement accessibles. - Balayer et reconstruire. Allouer de nouveaux heaps ne contenant que les entrées accessibles, dédupliquées pour que deux signatures identiques partagent un seul blob.
- Renuméroter. Chaque offset de heap dans chaque table est réécrit vers sa nouvelle position. Les tokens vers les tables elles-mêmes sont réempaquetés aussi, car les lignes vides de
TypeRef/MemberReflaissées par les références fusionnées ou supprimées peuvent être abandonnées.
L’étape 3 est la raison pour laquelle ceci ne peut pas être un correctif ponctuel. Un token de métadonnées comme 0x06000012 (un MethodDef, ligne 0x12) est référencé depuis l’IL (call 0x06000012), depuis d’autres tables et depuis les signatures de #Blob. Renumérotez une table et vous devez corriger chaque call, ldtoken, newobj et ldstr qui la traverse. Nebula le fait comme un unique remapping cohérent : il construit une table ancien token → nouveau token, réécrit les tables, puis réécrit les opérandes de l’IL de chaque corps de méthode d’après cette même table.
// IL before — operand is a raw metadata token
IL_000a: ldstr 0x70000A1C // "CalculateInvoiceTotal failed for order "
IL_000f: call 0x0A000037 // MemberRef into a #Blob signature
// IL after compaction — same instructions, renumbered operands
IL_000a: ldstr 0x70000044
IL_000f: call 0x0A00000B
Les instructions sont identiques octet pour octet dans leur forme ; seules les opérandes bougent. Trompez-vous d’une ligne dans le remapping et l’assembly lève BadImageFormatException au chargement, ce qui explique exactement pourquoi vous ne faites pas cela à la main et pourquoi Nebula vérifie l’image reconstruite avant de l’écrire.
C’est aussi une étape de durcissement, pas seulement de taille
Le compactage se vend généralement sur la taille, mais l’angle sécurité, ce sont les octets orphelins de #Strings eux-mêmes. Un renommage qui ne fait que repointer les offsets laisse CalculateInvoiceTotal, _pendingReconciliationQueue et tout autre nom d’origine physiquement présents dans le fichier. Ils ne se résolvent plus via les métadonnées — un décompilateur affiche a, b, c — mais un balayage trivial de type strings sur les octets bruts récupère tout votre vocabulaire d’origine :
$ strings Acme.Billing.dll | grep -i invoice
CalculateInvoiceTotal
InvoiceReconciliationService
_pendingInvoiceBatch
C’est une fuite bien réelle. Vos noms de méthode décrivent souvent votre domaine aussi clairement que le code. Le compactage efface les orphelins, si bien que le balayage ne renvoie rien et que les seuls noms présents dans le fichier sont les noms courts et dénués de sens produits par le renommage. Il en va de même pour #US : les littéraux que vous avez chiffrés et remplacés traînent encore dans le heap de chaînes utilisateur jusqu’à ce que le heap soit reconstruit.
Comment l’activer
Le compactage s’exécute après le renommage, le chiffrement des chaînes et le traitement des ressources, car il doit voir l’ensemble final des références vivantes. Dans nebula.config.json, c’est une étape sous la sortie, activée par défaut lorsque vous renommez, mais configurable :
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/Acme.Billing.dll" ],
"outputDirectory": "protected",
"rename": { "enabled": true },
"stringEncryption": { "enabled": true },
"metadata": {
"compactHeaps": true,
"dedupeBlobs": true,
"removeOrphanStrings": true,
"renumberTokens": true
}
}
Puis l’invocation habituelle :
nebula protect --config nebula.config.json --out protected
Le seul réglage qui mérite d’être compris est renumberTokens. Laisser les tokens tels quels (reconstruire seulement les heaps) est le choix conservateur si quelque chose en aval épingle un token précis — par exemple un outil qui lit votre assembly par une ligne MethodDef codée en dur. C’est rare. Gardez-le à true sauf raison concrète, car c’est la renumérotation qui permet d’abandonner les lignes de table vides.
Quand se retenir
Le compactage est sûr pour les assemblys ordinaires, mais deux cas méritent une liste metadata.preserve. D’abord, un assembly chargé par mdToken à travers une frontière — certains hôtes de profilage ou d’instrumentation mettent en cache les tokens. Ensuite, tout ce qui fait Module.ResolveMethod(int metadataToken) sur lui-même avec un token littéral incrusté dans le code source. Les deux sont inhabituels ; quand ils s’appliquent, épinglez les membres concernés :
"metadata": {
"compactHeaps": true,
"renumberTokens": true,
"preserve": [ "Acme.Billing.Diagnostics.TokenProbe.*" ]
}
Les membres nommés conservent leurs tokens d’origine ; tout le reste est renuméroté et compacté autour d’eux.
Ce que ça économise réellement
Les chiffres dépendent entièrement de la densité de noms de votre assembly, c’est-à-dire de la quantité de renommage retirée. Un résultat représentatif sur un assembly métier de taille moyenne — ~4 200 méthodes, vocabulaire de domaine abondant, chaînes chiffrées — ressemble à ceci :
#Strings #US #Blob File
rename only (no compaction) 412 KB 188 KB 96 KB 1.84 MB
+ heap compaction 34 KB 2 KB 71 KB 1.27 MB
─────── ────── ────── ───────
-92% -99% -26% -31%
L’effondrement de #Strings, ce sont les identifiants d’origine orphelins qui disparaissent. L’effondrement de #US, ce sont les littéraux d’avant chiffrement qui disparaissent. #Blob rétrécit moins et seulement grâce à la déduplication, car les signatures étaient toutes vivantes. Une réduction du fichier de 31 % est typique d’un assembly chargé de renommages ; un petit utilitaire avec peu de membres ne verra presque rien, car il y avait peu d’orphelins à collecter.
Le démarrage bouge aussi, mais moins que la taille ne le suggère. Le runtime mappe les métadonnées en mémoire et les lit paresseusement, si bien qu’un heap #Strings plus petit aide surtout le démarrage à froid et le working set, plutôt que le débit en régime permanent. Traitez le gain de taille comme le titre principal et le gain de démarrage comme un bonus — et, comme toujours, mesurez votre propre assembly plutôt que de vous fier à un tableau.
Vérifiez que ça a fonctionné
Deux contrôles, tous deux rapides. D’abord, confirmez que les orphelins ont disparu avec le même balayage qui les avait exposés :
$ strings protected/Acme.Billing.dll | grep -i invoice
$ # (no output — the original names are no longer in the file)
Ensuite, ouvrez l’assembly protégé dans Glass.NET et regardez la vue des métadonnées : le heap #Strings ne devrait contenir que la sortie courte du renommage et les noms du framework, le heap #US devrait être quasi vide si vous avez chiffré les chaînes, et la navigation par tokens devrait se résoudre proprement — un bug de renumérotation apparaît immédiatement sous forme de référence cassée. Glass lit les heaps directement, c’est donc la façon honnête de confirmer que le compactage a fait ce que la configuration demandait sans avoir à publier d’abord.
La version courte
Le renommage change ce vers quoi pointent les métadonnées ; le compactage récupère ce vers quoi elles pointaient. Sautez-le et vous expédiez un assembly dont les noms d’origine sont masqués pour un décompilateur mais trivialement récupérables avec strings, chargé de centaines de kilo-octets de heap mort. Exécutez-le et les orphelins sont effacés, les blobs dédupliqués, les tokens réempaquetés, et le fichier devient à la fois plus petit et véritablement débarrassé du vocabulaire que vous vouliez cacher. Il est activé par défaut lorsque vous renommez, précisément pour cette raison : laissez-le actif, épinglez le rare token autoréférentiel et vérifiez dans Glass avant d’expédier.
Consultez Nebula.NET pour le pipeline complet de transformations et la référence de nebula.config.json, et les tables de métadonnées expliquées pour les structures sur lesquelles opère le compactage.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.