Skip to content
← Todas las publicaciones
· Delta1 Labs DecompilationGlass

Cómo se decompilan los literales de cadena raw en C#

Un literal de cadena sin formato, una cadena textual y una cadena normal compilan todos al mismo ldstr idéntico hacia el heap #US. Aquí está el IL, los bytes de cadena de usuario que hay detrás y cómo Glass.NET elige qué forma de comillas reconstruir.

Los literales de cadena sin formato —la forma """...""" que llegó en C# 11— parecen tener que dejar algún rastro en el ensamblado compilado. Permiten pegar JSON, SQL, expresiones regulares o una ruta de archivo sin ningún escape, eliminan la indentación por ti y conservan los saltos de línea. Seguro que algo tan ingenioso queda registrado en los metadatos, ¿no?

Pues no. Un literal de cadena sin formato, una cadena textual @"..." a la antigua usanza y una cadena normal "..." con escapes compilan todos exactamente a lo mismo: una instrucción ldstr que apunta a una entrada del heap #US (de cadenas de usuario). La sintaxis de triples comillas, las reglas de indentación, el tratamiento de los saltos de línea: todo eso se ejecuta en tiempo de compilación y produce una string constante corriente. Para cuando los bytes llegan al disco no queda nada «sin formato» que encontrar. Eso convierte a los literales de cadena sin formato en una lente perfecta para dos preguntas que un descompilador debe responder: ¿dónde viven realmente las constantes de cadena? y cuando la forma del código fuente se ha borrado, ¿qué forma deberías reconstruir? Este artículo recorre ambas usando Glass.NET.

Cómo se ve el código fuente

Aquí tienes un método que devuelve un pequeño bloque de texto que sería miserable escribir como una cadena normal: tiene comillas simples, comillas dobles, una barra invertida y saltos de línea:

static class Report
{
    public static string Banner() => """
        It's "ready".
        Path: C:\tmp
        """;
}

En tiempo de compilación ocurren tres cosas, y las tres son puramente léxicas. El salto de línea inmediatamente posterior al """ de apertura se elimina, y también el salto de línea anterior al """ de cierre. El espacio en blanco a la izquierda del delimitador de cierre fija la indentación común que se elimina de cada línea de contenido —aquí ocho espacios, así que el contenido se desindenta hasta el margen izquierdo—. Y dentro del literal no hay ningún procesamiento de escapes: la barra invertida en C:\tmp es una barra invertida literal, y las comillas son comillas literales. Lo que queda es un único valor de cadena:

It's "ready".
Path: C:\tmp

