Skip to content
← Tous les articles
· Delta1 Labs Glass.NETDécompilation.NETAnalyse approfondie

Lire les instructions de haut niveau en C# décompilé

Un fichier d'instructions de niveau supérieur n'a aucune classe visible ni aucun Main visible, mais l'assembly, lui, en a. Le compilateur C# enveloppe vos instructions dans une classe interne nommée Program et dans une méthode d'entrée au nom imprononçable <Main>$, marquée par la directive .entrypoint. Voici exactement ce que le compilateur émet dans les cas synchrone et async, pourquoi le point d'entrée est la méthode que vous ne pouvez jamais écrire à la main, où sont passés vos global usings, et comment Glass.NET le relit comme le programme de niveau supérieur que vous avez écrit.

Un fichier C# qui utilise des instructions de niveau supérieur semble n”avoir ni classe ni Main — vous écrivez simplement des instructions et le programme s”exécute. Mais un assembly doit avoir un point d”entrée, et les métadonnées doivent nommer un type auquel le rattacher. Le compilateur fournit les deux à votre place, et quand vous ouvrez le résultat dans un décompilateur, l”échafaudage redevient visible : une classe nommée Program que vous n”avez jamais écrite, et une méthode d”entrée portant un nom que vous ne pouvez pas écrire.

Ceci est une plongée pratique dans cet échafaudage : ce que le compilateur C# émet pour un programme de niveau supérieur dans les cas synchrone et async, l”indice .entrypoint qui identifie le véritable point d”entrée quel que soit son nom, où disparaissent vos directives using, et comment Glass.NET relit le tout jusqu”au programme de niveau supérieur dont vous êtes parti. Glass est un décompilateur .NET gratuit, et tout ici relève de l”analyse statique pure : lire les métadonnées et l”IL d”un assembly que vous avez le droit d”inspecter, sans jamais l”exécuter.

Le code source

Aussi simple qu”un programme de niveau supérieur puisse être : une instruction et un code de sortie :

using System;

Console.WriteLine($"args: {args.Length}");
return 0;

Pas d”espace de noms, pas de classe, pas de signature de méthode, et pourtant args est dans la portée et return définit le code de sortie du processus. Ces trois choses, c”est le compilateur qui les arrange en votre nom.

Ce que le compilateur émet

Les instructions deviennent le corps d”une méthode que le compilateur nomme <Main>$, placée sur une classe synthétisée nommée Program. Décompilée en C# lisible, la forme générée est celle-ci :

internal class Program
{
    private static int <Main>$(string[] args)
    {
        Console.WriteLine($"args: {args.Length}");
        return 0;
    }
}

Deux détails méritent qu”on s”y arrête. La classe est internal (et non static), elle porte donc un constructeur d”instance par défaut même si le point d”entrée lui-même est static — un Program écrit à la main avec un static Main est généralement une static class ou possède un constructeur que vous avez choisi, de sorte que la simple internal class avec une méthode au nom du compilateur est en soi un indice. Et le nom de la méthode, <Main>$, n”est pas un identifiant C# valide : les chevrons et le signe dollar le rendent imprononçable, si bien qu”il ne peut jamais entrer en collision avec un Main que vous ajouteriez et que vous ne pouvez jamais l”invoquer par son nom.

Voici l”IL, où vit le marqueur décisif :

.class private auto ansi beforefieldinit Program
       extends [System.Runtime]System.Object
{
  .method private hidebysig static int32
          '<Main>$'(string[] args) cil managed
  {
    .entrypoint
    .maxstack  8
    ldstr      "args: "
    ldarg.0
    ldlen
    conv.i4
    box        [System.Runtime]System.Int32
    call       string [System.Runtime]System.String::Concat(object, object)
    call       void [System.Console]System.Console::WriteLine(string)
    ldc.i4.0
    ret
  }
}

La directive .entrypoint est celle qui compte. Exactement une méthode dans un exécutable la porte, et c”est ce que le CLR lit pour décider où commence l”exécution. Un décompilateur n”a pas besoin de reconnaître la convention de nommage <Main>$ pour trouver le point d”entrée — il lit le jeton de point d”entrée des métadonnées directement dans l”en-tête CLI et atterrit sur cette méthode. Le nom est une commodité pour les humains ; .entrypoint est la vérité de terrain.

source niveau sup.Console.WriteLine(x);return 0;pas de classe · pas de Mainmétadonnées compiléesinternal class Programint32 <Main>$(string[]) .entrypointnom imprononçablejeton d'entrée (CLI)pointe direct vers <Main>$reconstruction de GlassConsole.WriteLine(x);return 0;instructions niveau sup.

