Ofuscar una aplicación WinUI 3 sin romper el XAML
WinUI 3 compila {x:Bind} a una clase de enlace generada dentro de tu propio ensamblado —una llamada tipada al getter por token de metadatos más una comparación literal de PropertyName—, así que todo el view model se renombra sin problemas. Los fallos que quedan son los tres lugares donde WinUI, o tu propio código, todavía pasa por una cadena: una ruta de {Binding} clásico resuelta por reflexión, una página localizada con Type.GetType a partir de un nombre construido, y un tipo que el Package.appxmanifest activa por su nombre literal. Esta entrada lee el código de enlace generado, muestra por qué {x:Bind} sobrevive a un renombrado completo mientras que {Binding} vuelve vacío, explica qué nombres de propiedades de dependencia personalizadas son realmente críticos, y da la configuración de Nebula que aplana la aplicación sin tocar la superficie que se resuelve por cadenas.
Una guía de ofuscación para WPF no se traslada a WinUI 3, y una de UWP solo se traslada a medias, porque lo que decide qué sobrevive a un renombrado es el compilador de XAML, y el de WinUI 3 se parece más al de Avalonia que al de WPF. WPF compila el XAML a BAML —un grafo de objetos serializado que el runtime instancia por nombre, con las rutas de enlace recorridas por reflexión—. WinUI 3 compila {x:Bind} a C# dentro de tu propio ensamblado: una clase de enlace generada cuyo trabajo es llamar a tus getters directamente e introducir los valores en tus controles. Para cuando Nebula ve el ensamblado, la mayor parte de lo que un ofuscador rompería en WPF ya se ha convertido en tokens de metadatos — y los tokens son justo lo que un renombrador reescribe correctamente.
Así que los fallos que quedan son los lugares donde WinUI, o tu propio código, todavía pasa por una cadena. Hay tres que importan, y conviene ordenarlos por lo rápido que muerden: una ruta de {Binding} clásico vuelve vacía con una línea de log y un control en blanco; una página localizada con Type.GetType sobre un nombre que tú construiste rompe toda navegación que la use; y un tipo que tu Package.appxmanifest activa por su nombre literal no arranca, con un error de clase no registrada que lanza el sistema operativo, no tu código.
En qué compila {x:Bind}
Lee primero el código generado, porque todo el argumento de seguridad depende de qué hay exactamente en él. Una página con un enlace tipado:
<!-- 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>
El compilador de XAML escribe un MainPage.xaml.g.cs que contiene una clase de enlace anidada. Descompilada y limpiada para leerla, la parte que empuja el valor al TextBlock tiene este aspecto:
// Generado en MyApp.dll: MainPage.xaml.g.cs, clase anidada MainPage_obj1_Bindings
private global::MyApp.MainViewModel dataRoot; // la fuente del 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 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 es el TextBlock
}
// seguimiento de cambios para el enlace OneWay:
private void PropertyChanged_ViewModel(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "Greeting":
this.Update_ViewModel_Greeting(this.dataRoot.Greeting, DATA_CHANGED);
break;
// "" o null -> actualiza todas las propiedades rastreadas
}
}
Dos cosas referencian Greeting, y son tipos de referencia distintos. obj.Greeting compila a callvirt instance string MyApp.MainViewModel::get_Greeting() — un token de metadatos. Cuando Nebula renombra get_Greeting a a, reescribe cada token que apunta a él, este incluido, así que el código generado llama al getter renombrado y devuelve el valor correcto. La referencia al propio MainViewModel, y el acceso al campo de obj2, también son tokens, reescritos igual.
La segunda referencia es la cadena "Greeting" en el switch. No se usa para encontrar la propiedad — el método de actualización ya tiene el getter. Decide, cuando llega un evento PropertyChanged, si este enlace es el que cambió. Así que la pregunta es qué pone el view model en ese evento:
public sealed partial class MainViewModel : ObservableObject // CommunityToolkit.Mvvm
{
[ObservableProperty]
private string _greeting = "Ready";
// el generador emite: set { ...; OnPropertyChanged("Greeting"); } — un literal
// o a mano, con el mismo resultado:
private int _count;
public int Count
{
get => _count;
set { _count = value; OnPropertyChanged(nameof(Count)); }
}
}
nameof(Count), [CallerMemberName] y el generador del MVVM Toolkit se resuelven todos a un literal de cadena en IL — ldstr "Count" — antes de que el ofuscador se ejecute. Renombrar la propiedad cambia el nombre de metadatos y deja el literal intacto. El switch generado compara su literal "Greeting" con el literal "Greeting" del evento, ambos sin cambios, y la coincidencia se mantiene. El enlace funciona, la notificación de cambio funciona, y la propiedad puede renombrarse a una sola letra.
La única forma de romperlo es una clase base que emita PropertyChanged enumerando GetType().GetProperties() y pasando prop.Name — un nombre de tiempo de ejecución que sí cambia. Eso es una dependencia de reflexión como cualquier otra, y necesita una reescritura o una regla de conservación. El MVVM Toolkit no hace esto; las bases hechas a mano a veces sí.
El {Binding} clásico: una cadena que el runtime recorre
Escribe {Binding Greeting} en lugar de {x:Bind} y nada se resuelve en tiempo de compilación. El enlace almacena la ruta "Greeting" y, cuando se asigna el contexto de datos, le pide al objeto fuente un miembro de ese nombre. En una aplicación WinUI 3 administrada esa resolución pasa por reflexión (o, bajo Native AOT, por un proveedor [GeneratedBindableCustomProperty] generado). Tras la ofuscación no hay ningún miembro llamado Greeting; la búsqueda no devuelve nada, el motor de enlaces registra un fallo de enlace, y el control queda vacío. Sin excepción. La ventana se abre, tu prueba de arranque pasa, y la pantalla queda silenciosamente en blanco.
Puedes salir del paso con conservación —mantener las propiedades públicas de cada view model— pero es la solución equivocada, porque deja la dependencia en su sitio y los nombres más descriptivos de la aplicación en texto plano. La solución correcta es eliminar la dependencia migrando a {x:Bind}, lo que además traslada el fallo a la compilación: el compilador de XAML da error ante cualquier ruta de x:Bind que no pueda resolver, así que un enlace que se rompería con el renombrado no compila. Donde de verdad necesites una ruta de enlace tardío —enlazar a una fila dinámica de un plugin, por ejemplo— conserva exactamente las propiedades públicas de ese tipo con una regla dirigida, no toda la capa de view models.
Navegación y activación por nombre
El patrón que tumba toda la aplicación de golpe es la navegación construida a partir de una cadena:
// clave de página -> Type por nombre; común en ajustes y navegación de shell
var pageType = Type.GetType($"MyApp.Views.{key}Page"); // "MyApp.Views.SettingsPage"
rootFrame.Navigate(pageType, argument);
Renombra las páginas y Type.GetType("MyApp.Views.SettingsPage") devuelve null — el tipo ahora es a.b — así que Navigate(null) lanza y toda navegación por esta ruta de código muere. La solución es la misma de siempre: convierte la cadena en un token. rootFrame.Navigate(typeof(SettingsPage)) es un ldtoken, que el renombrador sigue, y un Dictionary<string, Type> indexado por una clave externa estable (un fragmento de URL, un valor de ajustes) mapeado a typeof(SettingsPage) conserva la clave estable mientras renombra el tipo.
El caso irreducible es la activación declarada en Package.appxmanifest. Una tarea en segundo plano, una clase de extensión de aplicación, un manejador de protocolo, un servidor COM fuera de proceso — cada uno se nombra en el manifiesto como una cadena completamente cualificada, y la plataforma lo construye a través de la fábrica de activación de WinRT a partir de ese literal:
<!-- Package.appxmanifest -->
<Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="MyApp.Tasks.SyncTask">
<BackgroundTasks><Task Type="timer" /></BackgroundTasks>
</Extension>
</Extensions>
Nada en tu IL referencia MyApp.Tasks.SyncTask; el sistema operativo sí, por nombre, cuando se dispara el trigger. Renómbralo y la activación falla con un error de clase no registrada que aflora muy lejos de la compilación. Esos tipos deben conservar sus nombres y seguir siendo visibles para WinRT — son la única lista de conservación que ninguna disciplina de x:Bind elimina.
Una nota sobre los nombres de las propiedades de dependencia
Es tentador conservar cada propiedad de dependencia personalizada, y suele ser innecesario. DependencyProperty.Register("Title", typeof(string), typeof(MyControl), ...) almacena "Title" como literal, y el marcado Title="..." que la establece también es un literal; la información de tipos XAML generada mapea ese nombre a un delegado setter referenciado por token. Al renombrar, el token se reescribe y los dos literales siguen siendo iguales, así que la propiedad sigue funcionando desde el marcado, desde {x:Bind} y desde un Storyboard que la apunte por nombre — ninguno de los cuales consulta el nombre de metadatos del envoltorio de CLR. La cadena de registro ni siquiera necesita ser igual al envoltorio renombrado para que XAML funcione. El nombre del envoltorio solo es crítico donde algo lo alcanza por reflexión: un {Binding Title} clásico, un GetProperty("Title") manual, un serializador. Consérvalo ahí; si no, déjalo renombrar.
La configuración de Nebula
Con {x:Bind} en lugar de los enlaces clásicos y la navegación encaminada por typeof, casi nada en la aplicación se resuelve por nombre, así que la configuración es corta:
<Nebula>
<Assembly file="MyApp.dll">
<Rename enabled="true">
<!-- Tipos que el Package.appxmanifest activa por cadena, a través de la fábrica de WinRT.
Conserva sus nombres y su visibilidad WinRT; nada los referencia en IL. -->
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
</Rename>
<ControlFlow enabled="true" />
<StringEncryption enabled="true" />
</Assembly>
</Nebula>
El cifrado de cadenas es seguro de dejar activado para todo el ensamblado. El literal "Greeting" del switch de enlace generado y el literal "Greeting" del OnPropertyChanged del view model se descifran cada uno en el punto de uso, y la comparación se ejecuta sobre los valores descifrados — el enlace ve las mismas dos cadenas que siempre.
Si aún no te has librado de los enlaces clásicos —una aplicación grande con años de {Binding}— esta es la regla provisional, acotada exactamente a la superficie que la reflexión toca y nada más:
<Rename enabled="true">
<Preserve names="true" members="false" type="MyApp.Tasks.SyncTask" />
<!-- SOLO PROVISIONAL: el {Binding} clásico recorre estos nombres de propiedad pública por
reflexión. Conserva las propiedades; renombra los campos, los miembros de respaldo de
los comandos y los tipos. -->
<Preserve names="true" members="public" baseType="MyApp.ViewModels.ViewModelBase" />
</Rename>
members="public" conserva los nombres de propiedad que el motor de enlaces lee mientras sigue renombrando los campos privados, los miembros de respaldo de los comandos generados y todo lo que el motor nunca ve. Trata el bloque como una lista de tareas: cada línea es una dependencia a eliminar, y cuando el último {Binding} se convierte en un {x:Bind}, la línea desaparece con él.
La conclusión práctica
Una aplicación WinUI 3 moderna es mayormente segura ante el renombrado antes de que configures nada, porque {x:Bind} compiló las referencias a miembros en tokens y el ofuscador reescribe tokens correctamente. Tu trabajo es encontrar las tres cadenas restantes —una ruta de {Binding} clásico, un Type.GetType construido a partir de un nombre, un tipo de activación declarado en el manifiesto— y tratar cada una en su origen: migra el enlace para que el compilador lo detecte, encamina la navegación por typeof, y conserva solo los tipos nombrados en el manifiesto. Hazlo y podrás aplanar las páginas, los view models y sus miembros a letras sueltas mientras cada pantalla sigue enlazando, actualizándose y navegando. Como siempre, ofusca solo software que tengas derecho a proteger, y deja que sea la compilación —no la pantalla en blanco de un usuario— lo que te diga que un enlace se rompió.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.