Skip to content
← Todas las publicaciones
· Delta1 Labs Anti-dumpNebula

Impedir que un volcado de memoria recupere tu ensamblado

El renombrado y el cifrado de cadenas se deshacen si un atacante simplemente vuelca tu proceso en ejecución a disco. Cómo el anti-dump de Nebula.NET reubica y borra los encabezados PE y de metadatos en memoria para que una imagen extraída sea inservible: con los offsets reales, C#, un SVG de la ruta de extracción y los límites honestos.

Renombra cada tipo, cifra cada cadena, aplana cada rama, y un atacante puede saltarse todo ello con un solo movimiento: dejar que tu programa arranque y luego copiar el ensamblado directamente de su propia memoria para abrir esa copia en un descompilador. El runtime ya ha hecho la parte difícil. Las cadenas se descifran en el primer uso, los metadatos se resuelven, el JIT tiene los tokens reales. Un volcado de proceso captura un módulo que, en cierto modo, está más limpio que el archivo que distribuiste.

Este es el ataque contra el que la ofuscación por sí sola no hace nada, y la contramedida —el anti-dump— es una de las protecciones peor entendidas de la caja. Esto es exactamente de qué depende un volcador, cómo Nebula.NET se lo quita y dónde se detiene la técnica.

Qué hace realmente un volcador

Un ensamblado gestionado es un archivo PE. Cuando el CLR lo carga, el cargador mapea ese PE en el espacio de direcciones del proceso como una imagen: cada sección aterriza en su dirección virtual, de modo que un puntero en memoria es simplemente base + RVA. Una herramienta de volcado explota ese diseño regular. Los pasos son mecánicos:

  1. Enumerar los módulos cargados (o rastrear la memoria confirmada en busca de un encabezado DOS MZ seguido de una firma PE\0\0).
  2. Recorrer los encabezados hasta el encabezado CLI (el IMAGE_COR20_HEADER, entrada 14 del directorio de datos) y, a partir de él, leer el directorio MetaData: el RVA y el tamaño de la raíz de metadatos que empieza con la firma ASCII BSJB.
  3. Extraer la imagen mapeada de la memoria, «desmapearla» (reescribir los RVA de sección de vuelta a offsets de archivo en crudo para que los bytes vuelvan a formar un PE válido en disco) y escribir un .dll.
  4. Abrirlo en dnSpy/ILSpy. Cada nombre que renombraste sigue renombrado, pero cada cadena que tu código ya tocó está ahí en texto claro, y el módulo se ejecuta.

Todo el ataque descansa sobre una suposición: que los encabezados PE y la raíz de metadatos siguen en memoria, en forma canónica, donde un rastreador puede encontrarlos. El anti-dump rompe esa suposición.

La idea: mover los metadatos, borrar el original

No puedes simplemente poner a cero los metadatos tras la carga: el CLR los necesita para la reflexión, la instanciación de genéricos y la resolución de tipos de excepción durante toda la vida del proceso. Por eso Nebula hace algo más quirúrgico, en un stub de arranque que se ejecuta antes que nada de tu código:

  1. Localizar la dirección base de este propio módulo.
  2. Reservar una región privada nueva, copiar allí los metadatos y reescribir el RVA MetaData del encabezado CLI en memoria para que el runtime siga la copia. El CLR sigue funcionando: lee el puntero parcheado.
  3. Borrar el original: sobrescribir la firma BSJB y los campos del encabezado de la imagen mapeada en los que se apoya un rastreador.

Ahora un volcador que extrae la imagen mapeada copia una región borrada. El encabezado CLI apunta a metadatos que han sido sobrescritos; la firma BSJB ya no está. El archivo extraído no es un ensamblado cargable, y una herramienta que siga el directorio aterriza en basura, mientras que tu proceso, siguiendo el puntero reubicado, se ejecuta con normalidad.

Para hacer todo esto, el stub tiene que leer la cadena de encabezados a mano. Los offsets son fijos y vale la pena conocerlos, porque son exactamente lo que lee también la herramienta del atacante:

// Ilustrativo: cómo el stub de arranque localiza su propio encabezado CLI y los metadatos.
// La inyección real es nativa primero, ofuscada, y se ejecuta antes de tu Main.
static unsafe (IntPtr metaRoot, int metaSize) FindMetadata(Module module)
{
    byte* base_ = (byte*)Marshal.GetHINSTANCE(module);   // base de la imagen mapeada
    int e_lfanew = *(int*)(base_ + 0x3C);                // -> firma PE
    byte* nt = base_ + e_lfanew;                         // "PE\0\0"
    short magic = *(short*)(nt + 0x18);                  // magic del encabezado opcional
    // los directorios de datos empiezan en 0x60 (PE32) o 0x70 (PE32+)
    int ddOffset = (magic == 0x20B) ? 0x70 : 0x60;
    byte* dataDirs = nt + 0x18 + ddOffset;
    // entrada 14 = IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR (encabezado CLI)
    int cor20Rva = *(int*)(dataDirs + 14 * 8);
    byte* cor20 = base_ + cor20Rva;                      // IMAGE_COR20_HEADER
    int metaRva = *(int*)(cor20 + 8);                    // MetaData.VirtualAddress
    int metaSize = *(int*)(cor20 + 12);                  // MetaData.Size
    return ((IntPtr)(base_ + metaRva), metaSize);        // empieza con 'BSJB'
}

