Suppression du code mort

La suppression du code mort est une technique d’optimisation essentielle de Babel Obfuscator. Elle consiste à repérer et à éliminer le code qui ne sera jamais exécuté : méthodes, propriétés, champs, voire types entiers reconnus comme inutilisés. En supprimant le code mort, Babel réduit la taille et la complexité de l’assembly obfusqué, ce qui présente plusieurs avantages.

La suppression du code mort réduit le temps de chargement de l’application. Débarrassé du code inutile, l’assembly obfusqué est plus petit, donc plus rapide à charger et à initialiser. Cette optimisation est particulièrement utile pour les applications dont la base de code est volumineuse ou dont l’initialisation consomme beaucoup de ressources.

La suppression du code mort améliore aussi les performances globales de l’application obfusquée. Sans les méthodes, les propriétés et les champs inutilisés, l’exécution est plus efficace. L’absence de code mort réduit les appels de fonction et les allocations de mémoire inutiles, d’où de meilleures performances à l’exécution et une meilleure réactivité.

Enfin, la suppression du code mort renforce la sécurité du code obfusqué. Retirer le code inutilisé limite les points d’entrée et les vulnérabilités possibles, et réduit donc la surface d’attaque offerte aux personnes malveillantes. Cela évite aussi d’exposer par accident des informations sensibles ou des fonctionnalités exploitables.

Ligne de commande

Pour activer la suppression du code mort en ligne de commande, utilisez l’option --deadcode lorsque vous exécutez Babel.


babel myapp.exe --deadcode

Tâche MSBuild Babel


<PropertyGroup>
  <DeadCodeElimination>true</DeadCodeElimination>
</PropertyGroup>
 
<Babel DeadCodeElimination="$(DeadCodeElimination)" />

Règles XML

Vous pouvez contrôler la suppression des symboles inutilisés à l’aide de règles XML qui visent la fonctionnalité « dead code ». L’exemple de règle XML suivant empêche la suppression de tous les symboles de l’espace de noms Utilities :


<Rule name="remove1" feature="dead code" exclude="true">
  <Pattern isRegEx="true">
    <![CDATA[
      (Utilities.*)
    ]]>
  </Pattern>
  <Description>Do not remove symbols in Utilities namespace</Description>
</Rule>

Dans l’ensemble, la suppression du code mort de Babel Obfuscator profite nettement à la base de code obfusquée : elle en réduit la taille, raccourcit le temps de chargement, améliore les performances à l’exécution et renforce la sécurité.

Points d’entrée supplémentaires

Babel Obfuscator effectue une analyse complète de la base de code à partir de l’interface publique et du point d’entrée de l’assembly. Cette analyse vise à déterminer toutes les portions de code atteignables à l’exécution. En examinant le point d’entrée et en parcourant l’interface publique, Babel établit le flux d’exécution et repère les méthodes non atteignables, c’est-à-dire celles qui ne sont ni appelées ni utilisées pendant l’exécution du programme. Ces méthodes sont considérées comme du « code mort », car elles ne contribuent pas au fonctionnement de l’application.

Outre l’analyse du code à partir de l’interface publique et du point d’entrée de l’assembly, Babel Obfuscator peut prendre en compte d’autres points d’entrée nécessaires à la bonne exécution du code. Ces points d’entrée supplémentaires comprennent les méthodes susceptibles d’être appelées par réflexion, ou en interne par d’autres composants au moyen de l’attribut InternalVisibleTo.

Vous indiquez ces points d’entrée supplémentaires sous forme d’expressions régulières transmises à l’option de suppression du code mort, comme le montre la section Indiquer les points d’entrée ci-dessous. Dans Babel Desktop, activez DeadCodeElimination dans le groupe Optimisation de l’assembly sélectionné et ajoutez les expressions de points d’entrée à sa liste.

Grâce à ces points d’entrée, Babel Obfuscator détermine avec exactitude le code atteignable et préserve pendant l’optimisation les méthodes nécessaires à la réflexion ou à un usage interne. L’analyse de la base de code est ainsi complète, et le code mort, inatteignable depuis les points d’entrée indiqués, est supprimé.

Indiquer les points d’entrée

Pour indiquer des points d’entrée supplémentaires à la suppression du code mort en ligne de commande, passez des expressions régulières en arguments de l’option --deadcode. Les expressions régulières offrent un moyen souple de définir des motifs correspondant à des noms de méthodes. Vous pouvez désigner des méthodes précises, viser des espaces de noms entiers, rechercher des motifs dans les noms de méthodes ou combiner plusieurs expressions pour inclure plusieurs points d’entrée.

Voici quelques exemples de points d’entrée indiqués par des expressions régulières en arguments de l’option --deadcode :

Pour désigner une méthode précise :


babel myapp.exe --deadcode MyNamespace.MyClass.MyMethod

Pour désigner toutes les méthodes d’un espace de noms :
```
babel myapp.exe --deadcode MyNamespace.*
```
Pour désigner toutes les méthodes d’une classe donnée :
```
babel myapp.exe --deadcode MyNamespace.MyClass.*
```
Pour désigner les méthodes qui correspondent à un motif donné à l’aide d’expressions régulières :
```
babel myapp.exe --deadcode MyNamespace.*[Gg]et.*
```
Pour indiquer plusieurs points d’entrée à l’aide de plusieurs expressions régulières :
```
babel myapp.exe --deadcode MyNamespace.* --deadcode AnotherNamespace.*
```

Pour indiquer des points d’entrée à la tâche Babel dans votre projet MSBuild à l’aide d’expressions régulières, utilisez la propriété <DeadCodeElimination>. Cette propriété accepte une liste d’expressions régulières, séparées par des points-virgules (;), qui correspondent aux méthodes servant de points d’entrée.

Voici un exemple de points d’entrée indiqués par des expressions régulières dans la tâche Babel :


<PropertyGroup>
  <DeadCodeElimination>MyNamespace.*;true</DeadCodeElimination>
</PropertyGroup>
 
<Babel DeadCodeElimination="$(DeadCodeElimination)" />

Ces exemples montrent comment définir, avec des expressions régulières, les points d’entrée de l’analyse de suppression du code mort de Babel. Avec des motifs précis ou des caractères génériques, vous visez exactement les méthodes ou les groupes de méthodes à prendre en compte pendant l’analyse.