Skip to content
← Todas las publicaciones
· Delta1 Labs Reproducible BuildsNebula

Compilaciones reproducibles de ensamblados .NET ofuscados

La compilación determinista te da un DLL idéntico byte a byte a partir del mismo código fuente... hasta que el ofuscador estampa un MVID nuevo, la hora actual y una semilla de renombrado aleatoria en la salida. Aquí se explica dónde vive esa falta de determinismo en el PE y en los metadatos, y cómo el modo determinista de Nebula.NET deriva el MVID, la marca de tiempo y la semilla de renombrado de un hash del contenido para que el ensamblado protegido tenga el mismo hash en cada ejecución.

La compilación determinista es una de las victorias más silenciosas del .NET moderno. Activa <Deterministic>true</Deterministic> —es el valor predeterminado en los proyectos de estilo SDK— y Roslyn emitirá un ensamblado idéntico byte a byte a partir de un código fuente idéntico, referencias idénticas y un compilador idéntico. Sin marca de tiempo de reloj, sin GUID de módulo aleatorio. Dos ingenieros en dos máquinas obtienen el mismo DLL, y CI puede demostrar que el binario enviado coincide con el código.

Luego lo pasas por un ofuscador y la garantía se evapora. Calcula el hash del ensamblado protegido de dos ejecuciones consecutivas con exactamente las mismas entradas y obtendrás dos hashes distintos. Nada de tu código cambió. ¿Adónde se fue el determinismo?

La verdadera pregunta

Un ofuscador lee un ensamblado, reescribe sus metadatos y su IL, y escribe un ensamblado nuevo. Dos campos de esa salida se rellenan, por larga tradición, a partir del entorno y no de la entrada —y una tercera fuente de variación se esconde en cómo el renombrador recorre tus miembros. Encuentra esas tres y podrás restaurar la garantía.

Dónde vive la falta de determinismo

La primera es la identidad del módulo. Todo módulo .NET lleva un Module Version ID, un GUID almacenado en el montículo de metadatos #GUID y referenciado desde la única fila de la tabla Module. ildasm lo imprime al inicio del módulo:

// Metadata: Module (table 0x00)
//   Gen   Name         Mvid (-> #GUID)   EncId   EncBaseId
//   0     MyApp.dll    1                 0       0
// #GUID[1] = {3f2504e0-4f89-41d3-9a0c-0305e82c3301}

Roslyn, en modo determinista, fija ese GUID a un hash de las entradas de la compilación. Un ofuscador típico vuelve a emitir el módulo y lo fija a Guid.NewGuid() —un valor aleatorio nuevo en cada ejecución. Un solo campo, y la reproducibilidad ya se perdió.

La segunda es la marca de tiempo del encabezado PE. El encabezado COFF tiene un TimeDateStamp de 32 bits. Roslyn determinista no escribe ahí la hora real; escribe un hash del contenido con el bit más alto activado, para que las herramientas sepan que no es una marca de tiempo:

// PE / COFF header
//   Machine:        0x014C (I386)
//   TimeDateStamp:  0x8E0F3A21   // high bit set: content hash, not a real time

Un ofuscador que llama a DateTimeOffset.UtcNow para rellenar ese campo hace que la salida difiera cada segundo.

La tercera es más sutil y vive en el renombrador. Dar a un miembro su nombre ofuscado es determinista de forma aislada, pero el orden en que se visitan los miembros normalmente no lo es. Recorre los métodos de un tipo a través de un HashSet o de una colección ordenada por reflexión y el orden de iteración puede cambiar entre ejecuciones o versiones del framework; siembra el generador de nombres desde Environment.TickCount y el primerísimo nombre cambia en cada ejecución. Esta es la forma de una implementación ingenua —cada línea es una fuga de reproducibilidad:

module.Mvid = Guid.NewGuid();                                  // random identity
peHeader.TimeDateStamp = (uint)DateTimeOffset.UtcNow
                             .ToUnixTimeSeconds();             // wall clock
var rng = new NameGenerator(seed: Environment.TickCount);     // random seed
foreach (var m in type.Methods)                               // unstable order
    m.Name = rng.Next();                                      // -> different map

Incluso el cifrado de cadenas contribuye: si la clave por compilación proviene de RandomNumberGenerator, los blobs cifrados en los datos adyacentes a #US difieren en cada ejecución aunque descifren a las mismas cadenas.

MyApp.dlldeterministaOfuscacion por defectoMvid = Guid.NewGuid() · ts = UtcNowseed = TickCount · unordered membersModo deterministaMvid = H(content) · ts = H(content)seed = H(content) · sorted memberssha256 = 9a4f…sha256 = c17b…sha256 = 4e02…ambas ejecuciones identicas
La misma entrada en dos ejecuciones. La ofuscación por defecto siembra la identidad desde el entorno, así que las dos salidas tienen hashes distintos; el modo determinista lo siembra todo desde un hash del contenido, así que ambas ejecuciones producen el mismo SHA-256.

Derivar la identidad del contenido

