Qué ofuscar en una solución .NET Aspire
Un AppHost de Aspire es orquestación en tiempo de desarrollo que nunca distribuyes; los ensamblados que llegan a producción son los servicios individuales. Aquí está por qué el renombrado es seguro a través de la frontera entre servicios, qué ensamblados proteger y los pocos miembros que aún debes conservar.
Un equipo adopta .NET Aspire, monta un AppHost y llega al momento de distribuir. La primera pregunta es casi siempre la equivocada: «¿cómo ofusco mi aplicación de Aspire?». No hay una única aplicación de Aspire que ofuscar. Una solución de Aspire es un conjunto de servicios .NET corrientes más un modelo de tiempo de desarrollo que describe cómo encajan entre sí. Saber cuáles de esos ensamblados llegan realmente a un cliente — y cuáles nunca salen de tu máquina de compilación — decide toda la estrategia de protección, y es más sencillo de lo que parece.
El AppHost es un plano, no un binario que distribuyes
Abre una solución de Aspire recién creada y obtienes tres clases de proyecto: el AppHost, una biblioteca compartida ServiceDefaults y uno o más servicios (una API, un front end web, workers). Resulta tentador tratar el AppHost como la aplicación, porque es donde pulsas F5. No lo es. El AppHost es un modelo de orquestación. Su único trabajo es construir un grafo de recursos y sus relaciones:
var builder = DistributedApplication.CreateBuilder(args);
var api = builder.AddProject<Projects.ApiService>("apiservice");
builder.AddProject<Projects.Web>("webfrontend")
.WithReference(api);
builder.Build().Run();
Esos tipos Projects.ApiService y Projects.Web no son algo que escribiste. El generador de código fuente de Aspire emite un tipo de metadatos por cada proyecto referenciado dentro del ensamblado del AppHost, portando la ruta del proyecto para que el host pueda lanzarlo. El AppHost los usa en tiempo de desarrollo para arrancar procesos, y en tiempo de publicación para emitir un manifiesto de despliegue (aspire-manifest.json) que una herramienta de despliegue consume. En ninguno de los dos modos el ensamblado del AppHost viaja a producción como código en ejecución que tu cliente pueda desmenuzar. Es un artefacto de compilación.
Así que la primera regla se escribe sola: no ofusques el AppHost. No hay PI en un grafo de recursos que un atacante no pudiera reconstruir observando la topología desplegada, los tipos Projects.* generados son fontanería del compilador, y el paso del manifiesto quiere un ensamblado limpio y predecible. Exclúyelo y gasta el presupuesto de protección donde el código realmente se distribuye.
Los servicios hablan por nombre, no por tipo
La propiedad que hace que Aspire sea agradable de ofuscar es cómo se encuentran los servicios entre sí. Cuando el front end web llama a la API, no mantiene una referencia a un tipo de la API. Hace una llamada HTTP a un nombre lógico:
builder.Services.AddHttpClient<ApiClient>(c =>
c.BaseAddress = new("https+http://apiservice"));
apiservice es el nombre que le diste al recurso en el AppHost, nada más. En tiempo de ejecución, el descubrimiento de servicios lo resuelve desde la configuración que el orquestador inyecta como variables de entorno al arrancar el proceso — una clave por endpoint:
Services__apiservice__https__0 = https://10.0.3.14:8443
Services__apiservice__http__0 = http://10.0.3.14:8080
Lee eso con atención, porque es todo el argumento. El vínculo entre dos servicios es una cadena de configuración y una URL de endpoint. No es un nombre de tipo obtenido por reflexión, ni un nombre de ensamblado, ni un método. Cuando Nebula renombra ApiService.OrderController.PlaceOrder a a.b.c, el front end web sigue llamando a https+http://apiservice/orders y sigue resolviendo apiservice desde la misma clave inyectada. El renombrado no puede alcanzar el otro lado de la frontera de proceso, porque la frontera de proceso es una frontera HTTP y nada gestionado la cruza.
Esta es una posición genuinamente mejor que la de un monolito en proceso. En un monolito, dos componentes que comparten un tipo gestionado deben renombrarse con un único mapa coordinado o la identidad del tipo compartido se desalinea. Los servicios de Aspire nunca comparten un tipo gestionado en tiempo de ejecución — comparten un contrato de cable — así que puedes ofuscar apiservice.dll y webfrontend.dll con semillas independientes sin ninguna coordinación.
Las tres cosas que aún muerden
La independencia se detiene exactamente en los datos que cruzan el cable, y en el proyecto compartido contra el que ambos servicios compilan. Tres superficies requieren cuidado.
DTO serializados. El contrato HTTP es JSON, y System.Text.Json enlaza por nombre de propiedad. Si apiservice devuelve un OrderResult y webfrontend lo deserializa, ambos lados coinciden en "orderId", "total", etc. — por nombre. Renombra la propiedad en cualquiera de los lados y el campo desaparece silenciosamente de la carga útil:
// antes — serializa { "orderId": 4012, "total": 59.90 }
public sealed class OrderResult
{
public int OrderId { get; set; }
public decimal Total { get; set; }
}
// tras un renombrado ciego — la clave JSON cambia con el nombre de la propiedad
.property instance int32 a() { .get instance int32 OrderResult::get_a() }
// System.Text.Json ahora escribe { "a": 4012, ... } y el llamador ve null
La corrección es la misma regla de conservación que necesita cualquier tipo web serializado: excluye las propiedades del DTO del renombrado, o fija los nombres con [JsonPropertyName] para que la clave del cable se desacople del nombre del miembro. La lista de conservación de Nebula gestiona esto de forma declarativa — haz coincidir el espacio de nombres del DTO y conserva los nombres de propiedad públicos, mientras los cuerpos de los métodos y todo lo interno permanecen totalmente ofuscados.
Enlace de configuración. Los servicios enlazan opciones desde la configuración — incluidos los valores de descubrimiento de servicios y de cadena de conexión que Aspire inyecta. builder.Services.Configure<SmtpOptions>(config.GetSection("Smtp")) hace coincidir SmtpOptions.Host con la clave Smtp:Host por nombre de propiedad. Renombrado, el enlace devuelve un valor por defecto y la función se configura mal en tiempo de ejecución sin excepción. Las clases de opciones enlazadas desde la configuración pertenecen a la lista de conservación por la misma razón que los DTO.
ServiceDefaults. Este es el único ensamblado compartido en forma gestionada en lugar de por el cable. El Program.cs de cada servicio llama a él:
builder.AddServiceDefaults(); // OpenTelemetry, health checks, descubrimiento de servicios
// ...
app.MapDefaultEndpoints(); // /health y /alive
AddServiceDefaults es un método público en ServiceDefaults.dll, llamado desde cada ensamblado de servicio. Si ofuscas ServiceDefaults.dll por separado y renombras ese método público, cada llamador se rompe — el punto de llamada en apiservice.dll sigue buscando AddServiceDefaults. La respuesta no es mantener el nombre del método público para siempre; es ofuscar la solución como una unidad, para que el renombrador reescriba el método y todos sus puntos de llamada juntos a través de los ensamblados. Esto es ofuscación multiproyecto corriente: agrupa ServiceDefaults con sus consumidores bajo una sola ejecución, y la fontanería pública puede renombrarse libremente porque el ofuscador ve ambos extremos. Observa que las cadenas de endpoint "/health" y "/alive" son literales, no símbolos — el renombrado no las toca y siguen funcionando.
Adónde van las transformaciones pesadas
Con las fronteras conservadas, dirige la protección de verdad al código que aporta valor dentro de cada servicio: comprobaciones de licencia y de derechos, lógica de precios y de cuotas, derivación de claves, cualquier algoritmo propietario. Aplica aplanamiento del flujo de control, cifrado de cadenas y — en los pocos métodos que justifican el coste en tiempo de ejecución — virtualización de código a esos métodos en concreto, exactamente como harías en una compilación de un solo servicio. La forma de Aspire no cambia qué proteges; solo cambia el empaquetado a su alrededor. Una configuración razonable de Nebula ofusca cada proyecto de servicio, conserva la superficie serializada y enlazada por configuración, excluye el AppHost y se ejecuta sobre la salida de compilación antes de que dotnet publish produzca las imágenes de contenedor:
{
"input": "apiservice.dll",
"keep": [
"ApiService.Contracts.*",
"ApiService.Options.*"
],
"controlFlow": "aggressive",
"stringEncryption": true,
"virtualize": [ "ApiService.Licensing.*" ]
}
Conclusión
Una solución de Aspire no es una aplicación con una historia de protección especial; son varios servicios corrientes cuyo acoplamiento resulta ser basado en cadenas y fuera de proceso, orquestados por un AppHost que nunca distribuyes. Eso deja la estrategia limpia: omite el AppHost, ofusca cada servicio con su propia semilla, conserva las superficies JSON y de configuración que cruzan la frontera, y ofusca ServiceDefaults junto con los servicios que lo llaman. Luego apunta las transformaciones pesadas a la lógica de cumplimiento y de negocio dentro de cada proceso — que es donde siempre debieron estar. Para la referencia completa de reglas de conservación, consulta la documentación de configuración de Nebula, y verifica el resultado con Glass.NET.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.