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

Metadaten-Heap-Kompaktierung und Token-Neunummerierung: ein .NET-Assembly nach der Obfuskierung verkleinern

Das Umbenennen hinterlässt tote Strings und Blobs in den Heaps #Strings und #Blob. Wie Nebula die Metadaten-Heaps kompaktiert und Tokens neu nummeriert, mit echtem Metadaten-Layout, IL, Konfiguration und Vorher/Nachher-Messungen.

Benennen Sie ein paar Tausend Member um, und Sie haben jeden Bezeichner in Ihrem Assembly verkürzt: CalculateInvoiceTotal wurde zu a, _pendingReconciliationQueue wurde zu b. Man würde erwarten, dass die Datei schrumpft. Öffnen Sie die beiden Builds in einem Hex-Viewer, und oft ist das nicht der Fall: Die ursprünglichen langen Namen sitzen immer noch im #Strings-Heap, verwaist, aber nie entfernt. Die Obfuskierung hat geändert, auf welche Strings die Metadaten-Tabellen zeigen; sie hat die Strings nicht zurückgewonnen, auf die sie einst zeigten.

In diesem Beitrag geht es um den Durchlauf, der die Arbeit vollendet: die Metadaten-Heap-Kompaktierung und die Token-Neunummerierung. Es ist die unspektakulärste Transformation, die Nebula ausführt, und bei einem großen Assembly eine der am besten messbaren: Sie ist der Unterschied zwischen einem Umbenennen, das Namen nur verbirgt, und einem, das sie auch löscht.

Wo die Namen tatsächlich wohnen

Die Metadaten eines .NET-Assemblys sind eine Menge von Tabellen (TypeDef, MethodDef, Field, …) plus vier Heaps, die die Tabellen indizieren:

  • #Strings — nullterminierte UTF-8-Bezeichnernamen: Typ-, Methoden-, Feld- und Namespace-Namen.
  • #US — der User-String-Heap, der die UTF-16-String-Literale enthält, die Ihr Code mit ldstr lädt.
  • #Blob — Signaturen, Argumente benutzerdefinierter Attribute, Konstantenwerte und Marshalling-Deskriptoren.
  • #GUID — Modulversions-IDs und Verwandtes.

Eine MethodDef-Zeile speichert nicht ihren Namen; sie speichert einen Offset in #Strings. Der Name "CalculateInvoiceTotal" wohnt genau einmal im Heap, und jedes Token, das ihn braucht, trägt die Ganzzahl des Offsets, an dem er beginnt.

Renaming repoints a metadata offset and orphans the old stringMethodDef rowRVA | ImplFlags |Name → offset 0x1A40#Strings heap0x1A40 "CalculateInvoiceTotal\0" (orphan)0x2F10 "a\0" (appended)beforeafter rename:Name → 0x2F10Name → offset 0x2F10after compaction0x0004 "a\0" — orphan removed, heap rebuilt, token renumbered

Das Umbenennen schreibt das Name-Feld auf einen neuen Offset um. Der naive Weg, diesen Offset zu bekommen, besteht darin, "a\0" an das Ende von #Strings anzuhängen und dorthin zu zeigen. Schnell, korrekt — und es rührt die alten Bytes nie an. Nach einem vollständigen Umbenennungs-Durchlauf enthält der Heap alle ursprünglichen Bezeichner plus jeden kurzen Ersatz. Die Datei kann sogar wachsen.

Was die Kompaktierung tut

Die Kompaktierung behandelt die Heaps wie eine von einem Garbage Collector verwaltete Arena. Die Schritte:

  1. Markieren. Jede Tabellenspalte durchlaufen, die eine Heap-Referenz ist — TypeDef.Name, TypeDef.Namespace, MethodDef.Name, Field.Signature, jedes ldstr in #US, jedes #Blob eines benutzerdefinierten Attributs — und festhalten, welche Offsets tatsächlich erreichbar sind.
  2. Durchkehren und neu aufbauen. Frische Heaps anlegen, die nur die erreichbaren Einträge enthalten, dedupliziert, damit zwei identische Signaturen sich einen einzigen Blob teilen.
  3. Neunummerieren. Jeder Heap-Offset in jeder Tabelle wird auf seine neue Position umgeschrieben. Tokens in die Tabellen selbst werden ebenfalls neu gepackt, weil leere TypeRef/MemberRef-Zeilen, die von zusammengeführten oder entfernten Referenzen übrig bleiben, verworfen werden können.

