Skip to content
← Todas las publicaciones
· Delta1 Labs MetadataNebula

Compactación de heaps de metadatos y renumeración de tokens: reducir un ensamblado .NET tras la ofuscación

El renombrado deja cadenas y blobs muertos en los heaps #Strings y #Blob. Cómo Nebula compacta los heaps de metadatos y renumera los tokens, con el diseño real de metadatos, IL, configuración y mediciones antes/después.

Renombra unos miles de miembros y habrás acortado cada identificador de tu ensamblado: CalculateInvoiceTotal pasó a ser a, _pendingReconciliationQueue pasó a ser b. Esperarías que el archivo encogiera. Abre las dos compilaciones en un visor hexadecimal y, a menudo, no lo ha hecho: los nombres largos originales siguen ahí, en el heap #Strings, huérfanos pero nunca eliminados. La ofuscación cambió a qué cadenas apuntan las tablas de metadatos; no recuperó las cadenas a las que solían apuntar.

Esta publicación trata del paso que termina el trabajo: la compactación de heaps de metadatos y la renumeración de tokens. Es la transformación menos vistosa que ejecuta Nebula y, en un ensamblado grande, una de las más medibles: es la diferencia entre un renombrado que solo oculta nombres y uno que además los borra.

Dónde viven realmente los nombres

Los metadatos de un ensamblado .NET son un conjunto de tablas (TypeDef, MethodDef, Field, …) más cuatro heaps que las tablas indexan:

  • #Strings — nombres de identificadores en UTF-8 terminados en nulo: nombres de tipos, métodos, campos y espacios de nombres.
  • #US — el heap de cadenas de usuario, que contiene los literales de cadena UTF-16 que tu código carga con ldstr.
  • #Blob — firmas, argumentos de atributos personalizados, valores constantes y descriptores de marshalling.
  • #GUID — identificadores de versión de módulo y afines.

Una fila de MethodDef no almacena su nombre; almacena un offset en #Strings. El nombre "CalculateInvoiceTotal" vive una sola vez en el heap, y cada token que lo necesita lleva el entero del offset donde empieza.

Renaming repoints a metadata offset and orphans the old stringMethodDef rowRVA | ImplFlags |Name → offset 0x1A40#Strings heap0x1A40 "CalculateInvoiceTotal\0" (orphan)0x2F10 "a\0" (appended)beforeafter rename:Name → 0x2F10Name → offset 0x2F10after compaction0x0004 "a\0" — orphan removed, heap rebuilt, token renumbered

El renombrado reescribe el campo Name con un nuevo offset. La forma ingenua de obtener ese offset es añadir "a\0" al final de #Strings y apuntar allí. Rápido, correcto, y nunca toca los bytes antiguos. Tras un pase completo de renombrado, el heap contiene todos los identificadores originales más cada reemplazo corto. El archivo puede incluso crecer.

Qué hace la compactación

La compactación trata los heaps como un arena recolectada por un recolector de basura. Los pasos:

  1. Marcar. Recorrer cada columna de tabla que sea una referencia a heap — TypeDef.Name, TypeDef.Namespace, MethodDef.Name, Field.Signature, cada ldstr hacia #US, cada #Blob de atributo personalizado — y registrar qué offsets son realmente alcanzables.
  2. Barrer y reconstruir. Asignar heaps nuevos que contengan solo las entradas alcanzables, deduplicadas para que dos firmas idénticas compartan un único blob.
  3. Renumerar. Cada offset de heap en cada tabla se reescribe a su nueva posición. Los tokens hacia las tablas mismas también se reempaquetan, porque las filas vacías de TypeRef/MemberRef que dejan las referencias fusionadas o eliminadas pueden descartarse.

El paso 3 es la razón por la que esto no puede ser un arreglo puntual. Un token de metadatos como 0x06000012 (un MethodDef, fila 0x12) se referencia desde el IL (call 0x06000012), desde otras tablas y desde las firmas de #Blob. Renumera una tabla y tendrás que corregir cada call, ldtoken, newobj y ldstr que la cruce. Nebula lo hace como un remapeo único y coherente: construye un mapa de token antiguo → token nuevo, reescribe las tablas y luego reescribe los operandos del IL de cada cuerpo de método con ese mismo mapa.

// IL before — operand is a raw metadata token
IL_000a:  ldstr      0x70000A1C      // "CalculateInvoiceTotal failed for order "
IL_000f:  call       0x0A000037      // MemberRef into a #Blob signature

// IL after compaction — same instructions, renumbered operands
IL_000a:  ldstr      0x70000044
IL_000f:  call       0x0A00000B

Las instrucciones son idénticas byte a byte en su forma; solo se mueven los operandos. Equivócate en el remapeo por una fila y el ensamblado lanza BadImageFormatException al cargar, que es exactamente por qué no haces esto a mano y por qué Nebula verifica la imagen reconstruida antes de escribirla.

También es un paso de endurecimiento, no solo de tamaño

La compactación suele venderse por el tamaño, pero el ángulo de seguridad son los propios bytes huérfanos de #Strings. Un renombrado que solo reapunta offsets deja CalculateInvoiceTotal, _pendingReconciliationQueue y cualquier otro nombre original físicamente presentes en el archivo. Ya no resuelven a través de los metadatos —un decompilador muestra a, b, c— pero un escaneo trivial al estilo strings sobre los bytes crudos recupera todo tu vocabulario original:

