Warum ein gespeicherter Typname nach dem Umbenennen bricht
Eine Plugin-Anwendung, die "Acme.Exporters.PdfExporter, Acme.Exporters" mit Type.GetType und Activator.CreateInstance auflöst, läuft im Debug und fällt in der Produktion aus, sobald man sie obfuskiert. Die Ursache ist eine Diskrepanz zwischen einem Metadaten-Token und einer schlichten Zeichenfolge – und die Lösung ist eine umbenennungssichere Registry, die keinen Namen behält.
Hier ist ein Plugin-Loader, der in tausend .NET-Anwendungen ausgeliefert wurde. Die Anwendung liest den Typnamen eines Exporters aus der Konfiguration, löst ihn auf und erzeugt eine Instanz:
// appsettings: "Exporter": "Acme.Exporters.PdfExporter, Acme.Exporters"
string typeName = config["Exporter"];
Type? t = Type.GetType(typeName);
var exporter = (IExporter)Activator.CreateInstance(t!)!;
exporter.Export(report);
Er besteht jeden Test. Sie obfuskieren den Build, liefern ihn aus, und der erste Kunde, der den PDF-Exporter wählt, bekommt eine NullReferenceException – weil Type.GetType null zurückgab. An der Logik hat sich nichts geändert. Der Typ ist noch in der Assembly. Also was ist weggewandert?
Die eigentliche Frage: Token oder Zeichenfolge?
Das Umbenennen ist das Rückgrat der Obfuskierung: Es schreibt PdfExporter zu a um, Acme.Exporters zu nichts, über die gesamte Assembly hinweg. Der Grund, warum ein normaler Methodenaufruf dies übersteht, ist, dass der Compiler nie den Namen dessen gespeichert hat, was er aufruft – er speicherte ein Metadaten-Token, einen numerischen Verweis in die Typ- und Member-Tabellen der Assembly. Wenn der Obfuskator einen Typ umbenennt, schreibt er die Zielzeile des Tokens und jedes Token, das darauf zeigt, im Gleichschritt um. Die Verbindung ist numerisch, also kann sie nicht abdriften.
Eine Zeichenfolge ist kein Token. Type.GetType("Acme.Exporters.PdfExporter, Acme.Exporters") übergibt dem Loader eine Folge von Zeichen und bittet ihn, zur Laufzeit die Metadaten nach einem Typ zu durchsuchen, dessen Namespace und Name das buchstabieren. Die Zeichenfolge liegt im User-String-Heap der Assembly als inertes Datum. Das Umbenennen schreibt die Spalten Name und Namespace des Typs in der TypeDef-Tabelle um – aber es hat keinen Grund, ein Zeichenfolgen-Literal anzufassen, und keine sichere Möglichkeit zu wissen, dass dieses bestimmte Literal genau diesen Typ benennen sollte. Also sagt die Zeichenfolge weiterhin Acme.Exporters.PdfExporter, die TypeDef-Zeile sagt nun a, die Suche passt zu nichts, und Sie bekommen null.
Das ist der ganze Fehler. Es ist dieselbe Bruchlinie wie bei der Reflexion per Membername, nur eine Ebene höher: Hier ist die Typidentität selbst das, was als Zeichenfolge transportiert wird.
Es im IL sehen
Vergleichen Sie, wie die beiden Arten, einen Typ zu benennen, kompilieren. Ein typeof(PdfExporter) wird zu einem Token-Load reduziert:
ldtoken Acme.Exporters.PdfExporter
call class System.Type System.Type::GetTypeFromHandle(valuetype System.RuntimeTypeHandle)
Der Operand von ldtoken ist ein Token in die TypeDef/TypeRef-Tabelle. Benennen Sie den Typ um, und der Obfuskator schreibt die Zeile und diesen Operanden gemeinsam um – der Verweis zeigt weiterhin auf den richtigen Typ.
Type.GetType(string) wird zu einem String-Load reduziert:
ldstr "Acme.Exporters.PdfExporter, Acme.Exporters"
call class System.Type System.Type::GetType(string)
Der Operand von ldstr zeigt in den User-String-Heap. Der Obfuskator lässt ihn in Ruhe. (String-Verschlüsselung würde dieses ldstr durch einen Entschlüsselungsaufruf ersetzen, aber der entschlüsselte Wert ist derselbe Text – das ändert also das statische Bild, nicht die Suche, und die Auflösung scheitert weiterhin.) Unterdessen hat sich die TypeDef-Zeile, die die Zeichenfolge finden sollte, unter ihr verändert:
Beachten Sie, was nicht gebrochen ist: Activator.CreateInstance(t). Sobald Sie ein echtes Type halten, ruft Activator dessen Konstruktor per Token auf, und Konstruktoren werden nie umbenannt. Der gesamte Fehler konzentriert sich auf den einen Schritt von der Zeichenfolge zum Type.
Die Lösung: per Token auflösen, einen Schlüssel speichern
Die robuste Lösung ist, einen CLR-Typnamen gar nicht erst als Datum zu transportieren. Transportieren Sie einen stabilen Schlüssel, den Sie wählen – einen, der nichts damit zu tun hat, wie der Typ in der Assembly heißt – und bilden Sie ihn über typeof() auf den Typ ab:
static readonly Dictionary<string, Type> Exporters = new()
{
["pdf"] = typeof(PdfExporter),
["csv"] = typeof(CsvExporter),
["xlsx"] = typeof(XlsxExporter),
};
// appsettings: "Exporter": "pdf"
Type t = Exporters[config["Exporter"]];
var exporter = (IExporter)Activator.CreateInstance(t)!;
Jedes typeof() kompiliert hier zu einem Token. Nach dem Umbenennen heißt PdfExporter a, und das Dictionary gibt weiterhin das richtige Type zurück, weil der Obfuskator das Token beim Umbenennen der Zeile mitgeschrieben hat. Die Schlüssel "pdf", "csv", "xlsx" sind Ihr Vokabular, nicht das der Laufzeit – das Umbenennen sieht sie nie an, und Sie können die String-Verschlüsselung sogar darauf eingeschaltet lassen, weil ihr Wert ein von Ihnen kontrollierter Vertrag ist, kein durchgesickerter Bezeichner. Sie behalten keinen Typnamen auf Ihrer Keep-List. Das ist das ideale Ergebnis: volles Umbenennen, keine lesbaren Löcher, und es übersteht zudem künftige Refactorings der Typnamen.
Wenn Sie wirklich nicht entkoppeln können – die Typnamen sind ein veröffentlichter Vertrag, oder ein Host außerhalb Ihrer Assembly löst sie auf – behalten Sie genau diese Namen und nichts anderes. In nebula.config.json steht ein reines Namen-Keep über dem Umbenennungs-Catch-all:
{
"inputs": [ "bin/Release/net8.0/Acme.App.dll" ],
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Acme.Exporters.*Exporter", "action": "keep" },
{ "pattern": "Acme.*", "action": "rename" }
]
}
}
Oder fixieren Sie es an der Deklaration mit einem Attribut, das die Regel beim Code hält, den sie schützt:
[Obfuscation(Feature = "renaming", Exclude = true)]
public sealed class PdfExporter : IExporter { /* ... */ }
In beiden Fällen wirkt das Keep nur auf den Namen: Die Methodenrümpfe von PdfExporter werden weiterhin kontrollflussobfuskiert und seine Zeichenfolgen-Literale weiterhin verschlüsselt. Sie haben verhindert, dass sein Name wandert, damit die Zeichenfolge ihn finden kann; Sie haben seine Logik nicht vom Schutz ausgenommen. Aber denken Sie an die bleibenden Kosten der Keep-List-Disziplin: Jeder behaltene Name ist eine Klartext-Beschriftung in den Metadaten. Eine auf "pdf" geschlüsselte Registry verrät nichts; ein behaltenes PdfExporter verrät den Klassennamen. Bevorzugen Sie die Registry überall dort, wo Sie Herr der Auflösung sind.
Wann es trotzdem beißt
Ein paar Randfälle erwischen Leute selbst nach dem Verständnis des Mechanismus:
- Reine Namespace-Umbenennungen. Selbst
Type.GetType("Acme.Exporters.PdfExporter")ohne Assembly-Suffix bricht, weil auch der Namespace umbenannt wird. Manchmal nimmt man an, nur der Blattname zähle. - Verschachtelte Typen. Der Name eines verschachtelten Typs in einer Zeichenfolge verwendet einen
+-Trenner (Outer+Inner). Beide Teile umzubenennen bricht die Zeichenfolge genauso, und die+-Form ist beim Schreiben eines Keep-Musters leicht zu vergessen. - Generische Typen. Der Reflexionsname eines Generics trägt eine Backtick-Arität (
List\1). Speichern SieMyCache`1` und benennen es um, bleibt die Arität, aber der Name wandert – derselbe Fehler. - Plugins in anderen Assemblys. Lebt der Typ in einer Assembly, die nicht Teil dieses Obfuskierungslaufs ist – ein Drittanbieter-Plugin – benennt Ihr Lauf ihn nie um, sein Name ist also stabil und
Type.GetTypefunktioniert weiter. Das Registry-Muster hilft Ihnen trotzdem, aber der Bruch betrifft nur Typen, die Sie selbst obfuskieren. - Assembly-Name in der Zeichenfolge. Der Assembly-Identitätsteil (
, Acme.Exporters) wird gegen den Assembly-Namen abgeglichen, den das Umbenennen nicht ändert – diese Hälfte der Zeichenfolge ist also in Ordnung. Es ist immer der Typteil, der abdriftet.
Fazit
Ein Metadaten-Token wandert mit dem Umbenennen; eine Zeichenfolge nicht. Immer wenn Ihr eigener Code einen Ihrer eigenen Typen als Text benennt – Type.GetType, ein Typname in der Konfiguration, ein persistierter Diskriminator – macht das Umbenennen ihn stillschweigend ungültig und lässt dabei jeden Test auf dem nicht obfuskierten Build grün. Die dauerhafte Lösung ist kein Keep-List-Eintrag; sie besteht darin, über typeof() aufzulösen und einen von Ihnen gewählten Schlüssel zu transportieren, sodass das Einzige, was die Speichergrenze überquert, ein Wort ist, das die Laufzeit nie gegen einen umbenannten Namen abgleichen muss. Siehe den begleitenden Fallstrick-Katalog für die übrigen Fehler per Name und Nebula.NET für die hier beschriebenen Durchläufe von Umbenennen und String-Verschlüsselung.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.