Skip to content
← Alle Beiträge
· Delta1 Labs Reproducible BuildsNebula

Reproduzierbare Builds für obfuskierte .NET-Assemblys

Deterministische Kompilierung liefert dir eine Byte-für-Byte identische DLL aus identischem Quellcode – bis der Obfuskator eine frische MVID, die aktuelle Uhrzeit und einen zufälligen Umbenennungs-Seed in die Ausgabe stempelt. Hier wird gezeigt, wo diese Nichtdeterminismus im PE und in den Metadaten steckt und wie der deterministische Modus von Nebula.NET die MVID, den Zeitstempel und den Umbenennungs-Seed aus einem Hash des Inhalts ableitet, sodass die geschützte Assembly bei jedem Lauf denselben Hash hat.

Deterministische Kompilierung ist einer der leiseren Erfolge des modernen .NET. Aktiviere <Deterministic>true</Deterministic> – es ist die Voreinstellung für Projekte im SDK-Stil – und Roslyn gibt eine Byte-für-Byte identische Assembly aus identischem Quellcode, identischen Referenzen und einem identischen Compiler aus. Kein Uhrzeit-Zeitstempel, keine zufällige Modul-GUID. Zwei Ingenieure an zwei Maschinen bekommen dieselbe DLL, und die CI kann beweisen, dass die ausgelieferte Binärdatei zum Quellcode passt.

Dann lässt du sie durch einen Obfuskator laufen, und die Garantie verflüchtigt sich. Bilde den Hash der geschützten Assembly aus zwei aufeinanderfolgenden Läufen mit exakt denselben Eingaben, und du bekommst zwei verschiedene Hashes. Nichts an deinem Code hat sich geändert. Wo ist der Determinismus hin?

Die eigentliche Frage

Ein Obfuskator liest eine Assembly, schreibt ihre Metadaten und ihr IL um und schreibt eine neue Assembly. Zwei Felder dieser Ausgabe werden aus langer Tradition aus der Umgebung statt aus der Eingabe gefüllt – und eine dritte Quelle der Varianz versteckt sich darin, wie der Umbenenner deine Member durchläuft. Finde diese drei, und du kannst die Garantie wiederherstellen.

Wo die Nichtdeterminismus steckt

Die erste ist die Modulidentität. Jedes .NET-Modul trägt eine Module Version ID, eine GUID, die im Metadaten-Heap #GUID gespeichert und aus der einzigen Zeile der Module-Tabelle referenziert wird. ildasm druckt sie am Kopf des Moduls:

// Metadata: Module (table 0x00)
//   Gen   Name         Mvid (-> #GUID)   EncId   EncBaseId
//   0     MyApp.dll    1                 0       0
// #GUID[1] = {3f2504e0-4f89-41d3-9a0c-0305e82c3301}

Roslyn setzt diese GUID im deterministischen Modus auf einen Hash der Kompilierungseingaben. Ein typischer Obfuskator gibt das Modul neu aus und setzt sie auf Guid.NewGuid() – einen frischen Zufallswert bei jedem Lauf. Ein einziges Feld, und die Reproduzierbarkeit ist bereits dahin.

Die zweite ist der Zeitstempel des PE-Headers. Der COFF-Header hat einen 32-Bit-TimeDateStamp. Deterministisches Roslyn schreibt dort nicht die echte Zeit; es schreibt einen Hash des Inhalts mit gesetztem höchstem Bit, damit Werkzeuge erkennen, dass es kein Zeitstempel ist:

// PE / COFF header
//   Machine:        0x014C (I386)
//   TimeDateStamp:  0x8E0F3A21   // high bit set: content hash, not a real time

Ein Obfuskator, der DateTimeOffset.UtcNow aufruft, um dieses Feld zu füllen, lässt die Ausgabe jede Sekunde anders ausfallen.

