Cómo el renombrado rompe los parámetros de componentes Blazor
Una app Blazor Hybrid envía su ensamblado de componentes a la máquina del usuario, así que vale la pena ofuscarla, pero un componente pasa sus parámetros a través de un árbol de render indexado por nombre, no por una llamada a método. Este artículo lee el BuildRenderTree generado por Razor para mostrar que cada nombre de [Parameter] viaja como un literal de cadena que el renderizador resolve por reflexión, por lo que renombrar uno lanza una excepción en el primer render, y luego acota Nebula para conservar esos nombres y ofuscar todo lo demás.
Una app Blazor Server no tiene nada que proteger en el cliente: el ensamblado se ejecuta en tu servidor y el navegador solo ve HTML. Una app Blazor Hybrid es lo contrario. Cuando alojas un BlazorWebView dentro de un contenedor .NET MAUI, WPF o WinForms, tus componentes Razor se compilan en un ensamblado gestionado normal que se envía a la máquina del usuario, donde un descompilador lo lee como cualquier otro binario de escritorio. Esa es una buena razón para ofuscarlo. También es donde la gente se lleva una sorpresa, porque un componente Blazor no pasa sus parámetros como un método pasa sus argumentos. Los pasa por nombre, a través de un árbol de render, y los nombres son cadenas.
La pregunta de verdad
Renombra un ensamblado y la pregunta honesta es siempre la misma: ¿qué nombres resuelve el runtime por su cadena, y cuáles ya cableó el compilador como una referencia directa por token? Para la mayoría del C# la respuesta es “tokens”: una llamada a método es una referencia a MethodDef, un acceso a campo es un FieldDef, y el renombrado reescribe tanto la definición como cada referencia a la vez. Los parámetros de componente son la excepción. El compilador de Razor baja <Counter IncrementBy="@step" /> a código que nombra el parámetro con un literal de cadena, y el renderizador empareja esa cadena contra las propiedades del hijo por reflexión. Acierta esa distinción y una app Blazor Hybrid se ofusca tan fuerte como cualquier otra; fállala y la app lanza una excepción en el primer render.
Lo que emite el compilador de Razor
Toma un componente trivial y el padre que lo usa.
@* Counter.razor *@
<p>Count: @Current</p>
@code {
[Parameter] public int IncrementBy { get; set; } = 1;
[Parameter] public EventCallback<int> OnChanged { get; set; }
private int Current;
}
@* Parent.razor *@
<Counter IncrementBy="5" OnChanged="Handle" />
@code {
private void Handle(int v) { /* ... */ }
}
El compilador de Razor convierte cada archivo .razor en una clase de C# con un método BuildRenderTree. El del padre, recortado a lo que importa, es este:
protected override void BuildRenderTree(RenderTreeBuilder __builder)
{
__builder.OpenComponent<MyApp.Components.Counter>(0);
__builder.AddComponentParameter(1, "IncrementBy", 5);
__builder.AddComponentParameter(2, "OnChanged",
EventCallback.Factory.Create<int>(this, Handle));
__builder.CloseComponent();
}
(En .NET 7 y anteriores esto era AddAttribute en lugar de AddComponentParameter; el argumento de cadena es idéntico.) Ahora viven dos clases de nombre en este IL, y el renombrado las trata de forma opuesta.
Cadenas frente a tokens
OpenComponent<MyApp.Components.Counter>(0) lleva el tipo Counter como argumento de tipo genérico —un token de metadatos, emitido por la fontanería de ldtoken/typeof que el JIT resuelve al TypeDef—. Renombra Counter a a y Nebula reescribe la fila y esta referencia a la vez; el componente sigue abriéndose. El nombre del tipo de componente es libre.
Los nombres de parámetro no lo son. "IncrementBy" y "OnChanged" son constantes de cadena de usuario: simples cargas ldstr en el montículo #US:
IL_0007: ldstr "IncrementBy"
IL_000c: ldc.i4.5
IL_000d: box [System.Private.CoreLib]System.Int32
IL_0012: callvirt instance void RenderTreeBuilder::AddComponentParameter(int32, string, object)
Nada en ese ldstr le dice al ofuscador que nombra una propiedad. Nebula renombra metadatos —nombres de tipo, método, campo y propiedad en las tablas— y actualiza las referencias por token a ellos. No reescribe literales de cadena arbitrarios para perseguir un renombrado, porque no puede saber que el texto "IncrementBy" pretende ser igual a un nombre de propiedad y no, por ejemplo, un mensaje de log. Así que la cadena sigue siendo "IncrementBy" mientras la propiedad a la que debía apuntar se convierte en a.
Lo que ocurre a continuación es el meollo. Cuando el renderizador instancia Counter, le entrega al componente un ParameterView construido a partir de esos atributos con nombre y llama a SetParametersAsync, cuya implementación por defecto llama a ComponentProperties.SetProperties. Ese método mantiene una caché por tipo —un Dictionary<string, IPropertySetter> construido una vez por reflexión sobre las propiedades del componente e indexado por el nombre de cada propiedad [Parameter]—. Tras la ofuscación ese diccionario tiene una clave "a". El atributo entrante se llama "IncrementBy". No hay coincidencia, y Blazor no lo pasa por alto:
System.InvalidOperationException: Object of type 'MyApp.Components.Counter'
does not have a property matching the name 'IncrementBy'.
A diferencia de un binding de WPF —que registra un error de ruta y deja el control en su valor de reserva— esto lanza una excepción en el primer render del componente. Eso es un regalo: el fallo es ruidoso e inmediato.
Así que la keep-list es específica: cada nombre de propiedad [Parameter] y [CascadingParameter], los nombres de parámetro EventCallback generados, ChildContent y cualquier otro slot RenderFragment, y el par Value/ValueChanged al que expande @bind-Value. Todo lo demás que declara el componente —los campos y métodos privados de @code, los propios tipos de componente, un [CascadingParameter] sin nombre emparejado por tipo— se referencia por token y se renombra sin efecto sobre el renderizado.
Acotar Nebula
El propio analizador de Blazor exige que cada propiedad [Parameter] sea pública, así que los nombres que debes conservar son exactamente la superficie pública de tus tipos de componente. Eso es una única regla de keep acotada. Pon un componente Counter.razor bajo un espacio de nombres Components y:
{
"schemaVersion": 1,
"inputs": ["bin/Release/net8.0/MyApp.dll"],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "MyApp.Components.*", "action": "keep", "members": "public" },
{ "pattern": "MyApp.*", "action": "rename" }
]
}
}
La primera regla conserva los nombres de parámetro públicos de cada componente, mientras que members: "public" deja que el campo privado Current, el método Handle y el propio nombre del tipo del componente se renombren. La segunda renombra todo lo demás: tus servicios, tu lógica de dominio, tus comprobaciones de licencia. El keep es solo de nombre: los componentes conservados siguen recibiendo ofuscación de flujo de control en sus cuerpos de método y cifrado de sus literales de cadena. Renuncias al renombrado de un puñado de nombres de parámetro, no a la protección del código que hay detrás.
Si prefieres fijar los nombres en el código fuente para que viajen con un refactor, el paquete de anotaciones de Nebula 2.2.0 lo hace por miembro: [Keep] sobre una propiedad de parámetro conserva solo ese nombre y deja que el resto del componente se renombre, y el atributo se elimina de la salida protegida, así que no añade dependencia en runtime:
using Nebula.Annotations;
[Parameter, Keep] public int IncrementBy { get; set; } = 1;
Advertencias y cuándo se rompe
El fallo ruidoso cubre el caso común, pero tres bordes son más silenciosos. Primero, la cobertura: un componente que solo se renderiza detrás de una pantalla que tu smoke test nunca abre no lanzará nada hasta que un usuario llegue ahí, así que la prueba de aceptación honesta ejercita cada componente al menos una vez contra el build protegido, no el de depuración. Segundo, la interop con JS: un método [JSInvokable] se llama desde JavaScript por su nombre de método, así que ese nombre es un contrato de cadena: consérvalo, y conserva el tipo si JS también lo resuelve por nombre. Tercero, DynamicComponent: <DynamicComponent Type="@t" /> donde t se produjo a partir de una cadena con un nombre de tipo se resuelve por nombre y el tipo destino debe conservarse; donde t vino de typeof(...) es un token y se renombra libremente.
Y el encuadre que subyace a todo: esto trata de proteger la PI de tu propia aplicación. Conserva los nombres que el árbol de render resuelve por cadena; ofusca los componentes y la lógica que hay detrás.
Conclusión
Un componente Blazor pasa sus parámetros a través de un árbol de render indexado por nombre, así que cada nombre [Parameter] vive en tu ensamblado como un literal de cadena que el renderizador empareja por reflexión, y renombrarlo lanza una excepción en el primer render en lugar de fallar en silencio. Los tipos de componente, los miembros privados de @code y los parámetros en cascada sin nombre se cablean por token y se renombran gratis. Un keep members: "public" sobre el espacio de nombres de tus componentes traza exactamente esa línea, y por eso ofuscar una app Blazor Hybrid es un problema de alcance, no una razón para dejar en texto claro el ensamblado que envías. Nebula.NET conserva el contrato de parámetros y ofusca todo lo que hay detrás; abre el resultado en Glass.NET para confirmar que tus nombres de parámetro sobrevivieron mientras los internos del componente se leen como a, b, c.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.