Skip to content
← Todas las publicaciones
· Delta1 Labs Control flowNebula

Cómo los manejadores de excepciones ocultan el flujo

Un decompilador reconstruye tu if/else a partir de las instrucciones de salto que encuentra en el IL. Encaminar una decisión a través de un centinela lanzado y capturado traslada esa arista a la tabla de cláusulas de manejo de excepciones, donde la decompilación estructurada se rompe. Aquí tienes el IL real, por qué derrota a una lectura estática y el coste en tiempo de ejecución que obliga a usarlo con moderación.

Al decompilar un ensamblado .NET renombrado, lo que sigue leyéndose con claridad es el flujo de control. Los identificadores pasan a ser a, b, M3; la forma de la lógica sobrevive. Esto ocurre porque un decompilador reconstruye C# leyendo las instrucciones de salto del IL —br, brtrue, bge— y encajando su patrón de vuelta en if, else, while. El grafo de ramificación es la legibilidad, y por eso los ofuscadores invierten tanto esfuerzo en él. El aplanamiento y los predicados opacos atacan ambos directamente el grafo de ramificación.

Hay un segundo lugar, más silencioso, donde un método .NET guarda su flujo de control: la tabla de cláusulas de manejo de excepciones. Encaminar una decisión a través de ella ataca una parte del decompilador que las transformaciones del grafo de ramificación nunca tocan.

El único lugar donde una ramificación no es una ramificación

Cada método lleva una tabla de regiones protegidas: las cláusulas de manejo estructurado de excepciones (SEH). Cada fila es una tupla: el desplazamiento y la longitud de una región try, el desplazamiento y la longitud de su manejador, y qué captura ese manejador. El compilador de C# solo las emite para try/catch/finally genuinos, y las emite bien anidadas y ordenadas. Los decompiladores se apoyan con fuerza en esa suposición: leen la tabla de cláusulas, asumen que la produjo un compilador y la pliegan de vuelta en C# estructurado.

El verificador de IL también impone una regla que importa aquí. No puedes salir de una región protegida con br ni con ret. La única forma legal de abandonar un try o un catch es la instrucción leave, que transfiere el control a un desplazamiento fuera de la región y, como efecto secundario, vacía la pila de evaluación. Ese vaciado de la pila es la palanca.

Llevar una decisión a través de un catch

Toma un método cuyo contenido completo sea una sola ramificación:

static int Classify(int n)
{
    if (n < 0) return -1;
    return 1;
}

Compilado de forma normal, eso es un bge (saltar si es mayor o igual) y dos bloques de retorno: una forma que cualquier decompilador imprime de vuelta tal cual. La transformación de arista de excepción conserva el comportamiento pero hace que la ruta n >= 0 sea alcanzable solo lanzando un tipo centinela que un manejador captura:

.method private hidebysig static int32 Classify(int32 n) cil managed
{
    .locals init (int32 result)
    .try
    {
        ldarg.0
        ldc.i4.0
        bge.s      RAISE          // n >= 0  -> take the exception edge
        ldc.i4.m1
        stloc.0                    // result = -1
        leave.s    DONE
      RAISE:
        newobj     instance void ControlFlow::.ctor()
        throw                      // the only edge into the catch
    }
    catch ControlFlow
    {
        pop                        // discard the sentinel
        ldc.i4.1
        stloc.0                    // result = 1
        leave.s    DONE
    }
  DONE:
    ldloc.0
    ret
}

La lógica no cambia: n < 0 sigue produciendo -1, todo lo demás produce 1. Pero la rama «else» ya no es una ramificación. Es un lanzamiento de ControlFlow, y el código que se ejecuta para ella vive en un manejador catch. La tabla de cláusulas tiene ahora una fila que dice «si una excepción escapa de los desplazamientos X–Y, ejecuta el manejador en Z», y lo que lanza esa excepción es la propia ruta normal del programa.

Antes — una rama que el decompilador lee directamenten < 0 ?return -1return 1truefalse→Después — la arista falsa pasa por la tabla EHn < 0 ?result = -1 · leavethrow ControlFlowcatch: result = 1throwhandlerfila cláusula EHtry X-Y → catch Z
La decisión sobrevive, pero su arista falsa la transporta ahora un centinela lanzado y un manejador catch: una fila en la tabla de cláusulas de manejo de excepciones, no una ramificación en el flujo de instrucciones.

