Affichage des articles dont le libellé est Désassembleur. Afficher tous les articles
Affichage des articles dont le libellé est Désassembleur. Afficher tous les articles

lundi 5 octobre 2009

Atelier 01 - Comprendre la compilation .NET

Afin de comprendre la compilation d'un programme en C#, nous allons utiliser le programme IL Disassembler (que l'on doit normalement trouver dans le menu démarrer, tous les programmes, Microsoft.. Pour ma part il se trouve dans Microsoft Windows SDK -> Tools

Une fois lancé, on ouvre avec ce programme, le fichier Calculateur.dll

ildasm affiche sous forme d'arborescence le code désassemblé et les métadonnées de tout fichier exécutable ou librairie compilé spécifiquement pour Microsoft .Net.

Lors d'une compilation C#, le compilateur convertit le code source en langage MSIL (Microsoft Intermediate Language), un jeu d'instructions indépendant du processeur qui est converti ensuite en code natif. MSIL inclut des instructions pour le chargement, le stockage, l'initialisation et l'appel de méthodes sur des objets, ainsi que des instructions pour la réalisation d'opérations arithmétiques et logiques, le flux de contrôle, l'accès direct à la mémoire, la gestion des exceptions et d'autres opérations. Avant d'exécuter du code, vous devez d'abord convertir le langage MSIL en code spécifique du processeur, généralement à l'aide du compilateur JIT (Just-In-Time) fourni par le Framework .Net dans le Common Language Runtime (CLR). On dit alors que le code est géré par le CLR, d’où le nom de code managé.

Lorsqu'un compilateur produit un code MSIL, il génère aussi des métadonnées. Les métadonnées décrivent les types contenus dans votre code, y compris la définition de chaque type, les signatures des membres de chaque type, les membres référencés par votre code, et d'autres données que le runtime utilise au moment de l'exécution. Le code MSIL et les métadonnées sont stockés dans un fichier exécutable portable (PE) qui est basé sur le fichier Microsoft PE publié qu'il prolonge et sur le format COFF (Common Object File Format) utilisé traditionnellement pour le contenu exécutable. Ce format de fichier, qui accepte le code MSIL ou le code natif ainsi que les métadonnées, permet au système d'exploitation de reconnaître les images du Common Language Runtime. La présence de métadonnées dans le fichier en même temps que le jeu d'instructions MSIL permet à votre code de se décrire lui-même, ce qui signifie que les bibliothèques de types et IDL (Interface Definition Language) ne sont pas nécessaires. Le runtime recherche les métadonnées dans le fichier et les extrait selon les besoins, au moment de l'exécution.

Le code MSIL ressemble à un assembleur évolué et indépendant de la plateforme ; il vous est possible de le modifier.

