Obfusquer un client REST Refit sans le casser
Refit construit un client HTTP à partir d'une interface C#, mais la forme du câble provient des attributs — [Get("/users/{id}")], [Header], [Body], [Query] — et non du nom du type ou des méthodes de l'interface. Le nom de l'interface, ses méthodes et l'implémentation générée se renomment donc librement. Le seul vrai danger, ce sont les noms des paramètres, qui se lient par nom aux clés de chemin et de query ; [AliasAs] les découple pour que Nebula puisse tout renommer.
La plupart des avertissements « n”obfusquez pas ceci » concernent la sérialisation : le nom du membre est la clé du câble, donc le renommer le casse. Refit semble devoir entrer dans cette catégorie — vous lui donnez une interface C# et il produit un client HTTP — mais c”est en réalité l”une des bibliothèques les plus faciles à obfusquer, une fois que vous comprenez où vit le contrat. Le contrat est dans les attributs, pas dans les noms du type et des méthodes. Cet article parcourt exactement ce que Refit fixe au câble, ce qu”il ne fixe pas, et le seul endroit où le renommage corrompra silencieusement vos requêtes si vous n”y prenez pas garde.
Comment Refit transforme une interface en requête
Vous décrivez une API REST comme une interface C# ordinaire et vous décorez chaque méthode avec un attribut HTTP. Le Refit moderne (v6+) exécute un source generator à la compilation qui émet une implémentation concrète de l”interface ; les versions plus anciennes construisent un proxy basé sur System.Reflection à l”exécution. Dans les deux cas, la requête est assemblée à partir des attributs :
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);
}
Quand Refit exécute GetUser(42, true), il lit [Get("/users/{id}")], substitue le paramètre nommé id dans le marqueur {id} et, comme includeOrders n”est pas un segment de chemin, l”ajoute comme clé de query. La ligne de requête résultante est :
GET /users/42?includeOrders=true
Accept: application/json
Les chaînes IUserApi, GetUser et includeOrders en tant que symboles ne figurent nulle part dans cette requête. Le verbe est venu du nom de l”attribut, le chemin d”un littéral de chaîne et l”en-tête de [Headers]. Cette séparation est ce qui rend l”obfuscation sûre.
Ce qui se renomme librement
Trois éléments ne portent aucun sens sur le câble et peuvent être renommés (et, pour l”implémentation, leurs chaînes chiffrées) sans changer un seul octet d”aucune requête :
Le nom du type de l”interface
IUserApi est un nom de type CLR. Refit ne le sérialise jamais ; il a seulement besoin d”un type contre lequel générer. Renommez-le en N0 et le client généré émet toujours GET /users/42.
Les noms des méthodes
GetUser, ListUsers, CreateUser sont des étiquettes. Le verbe HTTP et le chemin viennent de [Get]/[Post] et du modèle littéral, donc renommer GetUser en a1 laisse la requête identique.
L”implémentation générée
Le source generator émet une classe interne (historiquement AutoGeneratedIUserApi) qui implémente l”interface. C”est de la plomberie interne sans contrat public, c”est donc une cible idéale de renommage et de chiffrement de chaînes : les modèles d”URL qu”elle contient sont des littéraux de chaîne qui se chiffrent proprement et se déchiffrent vers le même chemin à l”exécution.
Le seul vrai danger : les noms des paramètres
Voici le piège. Un paramètre de méthode sans attribut de routage se lie à l”URL par son nom CLR :
- Un paramètre dont le nom correspond à un
{marqueur}remplit ce marqueur. - Un paramètre sans marqueur et sans
[Body]est ajouté à la chaîne de query sous son propre nom.
Ainsi, dans cette méthode sans alias :
[Get("/users")]
Task<Page<User>> ListUsers(int page, int pageSize); // fragile
Refit produit GET /users?page=1&pageSize=20. Les clés de query page et pageSize sont les noms des paramètres. Un obfuscateur qui renomme les paramètres — et beaucoup le feront, car les noms de paramètres sont des métadonnées qu”un attaquant peut lire — transforme cela en :
GET /users?a=1&b=20
Le serveur, qui attend toujours page et pageSize, voit désormais deux clés inconnues et abandonne silencieusement votre pagination. Pas d”exception, pas d”erreur de compilation — juste une requête incorrecte. Les marqueurs de chemin échouent de la même façon : si GetUser(int id) devient GetUser(int a), Refit ne trouve plus de paramètre nommé id pour remplir {id}.
La solution : donner un alias à chaque paramètre lié
Fixez explicitement le nom du câble pour qu”il ne dépende plus de l”identifiant CLR. [AliasAs] définit le nom d”un paramètre de chemin ou de query ; [Query] peut aussi porter l”alias. Une fois que chaque paramètre lié a un alias, le nom du paramètre devient libre d”être renommé :
[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);
Maintenant le littéral de chaîne de l”alias définit le nom du câble, et le paramètre CLR peut être renommé en n”importe quoi. C”est l”habitude la plus importante pour un client Refit compatible avec l”obfuscation : traitez [AliasAs] comme obligatoire sur chaque paramètre lié, exactement comme vous traiteriez [ProtoMember(N)] sur un type protobuf.
L”injection de dépendances continue de fonctionner
Si vous enregistrez le client par type et le résolvez par interface, le renommage est transparent : le conteneur de DI fait la correspondance sur le Type, que l”obfuscateur réécrit de façon cohérente côté enregistrement comme côté résolution :
builder.Services
.AddRefitClient<IUserApi>()
.ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.example.com"));
// ailleurs, résolu par interface — sûr face au renommage
public sealed class OrderService(IUserApi users)
{
public Task<User> Load(int id) => users.GetUser(id, includeOrders: true);
}
La seule chose qui casse, c”est la réflexion sur l”interface par nom : typeof(IUserApi).Name, nameof(IUserApi.GetUser), ou tout câblage manuel de RestService.For<T> fondé sur une chaîne que vous comparez au nom du type. Si vous journalisez le nom de l”interface, ou pilotez l”enregistrement du proxy depuis nameof, cette chaîne ne correspond plus après le renommage.
La configuration de Nebula
Pour un client correctement doté d”alias, vous n”avez besoin d”aucune règle keep : l”interface, les membres et l”implémentation se renomment tous, et les modèles aux chaînes chiffrées produisent toujours la bonne requête. N”ajoutez une règle keep que pour le cas de la réflexion par nom. Un nebula.config.json réaliste :
{
"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": "Uniquement si le code fait typeof(IUserApi).Name / nameof pour la journalisation ou un câblage manuel du proxy.",
"type": "Acme.ApiClient.IUserApi",
"keepName": true,
"keepMembers": false
}
]
}
Notez keepMembers: false : même quand vous devez conserver le nom du type parce que quelque chose fait de la réflexion dessus, les noms des méthodes peuvent toujours être renommés, car Refit ne les lit pas. Si rien ne fait de réflexion sur l”interface, supprimez entièrement le bloc keep.
Exécutez le protecteur sur l”assembly compilé :
nebula protect --config nebula.config.json
Vérifier que le câble est inchangé
La preuve que l”obfuscation n”a pas touché au contrat, c”est que la ligne de requête est identique octet pour octet avant et après. Pointez le client vers un endpoint qui capture la requête (ou vers un DelegatingHandler de journalisation) et comparez. Avant l”obfuscation, GetUser(42, true) émet :
GET /users/42?includeOrders=true
Accept: application/json
Après nebula protect — avec IUserApi renommé en N0, GetUser en a, les deux paramètres renommés et le modèle /users/{id} à la chaîne chiffrée — exactement les mêmes octets partent :
GET /users/42?includeOrders=true
Accept: application/json
Le modèle d”URL était un littéral de chaîne ; Nebula a chiffré la constante stockée, mais elle se déchiffre en /users/{id} à l”exécution avant que Refit ne la remplisse. Les littéraux de [AliasAs] ont porté les noms des clés de query à travers le renommage des paramètres. Rien de ce que lit le serveur n”a changé.
Résumé
Refit est compatible avec le renommage parce que le contrat HTTP vit dans les attributs et les littéraux de chaîne, pas dans les identifiants CLR. Le nom du type de l”interface, chaque nom de méthode et l”implémentation générée peuvent être renommés et voir leurs chaînes chiffrées librement. Le seul danger, ce sont les noms des paramètres qui se lient aux marqueurs de chemin et aux clés de query, alors mettez [AliasAs("...")] sur chaque paramètre lié pour découpler le nom du câble du nom CLR. Après cela, laissez Nebula Pro renommer tout le client et ne recourez à une keep-list que là où quelque chose fait réellement de la réflexion sur l”interface par nom.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.