Skip to content
← Todas las publicaciones
· Delta1 Labs ObfuscationNebula

Cómo los predicados opacos frustran a los desofuscadores automáticos

Por qué los predicados siempre-verdaderos y las ramas basura derrotan a herramientas tipo de4dot — con C# real, IL representativo, el equilibrio rendimiento/tamaño y qué nivel de Nebula lo hace.

Renombra todo, cifra cada cadena, y aun así un descompilador le entrega al atacante algo intacto: la forma de tu lógica. Las ramas, los bucles y las cláusulas de guarda sobreviven a la compilación casi a la perfección, y esa forma es la mayor parte de lo que hace legible el código descompilado. El aplanamiento de flujo de control ataca la forma directamente. Los predicados opacos y el flujo de control falso atacan algo más sutil: las herramientas del atacante. Plantan ramas que parecen significativas, se ejecutan de forma predecible y resisten los pases automáticos con los que un desofuscador hace limpieza.

Esto es una explicación en profundidad: qué es realmente un predicado opaco a nivel de IL, por qué un desofuscador genérico como de4dot no puede simplemente plegarlo, y qué pagas en tamaño y velocidad por usarlo.

Lo que un descompilador hace gratis

Dale a un descompilador este método y te devuelve algo casi idéntico al código fuente:

decimal ApplyDiscount(decimal price, int tier)
{
    if (tier >= 3)
        return price * 0.80m;
    return price;
}

El IL es una única rama condicional sobre dos bloques básicos. Un descompilador recorre el grafo de flujo de control, reconoce el patrón brtrue/blt como un if y reconstruye el código fuente. Aquí no se oculta nada. El grafo es la legibilidad, así que el trabajo consiste en poner en ese grafo aristas en las que una herramienta no pueda confiar.

La idea: una rama cuya respuesta ya se conoce

Un predicado opaco es una expresión booleana cuyo valor queda fijado cuando Nebula reescribe el ensamblado, pero que un analizador estático no puede demostrar de forma barata. La forma clásica es una identidad de teoría de números que es verdadera para todo entero:

x * (x + 1) siempre es par, así que (x * (x + 1)) % 2 == 0 es siempre verdadero, para cualquier x.

Un humano lo ve en un segundo. Un descompilador ve una multiplicación, una suma, un resto y una comparación sobre un valor que no conoce, y no tiene ninguna constante que plegar. Así que imprime la rama tal cual, incluido el brazo muerto que Nebula ha rellenado con basura de aspecto plausible.

Aquí está el método después de entretejer un predicado opaco (descompilado de vuelta a C# para mostrar el efecto):

decimal ApplyDiscount(decimal price, int tier)
{
    int x = tier;
    if ((x * (x + 1)) % 2 == 0)        // opaque-true: always taken
    {
        if (tier >= 3)
            return price * 0.80m;
        return price;
    }
    // bogus arm: never executes, but the tool cannot prove it
    return price * (decimal)((x ^ 0x5F) + 1);
}

La lógica real queda ahora anidada dentro de una guarda que siempre pasa, junto a un return falso que el analizador debe conservar porque no puede descartarlo. Multiplica esto a lo largo de un método y el código reconstruido es una maraña de condiciones que parecen todas imprescindibles.

A nivel de IL

El predicado es barato: un puñado de operaciones enteras y una rama. IL representativo de la guarda insertada, con el cuerpo real bajo IL_0015 y el bloque falso bajo IL_002a:

// int x = tier;
IL_0000: ldarg.1
IL_0001: stloc.0          // x

// (x * (x + 1)) % 2 == 0  -> always true
IL_0002: ldloc.0
IL_0003: ldloc.0
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: mul              // x * (x + 1)  — provably even
IL_0007: ldc.i4.2
IL_0008: rem
IL_0009: brtrue IL_002a   // if odd -> bogus; proven impossible at runtime

IL_0015: ldarg.1          // --- real body ---
IL_0016: ldc.i4.3
// ... if (tier >= 3) return price * 0.80m; else return price;

IL_002a: ldarg.0          // --- bogus block: dead, but opaque ---
// ... return price * ((x ^ 0x5F) + 1);

La línea crucial es IL_0009. En tiempo de ejecución rem siempre vale 0, así que brtrue nunca salta y el bloque falso es inalcanzable. Pero la inalcanzabilidad aquí es un teorema, no un hecho sintáctico. Para borrar IL_002a una herramienta tendría que demostrar que x * (x + 1) es par para todo int —incluido el desbordamiento con envoltura— algo que ningún pase genérico intenta.

Un predicado opaco-verdadero añade una rama muerta que un desofuscador no puede probar inalcanzable Grafo original Con predicado opaco tier >= 3 ? price*0.80 price x*(x+1) par ? cuerpo real rama falsa siempre nunca En ejecución solo se toma la arista sólida. Una herramienta estática debe conservar la discontinua: no puede probar que el predicado sea constante.

Por qué las herramientas tipo de4dot no pueden limpiarlos sin más

Los desofuscadores genéricos son, en el fondo, comparadores de patrones con un plegador de constantes. Funcionan de forma espectacular contra ofuscadores conocidos porque estos emiten predicados con una forma fija y reconocible: pliega la constante, prueba que la rama está muerta, bórrala, repite. Esa estrategia se rompe con los predicados opacos por tres razones.

1. No hay constante que plegar

(x * (x + 1)) % 2 == 0 no contiene ningún literal que se resuelva en un booleano fijo. La verdad es una propiedad de la aritmética entera, no un valor que esté en el IL. Un plegador de constantes no tiene nada a lo que agarrarse. Demostrarlo exigiría que la herramienta cargara un pequeño demostrador de teoremas y aplicara teoría de números, muy lejos de lo que hace un pase de limpieza de propósito general, y poco fiable si lo adivina.

2. Eliminar una rama que no puedes probar muerta es peligroso

La directriz suprema de un desofuscador es no cambiar el comportamiento. Si borra una rama que solo sospecha que está muerta y se equivoca, corrompe el programa en silencio. Así que cuando un predicado no es demostrablemente constante, la jugada segura —la única segura— es conservarlo. Los predicados opacos convierten esa cautela en arma: cada uno que añades es una rama que la herramienta debe preservar.

3. La diversidad de patrones derrota a las firmas

Si todos los predicados fueran x*(x+1)%2, el autor de la herramienta codificaría una regla para él. Nebula recurre a una familia —identidades de paridad, que 7y² − 1 nunca sea un cuadrado perfecto, hechos de suma de cuadrados y predicados sembrados a partir de valores que solo existen en tiempo de ejecución— y los varía por emplazamiento usando la semilla estable del proyecto. No hay una única firma que casar, y un predicado construido sobre un valor de ejecución no tiene respuesta estática alguna.

Cómo activarlo

El flujo de control falso vive bajo el bloque controlFlow de nebula.config.json:

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "controlFlow": {
    "enabled": true,
    "opaquePredicates": true,
    "bogusBranchDensity": "medium",
    "predicateFamilies": ["parity", "quadratic", "runtime-seeded"]
  }
}

