Comment les littéraux de chaîne bruts se décompilent en C#
Un littéral de chaîne brut, une chaîne verbatim et une chaîne ordinaire se compilent tous vers le même ldstr identique pointant vers le tas #US. Voici l'IL, les octets de la chaîne utilisateur qui se cachent derrière, et comment Glass.NET choisit la forme de guillemets à reconstruire.
Les littéraux de chaîne bruts — la forme """...""" arrivée avec C# 11 — donnent l’impression de devoir laisser une trace dans l’assembly compilé. Ils permettent de coller du JSON, du SQL, une expression régulière ou un chemin de fichier sans aucun échappement, suppriment l’indentation à votre place et conservent les sauts de ligne. Une chose aussi astucieuse doit bien être consignée dans les métadonnées, non ?
Eh bien non. Un littéral de chaîne brut, une bonne vieille chaîne verbatim @"..." et une chaîne ordinaire "..." avec échappements se compilent tous exactement vers la même chose : une instruction ldstr pointant vers une entrée du tas #US (chaînes utilisateur). La syntaxe à triples guillemets, les règles d’indentation, la gestion des sauts de ligne — tout cela s’exécute à la compilation et produit une constante string ordinaire. Au moment où les octets atteignent le disque, il ne reste plus rien de « brut » à trouver. Cela fait des littéraux de chaîne bruts une loupe idéale pour deux questions auxquelles un décompilateur doit répondre : où vivent réellement les constantes de chaîne ? et lorsque la forme source a été effacée, quelle forme faut-il reconstruire ? Cet article parcourt les deux à l’aide de Glass.NET.
À quoi ressemble le code source
Voici une méthode qui renvoie un petit bloc de texte qu’il serait pénible d’écrire comme une chaîne ordinaire : il contient des guillemets simples, des guillemets doubles, une barre oblique inverse et des sauts de ligne :
static class Report
{
public static string Banner() => """
It's "ready".
Path: C:\tmp
""";
}
Trois choses se produisent à la compilation, et les trois sont purement lexicales. Le saut de ligne immédiatement après le """ d’ouverture est supprimé, de même que le saut de ligne avant le """ de fermeture. L’espace à gauche du délimiteur de fermeture définit l’indentation commune qui est retirée de chaque ligne de contenu — ici huit espaces, donc le contenu se désindente jusqu’à la marge de gauche. Et à l’intérieur du littéral, il n’y a aucun traitement d’échappement : la barre oblique inverse dans C:\tmp est une barre oblique inverse littérale, et les guillemets sont des guillemets littéraux. Ce qui reste est une unique valeur de chaîne :
It's "ready".
Path: C:\tmp
Cette valeur — une string de 25 caractères comprenant un \n incorporé — est la seule chose que le compilateur transporte plus loin. Les délimiteurs """ ont fait leur travail et ont disparu.
Il n’y a rien de « brut » dans l’IL
Ouvrez la méthode dans la vue IL de Glass et toute la fonctionnalité se réduit à une seule instruction :
.method public hidebysig static string Banner () cil managed
{
.maxstack 8
IL_0000: ldstr "It's \"ready\".\nPath: C:\\tmp"
IL_0001: ret
}
ldstr charge une constante de chaîne. Le désassembleur l’imprime avec des échappements à la C — \", \n, \\ — parce que c’est ainsi qu’un listing tokenisé affiche une valeur, mais ces échappements sont le rendu du désassembleur, et non quelque chose stocké dans le fichier. Écrivez le même texte identique de trois façons différentes dans le code source :
"It's \"ready\".\nPath: C:\\tmp" // plain, escaped
@"It's ""ready"".
Path: C:\tmp" // verbatim
"""
It's "ready".
Path: C:\tmp
""" // raw
…et les trois se compilent vers le même ldstr pointant vers la même entrée du tas. Le choix entre elles est une décision de lisibilité au niveau du code source que le compilateur résout puis jette. C’est le fait central pour la décompilation : le style de guillemets n’est pas une métadonnée. Il ne peut pas être récupéré, seulement re-choisi.
Où vit réellement la chaîne : le tas #US
L’opérande de ldstr est un jeton de métadonnées dont l’octet de poids fort est 0x70. Cet identifiant de table signifie tas de chaînes utilisateur, et les trois octets de poids faible sont un décalage en octets dans le flux #US — l’un des tas nommés des métadonnées managées, aux côtés de #Strings (identifiants), #Blob (signatures et constantes) et #GUID. Ainsi IL_0000: ldstr encode en réalité quelque chose comme ldstr 0x70000001, et 0x000001 est l’endroit où commencent les caractères dans #US.
Le tas #US stocke chaque chaîne sous une forme compacte et auto-descriptive définie par ECMA-335 : un préfixe de longueur compressé, puis les caractères en UTF-16 (petit-boutiste, deux octets chacun), puis un unique octet indicateur final. Le préfixe de longueur compte les octets qui suivent, soit 2 × nombreDeCaractères + 1 — le +1 correspond à cet indicateur final. Prenez une minuscule chaîne de deux caractères, A' (un A et une apostrophe), pour voir chaque octet :
Les octets sont 05 41 00 27 00 01. Le 05 initial est la longueur compressée : cinq octets suivent. 41 00 est A en UTF-16LE, 27 00 est l’apostrophe. Le 01 final est l’indicateur : le runtime le met à 1 lorsqu’un caractère sort d’un ensemble « simple » — tout caractère dont l’octet de poids fort est non nul, ou l’un d’une poignée de points de code spéciaux comprenant 0x27 (l’apostrophe) et 0x2D (le trait d’union). Notre apostrophe le déclenche, l’indicateur vaut donc 01. Une chaîne purement ASCII comme "ready" porterait plutôt un indicateur 00. La chaîne réelle de Banner suit le même schéma — longueur compressée, caractères UTF-16 y compris le saut de ligne 0x000A, et un indicateur 01 à cause de cette même apostrophe — simplement plus longue.
Deux conséquences découlent de cette disposition. Première : les chaînes dans #US sont dédupliquées par valeur, donc écrire le même texte littéral dans deux méthodes, avec deux styles de guillemets différents, produit deux jetons ldstr pointant vers une seule entrée du tas. Seconde, et c’est tout l’enjeu : le tas conserve les caractères et rien de la syntaxe. Aucun bit ne dit « ceci était un littéral de chaîne brut ».
Ce que Glass reconstruit, et comment il choisit la forme de guillemets
Comme la syntaxe a disparu, Glass ne récupère pas un littéral de chaîne brut ; il le re-choisit. Il relit la constante depuis le tas et se demande quelle forme de guillemets C# rend ces caractères exacts de la manière la plus lisible. La logique suit un ordre clair :
- Pas de sauts de ligne et pas de caractères gênants → un littéral ordinaire
"...". - Des barres obliques inverses mais pas de guillemets doubles incorporés ni de sauts de ligne → une chaîne verbatim
@"...", qui évite de doubler chaque barre oblique inverse. - Des sauts de ligne accompagnés de guillemets ou de barres obliques inverses → un littéral de chaîne brut, qui n’a besoin d’échapper ni l’un ni l’autre et montre directement la structure des lignes.
Notre chaîne Banner relève du dernier cas — elle a un saut de ligne, les deux sortes de guillemets et une barre oblique inverse — donc Glass la reconstruit sous la forme brute, en choisissant un délimiteur d’au moins trois guillemets (et plus long si le contenu lui-même contenait une suite de """), puis en réindentant le corps sous un délimiteur de fermeture :
static class Report
{
public static string Banner() => """
It's "ready".
Path: C:\tmp
""";
}
C’est le même texte que celui avec lequel vous avez commencé, mais il vaut la peine d’être précis sur ce qui s’est passé : Glass n’a pas lu """ dans le fichier, car """ n’a jamais été dans le fichier. Il a reconstruit la syntaxe la plus lisible qui produit les octets qu’il a trouvés. Repassez ce code source reconstruit par le compilateur et vous obtenez un ldstr identique octet pour octet vers une entrée #US identique octet pour octet. L’aller-retour est exact au niveau qui compte — la valeur — même si la syntaxe de surface est un choix nouveau et indépendant.
Lisez-le vous-même
Vous pouvez observer chaque étape de ce processus dans Glass depuis la ligne de commande :
glass decompile Report.dll --type Report --member Banner
glass decompile Report.dll --type Report --member Banner --il
La première commande affiche le littéral de chaîne brut reconstruit ; la seconde montre l’unique ldstr qui se cache derrière. Ouvrez ensuite l’assembly dans l’interface de Glass, passez à la navigation par métadonnées et inspectez directement le tas #US pour voir par vous-même les octets UTF-16 préfixés par la longueur et l’indicateur final : l’apostrophe faisant passer ce dernier octet à 01 est le genre de détail que l’on ne croit qu’une fois qu’on a vu les octets bruts.
Glass.NET est un décompilateur .NET gratuit pour inspecter les assemblys que vous avez le droit d’inspecter : vos propres builds, vos dépendances et les binaires tiers que vous êtes autorisé à analyser. Les littéraux de chaîne bruts sont un petit rappel d’une grande vérité sur la décompilation : un décompilateur reconstruit du sens, pas des frappes au clavier, et le mieux qu’il puisse faire — ce que vise Glass — est de reconstruire le code source le plus clair qui se recompile exactement vers ce qu’il a lu.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.