Decodificar blobs de atributos personalizados: de los bytes de #Blob de vuelta a [Cache(30, ...)]
La aplicación de un atributo no se almacena como código fuente. Es un blob binario en el heap #Blob: un prólogo, los argumentos posicionales serializados según la firma del constructor y luego una lista contada de valores de campos y propiedades con nombre. Aquí está la disposición exacta de los bytes y cómo Glass.NET la reconstruye como un atributo de C#.
La mayoría de los constructos de C# se reducen a instrucciones de IL. Los atributos no: la aplicación de un atributo se compila en datos, un registro binario empaquetado almacenado en el heap #Blob y apuntado por una fila en la tabla de metadatos CustomAttribute. No hay código que leer de vuelta, solo bytes que decodificar, y la decodificación se guía por una firma que vive en otro lugar completamente distinto. Equivocarse en la etiqueta campo-o-propiedad de un argumento con nombre, o malinterpretar el nombre de tipo incrustado de una enumeración, produce un atributo que parece plausible y se enlaza con el miembro equivocado. Este artículo recorre la disposición exacta de los bytes y muestra lo que reconstruye Glass.NET.
El código fuente
Un solo atributo, que lleva dos argumentos posicionales y dos con nombre (uno una propiedad, otro un campo), basta para ejercitar cada parte del formato:
using System;
[AttributeUsage(AttributeTargets.Class)]
sealed class CacheAttribute : Attribute
{
public CacheAttribute(int seconds, string region)
{
Seconds = seconds;
Region = region;
}
public int Seconds { get; }
public string Region { get; }
public bool SlidingExpiration { get; set; } // property
public int Priority; // field
}
[Cache(30, "catalog", SlidingExpiration = true, Priority = 5)]
sealed class ProductService { }
La aplicación sobre ProductService dice: llama al constructor (int, string) con 30 y "catalog", luego asigna true a la propiedad SlidingExpiration y 5 al campo Priority. Ninguno de esos nombres de miembro ni valores se almacena como texto en forma de código fuente; se serializan en un blob cuya forma fija la especificación ECMA-335 §II.23.3.
Lo que contienen realmente los metadatos
ildasm y la vista de IL de Glass representan ambos la aplicación como una referencia al constructor seguida del blob en bruto:
.custom instance void CacheAttribute::.ctor(int32, string) = (
01 00 1E 00 00 00 07 63 61 74 61 6C 6F 67 02 00
54 02 11 53 6C 69 64 69 6E 67 45 78 70 69 72 61
74 69 6F 6E 01 53 08 08 50 72 69 6F 72 69 74 79
05 00 00 00 )
Cincuenta y dos bytes. Cada campo del atributo está ahí, en un orden estricto, sin delimitadores y sin nombres para los argumentos posicionales. Aquí está el mismo blob, troceado:
| Bytes | Significado |
|---|---|
01 00 | Prólogo — siempre 0x0001, little-endian |
1E 00 00 00 | Argumento fijo 1: int32 = 30 |
07 + 63 61 74 61 6C 6F 67 | Argumento fijo 2: SerString, longitud 7, UTF-8 “catalog” |
02 00 | NumNamed = siguen 2 argumentos con nombre |
54 | Etiqueta del argumento con nombre 1: PROPERTY |
02 | Tipo de elemento BOOLEAN |
11 + 53 6C 69 64 … | Nombre SerString, longitud 17, “SlidingExpiration” |
01 | Valor: true |
53 | Etiqueta del argumento con nombre 2: FIELD |
08 | Tipo de elemento I4 (int32) |
08 + 50 72 69 6F … | Nombre SerString, longitud 8, “Priority” |
05 00 00 00 | Valor: 5 |
El prólogo y los argumentos fijos
Los dos primeros bytes son un prólogo de versión, siempre 0x0001. Después vienen los argumentos fijos (los parámetros posicionales del constructor), serializados uno tras otro en el orden de declaración, sin etiquetas de tipo y sin nombres. El blob almacena 1E 00 00 00 y 07 catalog; no registra que el primero sea seconds ni el segundo region. La única forma de saber que los cuatro bytes 1E 00 00 00 son un int32 y que el siguiente grupo es una cadena es leer la firma del constructor desde el MethodDef/MemberRef al que apunta la fila CustomAttribute. Los argumentos fijos se decodifican mediante una firma externa; el blob por sí solo es ambiguo.
Las cadenas usan la codificación SerString: una longitud sin signo comprimida (aquí un único byte 0x07) seguida de esa cantidad de bytes UTF-8. Una longitud comprimida ocupa uno, dos o cuatro bytes según su magnitud (el mismo esquema que se usa en todos los heaps de metadatos), y una cadena nula es el único byte 0xFF, distinto del 0x00 de una cadena vacía.
Los argumentos con nombre son autodescriptivos
Tras los argumentos fijos viene un recuento de 2 bytes —02 00 aquí— y luego cada argumento con nombre, que a diferencia de los fijos lleva su propia información de tipo. Cada uno empieza con un byte de etiqueta que es justo la pieza de información que la sintaxis de C# descarta:
0x53=FIELD0x54=PROPERTY
En el código fuente, SlidingExpiration = true y Priority = 5 tienen el mismo aspecto: ambos son Name = value. En el blob se distinguen en el byte de desplazamiento cero de cada argumento con nombre. La etiqueta va seguida de un byte de tipo de elemento (0x02 para BOOLEAN, 0x08 para I4, 0x0E para STRING, …), un SerString para el nombre del miembro y el valor serializado según ese tipo de elemento.
La asimetría es toda la historia: los argumentos fijos se apoyan en una firma externa, los argumentos con nombre se describen a sí mismos. Un decodificador tiene que cambiar de estrategia a mitad del blob.
Los casos incómodos: enumeraciones, Type y arrays
Tres clases de argumento complican la regla “byte de tipo de elemento y luego valor”, y son donde los decodificadores ingenuos se desvían.
Enumeraciones. Un argumento de enumeración no tiene un byte de tipo de elemento primitivo. Se codifica como 0x55 seguido de un SerString que nombra el tipo de la enumeración, y luego el valor serializado como el tipo entero subyacente de la enumeración. Supón que CacheAttribute también aceptara una enumeración CachePriority:
[Cache(30, "catalog", Level = CachePriority.High)]
Los bytes del argumento con nombre serían 54 (propiedad) 55 (enumeración) luego "...CachePriority" como un SerString, y luego 02 00 00 00 para el valor int subyacente 2. El blob almacena el número, no el nombre del miembro High. Para representar CachePriority.High, Glass resuelve el tipo de la enumeración por su nombre incrustado y reasigna 2 al miembro, o emite (CachePriority)2 cuando ningún miembro coincide con una combinación de flags.
System.Type. Un argumento typeof(...) se serializa como el tipo de elemento 0x50 seguido de un SerString del nombre del tipo (cualificado por ensamblado cuando vive en otra parte). Glass analiza ese nombre de vuelta a una expresión typeof(T) en lugar de dejar un literal de cadena.
Arrays. Un argumento de array es SZARRAY (0x1D), el tipo de elemento, un recuento de elementos de 4 bytes y luego los elementos empaquetados en secuencia (0xFFFFFFFF marca un array nulo, distinto de uno de longitud cero). Cada elemento se serializa según el tipo de elemento, así que un string[] es un recuento seguido de esa cantidad de SerStrings.
Lo que reconstruye Glass
Glass lee la fila CustomAttribute, resuelve el constructor para recuperar los tipos de los argumentos fijos, decodifica el blob en dos pasadas (guiada por la firma para los argumentos fijos, autodescriptiva para los argumentos con nombre), respeta cada etiqueta FIELD/PROPERTY para enlazar el miembro correcto y resuelve los nombres de enumeraciones y Type. A partir de los 52 bytes de arriba produce exactamente la aplicación original:
[Cache(30, "catalog", SlidingExpiration = true, Priority = 5)]
sealed class ProductService { }
Un decodificador que se saltara el byte de etiqueta del argumento con nombre, o que tratara la cadena de tipo incrustada de la enumeración como un valor posicional, emitiría algo que compila pero que nombra el miembro o la constante equivocados: la misma clase de error silencioso e invisible en la página que descartar un sufijo de desbordamiento.
Léelo tú mismo
Abre cualquier ensamblado en Glass, selecciona un tipo o método decorado y cambia a la vista IL para ver el blob .custom en bruto junto al C# reconstruido. Alinea el prólogo 01 00, cuenta los argumentos fijos contra la firma del constructor, encuentra el recuento de argumentos con nombre 02 00 y observa cómo las etiquetas 53/54 eligen entre campo y propiedad. Para un experimento rápido, añade una propiedad con tipo de enumeración a un atributo y recompila: verás aparecer el tipo de elemento 0x55 y el nombre de tipo incrustado en el blob, con el valor numérico almacenado donde el nombre del miembro nunca está.
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 tienes licencia para analizar. Decodificar un blob de atributo personalizado con fidelidad, hasta la etiqueta campo-o-propiedad, es la diferencia entre leer los metadatos y adivinarlos.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.