Skip to content
← Alle Beiträge
· Delta1 Labs ReadyToRunNebula

Die richtige Reihenfolge von ReadyToRun und Obfuskierung

Ein ReadyToRun-Build ist ein Doppelabbild — dein IL plus eine native Kopie davon, von crossgen aus dem Zustand des IL zum Veröffentlichungszeitpunkt kompiliert. Obfuskierst du nach crossgen, ist diese native Kopie ein sauberer, von jedem Decompiler unabhängiger Mitschnitt deiner ursprünglichen Logik; sie macht zudem das R2R-Abbild ungültig, sodass die Runtime still auf den JIT zurückfällt. Hier steht, warum die Reihenfolge alles entscheidet und wie du Nebula so einhängst, dass crossgen geschütztes IL kompiliert.

Die meisten Ratschläge zum .NET-Schutz behandeln Obfuskierung und Veröffentlichung als zwei unabhängige Schritte, die man in beliebiger Reihenfolge ausführen kann. Für einen gewöhnlichen Framework-abhängigen Build stimmt das ungefähr. Für einen ReadyToRun-Build stimmt es nicht — und die falsche Reihenfolge erzeugt ein ausgeliefertes Artefakt, das genau die Logik preisgibt, die du obfuskiert hast, und wirft zugleich den Startvorteil weg, für den du R2R überhaupt eingeschaltet hast.

Der Grund ist strukturell, kein Fehler: eine ReadyToRun-Assembly ist nicht eine Darstellung deines Codes, sondern zwei. Die Obfuskierung berührt stets nur eine davon. Dieser Beitrag handelt davon, welche das ist, warum die zweite Kopie aus dem Zustand der ersten zum Zeitpunkt des crossgen-Laufs kompiliert wird und wie man Nebula.NET so sequenziert, dass beide Kopien am Ende geschützt sind.

Was ein ReadyToRun-Build tatsächlich erzeugt

PublishReadyToRun=true führt während dotnet publish den crossgen2-Compiler aus. crossgen liest die verwalteten Assemblys und gibt für jede Methode vorab nativen Maschinencode aus, der zusammen mit einem ReadyToRun-Header in die Assembly eingebettet wird. Das Ziel ist ein schnellerer Start: die Runtime kann den vorkompilierten nativen Code ausführen, statt die Methode beim ersten Aufruf per JIT zu kompilieren.

Die entscheidende Tatsache — die, um die sich die ganze Reihenfolgefrage dreht — ist, dass ReadyToRun nicht Native AOT ist. Es entfernt dein IL nicht. Die veröffentlichte Assembly bleibt eine völlig gewöhnliche .NET-Assembly: vollständige Metadaten, vollständiges IL, vollständige verwaltete Methodenkörper, plus einen nativen Codeabschnitt, der die heißen Methoden dupliziert. Das IL bleibt, weil es der maßgebliche Rückfall ist. Ist das R2R-Abbild für die aktuelle Runtime nicht gültig — falsche Architektur, eine nicht passende Versionsblase, ein verändertes Modul — verwirft die CLR den nativen Code und kompiliert per JIT aus dem IL. R2R ist eine über deine Assembly gelegte Optimierung, niemals ein Ersatz für sie.

Nach einer ReadyToRun-Veröffentlichung lieferst du also zwei unabhängige Kodierungen jeder vorkompilierten Methode aus:

  • den IL-Methodenkörper, den ein Decompiler in nahezu originalen C#-Code zurückverwandelt, und
  • die native Kompilierung derselben Methode, die ein nativer Disassembler direkt liest.

Obfuskierung ist eine IL-zu-IL-Transformation. Sie schreibt die erste Kodierung um. Die zweite kann sie nicht berühren: der native Code ist für sie undurchsichtig. Der einzige Hebel, den du über die native Kopie hast, ist der Zustand des IL, als crossgen es kompilierte.

Die Reihenfolgenfalle

Stell dir die verlockende Kette vor: bauen, mit ReadyToRun veröffentlichen und dann den Obfuskator über den fertigen Publish-Ordner laufen lassen, weil das ja das Artefakt ist, das du ausgibst. Es fühlt sich richtig an — das zu schützen, was du aushändigst. Es ist genau verkehrt herum.

