Skip to content
← Todas las publicaciones
· Delta1 Labs ObfuscationNebula

¿Puede la ofuscación ocultar una cadena de conexión? Qué protege Nebula y qué no

Una cadena de conexión, una clave de API o un secreto de firma que se distribuye dentro de tu aplicación .NET es recuperable en principio: el proceso tiene que usarlo, así que el proceso tiene que retenerlo. Esta es una comparación honesta de los tres lugares donde se esconde un secreto en un ensamblado distribuido, qué cambia exactamente el cifrado de cadenas y de recursos de Nebula.NET en cada uno, dónde está el techo y la estratificación que de verdad mantiene un secreto fuera del alcance de un atacante.

Toda herramienta de protección recibe la misma pregunta, normalmente planteada como una exigencia: “Tengo una cadena de conexión en mi aplicación de escritorio, ¿puedes hacer que nadie pueda leerla?” La respuesta honesta es una comparación, no un sí. Un secreto que se distribuye dentro de código del lado del cliente es recuperable en principio, porque el proceso tiene que usarlo, lo que significa que el proceso tiene que retener el texto claro en algún instante. Lo que la ofuscación cambia es el coste de la recuperación —de “doble clic en un visor de recursos” a “conectar un depurador, encontrar el descifrado, reproducirlo”— y si la cadena está en texto claro para que un volcado de strings.exe o un rastreador web la encuentre.

Este artículo es la comparación completa. Dónde se esconde realmente una cadena de conexión en un ensamblado distribuido, qué hacen el cifrado de cadenas y de recursos de Nebula.NET con cada escondite, dónde está el techo y por qué, y la estratificación que mantiene el secreto fuera del binario por completo cuando es posible.

Los tres lugares donde se esconde un secreto

Una cadena de conexión, una clave de API, una clave simétrica para un archivo de datos embebido: todos llegan al ensamblado distribuido por una de tres rutas, y cada una se descompila de forma distinta.

Como literal en el código. La más común y la más expuesta:

const string Conn = "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;";

El compilador de C# lo emite como un único ldstr en el montón de cadenas. No está cifrado, ni codificado, ni oculto: es texto UTF-16 en una tabla bien conocida:

ldstr      "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;"

Como recurso appsettings.json embebido. Marcas el archivo como EmbeddedResource para que viaje dentro de la DLL:

<ItemGroup>
  <EmbeddedResource Include="appsettings.Production.json" />
</ItemGroup>

Ahora el JSON —cadenas de conexión incluidas— es un blob con prefijo de longitud en la tabla ManifestResource. No hace falta descompilador; System.Resources lo lee, y cualquier visor de recursos también.

Como valor enlazado a través de la configuración. La cadena vive en appsettings.json en disco y IConfiguration la lee hacia un POCO de opciones. Este es el único de los tres que no está en el ensamblado, pero es un archivo de texto claro junto al binario, lo cual es una exposición distinta, no menor.

Observa la división: los dos primeros distribuyen el secreto dentro del binario, donde la ofuscación puede actuar; el tercero lo distribuye junto al binario, donde la ofuscación no alcanza en absoluto. Esa distinción gobierna toda la comparación.

DEFAULT EXPOSUREAFTER NEBULARUNTIME CEILINGconst literalin code (ldstr)"...Password=S3cr3t!"plaintext in string heapstringEncryption →decode call, no literalheld decryptedin memory at useembeddedappsettings.jsonJSON blob in manifestany resource viewer reads itresourceEncryption →ciphertext, resolver decryptsdecrypted whenthe config is readon-diskconfig fileplaintext file beside thebinary — outside the DLLobfuscation cannotreach it — move it outread into processmemory on loadRed = readable in one step · Green = raised to reverse-engineering · Grey = not in the assembly

Qué ve un descompilador antes de la protección

Abre una compilación sin proteger en Glass.NET (o cualquier descompilador) y el caso del literal no requiere esfuerzo alguno. La vista de IL muestra el ldstr; la vista del montón de cadenas lista el valor. Ni siquiera tienes que encontrar el método: el navegador de metadatos de un descompilador lista todas las cadenas del ensamblado, y Server=…;Password=…; queda ordenado justo al lado de tus mensajes de error.

