Masquer le flux de contrôle .NET par les exceptions
Un décompilateur reconstruit vos if/else à partir des instructions de branchement qu'il trouve dans l'IL. Faire passer une décision par une sentinelle levée puis capturée déplace cette arête dans la table des clauses de gestion des exceptions, où la décompilation structurée s'effondre. Voici l'IL réel, pourquoi il déjoue une lecture statique et le coût à l'exécution qui impose de l'employer avec parcimonie.
En décompilant un assembly .NET renommé, ce qui reste lisible, c”est le flux de contrôle. Les identifiants deviennent a, b, M3 ; la forme de la logique survit. C”est que le décompilateur reconstruit du C# en lisant les instructions de branchement de l”IL — br, brtrue, bge — et en rapprochant leur motif de if, else, while. Le graphe de branchement est la lisibilité, et c”est pourquoi les obfuscateurs y consacrent tant d”efforts. L”aplatissement et les prédicats opaques attaquent tous deux directement le graphe de branchement.
Il existe un second endroit, plus discret, où une méthode .NET conserve son flux de contrôle : la table des clauses de gestion des exceptions. Y faire passer une décision attaque une partie du décompilateur que les transformations du graphe de branchement ne touchent jamais.
Le seul endroit où un branchement n”en est pas un
Chaque méthode porte une table de régions protégées : les clauses de gestion structurée des exceptions (SEH). Chaque ligne est un tuple : le décalage et la longueur d”une région try, le décalage et la longueur de son gestionnaire, et ce que ce gestionnaire capture. Le compilateur C# n”en émet que pour de vrais try/catch/finally, et il les émet bien imbriquées et proprement. Les décompilateurs s”appuient fortement sur cette hypothèse : ils lisent la table des clauses, supposent qu”elle est l”œuvre d”un compilateur et la replient en C# structuré.
Le vérificateur d”IL impose aussi une règle qui compte ici. On ne peut pas sortir d”une région protégée par br ni par ret. La seule façon légale de quitter un try ou un catch est l”instruction leave, qui transfère le contrôle vers un décalage hors de la région et, par effet de bord, vide la pile d”évaluation. Ce vidage de pile est le levier.
Faire passer une décision par un catch
Prenez une méthode dont tout le contenu est un seul branchement :
static int Classify(int n)
{
if (n < 0) return -1;
return 1;
}
Compilé normalement, c”est un bge (brancher si supérieur ou égal) et deux blocs de retour : une forme que tout décompilateur réimprime telle quelle. La transformation en arête d”exception conserve le comportement mais rend le chemin n >= 0 atteignable uniquement en levant un type sentinelle qu”un gestionnaire capture :
.method private hidebysig static int32 Classify(int32 n) cil managed
{
.locals init (int32 result)
.try
{
ldarg.0
ldc.i4.0
bge.s RAISE // n >= 0 -> take the exception edge
ldc.i4.m1
stloc.0 // result = -1
leave.s DONE
RAISE:
newobj instance void ControlFlow::.ctor()
throw // the only edge into the catch
}
catch ControlFlow
{
pop // discard the sentinel
ldc.i4.1
stloc.0 // result = 1
leave.s DONE
}
DONE:
ldloc.0
ret
}
La logique est inchangée : n < 0 produit toujours -1, tout le reste produit 1. Mais la branche « else » n”est plus un branchement. C”est une levée de ControlFlow, et le code qui s”exécute pour elle vit dans un gestionnaire catch. La table des clauses possède désormais une ligne qui dit « si une exception s”échappe des décalages X–Y, exécute le gestionnaire en Z » — et c”est le chemin normal du programme lui-même qui lève cette exception.
Pourquoi une lecture statique s”effondre
Un décompilateur correct n”a d”autre choix que d”être fidèle à cela. L”IL lève réellement et capture réellement, donc la reconstruction qu”il imprime est :
static int Classify(int n)
{
int result;
try
{
if (n >= 0) throw new ControlFlow();
result = -1;
}
catch (ControlFlow)
{
result = 1;
}
return result;
}
C”est identiquement équivalent en comportement à l”original, et bien plus difficile à lire. Le lecteur doit remarquer que le throw est inconditionnel sur le chemin pris, que le catch est le vrai « else », et que ControlFlow est un dispositif de flux de contrôle et non une erreur. Trois choses aggravent la peine :
- La table des clauses résiste à la structuration. Superposez ou imbriquez quelques-unes de ces régions et le décompilateur devra représenter les transferts par des gotos et des locales déversées, car il ne peut plus faire correspondre les régions à des blocs
tryproprement imbriqués. Certains décompilateurs renoncent et émettent une sortie non structurée pour la méthode. leaveefface l”état de la pile. Comme quitter une région vide la pile d”évaluation, chaque valeur qui doit franchir la frontière est d”abord déversée dans une locale. Les décompilateurs orientés expression qui reconstruisenta + b * cà partir des push de pile perdent cette continuité et retombent dans un code verbeux, affectation par affectation.- Les prédicats opaques masquent l”élagage. Le
bgegardien peut être un prédicat opaque — une expression prouvablement constante à l”exécution mais coûteuse à évaluer statiquement — de sorte qu”un outil ne peut décider que l”arête d”exception est « jamais/toujours prise » et la supprimer.
Comment Nebula.NET l”applique
Les arêtes d”exception sont une option de la passe de flux de contrôle de Nebula.NET, superposée à l”aplatissement et aux prédicats opaques plutôt que de les remplacer. Vous la cadrez de la même manière :
{
"controlFlowObfuscation": "aggressive",
"controlFlowExceptionEdges": true,
"controlFlowInclude": [
"MyApp.Licensing.*",
"MyApp.Activation.LicenseGate.Validate"
]
}
Le type sentinelle que Nebula injecte est lui-même anonyme et obfusqué, et le moteur ne réécrit que les arêtes dont il peut prouver que la transformation est saine : il ne convertira pas un branchement qui franchit une frontière de pile non vide d”une manière qui ne peut être déversée légalement. Comme pour toute transformation, la correction n”est jamais sacrifiée à la densité : une arête qui ne peut être déplacée sûrement est laissée comme branchement et durcie autrement.
Le coût qui gouverne tout
Lever une exception coûte cher — des ordres de grandeur de plus qu”un branchement — car le runtime parcourt la pile pour trouver un gestionnaire. C”est le seul fait qui décide de la façon d”employer la transformation. On ne met pas une arête d”exception sur un chemin chaud ; faire passer une décision par itération à travers un throw apparaîtra immédiatement dans un profileur.
La bonne cible est une décision qui s”exécute rarement et qui compte beaucoup : le branchement au sein d”un contrôle de licence, d”une porte d”activation, d”un verdict d”intégrité. Une exception une fois par démarrage ne coûte rien qu”un utilisateur perçoive, et en échange le branchement le plus intéressant de votre assembly cesse de ressembler à un branchement. C”est le compromis à peser : un coût réel à l”exécution sur un chemin froid, racheté en décompilation cassée précisément sur le code que vous voulez le plus protéger.
Et le plafond honnête : cela élève le coût de lire le flux de contrôle, cela n”empêche pas un attaquant d”exécuter le code et d”observer quel chemin s”exécute. Un débogueur posé sur la méthode voit toujours n >= 0 décider du résultat. Les arêtes d”exception sont une couche : avec des prédicats opaques sur le gardien, le chiffrement des chaînes sur les littéraux que ces chemins consomment et l”anti-débogage qui renchérit l”analyse dynamique, elles suppriment le raccourci statique et imposent la voie lente et manuelle que l”obfuscation existe pour imposer.
Essayez-le sur une décision : installez la CLI avec dotnet tool install --global Delta1Labs.Nebula.Tool, ajoutez une méthode sensible à votre liste d”inclusion de flux de contrôle avec controlFlowExceptionEdges activé, et décompilez l”avant et l”après. Consultez la documentation Nebula.NET pour démarrer, et l”obfuscation de références pour masquer le graphe d”appels que ces méthodes atteignent.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.