SuppressIldasmAttribute no es protección: lo que realmente aporta el anti-ILDASM
Por qué el atributo [SuppressIldasm] detiene a una sola herramienta — y es ignorado por completo en el .NET moderno — además de lo que hace el endurecimiento real de metadatos y cadenas, con C#, IL y configuración de Nebula.
Busca “proteger ensamblado .NET” y alguien te dirá que añadas una línea:
[assembly: System.Runtime.CompilerServices.SuppressIldasm]
La promesa es que tu DLL ya no se puede desensamblar. La realidad es mucho más limitada de lo que imagina casi cualquiera que pega esa línea, y en el .NET moderno no hace nada en absoluto. Esta es una explicación en profundidad de lo que SuppressIldasmAttribute hace realmente, por qué detiene a exactamente un programa, y qué hace falta para que un ensamblado sea genuinamente caro de leer.
Qué es realmente el atributo
SuppressIldasmAttribute no es cifrado, ni un permiso, ni un candado. Es un marcador: un atributo personalizado sin campos que el compilador escribe en los metadatos de tu ensamblado. A nivel de IL no es más que otra entrada .custom en la tabla CustomAttribute:
.custom instance void [System.Runtime]
System.Runtime.CompilerServices.SuppressIldasmAttribute::.ctor() = ( 01 00 00 00 )
Ese ( 01 00 00 00 ) es el blob del atributo: un prólogo de dos bytes y un contador de dos bytes, sin argumentos. Nada de tu código cambia. Cada tipo, cada cuerpo de método, cada cadena literal se escribe en el archivo exactamente igual que antes. Lo único nuevo en el ensamblado es un indicador que dice, en esencia, “por favor, no me desensambles”.
Que alguien respete esa petición depende por completo de la herramienta que lea el archivo.
Exactamente una herramienta escuchó — y dejó de hacerlo
Históricamente, el propio ildasm.exe de Microsoft — el desensamblador de IL que venía con el SDK de .NET Framework — comprobaba este atributo. Si lo encontraba, imprimía // This assembly is protected... y se negaba a volcar el IL. Ese es todo el mecanismo. Era un acuerdo de caballeros entre la herramienta de autoría de Microsoft y la herramienta de desensamblado de Microsoft.
Dos hechos derrumban la protección:
-
Ningún otro lector lo comprobó jamás. ILSpy, dnSpy, dotPeek, JustDecompile, la utilidad
monodisde Mono y los descompiladores modernos, incluido Glass.NET, leen las tablas de metadatos directamente. Ninguno de ellos consulta el indicadorSuppressIldasm, porque nada en el formato ECMA-335 les obliga a ello. Abren el archivo, recorren las tablasTypeDefyMethodDef, resuelven el IL de cada método a partir de su RVA y reconstruyen el C#. El atributo es invisible para ellos. -
En .NET 6 y posteriores, hasta ildasm lo ignora. Ese respeto se eliminó. El atributo todavía compila — está marcado como obsoleto — pero el desensamblador moderno vuelca el ensamblado de todas formas. Así que en cualquier destino .NET actual,
[assembly: SuppressIldasm]es literalmente una operación nula: cambia cuatro bytes de metadatos y no protege nada, ni siquiera frente a la única herramienta para la que se escribió.
El efecto neto, hoy: has añadido un atributo que no hace nada y, posiblemente, te has convencido de que estás protegido cuando no lo estás. Esa segunda parte es el verdadero peligro.
Por qué siempre fue débil: el archivo sigue siendo legible
Aléjate del atributo y observa lo que un ensamblado .NET realmente expone. Los metadatos administrados no son un blob opaco: son un conjunto de streams bien definidos dentro del archivo PE, y los descompiladores se alimentan de ellos directamente.
El heap #Strings guarda el nombre en texto plano de cada tipo, método, campo y parámetro. El heap #US (cadenas de usuario) guarda cada cadena literal que contiene tu código. El stream #~ guarda las tablas que los entrelazan, y el IL de cada método se resuelve a partir de su dirección virtual relativa. Un descompilador abre el archivo y lee estas estructuras. Ese es todo el trabajo.
El indicador SuppressIldasm se sitúa junto a todo esto, en una fila de la tabla CustomAttribute. No elimina ni un solo nombre, no cifra ni un solo literal, no oculta ni un solo opcode. Pide a un lector que mire hacia otro lado, y los datos de los que apartaría la mirada siguen ahí, completos, para todos los demás. Por eso la protección nunca fue significativa, al margen del cambio de .NET 6: lo que valía la pena proteger nunca se tocó.
Lo que realmente eleva el coste
La protección real no pide al lector que sea cortés. Elimina o revuelve la información de la que depende el lector, de modo que un descompilador que ignora todos los indicadores aun así entregue muy poco a su operador.
Renombra los metadatos. El heap #Strings es donde se filtra el significado. CalculateMonthlyAccrual y _remainingTrialDays le dicen al atacante exactamente dónde mirar. Renómbralos a identificadores no imprimibles o en colisión y la salida descompilada se convierte en un laberinto de a.b(c) sin anclas semánticas: los nombres simplemente han desaparecido del heap.
Cifra los literales. El heap #US es el otro delator: la forma de las cadenas de conexión, las rutas de API, los mensajes de error y el texto de comprobación de licencia se leen en claro. Sustituye cada literal por un blob cifrado y un descifrador perezoso, y el heap llevará texto cifrado en lugar de tu lógica de negocio en prosa.
Reconfigura el flujo. El aplanamiento de flujo de control y los predicados opacos atacan la forma de la lógica que sobrevive en los cuerpos de los métodos, de modo que incluso el código reconstruido resiste la lectura.
En Nebula esto es configuración, no atributos. Un nebula.config.json mínimo que hace el trabajo que SuppressIldasm solo finge hacer:
{
"renaming": { "mode": "dictionary" },
"encryptStrings": true,
"controlFlow": { "enabled": true, "opaquePredicates": true },
"antiIldasm": true
}
Luego protege el ensamblado compilado:
nebula protect ./bin/Release/net8.0/Billing.dll \
--config nebula.config.json \
--out ./protected/
Fíjate en que antiIldasm está en esa lista: Nebula emitirá el indicador si se lo pides, porque no cuesta nada y cierra una puerta trivial en los frameworks donde todavía tiene algún efecto. Pero es la última y menos importante línea del archivo, deliberadamente. Las tres líneas que están por encima son las que cambian el resultado. Activar solo antiIldasm y publicar es el error que este artículo entero existe para evitar.
Compruébalo por ti mismo
No tienes que creerlo sin más. Compila un ensamblado con nada más que el atributo y luego ábrelo en cualquier descompilador moderno, incluido uno gratuito como Glass.NET:
# Build with only [assembly: SuppressIldasm] — no other protection
dotnet build -c Release
# Open the output and read the source straight back
glass decompile ./bin/Release/net8.0/Billing.dll --out ./recovered/
Cada nombre de método, cada cadena, cada línea de lógica vuelve. Ahora pasa el mismo ensamblado por nebula protect con la configuración anterior y descompila eso. Los nombres han desaparecido, las cadenas son texto cifrado y el flujo de control se te resiste. Ese contraste es todo el argumento: un enfoque le pide a una herramienta que no mire; el otro elimina lo que la herramienta buscaba.
La conclusión
SuppressIldasmAttribute es una cortesía histórica entre dos herramientas de Microsoft, y esa cortesía terminó en .NET 6. Nunca protegió tu código: le pedía a un único desensamblador heredado que se abstuviera de mostrarlo, mientras dejaba intactos para cualquier otro lector todos los nombres, literales y opcodes. Publícalo si quieres; es gratis e inofensivo. Pero no lo confundas nunca con una defensa. El ensamblado está protegido cuando la información que un atacante necesita no está en el archivo para leerla, y eso es un problema de renombrado, cifrado de cadenas y flujo de control, no de un atributo de una sola línea.
El renombrado y el cifrado de cadenas son funciones Pro en Nebula; la protección agresiva del flujo de control es Enterprise. El atributo está en todos los niveles, porque una casilla que no cuesta nada vale exactamente lo que cuesta.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.