El caso del recurso embebido es peor, porque ni siquiera requiere un descompilador. Expande el nodo de recursos del ensamblado y ahí está el recurso appsettings.Production.json; un clic vuelca el JSON. La BCL incluso trae el lector, así que un programa de cinco líneas lo recupera:

var asm = Assembly.LoadFile(path);
using var s = asm.GetManifestResourceStream("MyApp.appsettings.Production.json");
using var r = new StreamReader(s!);
Console.WriteLine(r.ReadToEnd()); // connection strings and all

“Lo compilé dentro de la DLL” no es protección. Es un nombre de archivo ligeramente menos obvio.

Qué cambia Nebula, en concreto

Nebula.NET actúa sobre los dos casos internos al ensamblado. El cifrado de cadenas reescribe el literal. El ldstr se reemplaza por una llamada a una rutina de descifrado generada que toma un token opaco y devuelve el texto claro en el punto de uso:

ldc.i4     0x3f91a7
call       string <Nebula>.Decode(int32)

La cadena de conexión en claro ha desaparecido del montón de cadenas. Un navegador de metadatos ahora lista un blob codificado; un volcado de strings no encuentra nada; un descompilador muestra una llamada a código protegido en lugar de un valor. Lo acotas en nebula.config.json para que los literales valiosos queden cubiertos sin penalizar una ruta caliente ya medida:

{
  "schemaVersion": 1,
  "inputs": [ "bin/Release/net8.0/MyApp.dll" ],
  "outputDirectory": "protected",

  "stringEncryption": {
    "enabled": true,
    "include": [ "MyApp.Data.*", "MyApp.Security.*" ]
  },

  "resourceEncryption": {
    "enabled": true,
    "include": [ "MyApp.appsettings.Production.json" ],
    "exclude": [ "*.g.resources" ]
  },

  "controlFlow": { "enabled": true }
}

El cifrado de recursos se encarga del JSON embebido. La pasada reemplaza los bytes del recurso en texto claro por texto cifrado en tiempo de compilación e instala un resolutor para que GetManifestResourceStream —y por tanto el proveedor de configuración que lo lee— reciba un flujo que descifra los nombres protegidos. Tu lugar de llamada no cambia:

var config = new ConfigurationBuilder()
    .AddJsonStream(Assembly.GetExecutingAssembly()
        .GetManifestResourceStream("MyApp.appsettings.Production.json")!)
    .Build();

Esto sigue enlazando, porque el resolutor descifra de forma transparente. Lo único que cambió es lo que un visor estático ve en disco: texto cifrado, no una cadena de conexión. Ejecútalo con:

nebula protect --config nebula.config.json --out bin/Protected

Ambas pasadas hacen lo mismo en partes distintas del PE: eliminan la divulgación trivial —el valor que podías leer en un solo paso— y fuerzan cualquier recuperación a pasar por el código ofuscado, donde cuesta esfuerzo real. Esa es toda la afirmación, honesta.

El techo, y por qué existe

Aquí está la parte que un proveedor debería decir sin rodeos: el cifrado no vuelve irrecuperable un secreto del lado del cliente. La clave de descifrado también se distribuye en el ensamblado, porque el proceso tiene que descifrar el valor para usarlo. Nebula deriva esa clave a través de la misma ruta de código protegido que guarda tus métodos —no es una constante en un campo—, de modo que recuperarla implica aplicar ingeniería inversa a código con flujo aplanado y cadenas cifradas en lugar de leer un literal. Eso es un gran aumento de coste. No es infinito.

El límite más agudo es el tiempo de ejecución. En el instante en que tu código hace esto:

using var conn = new SqlConnection(decryptedConnString);

la cadena de conexión en claro existe como un string vivo en el montón administrado. Un atacante que pueda ejecutar tu proceso —cosa que, en una máquina cliente, puede— puede conectar un depurador, parar en SqlConnection..ctor y leer el argumento. Sin descompilar. Lo mismo ocurre con el appsettings.json descifrado: una vez que el proveedor de configuración lo ha leído, los valores son objetos en memoria. La ofuscación eleva el listón contra la inspección estática y contra volcados casuales. No puede ganar contra un depurador conectado a un proceso que está a punto de usar el secreto, porque en ese momento el secreto es, por necesidad, texto claro.

