Skip to content
← Todas las publicaciones
· Delta1 Labs ObfuscationNebula

Ofuscar grains de Orleans sin romper el enrutamiento del clúster

Orleans enruta cada llamada a un grain mediante cadenas del manifiesto del clúster: un GrainInterfaceType y un GrainType derivados por defecto de los nombres de tus tipos .NET. Renombra un grain y la identidad se mueve, dejando huérfano el estado persistido y rompiendo las llamadas entre silos. Así se desacopla la identidad con [Alias]/[GrainType] y aun así se ofusca de forma agresiva.

Una aplicación Orleans es un candidato sólido a la ofuscación y fácil de romper. Los grains son el producto —los actores con estado que contienen tu lógica de precios, liquidación, emparejamiento o detección de fraude y se ejecutan sin interfaz en un servidor que quizá no controles— y casi todo ese código puede renombrarse, cifrarse en cadenas y virtualizarse libremente. Pero Orleans tiene una costura en la que un pase ingenuo cae de lleno, y el modo de fallo es del tipo silencioso: el clúster arranca, un cliente se conecta, una llamada se despacha, y el grain que la atendió ayer de repente no está registrado, o su estado persistido ha desaparecido. Nada en tu propio código lanzó una excepción; Orleans simplemente no encontró lo que renombraste.

La causa es específica de cómo Orleans decide qué es un grain, y una vez que lo ves la solución es un puñado de atributos. Este artículo trata de ese mecanismo —cómo Orleans deriva la identidad de un grain a partir de su tipo, por dónde viajan esas identidades, y cómo proteger el valioso interior con Nebula.NET dejando las identidades exactamente donde el clúster las espera.

Resumen

  • Orleans enruta por cadenas del manifiesto del clúster, no por la identidad del tipo .NET: un GrainInterfaceType (qué interfaz) y un GrainType (qué clase de grain), ambos derivados por defecto de los nombres de tus tipos.
  • Un GrainId empieza con el GrainType, así que indexa el estado persistido y los reminders. Cambia el GrainType y ese estado queda huérfano.
  • La serialización es numérica —el serializador moderno codifica los campos por su etiqueta [Id(n)], así que renombrar campos es seguro. Solo la identidad del tipo (su [Alias] o nombre completo) depende del nombre.
  • La solución robusta es desacoplar la identidad del símbolo: fija [GrainType], [GrainInterfaceType] y [Alias] a cadenas fijas, y luego renombra los tipos libremente.
  • Todo lo que hay detrás del grain —servicios, auxiliares, algoritmos— se renombra, cifra y virtualiza sin nada que conservar.

Por qué ofuscar una aplicación Orleans

Las clases de grain son donde vive tu propiedad intelectual: el método que puntúa una transacción, la máquina de estados que liquida una operación, el actor que recalcula un precio cuando el mercado se mueve. Ese código se despliega como un DLL en un host de silo —con frecuencia uno que opera tu cliente— y cualquiera con acceso al archivo puede abrirlo en un descompilador y leerlo de vuelta como C# limpio. La capa de grains es también donde se concentran las constantes sensibles: URLs de endpoints internos, credenciales de socios, material de firma, nombres de proveedores. Elevar el coste de leer tu propia lógica desplegada de vuelta desde ese binario es exactamente el caso legítimo de la ofuscación.

Cómo construye Orleans la identidad de un grain

Aquí tienes una interfaz de grain corriente, su implementación y un tipo de estado serializable, cada uno anotado al estilo moderno de Orleans:

namespace Contoso.Trading.Abstractions;

public interface IOrderGrain : IGrainWithStringKey
{
    Task<decimal> Settle(decimal amount);
}
namespace Contoso.Trading.Grains;

public sealed class OrderGrain : Grain, IOrderGrain
{
    private readonly IPersistentState<OrderState> _state;

    public OrderGrain([PersistentState("order")] IPersistentState<OrderState> state)
        => _state = state;

    public async Task<decimal> Settle(decimal amount)
    {
        // propietario — la razón por la que existe este grain
        var net = _state.State.ApplySettlement(amount);
        await _state.WriteStateAsync();
        return net;
    }
}

