Skip to content
← Alle Beiträge
· Delta1 Labs BlazorNebula

Wie Umbenennung Blazor-Komponentenparameter zerstört

Eine Blazor-Hybrid-App liefert ihr Komponenten-Assembly auf den Rechner des Nutzers aus und lohnt daher die Obfuskierung – doch eine Komponente übergibt ihre Parameter über einen namensindizierten Render-Tree, nicht über einen Methodenaufruf. Dieser Beitrag liest den von Razor generierten BuildRenderTree, um zu zeigen, dass jeder [Parameter]-Name als String-Literal reist, das der Renderer per Reflexion abgleicht, weshalb das Umbenennen eines davon beim ersten Rendern eine Ausnahme wirft, und richtet dann Nebula so aus, dass diese Namen erhalten bleiben und alles andere obfuskiert wird.

Eine Blazor-Server-App hat clientseitig nichts zu schützen – das Assembly läuft auf Ihrem Server, und der Browser sieht nur HTML. Eine Blazor-Hybrid-App ist das Gegenteil. Wenn Sie eine BlazorWebView in einer .NET-MAUI-, WPF- oder WinForms-Hülle hosten, werden Ihre Razor-Komponenten in ein gewöhnliches verwaltetes Assembly kompiliert, das auf den Rechner des Nutzers ausgeliefert wird, wo ein Dekompiler es wie jede andere Desktop-Binärdatei liest. Das ist ein guter Grund, es zu obfuskieren. Es ist auch die Stelle, an der man überrascht wird, denn eine Blazor-Komponente übergibt ihre Parameter nicht so, wie eine Methode ihre Argumente übergibt. Sie übergibt sie per Name, durch einen Render-Tree, und die Namen sind Strings.

Die eigentliche Frage

Benennen Sie ein Assembly um, lautet die ehrliche Frage immer gleich: Welche Namen löst die Laufzeit über ihren String auf, und welche hat der Compiler bereits als direkte Token-Referenz verdrahtet? Für das meiste C# lautet die Antwort „Token”: Ein Methodenaufruf ist eine MethodDef-Referenz, ein Feldzugriff ein FieldDef, und die Umbenennung schreibt sowohl die Definition als auch jede Referenz zusammen um. Komponentenparameter sind die Ausnahme. Der Razor-Compiler senkt <Counter IncrementBy="@step" /> auf Code ab, der den Parameter mit einem String-Literal benennt, und der Renderer gleicht diesen String per Reflexion mit den Eigenschaften des Kindes ab. Treffen Sie diese Unterscheidung richtig, lässt sich eine Blazor-Hybrid-App so stark obfuskieren wie jede andere; treffen Sie sie falsch, wirft die App beim ersten Rendern eine Ausnahme.

Was der Razor-Compiler ausgibt

Nehmen Sie eine triviale Komponente und das Elternteil, das sie verwendet.

@* 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) { /* ... */ }
}

Der Razor-Compiler verwandelt jede .razor-Datei in eine C#-Klasse mit einer BuildRenderTree-Methode. Die des Elternteils lautet, auf das Wesentliche gekürzt, so:

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();
}

(Auf .NET 7 und früher hieß dies AddAttribute statt AddComponentParameter; das String-Argument ist identisch.) In diesem IL leben nun zwei Arten von Namen, und die Umbenennung behandelt sie gegensätzlich.

Strings gegen Token

OpenComponent<MyApp.Components.Counter>(0) trägt den Typ Counter als generisches Typargument – ein Metadaten-Token, ausgegeben von der ldtoken/typeof-Mechanik, die der JIT zum TypeDef auflöst. Benennen Sie Counter in a um, und Nebula schreibt die Zeile und diese Referenz zusammen um; die Komponente öffnet sich weiterhin. Der Komponententypname ist frei.

Die Parameternamen sind es nicht. "IncrementBy" und "OnChanged" sind Benutzer-String-Konstanten: schlichte ldstr-Ladevorgänge in den #US-Heap:

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)

Nichts an diesem ldstr sagt dem Obfuskator, dass es eine Eigenschaft benennt. Nebula benennt Metadaten um – Typ-, Methoden-, Feld- und Eigenschaftsnamen in den Tabellen – und aktualisiert die Token-Referenzen darauf. Es schreibt keine beliebigen String-Literale um, um einer Umbenennung zu folgen, denn es kann nicht wissen, dass der Text "IncrementBy" einem Eigenschaftsnamen entsprechen soll und nicht etwa einer Log-Nachricht. Der String bleibt also "IncrementBy", während die Eigenschaft, die er treffen sollte, zu a wird.

Was als Nächstes passiert, ist der springende Punkt. Wenn der Renderer Counter instanziiert, übergibt er der Komponente eine ParameterView, die aus diesen benannten Attributen gebaut wird, und ruft SetParametersAsync auf, dessen Standardimplementierung ComponentProperties.SetProperties aufruft. Diese Methode hält einen Cache pro Typ – ein Dictionary<string, IPropertySetter>, das einmal per Reflexion über die Eigenschaften der Komponente gebaut und über den Namen jeder [Parameter]-Eigenschaft indiziert wird. Nach der Obfuskierung hat dieses Dictionary einen Schlüssel "a". Das eingehende Attribut heißt "IncrementBy". Keine Übereinstimmung, und Blazor übergeht das nicht:

System.InvalidOperationException: Object of type 'MyApp.Components.Counter'
does not have a property matching the name 'IncrementBy'.