Esto no es una debilidad específica de Nebula; es la naturaleza de los secretos del lado del cliente. Cualquier herramienta que afirme lo contrario está vendiendo la afirmación, no la protección.

La estratificación que sí funciona

Por culpa de ese techo, la verdadera estrategia es una jerarquía, y la ofuscación es el último nivel, no el primero.

Nivel 1: no distribuyas el secreto. Una cadena de conexión a un servidor que tú controlas, una clave de API de terceros, cualquier cosa que autentique al cliente contra un backend: esto no debería estar en el binario en absoluto. Mantenlo fuera del código fuente con user-secrets en desarrollo, suminístralo desde una variable de entorno o la identidad administrada de tu plataforma en producción o —mejor— nunca entregues al cliente una credencial de larga duración y, en su lugar, intermedia el acceso para que el servidor emita un token efímero y acotado. Un secreto que nunca está en el artefacto no tiene coste de recuperación porque no hay nada que recuperar. La ofuscación es irrelevante para el Nivel 1, y eso es lo importante: la protección más fuerte es la ausencia.

Nivel 2: para el secreto que de verdad debes embeber, eleva el coste. Algunos secretos tienen que distribuirse: la clave pública que tu app usa para verificar una licencia, una clave simétrica que descifra un archivo de datos propietario embebido, un certificado anclado. Estos no pueden trasladarse a un servidor porque la app debe funcionar sin conexión o no debe confiar en la red para esta comprobación. Para estos, Nebula es exactamente la herramienta adecuada. Cifra el literal, cifra el recurso, aplana el flujo de control alrededor de la derivación y —para la rutina de mayor valor— virtualiza el método para que la derivación de la clave se ejecute sobre un conjunto de instrucciones interpretado en lugar de IL legible. No estás haciendo imposible la recuperación; la estás haciendo lo bastante cara como para que no merezca la pena en relación con lo que el secreto protege.

La decisión es una tabla breve.

El secreto¿Puede salir del binario?Tratamiento
Cadena de conexión a BD, clave de API de backendSí — autentica contra tu servidorNivel 1: intermédialo, emite tokens efímeros
Clave de terceros ligada a tu cuentaNormalmenteNivel 1: haz de proxy de la llamada por tu backend
Clave pública de verificación de licenciaNo — debe verificar sin conexiónNivel 2: distribúyela, cifra cadenas + flujo de control
Clave simétrica de un archivo de datos embebidoNo — la app debe descifrar en localNivel 2: cifra el recurso + virtualiza la derivación

El error es saltarse el Nivel 1 y pedirle a la ofuscación que haga su trabajo. La ofuscación vuelve costoso de extraer un secreto que debe distribuirse. No hace nada por justificar la distribución de un secreto que nunca tuvo que estar ahí.

Verifica lo que distribuiste

Tras una compilación protegida, confirma que los dos casos internos al ensamblado están realmente cerrados. Abre protected/MyApp.dll en Glass.NET: el montón de cadenas ya no debería listar tu cadena de conexión, y el recurso appsettings.Production.json debería volcarse como texto cifrado, no como JSON. Conviértelo en una barrera de CI: un script que abra la salida protegida, verifique que ningún recurso se descodifica a JSON reconocible y que ningún literal coincide con un patrón Password=, y que haga fallar la compilación si alguno lo hace. Eso detecta el día en que alguien añade un nuevo literal portador de secreto a un espacio de nombres que tu lista include no cubre.

Un binario protegido que todavía hace grep-match con tu contraseña significa que la pasada no lo alcanzó; uno limpio significa que has hecho todo lo que la ofuscación del lado del cliente puede hacer, y has dicho la verdad sobre dónde termina eso.

Consulta Nebula.NET para la canalización completa de transformaciones y la referencia de nebula.config.json, cifrar recursos embebidos para la pasada de recursos en profundidad, y Glass.NET para verificar lo que un descompilador aún puede leer.

Prueba Nebula.NET

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