Skip to content
← Todas las publicaciones
· Delta1 Labs ObfuscationNebula

Ocultar las operaciones enteras que controlan tu software

El renombrado oculta cómo se llama un valor; la MBA oculta qué calcula. Esta guía a fondo muestra cómo Nebula reescribe a + b como marañas equivalentes de aritmética y operaciones de bits que derrotan el plegado de constantes y la ejecución simbólica, con C# real, IL representativo, las identidades, la configuración y el coste honesto.

El renombrado ataca cómo se llama algo. El cifrado de cadenas y constantes ataca los literales que transporta. Pero lo más valioso en gran parte del código .NET no es ninguna de esas cosas: es un pequeño fragmento de aritmética, la expresión que convierte un nivel en un límite de asientos, que pliega la huella de un dispositivo en un dígito de control o que decide si el bit 0x40 de una bandera de permisos está activo. Esas operaciones sobreviven a la compilación casi perfectamente, y un descompilador las devuelve como C# limpio y legible. La aritmética booleana mixta (MBA, por sus siglas en inglés) es el paso que se las lleva.

Esta es una explicación a fondo: qué es realmente la MBA, las identidades algebraicas que la sustentan, qué aspecto tiene el IL reescrito, por qué derrota específicamente las dos herramientas a las que recurre un atacante —un plegador de constantes y un motor de ejecución simbólica— y qué pagas por ello.

El problema: la aritmética se documenta sola

Aquí tienes un método que calcula cuántos asientos concede una licencia. Propiedad intelectual legítima: es tu lógica de precios, y preferirías que un competidor no la leyera en una descompilación.

int SeatLimit(int tier, int flags)
{
    int baseSeats = tier * 5 + 10;
    if ((flags & 0x40) != 0)      // the "enterprise" bit
        baseSeats = baseSeats * 2;
    return baseSeats;
}

Descompila la compilación Release y obtienes eso tal cual: el * 5, el + 10, el & 0x40, todo. El renombrado convierte SeatLimit en a y tier en b, pero la expresión queda intacta, y la expresión es el secreto. Un atacante no necesita los nombres. Necesita la fórmula, y la fórmula está a la vista.

La idea: sustituir una operación por otra igual, pero más fea

La MBA se apoya en una familia de identidades que son ciertas para cualquier entero de máquina, que mezclan operadores booleanos (&, |, ^, ~) con operadores aritméticos (+, -, *). Algunas de las más habituales:

  • a + b == (a | b) + (a & b)
  • a + b == (a ^ b) + 2 * (a & b)
  • a ^ b == (a | b) - (a & b)
  • a & b == (a | b) - (a ^ b)

Cada una se cumple para todo int, incluido el desbordamiento con envolvente, porque ^ es la suma sin acarreo y a & b desplazado a la izquierda es el acarreo. Nebula elige una identidad por cada sitio de operador y luego recurre: el (a & b) que acaba de introducir puede reescribirse a su vez, y las constantes pueden dividirse: 0x40 se convierte en 0x5A ^ 0x1A (que realmente dan 0x40 al aplicar XOR), y 10 se convierte en una pequeña suma opaca. Tras dos o tres niveles, un add de un solo token es un árbol frondoso de ANDs, ORs, XORs y sumas sin ningún literal que reconocer.

Tras aplicar la primera identidad, el cálculo de asientos vuelve de un descompilador con este aspecto:

int SeatLimit(int tier, int flags)
{
    int baseSeats = ((tier << 2) | tier) + ((tier << 2) & tier) + ((0x5A ^ 0x1A) - (10 & (0x5A ^ 0x1A)));
    if (((flags | (0x5A ^ 0x1A)) - (flags ^ (0x5A ^ 0x1A))) != 0)
        baseSeats = (baseSeats | baseSeats) + (baseSeats & baseSeats);
    return baseSeats;
}

Cada línea sigue calculando exactamente el valor original. Pero el * 5 ha desaparecido (reescrito como (tier << 2) + tier), el + 10 está enterrado, el & 0x40 es una resta de dos términos OR/XOR sobre una constante que a su vez es un XOR, y el * 2 es una suma MBA. Nada de esto se lee ya como lógica de precios.

A nivel de IL

Todo el sentido es que la reescritura ocurre en IL, así que no hay forma de código fuente que proteger y el JIT sigue produciendo código correcto. El original baseSeats = baseSeats * 2 es una sola multiplicación:

IL_0012: ldloc.0        // baseSeats
IL_0013: ldc.i4.2
IL_0014: mul
IL_0015: stloc.0

Tras la identidad de suma MBA a + a == (a | a) + (a & a), el mismo almacenamiento es:

IL_0012: ldloc.0        // baseSeats
IL_0013: ldloc.0
IL_0014: or             // (a | a)
IL_0015: ldloc.0
IL_0016: ldloc.0
IL_0017: and            // (a & a)
IL_0018: add            // (a|a) + (a&a)  ==  2*a
IL_0019: stloc.0

Cuatro instrucciones más, un resultado demostrablemente idéntico y un árbol sin multiplicación y sin el literal 2 en el que un comparador de patrones pueda anclarse. La prueba (flags & 0x40) se expande de la misma manera, con 0x40 llegando solo como el XOR de otras dos constantes, de modo que no hay ningún 0x40 en los heaps #US/blob de metadatos ni en el flujo de IL que buscar.

An MBA rewrite turns one add instruction into an equivalent bitwise-arithmetic tree a solver must normaliseOriginal: one operationAfter MBA: equal, opaque treea + babIL: ldarg · ldarg · addadda | ba & babIL: or · and · add — same resultA decompiler prints the tree verbatim. To recover “a + b” a solvermust prove the two sides equal for all 2^32 inputs — not a fold itcan pattern-match, and the constants are split so there is nothing to anchor on.

