Wie opake Prädikate automatische Deobfuscatoren ausbremsen
Warum stets-wahre Prädikate und Müllverzweigungen Tools vom Typ de4dot scheitern lassen — mit echtem C#, repräsentativem IL, dem Kompromiss Performance/Größe und der zuständigen Nebula-Stufe.
Benennen Sie alles um, verschlüsseln Sie jede Zeichenfolge — ein Decompiler übergibt dem Angreifer trotzdem eines unversehrt: die Form Ihrer Logik. Verzweigungen, Schleifen und Guard-Klauseln überstehen die Kompilierung nahezu perfekt, und diese Form macht den Großteil dessen aus, was decompilierten Code lesbar macht. Das Abflachen des Kontrollflusses greift die Form direkt an. Opake Prädikate und unechter Kontrollfluss greifen etwas Subtileres an: die Werkzeuge des Angreifers. Sie pflanzen Verzweigungen ein, die bedeutsam aussehen, vorhersehbar ablaufen und den automatischen Durchläufen widerstehen, mit denen ein Deobfuscator aufräumt.
Dies ist eine ausführliche Erklärung: was ein opakes Prädikat auf IL-Ebene tatsächlich ist, warum ein generischer Deobfuscator wie de4dot es nicht einfach wegfalten kann und was Sie an Größe und Geschwindigkeit dafür bezahlen.
Was ein Decompiler gratis erledigt
Geben Sie einem Decompiler diese Methode, und er liefert etwas nahezu Identisches zum Quelltext zurück:
decimal ApplyDiscount(decimal price, int tier)
{
if (tier >= 3)
return price * 0.80m;
return price;
}
Das IL ist eine einzige bedingte Verzweigung über zwei Basisblöcke. Ein Decompiler durchläuft den Kontrollflussgraphen, erkennt das Muster brtrue/blt als ein if und rekonstruiert den Quelltext. Hier wird nichts verborgen. Der Graph ist die Lesbarkeit — die Aufgabe besteht also darin, Kanten in diesen Graphen zu legen, denen ein Tool nicht trauen kann.
Die Idee: eine Verzweigung, deren Antwort bereits bekannt ist
Ein opakes Prädikat ist ein boolescher Ausdruck, dessen Wert feststeht, wenn Nebula das Assembly umschreibt, den ein statischer Analysator aber nicht günstig beweisen kann. Die klassische Form ist eine zahlentheoretische Identität, die für jede ganze Zahl wahr ist:
x * (x + 1)ist immer gerade — also ist(x * (x + 1)) % 2 == 0immer wahr, für jedesx.
Ein Mensch sieht das in einer Sekunde. Ein Decompiler sieht eine Multiplikation, eine Addition, einen Rest und einen Vergleich über einem Wert, den er nicht kennt, und hat keine Konstante zum Falten. Also druckt er die Verzweigung wörtlich, einschließlich des toten Arms, den Nebula mit plausibel wirkendem Müll gefüllt hat.
Hier ist die Methode, nachdem ein opakes Prädikat eingewoben wurde (zur Veranschaulichung nach C# zurückdecompiliert):
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);
}
Die echte Logik steckt nun verschachtelt in einer Guard, die immer passiert, neben einem unechten return, das der Analysator behalten muss, weil er es nicht ausschließen kann. Vervielfachen Sie das über eine Methode, und der rekonstruierte Code wird zu einem Dickicht aus Bedingungen, die alle tragend wirken.
Auf IL-Ebene
Das Prädikat ist billig — eine Handvoll Ganzzahl-Operationen und eine Verzweigung. Repräsentatives IL für die eingefügte Guard, mit dem echten Rumpf unter IL_0015 und dem unechten Block unter 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);
Die entscheidende Zeile ist IL_0009. Zur Laufzeit ist rem immer 0, also springt brtrue nie und der unechte Block ist unerreichbar. Doch die Unerreichbarkeit ist hier ein Theorem, keine syntaktische Tatsache. Um IL_002a zu löschen, müsste ein Tool beweisen, dass x * (x + 1) für jedes int gerade ist — einschließlich Überlauf mit Umbruch — was kein generischer Durchlauf versucht.
Warum Tools vom Typ de4dot sie nicht einfach entfernen können
Generische Deobfuscatoren sind im Kern Mustervergleicher mit einem Konstantenfalter. Gegen bekannte Obfuscatoren funktionieren sie spektakulär, weil diese Prädikate in einer festen, erkennbaren Form ausgeben: Konstante falten, Zweig als tot beweisen, löschen, wiederholen. Diese Strategie scheitert an opaken Prädikaten aus drei Gründen.
1. Es gibt keine Konstante zum Falten
(x * (x + 1)) % 2 == 0 enthält kein Literal, das sich zu einem festen booleschen Wert auflöst. Die Wahrheit ist eine Eigenschaft der Ganzzahlarithmetik, kein Wert, der im IL steht. Ein Konstantenfalter hat nichts zum Zupacken. Es zu beweisen würde erfordern, dass das Tool einen kleinen Theorembeweiser mitführt und Zahlentheorie anwendet — weit jenseits dessen, was ein universeller Bereinigungsdurchlauf tut, und unsicher, wenn man es rät.
2. Einen Zweig zu entfernen, den man nicht als tot beweisen kann, ist gefährlich
Die oberste Direktive eines Deobfuscators lautet das Verhalten nicht ändern. Löscht er einen Zweig, den er bloß als tot vermutet, und liegt er falsch, beschädigt er das Programm stillschweigend. Wenn ein Prädikat also nicht beweisbar konstant ist, ist der sichere Zug — der einzig sichere — es zu behalten. Opake Prädikate machen aus dieser Vorsicht eine Waffe: Jedes, das Sie hinzufügen, ist ein Zweig, den das Tool bewahren muss.
3. Mustervielfalt besiegt Signaturen
Wäre jedes Prädikat x*(x+1)%2, würde der Tool-Autor eine feste Regel dafür einprogrammieren. Nebula schöpft aus einer Familie — Paritätsidentitäten, die Tatsache, dass 7y² − 1 nie eine perfekte Quadratzahl ist, Summe-von-Quadraten-Fakten und Prädikate, die aus Werten gesät werden, die nur zur Laufzeit existieren — und variiert sie pro Stelle anhand des stabilen Projekt-Seeds. Es gibt keine einzelne Signatur zum Abgleichen, und ein auf einem Laufzeitwert aufgebautes Prädikat hat überhaupt keine statische Antwort.
So aktivieren Sie es
Der unechte Kontrollfluss wohnt im Block controlFlow von nebula.config.json:
{
"renaming": { "mode": "dictionary" },
"encryptStrings": true,
"controlFlow": {
"enabled": true,
"opaquePredicates": true,
"bogusBranchDensity": "medium",
"predicateFamilies": ["parity", "quadratic", "runtime-seeded"]
}
}
Führen Sie dann den Obfuscator über Ihr gebautes Assembly aus:
nebula protect ./bin/Release/net8.0/Billing.dll \
--config nebula.config.json \
--out ./protected/
bogusBranchDensity ist der Regler, auf den es ankommt. low streut Prädikate an die Einsprungpunkte der Methoden; high umhüllt innere Blöcke und verschachtelt unechte Regionen. Die Dichte wird direkt gegen Größe und Geschwindigkeit eingetauscht, also stimmen Sie sie auf die Methode ab, nicht auf das ganze Assembly — genau dafür sind keepList-Einträge und Überschreibungen pro Namensraum da.
Die Kosten, ehrlich
Opake Prädikate sind nicht kostenlos, und wer Ihnen etwas anderes erzählt, verkauft Ihnen eine Überraschung in der Produktion.
- Größe. Jedes Prädikat fügt ein paar IL-Instruktionen plus einen unechten Block hinzu, der echt aussehen muss. Bei Dichte
mediumist mit einem Wachstum der Assemblys im Bereich niedriger zweistelliger Prozentwerte zu rechnen;highkann Methodenrümpfe in heißen Namensräumen mehr als verdoppeln. - Geschwindigkeit. Das Prädikat selbst ist eine Handvoll Ganzzahl-Operationen — isoliert vernachlässigbar. Die echten Kosten sind indirekt: größere Methoden sprengen das Inlining-Budget des JIT und verschmutzen den Instruktions-Cache. Eine zuvor inlinete Methode wird danach womöglich nicht mehr inlinet. Setzen Sie nie unechten Fluss hoher Dichte in eine enge Schleife; schützen Sie stattdessen die Methode, die in die Schleife aufruft.
- Debugbarkeit. Geschützte Stacktraces und decompilierte Dumps werden wirklich schwerer zu lesen — für Sie genauso wie für einen Angreifer. Bewahren Sie Ihre Umbenennungs-Map und Ihre Symbol-Artefakte auf, damit Sie Produktions-Traces zurückverfolgen können.
Das mentale Modell: Opake Prädikate machen Ihren Code nicht unmöglich zu verstehen. Sie machen das automatische Verstehen unzuverlässig, was die Angriffskosten von „de4dot laufen lassen, Ausgabe lesen“ auf „jeden Zweig von Hand analysieren und entscheiden, welche echt sind“ anhebt. Für die meiste IP ist dieser Unterschied das ganze Spiel.
Welche Stufe
Die grundlegende Kontrollfluss-Obfuskation — opake Prädikate bei niedriger bis mittlerer Dichte — ist eine Pro-Funktion, neben Code-Virtualisierung und Methodenverschlüsselung. Die aggressive Kontrollfluss-Stufe, mit hoher Prädikatdichte, tief verschachtelten unechten Regionen und korrelierten Prädikatnetzen, in denen mehrere opake Bedingungen eine gemeinsame Laufzeit-Invariante referenzieren, gehört zu Enterprise. Die Korrelation ist das, was es von „übersteht einen generischen Durchlauf“ zu „übersteht einen entschlossenen Menschen mit einem Disassembler“ bringt — weshalb sie höher eingestuft ist.
Wohin es passt
Opake Prädikate sind eine Schicht, keine Strategie. Benennen Sie um, um die Namen zu töten, verschlüsseln Sie Zeichenfolgen und Konstanten, um die Literale zu töten, flachen Sie den Kontrollfluss ab, um die Form zu töten — und fügen Sie dann unechten Fluss hinzu, damit die Tools, die all das rückgängig machen würden, nicht unbeaufsichtigt laufen können. Jede Schicht hebt den Boden an; gemeinsam verwandeln sie eine Fünf-Minuten-Decompilierung in ein Projekt, von dem der Angreifer entscheiden muss, ob es seine Woche wert ist. Beginnen Sie bei medium, messen Sie die zwei Zahlen, die zählen — die Assembly-Größe 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.