Skip to content
← Todas las publicaciones
· Delta1 Labs NativeAOTGlass

Lo que un descompilador ve en un binario NativeAOT

Dale a Glass una biblioteca publicada con NativeAOT y no obtienes nada: ni C#, ni IL, ni siquiera una lista de métodos. Esta es la razón a nivel de PE, qué metadatos sobreviven dentro de la imagen nativa y por qué NativeAOT no es el ofuscador que la gente supone.

Publica una biblioteca con NativeAOT, entrega el resultado a un descompilador y no obtendrás nada útil de vuelta. Ni C# reconstruido, ni listado de IL, ni siquiera una lista de métodos: la mayoría de las herramientas simplemente informan de que el archivo no es un ensamblado .NET. Los ingenieros lo toman como prueba de que NativeAOT es «ofuscación gratis». No lo es, pero vale la pena entender con exactitud el motivo por el que lo parece, porque te dice precisamente qué necesita un descompilador y cuáles de esas cosas elimina NativeAOT.

La pregunta de fondo

Un descompilador convierte un DLL de vuelta en C#. Para ello necesita dos cosas concretas, y solo esas dos: metadatos que describan los tipos y miembros, y cuerpos de método en IL que contengan las instrucciones. Todo lo que Glass te muestra —el árbol de tipos, las firmas, el C# recuperado— se reconstruye a partir de ellos. Así que la pregunta no es «¿es NativeAOT una magia especial?». Es simplemente: ¿un binario NativeAOT sigue conteniendo metadatos e IL? La respuesta es no, y la mecánica del porqué es concreta.

Qué lleva un ensamblado gestionado

Empecemos con un ensamblado normal compilado por JIT, porque es la base que un descompilador espera. Es un archivo PE (Portable Executable) con una cosa extra que un ejecutable nativo no tiene: una cabecera CLI. La cabecera opcional del PE tiene un array de directorios de datos, y la entrada 14 —IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR, el directorio «.NET»— apunta a una IMAGE_COR20_HEADER. Esa cabecera COR20 es la puerta a todo lo gestionado. Contiene el RVA de la raíz de metadatos, que a su vez expone los flujos de ECMA-335: #~ (las tablas: TypeDef, MethodDef, firmas), #Strings, #US, #Blob, #GUID.

Cada fila de la tabla MethodDef lleva un RVA que apunta a un cuerpo de método en IL dentro del PE. Un descompilador lee las tablas para reconstruir la forma de tipos y miembros, sigue el RVA de cada MethodDef hasta su IL y ejecuta la recuperación de IL a C#. Un método de una sola línea es toda la cadena en miniatura:

public static int Add(int a, int b) => a + b;
.method public hidebysig static int32 Add(int32 a, int32 b) cil managed
{
  .maxstack 2
  ldarg.0
  ldarg.1
  add
  ret
}

Ese IL es lo que sobrevive en un DLL normal, y es lo que Glass convierte de vuelta en a + b. Lo primero que hace cualquier descompilador al abrir es leer la entrada 14 del directorio de datos. Si está presente, el archivo es gestionado y la cadena se ejecuta. Si es cero, el archivo es un binario nativo corriente y no hay nada que descompilar.

Qué distribuye NativeAOT en su lugar

NativeAOT invierte esto. El compilador de IL (ILC) toma tu IL y el de cada dependencia y compila el programa completo, de mundo cerrado, a código máquina nativo de forma anticipada. El ensamblado gestionado es una entrada de esa compilación, se consume y se descarta; nunca se distribuye. Lo que distribuyes es una única imagen nativa: en Windows un PE cuya sección .text contiene código máquina x64/arm64, en Linux un ELF, en macOS un Mach-O.

Fundamentalmente, ese PE de salida no tiene cabecera CLI. La entrada 14 del directorio de datos es cero. No hay cabecera COR20, así que no hay raíz de metadatos, así que no hay tablas #~ ni RVA de MethodDef, así que no hay cuerpos de método en IL. El Add de arriba es ahora algo como el nativo lea eax, [rcx+rdx]; ret bajo un símbolo con nombre mutilado, si es que ILC lo conservó como función independiente en lugar de integrarlo por completo. La primerísima comprobación de un descompilador falla:

$ glass decompile MyLib.dll --to csharp
error: not a managed assembly — the COM descriptor directory is empty.
       This is a native image (NativeAOT or an unmanaged binary); there is no IL to decompile.
Ensamblado JIT (se descompila) Dir datos [14] → cabecera COR20 Metadatos: tablas #~, #Strings, #Blob, #US (TypeDef, MethodDef) Cuerpos IL (por RVA de MethodDef) lee metadatos + IL → C# reconstruido Binario NativeAOT (no) Dir datos [14] = 0 (sin cabecera CLI) .text: código máquina nativo (símbolos mutilados, sin IL) Blob de reflexión reducido (solo nombres) sin raíz de metadatos, sin MethodDef → solo herramientas nativas
El punto de entrada del descompilador es el directorio de datos 14. Un ensamblado JIT lo rellena; una imagen NativeAOT lo deja vacío, así que no hay IL que recuperar.