Wenn dein Obfuskator läuft, hat crossgen den nativen Code längst aus deinem sauberen, nicht obfuskierten IL kompiliert. Deine Lizenzprüfung, deine Schlüsselableitungsroutine, deine Preisberechnung: all das liegt nun im nativen Abschnitt als getreue, voll optimierte Maschinencode-Umsetzung des ursprünglichen Algorithmus. Dein Obfuskator flacht dann die IL-Kopie dieser Methode ab, verschlüsselt ihre Strings, virtualisiert sie vielleicht. Die IL-Kopie ist wunderbar geschützt. Die native Kopie, Minuten zuvor kompiliert, ist ein zweiter, unberührter Mitschnitt derselben Logik, den keine IL-Transformation je erreicht. Ein Angreifer disassembliert einfach die native Methode und liest den Kontrollfluss, den du verborgen glaubtest.

Darüber stapelt sich ein zweites, leiseres Versagen. Die Obfuskierung schreibt das Modul um: neue Metadaten-Token, neue Namen, neue Methodenkörper, eine neue MVID. Das ReadyToRun-Abbild war an das Modul vor der Obfuskierung gebunden. Das Mutieren der Assembly nach crossgen macht die Integritäts- und Versionsprüfungen des R2R-Headers ungültig, sodass die Runtime beim Laden das native Abbild verwirft und das IL per JIT kompiliert. Du hast die Größenkosten von R2R bezahlt, eine native Kopie deiner ungeschützten Logik ausgeliefert und den Startvorteil verloren. Drei schlechte Ergebnisse aus einem einzigen Reihenfolgefehler.

Obfuscate before crossgen — native code is compiled from protected ILManaged ILNebulaobfuscate ILcrossgen2emit nativeR2R imageIL + native both protectedObfuscate after crossgen — native copy keeps the original logic, R2R is discardedManaged ILcrossgen2emit nativeNebularewrites IL onlyLeaky artifactclean native + R2R invalidnative copyunprotected

Obfuskiere vor crossgen

Die Regel folgt unmittelbar aus dem Diagramm: das IL, das crossgen kompiliert, muss bereits obfuskiert sein. Konkret muss die Obfuskierung nachdem der C#-Compiler deine Assemblys erzeugt hat und bevor dotnet publish den ReadyToRun-Schritt ausführt stattfinden. Es gibt zwei saubere Wege, das zu arrangieren.

Zweistufiges CI. Baue, obfuskiere die kompilierte Ausgabe und veröffentliche dann mit ReadyToRun, auf die bereits geschützten Assemblys gerichtet:

dotnet build -c Release -p:PublishReadyToRun=false
nebula --config nebula.config.json            # rewrites the IL in place
dotnet publish -c Release --no-build \
  -p:PublishReadyToRun=true -o out            # crossgen now compiles protected IL

Die nebula.config.json bewahrt alles, was R2R und Reflexion benötigen, und wendet die schweren Transformationen dort an, wo sie zählen:

{
  "schemaVersion": 1,
  "inputs": ["bin/Release/net8.0/MyApp.dll", "bin/Release/net8.0/MyApp.Core.dll"],
  "outputDirectory": "bin/Release/net8.0",
  "preservePublicApi": true,
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "autoProtectLicensing": true
}

Da crossgen die Assemblys in bin/Release/net8.0 zum Veröffentlichungszeitpunkt liest, wird der native Code, den es ausgibt, aus dem abgeflachten, string-verschlüsselten IL kompiliert: die beiden Kodierungen stimmen nun überein, und beide sind geschützt.

Ein MSBuild-Hook, damit ein einfaches dotnet publish schon korrekt ist. Das Einzige, was zählt, ist, dass der Obfuskierungs-Exec vor der ReadyToRun-Kompilierung des SDK läuft, nicht danach:

<Target Name="NebulaProtect" AfterTargets="Build" BeforeTargets="Publish">
  <Exec Command="nebula --config $(ProjectDir)nebula.config.json" />
</Target>

Welchen Weg du auch wählst, das Prinzip ist dasselbe, das Native AOT und die Single-File-Veröffentlichung regiert: der Schutz gehört auf das verwaltete IL, zwischen Kompilierung und Veröffentlichung. R2R erhöht nur den Einsatz, denn hier verpackt der Veröffentlichungsschritt dein IL nicht bloß — er kompiliert eine zweite, unabhängige Kopie davon.

Wie jede Kodierung aussieht

Nimm eine repräsentative Lizenz-Durchsetzungsmethode:

