Cómo un descompilador lee los interceptores de C#
Los interceptores de C# redirigen una llamada en tiempo de compilación sin dejar marca en el punto de llamada; el único rastro es un atributo InterceptsLocation cuyo blob base64 Glass descodifica para recuperar un hash de contenido, una posición de origen y el nombre del método interceptado.
Descompilas una compilación de lanzamiento, abres Program.cs y encuentras una llamada que ya no va a donde decía el código fuente. El código dice client.GetForecast("NYC"), pero el IL llama a un método estático de una clase file generada que nunca habías visto. Nadie editó el código fuente. El compilador recableó la llamada, y apenas dejó nada que lo explique.
Esto es un interceptor de C#. Es una de las pocas características del lenguaje que cambia a qué método se enlaza una llamada después de que la hayas escrito, y es deliberadamente invisible en el punto de llamada. Para un descompilador eso es un problema: no hay opcode, ni modificador, ni marca que diga «esta llamada fue redirigida». Entender tu propia compilación significa saber dónde vive la única evidencia que sobrevive y cómo leerla.
La verdadera pregunta
Un interceptor es un método, proporcionado por un generador de código fuente, que el compilador sustituye por una llamada concreta en una ubicación concreta del código fuente. Las API mínimas de ASP.NET Core usan esto para reemplazar la fontanería basada en reflexión de MapGet por controladores de solicitud generados y fuertemente tipados; los enlazadores de configuración y las bibliotecas de mapeo lo usan igual. La característica es opcional, detrás de <InterceptorsNamespaces> en el archivo de proyecto.
Aquí están el código del usuario y el interceptor generado:
// Program.cs (what you wrote)
var client = new WeatherClient();
var forecast = client.GetForecast("NYC"); // ← compiler redirects this call
// WeatherClient.g.cs (emitted by a source generator)
namespace Generated;
file static class WeatherInterceptors
{
[global::System.Runtime.CompilerServices.InterceptsLocation(
1, "khAcU2t0b2tlbgAAAABQAAAAUHJvZ3JhbS5jcw==")]
public static Forecast GetForecast_Fast(this WeatherClient client, string city)
{
// generated fast path, no reflection
}
}
El compilador ve que GetForecast_Fast reclama la ubicación de la llamada a GetForecast y emite en su lugar una llamada al interceptor. La pregunta que un descompilador debe responder es: dado solo el ensamblado, ¿cómo recuperas el hecho de que ocurrió la interceptación, y cuál era el objetivo original?
El punto de llamada no te dice nada
Empieza donde tu instinto dice que mires: la llamada misma. El IL emitido para esa línea es una llamada ordinaria:
ldloc.0 // client
ldstr "NYC"
call class Generated.Forecast
Generated.WeatherInterceptors::GetForecast_Fast(
class WeatherClient, string)
No hay ningún WeatherClient::GetForecast en ningún lugar de este cuerpo de método. El objetivo original no está referenciado, ni comentado, ni marcado. En lo que al IL respecta, simplemente escribiste una llamada a GetForecast_Fast. Un descompilador que renderice esto fielmente te mostrará exactamente eso —lo cual es correcto, porque es lo que se ejecuta—, pero oculta la reescritura. La interceptación es una decisión de enlace horneada en el token de llamada; nada sobrevive en el punto de llamada para deshacerla.
Así que el único lugar donde se registra la redirección es en el método interceptor, como atributo personalizado.
Descodificar el blob InterceptsLocation
InterceptsLocationAttribute se emite a los metadatos como cualquier otro atributo personalizado. La forma actual (versión 1) toma dos argumentos: un int de versión y un blob string de datos:
.method public hidebysig static class Forecast
GetForecast_Fast(class WeatherClient client, string city) cil managed
{
.custom instance void
System.Runtime.CompilerServices.InterceptsLocationAttribute::.ctor(int32, string)
= ( 01 00 01 00 00 00 24 6B 68 41 63 55 32 74 30 62 32 74 6C 62 ... 00 00 )
Lee ese blob de CA según las reglas de ECMA-335. 01 00 es el prólogo. 01 00 00 00 es el primer argumento fijo, el int32 de versión 1. Luego viene el argumento string como una SerString: una longitud en entero comprimido (0x24 = 36 bytes) seguida de los bytes UTF-8 del texto base64. El 00 00 final es el recuento de argumentos con nombre, cero.
Esa cadena base64 es a su vez un registro binario empaquetado. Descodifícala y obtienes tres campos dispuestos uno tras otro:
byte[] blob = Convert.FromBase64String(data);
// 1) 16-byte content hash of the intercepted source file (XxHash128 in current Roslyn)
ReadOnlySpan<byte> contentHash = blob.AsSpan(0, 16);
// 2) position of the intercepted name token, as an ECMA-335 compressed unsigned integer
int offset = 16;
int position = ReadCompressedUInt(blob, ref offset);
// 3) a display name for the file, UTF-8, to the end of the blob
string displayName = Encoding.UTF8.GetString(blob, offset, blob.Length - offset);
Ahora el atributo significa algo concreto. Dice: este método intercepta la llamada cuyo token de nombre comienza en el carácter position de un archivo cuyo contenido tiene el hash contentHash, mostrado a los humanos como displayName. Glass realiza exactamente esta descodificación cuando encuentra un atributo InterceptsLocation, de modo que el método interceptor del árbol de tipos queda etiquetado con la posición y el archivo que reclama, en lugar de mostrarte una cadena base64 opaca.
De la evidencia a la comprensión
Junta las dos mitades y la reescritura se vuelve legible. Recorre el árbol de tipos buscando métodos que lleven InterceptsLocation; cada uno es un interceptor. Su firma te indica la forma de la llamada que reemplazó: un primer parámetro de estilo extensión this WeatherClient significa que sustituye a una llamada de instancia sobre WeatherClient, y el nombre de método que eligió el generador (GetForecast_Fast) suele hacer eco del original. Luego cruza la referencia: busca en el ensamblado llamadas directas a ese interceptor, y esos puntos de llamada son los lugares que el compilador redirigió. La position y el displayName descodificados te dicen qué archivo de origen y, aproximadamente, dónde, si tienes el código fuente para cotejarlo con el hash.
En Glass, los métodos interceptores aparecen con su ubicación descodificada en la vista de IL, y el blob del atributo se expande en lugar de mostrarse en crudo, de modo que ves de un vistazo que un método generado está reclamando un punto de llamada, que es la pista de que una llamada de aspecto normal en otro sitio no es lo que parece.
Cuándo esto se rompe
Sé honesto sobre los límites, porque son reales.
- Sin código fuente, sin número de línea. El blob de la versión 1 es deliberadamente relativo al origen. El hash de contenido y la posición de carácter solo son resolubles si tienes el archivo original para calcular su hash e indexar en él. Sin él aprendes que una llamada fue interceptada y su nombre visible, nunca la línea exacta. Esto es por diseño: la codificación cambia legibilidad por resistencia a ediciones de espacios en blanco.
- El punto de llamada está genuinamente limpio. No vayas a buscar un modificador o una marca en la llamada redirigida. No la hay. La redirección vive solo en el interceptor, así que un descompilador que no inspeccione los atributos personalizados se perderá la característica por completo y mostrará una llamada que parece escrita a mano.
- La forma heredada se lee distinto. La codificación original en vista previa era
[InterceptsLocation(string filePath, int line, int character)]: legible para humanos, pero frágil y ahora superada. Aún puedes encontrarla en ensamblados antiguos; descodifícala como tres argumentos simples, no como un blob. - Sigue siendo una característica opcional y en movimiento. Los interceptores viven detrás de
<InterceptorsNamespaces>, y la forma del atributo ya ha cambiado una vez. Trata la disposición exacta de bytes como dependiente de la versión y lee primero el argumento de versión.
Conclusión
Los interceptores son el caso donde la descompilación honesta y la descompilación útil divergen. El IL que se ejecuta es una llamada directa a un método generado, y renderizar eso fielmente es correcto, pero oculta una reescritura en tiempo de compilación. Toda la historia está plegada en un atributo personalizado sobre el interceptor, y leerlo significa descodificar un registro base64 de un hash de contenido, una posición de origen y un nombre. Glass hace esa descodificación por ti, que es la diferencia entre ver una llamada a GetForecast_Fast y entender que tu propia llamada a GetForecast fue reemplazada en silencio.
Glass.NET es un descompilador de .NET gratuito. Consulta la página del producto y la documentación.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.