Die Ganzzahl-Rechnungen verbergen, die Ihre Software steuern
Umbenennung verbirgt, wie ein Wert heißt; MBA verbirgt, was er berechnet. Dieser Deep Dive zeigt, wie Nebula a + b in äquivalente Gewirre aus Arithmetik und Bitoperationen umschreibt, die Konstantenfaltung und symbolische Ausführung aushebeln – mit echtem C#, repräsentativem IL, den Identitäten, der Konfiguration und den ehrlichen Kosten.
Umbenennung greift an, wie etwas heißt. String- und Konstantenverschlüsselung greift die Literale an, die es trägt. Doch das Wertvollste in weiten Teilen von .NET-Code ist nichts davon – es ist ein kleines Stück Arithmetik: der Ausdruck, der eine Stufe in ein Platzlimit verwandelt, einen Geräte-Fingerabdruck in eine Prüfziffer faltet oder entscheidet, ob Bit 0x40 eines Berechtigungs-Flags gesetzt ist. Diese Rechnungen überleben die Kompilierung nahezu perfekt, und ein Decompiler gibt sie als sauberes, lesbares C# zurück. Gemischte boolesche Arithmetik (MBA, nach dem englischen Akronym) ist der Durchgang, der sie verschwinden lässt.
Dies ist eine gründliche Erklärung: was MBA wirklich ist, die algebraischen Identitäten dahinter, wie das umgeschriebene IL aussieht, warum es gezielt die beiden Werkzeuge aushebelt, zu denen ein Angreifer greift – ein Konstantenfalter und eine symbolische Ausführungs-Engine – und was Sie dafür zahlen.
Das Problem: Arithmetik dokumentiert sich selbst
Hier ist eine Methode, die berechnet, wie viele Plätze eine Lizenz gewährt. Legitimes geistiges Eigentum: Es ist Ihre Preislogik, und Sie möchten lieber nicht, dass ein Wettbewerber sie aus einer Dekompilierung herausliest.
int SeatLimit(int tier, int flags)
{
int baseSeats = tier * 5 + 10;
if ((flags & 0x40) != 0) // the "enterprise" bit
baseSeats = baseSeats * 2;
return baseSeats;
}
Dekompilieren Sie den Release-Build, und Sie erhalten genau das zurück: das * 5, das + 10, das & 0x40, alles. Die Umbenennung macht aus SeatLimit ein a und aus tier ein b, aber der Ausdruck bleibt unangetastet, und der Ausdruck ist das Geheimnis. Ein Angreifer braucht die Namen nicht. Er braucht die Formel, und die Formel liegt offen zutage.
Die Idee: eine Operation durch eine gleichwertige, hässlichere ersetzen
MBA stützt sich auf eine Familie von Identitäten, die für jede Maschinen-Ganzzahl wahr sind und boolesche Operatoren (&, |, ^, ~) mit arithmetischen (+, -, *) mischen. Einige der Arbeitspferde:
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)
Jede gilt für alle int, einschließlich Überlauf mit Umbruch, denn ^ ist die Addition ohne Übertrag, und a & b nach links verschoben ist der Übertrag. Nebula wählt pro Operator-Stelle eine Identität und rekursiert dann: Das soeben eingeführte (a & b) kann selbst umgeschrieben werden, und die Konstanten können aufgeteilt werden – 0x40 wird zu 0x5A ^ 0x1A (deren XOR tatsächlich 0x40 ergibt), und 10 wird zu einer kleinen opaken Summe. Nach zwei oder drei Ebenen ist ein add aus einem einzigen Token ein verzweigter Baum aus ANDs, ORs, XORs und Additionen ohne jedes erkennbare Literal.
Nach Anwendung der ersten Identität kommt die Platzberechnung aus einem Decompiler so heraus:
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;
}
Jede Zeile berechnet weiterhin exakt den ursprünglichen Wert. Aber das * 5 ist weg (umgeschrieben als (tier << 2) + tier), das + 10 ist vergraben, das & 0x40 ist eine Subtraktion zweier OR/XOR-Terme über einer Konstante, die selbst ein XOR ist, und das * 2 ist eine MBA-Addition. Nichts hier liest sich mehr wie Preislogik.
Auf IL-Ebene
Der ganze Sinn ist, dass die Umschreibung im IL geschieht, sodass es keine Quellcode-Form zu schützen gibt und der JIT weiterhin korrekten Code erzeugt. Das ursprüngliche baseSeats = baseSeats * 2 ist eine einzige Multiplikation:
IL_0012: ldloc.0 // baseSeats
IL_0013: ldc.i4.2
IL_0014: mul
IL_0015: stloc.0
Nach der MBA-Additionsidentität a + a == (a | a) + (a & a) lautet dieselbe Speicherung:
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
Vier zusätzliche Instruktionen, ein nachweislich identisches Ergebnis und ein Baum ohne Multiplikation und ohne Literal 2, an dem sich ein Mustererkenner festmachen könnte. Der Test (flags & 0x40) wird genauso entfaltet, wobei 0x40 nur als XOR zweier anderer Konstanten eintrifft, sodass es weder in den Metadaten-Heaps #US/blob noch im IL-Strom ein 0x40 zu finden gibt.
Warum sowohl ein Konstantenfalter als auch eine symbolische Engine ins Stocken geraten
Zwei Werkzeuge erledigen die Schwerstarbeit in einem Deobfuskations-Workflow, und MBA ist gegen beide ausgelegt.
Ein Konstantenfalter hat nichts Konstantes zum Falten
Generische Deobfuskatoren stützen sich auf einen Konstantenpropagations-Durchgang: ein Literal finden, es durch die Arithmetik schieben, vereinfachen. MBA lässt kein Literal in der Operation übrig – 0x40 taucht nie auf, nur 0x5A ^ 0x1A, und selbst das kann zu einem berechneten Wert angehoben werden. Es gibt kein mul, keine 2, kein 0x40 im Strom, das die Faltung anstoßen könnte. Der Durchgang läuft und ändert nichts, weil seine Vorbedingung – ein bekannter Wert, der in eine Operation eingeht – nie erfüllt ist.
Eine symbolische Engine steht vor einer Äquivalenz, die sie beweisen, nicht sehen muss
Der stärkere Angriff ist symbolische Ausführung oder ein SMT-Solver: a und b als freie Variablen behandeln, den Ausdruck aufbauen und den Solver um Vereinfachung bitten. Genau hier beißt MBA zu. (a | b) + (a & b) == a + b ist ein Theorem über 32-Bit-Zweierkomplement-Arithmetik, und die Äquivalenz gemischter boolesch-arithmetischer Ausdrücke zu entscheiden ist ein bekannt schweres Problem: Solver werden drastisch langsamer, je mehr Sie Identitäten verschachteln und Arithmetik beimischen, weil die boolesche und die modulare Ganzzahl-Theorie schlecht zusammenwirken. Eine Ebene ist lästig. Drei verschachtelte Ebenen mit aufgeteilten Konstanten machen aus einer Millisekunden-Vereinfachung eine Abfrage, die der Angreifer sich drehen sieht – pro Ausdruck, über jede Stelle in der Assembly hinweg.
Keines der beiden Werkzeuge ist im absoluten Sinne besiegt – ein entschlossener Mensch mit Zeit kann jeden einzelnen Ausdruck von Hand normalisieren. Bei MBA geht es darum, die Kosten pro Stelle so weit zu erhöhen, bis aus „die Formel in der Dekompilierung ablesen“ ein „Hunderte von Hand verknotete Ausdrücke rückentwickeln, von denen jeder ein Köder sein könnte“ wird. Darum geht es im Kern.
Einschalten
MBA liegt unter dem Block arithmetic in nebula.config.json (vollständige Konfigurationsreferenz):
{
"renaming": { "mode": "dictionary" },
"encryptStrings": true,
"arithmetic": {
"enabled": true,
"rewriteOps": ["add", "sub", "and", "or", "xor", "mul"],
"constantSplitting": true,
"depth": 2
}
}
Schützen Sie dann Ihre kompilierte Assembly mit der CLI:
nebula --config nebula.config.json
depth ist der wichtigste Regler: 1 wendet eine Identität pro Stelle an, 3 rekursiert in die Terme, die jede Identität einführt. constantSplitting steuert, ob Literale wie 0x40 selbst zerlegt werden. Steuern Sie in der CI dieselbe Konfiguration über ein MSBuild-Target, damit Entwickler saubere lokale Builds behalten und nur das Release-Artefakt gehärtet wird:
<Target Name="NebulaProtect" AfterTargets="Publish" Condition="'$(Configuration)' == 'Release'">
<Exec Command="nebula --config nebula.config.json" WorkingDirectory="$(PublishDir)" />
</Target>
Grenzen Sie es ein. MBA rechtfertigt seine Kosten bei dem Dutzend Methoden, die Ihre Lizenzrechnungen, Ihren Prüfziffer-Algorithmus, Ihre Feature-Flag-Dekodierung kodieren – nicht bei Ihren JSON-DTOs. Nutzen Sie keepList-Einträge und namespaceweise Überschreibungen, um den Durchgang auf die verbergenswerte Arithmetik zu richten und heißen, langweiligen Code in Ruhe zu lassen.
Die Kosten, ehrlich
MBA ist der arithmetisch lastigste Durchgang, den Nebula mitbringt, und er ist nicht kostenlos.
- Geschwindigkeit. Jede umgeschriebene Operation wird zu mehreren. Bei kaltem, selten aufgerufenem Code – einer Lizenzprüfung, die einmal beim Start läuft – ist das unsichtbar. Innerhalb einer engen numerischen Schleife nicht: vier bis zehn zusätzliche Ganzzahl-Operationen pro Iteration, und eine über das Inlining-Budget des JIT hinaus aufgeblähte Methode wird nicht mehr inline eingebunden. Richten Sie MBA niemals auf einen heißen numerischen Kern. Schützen Sie die Methode, die etwas entscheidet, nicht die Schleife, die etwas verrechnet.
- Größe. Methodenkörper wachsen mit
depth. Beidepth: 2erwarten Sie, dass die gezielten Methoden ihr IL in etwa verdoppeln;depth: 3kann es verdreifachen. Da Sie MBA auf eine Handvoll Methoden eingrenzen, bleibt die Auswirkung auf die gesamte Assembly gering – das ist das Argument fürs Eingrenzen statt eines globalen Schalters. - Debugbarkeit. Ein umgeschriebener Ausdruck in einem Absturz-Dump ist auch für Sie unlesbar. Bewahren Sie die von Nebula ausgegebene Symbol-/Umbenennungs-Zuordnung auf und führen Sie Produktions-Traces mit
nebula deobfuscate --mapzurück, damit aus einem Support-Ticket kein archäologisches Projekt wird.
Wo es hingehört
MBA ist eine Schicht und fügt sich mit den anderen zusammen, statt sie zu ersetzen. Benennen Sie um, um die Namen zu beseitigen; verschlüsseln Sie Strings, um den Text zu beseitigen; setzen Sie opake Prädikate ein, um die Automatisierung der Werkzeuge zu beseitigen; und nutzen Sie MBA, um das Einzige zu beseitigen, das all das unangetastet lässt: die lesbare Arithmetik, die Ihr Algorithmus ist. Zusammen verwandeln sie einen Wert, den ein Angreifer auf einen Blick lesen könnte, in eine Äquivalenz, die er beweisen müsste.
Ausdrucks- und Arithmetik-Obfuskation ist eine Pro-Funktion, neben Code-Virtualisierung und Methodenverschlüsselung. Die schwerste Konfiguration – ein hohes depth mit korrelierten Konstantennetzen, die über viele Stellen hinweg eine zur Laufzeit abgeleitete Invariante teilen – reist mit der aggressiven Kontrollfluss-Stufe auf Enterprise, denn die Korrelation ist es, die MBA von „ein Solver findet sie langsam“ zu „ein Solver kann sie überhaupt nicht im Batch verarbeiten“ treibt. Beginnen Sie mit depth: 2 in Ihrem Lizenz-Namespace, messen Sie die Größe dieser Methoden und den Durchsatz Ihres heißesten Pfads, und bewegen Sie den Regler von dort aus.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.