Luego ejecuta el ofuscador sobre tu ensamblado compilado:

nebula protect ./bin/Release/net8.0/Billing.dll \
  --config nebula.config.json \
  --out ./protected/

bogusBranchDensity es el dial que importa. low espolvorea predicados en los puntos de entrada de los métodos; high envuelve bloques interiores y anida regiones falsas. La densidad se intercambia directamente con el tamaño y la velocidad, así que ajústala al método, no a todo el ensamblado, para lo cual están las entradas de keepList y las anulaciones por espacio de nombres.

El coste, con honestidad

Los predicados opacos no son gratis, y quien te diga lo contrario te está vendiendo una sorpresa en producción.

  • Tamaño. Cada predicado añade unas pocas instrucciones de IL más un bloque falso que debe parecer real. Con densidad medium espera que los ensamblados crezcan en el orden de las decenas bajas de por ciento; high puede más que duplicar los cuerpos de los métodos en los espacios de nombres calientes.
  • Velocidad. El predicado en sí es un puñado de operaciones enteras, insignificante de forma aislada. El coste real es indirecto: los métodos más grandes revientan el presupuesto de inlining del JIT y contaminan la caché de instrucciones. Un método que antes era inlineado puede dejar de serlo después. Nunca pongas flujo falso de alta densidad dentro de un bucle ajustado; protege en su lugar el método que llama al bucle.
  • Depurabilidad. Las trazas de pila protegidas y los volcados descompilados se vuelven genuinamente más difíciles de leer, para ti tanto como para un atacante. Conserva tu mapa de renombrado y tus artefactos de símbolos para poder re-trazar las trazas de producción.

El modelo mental: los predicados opacos no hacen tu código imposible de entender. Hacen que la comprensión automática no sea fiable, lo que eleva el coste del ataque de “ejecuta de4dot, lee la salida” a “analiza a mano cada rama y decide cuáles son reales”. Para la mayoría de la IP, esa diferencia lo es todo.

Qué nivel

La ofuscación básica de flujo de control —predicados opacos a densidad baja o media— es una función de Pro, junto con la virtualización de código y el cifrado de métodos. El nivel agresivo de flujo de control, con alta densidad de predicados, regiones falsas profundamente anidadas y redes de predicados correlacionados en las que varias condiciones opacas referencian una invariante de ejecución compartida, es Enterprise. La correlación es lo que lo lleva de “sobrevive a un pase genérico” a “sobrevive a un humano decidido con un desensamblador”, que es por lo que se reserva a un nivel superior.

Dónde encaja

Los predicados opacos son una capa, no una estrategia. Renombra para matar los nombres, cifra cadenas y constantes para matar los literales, aplana el flujo de control para matar la forma, y luego añade flujo falso para que las herramientas que deshacen todo lo anterior no puedan ejecutarse solas. Cada capa sube el suelo; juntas convierten una descompilación de cinco minutos en un proyecto que el atacante tiene que decidir si merece su semana. Empieza en medium, mide los dos números que importan —el tamaño del ensamblado y el rendimiento de tu ruta más caliente— y mueve el dial desde ahí.

Prueba Nebula.NET

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