Skip to content
← Todas las publicaciones
· Delta1 Labs ReadyToRunNebula

Acertar el orden de ReadyToRun y la ofuscación

Una compilación ReadyToRun es una imagen doble: tu IL más una copia nativa de él, compilada por crossgen a partir del aspecto que tenía el IL en el momento de la publicación. Ofusca después de crossgen y esa copia nativa es un registro limpio e independiente de cualquier decompilador de tu lógica original; además invalida la imagen R2R, así que el runtime vuelve silenciosamente al JIT. Esto es por qué el orden lo decide todo, y cómo conectar Nebula para que crossgen compile IL protegido.

La mayoría de los consejos sobre protección de .NET tratan la ofuscación y la publicación como dos pasos independientes que puedes hacer en cualquier orden. Para una compilación corriente dependiente del framework eso es más o menos cierto. Para una compilación ReadyToRun no lo es, y equivocar el orden produce un artefacto enviado que filtra justo la lógica que ofuscaste, mientras tira silenciosamente a la basura la ventaja de arranque por la que activaste R2R.

La razón es estructural, no un error: un ensamblado ReadyToRun no es una representación de tu código, son dos. La ofuscación solo toca una de ellas. Este artículo trata de cuál, de por qué la segunda copia se compila a partir del aspecto que tenía la primera en el momento en que se ejecutó crossgen, y de cómo secuenciar Nebula.NET para que ambas copias acaben protegidas.

Qué produce realmente una compilación ReadyToRun

PublishReadyToRun=true ejecuta el compilador crossgen2 durante dotnet publish. Crossgen lee los ensamblados gestionados y, para cada método, emite código máquina nativo de forma anticipada, incrustándolo en el ensamblado junto con una cabecera ReadyToRun. El objetivo es un arranque más rápido: el runtime puede ejecutar el código nativo precompilado en lugar de compilar el método con el JIT en la primera llamada.

El hecho crítico —el que decide toda la cuestión del orden— es que ReadyToRun no es Native AOT. No elimina tu IL. El ensamblado publicado sigue siendo un ensamblado .NET completamente corriente: metadatos completos, IL completo, cuerpos de método gestionados completos, más una sección de código nativo que duplica los métodos calientes. El IL permanece porque es el respaldo autoritativo. Si la imagen R2R no es válida para el runtime actual —arquitectura incorrecta, un desajuste de burbuja de versión, un módulo modificado— el CLR descarta el código nativo y compila con el JIT a partir del IL. R2R es una optimización superpuesta sobre tu ensamblado, nunca un sustituto de él.

Así que tras una publicación ReadyToRun estás enviando dos codificaciones independientes de cada método precompilado:

  • el cuerpo de método IL, que un decompilador convierte de nuevo en C# casi original, y
  • la compilación nativa de ese mismo método, que un desensamblador nativo lee directamente.

La ofuscación es una transformación de IL a IL. Reescribe la primera codificación. No puede tocar la segunda: el código nativo es opaco para ella. La única palanca que tienes sobre la copia nativa es el aspecto que tenía el IL cuando crossgen lo compiló.

La trampa del orden

Imagina la tentadora cadena: compilar, publicar con ReadyToRun y luego ejecutar el ofuscador sobre la carpeta de publicación terminada porque ese es el artefacto que envías. Parece correcto —proteger la cosa que entregas—. Es exactamente al revés.

Para cuando tu ofuscador se ejecuta, crossgen ya ha compilado el código nativo a partir de tu IL limpio y sin ofuscar. Tu comprobación de licencia, tu rutina de derivación de claves, tus cálculos de precios: todo ello está ahora en la sección nativa como una implementación en código máquina fiel y totalmente optimizada del algoritmo original. Tu ofuscador entonces aplana la copia IL de ese método, cifra sus cadenas, quizá lo virtualiza. La copia IL queda bellamente protegida. La copia nativa, compilada minutos antes, es un segundo registro intacto de la misma lógica que ninguna transformación de IL alcanzará jamás. Un atacante simplemente desensambla el método nativo y lee el flujo de control que creías haber ocultado.

Hay un segundo fallo, más silencioso, apilado encima. La ofuscación reescribe el módulo: nuevos tokens de metadatos, nuevos nombres, nuevos cuerpos de método, un nuevo MVID. La imagen ReadyToRun estaba ligada al módulo anterior a la ofuscación. Mutar el ensamblado tras crossgen invalida las comprobaciones de integridad y de versión de la cabecera R2R, así que en el momento de carga el runtime rechaza la imagen nativa y vuelve a compilar el IL con el JIT. Pagaste el coste de tamaño de R2R, enviaste una copia nativa de tu lógica desprotegida y perdiste la ventaja de arranque. Tres malos resultados de un solo error de orden.

Obfuscate before crossgen — native code is compiled from protected ILManaged ILNebulaobfuscate ILcrossgen2emit nativeR2R imageIL + native both protectedObfuscate after crossgen — native copy keeps the original logic, R2R is discardedManaged ILcrossgen2emit nativeNebularewrites IL onlyLeaky artifactclean native + R2R invalidnative copyunprotected

Ofusca antes de crossgen

La regla sale directamente del diagrama: el IL que crossgen compila ya debe estar ofuscado. En concreto, la ofuscación tiene que suceder después de que el compilador de C# produzca tus ensamblados y antes de que dotnet publish ejecute el paso ReadyToRun. Hay dos formas limpias de organizarlo.