Por qué se atascan tanto un plegador de constantes como un motor simbólico

Dos herramientas hacen el trabajo pesado en un flujo de desofuscación, y la MBA está diseñada contra ambas.

Un plegador de constantes no tiene nada constante que plegar

Los desofuscadores genéricos se apoyan en un paso de propagación de constantes: encuentra un literal, propágalo a través de la aritmética, simplifica. La MBA no deja ningún literal en la operación: 0x40 nunca aparece, solo 0x5A ^ 0x1A, e incluso eso puede elevarse a un valor calculado. No hay mul, ni 2, ni 0x40 en el flujo que sirva de semilla para el plegado. El paso se ejecuta y no cambia nada, porque su precondición —un valor conocido que entra en una operación— nunca se cumple.

Un motor simbólico se enfrenta a una equivalencia que debe demostrar, no ver

El ataque más fuerte es la ejecución simbólica o un solucionador SMT: trata a y b como variables libres, construye la expresión y pide al solucionador que simplifique. Justo ahí muerde la MBA. (a | b) + (a & b) == a + b es un teorema sobre la aritmética de 32 bits en complemento a dos, y decidir la equivalencia de expresiones de aritmética booleana mixta es un problema conocido por ser difícil: los solucionadores se ralentizan bruscamente a medida que anidas identidades y mezclas aritmética, porque las teorías booleana y de enteros modulares interactúan mal. Un nivel es molesto. Tres niveles anidados con constantes divididas convierten una simplificación de un milisegundo en una consulta que el atacante ve girar, por cada expresión, en todos los sitios del ensamblado.

Ninguna de las dos herramientas queda derrotada en sentido absoluto: un humano decidido y con tiempo puede normalizar cualquier expresión a mano. La MBA consiste en elevar el coste por sitio hasta que “leer la fórmula en la descompilación” se convierte en “invertir cientos de expresiones enmarañadas a mano, cualquiera de las cuales podría ser un señuelo”. Ese es todo el juego.

Cómo activarlo

La MBA vive bajo el bloque arithmetic en nebula.config.json (referencia completa de configuración):

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "arithmetic": {
    "enabled": true,
    "rewriteOps": ["add", "sub", "and", "or", "xor", "mul"],
    "constantSplitting": true,
    "depth": 2
  }
}

Luego protege tu ensamblado compilado con la CLI:

nebula --config nebula.config.json

depth es el dial que más importa: 1 aplica una identidad por sitio, 3 recurre en los términos que cada identidad introduce. constantSplitting controla si los literales como 0x40 se descomponen a su vez. En CI, controla la misma configuración desde un destino de MSBuild para que los desarrolladores conserven compilaciones locales limpias y solo el artefacto de versión quede endurecido:

<Target Name="NebulaProtect" AfterTargets="Publish" Condition="'$(Configuration)' == 'Release'">
  <Exec Command="nebula --config nebula.config.json" WorkingDirectory="$(PublishDir)" />
</Target>

Acótalo. La MBA justifica su coste en la docena de métodos que codifican tus operaciones de licencia, tu algoritmo de dígito de control, tu decodificación de banderas de características, no en tus DTO de JSON. Usa entradas de keepList y anulaciones por espacio de nombres para apuntar el paso a la aritmética que vale la pena ocultar y dejar en paz el código activo y aburrido.

El coste, con honestidad

La MBA es el paso con más carga aritmética que incluye Nebula, y no es gratis.

  • Velocidad. Cada operación reescrita se convierte en varias. En código frío y poco llamado —una comprobación de licencia que se ejecuta una vez al arrancar— esto es invisible. Dentro de un bucle numérico ajustado no lo es: de cuatro a diez operaciones enteras extra por iteración, y un método hinchado más allá del presupuesto de inserción (inlining) del JIT deja de insertarse. Nunca apuntes la MBA a un núcleo numérico activo. Protege el método que decide algo, no el bucle que procesa algo.
  • Tamaño. Los cuerpos de los métodos crecen con depth. En depth: 2 espera que los métodos afectados aproximadamente dupliquen su IL; depth: 3 puede triplicarlo. Como acotas la MBA a un puñado de métodos, el impacto en todo el ensamblado sigue siendo pequeño, lo que es el argumento a favor de acotar en lugar de un interruptor global.
  • Depurabilidad. Una expresión reescrita en un volcado de fallo también es ilegible para ti. Conserva el mapa de símbolos/renombrado que Nebula emite y retraza las trazas de producción con nebula deobfuscate --map para que un ticket de soporte no se convierta en un proyecto de arqueología.

Dónde encaja

La MBA es una capa, y se compone con las demás en lugar de sustituirlas. Renombra para eliminar los nombres; cifra las cadenas para eliminar el texto; usa predicados opacos para eliminar la automatización de las herramientas; y usa la MBA para eliminar lo único que todo lo anterior deja intacto: la aritmética legible que es tu algoritmo. Juntas, convierten un valor que un atacante podría leer de un vistazo en una equivalencia que tendría que demostrar.

La ofuscación de expresiones y aritmética es una característica Pro, junto con la virtualización de código y el cifrado de métodos. La configuración más pesada —un depth alto con redes de constantes correlacionadas que comparten una invariante derivada en tiempo de ejecución entre muchos sitios— viaja con el nivel agresivo de flujo de control en Enterprise, porque la correlación es lo que empuja la MBA de “un solucionador la encuentra lenta” a “un solucionador no puede procesarla por lotes en absoluto”. Empieza en depth: 2 en tu espacio de nombres de licencias, mide el tamaño de esos métodos y el rendimiento de tu ruta más activa, y mueve el dial a partir de ahí.

Prueba Nebula.NET

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