[GenerateSerializer]
public sealed class OrderState
{
    [Id(0)] public decimal Balance { get; set; }
    [Id(1)] public int Version { get; set; }

    public decimal ApplySettlement(decimal amount) { /* ... */ return Balance; }
}

Un llamante resuelve el grain por interfaz y lo invoca:

var grain = client.GetGrain<IOrderGrain>("order-7b1e");
var net = await grain.Settle(149.95m);

Nada en esa llamada nombra un silo, una dirección o una clave de enrutamiento. Orleans lo deduce todo a partir de la identidad del tipo expresada como cadenas. Dos cadenas, en concreto, calculadas desde tus tipos y publicadas en el manifiesto del clúster que comparten todos los silos y clientes:

  • Un GrainInterfaceType para IOrderGrain —derivado por defecto del nombre de la interfaz ("ordergrain" más la desambiguación del espacio de nombres)—. Indica al clúster a qué contrato apunta una llamada, y es cómo la referencia de grain generada de un cliente se hace coincidir con una implementación en algún lugar del clúster.
  • Un GrainType para OrderGrain —derivado por defecto del nombre de la clase ("ordergrain")—. Nombra qué clase de grain debe activarse para atender la llamada, y gobierna la colocación (placement).

La propia llamada se convierte en un mensaje que lleva el GrainInterfaceType, un identificador de método y un GrainId destino. Y el GrainId es el silencioso: es GrainType + / + tu clave —

ordergrain/order-7b1e

— así que la cadena GrainType es literalmente el prefijo de la identidad bajo la cual Orleans coloca la activación, almacena [PersistentState] y registra los reminders. El proveedor de almacenamiento escribe OrderState bajo una clave construida a partir de ese GrainId. Cambia el GrainType y cada fila escrita previamente apunta a un grain que el clúster ya no conoce.

Cliente / referencia de grainclient.GetGrain<IOrderGrain>("order-7b1e")internos de la llamada renombrados · cifradosidentidad fijada →GrainInterfaceType: "order"GrainId: order/order-7b1eManifiesto del clúster + colocacióncoincide "order" → activación en siloGrainType indexa estado + remindersSilo / activación de grainOrderGrain : Grain, IOrderGraininterior renombrado · cifrado · virtualizado[GrainType("order")] fija la identidad →GrainType: "order"clave de [PersistentState] sin cambiosFija la identidad con atributos, luego ofusca el tipoAmbos lados anuncian la cadena idéntica → enrutamiento + persistencia se mantienenClases de grain, estado, servicios: renombrados, cifrados, virtualizadosRenombra un tipo sin fijarlo → la identidad se mueve → la llamada no se coloca

Lo que no depende del nombre: la serialización

En OrderState se esconde un alivio. El serializador moderno de Orleans es numérico: el generador de código emite un serializador que lee y escribe el campo 0, el campo 1, etc., indexado por la etiqueta [Id(n)] —nunca por el nombre del campo—. Tras la ofuscación, el símbolo del campo Balance y el serializador generado que lo referencia se renombran juntos, dentro del mismo ensamblado, y los bytes del cable siguen numerados. Así que renombrar las propiedades de un tipo [GenerateSerializer] es completamente seguro, siempre que las etiquetas [Id(n)] se mantengan. La única parte que depende del nombre es la referencia de tipo que el serializador escribe para que el receptor sepa qué construir —y esa usa el [Alias] del tipo o, en su ausencia, su nombre completo.

La solución robusta: desacoplar la identidad del símbolo

El instinto ingenuo es poner en la keep-list todos los tipos de grain y serializables. Funciona, pero deja legibles las clases más valiosas de tu ensamblado. El mejor movimiento es hacer que la identidad de Orleans sea independiente del nombre del tipo .NET, de modo que el símbolo quede libre para ser destruido mientras el manifiesto sigue anunciando una cadena fija. Tres atributos lo logran:

namespace Contoso.Trading.Abstractions;