Schritt 3 ist der Grund, warum dies keine punktuelle Korrektur sein kann. Ein Metadaten-Token wie 0x06000012 (ein MethodDef, Zeile 0x12) wird aus dem IL (call 0x06000012), aus anderen Tabellen und aus den #Blob-Signaturen referenziert. Nummerieren Sie eine Tabelle neu, und Sie müssen jedes call, ldtoken, newobj und ldstr korrigieren, das sie kreuzt. Nebula macht das als ein einziges kohärentes Remapping: Es baut eine Tabelle altes Token → neues Token, schreibt die Tabellen um und schreibt anschließend die IL-Operanden jedes Methodenrumpfs anhand derselben Tabelle um.

// IL before — operand is a raw metadata token
IL_000a:  ldstr      0x70000A1C      // "CalculateInvoiceTotal failed for order "
IL_000f:  call       0x0A000037      // MemberRef into a #Blob signature

// IL after compaction — same instructions, renumbered operands
IL_000a:  ldstr      0x70000044
IL_000f:  call       0x0A00000B

Die Instruktionen sind Byte für Byte identisch in ihrer Form; nur die Operanden verschieben sich. Vergreifen Sie sich beim Remapping um eine Zeile, und das Assembly wirft beim Laden BadImageFormatException — genau deshalb macht man dies nicht von Hand und deshalb verifiziert Nebula das neu aufgebaute Image, bevor es geschrieben wird.

Es ist auch ein Härtungs-Durchlauf, nicht nur ein Größen-Durchlauf

Die Kompaktierung wird meist über die Größe verkauft, aber der Sicherheitsaspekt sind die verwaisten #Strings-Bytes selbst. Ein Umbenennen, das nur Offsets umzeigt, lässt CalculateInvoiceTotal, _pendingReconciliationQueue und jeden anderen ursprünglichen Namen physisch in der Datei zurück. Sie lösen sich nicht mehr über die Metadaten auf — ein Decompiler zeigt a, b, c — aber ein trivialer strings-artiger Scan über die rohen Bytes stellt Ihren gesamten ursprünglichen Wortschatz wieder her:

$ strings Acme.Billing.dll | grep -i invoice
CalculateInvoiceTotal
InvoiceReconciliationService
_pendingInvoiceBatch

Das ist ein echtes Leck. Ihre Methoden-Namen beschreiben Ihre Domäne oft genauso klar wie der Code. Die Kompaktierung löscht die Waisen, sodass der Scan leer zurückkommt und die einzigen Namen in der Datei die bedeutungslosen kurzen sind, die das Umbenennen erzeugt hat. Dasselbe gilt für #US: Literale, die Sie verschlüsselt und ersetzt haben, verweilen im User-String-Heap, bis der Heap neu aufgebaut wird.

Wie man es einschaltet

Die Kompaktierung läuft nach dem Umbenennen, der String-Verschlüsselung und der Ressourcenverarbeitung, weil sie die endgültige Menge der lebenden Referenzen sehen muss. In nebula.config.json ist sie eine Stufe unter der Ausgabe, standardmäßig aktiviert, wenn Sie umbenennen, aber konfigurierbar:

{
  "schemaVersion": 1,
  "inputs": [ "bin/Release/net8.0/Acme.Billing.dll" ],
  "outputDirectory": "protected",

  "rename": { "enabled": true },
  "stringEncryption": { "enabled": true },

  "metadata": {
    "compactHeaps": true,
    "dedupeBlobs": true,
    "removeOrphanStrings": true,
    "renumberTokens": true
  }
}

Dann der übliche Aufruf:

nebula protect --config nebula.config.json --out protected

Die einzige Einstellung, die man verstehen sollte, ist renumberTokens. Die Tokens so zu lassen, wie sie waren (nur die Heaps neu aufzubauen), ist die konservative Wahl, falls etwas weiter unten ein bestimmtes Token festnagelt — etwa ein Werkzeug, das Ihr Assembly über eine fest codierte MethodDef-Zeile liest. Das ist selten. Lassen Sie es auf true, sofern Sie keinen konkreten Grund haben, denn die Neunummerierung ist es, die das Verwerfen leerer Tabellenzeilen ermöglicht.

Wann man sich zurückhalten sollte

