Skip to content
← Tous les articles
· Delta1 Labs ObfuscationNebula

SuppressIldasmAttribute n'est pas une protection : ce que l'anti-ILDASM apporte vraiment

Pourquoi l'attribut [SuppressIldasm] n'arrête qu'un seul outil — et est purement ignoré sur le .NET moderne — plus ce que fait le vrai durcissement des métadonnées et des chaînes, avec C#, IL et configuration Nebula.

Cherchez « protéger un assembly .NET » et quelqu’un vous dira d’ajouter une ligne :

[assembly: System.Runtime.CompilerServices.SuppressIldasm]

La promesse, c’est que votre DLL ne peut plus être désassemblée. La réalité est bien plus étroite que ne le croit presque quiconque colle cette ligne, et sur le .NET moderne elle ne fait absolument rien. Voici une explication en profondeur de ce que SuppressIldasmAttribute fait réellement, pourquoi il n’arrête qu’un seul programme, et ce qu’il faut pour qu’un assembly soit véritablement coûteux à lire.

Ce qu’est réellement l’attribut

SuppressIldasmAttribute n’est ni un chiffrement, ni une permission, ni un verrou. C’est un marqueur : un attribut personnalisé sans champ que le compilateur écrit dans les métadonnées de votre assembly. Au niveau de l’IL, ce n’est qu’une entrée .custom de plus dans la table CustomAttribute :

.custom instance void [System.Runtime]
    System.Runtime.CompilerServices.SuppressIldasmAttribute::.ctor() = ( 01 00 00 00 )

Ce ( 01 00 00 00 ) est le blob de l’attribut : un prologue de deux octets et un compteur de deux octets, sans arguments. Rien de votre code ne change. Chaque type, chaque corps de méthode, chaque chaîne littérale est écrit dans le fichier exactement comme avant. La seule nouveauté dans l’assembly est un indicateur qui dit, en substance, « merci de ne pas me désassembler ».

Que quelqu’un respecte cette demande dépend entièrement de l’outil qui lit le fichier.

Un seul outil a écouté — et il a cessé

Historiquement, l’ildasm.exe de Microsoft — le désassembleur IL livré avec le SDK du .NET Framework — vérifiait cet attribut. S’il le trouvait, il affichait // This assembly is protected... et refusait de vider l’IL. C’est tout le mécanisme. C’était un accord de gentlemen entre l’outil d’édition de Microsoft et l’outil de désassemblage de Microsoft.

Deux faits font s’effondrer la protection :

  1. Aucun autre lecteur ne l’a jamais vérifié. ILSpy, dnSpy, dotPeek, JustDecompile, l’utilitaire monodis de Mono et les décompilateurs modernes, dont Glass.NET, lisent directement les tables de métadonnées. Aucun d’eux ne consulte l’indicateur SuppressIldasm, car rien dans le format ECMA-335 ne les y oblige. Ils ouvrent le fichier, parcourent les tables TypeDef et MethodDef, résolvent l’IL de chaque méthode à partir de son RVA et reconstruisent le C#. L’attribut leur est invisible.

  2. Sur .NET 6 et au-delà, même ildasm l’ignore. Ce respect a été supprimé. L’attribut compile toujours — il est marqué obsolète — mais le désassembleur moderne vide l’assembly quand même. Donc sur toute cible .NET actuelle, [assembly: SuppressIldasm] est littéralement une opération sans effet : il change quatre octets de métadonnées et ne protège rien, pas même face au seul outil pour lequel il a été écrit.

L’effet net, aujourd’hui : vous avez ajouté un attribut qui ne fait rien et, peut-être, vous êtes convaincu d’être protégé alors que vous ne l’êtes pas. Cette seconde partie est le véritable danger.

Pourquoi il a toujours été faible : le fichier reste lisible

Prenez du recul par rapport à l’attribut et regardez ce qu’un assembly .NET expose réellement. Les métadonnées managées ne sont pas un blob opaque : ce sont un ensemble de streams bien définis à l’intérieur du fichier PE, et les décompilateurs s’en nourrissent directement.

What a decompiler reads from the metadata streams — the SuppressIldasm flag guards none of it Assembly metadata a decompiler walks directly #~ (tables) TypeDef, MethodDef, Field, Param rows #Strings every type, method and field name #US every string literal in your code method bodies (IL) resolved from each RVA #Blob signatures, constants SuppressIldasm flag — one row in CustomAttribute The flag sits beside the data; it does not encrypt, remove or guard any of it. A reader that skips the flag still reads every box above.