Die dritte ist subtiler und steckt im Umbenenner. Einem Member seinen obfuskierten Namen zu geben, ist für sich genommen deterministisch, aber die Reihenfolge, in der die Member besucht werden, ist es meist nicht. Durchlaufe die Methoden eines Typs über ein HashSet oder eine per Reflexion geordnete Sammlung, und die Iterationsreihenfolge kann sich zwischen Läufen oder Framework-Versionen verschieben; seede den Namensgenerator aus Environment.TickCount, und der allererste Name ändert sich bei jedem Lauf. So sieht eine naive Implementierung aus – jede Zeile ist ein Reproduzierbarkeits-Leck:

module.Mvid = Guid.NewGuid();                                  // random identity
peHeader.TimeDateStamp = (uint)DateTimeOffset.UtcNow
                             .ToUnixTimeSeconds();             // wall clock
var rng = new NameGenerator(seed: Environment.TickCount);     // random seed
foreach (var m in type.Methods)                               // unstable order
    m.Name = rng.Next();                                      // -> different map

Sogar die Zeichenkettenverschlüsselung trägt bei: Stammt der Schlüssel pro Build aus RandomNumberGenerator, unterscheiden sich die verschlüsselten Blobs in den an #US angrenzenden Daten bei jedem Lauf, obwohl sie zu denselben Zeichenketten entschlüsseln.

MyApp.dlldeterministischStandard-ObfuskationMvid = Guid.NewGuid() · ts = UtcNowseed = TickCount · unordered membersDeterministischer ModusMvid = H(content) · ts = H(content)seed = H(content) · sorted memberssha256 = 9a4f…sha256 = c17b…sha256 = 4e02…beide Laufe identisch
Dieselbe Eingabe über zwei Läufe. Die Standard-Obfuskation seedet die Identität aus der Umgebung, sodass die beiden Ausgaben unterschiedliche Hashes haben; der deterministische Modus seedet alles aus einem Hash des Inhalts, sodass beide Läufe denselben SHA-256 erzeugen.

Die Identität aus dem Inhalt ableiten

Die Lösung besteht darin, jeden aus der Umgebung stammenden Wert durch eine Funktion der Eingabe zu ersetzen. Der deterministische Modus von Nebula.NET berechnet einen Digest über das transformierte Modul in kanonischer Form – die Metadatentabellen und das IL nach dem Umschreiben, in Tabellenreihenfolge gelesen, mit maskierten namensabhängigen Feldern, damit der Digest nicht von Namen abhängt, die er noch nicht zugewiesen hat – und verwendet diesen Digest als einzige Entropiequelle:

byte[] digest = SHA256.HashData(canonicalModuleBytes);        // stable over inputs + config
module.Mvid = new Guid(digest.AsSpan(0, 16));                 // identity from content
peHeader.TimeDateStamp =
    BinaryPrimitives.ReadUInt32LittleEndian(digest.AsSpan(16)) | 0x8000_0000u;  // hash, flagged
var rng = new NameGenerator(seed: digest);                   // reproducible map
foreach (var m in type.Methods.OrderBy(StableKey))           // (declaring token, signature)
    m.Name = rng.Next();
var stringKey = HKDF.DeriveKey(HashAlgorithmName.SHA256, digest, 32, info: "nebula/strings"u8);

StableKey ist der Teil, der den Umbenenner ehrlich macht: Die Member werden nach einem Tupel aus dem Metadaten-Token ihres deklarierenden Typs und ihrer vollständigen Signatur sortiert, sodass die Durchlaufreihenfolge nicht von den Interna der Sammlung abhängt. Der Zeichenketten-Verschlüsselungsschlüssel wird aus demselben Digest mit HKDF abgeleitet, sodass auch die verschlüsselten Blobs stabil sind – und da dieser Schlüssel ohnehin innerhalb der Assembly leben muss, damit die Laufzeit entschlüsselt, gibt seine Ableitung aus dem Inhalt einem Angreifer nichts Neues.

Du aktivierst ihn mit einem einzigen Konfigurationsschlüssel:

{
  "assemblies": ["MyApp.dll"],
  "rename": { "enabled": true },
  "controlFlow": { "enabled": true },
  "stringEncryption": { "enabled": true },
  "deterministic": true
}

Jetzt ist die Pipeline eine reine Funktion. Führe sie zweimal aus und vergleiche:

