Skip to content
← Todas las publicaciones
· Delta1 Labs RefitNebula

Ofuscar un cliente REST de Refit sin romperlo

Refit construye un cliente HTTP a partir de una interfaz de C#, pero la forma del cable proviene de los atributos — [Get("/users/{id}")], [Header], [Body], [Query] — no del nombre del tipo ni de los métodos de la interfaz. Así que el nombre de la interfaz, sus métodos y la implementación generada se pueden renombrar libremente. El único peligro real son los nombres de los parámetros, que se enlazan por nombre a las claves de ruta y de query; [AliasAs] los desacopla para que Nebula pueda renombrarlo todo.

La mayoría de las advertencias de “no ofusques esto” tratan sobre serialización: el nombre del miembro es la clave del cable, así que renombrarlo lo rompe. Refit parece que debería estar en esa categoría —le entregas una interfaz de C# y produce un cliente HTTP— pero en realidad es una de las bibliotecas más amables para ofuscar, una vez que entiendes dónde vive el contrato. El contrato está en los atributos, no en los nombres del tipo y de los métodos. Este artículo recorre exactamente qué fija Refit al cable, qué no, y el único lugar donde el renombrado corromperá tus peticiones en silencio si no tienes cuidado.

Cómo Refit convierte una interfaz en una petición

Describes una API REST como una interfaz de C# normal y decoras cada método con un atributo HTTP. El Refit moderno (v6+) ejecuta un source generator en tiempo de compilación que emite una implementación concreta de la interfaz; las versiones antiguas construyen un proxy basado en System.Reflection en tiempo de ejecución. En cualquiera de los dos casos, la petición se ensambla a partir de los atributos:

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

Cuando Refit ejecuta GetUser(42, true), lee [Get("/users/{id}")], sustituye el parámetro llamado id en el marcador {id} y, como includeOrders no es un segmento de ruta, lo añade como clave de query. La línea de petición resultante es:

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

Las cadenas IUserApi, GetUser e includeOrders como símbolos no están en ninguna parte de esa petición. El verbo vino del nombre del atributo, la ruta vino de un literal de cadena y la cabecera vino de [Headers]. Esa separación es lo que hace que la ofuscación sea segura.

Qué se renombra libremente

Tres cosas no tienen significado en el cable y se pueden renombrar (y, en el caso de la implementación, cifrar sus cadenas) sin cambiar ni un solo byte de ninguna petición:

El nombre del tipo de la interfaz

IUserApi es un nombre de tipo CLR. Refit nunca lo serializa; solo necesita un tipo contra el que generar. Renómbralo a N0 y el cliente generado sigue emitiendo GET /users/42.

Los nombres de los métodos

GetUser, ListUsers, CreateUser son etiquetas. El verbo HTTP y la ruta vienen de [Get]/[Post] y de la plantilla literal, así que renombrar GetUser a a1 deja la petición idéntica.

La implementación generada

El source generator emite una clase interna (históricamente AutoGeneratedIUserApi) que implementa la interfaz. Es fontanería interna sin contrato público, por lo que es un objetivo ideal de renombrado y cifrado de cadenas: las plantillas de URL que contiene son literales de cadena que se cifran limpiamente y se descifran a la misma ruta en tiempo de ejecución.

Símbolos CLR — renombrar librementeinterface IUserApiTask GetUser(...)Task ListUsers(...)+ clase impl generada→ renombrada y cifrada, petición intactaAtributos — fijan el cable[Get("/users/{id}")][AliasAs("page_size")] pageSize[Body] CreateUserRequest bodyliterales de cadena → verbo + ruta + claves queryGET /users/42?page_size=20definenPuerta de keep-list — solo donde la reflexión lee la interfaz por nombretypeof(IUserApi).Name · nameof(IUserApi.GetUser)si no: no hace falta regla keep

El único peligro real: los nombres de los parámetros

Aquí está la trampa. Un parámetro de método sin atributo de enrutado se enlaza a la URL por su nombre CLR:

  • Un parámetro cuyo nombre coincide con un {marcador} rellena ese marcador.
  • Un parámetro sin marcador y sin [Body] se añade a la cadena de query con su propio nombre.

Así, en este método sin alias:

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

Refit produce GET /users?page=1&pageSize=20. Las claves de query page y pageSize son los nombres de los parámetros. Un ofuscador que renombra parámetros —y muchos lo harán, porque los nombres de parámetro son metadatos que un atacante puede leer— convierte esto en:

