Obfusquer une application WinUI 3 sans casser le XAML
WinUI 3 compile {x:Bind} en une classe de liaison générée dans votre propre assembly — un appel typé au getter par jeton de métadonnées plus une comparaison littérale de PropertyName —, de sorte que tout le view model se renomme proprement. Les défaillances qui subsistent sont les trois endroits où WinUI, ou votre propre code, passe encore par une chaîne : un chemin de {Binding} classique résolu par réflexion, une page localisée par Type.GetType à partir d'un nom construit, et un type que le Package.appxmanifest active par son nom littéral. Cet article lit le code de liaison généré, montre pourquoi {x:Bind} survit à un renommage complet alors que {Binding} revient vide, explique quels noms de propriétés de dépendance personnalisées sont réellement critiques, et donne la configuration Nebula qui aplatit l'application sans toucher à la surface résolue par chaînes.
Un guide d”obfuscation pour WPF ne se transpose pas à WinUI 3, et un guide UWP ne s”y transpose qu”à moitié, car ce qui décide de ce qui survit à un renommage, c”est le compilateur XAML, et celui de WinUI 3 est plus proche de celui d”Avalonia que de celui de WPF. WPF compile le XAML en BAML — un graphe d”objets sérialisé que le runtime instancie par nom, les chemins de liaison étant parcourus par réflexion. WinUI 3 compile {x:Bind} en C# dans votre propre assembly : une classe de liaison générée dont le rôle est d”appeler vos getters directement et de pousser les valeurs dans vos contrôles. Au moment où Nebula voit l”assembly, la plus grande partie de ce qu”un obfuscateur casserait dans WPF a déjà été transformée en jetons de métadonnées — et les jetons sont précisément ce qu”un renommeur réécrit correctement.
Les défaillances qui subsistent sont donc les endroits où WinUI, ou votre propre code, passe encore par une chaîne. Il y en a trois qui comptent, et il vaut la peine de les classer selon la rapidité avec laquelle elles mordent : un chemin de {Binding} classique revient vide avec une ligne de log et un contrôle vierge ; une page localisée par Type.GetType sur un nom que vous avez construit casse toute navigation qui l”emprunte ; et un type que votre Package.appxmanifest active par son nom littéral ne démarre pas, avec une erreur de classe non enregistrée que lève le système d”exploitation, pas votre code.
En quoi {x:Bind} se compile
Lisez d”abord le code généré, car tout l”argument de sûreté dépend de ce qu”il contient exactement. Une page avec une liaison typée :
<!-- 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>
Le compilateur XAML écrit un MainPage.xaml.g.cs contenant une classe de liaison imbriquée. Décompilée et nettoyée pour la lecture, la partie qui pousse la valeur dans le TextBlock ressemble à ceci :
// Généré dans MyApp.dll : MainPage.xaml.g.cs, classe imbriquée MainPage_obj1_Bindings
private global::MyApp.MainViewModel dataRoot; // la source du x:Bind (this.ViewModel)
private void Update_(global::MyApp.MainViewModel obj, int phase)
{
if (obj != null)
this.Update_ViewModel_Greeting(obj.Greeting, phase); // callvirt get_Greeting() — un jeton
}
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 est le TextBlock
}
// suivi des changements pour la liaison OneWay :
private void PropertyChanged_ViewModel(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "Greeting":
this.Update_ViewModel_Greeting(this.dataRoot.Greeting, DATA_CHANGED);
break;
// "" ou null -> mettre à jour toutes les propriétés suivies
}
}
Deux éléments référencent Greeting, et ce sont des types de référence différents. obj.Greeting se compile en callvirt instance string MyApp.MainViewModel::get_Greeting() — un jeton de métadonnées. Quand Nebula renomme get_Greeting en a, il réécrit chaque jeton qui pointe dessus, celui-ci compris, de sorte que le code généré appelle le getter renommé et renvoie la bonne valeur. La référence au MainViewModel lui-même, et l”accès au champ sur obj2, sont aussi des jetons, réécrits de la même façon.
La seconde référence est la chaîne "Greeting" dans le switch. Elle ne sert pas à trouver la propriété — la méthode de mise à jour détient déjà le getter. Elle décide, lorsqu”un événement PropertyChanged arrive, si cette liaison est celle qui a changé. La question est donc de savoir ce que le view model met dans cet événement :
public sealed partial class MainViewModel : ObservableObject // CommunityToolkit.Mvvm
{
[ObservableProperty]
private string _greeting = "Ready";
// le générateur émet : set { ...; OnPropertyChanged("Greeting"); } — un littéral
// ou à la main, avec le même résultat :
private int _count;
public int Count
{
get => _count;
set { _count = value; OnPropertyChanged(nameof(Count)); }
}
}
nameof(Count), [CallerMemberName] et le générateur du MVVM Toolkit se résolvent tous en un littéral de chaîne en IL — ldstr "Count" — avant que l”obfuscateur ne s”exécute. Renommer la propriété change le nom de métadonnées et laisse le littéral intact. Le switch généré compare son littéral "Greeting" avec le littéral "Greeting" de l”événement, tous deux inchangés, et la correspondance tient. La liaison fonctionne, la notification de changement fonctionne, et la propriété peut être renommée en une seule lettre.
La seule façon de le casser est une classe de base qui lève PropertyChanged en énumérant GetType().GetProperties() et en passant prop.Name — un nom d”exécution qui, lui, change. C”est une dépendance à la réflexion comme une autre, et elle nécessite une réécriture ou une règle de conservation. Le MVVM Toolkit ne fait pas cela ; les bases écrites à la main le font parfois.
Le {Binding} classique : une chaîne que le runtime parcourt
Écrivez {Binding Greeting} au lieu de {x:Bind} et rien n”est résolu à la compilation. La liaison stocke le chemin "Greeting" et, lorsque le contexte de données est affecté, demande à l”objet source un membre de ce nom. Dans une application WinUI 3 managée, cette résolution passe par la réflexion (ou, sous Native AOT, par un fournisseur [GeneratedBindableCustomProperty] généré). Après l”obfuscation, il n”existe plus de membre nommé Greeting ; la recherche ne renvoie rien, le moteur de liaison journalise un échec de liaison, et le contrôle reste vide. Aucune exception. La fenêtre s”ouvre, votre test de démarrage passe, et l”écran reste silencieusement vierge.
Vous pouvez vous en sortir par la conservation — garder les propriétés publiques de chaque view model — mais c”est la mauvaise solution, car elle laisse la dépendance en place et les noms les plus descriptifs de l”application en clair. La bonne solution est de supprimer la dépendance en migrant vers {x:Bind}, ce qui déplace aussi la défaillance vers la build : le compilateur XAML échoue sur tout chemin de x:Bind qu”il ne peut résoudre, donc une liaison qui casserait au renommage ne compile pas. Là où vous avez réellement besoin d”un chemin à liaison tardive — lier à une ligne dynamique issue d”un plugin, par exemple — conservez exactement les propriétés publiques de ce type avec une règle ciblée, pas toute la couche des view models.
Navigation et activation par nom
Le motif qui fait tomber toute l”application d”un coup est la navigation construite à partir d”une chaîne :
// clé de page -> Type par nom ; courant dans les réglages et la navigation du shell
var pageType = Type.GetType($"MyApp.Views.{key}Page"); // "MyApp.Views.SettingsPage"
rootFrame.Navigate(pageType, argument);
Renommez les pages et Type.GetType("MyApp.Views.SettingsPage") renvoie null — le type est désormais a.b — donc Navigate(null) lève une exception et toute navigation par ce chemin de code meurt. La solution est toujours la même : transformez la chaîne en jeton. rootFrame.Navigate(typeof(SettingsPage)) est un ldtoken, que le renommeur suit, et un Dictionary<string, Type> indexé par une clé externe stable (un fragment d”URL, une valeur de réglage) mappée vers typeof(SettingsPage) conserve la clé stable tout en renommant le type.
Le cas irréductible est l”activation déclarée dans Package.appxmanifest. Une tâche en arrière-plan, une classe d”extension d”application, un gestionnaire de protocole, un serveur COM hors processus — chacun est nommé dans le manifeste par une chaîne pleinement qualifiée, et la plateforme le construit via la fabrique d”activation WinRT à partir de ce littéral :
<!-- Package.appxmanifest -->
<Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="MyApp.Tasks.SyncTask">
<BackgroundTasks><Task Type="timer" /></BackgroundTasks>
</Extension>
</Extensions>
Rien dans votre IL ne référence MyApp.Tasks.SyncTask ; le système d”exploitation, lui, le fait, par nom, quand le déclencheur se déclenche. Renommez-le et l”activation échoue avec une erreur de classe non enregistrée qui apparaît très loin de la build. Ces types doivent conserver leurs noms et rester visibles pour WinRT — ils sont la seule liste de conservation qu”aucune discipline de x:Bind ne supprime.
Une note sur les noms des propriétés de dépendance
Il est tentant de préserver chaque propriété de dépendance personnalisée, et c”est généralement inutile. DependencyProperty.Register("Title", typeof(string), typeof(MyControl), ...) stocke "Title" comme littéral, et le balisage Title="..." qui l”affecte est aussi un littéral ; les informations de type XAML générées mappent ce nom vers un délégué setter référencé par jeton. Au renommage, le jeton est réécrit et les deux littéraux restent égaux, donc la propriété continue de fonctionner depuis le balisage, depuis {x:Bind} et depuis un Storyboard qui la cible par nom — aucun de ceux-ci ne consulte le nom de métadonnées de l”enveloppe CLR. La chaîne d”enregistrement n”a même pas besoin d”être égale à l”enveloppe renommée pour que XAML fonctionne. Le nom de l”enveloppe n”est critique que là où quelque chose l”atteint par réflexion : un {Binding Title} classique, un GetProperty("Title") manuel, un sérialiseur. Conservez-le là ; sinon, laissez-le être renommé.
La configuration Nebula
Avec {x:Bind} à la place des liaisons classiques et la navigation acheminée par typeof, presque rien dans l”application n”est résolu par nom, donc la configuration est courte :
<Nebula>
<Assembly file="MyApp.dll">
<Rename enabled="true">
<!-- Types que le Package.appxmanifest active par chaîne, via la fabrique WinRT.
Conservez leurs noms et leur visibilité WinRT ; rien ne les référence en IL. -->
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
</Rename>
<ControlFlow enabled="true" />
<StringEncryption enabled="true" />
</Assembly>
</Nebula>
Le chiffrement des chaînes peut rester activé sans risque pour tout l”assembly. Le littéral "Greeting" du switch de liaison généré et le littéral "Greeting" du OnPropertyChanged du view model sont chacun déchiffrés au point d”utilisation, et la comparaison s”exécute sur les valeurs déchiffrées — la liaison voit les deux mêmes chaînes qu”auparavant.
Si vous n”êtes pas encore débarrassé des liaisons classiques — une grande application avec des années de {Binding} — voici la règle provisoire, limitée exactement à la surface que la réflexion touche et rien de plus :
<Rename enabled="true">
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
<!-- PROVISOIRE SEULEMENT : le {Binding} classique parcourt ces noms de propriété publique
par réflexion. Conservez les propriétés ; renommez les champs, les membres de support
des commandes et les types. -->
<Preserve names="true" members="public" baseType="MyApp.ViewModels.ViewModelBase" />
</Rename>
members="public" conserve les noms de propriété que le moteur de liaison lit tout en continuant de renommer les champs privés, les membres de support des commandes générées et tout ce que le moteur ne voit jamais. Traitez ce bloc comme une liste de tâches : chaque ligne est une dépendance à supprimer, et quand le dernier {Binding} devient un {x:Bind}, la ligne disparaît avec lui.
À retenir en pratique
Une application WinUI 3 moderne est en grande partie sûre face au renommage avant même toute configuration, car {x:Bind} a compilé les références aux membres en jetons et l”obfuscateur réécrit les jetons correctement. Votre travail consiste à trouver les trois chaînes restantes — un chemin de {Binding} classique, un Type.GetType construit à partir d”un nom, un type d”activation déclaré dans le manifeste — et à traiter chacune à sa source : migrez la liaison pour que le compilateur la détecte, acheminez la navigation par typeof, et ne conservez que les types nommés dans le manifeste. Faites cela et vous pourrez aplatir les pages, les view models et leurs membres en lettres uniques pendant que chaque écran continue de lier, de se mettre à jour et de naviguer. Comme toujours, n”obfusquez que du logiciel que vous avez le droit de protéger, et laissez la build — et non l”écran vierge d”un utilisateur — vous dire qu”une liaison a cassé.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.