Comment le renommage casse les paramètres de composants Blazor
Une app Blazor Hybrid livre son assembly de composants sur la machine de l'utilisateur, elle mérite donc d'être obfusquée, mais un composant transmet ses paramètres via un arbre de rendu indexé par nom, pas par un appel de méthode. Cet article lit le BuildRenderTree généré par Razor pour montrer que chaque nom de [Parameter] voyage comme une chaîne littérale que le moteur de rendu résout par réflexion, de sorte que renommer l'un d'eux lève une exception au premier rendu, puis il cadre Nebula pour conserver ces noms et obfusquer tout le reste.
Une app Blazor Server n”a rien à protéger côté client : l”assembly s”exécute sur votre serveur et le navigateur ne voit que du HTML. Une app Blazor Hybrid est l”inverse. Quand vous hébergez un BlazorWebView dans une coquille .NET MAUI, WPF ou WinForms, vos composants Razor se compilent dans un assembly managé ordinaire livré sur la machine de l”utilisateur, où un décompilateur le lit comme tout autre binaire de bureau. C”est une bonne raison de l”obfusquer. C”est aussi là que l”on se fait surprendre, car un composant Blazor ne transmet pas ses paramètres comme une méthode transmet ses arguments. Il les transmet par nom, à travers un arbre de rendu, et les noms sont des chaînes.
La vraie question
Renommez un assembly et la question honnête est toujours la même : quels noms le runtime résout-il par leur chaîne, et lesquels le compilateur a-t-il déjà câblés comme une référence directe par token ? Pour la plupart du C#, la réponse est « des tokens » : un appel de méthode est une référence MethodDef, un accès à un champ un FieldDef, et le renommage réécrit à la fois la définition et chaque référence ensemble. Les paramètres de composant sont l”exception. Le compilateur Razor abaisse <Counter IncrementBy="@step" /> en code qui nomme le paramètre avec une chaîne littérale, et le moteur de rendu associe cette chaîne aux propriétés de l”enfant par réflexion. Réussissez cette distinction et une app Blazor Hybrid s”obfusque aussi fort que n”importe quelle autre ; ratez-la et l”app lève une exception au premier rendu.
Ce que le compilateur Razor émet
Prenez un composant trivial et le parent qui l”utilise.
@* 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) { /* ... */ }
}
Le compilateur Razor transforme chaque fichier .razor en une classe C# dotée d”une méthode BuildRenderTree. Celle du parent, réduite à l”essentiel, est la suivante :
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();
}
(Sur .NET 7 et antérieur, c”était AddAttribute plutôt que AddComponentParameter ; l”argument chaîne est identique.) Deux sortes de noms vivent désormais dans cet IL, et le renommage les traite de façon opposée.
Chaînes contre tokens
OpenComponent<MyApp.Components.Counter>(0) porte le type Counter comme argument de type générique — un token de métadonnées, émis par la plomberie ldtoken/typeof que le JIT résout vers le TypeDef. Renommez Counter en a et Nebula réécrit la ligne et cette référence ensemble ; le composant s”ouvre toujours. Le nom du type de composant est libre.
Les noms de paramètre ne le sont pas. "IncrementBy" et "OnChanged" sont des constantes de chaîne utilisateur : de simples chargements ldstr dans le tas #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)
Rien dans ce ldstr ne dit à l”obfuscateur qu”il nomme une propriété. Nebula renomme des métadonnées — noms de type, de méthode, de champ et de propriété dans les tables — et met à jour les références par token vers eux. Il ne réécrit pas des chaînes littérales arbitraires pour suivre un renommage, car il ne peut pas savoir que le texte "IncrementBy" est censé égaler un nom de propriété plutôt que, disons, un message de log. La chaîne reste donc "IncrementBy" tandis que la propriété qu”elle devait atteindre devient a.
Ce qui se passe ensuite est le nœud du problème. Quand le moteur de rendu instancie Counter, il remet au composant un ParameterView construit à partir de ces attributs nommés et appelle SetParametersAsync, dont l”implémentation par défaut appelle ComponentProperties.SetProperties. Cette méthode tient un cache par type — un Dictionary<string, IPropertySetter> construit une fois par réflexion sur les propriétés du composant et indexé par le nom de chaque propriété [Parameter]. Après l”obfuscation, ce dictionnaire a une clé "a". L”attribut entrant s”appelle "IncrementBy". Pas de correspondance, et Blazor ne laisse pas passer :
System.InvalidOperationException: Object of type 'MyApp.Components.Counter'
does not have a property matching the name 'IncrementBy'.
Contrairement à un binding WPF — qui journalise une erreur de chemin et laisse le contrôle à sa valeur de repli — ceci lève une exception au premier rendu du composant. C”est un cadeau : l”échec est bruyant et immédiat.
La keep-list est donc précise : chaque nom de propriété [Parameter] et [CascadingParameter], les noms de paramètre EventCallback générés, ChildContent et tout autre slot RenderFragment, et le couple Value/ValueChanged auquel @bind-Value se développe. Tout le reste de ce que le composant déclare — les champs et méthodes privés de @code, les types de composant eux-mêmes, un [CascadingParameter] sans nom associé par type — est référencé par token et se renomme sans effet sur le rendu.
Cadrer Nebula
L”analyseur de Blazor lui-même exige que chaque propriété [Parameter] soit publique, donc les noms que vous devez conserver sont exactement la surface publique de vos types de composant. C”est une seule règle de keep cadrée. Placez un composant Counter.razor sous un espace de noms Components et :
{
"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 première règle conserve les noms de paramètre publics de chaque composant, tandis que members: "public" laisse le champ privé Current, la méthode Handle et le nom de type du composant lui-même se renommer. La seconde renomme tout le reste : vos services, votre logique de domaine, vos vérifications de licence. Le keep est de nom uniquement : les composants conservés reçoivent toujours l”obfuscation de flot de contrôle sur leurs corps de méthode et le chiffrement de leurs chaînes littérales. Vous renoncez au renommage d”une poignée de noms de paramètre, pas à la protection du code qui se trouve derrière.
Si vous préférez fixer les noms dans le code source pour qu”ils voyagent avec un refactor, le paquet d”annotations de Nebula 2.2.0 le fait par membre : [Keep] sur une propriété de paramètre ne conserve que ce nom et laisse le reste du composant se renommer, et l”attribut est retiré de la sortie protégée, il n”ajoute donc aucune dépendance à l”exécution :
using Nebula.Annotations;
[Parameter, Keep] public int IncrementBy { get; set; } = 1;
Mises en garde et quand ça casse
L”échec bruyant couvre le cas courant, mais trois bords sont plus discrets. D”abord, la couverture : un composant rendu uniquement derrière un écran que votre smoke test n”ouvre jamais ne lèvera rien tant qu”un utilisateur n”y arrive pas, donc le test d”acceptation honnête exerce chaque composant au moins une fois contre le build protégé, pas celui de débogage. Ensuite, l”interop JS : une méthode [JSInvokable] est appelée depuis JavaScript par son nom de méthode, donc ce nom est un contrat de chaîne — conservez-le, et conservez le type si JS le résout aussi par nom. Enfin, DynamicComponent : <DynamicComponent Type="@t" /> où t a été produit à partir d”une chaîne contenant un nom de type se résout par nom et le type cible doit être conservé ; là où t provient de typeof(...), c”est un token et il se renomme librement.
Et le cadre sous-jacent à tout cela : il s”agit de protéger la PI de votre propre application. Conservez les noms que l”arbre de rendu résout par chaîne ; obfusquez les composants et la logique derrière eux.
À retenir
Un composant Blazor transmet ses paramètres à travers un arbre de rendu indexé par nom, donc chaque nom [Parameter] vit dans votre assembly comme une chaîne littérale que le moteur de rendu associe par réflexion — et le renommer lève une exception au premier rendu plutôt que d”échouer en silence. Les types de composant, les membres privés de @code et les paramètres en cascade sans nom sont câblés par token et se renomment gratuitement. Un keep members: "public" sur l”espace de noms de vos composants trace exactement cette ligne, et c”est pourquoi obfusquer une app Blazor Hybrid est un problème de portée, pas une raison de laisser en clair l”assembly que vous livrez. Nebula.NET conserve le contrat de paramètres et obfusque tout ce qui se trouve derrière ; ouvrez le résultat dans Glass.NET pour confirmer que vos noms de paramètre ont survécu tandis que les internes du composant se lisent comme a, b, c.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.