[GrainInterfaceType("order")]               // fija la identidad de la interfaz
public interface IOrderGrain : IGrainWithStringKey
{
    [Alias("settle")]                       // fija la identidad del método
    Task<decimal> Settle(decimal amount);
}
[GrainType("order")]                        // fija la identidad del grain + prefijo del GrainId
public sealed class OrderGrain : Grain, IOrderGrain { /* ... */ }

[GenerateSerializer, Alias("order-state")]  // fija la identidad del tipo serializado
public sealed class OrderState
{
    [Id(0)] public decimal Balance { get; set; }
    [Id(1)] public int Version { get; set; }
}

Con esto en su sitio, el clúster anuncia "order", hace coincidir las llamadas en "order", construye los GrainId empezando por "order" y escribe el estado bajo "order" —todo con independencia de cómo se llamen las clases—. Nebula.NET queda ahora libre para renombrar OrderGrain a a, IOrderGrain a b, Settle a c y OrderState a d, y nada en el cable ni en el almacenamiento se mueve.

Nota de migración: fija cada identidad al valor por defecto actual primero —la cadena que la compilación sin ofuscar ya anunciaba— para que los GrainId, los reminders y el estado persistido existentes se resuelvan sin cambios. Solo después de confirmar que nada se ha movido deberías ofuscar. Fijar a una cadena nueva es una migración de datos, no un paso de ofuscación.

La keep-list (cuando no puedes añadir atributos)

Si estás ofuscando un ensamblado de grains cuyo código fuente no posees, o simplemente no puedes tocar los tipos, recurre a conservar las identidades por nombre. Modela las interfaces de grain bajo un único espacio de nombres y nebula.config.json queda así:

{
  "schemaVersion": 1,
  "inputs": [
    "publish/Contoso.Trading.Grains.dll",
    "publish/Contoso.Trading.Abstractions.dll"
  ],
  "outputDirectory": "protected",

  "preservePublicApi": false,
  "encryptStrings": true,
  "controlFlowObfuscation": true,

  "renaming": {
    "rules": [
      { "pattern": "Contoso.Trading.Abstractions.*", "action": "keep", "scope": "type-and-members" },
      { "pattern": "*State",                         "action": "keep", "scope": "type" },
      { "pattern": "Contoso.Trading.*",              "action": "rename" }
    ]
  }
}

La primera regla fija cada interfaz de grain y sus métodos (el nombre del método alimenta la identidad del método). La segunda conserva los tipos de estado serializables por nombre para que su referencia de tipo por defecto sobreviva —un sustituto más tosco de [Alias]—. Todo lo demás —clases de grain, servicios, auxiliares— se renombra. El cifrado de cadenas y la ofuscación de flujo de control se aplican por todas partes, incluidos los tipos conservados, porque ninguno toca los nombres. Esto protege menos que el enfoque de atributos, porque los nombres de las clases de grain quedan expuestos; prefiere los atributos siempre que puedas editar el código.

La auditoría: qué se mueve y qué no

Recorre cada identidad que sale del ensamblado y el plan se escribe solo.

  • Tipos de interfaz de grain y sus métodos — construyen el GrainInterfaceType y las identidades de método que un cliente y cada silo hacen coincidir. Fija con [GrainInterfaceType] + [Alias], o conserva por nombre.
  • Clases de grain — construyen el GrainType, que prefija cada GrainId e indexa el estado persistido y los reminders. Fija con [GrainType], o conserva por nombre.
  • Tipos [GenerateSerializer] — se identifican en el cable por alias o nombre completo; los campos se identifican por [Id(n)], no por nombre. Fija el tipo con [Alias] y conserva las etiquetas [Id]; los campos se renombran libremente.
  • Interiores de las clases de grain — el cuerpo de Settle, los auxiliares privados, los servicios que invoca. Resueltos dentro del proceso por DI e identidad de tipo; nada en el cable los nombra. Renombra, cifra, virtualiza.
  • Nombres de proveedores y almacenamiento — "order" en [PersistentState("order")], espacios de nombres de streams, literales de cadena. Datos que reproduces en tiempo de ejecución; el cifrado de cadenas deja intacto el valor en ejecución. No requiere acción.

Una sola superficie que fijar, entonces —las identidades del grain y la interfaz— y todo el interior es terreno libre.

