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

Einen Refit-REST-Client obfuskieren, ohne ihn zu zerstören

Refit baut aus einem C#-Interface einen HTTP-Client, aber die Gestalt auf der Leitung ergibt sich aus den Attributen — [Get("/users/{id}")], [Header], [Body], [Query] — nicht aus dem Typ- oder Methodennamen des Interfaces. Der Interface-Name, seine Methoden und die generierte Implementierung lassen sich daher frei umbenennen. Die einzige echte Gefahr sind die Parameternamen, die sich über ihren Namen an Pfad- und Query-Schlüssel binden; [AliasAs] entkoppelt sie, damit Nebula alles umbenennen kann.

Die meisten „Das nicht obfuskieren”-Warnungen betreffen die Serialisierung: Der Mitgliedsname ist der Schlüssel auf der Leitung, also bricht das Umbenennen ihn. Refit sieht so aus, als gehörte es in diese Kategorie — Sie geben ihm ein C#-Interface und es erzeugt einen HTTP-Client — ist aber tatsächlich eine der am leichtesten zu obfuskierenden Bibliotheken, sobald Sie verstehen, wo der Vertrag lebt. Der Vertrag steckt in den Attributen, nicht in den Namen des Typs und der Methoden. Dieser Beitrag geht genau durch, was Refit auf der Leitung festlegt, was nicht, und die eine Stelle, an der das Umbenennen Ihre Anfragen still verfälscht, wenn Sie nicht aufpassen.

Wie Refit aus einem Interface eine Anfrage macht

Sie beschreiben eine REST-API als schlichtes C#-Interface und versehen jede Methode mit einem HTTP-Attribut. Das moderne Refit (v6+) führt zur Compile-Zeit einen Source Generator aus, der eine konkrete Implementierung des Interfaces erzeugt; ältere Versionen bauen zur Laufzeit einen auf System.Reflection basierenden Proxy. In beiden Fällen wird die Anfrage aus den Attributen zusammengesetzt:

using Refit;

[Headers("Accept: application/json")]
public interface IUserApi
{
    [Get("/users/{id}")]
    Task<User> GetUser(int id, [Query] bool includeOrders);

    [Get("/users")]
    Task<Page<User>> ListUsers(
        [AliasAs("page")] int pageNumber,
        [AliasAs("page_size")] int pageSize);

    [Post("/users")]
    [Headers("Idempotency-Key: auto")]
    Task<User> CreateUser([Body] CreateUserRequest body);
}

Wenn Refit GetUser(42, true) ausführt, liest es [Get("/users/{id}")], setzt den Parameter namens id in den Platzhalter {id} ein und hängt includeOrders, da es kein Pfadsegment ist, als Query-Schlüssel an. Die resultierende Anfragezeile lautet:

GET /users/42?includeOrders=true
Accept: application/json

Die Strings IUserApi, GetUser und includeOrders als Symbole stehen nirgends in dieser Anfrage. Das Verb kam aus dem Attributnamen, der Pfad aus einem String-Literal und der Header aus [Headers]. Diese Trennung ist es, die die Obfuskation sicher macht.

Was sich frei umbenennen lässt

Drei Dinge tragen auf der Leitung keine Bedeutung und können umbenannt (und bei der Implementierung stringverschlüsselt) werden, ohne ein einziges Byte irgendeiner Anfrage zu ändern:

Der Typname des Interfaces

IUserApi ist ein CLR-Typname. Refit serialisiert ihn nie; es braucht nur einen Typ, gegen den es generieren kann. Benennen Sie ihn in N0 um, und der generierte Client sendet weiterhin GET /users/42.

Die Methodennamen

GetUser, ListUsers, CreateUser sind Bezeichnungen. Das HTTP-Verb und der Pfad kommen aus [Get]/[Post] und der literalen Vorlage, also lässt das Umbenennen von GetUser in a1 die Anfrage identisch.

Die generierte Implementierung

