Comment les prédicats opaques contrarient les désobfuscateurs automatiques
Pourquoi les prédicats toujours-vrais et les branches factices mettent en échec les outils de type de4dot — avec du C# réel, de l'IL représentatif, le compromis performance/taille et le niveau Nebula concerné.
Renommez tout, chiffrez chaque chaîne, et un décompilateur livre quand même à l’attaquant une chose intacte : la forme de votre logique. Les branches, les boucles et les clauses de garde survivent à la compilation presque parfaitement, et cette forme constitue l’essentiel de ce qui rend le code décompilé lisible. L’aplatissement du flux de contrôle attaque la forme directement. Les prédicats opaques et le flux de contrôle factice s’attaquent à quelque chose de plus subtil : les outils de l’attaquant. Ils implantent des branches qui semblent significatives, s’exécutent de façon prévisible et résistent aux passes automatiques par lesquelles un désobfuscateur fait le ménage.
Ceci est une explication approfondie : ce qu’est réellement un prédicat opaque au niveau de l’IL, pourquoi un désobfuscateur générique comme de4dot ne peut pas simplement le réduire, et ce que vous payez en taille et en vitesse pour l’utiliser.
Ce qu’un décompilateur fait gratuitement
Donnez ce méthode à un décompilateur et il vous rend quelque chose de presque identique à la source :
decimal ApplyDiscount(decimal price, int tier)
{
if (tier >= 3)
return price * 0.80m;
return price;
}
L’IL est une unique branche conditionnelle sur deux blocs de base. Un décompilateur parcourt le graphe de flux de contrôle, reconnaît le motif brtrue/blt comme un if et reconstruit la source. Rien n’est caché ici. Le graphe est la lisibilité — le travail consiste donc à placer dans ce graphe des arêtes auxquelles un outil ne peut pas se fier.
L’idée : une branche dont la réponse est déjà connue
Un prédicat opaque est une expression booléenne dont la valeur est fixée lorsque Nebula réécrit l’assembly, mais qu’un analyseur statique ne peut pas prouver à bon compte. La forme classique est une identité arithmétique vraie pour tout entier :
x * (x + 1)est toujours pair, donc(x * (x + 1)) % 2 == 0est toujours vrai, pour toutx.
Un humain le voit en une seconde. Un décompilateur voit une multiplication, une addition, un reste et une comparaison sur une valeur qu’il ne connaît pas, et n’a aucune constante à réduire. Il imprime donc la branche telle quelle, y compris le bras mort que Nebula a rempli d’un code factice d’apparence plausible.
Voici la méthode après qu’un prédicat opaque y a été tissé (décompilée vers du C# pour montrer l’effet) :
decimal ApplyDiscount(decimal price, int tier)
{
int x = tier;
if ((x * (x + 1)) % 2 == 0) // opaque-true: always taken
{
if (tier >= 3)
return price * 0.80m;
return price;
}
// bogus arm: never executes, but the tool cannot prove it
return price * (decimal)((x ^ 0x5F) + 1);
}
La logique réelle est désormais imbriquée dans une garde qui passe toujours, à côté d’un return factice que l’analyseur doit conserver parce qu’il ne peut pas l’écarter. Multipliez cela à l’échelle d’une méthode et le code reconstruit devient un fourré de conditions qui semblent toutes porteuses.
Au niveau de l’IL
Le prédicat est bon marché : une poignée d’opérations entières et une branche. IL représentatif de la garde insérée, avec le corps réel sous IL_0015 et le bloc factice sous IL_002a :
// int x = tier;
IL_0000: ldarg.1
IL_0001: stloc.0 // x
// (x * (x + 1)) % 2 == 0 -> always true
IL_0002: ldloc.0
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: mul // x * (x + 1) — provably even
IL_0007: ldc.i4.2
IL_0008: rem
IL_0009: brtrue IL_002a // if odd -> bogus; proven impossible at runtime
IL_0015: ldarg.1 // --- real body ---
IL_0016: ldc.i4.3
// ... if (tier >= 3) return price * 0.80m; else return price;
IL_002a: ldarg.0 // --- bogus block: dead, but opaque ---
// ... return price * ((x ^ 0x5F) + 1);
La ligne cruciale est IL_0009. À l’exécution, rem vaut toujours 0, donc brtrue ne saute jamais et le bloc factice est inatteignable. Mais l’inatteignabilité est ici un théorème, pas un fait syntaxique. Pour supprimer IL_002a, un outil devrait prouver que x * (x + 1) est pair pour tout int — y compris le débordement par enroulement — ce qu’aucune passe générique ne tente.
Pourquoi les outils de type de4dot ne peuvent pas simplement les retirer
Les désobfuscateurs génériques sont, au fond, des comparateurs de motifs dotés d’un réducteur de constantes. Ils fonctionnent de façon spectaculaire contre les obfuscateurs connus parce que ceux-ci émettent des prédicats sous une forme fixe et reconnaissable : réduire la constante, prouver la branche morte, la supprimer, recommencer. Cette stratégie échoue sur les prédicats opaques pour trois raisons.
1. Il n’y a aucune constante à réduire
(x * (x + 1)) % 2 == 0 ne contient aucun littéral qui se résolve en un booléen fixe. La vérité est une propriété de l’arithmétique entière, pas une valeur présente dans l’IL. Un réducteur de constantes n’a rien à saisir. Le prouver exigerait que l’outil embarque un petit démonstrateur de théorèmes et applique de l’arithmétique — bien au-delà de ce que fait une passe de nettoyage générique, et peu fiable à deviner.
2. Supprimer une branche que l’on ne peut prouver morte est dangereux
La directive première d’un désobfuscateur est ne pas changer le comportement. S’il supprime une branche qu’il soupçonne seulement morte et qu’il a tort, il corrompt le programme en silence. Donc quand un prédicat n’est pas prouvablement constant, le choix sûr — le seul sûr — est de le conserver. Les prédicats opaques transforment cette prudence en arme : chacun que vous ajoutez est une branche que l’outil doit préserver.
3. La diversité des motifs met en échec les signatures
Si chaque prédicat était x*(x+1)%2, l’auteur de l’outil coderait une règle en dur pour lui. Nebula puise dans une famille — identités de parité, le fait que 7y² − 1 n’est jamais un carré parfait, des propriétés de somme de carrés et des prédicats semés à partir de valeurs qui n’existent qu’à l’exécution — et les fait varier par site à l’aide de la graine stable du projet. Il n’y a aucune signature unique à faire correspondre, et un prédicat bâti sur une valeur d’exécution n’a aucune réponse statique.
Comment l’activer
Le flux de contrôle factice vit sous le bloc controlFlow de nebula.config.json :
{
"renaming": { "mode": "dictionary" },
"encryptStrings": true,
"controlFlow": {
"enabled": true,
"opaquePredicates": true,
"bogusBranchDensity": "medium",
"predicateFamilies": ["parity", "quadratic", "runtime-seeded"]
}
}
Exécutez ensuite l’obfuscateur sur votre assembly compilé :
nebula protect ./bin/Release/net8.0/Billing.dll \
--config nebula.config.json \
--out ./protected/
bogusBranchDensity est le cadran qui compte. low saupoudre des prédicats aux points d’entrée des méthodes ; high enveloppe les blocs internes et imbrique les régions factices. La densité s’échange directement contre la taille et la vitesse, alors réglez-la à la méthode, pas à tout l’assembly — c’est précisément à cela que servent les entrées keepList et les surcharges par espace de noms.
Le coût, honnêtement
Les prédicats opaques ne sont pas gratuits, et quiconque vous dit le contraire vous vend une surprise en production.
- Taille. Chaque prédicat ajoute quelques instructions IL plus un bloc factice qui doit paraître réel. À densité
medium, attendez-vous à voir les assemblies croître de l’ordre de quelques dizaines de pour cent ;highpeut plus que doubler les corps de méthodes dans les espaces de noms chauds. - Vitesse. Le prédicat lui-même est une poignée d’opérations entières — négligeable isolément. Le vrai coût est indirect : des méthodes plus grosses font exploser le budget d’inlining du JIT et polluent le cache d’instructions. Une méthode auparavant inlinée peut cesser de l’être après. Ne mettez jamais de flux factice à haute densité dans une boucle serrée ; protégez plutôt la méthode qui appelle la boucle.
- Débogabilité. Les traces de pile protégées et les vidages décompilés deviennent réellement plus difficiles à lire — pour vous autant que pour un attaquant. Conservez votre carte de renommage et vos artefacts de symboles afin de pouvoir re-tracer les traces de production.
Le modèle mental : les prédicats opaques ne rendent pas votre code impossible à comprendre. Ils rendent la compréhension automatique peu fiable, ce qui fait passer le coût de l’attaque de « lance de4dot, lis la sortie » à « analyse à la main chaque branche et décide lesquelles sont réelles ». Pour la plupart de la PI, cette différence fait toute la partie.
Quel niveau
L’obfuscation de base du flux de contrôle — prédicats opaques à densité faible à moyenne — est une fonction Pro, aux côtés de la virtualisation de code et du chiffrement de méthodes. Le niveau agressif du flux de contrôle, avec une haute densité de prédicats, des régions factices profondément imbriquées et des réseaux de prédicats corrélés où plusieurs conditions opaques référencent un invariant d’exécution partagé, relève de Enterprise. La corrélation est ce qui le fait passer de « survit à une passe générique » à « survit à un humain déterminé muni d’un désassembleur » — d’où son placement à un niveau supérieur.
Où cela s’inscrit
Les prédicats opaques sont une couche, pas une stratégie. Renommez pour tuer les noms, chiffrez chaînes et constantes pour tuer les littéraux, aplatissez le flux de contrôle pour tuer la forme — puis ajoutez du flux factice pour que les outils censés défaire tout ce qui précède ne puissent pas s’exécuter sans surveillance. Chaque couche relève le plancher ; ensemble, elles transforment une décompilation de cinq minutes en un projet dont l’attaquant doit décider s’il vaut sa semaine. Commencez à medium, mesurez les deux chiffres qui comptent — la taille de l’assembly et le débit de votre chemin le plus chaud — et bougez le cadran à partir de là.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.