Le heap #Strings contient le nom en clair de chaque type, méthode, champ et paramètre. Le heap #US (chaînes utilisateur) contient chaque chaîne littérale de votre code. Le stream #~ contient les tables qui les relient, et l’IL de chaque méthode est résolu à partir de son adresse virtuelle relative. Un décompilateur ouvre le fichier et lit ces structures. C’est tout le travail.

L’indicateur SuppressIldasm se place à côté de tout cela, dans une ligne de la table CustomAttribute. Il ne retire pas un seul nom, ne chiffre pas un seul littéral, n’obscurcit pas un seul opcode. Il demande à un lecteur de détourner le regard — et les données dont il détournerait le regard sont toujours là, intégralement, pour tous les autres. Voilà pourquoi la protection n’a jamais été significative, indépendamment du changement de .NET 6 : ce qui méritait d’être protégé n’a jamais été touché.

Ce qui fait réellement monter le coût

La vraie protection ne demande pas à un lecteur d’être poli. Elle retire ou brouille l’information dont le lecteur dépend, de sorte qu’un décompilateur qui ignore tous les indicateurs ne livre malgré tout que très peu à son opérateur.

Renommez les métadonnées. Le heap #Strings est là où le sens fuit. CalculateMonthlyAccrual et _remainingTrialDays indiquent à un attaquant exactement où regarder. Renommez-les en identifiants non imprimables ou en collision et la sortie décompilée devient un labyrinthe de a.b(c) sans ancrage sémantique : les noms ont tout simplement disparu du heap.

Chiffrez les littéraux. Le heap #US est l’autre délateur : la forme des chaînes de connexion, les routes d’API, les messages d’erreur et le texte de vérification de licence se lisent en clair. Remplacez chaque littéral par un blob chiffré et un déchiffreur paresseux, et le heap portera du texte chiffré au lieu de votre logique métier en prose.

Remodelez le flux. L’aplatissement du flux de contrôle et les prédicats opaques attaquent la forme de la logique qui survit dans les corps de méthodes, de sorte que même le code reconstruit résiste à la lecture.

Dans Nebula, ce sont des réglages de configuration, pas des attributs. Un nebula.config.json minimal qui fait le travail que SuppressIldasm ne fait que prétendre faire :

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "controlFlow": { "enabled": true, "opaquePredicates": true },
  "antiIldasm": true
}

Puis protégez l’assembly compilé :

nebula protect ./bin/Release/net8.0/Billing.dll \
  --config nebula.config.json \
  --out ./protected/

Remarquez que antiIldasm figure dans cette liste : Nebula émettra l’indicateur si vous le demandez, car cela ne coûte rien et ferme une porte triviale sur les frameworks où il a encore un effet. Mais c’est la dernière et la moindre ligne du fichier, délibérément. Les trois lignes au-dessus sont celles qui changent le résultat. N’activer que antiIldasm et livrer, c’est l’erreur que cet article entier existe pour éviter.

Prouvez-le vous-même

Vous n’avez pas à le croire sur parole. Compilez un assembly avec rien d’autre que l’attribut, puis ouvrez-le dans n’importe quel décompilateur moderne, y compris un outil gratuit comme Glass.NET :

# Build with only [assembly: SuppressIldasm] — no other protection
dotnet build -c Release

# Open the output and read the source straight back
glass decompile ./bin/Release/net8.0/Billing.dll --out ./recovered/

Chaque nom de méthode, chaque chaîne, chaque ligne de logique revient. Passez maintenant le même assembly par nebula protect avec la configuration ci-dessus et décompilez cela. Les noms ont disparu, les chaînes sont chiffrées et le flux de contrôle vous résiste. Ce contraste est tout l’argument : une approche demande à un outil de ne pas regarder ; l’autre retire ce que l’outil cherchait.

À retenir

SuppressIldasmAttribute est une courtoisie historique entre deux outils de Microsoft, et cette courtoisie a pris fin avec .NET 6. Il n’a jamais protégé votre code : il demandait à un seul désassembleur hérité de renoncer à le montrer, tout en laissant intacts, pour tout autre lecteur, chaque nom, littéral et opcode. Livrez-le si vous voulez ; c’est gratuit et inoffensif. Mais ne le confondez jamais avec une défense. L’assembly est protégé lorsque l’information dont un attaquant a besoin n’est pas dans le fichier à lire — et c’est un problème de renommage, de chiffrement des chaînes et de flux de contrôle, pas un attribut d’une seule ligne.

Le renommage et le chiffrement des chaînes sont des fonctionnalités Pro dans Nebula ; la protection agressive du flux de contrôle est Enterprise. L’attribut est présent dans tous les niveaux, car une case à cocher qui ne coûte rien vaut exactement ce qu’elle coûte.

Essayez Nebula.NET

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