Ofuscar gRPC code-first sin romper las rutas
En gRPC code-first (protobuf-net.Grpc) no hay archivo .proto: el contrato de servicio es una interfaz .NET, y la biblioteca deriva la ruta de red `/package.Service/Method` del espacio de nombres de la interfaz, su nombre de tipo y el nombre de cada método en tiempo de ejecución. Renombra la interfaz o un método y la ruta HTTP/2 cambia, de modo que los clientes golpean una ruta que el servidor ya no sirve y cada llamada falla con UNIMPLEMENTED, sin error de compilación. Los miembros de los DTO se comportan al revés: protobuf serializa por la etiqueta numérica `[ProtoMember]`, así que esos identificadores se renombran sin problema. Este artículo lee exactamente cómo se calcula la ruta, por qué `[Service]` y `[Operation]` te permiten fijar los nombres de red mientras renombras los identificadores, y cómo escribir una keep-list en nebula.config.json que protege la implementación y los internos de los DTO dejando el enrutamiento intacto.
Un servicio gRPC code-first no tiene archivo .proto, así que es tentador pensar que no hay contrato externo que proteger: todo son interfaces C# y DTOs. Pero el contrato no desapareció; se trasladó a metadatos que el runtime lee por reflexión, y una pasada de renombrado a ciegas los reescribirá sin avisar.
En protobuf-net.Grpc el contrato de servicio es una interfaz .NET decorada con un par de atributos, y los DTOs son clases corrientes con etiquetas [ProtoMember]. No hay paso de generación de código ni .proto que versionar. Esa comodidad esconde un filo cortante para la ofuscación: la ruta gRPC que llama un cliente —la ruta /package.Service/Method que viaja en la cabecera HTTP/2 :path— no está escrita en ningún sitio que puedas ver. La biblioteca la calcula al enlazar, a partir del espacio de nombres de la interfaz, su nombre de tipo y el nombre del método. Renombra cualquiera de los tres y habrás cambiado en silencio tu contrato público de red, con una compilación limpia y un servidor que arranca bien y luego responde a cada llamada real con UNIMPLEMENTED.
El remedio es la misma disciplina que exige todo framework guiado por reflexión: encuentra los nombres que se leen como cadenas en la red, fija exactamente esos y deja que todo lo que hay detrás se renombre.
Qué está en la red y qué no
En un servicio gRPC code-first se encuentran dos sistemas de nombres distintos, y se comportan de maneras opuestas bajo renombrado. El enrutamiento se deriva de identificadores; la serialización se rige por etiquetas numéricas. Acertar con esta distinción es todo el trabajo.
Aquí está el contrato. Es solo una interfaz y dos DTOs, sin código generado en ninguna parte:
using System.Threading.Tasks;
using ProtoBuf;
using ProtoBuf.Grpc;
namespace Shop.Contracts;
[ServiceContract]
public interface ICalculator
{
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
}
[ProtoContract]
public class MultiplyRequest
{
[ProtoMember(1)] public double X { get; set; }
[ProtoMember(2)] public double Y { get; set; }
}
[ProtoContract]
public class MultiplyReply
{
[ProtoMember(1)] public double Result { get; set; }
}
El servidor registra la implementación contra la interfaz, y el cliente construye un proxy a partir de la misma interfaz:
// Servidor
app.MapGrpcService<CalculatorService>(); // CalculatorService : ICalculator
// Cliente
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var calc = channel.CreateGrpcService<ICalculator>();
var reply = await calc.Multiply(new MultiplyRequest { X = 6, Y = 7 });
Nada en ese código menciona la ruta /Shop.Contracts.Calculator/Multiply. Ambos extremos la derivan de forma independiente a partir de ICalculator.
Cómo se deriva realmente la ruta
Cuando protobuf-net.Grpc enlaza ICalculator, su service binder convierte el tipo de contrato en un nombre de servicio. La lógica es lo bastante pequeña como para enunciarla exactamente: toma el nombre del tipo, quita una I inicial si el siguiente carácter está en mayúscula, y antepone el espacio de nombres.
// Equivalente a ProtoBuf.Grpc's ServiceBinder.GetDefaultName(Type).
static string GetServiceName(Type contract)
{
var name = contract.Name; // "ICalculator"
if (contract.IsInterface && name.Length > 1
&& name[0] == 'I' && char.IsUpper(name[1]))
name = name.Substring(1); // "Calculator"
return contract.Namespace + "." + name; // "Shop.Contracts.Calculator"
}
El nombre de la operación toma por defecto el nombre del método, Multiply. gRPC compone entonces la ruta HTTP/2 como /{service}/{operation}:
/Shop.Contracts.Calculator/Multiply
Esa cadena es el contrato. Se construye a partir de tres piezas de metadatos —espacio de nombres, nombre de tipo, nombre de método— ninguna de las cuales el compilador trata como relevante. Renombra ICalculator a a y el servicio pasa a ser Shop.Contracts.a; muévelo a un namespace renombrado y cambia el prefijo; renombra Multiply a b y cambia la operación. Cada cambio produce una ruta distinta, y un cliente compilado contra el contrato original sigue enviando la original. El servidor no tiene handler en la ruta antigua, así que el flujo se cierra con:
Status(StatusCode="Unimplemented", Detail="Service is unimplemented.")
Sin error de compilación, sin error de arranque: el servicio se aloja tan contento en la nueva ruta mientras cada llamante existente falla.
Por qué los miembros DTO son lo opuesto
Los cuerpos de petición y respuesta son la mitad tranquilizadora de la historia. protobuf-net no serializa por nombre de miembro; serializa por la etiqueta entera que declaras en [ProtoMember(n)]. El nombre existe únicamente para tu código C#.
Result a a deja intactos los bytes de la red: los miembros DTO se renombran libremente.Como la clave de red es 1, no Result, Nebula puede renombrar la propiedad a a, renombrar el tipo DTO MultiplyReply a lo que sea (el nombre del tipo tampoco se transmite nunca), y los bytes de la red son idénticos byte a byte. La única regla es que los números [ProtoMember] deben permanecer fijos, y lo permanecen, porque son literales enteros dentro de un atributo, no identificadores. Lo mismo vale para los enums, que viajan como su valor numérico.
Así que la superficie de contrato que debes proteger es precisamente: el nombre de tipo de la interfaz de servicio, su espacio de nombres y los nombres de sus métodos. Nada más.
Fijar los nombres de red
Hay dos formas de mantener la ruta estable. La primera es una keep-list que le dice a Nebula que no renombre las interfaces de contrato. La segunda, y la mejor, es declarar los nombres de red de forma explícita para que los identificadores queden libres otra vez.
Con protobuf-net.Grpc los defines en el propio contrato:
using ProtoBuf.Grpc.Configuration;
namespace Shop.Contracts;
[Service("shop.Calculator")] // el nombre de red se fija aquí…
public interface ICalculator // …así que este identificador puede renombrarse
{
[Operation("Multiply")] // …y este también
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
}
Ahora el binder lee shop.Calculator y Multiply directamente de los valores del atributo y nunca mira los nombres de los metadatos, así que la ruta es /shop.Calculator/Multiply sin importar cómo llame el ofuscador a la interfaz o al método. Esto vale la pena con independencia de la ofuscación: fija tu superficie gRPC pública para que un renombrado rutinario o un cambio de namespace no puedan desplazarla.
La keep-list en nebula.config.json
Si no has anotado el contrato con nombres explícitos, fija los nombres derivados conservando las interfaces de contrato. Todo lo demás —la implementación, los DTOs, los servicios internos— entra en el renombrado:
{
"schemaVersion": 1,
"inputs": [
"bin/Release/net8.0/Shop.Server.dll",
"bin/Release/net8.0/Shop.Contracts.dll"
],
"outputDirectory": "protected",
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Shop.Contracts.I*", "action": "keep", "members": "public" },
{ "pattern": "Shop.Contracts.*", "action": "rename" },
{ "pattern": "Shop.Server.*", "action": "rename" }
]
}
}
La primera regla empareja las interfaces de contrato por el prefijo convencional I… y conserva tanto los nombres de tipo (de modo que se preserva la cadena de servicio namespace-más-nombre) como sus nombres de método públicos, mientras que members: "public" deja que cualquier miembro no público dentro del ámbito de la propia interfaz siga renombrándose. La segunda regla renombra todo lo demás en Shop.Contracts —fundamentalmente los tipos DTO y sus miembros, que son seguros porque viajan como etiquetas numéricas—. La tercera regla renombra todo el ensamblado del servidor: CalculatorService, tus validadores, los stores internos y los registros de DI reciben renombrado completo, ofuscación de flujo de control y cifrado de cadenas. El nombre de la clase de implementación nunca está en la red —el enlace ocurre a través de la interfaz—, así que puede irse sin problema.
Si sí anotaste cada contrato con [Service]/[Operation], puedes eliminar la regla de keep por completo y dejar que las interfaces también se renombren, porque los nombres de red viven ahora en literales de atributos que Nebula preserva. Para el método suelto que sea una excepción, un atributo sobre el miembro exacto es más preciso que un patrón de configuración y vive junto al código:
[Obfuscation(Feature = "renaming", Exclude = true, ApplyToMembers = false)]
ValueTask<MultiplyReply> Multiply(MultiplyRequest request, CallContext ctx = default);
Ejecuta la protección como parte de la compilación de release, contra la salida publicada:
nebula protect --config nebula.config.json
Las pasadas de renombrado, flujo de control y cifrado de cadenas de Nebula están disponibles en el nivel gratuito para evaluación; las protecciones más pesadas como la virtualización de métodos forman parte de Nebula Pro. Consulta la documentación de Nebula para la sintaxis completa de reglas, y /products/nebula para los niveles.
Advertencias y cuándo se rompe
El modo de fallo sutil es aquel en el que parece funcionar. Si tu cliente y tu servidor referencian el mismo ensamblado de contrato ofuscado, ambos derivan la misma ruta renombrada y las llamadas funcionan en pruebas, y luego se rompen el día en que un cliente se recompila a partir del paquete original, un consumidor que no es .NET entra con grpcurl, o ofuscas un lado y no el otro. La ruta solo es estable porque dos compilaciones coincidieron por casualidad; eso no es un contrato. Fija los nombres de red con [Service]/[Operation] y la coincidencia se vuelve una garantía.
Dos límites honestos más. Primero, los endpoints de reflexión o server-reflection que anuncian tu lista de servicios anunciarán los nombres renombrados si conservaste la nomenclatura derivada: está bien si posees ambos extremos, sorprendente si una herramienta te introspecciona. Segundo, estas reglas cubren solo la superficie del contrato; si diriges el enrutamiento o la serialización mediante cualquier otra reflexión basada en cadenas en tu propio código, esa cadena también tiene carga y debe ir en la keep-list.
La regla que subyace a todo esto es la misma que obedece todo framework guiado por reflexión: un nombre tiene carga exactamente cuando algo fuera de la propia resolución de tokens del CLR lo lee como una cadena. En gRPC code-first ese conjunto es pequeño y conocible —el nombre de tipo de la interfaz de servicio, su espacio de nombres y los nombres de sus métodos— y los miembros de petición y respuesta deliberadamente no están en él, porque protobuf los indexa por número. Fija esos pocos nombres, o decláralos sin rodeos con [Service] y [Operation], y Nebula renombrará la implementación, los internos de los DTO y la lógica de negocio libremente, protegiendo tu propio servicio publicado sin mover jamás una ruta de la que dependa un cliente.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.