Masquer les calculs entiers qui verrouillent votre logiciel
Le renommage masque le nom d'une valeur ; la MBA masque ce qu'elle calcule. Ce guide approfondi montre comment Nebula réécrit a + b en enchevêtrements équivalents d'arithmétique et d'opérations binaires qui déjouent le repliement de constantes et l'exécution symbolique, avec du C# réel, de l'IL représentatif, les identités, la configuration et le coût honnête.
Le renommage s’attaque au nom d’une chose. Le chiffrement des chaînes et des constantes s’attaque aux littéraux qu’elle transporte. Mais ce qu’il y a de plus précieux dans une grande partie du code .NET n’est aucun de ces éléments : c’est un petit morceau d’arithmétique, l’expression qui transforme un niveau en limite de postes, qui replie l’empreinte d’un appareil en un chiffre de contrôle, ou qui décide si le bit 0x40 d’un indicateur de droits est activé. Ces calculs survivent à la compilation presque parfaitement, et un décompilateur les restitue sous forme de C# propre et lisible. L’arithmétique booléenne mixte (MBA, selon l’acronyme anglais) est la passe qui les fait disparaître.
Ceci est une explication approfondie : ce qu’est réellement la MBA, les identités algébriques qui la sous-tendent, à quoi ressemble l’IL réécrit, pourquoi elle déjoue spécifiquement les deux outils vers lesquels se tourne un attaquant — un replieur de constantes et un moteur d’exécution symbolique — et ce que vous payez pour cela.
Le problème : l’arithmétique se documente elle-même
Voici une méthode qui calcule combien de postes accorde une licence. Propriété intellectuelle légitime : c’est votre logique tarifaire, et vous préféreriez qu’un concurrent ne la lise pas dans une décompilation.
int SeatLimit(int tier, int flags)
{
int baseSeats = tier * 5 + 10;
if ((flags & 0x40) != 0) // the "enterprise" bit
baseSeats = baseSeats * 2;
return baseSeats;
}
Décompilez la version Release et vous obtenez cela tel quel : le * 5, le + 10, le & 0x40, tout. Le renommage transforme SeatLimit en a et tier en b, mais l’expression reste intacte, et l’expression est le secret. Un attaquant n’a pas besoin des noms. Il a besoin de la formule, et la formule est sous ses yeux.
L’idée : remplacer une opération par une autre égale, mais plus laide
La MBA repose sur une famille d’identités qui sont vraies pour tout entier machine, mêlant opérateurs booléens (&, |, ^, ~) et opérateurs arithmétiques (+, -, *). Quelques-unes des plus courantes :
a + b == (a | b) + (a & b)a + b == (a ^ b) + 2 * (a & b)a ^ b == (a | b) - (a & b)a & b == (a | b) - (a ^ b)
Chacune est valable pour tout int, y compris en cas de débordement avec bouclage, car ^ est l’addition sans retenue et a & b décalé à gauche est la retenue. Nebula choisit une identité par site d’opérateur, puis récurse : le (a & b) qu’il vient d’introduire peut lui-même être réécrit, et les constantes peuvent être scindées : 0x40 devient 0x5A ^ 0x1A (dont le XOR donne réellement 0x40), et 10 devient une petite somme opaque. Après deux ou trois niveaux, un add d’un seul jeton est un arbre touffu de AND, OR, XOR et additions sans aucun littéral à reconnaître.
Une fois la première identité appliquée, le calcul des postes ressort d’un décompilateur avec cette allure :
int SeatLimit(int tier, int flags)
{
int baseSeats = ((tier << 2) | tier) + ((tier << 2) & tier) + ((0x5A ^ 0x1A) - (10 & (0x5A ^ 0x1A)));
if (((flags | (0x5A ^ 0x1A)) - (flags ^ (0x5A ^ 0x1A))) != 0)
baseSeats = (baseSeats | baseSeats) + (baseSeats & baseSeats);
return baseSeats;
}
Chaque ligne calcule toujours exactement la valeur d’origine. Mais le * 5 a disparu (réécrit en (tier << 2) + tier), le + 10 est enfoui, le & 0x40 est une soustraction de deux termes OR/XOR portant sur une constante qui est elle-même un XOR, et le * 2 est une addition MBA. Plus rien ici ne se lit comme une logique tarifaire.
Au niveau de l’IL
Tout l’intérêt est que la réécriture se produit en IL : il n’y a donc aucune forme de code source à protéger et le JIT produit toujours du code correct. L’original baseSeats = baseSeats * 2 est une seule multiplication :
IL_0012: ldloc.0 // baseSeats
IL_0013: ldc.i4.2
IL_0014: mul
IL_0015: stloc.0
Après l’identité d’addition MBA a + a == (a | a) + (a & a), le même stockage devient :
IL_0012: ldloc.0 // baseSeats
IL_0013: ldloc.0
IL_0014: or // (a | a)
IL_0015: ldloc.0
IL_0016: ldloc.0
IL_0017: and // (a & a)
IL_0018: add // (a|a) + (a&a) == 2*a
IL_0019: stloc.0
Quatre instructions de plus, un résultat identique de façon démontrable, et un arbre sans multiplication ni littéral 2 sur lequel un détecteur de motifs pourrait s’accrocher. Le test (flags & 0x40) se développe de la même manière, 0x40 n’arrivant que sous la forme du XOR de deux autres constantes, de sorte qu’il n’y a aucun 0x40 dans les heaps #US/blob de métadonnées ni dans le flux d’IL à rechercher.
Pourquoi un replieur de constantes et un moteur symbolique calent tous les deux
Deux outils font le gros du travail dans un flux de désobfuscation, et la MBA est conçue contre les deux.
Un replieur de constantes n’a aucune constante à replier
Les désobfuscateurs génériques s’appuient sur une passe de propagation de constantes : trouver un littéral, le propager dans l’arithmétique, simplifier. La MBA ne laisse aucun littéral dans l’opération : 0x40 n’apparaît jamais, seulement 0x5A ^ 0x1A, et même cela peut être élevé en une valeur calculée. Il n’y a ni mul, ni 2, ni 0x40 dans le flux pour amorcer le repliement. La passe s’exécute et ne change rien, car sa précondition — une valeur connue entrant dans une opération — n’est jamais remplie.
Un moteur symbolique affronte une équivalence qu’il doit prouver, pas voir
L’attaque la plus forte est l’exécution symbolique ou un solveur SMT : traiter a et b comme des variables libres, construire l’expression et demander au solveur de simplifier. C’est exactement là que la MBA mord. (a | b) + (a & b) == a + b est un théorème sur l’arithmétique 32 bits en complément à deux, et décider de l’équivalence d’expressions d’arithmétique booléenne mixte est un problème réputé difficile : les solveurs ralentissent fortement à mesure que vous imbriquez des identités et mêlez de l’arithmétique, car les théories booléenne et des entiers modulaires interagissent mal. Un niveau est agaçant. Trois niveaux imbriqués avec des constantes scindées transforment une simplification d’une milliseconde en une requête que l’attaquant regarde tourner, pour chaque expression, sur tous les sites de l’assembly.
Aucun des deux outils n’est vaincu au sens absolu : un humain déterminé et disposant de temps peut normaliser à la main n’importe quelle expression. La MBA consiste à relever le coût par site jusqu’à ce que « lire la formule dans la décompilation » devienne « inverser des centaines d’expressions emmêlées à la main, dont chacune pourrait être un leurre ». C’est là tout l’enjeu.
Comment l’activer
La MBA se trouve sous le bloc arithmetic dans nebula.config.json (référence complète de configuration) :
{
"renaming": { "mode": "dictionary" },
"encryptStrings": true,
"arithmetic": {
"enabled": true,
"rewriteOps": ["add", "sub", "and", "or", "xor", "mul"],
"constantSplitting": true,
"depth": 2
}
}
Protégez ensuite votre assembly compilé avec la CLI :
nebula --config nebula.config.json
depth est le réglage qui compte le plus : 1 applique une identité par site, 3 récurse dans les termes que chaque identité introduit. constantSplitting détermine si les littéraux comme 0x40 sont eux-mêmes décomposés. En CI, pilotez la même configuration depuis une cible MSBuild afin que les développeurs conservent des builds locaux propres et que seul l’artefact de version soit durci :
<Target Name="NebulaProtect" AfterTargets="Publish" Condition="'$(Configuration)' == 'Release'">
<Exec Command="nebula --config nebula.config.json" WorkingDirectory="$(PublishDir)" />
</Target>
Ciblez-la. La MBA justifie son coût sur la douzaine de méthodes qui encodent vos calculs de licence, votre algorithme de chiffre de contrôle, votre décodage d’indicateurs de fonctionnalités — pas sur vos DTO JSON. Utilisez des entrées keepList et des surcharges par espace de noms pour diriger la passe vers l’arithmétique qui mérite d’être masquée et laisser tranquille le code actif et banal.
Le coût, en toute honnêteté
La MBA est la passe la plus chargée en arithmétique que fournit Nebula, et elle n’est pas gratuite.
- Vitesse. Chaque opération réécrite en devient plusieurs. Sur du code froid et peu appelé — une vérification de licence qui s’exécute une fois au démarrage — c’est invisible. À l’intérieur d’une boucle numérique serrée, non : de quatre à dix opérations entières supplémentaires par itération, et une méthode gonflée au-delà du budget d’inlining du JIT cesse d’être inlinée. Ne dirigez jamais la MBA vers un noyau numérique actif. Protégez la méthode qui décide de quelque chose, pas la boucle qui calcule quelque chose.
- Taille. Les corps de méthodes grossissent avec
depth. Àdepth: 2, attendez-vous à ce que les méthodes ciblées doublent à peu près leur IL ;depth: 3peut le tripler. Comme vous ciblez la MBA sur une poignée de méthodes, l’impact sur l’ensemble de l’assembly reste faible — c’est l’argument en faveur du ciblage plutôt que d’un interrupteur global. - Débogabilité. Une expression réécrite dans un vidage sur incident est illisible pour vous aussi. Conservez la carte de symboles/renommage que Nebula émet et retracez les traces de production avec
nebula deobfuscate --mappour qu’un ticket de support ne devienne pas un projet d’archéologie.
Où elle s’insère
La MBA est une couche, et elle se compose avec les autres plutôt que de les remplacer. Renommez pour supprimer les noms ; chiffrez les chaînes pour supprimer le texte ; utilisez des prédicats opaques pour supprimer l’automatisation des outils ; et utilisez la MBA pour supprimer la seule chose que tout cela laisse intacte : l’arithmétique lisible qui est votre algorithme. Ensemble, elles transforment une valeur qu’un attaquant pourrait lire d’un coup d’œil en une équivalence qu’il devrait prouver.
L’obfuscation des expressions et de l’arithmétique est une fonctionnalité Pro, aux côtés de la virtualisation du code et du chiffrement des méthodes. La configuration la plus lourde — un depth élevé avec des réseaux de constantes corrélées qui partagent un invariant dérivé à l’exécution sur de nombreux sites — voyage avec le niveau agressif de flux de contrôle en Enterprise, car la corrélation est ce qui fait passer la MBA de « un solveur la trouve lente » à « un solveur ne peut pas la traiter par lots du tout ». Commencez à depth: 2 sur votre espace de noms de licences, mesurez la taille de ces méthodes et le débit de votre chemin le plus actif, puis ajustez le réglage à partir de là.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.