Por qué protobuf-net sobrevive al renombrado
protobuf-net serializa por las etiquetas numéricas de [ProtoMember(N)], no por los nombres de miembro, así que renombrar un DTO de protobuf-net es seguro en el cable, a diferencia de System.Text.Json o DataContract, donde los nombres SON el contrato. Aquí explicamos por qué el renombrado de propiedades es prácticamente gratis con protobuf-net y los cuatro casos que aún se rompen: numeración implícita de campos, nombres de tipo en ProtoInclude/AsReference, modelos por reflexión construidos por nombre de miembro y nombres de ProtoEnum.
Casi todo el consejo sobre ofuscar tipos serializados es una advertencia: no renombres tus DTO, los nombres son el contrato. Eso es correcto para System.Text.Json, Newtonsoft.Json y DataContract/WCF: el nombre del miembro (o un atributo que lo repite) es literalmente la clave que se escribe en el cable, así que renombrar OrderId a a cambia lo que lee el otro extremo. protobuf-net es la feliz excepción, y vale la pena entender el motivo porque invierte el consejo habitual: para los DTO de protobuf-net, el renombrado de propiedades y campos es prácticamente gratis, y solo tienes que pensar en una lista breve de excepciones.
El cable transporta números, no nombres
protobuf-net implementa el formato de cable de los Protocol Buffers de Google. Cada campo en el cable es un par clave/valor, y la clave es un varint construido a partir de un número de campo y un tipo de cable, no una cadena. El número de campo proviene del N que escribiste en [ProtoMember(N)]:
[ProtoContract]
public sealed class OrderLine
{
[ProtoMember(1)] public int OrderId { get; set; }
[ProtoMember(2)] public string Sku { get; set; } = "";
[ProtoMember(3)] public decimal UnitPrice { get; set; }
}
Al serializar, los bytes dicen “campo 1, varint”, luego “campo 2, delimitado por longitud”, etc. La cadena "OrderId" no aparece en ningún sitio de la salida. Ese es todo el truco: el nombre es una etiqueta de tiempo de compilación, y el número de etiqueta es el contrato en tiempo de ejecución.
Por qué eso hace seguro el renombrado
Como el nombre nunca llega al cable, un ofuscador es libre de reescribirlo. Después de que Nebula renombra el tipo, un descompilador ve algo como:
[ProtoContract]
public sealed class b
{
[ProtoMember(1)] public int a { get; set; }
[ProtoMember(2)] public string c { get; set; } = "";
[ProtoMember(3)] public decimal d { get; set; }
}
Los números de [ProtoMember(N)] quedan intactos —son datos en el blob del atributo, no identificadores— así que los bytes serializados son idénticos byte a byte a los de la compilación sin ofuscar. Un cliente antiguo que todavía tiene el OrderLine original lee la salida del servidor renombrado sin problema, y viceversa, porque ambos extremos coinciden en que el campo 3 es el precio unitario. El nombre legible solo existía para tu árbol de código fuente, y la ofuscación es precisamente la transformación que descarta ese árbol.
Esto es una ventaja real frente a los serializadores basados en nombres. Con System.Text.Json, renombrar UnitPrice a d o bien cambia la clave JSON a "d" (rompiendo a todos los consumidores) o te obliga a fijar cada propiedad con [JsonPropertyName("UnitPrice")], momento en el que has vuelto a introducir la misma cadena que intentabas ocultar. protobuf-net no necesita nada de eso. Usa numeración explícita con [ProtoMember(N)] y el renombrado es gratis.
Las cuatro cosas que aún se rompen
La libertad anterior se mantiene precisamente porque la etiqueta es explícita y el nombre está ausente. Cada excepción siguiente es un caso en el que eso deja de ser cierto: o la etiqueta depende del nombre, o el nombre se cuela en el cable o en una búsqueda por reflexión.
1. Numeración implícita de campos
protobuf-net puede asignar las etiquetas por ti:
[ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
public sealed class Customer // PELIGRO al renombrar
{
public int Id { get; set; } // etiqueta 1 implícita
public string Name { get; set; } // etiqueta 2 implícita
public string Region { get; set; } // etiqueta 3 implícita
}
Con ImplicitFields.AllPublic (o AllFields) no hay números explícitos. protobuf-net deriva las etiquetas enumerando los miembros y ordenándolos alfabéticamente por nombre, y luego numerando desde 1. Renombra Name a a y Region a b y el orden alfabético cambia, así que las etiquetas que antes eran Id=1, Name=2, Region=3 pasan a ser otra cosa en silencio: todos los campos se desplazan y el formato de cable se rompe frente a cualquier dato serializado previamente. Reordenar los miembros a mano produce lo mismo.
La solución es no depender de la numeración implícita en nada que ofusques. O conviertes el tipo a [ProtoMember(N)] explícito (la jugada recomendada: es seguro tanto al renombrar como al versionar), o pones el tipo en la keep-list para que sus miembros conserven sus nombres.
2. ProtoInclude, AsReference y manejo de tipos dinámicos
La herencia y el seguimiento de referencias pueden poner en juego un nombre de tipo:
[ProtoContract]
[ProtoInclude(10, typeof(ExpressShipment))]
public abstract class Shipment { [ProtoMember(1)] public string Tracking { get; set; } = ""; }
La forma [ProtoInclude(10, typeof(ExpressShipment))] se basa en la etiqueta (campo 10) y, por tanto, es segura al renombrar: el subtipo se identifica por el número 10, no por "ExpressShipment". Pero dos funciones relacionadas no son seguras por defecto: la serialización de grafos con AsReference y DynamicType pueden incrustar el nombre CLR del tipo calificado por ensamblado para que el lector pueda rehidratar el tipo exacto. Si renombras el tipo, esa cadena incrustada ya no coincide. Prefiere [ProtoInclude(N, typeof(T))] basado en etiqueta antes que DynamicType, y si debes serializar AsReference entre procesos, pon los tipos afectados en la keep-list.
3. Un modelo en tiempo de ejecución construido por nombre de miembro
Si configuras protobuf-net de forma imperativa en lugar de con atributos, puede que estés nombrando miembros como cadenas:
RuntimeTypeModel.Default
.Add(typeof(Customer), applyDefaultBehaviour: false)
.Add(1, "Id")
.Add(2, "Name") // búsqueda por cadena: se rompe tras el renombrado
.Add(3, "Region");
.Add(2, "Name") resuelve "Name" por reflexión al arrancar. Después de que Nebula renombre la propiedad a a, la cadena "Name" ya no coincide con ningún miembro y el modelo no se construye (o omite el campo en silencio). Este es el único caso realmente incompatible con el renombrado, así que estos tipos van en la keep-list o, mejor, migra el registro a la sobrecarga fuertemente tipada .Add(2, nameof(Customer.Name)) y luego ponlo en la keep-list, ya que nameof sigue siendo una cadena de tiempo de compilación grabada en el IL.
4. Nombres de ProtoEnum
Los valores de enumeración se serializan por su valor numérico, así que renombrar miembros de enumeración normalmente está bien. La excepción es un round-trip de nombre explícito:
[ProtoContract]
public enum Priority
{
[ProtoEnum(Name = "LOW")] Low = 0,
[ProtoEnum(Name = "HIGH")] High = 2,
}
[ProtoEnum(Name = "...")] es un literal de cadena en el atributo, así que no le afecta renombrar el miembro de la enumeración, pero sigue siendo una cadena legible en tus metadatos, y si alguna herramienta compara por ese nombre conviene dejarlo en paz. Las enumeraciones simples sin [ProtoEnum(Name=)] no necesitan ningún trato especial.
La keep-list: estrecha por diseño
Pon todo en el renombrado completo y luego exime solo los tipos concretos que caen en los casos 1–3 anteriores. Un nebula.config.json realista:
{
"input": "bin/Release/net8.0/Acme.Orders.dll",
"output": "dist/Acme.Orders.dll",
"rename": { "enabled": true, "scope": "all" },
"strings": { "encrypt": true },
"controlFlow": { "flatten": "sensitive" },
"keep": [
{
"type": "Acme.Orders.Dtos.Customer",
"members": "names",
"reason": "ImplicitFields.AllPublic — tags derive from member names/order"
},
{
"type": "Acme.Orders.Model.*",
"members": "names",
"reason": "RuntimeTypeModel built with .Add(n, \"MemberName\") by string"
}
]
}
"members": "names" preserva los nombres de miembro de esos tipos sin dejar de permitir que Nebula aplique cifrado de cadenas y transformaciones de flujo de control a los cuerpos de sus métodos: solo estás protegiendo los nombres que el serializador necesita, no eximiendo el tipo por completo. Luego protege el ensamblado:
nebula protect --config nebula.config.json
Todo lo que queda fuera de la keep-list —que, en un proyecto protobuf-net bien numerado, es básicamente toda la capa de DTO— se renombra con libertad sin riesgo para el formato de cable.
La regla general
protobuf-net invierte la tensión habitual entre serialización y ofuscación. Como el contrato es la etiqueta numérica y no el nombre del miembro, los DTO con [ProtoMember(N)] explícito son seguros al renombrar por construcción. Concentra el esfuerzo en un solo sitio: encuentra los tipos que dejan que el nombre vuelva a filtrarse al contrato —numeración implícita, AsReference/DynamicType y modelos en tiempo de ejecución con nombres como cadena—, convierte lo que puedas a etiquetas explícitas, pon el resto en la keep-list y deja que Nebula renombre toda la capa de DTO sin pensarlo dos veces.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.