Debugger-Anzeigen nach dem Umbenennen lesbar halten
Eine [DebuggerDisplay]-Formatzeichenfolge ist ein Literal zur Kompilierzeit, das die Obfuskation unverändert übersteht — und dennoch zeigt das Überwachungsfenster nach dem Umbenennen {CustomerName} #{Id} oder einen Fehler. Dieser Artikel erklärt warum: Die Zeichenfolge ist kein Text, den der Debugger ausgibt, sondern ein kleiner Ausdruck, den sein Auswerter am Haltepunkt über den Mitgliedsnamen bindet — benennt man die darin genannten Mitglieder um, schlägt die Auflösung fehl. Danach grenzt er Nebula.NET so ein, dass eure eigenen Staging-Builds im Debugger lesbar bleiben, ohne diese Namen im ausgelieferten Binary zu hinterlassen.
Ihr hängt den Debugger an euren eigenen Staging-Build, um einen Fehler zu jagen. Ihr fahrt über ein Invoice, und das Überwachungsfenster — das in der letzten Version Acme #4821 zeigte — zeigt jetzt den wörtlichen Text {CustomerName} #{Id} oder ein rotes error CS1061: 'a' does not contain a definition for 'CustomerName'. Das Objekt ist intakt. Jedes Feld hat den richtigen Wert. Die Obfuskation hat genau das getan, worum ihr gebeten habt. Der Debugger hat nur das eine verloren, was anzuzeigen ihr ihm aufgetragen hattet.
Die eigentliche Frage
Eine [DebuggerDisplay]-Formatzeichenfolge ist ein Zeichenfolgenliteral zur Kompilierzeit. Das Umbenennen rührt Zeichenfolgenliterale nicht an — genau deshalb überleben das ToString() eines Records oder eine Serilog-Nachrichtenvorlage die Obfuskation. Wenn die Formatzeichenfolge also intakt ist, warum ist die Anzeige dann kaputt? Weil die Zeichenfolge kein Text ist, den der Debugger ausgibt. Sie ist ein kleines Programm, das der Debugger am Haltepunkt ausführt, und dieses Programm sucht Mitglieder über den Namen — genau das, was das Umbenennen umschreibt.
Die Formatzeichenfolge ist ein Literal — und das ist die Falle
Nehmt einen gewöhnlichen annotierten Typ.
[DebuggerDisplay("{CustomerName} #{Id}")]
public sealed class Invoice
{
public string CustomerName { get; init; }
public int Id { get; init; }
public decimal Total { get; init; }
}
Das Attribut wird in den Metadaten als benutzerdefinierte Attribut-Zeile auf Invoice gespeichert, und das Konstruktorargument — eure Formatzeichenfolge — liegt als längenpräfigierte UTF-8-Bytes im #Blob-Heap:
.custom instance void [System.Private.CoreLib]
System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = (
01 00 14 7B 43 75 73 74 6F 6D 65 72 4E 61 6D 65 // ...{CustomerName
7D 20 23 7B 49 64 7D 00 00 ) // } #{Id}..
)
Diese Bytes 7B 43 75 73 74… buchstabieren {CustomerName. Sie sind ein undurchsichtiges Konstruktorargument, kein Metadatenname — der Obfuskator hat keinen Grund (und keinen sicheren Weg), in einen beliebigen Attribut-Blob hineinzugreifen und dort eine Teilzeichenfolge umzuschreiben. Wenn Nebula also die Eigenschaftszeile CustomerName in b umbenennt, sagt die Formatzeichenfolge weiterhin CustomerName. Das Literal überlebt perfekt. Das ist das Problem, nicht die Lösung.
Was der Debugger damit macht
An einem Haltepunkt liest der Ausdrucksauswerter von Visual Studio das DebuggerDisplay-Attribut, teilt das Format an seinen {…}-Segmenten auf und kompiliert jedes Segment als Ausdruck, der gegen die Instanz ausgewertet wird — this.CustomerName und this.Id. Er bindet diese Bezeichner an die Metadaten des Assemblys, das tatsächlich im Prozess geladen ist: das umbenannte. Es gibt kein Mitglied namens CustomerName mehr am geladenen Typ; es heißt b. Die Bindung schlägt fehl, und der Auswerter meldet einen Fehler für dieses Segment oder zeigt ersatzweise die rohen geschweiften Klammern. Der Wert "Acme" sitzt genau dort, im Feld b — dem Debugger wurde nur nicht gesagt, dort nachzusehen.
Das ist dieselbe Trennung, die auch das Destructuring von Serilog und die Konfigurationsbindung bestimmt: Ein Wert, der ein Literal zur Kompilierzeit ist, überlebt das Umbenennen, aber ein zur Laufzeit aufgelöster Name folgt ihm. DebuggerDisplay ist nur insofern ungewöhnlich, als die Auflösung zur Debug-Zeit geschieht, und es bündelt beide Hälften in einem Attribut — ein überlebendes Literal, das Mitglieder nennt, die der Umbenenner verschoben hat.
Vergleicht es mit dem Fall ohne Attribut. Entfernt [DebuggerDisplay] ganz, und der Debugger greift auf das ToString() des Typs zurück. Für einen Record wird ToString() vom Compiler mit jedem Mitgliedsnamen als eingebrannten Literalen erzeugt, also gibt es vor und nach dem Umbenennen dieselben Namen aus. Ein attributloser Typ wird korrekt angezeigt; ein DebuggerDisplay hinzuzufügen, das Mitglieder nennt, ist das, was die Abhängigkeit über den Namen zur Debug-Zeit einführt.
Nebula so eingrenzen, dass eure eigenen Builds lesbar bleiben
Entscheidend ist, für wen diese Attribute da sind. DebuggerDisplay, DebuggerTypeProxy und DebuggerBrowsable existieren für einen Menschen, der einen Debugger anhängt — und am Build, den ihr an Kunden ausliefert, tut das niemand. Eine gehärtete Version mit Anti-Debugging und einem virtualisierten heißen Pfad ist so gebaut, dass das Anhängen eines Debuggers erkannt wird und das Schrittweise-Durchlaufen sinnlos ist; eine kaputte Überwachungsanzeige an diesem Build kostet euch nichts, weil ihr ihn nie öffnet. Die erste und beste Antwort lautet also: Versucht nicht, die Anzeige am Kunden-Build zu erhalten. Lasst sie umbenennen.
Wo die Anzeige überleben muss, sind die Builds, die ihr tatsächlich debuggt — lokal und ein Staging-Build, der die Produktion spiegelt. Ist dieser Staging-Build leicht obfusziert oder gar nicht, seid ihr fertig; die Namen sind intakt. Ist er vollständig umbenannt und ihr müsst dennoch anhängen, behaltet nur das, was die Anzeige liest — und behaltet das Blatt, nicht den Typ. Der günstigste Weg ist, die gesamte Anzeige über ein Mitglied zu leiten und diesen einen Namen zu behalten:
[DebuggerDisplay("{DebugView,nq}")]
public sealed class Invoice
{
public string CustomerName { get; init; }
public int Id { get; init; }
public decimal Total { get; init; }
[Obfuscation(Feature = "renaming", Exclude = true)] // the only name the debugger binds
private string DebugView => $"{CustomerName} #{Id}";
}
Jetzt bindet der Auswerter genau einen Namen — DebugView —, den das Attribut behält. Innerhalb dieser Eigenschaft sind CustomerName, Id und Total gewöhnliche Mitgliedszugriffe, die zu IL kompiliert werden; das Umbenennen schreibt sie konsistent zusammen mit allen anderen Referenzen um, also werden sie überall weiterhin zu b, c, d umbenannt und geben in einem Decompiler nichts preis. Ihr habt drei beibehaltene Eigenschaftsnamen gegen einen beibehaltenen Umleitungsnamen getauscht, und der Spezifizierer ,nq entfernt die Anführungszeichen, damit sich die Anzeige sauber liest.
Wenn ihr eine Konfigurationsregel einem Attribut vorzieht — etwa einen ganzen Diagnose-Namespace von Debug-Ansichten — behaltet die Blatt-Mitglieder dort und benennt alles andere um:
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/Billing.dll" ],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Billing.Diagnostics.DebugViews.*", "action": "keep", "members": "public" },
{ "pattern": "Billing.*", "action": "rename" }
]
}
}
nebula protect --config nebula.config.json
Ein beibehaltener Name ist immer noch ein vollständig geschützter Rumpf — das beibehaltene Mitglied DebugView behält seine Kontrollfluss-Obfuskation und seine Zeichenfolgenverschlüsselung; nur sein Name bleibt lesbar. Das ist die übliche Keep-List-Disziplin: Behaltet die kleinste Menge an Namen, die etwas als Zeichenfolge auflöst, hier zur Debug-Zeit.
Wann es bricht
Drei Grenzfälle sind es wert, gekannt zu werden. Erstens, DebuggerTypeProxy: Sein Argument typeof(InvoiceDebugView) ist eine Typreferenz, die Nebula konsistent umschreibt, also hängt sich der Proxy nach dem Umbenennen weiterhin an — aber die öffentlichen Eigenschaftsnamen der Proxy-Klasse selbst sind das, was der Debugger im Überwachungsbaum aufklappt, und die werden zu a, b, c umbenannt. Wenn ihr diese aufgeklappte Ansicht lesbar wollt, behaltet die öffentlichen Mitgliedsnamen des Proxy-Typs; andernfalls ist es nur mehr Rauschen in einem Fenster, das ihr umbenennen lassen könnt.
Zweitens, die Zeichenfolgenverschlüsselung deckt die Formatzeichenfolge nicht ab. encryptStrings schreibt die ldstr-Ladevorgänge in Methodenrümpfen um; das Argument von DebuggerDisplay ist ein Konstruktorwert in einem Attribut-Blob, kein Methodenrumpf, also bleibt es selbst am gehärteten Build im Klartext. Die darin genannten Mitgliedsnamen liegen offen da — ein kleines Leck und ein weiterer Grund, die eine DebugView-Umleitung (die nichts nennt) vorzuziehen oder das Attribut schlicht nicht in den ausgelieferten Build zu übernehmen.
Drittens, die Schritt-Attribute sind gegenstandslos, nicht kaputt. [DebuggerStepThrough] und [DebuggerHidden] betreffen nur das Schrittweise-Durchlaufen, das das Umbenennen unangetastet lässt — aber sobald eine Methode einen abgeflachten Kontrollfluss hat oder virtualisiert ist, bleibt kein gewöhnliches IL mehr zum Durchschreiten übrig, also haben diese Attribute nichts, worauf sie wirken könnten. Fügt keine Keep-Regeln für sie hinzu; es gibt nichts zu behalten.
Fazit
Ein [DebuggerDisplay] ist ein Literal, das Mitglieder nennt, und das Umbenennen verschiebt die Mitglieder unter dem Literal weg. Die Formatzeichenfolge überlebt intakt; der Auswerter des Debuggers bindet die darin enthaltenen Namen an die umbenannten Metadaten und schlägt fehl. Entscheidet, wo die Anzeige wirklich funktionieren muss — eure debuggbaren Builds, nicht der gehärtete des Kunden — und leitet sie dort über ein einziges Mitglied, das ihr behaltet, statt mehrere Eigenschaften zu nennen, die ihr dann lesbar lassen müsst. Schützt den Rest mit Nebula.NET und öffnet das Ergebnis dann in Glass.NET, um zu bestätigen, dass sich eure Typen als a, b, c lesen, während das eine DebugView, auf das sich eure Ingenieure verlassen, seinen Namen weiterhin ausbuchstabiert.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.