Proteger el interior

Fijar una identidad no significa dejar nada legible. Las cadenas del manifiesto permanecen estables mientras todo lo que hay detrás del grain se oscurece. El cifrado de cadenas oculta las URLs internas, las credenciales y los nombres de proveedor que acumula la capa de grains. Las transformaciones más fuertes —virtualización de código y cifrado de método completo, ambas características Pro en Nebula.NET— van sobre las joyas de la corona: los métodos de liquidación, puntuación o precios, aplicadas a ese puñado de métodos en lugar de a todo el ensamblado:

[GrainType("order")]
public sealed class OrderGrain : Grain, IOrderGrain
{
    [Obfuscation(Feature = "virtualization")]   // Pro — el algoritmo, no la fontanería
    public async Task<decimal> Settle(decimal amount) { /* ... */ return 0m; }
}

El renombrado y la ofuscación de flujo de control se ejecutan ampliamente por debajo, convirtiendo el resto de los interiores de los grains en símbolos sin sentido y ramas enredadas mientras la identidad por la que enruta el clúster permanece exactamente donde estaba.

Integrar la protección en la compilación

Protege la salida publicada, y solo en el servidor de compilación para que la depuración local siga siendo rápida y legible:

dotnet publish Contoso.Trading.Silo -c Release -o publish
nebula protect --config nebula.config.json
<Target Name="NebulaProtect" AfterTargets="Publish"
        Condition="'$(CI)' == 'true'">
  <Exec Command="nebula protect --config nebula.config.json" />
</Target>

Distribuye la carpeta protected/, no la carpeta de publicación en bruto. nebula protect devuelve un código de salida distinto de cero en caso de fallo, así que un paso de protección roto hace fallar la compilación en lugar de distribuir un silo que renombró un grain por el que el resto del clúster todavía enruta.

Verificar que realmente funciona

Las pruebas unitarias no detectarán esto: un TestCluster que construye grains en un solo proceso desde el mismo binario ve identidades consistentes y pasa incluso cuando la identidad se movería a través de un despliegue real y heterogéneo. Dos comprobaciones sí lo detectan. Primero, ejecútalo contra un clúster multi-silo construido desde los DLL protegidos, idealmente con un silo todavía en la compilación anterior para imitar una actualización progresiva, y confirma que una llamada de cliente se coloca y un grain se activa. Una llamada que no encuentra un tipo de grain registrado, o un grain cuyo estado persistido previamente vuelve vacío, es la firma exacta de una identidad movida —compara el GrainType/GrainInterfaceType que anuncia el manifiesto con lo que espera el otro silo.

Segundo, abre el ensamblado distribuido en un descompilador y léelo como lo hará un atacante. Glass.NET es el compañero gratuito, estático-solo, para ese pase: carga el DLL protegido, confirma que las cadenas [GrainType("order")], [GrainInterfaceType("order")] y [Alias] siguen presentes —deben estarlo, para coincidir con el manifiesto— y luego confirma que no queda nada legible dentro del renombrado OrderGrain ni de los servicios que invoca.

La conclusión

Orleans identifica un grain por cadenas —un GrainInterfaceType y un GrainType, derivados por defecto de los nombres de tus tipos .NET, publicados en el manifiesto del clúster y hechos coincidir entre silos y clientes. El GrainType también prefija cada GrainId, así que indexa el estado persistido y los reminders. Renombra un grain y la identidad se mueve en un silo recién compilado: la llamada no puede colocarse y el estado antiguo queda huérfano, sin que nada en tu código lance una excepción. La serialización, por suerte, es numérica —etiquetas [Id(n)], no nombres de campo— así que renombrar campos es seguro. Fija las identidades con [GrainType], [GrainInterfaceType] y [Alias] a los valores que la compilación sin ofuscar ya anunciaba, y el símbolo queda libre para ser destruido: entrega todo el interior del grain a Nebula.NET para renombrar, cifrar cadenas y virtualizar, luego levanta un clúster multi-silo protegido, observa activarse el grain correcto y lee el DLL distribuido para confirmar que la lógica que había detrás ha desaparecido.

Prueba Nebula.NET

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