Der Source Generator erzeugt eine interne Klasse (historisch AutoGeneratedIUserApi), die das Interface implementiert. Sie ist interne Infrastruktur ohne öffentlichen Vertrag und daher ein ideales Ziel für Umbenennung und Stringverschlüsselung: Die URL-Vorlagen, die sie hält, sind String-Literale, die sich sauber verschlüsseln und zur Laufzeit zum selben Pfad entschlüsseln lassen.

CLR-Symbole — frei umbenenneninterface IUserApiTask GetUser(...)Task ListUsers(...)+ generierte Impl-Klasse→ umbenannt & verschlüsselt, Anfrage bleibtAttribute — legen die Leitung fest[Get("/users/{id}")][AliasAs("page_size")] pageSize[Body] CreateUserRequest bodyString-Literale → Verb + Pfad + Query-SchlüsselGET /users/42?page_size=20definierenKeep-List-Gate — nur dort, wo Reflection das Interface über den Namen liesttypeof(IUserApi).Name · nameof(IUserApi.GetUser)sonst: keine Keep-Regel nötig

Die einzige echte Gefahr: die Parameternamen

Hier ist die Falle. Ein Methodenparameter ohne Routing-Attribut bindet sich über seinen CLR-Namen an die URL:

  • Ein Parameter, dessen Name zu einem {Platzhalter} passt, füllt diesen Platzhalter.
  • Ein Parameter ohne Platzhalter und ohne [Body] wird unter seinem eigenen Namen an den Query-String angehängt.

So erzeugt diese Methode ohne Alias:

[Get("/users")]
Task<Page<User>> ListUsers(int page, int pageSize);   // fragil

Refit produziert GET /users?page=1&pageSize=20. Die Query-Schlüssel page und pageSize sind die Parameternamen. Ein Obfuskator, der Parameter umbenennt — und viele tun das, denn Parameternamen sind Metadaten, die ein Angreifer lesen kann — macht daraus:

GET /users?a=1&b=20

Der Server, der weiterhin page und pageSize erwartet, sieht nun zwei unbekannte Schlüssel und verwirft Ihre Paginierung still. Keine Ausnahme, kein Compile-Fehler — nur eine falsche Anfrage. Pfad-Platzhalter scheitern genauso: Wird GetUser(int id) zu GetUser(int a), findet Refit keinen Parameter namens id mehr, um {id} zu füllen.

Die Lösung: jedem gebundenen Parameter einen Alias geben

Legen Sie den Leitungsnamen explizit fest, damit er nicht mehr vom CLR-Bezeichner abhängt. [AliasAs] setzt den Namen eines Pfad- oder Query-Parameters; [Query] kann den Alias ebenfalls tragen. Sobald jeder gebundene Parameter einen Alias hat, wird der Parametername frei umbenennbar:

[Get("/users/{id}")]
Task<User> GetUser([AliasAs("id")] int id, [AliasAs("includeOrders")] bool includeOrders);

[Get("/users")]
Task<Page<User>> ListUsers(
    [AliasAs("page")] int pageNumber,
    [AliasAs("page_size")] int pageSize);

Jetzt definiert das String-Literal des Alias den Leitungsnamen, und der CLR-Parameter kann in alles umbenannt werden. Das ist die wichtigste Angewohnheit für einen obfuskationsfreundlichen Refit-Client: behandeln Sie [AliasAs] als Pflicht an jedem gebundenen Parameter, genau wie Sie [ProtoMember(N)] an einem protobuf-Typ behandeln würden.

Die Dependency Injection funktioniert weiter

Wenn Sie den Client per Typ registrieren und über das Interface auflösen, ist das Umbenennen transparent: Der DI-Container gleicht über den Type ab, den der Obfuskator sowohl auf der Registrierungs- als auch auf der Auflösungsseite konsistent umschreibt:

builder.Services
    .AddRefitClient<IUserApi>()
    .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.example.com"));

