Skip to content
← Todas las publicaciones
· Delta1 Labs DecompilationGlass

Descompilar aritmética comprobada: add.ovf, conv.ovf y reconstruir el bloque checked

Una palabra clave checked o unchecked nunca sobrevive en los metadatos. La comprobación de desbordamiento se codifica por instrucción como add.ovf, mul.ovf y conv.ovf.u1: aquí está el IL, las asimetrías y cómo Glass.NET reconstruye la región checked mínima que lo explica.

Una palabra clave checked o unchecked es uno de los pocos constructos de C# que no deja huella directa en los metadatos. No hay ningún atributo, ni indicador, ni registro de ámbito que diga «aquí estaba activada la comprobación de desbordamiento». La información sobrevive de una forma completamente distinta: queda esparcida por las instrucciones aritméticas individuales, cada una de las cuales viene en una variante con comprobación y otra sin ella. Reconstruir la palabra clave significa leer esas instrucciones hacia atrás y deducir el bloque de código más pequeño que habría producido exactamente ese patrón, y equivocarse cambia lo que hace el programa. Este artículo recorre la reducción en ambas direcciones y muestra lo que reconstruye Glass.NET.

Cómo se ve el código fuente

La comprobación de desbordamiento controla una cosa: qué ocurre cuando una operación entera produce un resultado demasiado grande para su tipo. Bajo unchecked (el valor predeterminado de C#) el resultado da la vuelta en silencio. Bajo checked el tiempo de ejecución lanza OverflowException. La palabra clave puede delimitar un bloque o una sola expresión:

using System;

static class Money
{
    public static int Total(int a, int b)
    {
        checked
        {
            return a + b;
        }
    }

    public static byte ToByte(int n) => checked((byte)n);

    public static int Fast(int a, int b) => unchecked(a * b);
}

Tres métodos, tres decisiones. Total suma con la comprobación de desbordamiento activada. ToByte reduce un int a un byte con una comprobación de rango. Fast multiplica con la comprobación explícitamente desactivada. Nada de estas intenciones se almacena como tal: cada una se convierte en una elección de opcode.

Lo que el compilador realmente emite

Estos son los tres cuerpos de método tal como los muestra Glass en la vista de IL. Fíjate en los sufijos.

.method public hidebysig static int32 Total (int32 a, int32 b) cil managed
{
    IL_0000: ldarg.0
    IL_0001: ldarg.1
    IL_0002: add.ovf
    IL_0003: ret
}

.method public hidebysig static uint8 ToByte (int32 n) cil managed
{
    IL_0000: ldarg.0
    IL_0001: conv.ovf.u1
    IL_0002: ret
}

.method public hidebysig static int32 Fast (int32 a, int32 b) cil managed
{
    IL_0000: ldarg.0
    IL_0001: ldarg.1
    IL_0002: mul
    IL_0003: ret
}

Toda la diferencia entre checked y unchecked son tres caracteres de mnemónico de opcode. add.ovf es add con una trampa en caso de desbordamiento. conv.ovf.u1 es la conversión de reducción con comprobación de rango a 8 bits sin signo; su gemelo sin comprobación es el conv.u1 escueto, que trunca. mul es la multiplicación normal sin trampa. El compilador tomó una decisión de comprobación por instrucción y descartó la estructura del bloque.

Los opcodes de conversión son una familia

Las conversiones de reducción son donde más importa la comprobación de desbordamiento, porque cada asignación a un tipo entero más pequeño es una posible pérdida. El CLR ofrece a cada tipo de destino un par emparejado:

conv.u1       // int -> byte, truncating      (unchecked)
conv.ovf.u1   // int -> byte, range-checked    (checked)
conv.i2       // int -> short, truncating      (unchecked)
conv.ovf.i2   // int -> short, range-checked    (checked)
conv.ovf.i4.un // uint -> int, range-checked, source treated as unsigned

El sufijo .un del último es el segundo eje: le dice a la conversión que trate su origen como sin signo al decidir si el valor cabe. Así es como se distingue checked((int)someUInt) de checked((int)someInt): el mismo destino, distinta interpretación de los bits que ya están en la pila. Un descompilador tiene que arrastrar tanto el indicador .ovf como el .un, porque descartar cualquiera de los dos cambia en silencio la semántica de la conversión.

La asimetría: donde checked no hace nada

No todas las operaciones aritméticas tienen una variante de desbordamiento, y esta es la parte que la reconstrucción ingenua se equivoca. No existe div.ovf ni rem.ovf. La división entera tiene exactamente un caso de desbordamiento (int.MinValue / -1, cuyo resultado real es 2147483648 y no cabe en un int) y ECMA-335 hace que ese caso lance una excepción de forma incondicional, igual en contextos checked y unchecked. Como el comportamiento es idéntico de todos modos, el compilador emite div normal hayas escrito checked o no.

La consecuencia práctica para la descompilación: una instrucción div no lleva ninguna información de contexto de desbordamiento. Si un método contiene checked { return a / b; }, el IL es indistinguible de unchecked { return a / b; }, y Glass no fabricará una región checked alrededor de un div escueto. Reconstruye el contexto solo a partir de instrucciones que realmente lo codifican.

El flujo completo, de principio a fin

How a checked block compiles to per-instruction overflow opcodes and how Glass.NET rebuilds the smallest checked region 1 · Source block checked { return a + b; } 2 · Per-instruction ldarg.0 / ldarg.1 add.ovf block boundary erased 3 · Opcode set .ovf present → trap plain → wrap div → no signal Glass.NET reconstructs checked { return a + b; } smallest region covering every .ovf instruction, no larger

El compilador expande una palabra clave en un conjunto de elecciones de opcode; el descompilador lee el conjunto e infiere la palabra clave más estrecha que lo reproduce.

Lo que muestra un descompilador ingenuo, y lo que muestra Glass

Un descompilador que ignora los sufijos de desbordamiento produce código que compila y se lee con claridad pero que se comporta de otra manera. Quita el .ovf de conv.ovf.u1 y habrás convertido una conversión que lanza excepción con una entrada fuera de rango en una que trunca en silencio:

// suffix ignored — compiles, reads fine, WRONG behaviour
public static byte ToByte(int n) => (byte)n;   // truncates 300 to 44

Ese es el modo de fallo peligroso: el error es invisible sobre el papel. Glass arrastra el indicador de comprobación y representa la palabra clave que restaura la semántica exacta. También delimita el bloque de forma mínima: no envuelve todo el método en checked cuando solo una instrucción lleva .ovf:

static class Money
{
    public static int Total(int a, int b) => checked(a + b);

    public static byte ToByte(int n) => checked((byte)n);

    public static int Fast(int a, int b) => a * b;
}

Observa que Fast pierde su unchecked explícito: como unchecked es el valor predeterminado del lenguaje, a * b y unchecked(a * b) compilan al mul idéntico, así que Glass representa la forma más corta que produce el mismo IL. Añade la palabra clave solo donde la elección de opcode se perdería de otro modo.

Lo único que el IL no puede decirte

Si el proyecto se compiló con <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>, el contexto predeterminado cambia para todo el ensamblado. Un simple a + b compila entonces a add.ovf sin ninguna palabra clave a la vista, byte por byte idéntico a un checked(a + b) explícito en un proyecto normal. Glass reconstruye bajo la suposición estándar de unchecked por defecto, así que mostrará checked donde los opcodes lo exijan. No puede recuperar un indicador de todo el proyecto que no dejó rastro, y no lo adivina.

Léelo tú mismo

Abre el ensamblado en Glass, selecciona un método y cambia entre las vistas C# e IL. Alinea cada región checked(...) del código fuente con los sufijos .ovf del IL, y encuentra el div que no lleva ningún sufijo. Luego prueba una conversión de reducción de ambas formas en un ensamblado de prueba y observa cómo conv.u1 se convierte en conv.ovf.u1 en el momento en que añades la palabra clave: es la forma más clara de ver que la comprobación de desbordamiento es una decisión a nivel de instrucción, no un bloque que los metadatos recuerdan.

Glass.NET es un descompilador .NET gratuito para inspeccionar código que tienes derecho a inspeccionar: tus propios ensamblados, tus dependencias y binarios de terceros que tienes licencia para analizar. Preservar detalles que conllevan semántica, como el sufijo .ovf, es la diferencia entre una descompilación en la que puedes confiar y una que se lee bien pero se ejecuta mal.

Prueba Nebula.NET

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