CI en dos etapas. Compila, ofusca la salida compilada y luego publica con ReadyToRun apuntando a los ensamblados ya protegidos:

dotnet build -c Release -p:PublishReadyToRun=false
nebula --config nebula.config.json            # rewrites the IL in place
dotnet publish -c Release --no-build \
  -p:PublishReadyToRun=true -o out            # crossgen now compiles protected IL

El nebula.config.json mantiene todo lo que R2R y la reflexión necesitan, y aplica las transformaciones pesadas donde importan:

{
  "schemaVersion": 1,
  "inputs": ["bin/Release/net8.0/MyApp.dll", "bin/Release/net8.0/MyApp.Core.dll"],
  "outputDirectory": "bin/Release/net8.0",
  "preservePublicApi": true,
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "autoProtectLicensing": true
}

Como crossgen lee los ensamblados en bin/Release/net8.0 en el momento de la publicación, el código nativo que emite se compila a partir del IL aplanado y con cadenas cifradas: las dos codificaciones ahora concuerdan, y ambas están protegidas.

Un hook de MSBuild, para que un dotnet publish simple ya sea correcto. Lo único que importa es que el Exec de ofuscación se ejecute antes de la compilación ReadyToRun del SDK, no después:

<Target Name="NebulaProtect" AfterTargets="Build" BeforeTargets="Publish">
  <Exec Command="nebula --config $(ProjectDir)nebula.config.json" />
</Target>

Uses la que uses, el principio es el mismo que gobierna Native AOT y la publicación de archivo único: la protección pertenece al IL gestionado, entre la compilación y la publicación. R2R solo eleva lo que está en juego, porque aquí el paso de publicación no se limita a empaquetar tu IL: compila una segunda copia independiente de él.

Cómo se ve cada codificación

Toma un método de aplicación de licencias representativo:

public bool IsLicensed(string key)
{
    if (!key.StartsWith("LIC-")) return false;
    return ValidateSignature(key, "https://api.example.com/v1/activate");
}

Ofusca el IL antes de crossgen y la copia IL se decompila a un dispatcher aplanado con el prefijo y el endpoint extraídos del almacén de cadenas cifradas en tiempo de ejecución:

public bool a(string A_0)
{
    int s = 0;
    while (true) { switch (s) {
        case 0: if (!A_0.StartsWith(Strings.Get(0x3f1))) { s = 9; break; } s = 4; break;
        case 9: return false;
        case 4: return b(A_0, Strings.Get(0x412));
        /* ... */ } }
}

Fundamentalmente, el método nativo que crossgen produce es ahora una compilación de ese dispatcher: la misma estructura opaca de ramas, ninguna URL literal, nada que leer con claridad. Ten en cuenta que los literales de cadena de .NET viven en el heap de metadatos #US, no incrustados en el código nativo, así que el cifrado de cadenas protege ambas codificaciones a través de los metadatos, independientemente de R2R; es el flujo de control y la forma del algoritmo lo que la copia nativa expondría de otro modo, y aquí expone la forma ofuscada.

Ofusca después de crossgen y la copia IL se ve idéntica a la versión protegida de arriba, pero la sección nativa es una traducción directa a código máquina del original limpio: una comparación de prefijo reconocible, una llamada a la validación de firma, la estructura de ramas de tu método real, totalmente optimizada y perfectamente legible para cualquiera que desensamble la imagen R2R. La ofuscación del IL fue trabajo real gastado en proteger la copia que nadie necesita leer.

Verificar que la compilación R2R está realmente protegida

Dos comprobaciones rápidas convierten la garantía de orden en evidencia:

  1. La imagen R2R está presente y es válida. Tras la publicación protegida, confirma que el ensamblado sigue llevando una cabecera ReadyToRun (las herramientas crossgen2/r2rdump del SDK la volcarán). Si la ofuscación hubiera corrido después de crossgen, la imagen estaría ausente o sería rechazada en la carga y volverías silenciosamente al JIT, así que una cabecera válida es la prueba de que el orden se mantuvo.
  2. Los cuerpos de método nativos mapean a miembros renombrados. Vuelca la lista de métodos R2R; los entrypoints deberían corresponder a los identificadores renombrados por Nebula (a, b, …), porque se compilaron a partir de los metadatos ofuscados. Que afloren nombres originales en la tabla de métodos nativos significa que crossgen corrió primero: una señal de alarma.

Para el lado del IL, verifica como lo harías con cualquier compilación protegida: abre el ensamblado enviado en Glass.NET o el decompilador de tu elección y confirma que los métodos sensibles vuelven como dispatchers aplanados en lugar de C# limpio, exactamente como se cubre en verificar la ofuscación en CI.

La conclusión

ReadyToRun es una buena optimización de arranque y vale la pena enviarla. Pero cambia de raíz la cuestión de la ofuscación, porque compila una segunda copia nativa de tu código a partir del IL que se le entregue. Ofusca primero y esa copia hereda tu protección; ofusca al final y se convierte en un registro limpio e independiente de cualquier decompilador de la lógica que intentabas ocultar, mientras la imagen R2R desajustada se descarta en la carga, costándote el único beneficio por el que la activaste. No hay término medio ni un “ya protegeremos la carpeta de publicación luego”. Crossgen debe compilar IL protegido. Secuencia Nebula antes del paso ReadyToRun, verifica que los métodos nativos llevan la forma renombrada, y ambas mitades de la imagen contarán la misma historia protegida.

Prueba Nebula.NET

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