La solución es reemplazar cada valor proveniente del entorno por una función de la entrada. El modo determinista de Nebula.NET calcula un digest sobre el módulo transformado en una forma canónica —las tablas de metadatos y el IL después de reescribir, leídos en orden de tabla, con los campos que dependen del nombre enmascarados para que el digest no dependa de nombres que aún no ha asignado— y usa ese digest como la única fuente de entropía:

byte[] digest = SHA256.HashData(canonicalModuleBytes);        // stable over inputs + config
module.Mvid = new Guid(digest.AsSpan(0, 16));                 // identity from content
peHeader.TimeDateStamp =
    BinaryPrimitives.ReadUInt32LittleEndian(digest.AsSpan(16)) | 0x8000_0000u;  // hash, flagged
var rng = new NameGenerator(seed: digest);                   // reproducible map
foreach (var m in type.Methods.OrderBy(StableKey))           // (declaring token, signature)
    m.Name = rng.Next();
var stringKey = HKDF.DeriveKey(HashAlgorithmName.SHA256, digest, 32, info: "nebula/strings"u8);

StableKey es la parte que vuelve honesto al renombrador: los miembros se ordenan por una tupla del token de metadatos de su tipo declarante y su firma completa, de modo que el orden del recorrido no depende de las interioridades de la colección. La clave de cifrado de cadenas se deriva del mismo digest con HKDF, así que los blobs cifrados también son estables —y como esa clave ya tiene que vivir dentro del ensamblado para que el runtime descifre, derivarla del contenido no le da nada nuevo a un atacante.

Se activa con una sola clave de configuración:

{
  "assemblies": ["MyApp.dll"],
  "rename": { "enabled": true },
  "controlFlow": { "enabled": true },
  "stringEncryption": { "enabled": true },
  "deterministic": true
}

Ahora el pipeline es una función pura. Ejecútalo dos veces y compara:

nebula --config nebula.config.json --out run1/
nebula --config nebula.config.json --out run2/
sha256sum run1/MyApp.dll run2/MyApp.dll
# 4e02a9…  run1/MyApp.dll
# 4e02a9…  run2/MyApp.dll      <- identical

Qué te aporta

Atestación. Un ensamblado protegido reproducible puede ser recompilado por cualquiera que tenga el ensamblado de entrada y la configuración, y el hash que obtenga es el hash que enviaste. Eso convierte el “confía en nuestro servidor de compilación” en “recompílalo tú mismo y compara”, que es todo el sentido de una postura de compilaciones reproducibles para una cadena de suministro.

Caché. Como la salida es una función de (ensamblado de entrada, configuración, versión de Nebula.NET), puedes dar clave a una caché de CI con el hash de exactamente esas tres cosas. En una rama que no tocó el ensamblado, la caché acierta y te saltas por completo la ofuscación —algo seguro, porque un acierto garantiza una salida idéntica byte a byte a la que habrías producido.

Comparabilidad. Con un MVID y una marca de tiempo fijados, una comparación binaria entre dos lanzamientos muestra solo los metadatos y el IL que realmente cambiaron, en lugar de quedar inundada por un GUID nuevo y una marca de tiempo nueva en cada compilación. Combina esto con un mapa de renombrado estable y la comparación refleja el cambio real.

Cuándo se rompe

La reproducibilidad es solo tan determinista como su entrada más débil, y tres merecen mencionarse con honestidad.

La versión de la herramienta es parte de la clave. Una versión nueva de Nebula.NET puede añadir o refinar una transformación, lo que cambia legítimamente la salida. La salida determinista es reproducible para una versión fija; fija la versión en CI y regístrala junto al hash.

El marcado de tiempo de Authenticode no es reproducible. La firma por nombre seguro es determinista —es una función de la clave y del contenido— pero una firma de Authenticode con una contrafirma RFC 3161 incrusta la hora de firmado y el nonce de la TSA, que no comparten dos firmas. Mantén la firma como el paso final y atesta el hash del ensamblado protegido sin firmar, o compara el contenido a firmar.

Los metadatos de compilación incrustados se filtran. Si tu propio código incrusta DateTime.Now, un contador de compilación o un GUID nuevo en una constante, esa falta de determinismo está en el ensamblado de entrada antes de que Nebula.NET lo vea. La compilación determinista aguas arriba es un requisito previo, no algo posterior —arregla primero el código fuente.

Conclusión

La ofuscación no tiene por qué costarte una compilación reproducible. La falta de determinismo no es inherente a reescribir un ensamblado; vive en tres decisiones reemplazables —el GUID del módulo, la marca de tiempo del PE y la semilla de renombrado— más el material de clave de cualquier transformación que cifre contenido. Deriva cada una de ellas de un hash de la entrada en lugar del reloj o de un generador aleatorio, recorre tus miembros en un orden estable, y el DLL protegido tendrá el mismo hash en cada ejecución. Activa deterministic: true, fija la versión, y tu artefacto endurecido se convierte en algo que puedes atestar y cachear en lugar de algo que cambia cada vez que lo miras.

Prueba Nebula.NET

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