// an anderer Stelle, über das Interface aufgelöst — umbenennungssicher
public sealed class OrderService(IUserApi users)
{
    public Task<User> Load(int id) => users.GetUser(id, includeOrders: true);
}

Das Einzige, was bricht, ist Reflection über den Interface-Namen: typeof(IUserApi).Name, nameof(IUserApi.GetUser) oder jede manuelle RestService.For<T>-Verdrahtung, die auf einem String basiert, den Sie mit dem Typnamen vergleichen. Wenn Sie den Interface-Namen loggen oder die Proxy-Registrierung aus nameof steuern, passt dieser String nach dem Umbenennen nicht mehr.

Die Nebula-Konfiguration

Für einen sauber mit Aliassen versehenen Client brauchen Sie überhaupt keine Keep-Regel: Interface, Mitglieder und Implementierung werden alle umbenannt, und die stringverschlüsselten Vorlagen erzeugen weiterhin die richtige Anfrage. Fügen Sie eine Keep-Regel nur für den Fall der Reflection über den Namen hinzu. Eine realistische nebula.config.json:

{
  "input": "bin/Release/net8.0/Acme.ApiClient.dll",
  "output": "dist/Acme.ApiClient.dll",
  "rename": {
    "enabled": true,
    "renameParameters": true
  },
  "stringEncryption": {
    "enabled": true
  },
  "controlFlow": {
    "enabled": true
  },
  "keep": [
    {
      "comment": "Nur falls der Code typeof(IUserApi).Name / nameof für Logging oder manuelle Proxy-Verdrahtung nutzt.",
      "type": "Acme.ApiClient.IUserApi",
      "keepName": true,
      "keepMembers": false
    }
  ]
}

Beachten Sie keepMembers: false: Selbst wenn Sie den Typnamen behalten müssen, weil etwas darauf Reflection ausführt, können die Methodennamen weiterhin umbenannt werden, denn Refit liest sie nicht. Führt nichts Reflection auf dem Interface aus, löschen Sie den gesamten keep-Block.

Führen Sie den Protector gegen die kompilierte Assembly aus:

nebula protect --config nebula.config.json

Prüfen, dass die Leitung unverändert ist

Der Beweis, dass die Obfuskation den Vertrag nicht angetastet hat, ist, dass die Anfragezeile vorher und nachher byte-identisch ist. Richten Sie den Client auf einen Endpunkt, der die Anfrage aufzeichnet (oder auf einen loggenden DelegatingHandler), und vergleichen Sie. Vor der Obfuskation sendet GetUser(42, true):

GET /users/42?includeOrders=true
Accept: application/json

Nach nebula protect — mit IUserApi umbenannt in N0, GetUser in a, beiden umbenannten Parametern und der stringverschlüsselten Vorlage /users/{id} — gehen genau dieselben Bytes hinaus:

GET /users/42?includeOrders=true
Accept: application/json

Die URL-Vorlage war ein String-Literal; Nebula verschlüsselte die gespeicherte Konstante, aber sie entschlüsselt zur Laufzeit zu /users/{id}, bevor Refit sie füllt. Die [AliasAs]-Literale trugen die Namen der Query-Schlüssel durch das Umbenennen der Parameter. Nichts, was der Server liest, hat sich geändert.

Zusammenfassung

Refit ist umbenennungsfreundlich, weil der HTTP-Vertrag in Attributen und String-Literalen lebt, nicht in CLR-Bezeichnern. Der Typname des Interfaces, jeder Methodenname und die generierte Implementierung können frei umbenannt und stringverschlüsselt werden. Die einzige Gefahr sind die Parameternamen, die sich an Pfad-Platzhalter und Query-Schlüssel binden — setzen Sie also [AliasAs("...")] an jeden gebundenen Parameter, um den Leitungsnamen vom CLR-Namen zu entkoppeln. Danach lassen Sie Nebula Pro den gesamten Client umbenennen und greifen nur dort zu einer Keep-List, wo tatsächlich etwas Reflection über den Interface-Namen ausführt.

Nebula.NET testen

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