On va dumper (File, Dump) le fichier Calculateur que l'on vient d'ouvrir avec le désassembleur et le sauver avec le reste du code, mais au format .il
On ouvre ce fichier .il avec notepad (pour ma part notepad++ car c'est un superbe programme) et on va chercher la ligne de l'addition add et la remplacer par mul
.class public auto ansi beforefieldinit Coach.Calculateur
extends [mscorlib]System.Object
{
.method public hidebysig static int32 Ajouter(int32 Valeur01,
int32 Valeur02) cil managed
{
// Code size 9 (0x9)
.maxstack 2
.locals init (int32 V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldarg.1
IL_0003: mul
IL_0004: stloc.0
IL_0005: br.s IL_0007

IL_0007: ldloc.0
IL_0008: ret
} // end of method Calculateur::Ajouter
On sauve le fichier et nous allons le réassembler avec la commande ilasm.exe

Nous devons fermer le désassembleur pour éviter les erreurs, et supprimer la dll.
La commande à taper pour recompiler la dll est la suivante (suivant où se trouve ilasm.exe) :
ilasm calculateur.il /DLL
Par défaut, ilasm.exe tente de compiler le code .il avec une extension .exe. Dans notre cas, la librairie n’ayant pas de point d’entrée (elle n’a pas de bloc static void Main() ), nous devons préciser que nous voulons une librairie en utilisant le switch /DLL .

Dans l'invite de commande, nous allons pouvoir taper PremierProgramme, et normalement (car dans mon cas cela n'a pas fonctionner, mais vu que je n'ai pas la même version de .NET je me suis dit que c'était presque normal...) et nous aurions dû obtenir la réponse 50 au lieu des 15 précédemment.

Comme on vient de le voir, le compilateur C# transforme le code C# en MSIL, puis le code est assemblé dans un fichier d’extension .dll. C’est pour cette raison que nous appelons les librairies compilées avec .Net « assemblage » (ou « assembly » en littérature anglaise).

Comme on vient de le faire, on peut imaginer modifier relativement facilement un assemblage compilé, en le désassemblant avec ildasm.exe, puis en réassemblant avec ilasm.exe. Dans de nombreuses applications, cela ne posera aucun souci, mais il arrive parfois que des enjeux économiques, ou un engagement de sécurité nécessitent de se protéger contre une telle pratique. Nous allons donc signer avec une clé le code. Par la suite, sans cette clé (qu’il ne faudra donc pas distribuer), il sera impossible de réassembler un code MSIL sans générer une erreur lors de l’exécution du programme utilisant cet assemblage.

Je vais zapper cette partie, étant donné que je ne retrouve pas les même commandes entre Visual Studio 2005 et 2008, ainsi qu'entre le2 Framework 2.0 et 3.5 et que je n'ai pas forcément l'envie de chercher cette information, mais je sais que c'est possible de le faire.


Partage de l'assemblage avec d’autres programmes

Pour la plupart des applications .NET Framework, on localise les assemblages qui composent notre application dans le répertoire de l'application. Il est néanmoins possible de les mettre ailleurs, soit dans un sous répertoire de l’application (en paramétrant ce chemin dans la configuration de l’application), soit dans un référentiel centralisé contenant tous les assemblages partagés installés sur notre poste de travail. Ce référentiel centralisé est le Global Assembly Cache ou GAC.

Chaque ordinateur sur lequel le Common Language Runtime (CLR) est installé possède un cache de code à l'échelle de l'ordinateur appelé Global Assembly Cache (GAC). Le GAC stocke les assemblages spécialement destinés à être partagés entre plusieurs applications sur l'ordinateur. Vous ne devez partager des assemblages en les installant dans le GAC qu'en cas de nécessité. En règle générale, vous devez garder les dépendances vers les assemblages privés et rechercher les assemblages dans le répertoire de l'application. En outre, il n'est pas nécessaire d'installer des assemblages dans le GAC pour les rendre accessibles à COM Interop ou au code non managé.

Le GAC est sur le disque de notre ordinateur, dans le répertoire assembly sous le répertoire d’installation de Windows (donc, classiquement dans c:\Windows\assembly).

Le GAC n’est pas un répertoire comme les autres, car il peut contenir des assemblages ayant un même nom, mais des numéros de versions différentes.

Petit test, nous allons créer un fichier CalculateurInfos.cs et le remplir du code suivant :
[assembly: System.Reflection.AssemblyVersion("1.1.2.0")]
[assembly: System.Reflection.AssemblyFileVersion("1.2.2.0")]
[assembly: System.Reflection.AssemblyTitle("Calculateur")]
[assembly: System.Reflection.AssemblyDescription("")]
[assembly: System.Reflection.AssemblyConfiguration("")]
[assembly: System.Reflection.AssemblyCompany("Agilcom")]
[assembly: System.Reflection.AssemblyProduct("Coach")]
[assembly: System.Reflection.AssemblyCopyright("© 2007")]
[assembly: System.Reflection.AssemblyTrademark("")]
[assembly: System.Reflection.AssemblyCulture("")]
Dans l’invite de commande, compilez le code C# du calculateur, en référençant maintenant les informations de l’assemblage et en l’associant avec votre fichier de clés, en tapant l’ordre :
csc /target:library calculateur.cs calculateurinfos.cs
Dans l’invite de commande, recompilez maintenant le programme principal, en tapant l’ordre suivant :
csc premierprogramme.cs /reference:calculateur.dll
En testant PremierProgramme, tout se passe bien, nous avons le bon fonctionnement du programme.
Dans l’invite de commande, tapez l’ordre suivant pour ajouter l’assemblage au GAC : gacutil /i calculateur.dll
Et normalement (je n'ai pas pu tester...) nous devrions retrouver notre dll dans le répertoire assembly

En détruisant la dll qui se trouve dans le dossier où nous avons les sources, le programme devrait quand même fonctionner en allant chercher les infos manquantes dans le GAC.


La documentation

Dans tous les livres, et partout sur le net, on trouvera que la documentation et ce qu'il y'a de plus important dans un code, bien que ce soit pénible à faire... Le C# va nous aider à faire une bonne documentation, sans pénaliser notre principale fonction : développer.

C# propose quatre catégories de commentaires, que nous pouvons utiliser dans nos développements :
- La ligne simple de commentaire, précédée par //
- Les commentaires délimités, encadrés par /* notre commentaire */
- La ligne simple de documentation, précédée par ///
- Et enfin, la documentation délimitée, qui combine les deux possibilités précédentes ;
L’intérêt de la ligne simple de documentation et de la documentation délimitée est qu’au moment de la compilation du code, il est possible de préciser que l’on souhaite l’extraction de la documentation. Un fichier XML est alors généré, et il suffit d’y appliquer une feuille de style XSL-T pour obtenir la documentation de notre code

Nous allons modifier le code Calculateur.cs :
/*
Auteur : Resize
Commentaire : Programme de calcul avancé
Révisions et Modifications
---------------------------------------------------
Date Par Commentaires
03/10/2009 Resize Version Initiale

*/

namespace Coach
{
/// <summary>
/// Cette classe implémente les fonctions de calcul
/// </summary>
public class Calculateur
{
/// <summary>
/// Cette fonction ajoute deux valeurs entières
/// </summary>
/// <param name="Valeur01">Première valeur</param>
/// <param name="Valeur02">Deuxième valeur</param>
/// <returns>l'entier de résultat</returns>
public static int Ajouter(int Valeur01, int Valeur02)
{
return Valeur01 + Valeur02; // retour valeur
}
}
}

On recompile le programme avec la commande suivante :
csc /target:library calculateur.cs calculateurinfos.cs /doc:calculateur.xml
Un nouveau fichier .xml a été créé. On peut l'ouvrir et voir ce qu'il contient. On peut lui ajouter un fichier xsl pour que ce soit plus digeste.