Quand le programme est async

Ajoutez un await n”importe où dans les instructions de niveau supérieur et le point d”entrée change de forme. Supposons que le code source soit :

using System;
using System.Threading.Tasks;

await Task.Delay(100);
Console.WriteLine("done");
return args.Length;

Comme le corps fait await et renvoie un int, le compilateur émet <Main>$ comme une méthode async Task<int> et le traduit exactement comme n”importe quelle méthode async : une structure de machine à états générée contient la logique, et <Main>$ lui-même devient un amorçage léger. Décompilée, la méthode visible n”est que ceci :

[AsyncStateMachine(typeof(<<Main>$>d__0))]
[DebuggerStepThrough]
private static Task<int> <Main>$(string[] args)
{
    <<Main>$>d__0 stateMachine = default;
    stateMachine.args = args;
    stateMachine.<>t__builder =
        AsyncTaskMethodBuilder<int>.Create();
    stateMachine.<>1__state = -1;
    stateMachine.<>t__builder.Start(ref stateMachine);
    return stateMachine.<>t__builder.Task;
}

Le flux de contrôle réel — le await, la continuation après Task.Delay, le retour — vit dans <<Main>$>d__0.MoveNext(), le même motif de machine à états [CompilerGenerated] utilisé pour chaque méthode async. La seule chose particulière est le nom de base renommé <Main>$ enchâssé dans le propre nom de la machine à états, <<Main>$>d__0. Le runtime démarre toujours sur l”enveloppe synchrone <Main>$, que les règles du langage C# adaptent discrètement à un point d”entrée async pour vous.

Où sont passées les directives using

Une chose que vous ne trouverez pas dans les métadonnées, ce sont vos directives using — et encore moins les globales. Les usings implicites (<ImplicitUsings>enable</ImplicitUsings>) et les directives global using explicites sont une commodité de liaison à la compilation ; elles résolvent les noms de type pendant la compilation et n”émettent ni métadonnées ni IL. Au moment où l”assembly existe, chaque référence de type est déjà pleinement qualifiée dans les tables de métadonnées.

Donc le bloc using System; que vous voyez en haut de la sortie de Glass n”est pas une copie du code source d”origine — c”est la propre reconstruction de Glass, calculée à partir des références pleinement qualifiées que la méthode utilise réellement. C”est le bon modèle mental pour toutes les listes de using décompilées : elles sont régénérées pour que la sortie compile et se lise clairement, et non récupérées du code source. Les lire comme la preuve de ce que l”auteur a écrit est une erreur.

Comment Glass la relit

Un décompilateur naïf s”arrête à la vérité littérale : une internal class Program avec une méthode nommée <Main>$. C”est exact mais malcommode — le nom entre chevrons ne revient pas à du C# compilable, et l”échafaudage masque les trois lignes qui vous intéressent.

Glass.NET reconnaît le motif — la méthode .entrypoint, la convention de nommage <Main>$ et le conteneur Program synthétisé — et vous propose le programme tel qu”il a été écrit : sous forme d”instructions de niveau supérieur, avec le return mappé sur le code de sortie et args présenté comme le paramètre dans la portée. Lorsque le point d”entrée est async, Glass replie l”amorçage et la machine à états <<Main>$>d__0 vers les instructions qui font await, de sorte que vous lisez await Task.Delay(100) au lieu d”une danse de builder. Vous pouvez toujours descendre jusqu”à l”IL brut et voir .entrypoint par vous-même quand vous voulez confirmer par quoi le runtime démarre réellement.

La conclusion pratique

Quand vous ouvrez un exécutable et que le point d”entrée paraît étrange — une internal class Program que vous n”auriez pas écrite, une méthode nommée <Main>$, ou une courte enveloppe async devant une structure <<Main>$>d__0 — vous regardez des instructions de niveau supérieur ordinaires, rien d”exotique. Trouvez la méthode marquée .entrypoint, lisez son corps (ou laissez Glass la replier en forme de niveau supérieur) et ignorez le bloc using reconstruit : c”est un échafaudage, pas du code source. Glass.NET est gratuit et fait cela uniquement en lisant les métadonnées et l”IL de l”assembly, de sorte que vous pouvez inspecter ce qu”un programme que vous avez le droit d”analyser fait réellement au démarrage — sans jamais l”exécuter.

Essayez Nebula.NET

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