Eine WinUI-3-App obfuskieren, ohne das XAML zu zerstören
WinUI 3 kompiliert {x:Bind} zu einer generierten Bindungsklasse in Ihrer eigenen Assembly — ein typisierter Getter-Aufruf per Metadaten-Token plus ein literaler PropertyName-Vergleich —, sodass sich das gesamte View Model sauber umbenennen lässt. Die Fehler, die bleiben, sind die drei Stellen, an denen WinUI oder Ihr eigener Code noch über eine Zeichenkette geht: ein per Reflexion aufgelöster klassischer {Binding}-Pfad, eine per Type.GetType aus einem zusammengesetzten Namen gefundene Seite und ein Typ, den das Package.appxmanifest über seinen literalen Namen aktiviert. Dieser Beitrag liest den generierten Bindungscode, zeigt, warum {x:Bind} eine vollständige Umbenennung übersteht, während {Binding} leer zurückkommt, erklärt, welche benutzerdefinierten Abhängigkeitseigenschaftsnamen wirklich tragend sind, und gibt die Nebula-Konfiguration an, die die App einebnet, ohne die per Zeichenkette aufgelöste Oberfläche anzutasten.
Ein Obfuskierungsleitfaden für WPF lässt sich nicht auf WinUI 3 übertragen, und ein UWP-Leitfaden nur zur Hälfte, denn was entscheidet, was eine Umbenennung übersteht, ist der XAML-Compiler, und der von WinUI 3 ähnelt dem von Avalonia mehr als dem von WPF. WPF kompiliert XAML zu BAML — einem serialisierten Objektgraphen, den die Laufzeit per Namen instanziiert, wobei Bindungspfade per Reflexion durchlaufen werden. WinUI 3 kompiliert {x:Bind} zu C# in Ihrer eigenen Assembly: eine generierte Bindungsklasse, deren Aufgabe es ist, Ihre Getter direkt aufzurufen und die Werte in Ihre Steuerelemente zu schieben. Wenn Nebula die Assembly sieht, ist der Großteil dessen, was ein Obfuskator in WPF brechen würde, bereits in Metadaten-Token umgewandelt — und Token sind genau das, was ein Umbenenner korrekt umschreibt.
Die Fehler, die bleiben, sind also die Stellen, an denen WinUI oder Ihr eigener Code noch über eine Zeichenkette geht. Es gibt drei, die zählen, und es lohnt sich, sie danach zu ordnen, wie schnell sie zuschlagen: ein klassischer {Binding}-Pfad kommt leer zurück, mit einer Log-Zeile und einem leeren Steuerelement; eine per Type.GetType über einen von Ihnen zusammengesetzten Namen gefundene Seite bricht jede Navigation, die sie nutzt; und ein Typ, den Ihr Package.appxmanifest über seinen literalen Namen aktiviert, startet nicht — mit einem Fehler „Klasse nicht registriert“, den das Betriebssystem auslöst, nicht Ihr Code.
Wozu {x:Bind} kompiliert
Lesen Sie zuerst den generierten Code, denn das gesamte Sicherheitsargument hängt davon ab, was genau darin steht. Eine Seite mit einer typisierten Bindung:
<!-- MainPage.xaml -->
<Page x:Class="MyApp.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<TextBlock Text="{x:Bind ViewModel.Greeting, Mode=OneWay}" />
</Page>
Der XAML-Compiler schreibt eine MainPage.xaml.g.cs, die eine verschachtelte Bindungsklasse enthält. Dekompiliert und zum Lesen bereinigt, sieht der Teil, der den Wert in den TextBlock schiebt, so aus:
// Generiert in MyApp.dll: MainPage.xaml.g.cs, verschachtelte Klasse MainPage_obj1_Bindings
private global::MyApp.MainViewModel dataRoot; // die x:Bind-Quelle (this.ViewModel)
private void Update_(global::MyApp.MainViewModel obj, int phase)
{
if (obj != null)
this.Update_ViewModel_Greeting(obj.Greeting, phase); // callvirt get_Greeting() — ein Token
}
private void Update_ViewModel_Greeting(string value, int phase)
{
if ((phase & (NOT_PHASED | DATA_CHANGED | (1 << 0))) != 0)
this.obj2.Text = value ?? string.Empty; // obj2 ist der TextBlock
}
// Änderungsverfolgung für die OneWay-Bindung:
private void PropertyChanged_ViewModel(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "Greeting":
this.Update_ViewModel_Greeting(this.dataRoot.Greeting, DATA_CHANGED);
break;
// "" oder null -> alle verfolgten Eigenschaften aktualisieren
}
}
Zwei Dinge referenzieren Greeting, und es sind unterschiedliche Arten von Referenzen. obj.Greeting kompiliert zu callvirt instance string MyApp.MainViewModel::get_Greeting() — ein Metadaten-Token. Wenn Nebula get_Greeting in a umbenennt, schreibt es jedes Token um, das darauf zeigt, auch dieses, sodass der generierte Code den umbenannten Getter aufruft und den richtigen Wert zurückgibt. Die Referenz auf MainViewModel selbst und der Feldzugriff auf obj2 sind ebenfalls Token, die genauso umgeschrieben werden.
Die zweite Referenz ist die Zeichenkette "Greeting" im switch. Sie dient nicht dazu, die Eigenschaft zu finden — die Update-Methode hält den Getter bereits. Sie entscheidet, wenn ein PropertyChanged-Ereignis eintrifft, ob diese Bindung diejenige ist, die sich geändert hat. Die Frage ist also, was das View Model in dieses Ereignis legt:
public sealed partial class MainViewModel : ObservableObject // CommunityToolkit.Mvvm
{
[ObservableProperty]
private string _greeting = "Ready";
// der Generator erzeugt: set { ...; OnPropertyChanged("Greeting"); } — ein Literal
// oder von Hand, mit demselben Ergebnis:
private int _count;
public int Count
{
get => _count;
set { _count = value; OnPropertyChanged(nameof(Count)); }
}
}
nameof(Count), [CallerMemberName] und der Generator des MVVM Toolkit werden alle zu einem String-Literal in IL aufgelöst — ldstr "Count" — bevor der Obfuskator läuft. Das Umbenennen der Eigenschaft ändert den Metadatennamen und lässt das Literal unangetastet. Der generierte switch vergleicht sein Literal "Greeting" mit dem Literal "Greeting" des Ereignisses, beide unverändert, und die Übereinstimmung hält. Die Bindung funktioniert, die Änderungsbenachrichtigung funktioniert, und die Eigenschaft kann auf einen einzelnen Buchstaben umbenannt werden.
Die einzige Möglichkeit, es zu brechen, ist eine Basisklasse, die PropertyChanged auslöst, indem sie GetType().GetProperties() durchläuft und prop.Name übergibt — ein Laufzeit-Name, der sich tatsächlich ändert. Das ist eine Reflexionsabhängigkeit wie jede andere und benötigt eine Umschreibung oder eine Erhaltungsregel. Das MVVM Toolkit tut das nicht; handgeschriebene Basisklassen manchmal schon.
Das klassische {Binding}: eine Zeichenkette, die die Laufzeit durchläuft
Schreiben Sie {Binding Greeting} statt {x:Bind}, und nichts wird zur Kompilierzeit aufgelöst. Die Bindung speichert den Pfad "Greeting" und fragt beim Setzen des Datenkontexts das Quellobjekt nach einem Member dieses Namens. In einer verwalteten WinUI-3-App geht diese Auflösung über Reflexion (oder, unter Native AOT, über einen generierten [GeneratedBindableCustomProperty]-Anbieter). Nach der Obfuskierung gibt es keinen Member namens Greeting mehr; die Suche liefert nichts, die Bindungs-Engine protokolliert einen Bindungsfehler, und das Steuerelement bleibt leer. Keine Ausnahme. Das Fenster öffnet sich, Ihr Starttest besteht, und der Bildschirm bleibt stillschweigend leer.
Sie können sich mit Erhaltung behelfen — die öffentlichen Eigenschaften jedes View Models beibehalten —, aber das ist die falsche Lösung, denn sie lässt die Abhängigkeit bestehen und die aussagekräftigsten Namen der App im Klartext. Die richtige Lösung besteht darin, die Abhängigkeit zu entfernen, indem Sie auf {x:Bind} migrieren, was den Fehler auch in den Build verlagert: Der XAML-Compiler scheitert an jedem x:Bind-Pfad, den er nicht auflösen kann, sodass eine Bindung, die bei der Umbenennung bräche, nicht kompiliert. Wo Sie wirklich einen spät gebundenen Pfad benötigen — etwa die Bindung an eine dynamische Zeile aus einem Plugin —, erhalten Sie genau die öffentlichen Eigenschaften dieses Typs mit einer gezielten Regel, nicht die gesamte View-Model-Schicht.
Navigation und Aktivierung per Name
Das Muster, das die gesamte App auf einmal umwirft, ist die aus einer Zeichenkette zusammengesetzte Navigation:
// Seitenschlüssel -> Type per Name; üblich in Einstellungen und Shell-Navigation
var pageType = Type.GetType($"MyApp.Views.{key}Page"); // "MyApp.Views.SettingsPage"
rootFrame.Navigate(pageType, argument);
Benennen Sie die Seiten um, und Type.GetType("MyApp.Views.SettingsPage") gibt null zurück — der Typ ist jetzt a.b —, sodass Navigate(null) eine Ausnahme auslöst und jede Navigation über diesen Codepfad stirbt. Die Lösung ist immer dieselbe: Verwandeln Sie die Zeichenkette in ein Token. rootFrame.Navigate(typeof(SettingsPage)) ist ein ldtoken, dem der Umbenenner folgt, und ein Dictionary<string, Type>, das über einen stabilen externen Schlüssel (ein URL-Fragment, einen Einstellungswert) auf typeof(SettingsPage) abgebildet wird, erhält den stabilen Schlüssel, während der Typ umbenannt wird.
Der unverzichtbare Fall ist die im Package.appxmanifest deklarierte Aktivierung. Eine Hintergrundaufgabe, eine App-Erweiterungsklasse, ein Protokollhandler, ein Out-of-Process-COM-Server — jeder wird im Manifest als voll qualifizierte Zeichenkette benannt, und die Plattform konstruiert ihn über die WinRT-Aktivierungsfabrik aus diesem Literal:
<!-- Package.appxmanifest -->
<Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="MyApp.Tasks.SyncTask">
<BackgroundTasks><Task Type="timer" /></BackgroundTasks>
</Extension>
</Extensions>
Nichts in Ihrem IL referenziert MyApp.Tasks.SyncTask; das Betriebssystem tut es, per Name, wenn der Trigger auslöst. Benennen Sie es um, und die Aktivierung scheitert mit einem Fehler „Klasse nicht registriert“, der weit entfernt vom Build auftaucht. Diese Typen müssen ihre Namen behalten und für WinRT sichtbar bleiben — sie sind die einzige Erhaltungsliste, die keine x:Bind-Disziplin beseitigt.
Eine Anmerkung zu den Namen von Abhängigkeitseigenschaften
Es ist verlockend, jede benutzerdefinierte Abhängigkeitseigenschaft zu erhalten, und meist ist das unnötig. DependencyProperty.Register("Title", typeof(string), typeof(MyControl), ...) speichert "Title" als Literal, und das Markup Title="...", das sie setzt, ist ebenfalls ein Literal; die generierten XAML-Typinformationen bilden diesen Namen auf einen per Token referenzierten Setter-Delegaten ab. Beim Umbenennen wird das Token umgeschrieben und die beiden Literale bleiben gleich, sodass die Eigenschaft weiterhin aus dem Markup, aus {x:Bind} und aus einem Storyboard funktioniert, das sie per Namen anspricht — keines davon zieht den Metadatennamen des CLR-Wrappers heran. Die Registrierungszeichenkette muss nicht einmal dem umbenannten Wrapper entsprechen, damit XAML funktioniert. Der Wrapper-Name ist nur dort tragend, wo etwas ihn per Reflexion erreicht: ein klassisches {Binding Title}, ein manuelles GetProperty("Title"), ein Serialisierer. Erhalten Sie ihn dort; ansonsten lassen Sie ihn umbenennen.
Die Nebula-Konfiguration
Mit {x:Bind} anstelle der klassischen Bindungen und der über typeof geführten Navigation wird fast nichts in der App per Name aufgelöst, also ist die Konfiguration kurz:
<Nebula>
<Assembly file="MyApp.dll">
<Rename enabled="true">
<!-- Typen, die das Package.appxmanifest per Zeichenkette über die WinRT-Fabrik aktiviert.
Erhalten Sie ihre Namen und ihre WinRT-Sichtbarkeit; nichts referenziert sie im IL. -->
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
</Rename>
<ControlFlow enabled="true" />
<StringEncryption enabled="true" />
</Assembly>
</Nebula>
Die Zeichenkettenverschlüsselung kann für die gesamte Assembly bedenkenlos aktiviert bleiben. Das Literal "Greeting" im generierten Bindungs-switch und das Literal "Greeting" im OnPropertyChanged des View Models werden jeweils am Verwendungsort entschlüsselt, und der Vergleich läuft über die entschlüsselten Werte — die Bindung sieht dieselben zwei Zeichenketten wie immer.
Wenn Sie die klassischen Bindungen noch nicht losgeworden sind — eine große App mit jahrelangem {Binding} —, ist dies die vorübergehende Regel, genau auf die Oberfläche beschränkt, die die Reflexion berührt, und nichts weiter:
<Rename enabled="true">
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
<!-- NUR VORÜBERGEHEND: das klassische {Binding} durchläuft diese öffentlichen
Eigenschaftsnamen per Reflexion. Erhalten Sie die Eigenschaften; benennen Sie die
Felder, die Backing-Member der Befehle und die Typen um. -->
<Preserve names="true" members="public" baseType="MyApp.ViewModels.ViewModelBase" />
</Rename>
members="public" erhält die Eigenschaftsnamen, die die Bindungs-Engine liest, während es die privaten Felder, die Backing-Member generierter Befehle und alles, was die Engine nie sieht, weiterhin umbenennt. Behandeln Sie den Block als Aufgabenliste: Jede Zeile ist eine zu entfernende Abhängigkeit, und wenn das letzte {Binding} zu einem {x:Bind} wird, verschwindet die Zeile mit ihm.
Das Fazit für die Praxis
Eine moderne WinUI-3-App ist größtenteils umbenennungssicher, bevor Sie irgendetwas konfigurieren, denn {x:Bind} hat die Member-Referenzen in Token kompiliert, und der Obfuskator schreibt Token korrekt um. Ihre Aufgabe ist es, die drei verbleibenden Zeichenketten zu finden — einen klassischen {Binding}-Pfad, ein aus einem Namen zusammengesetztes Type.GetType, einen im Manifest deklarierten Aktivierungstyp — und jede an ihrer Quelle zu behandeln: migrieren Sie die Bindung, damit der Compiler sie abfängt, führen Sie die Navigation über typeof, und erhalten Sie nur die im Manifest benannten Typen. Tun Sie das, und Sie können die Seiten, die View Models und ihre Member auf einzelne Buchstaben einebnen, während jeder Bildschirm weiterhin bindet, aktualisiert und navigiert. Wie immer gilt: Obfuskieren Sie nur Software, die zu schützen Sie berechtigt sind, und lassen Sie den Build — nicht den leeren Bildschirm eines Benutzers — Ihnen sagen, dass eine Bindung gebrochen ist.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.