$ strings Acme.Billing.dll | grep -i invoice
CalculateInvoiceTotal
InvoiceReconciliationService
_pendingInvoiceBatch

Eso es una fuga real. Tus nombres de método a menudo describen tu dominio con tanta claridad como el código. La compactación borra los huérfanos, así que el escaneo vuelve vacío y los únicos nombres en el archivo son los cortos y sin sentido que produjo el renombrado. Lo mismo vale para #US: los literales que cifraste y reemplazaste siguen rezagados en el heap de cadenas de usuario hasta que se reconstruye el heap.

Cómo activarlo

La compactación se ejecuta después del renombrado, el cifrado de cadenas y el procesamiento de recursos, porque debe ver el conjunto final de referencias vivas. En nebula.config.json es una etapa bajo la salida, activada por defecto cuando renombras, pero configurable:

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

  "rename": { "enabled": true },
  "stringEncryption": { "enabled": true },

  "metadata": {
    "compactHeaps": true,
    "dedupeBlobs": true,
    "removeOrphanStrings": true,
    "renumberTokens": true
  }
}

Luego la invocación habitual:

nebula protect --config nebula.config.json --out protected

El único ajuste que merece entenderse es renumberTokens. Dejar los tokens como estaban (solo reconstruir los heaps) es la opción conservadora si algo aguas abajo fija un token concreto —por ejemplo, una herramienta que lee tu ensamblado por una fila MethodDef codificada en duro—. Eso es raro. Mantenlo en true salvo que tengas un motivo concreto, porque la renumeración es lo que permite descartar las filas de tabla vacías.

Cuándo contenerse

La compactación es segura para los ensamblados ordinarios, pero dos casos merecen una lista metadata.preserve. Primero, un ensamblado cargado por mdToken a través de un límite —algunos hosts de perfilado o instrumentación cachean tokens—. Segundo, cualquier cosa que haga Module.ResolveMethod(int metadataToken) sobre sí misma con un token literal incrustado en el código fuente. Ambos son inusuales; cuando aplican, fija los miembros afectados:

"metadata": {
  "compactHeaps": true,
  "renumberTokens": true,
  "preserve": [ "Acme.Billing.Diagnostics.TokenProbe.*" ]
}

Los miembros nombrados conservan sus tokens originales; todo lo demás se renumera y compacta a su alrededor.

Qué ahorra en realidad

Las cifras dependen por completo de cuán cargado de nombres estaba tu ensamblado, es decir, de cuánto eliminó el renombrado. Un resultado representativo en un ensamblado de negocio de tamaño medio —~4.200 métodos, vocabulario de dominio abundante, cadenas cifradas— se ve así:

                           #Strings     #US      #Blob     File
rename only (no compaction)  412 KB   188 KB    96 KB    1.84 MB
+ heap compaction             34 KB     2 KB    71 KB    1.27 MB
                             ───────   ──────   ──────   ───────
                              -92%      -99%     -26%     -31%

El desplome de #Strings son los identificadores originales huérfanos desapareciendo. El desplome de #US son los literales previos al cifrado desapareciendo. #Blob encoge menos y solo por la deduplicación, porque las firmas estaban todas vivas. Una reducción del archivo del 31% es típica de un ensamblado cargado de renombrados; una utilidad pequeña con pocos miembros apenas verá nada, porque había pocos huérfanos que recolectar.

El arranque también se mueve, aunque menos de lo que sugiere el tamaño. El runtime mapea en memoria los metadatos y los lee de forma perezosa, así que un heap #Strings más pequeño ayuda sobre todo al arranque en frío y al working set, más que al rendimiento en régimen estacionario. Trata la ganancia de tamaño como el titular y la de arranque como un extra y, como siempre, mide tu propio ensamblado en vez de fiarte de una tabla.

Verifica que funcionó

Dos comprobaciones, ambas rápidas. Primero, confirma que los huérfanos desaparecieron con el mismo escaneo que los expuso:

$ strings protected/Acme.Billing.dll | grep -i invoice
$    # (no output — the original names are no longer in the file)

Segundo, abre el ensamblado protegido en Glass.NET y mira la vista de metadatos: el heap #Strings debería contener solo la salida corta del renombrado y nombres del framework, el heap #US debería estar casi vacío si cifraste las cadenas, y la navegación de tokens debería resolver limpiamente —un fallo de renumeración aparece de inmediato como una referencia rota—. Glass lee los heaps directamente, así que es la forma honesta de confirmar que la compactación hizo lo que pedía la configuración sin tener que publicar primero.

La versión corta

El renombrado cambia a qué apuntan los metadatos; la compactación recupera aquello a lo que solían apuntar. Omítela y enviarás un ensamblado cuyos nombres originales están ocultos a un decompilador pero son trivialmente recuperables con strings, cargando cientos de kilobytes de heap muerto. Ejecútala y los huérfanos se borran, los blobs se deduplican, los tokens se reempaquetan y el archivo queda a la vez más pequeño y genuinamente limpio del vocabulario que pretendías ocultar. Está activada por defecto cuando renombras precisamente por eso: déjala activa, fija el raro token autorreferencial y verifica en Glass antes de publicar.

Consulta Nebula.NET para el pipeline completo de transformaciones y la referencia de nebula.config.json, y las tablas de metadatos explicadas para las estructuras sobre las que opera la compactación.

Prueba Nebula.NET

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