nebula --config nebula.config.json --out run1/
nebula --config nebula.config.json --out run2/
sha256sum run1/MyApp.dll run2/MyApp.dll
# 4e02a9…  run1/MyApp.dll
# 4e02a9…  run2/MyApp.dll      <- identical

Was es dir bringt

Attestierung. Eine reproduzierbare geschützte Assembly kann von jedem neu gebaut werden, der die Eingabe-Assembly und die Konfiguration besitzt, und der Hash, den er bekommt, ist der Hash, den du ausgeliefert hast. Das verwandelt „vertraue unserem Build-Server” in „baue es selbst neu und vergleiche”, was der ganze Sinn einer reproduzierbaren Build-Haltung für eine Lieferkette ist.

Caching. Da die Ausgabe eine Funktion von (Eingabe-Assembly, Konfiguration, Nebula.NET-Version) ist, kannst du einen CI-Cache mit dem Hash genau dieser drei als Schlüssel versehen. In einem Branch, der die Assembly nicht angefasst hat, trifft der Cache, und du überspringst die Obfuskation vollständig – sicher, denn ein Treffer garantiert eine Byte-für-Byte identische Ausgabe zu der, die du erzeugt hättest.

Vergleichbarkeit. Mit einer fixierten MVID und einem fixierten Zeitstempel zeigt ein Binärvergleich zwischen zwei Releases nur die Metadaten und das IL, die sich tatsächlich geändert haben, statt von einer neuen GUID und einem neuen Zeitstempel bei jedem Build überflutet zu werden. Kombiniere dies mit einer stabilen Umbenennungszuordnung, und der Vergleich spiegelt die echte Änderung wider.

Wann es bricht

Reproduzierbarkeit ist nur so deterministisch wie ihre schwächste Eingabe, und drei verdienen es, ehrlich benannt zu werden.

Die Werkzeugversion ist Teil des Schlüssels. Eine neue Nebula.NET-Version kann eine Transformation hinzufügen oder verfeinern, was die Ausgabe legitim ändert. Deterministische Ausgabe ist für eine feste Version reproduzierbar; fixiere die Version in der CI und halte sie neben dem Hash fest.

Authenticode-Zeitstempelung ist nicht reproduzierbar. Die Signierung mit starkem Namen ist deterministisch – sie ist eine Funktion des Schlüssels und des Inhalts – aber eine Authenticode-Signatur mit einer RFC-3161-Gegensignatur bettet die Signierzeit und den Nonce der Zeitstempelstelle ein, die keine zwei Signaturen teilen. Behalte die Signierung als letzten Schritt und attestiere den Hash der unsignierten geschützten Assembly, oder vergleiche den zu signierenden Inhalt.

Eingebettete Build-Metadaten dringen durch. Wenn dein eigener Code DateTime.Now, einen Build-Zähler oder eine frische GUID in eine Konstante backt, steckt diese Nichtdeterminismus bereits in der Eingabe-Assembly, bevor Nebula.NET sie überhaupt sieht. Deterministische Kompilierung weiter oben ist eine Voraussetzung, kein nachträglicher Gedanke – korrigiere zuerst den Quellcode.

Fazit

Obfuskation muss dich keinen reproduzierbaren Build kosten. Die Nichtdeterminismus ist dem Umschreiben einer Assembly nicht inhärent; sie steckt in drei ersetzbaren Entscheidungen – der Modul-GUID, dem PE-Zeitstempel und dem Umbenennungs-Seed – plus dem Schlüsselmaterial jeder inhaltsverschlüsselnden Transformation. Leite jede davon aus einem Hash der Eingabe ab statt aus der Uhr oder einem Zufallsgenerator, durchlaufe deine Member in stabiler Reihenfolge, und die geschützte DLL hat bei jedem Lauf denselben Hash. Aktiviere deterministic: true, fixiere die Version, und dein gehärtetes Artefakt wird zu etwas, das du attestieren und cachen kannst, statt zu etwas, das sich jedes Mal ändert, wenn du hinschaust.

Nebula.NET testen

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