Cada número ahí es un offset PE/CLI real: e_lfanew en 0x3C, el magic del encabezado opcional en 0x18 dentro de los encabezados NT, el encabezado CLI en el índice 14 del directorio de datos y el directorio MetaData en el offset 8 dentro del IMAGE_COR20_HEADER de 72 bytes. El paso de reubicación entonces hace VirtualProtect de la página del encabezado para hacerla escribible, reescribe *(int*)(cor20 + 8) al nuevo RVA y sobrescribe los primeros cuatro bytes de la raíz de metadatos antigua (el magic BSJB) para que ningún rastreador pueda volver a encontrarla.

Imagen mapeada en memoria del procesoencabezados PEencabezado CLI (14)metadatos (BSJB)el volcador extrae base + RVA.dll extraído escrito a discoTras el stub de arranque anti-dumpencabezados PEencabezado CLI parcheadoborrado (sin BSJB)metadatos reubicadosel CLR sigue el nuevo puntero
Un volcador lee base + RVA directamente de la imagen mapeada. El anti-dump reubica los metadatos y borra la raíz BSJB en el sitio, de modo que la copia extraída no tiene metadatos legibles mientras el proceso vivo sigue el encabezado CLI parcheado.

Por qué tiene que ejecutarse primero

Todo el valor del anti-dump está en el momento. Si un atacante toma una instantánea del proceso antes de que tu stub se ejecute, los encabezados siguen intactos y no has protegido nada. Por eso Nebula no lo emite como C# normal que casualmente se ejecuta pronto: cablea el borrado en la ruta de carga del módulo (una entrada nativa primero que se ejecuta por delante del Main gestionado), de modo que para cuando algo de tu código, o el punto de interrupción de cualquiera, sea alcanzable, los encabezados ya están movidos y borrados.

También significa que el stub no puede ser un método ordenado y localizable. Un único AntiDump() que un atacante pueda localizar y NOP-ear en un depurador derrota todo el asunto, así que la lógica de reubicación está ofuscada, insertada en línea en la ruta de carga, y sus constantes se derivan en lugar de almacenarse: la misma disciplina que hace que el anti-tamper valga la pena distribuir.

Cómo activarlo

El anti-dump es un interruptor en la configuración de protección, aplicado como un paso de arranque:

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "antiDump": { "enabled": true },
  "antiTamper": { "enabled": true },
  "antiDebug": { "enabled": true }
}
nebula protect ./bin/Release/net8.0/Billing.dll \
  --config nebula.config.json \
  --out ./protected/

Aquí no hay ámbito por método: el anti-dump es de módulo completo por naturaleza, porque opera sobre los propios encabezados del módulo. El coste son unos pocos microsegundos en el arranque y una reserva privada del tamaño de tu flujo de metadatos, pagada una vez por proceso. Instala el CLI con dotnet tool install --global Delta1Labs.Nebula.Tool.

Dónde se detiene, con honestidad

El anti-dump tiene un trabajo específico y un punto ciego específico, y vender más allá de cualquiera de los dos es como acabas con una falsa confianza en producción.

  • Derrota a los rastreadores, no a los reconstructores. Un volcador que extrae la imagen mapeada en crudo queda bloqueado. Una herramienta que reconstruye un módulo a partir de las propias estructuras de ejecución del CLR —recorriendo las tablas de tipos y métodos mediante la superficie de depuración/DAC en lugar de leer tus encabezados PE— nunca mira los bytes que borraste. Esas herramientas son más lentas y torpes, y a menudo producen un módulo roto, pero el anti-dump no las detiene por sí solo. Combínalo con anti-debug para que adjuntar la clase de proceso que impulsa un volcador DAC se detecte en sí mismo.
  • No vuelve a cifrar lo que el runtime descifró. Una vez que tu código se ha ejecutado, las cadenas descifradas y los cuerpos de método compilados por el JIT viven en memoria en texto claro. El anti-dump hace que el módulo sea difícil de extraer como un ensamblado válido; no borra todos los secretos del heap. Acota las cadenas sensibles para que se descifren tarde y no se retengan, y apóyate en la virtualización de código para el puñado de métodos cuya lógica —no solo sus nombres— nunca debe recuperarse.
  • Dependiente del diseño. Los paquetes de archivo único, las imágenes ReadyToRun y NativeAOT cambian el diseño PE/CLI que recorre el stub; Nebula adapta el paso al tipo de salida, pero verifica que tu build protegido realmente arranca en la forma de despliegue de destino antes de confiar en él.

El modelo mental es el mismo que recorre cada protección de la suite. El anti-dump no hace que tu ensamblado sea imposible de extraer —nada que se ejecute en una máquina que no controlas lo hace—. Elimina la extracción más barata: la de «ejecútalo, vuélcalo, ábrelo» de un clic que convierte un proceso vivo descifrado en un archivo limpio en menos de un minuto. Esa ruta es como ocurre la mayor parte del robo casual de IP gestionada, y cerrarla obliga al atacante a usar las herramientas lentas y frágiles, lo que, combinado con el anti-tamper y el anti-debug, es la diferencia entre un minuto de trabajo y un proyecto que tiene que decidir si vale su semana.

Consulta la documentación de Nebula.NET para añadir el anti-dump a tu perfil de protección, y luego vuelca tu propio build protegido y observa cómo el archivo extraído se niega a abrirse.

Prueba Nebula.NET

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