GET /users?a=1&b=20

El servidor, que sigue esperando page y pageSize, ahora ve dos claves desconocidas y descarta tu paginación en silencio. Sin excepción, sin error de compilación: solo una petición incorrecta. Los marcadores de ruta fallan igual: si GetUser(int id) pasa a ser GetUser(int a), Refit ya no encuentra un parámetro llamado id que rellene {id}.

La solución: poner alias a cada parámetro enlazado

Fija el nombre del cable de forma explícita para que ya no dependa del identificador CLR. [AliasAs] establece el nombre de un parámetro de ruta o de query; [Query] también puede llevar el alias. Una vez que cada parámetro enlazado tiene alias, el nombre del parámetro queda libre para renombrar:

[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);

Ahora el literal de cadena del alias define el nombre del cable, y el parámetro CLR se puede renombrar a cualquier cosa. Este es el hábito más importante para un cliente de Refit apto para la ofuscación: trata [AliasAs] como obligatorio en cada parámetro enlazado, exactamente como tratarías [ProtoMember(N)] en un tipo de protobuf.

La inyección de dependencias sigue funcionando

Si registras el cliente por tipo y lo resuelves por interfaz, el renombrado es transparente: el contenedor de DI empareja por el Type, que el ofuscador reescribe de forma coherente tanto en el registro como en la resolución:

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

// en otro sitio, resuelto por interfaz — seguro frente al renombrado
public sealed class OrderService(IUserApi users)
{
    public Task<User> Load(int id) => users.GetUser(id, includeOrders: true);
}

Lo único que se rompe es la reflexión sobre la interfaz por nombre: typeof(IUserApi).Name, nameof(IUserApi.GetUser), o cualquier cableado manual de RestService.For<T> basado en una cadena que compares contra el nombre del tipo. Si registras el nombre de la interfaz, o diriges el registro del proxy desde nameof, esa cadena ya no coincide tras el renombrado.

La configuración de Nebula

Para un cliente con alias correctos no necesitas ninguna regla keep: la interfaz, los miembros y la implementación se renombran todos, y las plantillas con cadenas cifradas siguen produciendo la petición correcta. Añade una regla keep solo para el caso de reflexión por nombre. Un nebula.config.json realista:

{
  "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": "Solo si el código hace typeof(IUserApi).Name / nameof para registro o cableado manual del proxy.",
      "type": "Acme.ApiClient.IUserApi",
      "keepName": true,
      "keepMembers": false
    }
  ]
}

Fíjate en keepMembers: false: incluso cuando debes conservar el nombre del tipo porque algo usa reflexión sobre él, los nombres de los métodos aún pueden renombrarse, porque Refit no los lee. Si nada usa reflexión sobre la interfaz, borra el bloque keep entero.

Ejecuta el protector sobre el ensamblado compilado:

nebula protect --config nebula.config.json

Verificar que el cable no cambia

La prueba de que la ofuscación no tocó el contrato es que la línea de petición es idéntica byte a byte antes y después. Apunta el cliente a un endpoint que capture la petición (o a un DelegatingHandler de registro) y compara. Antes de la ofuscación, GetUser(42, true) emite:

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

Tras nebula protect —con IUserApi renombrado a N0, GetUser a a, ambos parámetros renombrados y la plantilla /users/{id} con la cadena cifrada— salen exactamente los mismos bytes:

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

La plantilla de URL era un literal de cadena; Nebula cifró la constante almacenada, pero esta se descifra a /users/{id} en tiempo de ejecución antes de que Refit la rellene. Los literales de [AliasAs] llevaron los nombres de las claves de query a través del renombrado de parámetros. Nada de lo que el servidor lee cambió.

Resumen

Refit es apto para el renombrado porque el contrato HTTP vive en atributos y literales de cadena, no en identificadores CLR. El nombre del tipo de la interfaz, cada nombre de método y la implementación generada se pueden renombrar y cifrar sus cadenas con libertad. El único peligro son los nombres de los parámetros que se enlazan a los marcadores de ruta y a las claves de query, así que pon [AliasAs("...")] en cada parámetro enlazado para desacoplar el nombre del cable del nombre CLR. Después de eso, deja que Nebula Pro renombre todo el cliente y recurre a una keep-list solo donde algo realmente use reflexión sobre la interfaz por nombre.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.