Mantener vivos los pack URI de WPF tras la ofuscación
WPF compila tu XAML en BAML dentro de un flujo de recursos con el nombre del ensamblado, y los pack URI fijan ese nombre — así que renombrar lo que no debes rompe cada ventana. Aquí tienes cómo Nebula.NET protege una app WPF sin cortar esos enlaces.
Una app WPF que funciona a la perfección en Debug puede lanzar IOException: Cannot locate resource 'views/mainwindow.xaml' la primera vez que arrancas su build ofuscado — antes de que se ejecute una sola línea de tu view-model. La ventana nunca se abre. Nada en tus enlaces XAML está mal, y preservePublicApi está activado. El fallo está un nivel por debajo de la capa de enlace donde se detiene la mayoría de los consejos de ofuscación de WPF: está en cómo WPF almacena y encuentra tu marcado compilado.
El consejo general — mantener nombrados los miembros enlazados para que {Binding CustomerName} resuelva — es necesario pero no suficiente. El XAML no se interpreta en tiempo de ejecución; se compila a BAML y se incrusta en un flujo de recursos cuyo nombre y referencias internas están acopladas a tu ensamblado de formas que un renombrador puede cortar sin ruido. Este artículo es el mecanismo: dónde vive realmente tu XAML en la DLL distribuida, qué nombres fija el runtime, y cómo Nebula.NET ofusca las entrañas con fuerza dejando esos enlaces intactos.
A dónde va tu XAML
Cuando compilas un proyecto WPF, cada archivo .xaml con la acción de compilación Page se compila a BAML — una forma binaria tokenizada del marcado — y todos esos flujos se empaquetan en un único recurso administrado con el nombre del ensamblado: MyApp.g.resources. Dentro de él, cada ventana o control se identifica por su ruta relativa al proyecto en minúsculas con extensión .baml, por ejemplo views/mainwindow.baml.
La mitad generada de tu clase de ventana alcanza ese flujo mediante un pack URI:
// MainWindow.g.cs — generado, normalmente oculto
public void InitializeComponent()
{
if (_contentLoaded) return;
_contentLoaded = true;
var uri = new Uri("/MyApp;component/views/mainwindow.xaml", UriKind.Relative);
Application.LoadComponent(this, uri);
}
Esa única cadena URI carga dos nombres cruciales. MyApp es el nombre corto del ensamblado — WPF convierte ;component en una búsqueda de MyApp.g.resources. views/mainwindow.xaml es la ruta del recurso, que WPF mapea a la entrada views/mainwindow.baml dentro de ese flujo. La misma forma aparece en todas partes donde el XAML referencia otro recurso:
<!-- App.xaml: merge a theme dictionary -->
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="pack://application:,,,/MyApp;component/Themes/Colors.xaml"/>
</ResourceDictionary.MergedDictionaries>
<!-- An image shipped with Build Action = Resource -->
<Image Source="pack://application:,,,/Images/logo.png"/>
Cada uno de estos resuelve a través de las mismas dos coordenadas: el nombre corto del ensamblado y una ruta de recurso. Renombra cualquiera de las dos sin actualizar la otra y la resolución falla.
Las tres formas en que la ofuscación lo rompe
Renombrar el ensamblado. Esta es la trampa clásica. Si tu herramienta renombra el ensamblado de salida — o fijas un AssemblyName distinto para el build protegido — el flujo pasa a ser Protected.g.resources mientras el pack URI sigue diciendo /MyApp;component/. WPF busca un flujo que ya no existe y falla en el arranque. La regla es simple: no renombres el nombre del ensamblado WPF. Ofusca todo dentro de él; deja en paz la identidad del ensamblado.
Renombrar tipos sin reescribir el BAML. Un flujo BAML no son bytes opacos. Comienza con una tabla de ensamblados y una tabla de tipos que nombran el tipo x:Class, cada tipo de elemento instanciado en el marcado y las propiedades asignadas sobre ellos. En tiempo de carga, WPF lee esos nombres y enlaza el flujo con tu code-behind MyApp.Views.MainWindow y sus miembros. Renombra ese tipo en los metadatos del IL pero deja el registro BAML apuntando a la cadena antigua, y el cargador no podrá conectar la ventana con su clase — obtendrás una XamlParseException o un code-behind nulo.
Cifrar lo que WPF tiene que leer como texto. Las rutas de recurso dentro de los pack URI y las claves de recurso x:Key dentro del BAML las consume el subsistema de XAML/recursos, no tu código. No son instrucciones ldstr que un paso de cifrado de cadenas vería, así que el cifrado de cadenas normal no las toca — pero cualquier mangling personalizado del nombre de recurso que sí lo hiciera rompería la resolución.
Qué hace Nebula.NET por ti
Nebula.NET reconoce un ensamblado WPF (lleva el flujo .g.resources y una huella ThemeInfo/XmlnsDefinition) y trata el BAML como metadatos de primera clase en lugar de un blob inerte:
- Preserva el nombre corto del ensamblado y el nombre del flujo
.g.resources, para que cada pack URI;componenty cada llamada aApplication.LoadComponentsigan resolviendo. - Analiza y reescribe las tablas de tipos y ensamblados del BAML en sincronía con el mapa de renombrado. Cuando un tipo referenciado desde el marcado se renombra en los metadatos, su registro BAML se reescribe al mismo nombre nuevo — el marcado y el IL renombrado quedan coherentes, exactamente como la renumeración de tokens mantiene coherentes los operandos de
callyldstrtras una reconstrucción de metadatos. - Deja en paz las rutas de recurso y las cadenas
x:Key, porque son direcciones que WPF resuelve, no secretos.
La configuración práctica es la misma superficie mínima y segura que usarías para cualquier app WPF, más la intención explícita de conservar los recursos intactos:
{
"inputs": ["bin/Release/net8.0/MyApp.dll"],
"outputDirectory": "protected",
"preservePublicApi": true,
"preserveResources": true,
"controlFlowObfuscation": true,
"encryptStrings": true
}
preserveResources mantiene direccionables los nombres de flujo y los archivos de recurso sueltos; preservePublicApi mantiene nombrados los miembros del view-model enlazados para que {Binding} siga resolviendo. Todo lo que el marcado no nombra — tus servicios, algoritmos, miembros privados — se renombra, se aplana y se cifran sus cadenas con toda la fuerza. El valor vive en el código detrás de la ventana, y eso es exactamente lo que queda protegido.
Controles personalizados y temas
Una biblioteca de controles reutilizable tiene un acoplamiento extra: el atributo [assembly: ThemeInfo] le dice a WPF que busque /themes/generic.baml para los estilos por defecto, y la DefaultStyleKey de cada control es su propio Type. Como Nebula preserva el flujo de recursos y reescribe la tabla de tipos del BAML de forma coherente, Themes/Generic.xaml sigue cargándose y los estilos por defecto siguen enlazando — pero es la pantalla más importante que revisar tras la protección, ya que un tema ausente falla visualmente en lugar de con una excepción dura.
Verifica que realmente carga
Los problemas de BAML afloran en la carga, no en la compilación, así que la prueba es ejecutar el build protegido y abrir cada ventana — especialmente los controles con plantilla personalizada y cualquier ResourceDictionary fusionado desde otro ensamblado. Si una ventana lanza una excepción, lee el mensaje: Cannot locate resource apunta a un desajuste de nombre de flujo o ruta de recurso, mientras que una XamlParseException que nombra un tipo apunta a una reescritura de la tabla de tipos del BAML que no ocurrió.
También puedes inspeccionar el artefacto distribuido directamente. Abre la DLL protegida en Glass.NET y mira los recursos administrados: confirma que el flujo <AssemblyName>.g.resources está presente bajo el nombre de ensamblado sin cambios y que sus entradas BAML siguen llevando las rutas esperadas. Para una comprobación más profunda, extrae un flujo BAML y confirma que su tabla de tipos nombra los tipos renombrados — esa es la prueba de que el marcado y los metadatos coinciden. Automatizar esa comprobación en CI sigue el mismo patrón que cualquier otra puerta de ofuscación: proteger, y luego afirmar que el flujo de recursos existe y que la prueba de humo de la app abre cada ventana. Consulta Verificar la ofuscación en CI para el arnés.
La versión corta
- WPF distribuye tu XAML como BAML dentro de
<AssemblyName>.g.resources, y los pack URI fijan el nombre corto del ensamblado y la ruta del recurso. - Nunca renombres el nombre del ensamblado WPF — está incrustado en cada URI
;componenty en el nombre del flujo de recursos. - Renombrar tipos está bien si la tabla de tipos del BAML se reescribe con ellos; Nebula.NET lo hace en sincronía con el mapa de renombrado.
- Mantén
preserveResourcesypreservePublicApiactivados, y luego ofusca las entrañas con fuerza — ahí es donde está el valor. - Prueba arrancando y abriendo cada ventana, y verifica el flujo de recursos con Glass.NET.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.