public bool IsLicensed(string key)
{
    if (!key.StartsWith("LIC-")) return false;
    return ValidateSignature(key, "https://api.example.com/v1/activate");
}

Obfuskiere das IL vor crossgen, und die IL-Kopie dekompiliert zu einem abgeflachten Dispatcher, wobei Präfix und Endpunkt zur Laufzeit aus dem verschlüsselten String-Speicher geholt werden:

public bool a(string A_0)
{
    int s = 0;
    while (true) { switch (s) {
        case 0: if (!A_0.StartsWith(Strings.Get(0x3f1))) { s = 9; break; } s = 4; break;
        case 9: return false;
        case 4: return b(A_0, Strings.Get(0x412));
        /* ... */ } }
}

Entscheidend ist, dass die native Methode, die crossgen erzeugt, nun eine Kompilierung dieses Dispatchers ist — dieselbe undurchsichtige Verzweigungsstruktur, keine literale URL, nichts sauber Lesbares. Beachte, dass .NET-String-Literale im Metadaten-Heap #US liegen und nicht in den nativen Code eingebettet werden; die String-Verschlüsselung schützt also beide Kodierungen über die Metadaten, unabhängig von R2R. Es sind der Kontrollfluss und die Gestalt des Algorithmus, die die native Kopie sonst offenlegen würde, und hier legt sie die obfuskierte Gestalt offen.

Obfuskiere nach crossgen, und die IL-Kopie sieht identisch zur geschützten Version oben aus — aber der native Abschnitt ist eine direkte Maschinencode-Übersetzung des sauberen Originals: ein erkennbarer Präfixvergleich, ein Aufruf in die Signaturvalidierung, die Verzweigungsstruktur deiner echten Methode, voll optimiert und für jeden, der das R2R-Abbild disassembliert, perfekt lesbar. Die IL-Obfuskierung war echte Arbeit, verschwendet auf den Schutz der Kopie, die niemand lesen muss.

Prüfen, ob der R2R-Build wirklich geschützt ist

Zwei schnelle Prüfungen verwandeln die Reihenfolgegarantie in Belege:

  1. Das R2R-Abbild ist vorhanden und gültig. Bestätige nach der geschützten Veröffentlichung, dass die Assembly weiterhin einen ReadyToRun-Header trägt (die Werkzeuge crossgen2/r2rdump des SDK geben ihn aus). Wäre die Obfuskierung nach crossgen gelaufen, wäre das Abbild abwesend oder würde beim Laden verworfen, und du wärst still zum JIT zurückgefallen — ein gültiger Header ist also der Beweis, dass die Reihenfolge gehalten hat.
  2. Die nativen Methodenkörper verweisen auf umbenannte Member. Gib die R2R-Methodenliste aus; die Einsprungpunkte sollten den von Nebula umbenannten Bezeichnern (a, b, …) entsprechen, weil sie aus den obfuskierten Metadaten kompiliert wurden. Tauchen originale Namen in der nativen Methodentabelle auf, lief crossgen zuerst — ein Warnsignal.

Für die IL-Seite prüfe wie bei jedem geschützten Build: öffne die ausgelieferte Assembly in Glass.NET oder dem Decompiler deiner Wahl und bestätige, dass die sensiblen Methoden als abgeflachte Dispatcher statt als sauberes C# zurückkommen, genau wie in Obfuskierung in CI prüfen beschrieben.

Das Fazit

ReadyToRun ist eine gute Startoptimierung und wert, ausgeliefert zu werden. Doch es verändert die Obfuskierungsfrage von Grund auf, denn es kompiliert eine zweite native Kopie deines Codes aus dem IL, das man ihm reicht. Obfuskiere zuerst, und diese Kopie erbt deinen Schutz; obfuskiere zuletzt, und sie wird zu einem sauberen, von jedem Decompiler unabhängigen Mitschnitt der Logik, die du verbergen wolltest, während das nicht passende R2R-Abbild beim Laden verworfen wird und dich den einen Vorteil kostet, für den du es eingeschaltet hast. Es gibt keinen Mittelweg und kein „den Publish-Ordner schützen wir später”. crossgen muss geschütztes IL kompilieren. Sequenziere Nebula vor dem ReadyToRun-Schritt, prüfe, dass die nativen Methoden die umbenannte Gestalt tragen, und beide Hälften des Abbilds erzählen dieselbe, geschützte Geschichte.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.