Anders als ein WPF-Binding – das einen Pfadfehler protokolliert und das Steuerelement auf seinem Rückfallwert belässt – wirft dies beim ersten Rendern der Komponente eine Ausnahme. Das ist ein Geschenk: Das Scheitern ist laut und sofortig.

Per STRING abgeglichen — erhaltenIncrementBy[Parameter] — Render-Tree benennt ihnOnChangedEventCallback-Parameter — per NameValue / ValueChangedNamen der @bind-Value-KonventionChildContentRenderFragment-Slot — fester Stringder Renderer reflektiert sie per NamePer TOKEN verdrahtet — frei umbenennbarCounterTyp — Token OpenComponent<Counter>[CascadingParameter]ohne Name — per TYP abgeglichenCurrent / Handle@code-Interna — im Code aufgerufen[Route]-Seiteper Attribut entdeckt, nicht per Name

Die Keep-List ist also konkret: jeder [Parameter]- und [CascadingParameter]-Eigenschaftsname, die generierten EventCallback-Parameternamen, ChildContent und jeder weitere RenderFragment-Slot sowie das Paar Value/ValueChanged, zu dem sich @bind-Value entfaltet. Alles andere, was die Komponente deklariert – die privaten @code-Felder und -Methoden, die Komponententypen selbst, ein per Typ abgeglichenes [CascadingParameter] ohne Name –, wird per Token referenziert und ohne Auswirkung auf das Rendern umbenannt.

Nebula ausrichten

Blazors eigener Analyzer verlangt, dass jede [Parameter]-Eigenschaft öffentlich ist, daher sind die zu erhaltenden Namen genau die öffentliche Oberfläche Ihrer Komponententypen. Das ist eine einzige ausgerichtete Keep-Regel. Legen Sie eine Counter.razor-Komponente unter einen Components-Namespace und:

{
  "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" }
    ]
  }
}

Die erste Regel erhält die öffentlichen Parameternamen jeder Komponente, während members: "public" das private Feld Current, die Methode Handle und den Typnamen der Komponente selbst umbenennen lässt. Die zweite benennt alles andere um: Ihre Dienste, Ihre Domänenlogik, Ihre Lizenzprüfungen. Der Keep ist nur namensbezogen: Die erhaltenen Komponenten erhalten weiterhin Kontrollfluss-Obfuskierung an ihren Methodenrümpfen und Verschlüsselung ihrer String-Literale. Sie geben die Umbenennung einer Handvoll Parameternamen auf, nicht den Schutz des Codes dahinter.

Wenn Sie die Namen lieber im Quellcode fixieren möchten, damit sie ein Refactoring überstehen, erledigt das Annotations-Paket von Nebula 2.2.0 das pro Member: [Keep] an einer Parameter-Eigenschaft erhält nur diesen Namen und lässt den Rest der Komponente umbenennen, und das Attribut wird aus der geschützten Ausgabe entfernt, fügt also keine Laufzeitabhängigkeit hinzu:

using Nebula.Annotations;

[Parameter, Keep] public int IncrementBy { get; set; } = 1;

Vorbehalte und wann es bricht

Das laute Scheitern deckt den Normalfall ab, doch drei Ränder sind leiser. Erstens die Abdeckung: Eine Komponente, die nur hinter einem Bildschirm gerendert wird, den Ihr Smoke-Test nie öffnet, wirft nichts, bis ein Nutzer dorthin gelangt – der ehrliche Abnahmetest übt also jede Komponente mindestens einmal gegen den geschützten Build aus, nicht den Debug-Build. Zweitens der JS-Interop: Eine [JSInvokable]-Methode wird aus JavaScript über ihren Methodennamen aufgerufen, dieser Name ist also ein String-Vertrag – erhalten Sie ihn, und erhalten Sie den Typ, falls JS ihn ebenfalls per Name auflöst. Drittens DynamicComponent: <DynamicComponent Type="@t" />, wobei t aus einem String mit einem Typnamen erzeugt wurde, löst per Name auf und der Zieltyp muss erhalten bleiben; stammt t aus typeof(...), ist es ein Token und wird frei umbenannt.

Und der Rahmen, der allem zugrunde liegt: Es geht darum, das geistige Eigentum Ihrer eigenen Anwendung zu schützen. Erhalten Sie die Namen, die der Render-Tree per String auflöst; obfuskieren Sie die Komponenten und die Logik dahinter.

Fazit

Eine Blazor-Komponente übergibt ihre Parameter über einen namensindizierten Render-Tree, daher lebt jeder [Parameter]-Name in Ihrem Assembly als String-Literal, das der Renderer per Reflexion abgleicht – und sein Umbenennen wirft beim ersten Rendern eine Ausnahme, statt still zu scheitern. Die Komponententypen, die privaten @code-Member und die unbenannten Cascading-Parameter sind per Token verdrahtet und werden kostenlos umbenannt. Ein members: "public"-Keep auf dem Namespace Ihrer Komponenten zieht genau diese Linie, und darum ist das Obfuskieren einer Blazor-Hybrid-App ein Frage des Umfangs und kein Grund, das ausgelieferte Assembly im Klartext zu lassen. Nebula.NET erhält den Parametervertrag und obfuskiert alles dahinter; öffnen Sie das Ergebnis in Glass.NET, um zu bestätigen, dass Ihre Parameternamen überlebt haben, während die Interna der Komponente sich als a, b, c lesen.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.