Qué sobrevive aun así

«Sin IL» no significa «sin información». ILC no puede descartarlo todo, porque el runtime todavía tiene que dar soporte a la reflexión que tu programa realmente usa. Por eso una imagen NativeAOT incrusta un blob de metadatos de reflexión reducido: nombres y formas de los tipos y miembros que siguen siendo visibles por reflexión tras pasar el recortador, además de lo que fuerces a permanecer con conmutadores de características o archivos de directivas de runtime. El runtime recorre ese blob para responder a typeof(T).GetMethods(); un analista decidido también puede recorrerlo.

Esa es la filtración honesta. El blob contiene nombres —Customer, ComputeDiscount, ApiKey— no el cuerpo de ComputeDiscount. Puedes conocer la superficie superviviente de un tipo, no su algoritmo. Junto a él, las cadenas corrientes de .rdata son visibles, y si se emitieron símbolos, las funciones nativas llevan nombres (mutilados). La lógica en sí es código nativo que abordarías con un desensamblador nativo como Ghidra o IDA, no con Glass, que es una herramienta de IL a C# y que, con razón, declina.

Cómo se aplica esto

Reconocerlo. Glass te dice que un archivo es una imagen nativa en lugar de fallar en silencio. Si quieres confirmarlo a mano, lee el directorio de datos de la cabecera opcional del PE: la entrada 14 con RVA/tamaño a cero significa que no hay cabecera CLI y, por tanto, que no es un ensamblado gestionado. Una entrada 14 presente y distinta de cero significa que es gestionado, y entonces se descompila, sea R2R o no. (ReadyToRun conserva su IL; véase Por qué los ensamblados ReadyToRun siguen descompilándose limpiamente.)

Recuperar tu propio código fuente perdido. Si publicaste una compilación con NativeAOT y perdiste las fuentes, la imagen nativa no te las devolverá: no hay IL que extraer. Conserva tus artefactos de compilación y tus PDB; el binario distribuido es una puerta de un solo sentido.

Triaje de seguridad. Una muestra NativeAOT resiste la descompilación de IL, así que cambias de enfoque: enumera el blob de reflexión en busca de nombres de tipo supervivientes, extrae las cadenas de .rdata y desensambla el código nativo. La ausencia de una cabecera CLI es en sí misma una señal útil sobre cómo se construyó la muestra.

Cuándo se rompe la creencia de la «ofuscación»

NativeAOT sí elimina la vía de recuperación de IL a C#, y eso es un beneficio colateral genuino si te preocupaba la descompilación trivial de un clic. Pero trátalo como un efecto secundario, no como un producto de protección, porque la creencia se rompe en cuatro puntos:

  • El código nativo sigue siendo reversible. Ghidra e IDA leen código máquina todo el día. Has cambiado una lectura fácil de IL por una lectura nativa más difícil, no por secreto.
  • Sin renombrado, sin protección de flujo de control. NativeAOT no renombra ni transforma nada por secreto; compila fielmente.
  • Los metadatos de reflexión filtran nombres. El blob superviviente puede exponer los nombres de tus tipos y miembros. Minimizar la reflexión lo reduce, pero no puedes confiar en él para ocultar nada.
  • Te impone restricciones. Sin generación de código en runtime, reflexión limitada, un único binario específico de plataforma, mayor tamaño de salida, depuración más difícil. Nadie adopta NativeAOT por el efecto secundario sobre la descompilación: lo adoptan por el arranque y la huella.

Si el objetivo real es proteger la propiedad intelectual en un ensamblado que sigues distribuyendo como IL, eso es un trabajo distinto, hecho a nivel de IL —renombrado, cifrado de cadenas, transformación de flujo de control— por un ofuscador como Nebula.NET. NativeAOT y la ofuscación responden a preguntas distintas; confundirlas te deja expuesto en la que de verdad necesitabas.

Conclusión

Un descompilador necesita una cabecera CLI, metadatos e IL. Un ensamblado JIT tiene las tres cosas y se abre en C# limpio. Un binario NativeAOT no tiene ninguna: su directorio de datos .NET está vacío, su lógica es código máquina nativo y lo único gestionado que queda es un blob de reflexión reducido de nombres. Eso lo hace indescompilable en el sentido de C#, pero es la arquitectura la que lo consigue, no la ofuscación, y los nombres que sobreviven, junto con la apertura del código nativo, son exactamente la razón por la que no debes confundir una cosa con la otra. Glass es gratis; apúntalo a un ensamblado gestionado y te mostrará todo, y te dirá claramente cuándo no hay nada que mostrar.

Prueba Nebula.NET

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