Ese valor —una string de 25 caracteres que incluye un \n incrustado— es lo único que el compilador arrastra hacia adelante. Los delimitadores """ han cumplido su cometido y han desaparecido.

No hay nada «sin formato» en el IL

Abre el método en la vista IL de Glass y toda la funcionalidad se colapsa en una sola instrucción:

.method public hidebysig static string Banner () cil managed
{
    .maxstack 8
    IL_0000: ldstr "It's \"ready\".\nPath: C:\\tmp"
    IL_0001: ret
}

ldstr carga una constante de cadena. El desensamblador la imprime con escapes al estilo C —\", \n, \\— porque así es como un listado tokenizado muestra un valor, pero esos escapes son la representación del desensamblador, no algo almacenado en el archivo. Escribe el mismo texto idéntico de tres formas distintas en el código fuente:

"It's \"ready\".\nPath: C:\\tmp"            // plain, escaped
@"It's ""ready"".
Path: C:\tmp"                                // verbatim
"""
It's "ready".
Path: C:\tmp
"""                                          // raw

…y las tres compilan al mismo ldstr que apunta a la misma entrada del heap. La elección entre ellas es una decisión de legibilidad a nivel de código fuente que el compilador resuelve y descarta. Este es el hecho central para la descompilación: el estilo de comillas no es metadato. No se puede recuperar, solo volver a elegir.

Dónde vive realmente la cadena: el heap #US

El operando de ldstr es un token de metadatos cuyo byte alto es 0x70. Ese id de tabla significa heap de cadenas de usuario, y los tres bytes bajos son un desplazamiento en bytes dentro del stream #US —uno de los heaps con nombre de los metadatos administrados, junto a #Strings (identificadores), #Blob (firmas y constantes) y #GUID—. Así que IL_0000: ldstr codifica en realidad algo como ldstr 0x70000001, y 0x000001 es donde comienzan los caracteres en #US.

El heap #US almacena cada cadena con una forma compacta y autodescriptiva definida por ECMA-335: un prefijo de longitud comprimido, luego los caracteres como UTF-16 (little-endian, dos bytes cada uno), y después un único byte de bandera final. El prefijo de longitud cuenta los bytes que siguen, que son 2 × númeroDeCaracteres + 1 —el +1 es esa bandera final—. Toma una cadena diminuta de dos caracteres, A' (una A y un apóstrofo), para ver cada byte:

How three source quoting forms collapse to one ldstr token into the #US heap, the heap’s byte layout, and how Glass.NET re-chooses a quoting form on the way back1 · Three source forms”a\n…” (escaped)@“a…” (verbatim)"""a…""" (raw)identical compiled value2 · One ldstr tokenldstr 0x700000010x70 = #US heap, offset 13 · #US bytes for “A‘“05 41 00 27 00 01len · UTF-16 · flagbyte-by-byte05 = length (2×2 chars + 1 flag)41 00 = ‘A’ 27 00 = ''' 01 = non-plain flagGlass.NET re-chooses a formnewlines + quotes + backslash → rebuild as a raw string literal

Los bytes son 05 41 00 27 00 01. El 05 inicial es la longitud comprimida: siguen cinco bytes. 41 00 es A en UTF-16LE, 27 00 es el apóstrofo. El 01 final es la bandera: el runtime la pone a 1 cuando algún carácter queda fuera de un conjunto «simple» —cualquiera con un byte alto distinto de cero, o uno de un puñado de puntos de código especiales que incluyen 0x27 (el apóstrofo) y 0x2D (el guion)—. Nuestro apóstrofo la dispara, así que la bandera es 01. Una cadena puramente ASCII como "ready" llevaría en su lugar una bandera 00. La cadena real de Banner sigue el mismo esquema —longitud comprimida, caracteres UTF-16 incluido el salto de línea 0x000A, y una bandera 01 por culpa de ese mismo apóstrofo—, solo que más larga.

De esta disposición se derivan dos consecuencias. Primera: las cadenas en #US se deduplican por valor, así que escribir el mismo texto literal en dos métodos, con dos estilos de comillas distintos, produce dos tokens ldstr que apuntan a una sola entrada del heap. Segunda, y la clave de todo esto: el heap conserva los caracteres y nada sobre la sintaxis. No hay ningún bit que diga «esto era un literal de cadena sin formato».

Lo que reconstruye Glass, y cómo elige la forma de comillas

Como la sintaxis ha desaparecido, Glass no recupera un literal de cadena sin formato; lo vuelve a elegir. Lee de vuelta la constante desde el heap y se pregunta qué forma de comillas de C# representa esos caracteres exactos de la manera más legible. La lógica sigue un orden claro:

  • Sin saltos de línea y sin caracteres incómodos → un literal normal "...".
  • Barras invertidas pero sin comillas dobles incrustadas y sin saltos de línea → una cadena textual @"...", que evita duplicar cada barra invertida.
  • Saltos de línea junto con comillas o barras invertidas → un literal de cadena sin formato, que no necesita escapar ninguno de los dos y muestra la estructura de líneas directamente.

Nuestra cadena de Banner cae en el último caso —tiene un salto de línea, ambos tipos de comillas y una barra invertida—, así que Glass la reconstruye como la forma sin formato, eligiendo un delimitador de al menos tres comillas de largo (y más largo si el contenido en sí contuviera una racha de """), y luego reindentando el cuerpo bajo un delimitador de cierre:

static class Report
{
    public static string Banner() => """
        It's "ready".
        Path: C:\tmp
        """;
}

Ese es el mismo texto con el que empezaste, pero vale la pena ser preciso sobre lo que ocurrió: Glass no leyó """ del archivo, porque """ nunca estuvo en el archivo. Reconstruyó la sintaxis más legible que produce los bytes que encontró. Pasa ese código fuente reconstruido de nuevo por el compilador y obtienes un ldstr idéntico byte a byte hacia una entrada #US idéntica byte a byte. El viaje de ida y vuelta es exacto en el nivel que importa —el valor— aunque la sintaxis superficial sea una elección nueva e independiente.

Léelo tú mismo

Puedes observar cada etapa de esto en Glass desde la línea de comandos:

glass decompile Report.dll --type Report --member Banner
glass decompile Report.dll --type Report --member Banner --il

El primer comando muestra el literal de cadena sin formato reconstruido; el segundo muestra el único ldstr que hay detrás. Luego abre el ensamblado en la interfaz de Glass, cambia a la navegación de metadatos e inspecciona el heap #US directamente para ver por ti mismo los bytes UTF-16 con prefijo de longitud y la bandera final: el apóstrofo poniendo ese último byte a 01 es el tipo de detalle que solo crees una vez que has visto los bytes crudos.

Glass.NET es un descompilador de .NET gratuito para inspeccionar ensamblados que tienes derecho a inspeccionar: tus propias compilaciones, tus dependencias y binarios de terceros que estás autorizado a analizar. Los literales de cadena sin formato son un pequeño recordatorio de una gran verdad sobre la descompilación: un descompilador reconstruye significado, no pulsaciones de teclas, y lo mejor que puede hacer —aquello a lo que apunta Glass— es reconstruir el código fuente más claro que vuelve a compilar exactamente a lo que leyó.

Prueba Nebula.NET

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