Por qué una lectura estática se rompe

Un decompilador correcto no tiene más remedio que ser fiel a esto. El IL realmente lanza y realmente captura, así que la reconstrucción que imprime es:

static int Classify(int n)
{
    int result;
    try
    {
        if (n >= 0) throw new ControlFlow();
        result = -1;
    }
    catch (ControlFlow)
    {
        result = 1;
    }
    return result;
}

Eso es idénticamente equivalente en comportamiento al original, y mucho más difícil de leer. El lector tiene que darse cuenta de que el throw es incondicional en la ruta tomada, que el catch es el verdadero «else» y que ControlFlow es un artefacto de flujo de control y no un error. Tres cosas agravan el problema:

  • La tabla de cláusulas resiste la estructuración. Superpón o anida unas cuantas de estas regiones y el decompilador deberá representar las transferencias con gotos y locales volcados, porque ya no puede mapear las regiones sobre bloques try anidados limpios. Algunos decompiladores se rinden y emiten salida sin estructurar para el método.
  • leave borra el estado de la pila. Como abandonar una región vacía la pila de evaluación, cada valor que debe cruzar la frontera se vuelca antes a un local. Los decompiladores orientados a expresiones que reconstruyen a + b * c a partir de los push de la pila pierden esa continuidad y recaen en código verboso, asignación por asignación.
  • Los predicados opacos ocultan la poda. El bge guardián puede ser un predicado opaco —una expresión demostrablemente constante en tiempo de ejecución pero costosa de evaluar estáticamente—, de modo que una herramienta no puede decidir que la arista de excepción «nunca/siempre se toma» y eliminarla.

Cómo lo aplica Nebula.NET

Las aristas de excepción son una opción dentro del pase de flujo de control de Nebula.NET, superpuesta al aplanamiento y a los predicados opacos en lugar de reemplazarlos. Lo delimitas de la misma forma:

{
  "controlFlowObfuscation": "aggressive",
  "controlFlowExceptionEdges": true,
  "controlFlowInclude": [
    "MyApp.Licensing.*",
    "MyApp.Activation.LicenseGate.Validate"
  ]
}

El tipo centinela que Nebula inyecta es a su vez anónimo y ofuscado, y el motor solo reescribe aristas donde puede demostrar que la transformación es correcta: no convertirá una ramificación que cruce una frontera de pila no vacía de un modo que no pueda volcarse legalmente. Como con toda transformación, la corrección nunca se sacrifica por densidad: una arista que no puede trasladarse con seguridad se deja como ramificación y se endurece de otra manera.

El coste que lo gobierna todo

Lanzar una excepción es caro —órdenes de magnitud más que una ramificación— porque el runtime recorre la pila para encontrar un manejador. Este es el único hecho que decide cómo usas la transformación. No pones una arista de excepción en una ruta caliente; encaminar una decisión por iteración a través de un throw aparecerá en un perfilador de inmediato.

El objetivo correcto es una decisión que se ejecute rara vez y que importe mucho: la ramificación dentro de una comprobación de licencia, una puerta de activación, un veredicto de integridad. Una excepción una vez por arranque no cuesta nada que un usuario note, y a cambio la ramificación más interesante de tu ensamblado deja de parecer una ramificación. Esa es la contrapartida a sopesar: un coste real en tiempo de ejecución sobre una ruta fría, recomprado como una decompilación rota exactamente sobre el código que más quieres proteger.

Y el techo honesto: esto eleva el coste de leer el flujo de control, no impide que un atacante ejecute el código y observe qué ruta se ejecuta. Un depurador puesto sobre el método sigue viendo que n >= 0 decide el resultado. Las aristas de excepción son una capa: con predicados opacos sobre el guardián, cifrado de cadenas sobre los literales que esas rutas consumen y anti-depuración que encarece el análisis dinámico, eliminan el atajo estático y fuerzan la vía lenta y manual que la ofuscación existe para imponer.

Pruébalo en una decisión: instala la CLI con dotnet tool install --global Delta1Labs.Nebula.Tool, añade un método sensible a tu lista de inclusión de flujo de control con controlFlowExceptionEdges activado y decompila el antes y el después. Consulta la documentación de Nebula.NET para empezar, y la ofuscación de referencias para ocultar el grafo de llamadas que esos métodos alcanzan.

Prueba Nebula.NET

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