Die Kompaktierung ist für gewöhnliche Assemblys sicher, aber zwei Fälle verdienen eine metadata.preserve-Liste. Erstens ein Assembly, das über mdToken über eine Grenze hinweg geladen wird — manche Profiling- oder Instrumentierungs-Hosts cachen Tokens. Zweitens alles, was Module.ResolveMethod(int metadataToken) auf sich selbst mit einem im Quellcode eingebetteten Literal-Token aufruft. Beides ist ungewöhnlich; wenn es zutrifft, nageln Sie die betroffenen Member fest:

"metadata": {
  "compactHeaps": true,
  "renumberTokens": true,
  "preserve": [ "Acme.Billing.Diagnostics.TokenProbe.*" ]
}

Benannte Member behalten ihre ursprünglichen Tokens; alles andere wird um sie herum neu nummeriert und kompaktiert.

Was es tatsächlich spart

Die Zahlen hängen ganz davon ab, wie namenslastig Ihr Assembly war, also wie viel das Umbenennen entfernt hat. Ein repräsentatives Ergebnis bei einem mittelgroßen Business-Assembly — ~4.200 Methoden, reicher Domänen-Wortschatz, Strings verschlüsselt — sieht so aus:

                           #Strings     #US      #Blob     File
rename only (no compaction)  412 KB   188 KB    96 KB    1.84 MB
+ heap compaction             34 KB     2 KB    71 KB    1.27 MB
                             ───────   ──────   ──────   ───────
                              -92%      -99%     -26%     -31%

Der Zusammenbruch von #Strings sind die verwaisten ursprünglichen Bezeichner, die verschwinden. Der Zusammenbruch von #US sind die Literale von vor der Verschlüsselung, die verschwinden. #Blob schrumpft weniger und nur durch die Deduplizierung, weil die Signaturen alle lebendig waren. Eine Dateireduktion von 31 % ist für ein umbenennungslastiges Assembly typisch; ein kleines Hilfsprogramm mit wenigen Membern wird fast nichts sehen, weil es wenige Waisen zu sammeln gab.

Auch der Start verschiebt sich, aber weniger, als die Größe nahelegt. Die Runtime bildet die Metadaten per Memory-Mapping ab und liest sie faul, sodass ein kleinerer #Strings-Heap vor allem dem Kaltstart und dem Working Set hilft, nicht dem Durchsatz im Dauerbetrieb. Behandeln Sie den Größengewinn als die Schlagzeile und den Startgewinn als Bonus — und messen Sie, wie immer, Ihr eigenes Assembly, statt einer Tabelle zu vertrauen.

Prüfen, dass es funktioniert hat

Zwei Kontrollen, beide schnell. Zuerst bestätigen, dass die Waisen weg sind, mit demselben Scan, der sie offenlegte:

$ strings protected/Acme.Billing.dll | grep -i invoice
$    # (no output — the original names are no longer in the file)

Zweitens öffnen Sie das geschützte Assembly in Glass.NET und schauen sich die Metadaten-Ansicht an: Der #Strings-Heap sollte nur die kurze Umbenennungsausgabe und Framework-Namen enthalten, der #US-Heap sollte nahezu leer sein, falls Sie Strings verschlüsselt haben, und die Token-Navigation sollte sauber auflösen — ein Neunummerierungsfehler zeigt sich sofort als kaputte Referenz. Glass liest die Heaps direkt, also ist es der ehrliche Weg, zu bestätigen, dass die Kompaktierung getan hat, was die Konfiguration verlangte, ohne erst ausliefern zu müssen.

Die Kurzfassung

Das Umbenennen ändert, worauf die Metadaten zeigen; die Kompaktierung gewinnt zurück, worauf sie einst zeigten. Lassen Sie es aus, und Sie liefern ein Assembly aus, dessen ursprüngliche Namen vor einem Decompiler verborgen, aber mit strings trivial wiederherstellbar sind — beladen mit Hunderten Kilobytes totem Heap. Führen Sie es aus, und die Waisen werden gelöscht, die Blobs dedupliziert, die Tokens neu gepackt, und die Datei wird zugleich kleiner und wirklich von dem Wortschatz gesäubert, den Sie verbergen wollten. Sie ist beim Umbenennen genau aus diesem Grund standardmäßig aktiviert: Lassen Sie sie an, nageln Sie das seltene selbstreferenzielle Token fest und verifizieren Sie in Glass, bevor Sie ausliefern.

Siehe Nebula.NET für die vollständige Transformations-Pipeline und die nebula.config.json-Referenz sowie die Metadaten-Tabellen erklärt für die Strukturen, auf denen die Kompaktierung arbeitet.

Nebula.NET testen

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