Skip to content
← Todas las publicaciones
· Delta1 Labs UnsafeAccessorGlass

Descompilar [UnsafeAccessor]: el método extern sin cuerpo y un nombre privado en su atributo

Un método UnsafeAccessor no tiene ningún cuerpo IL: el miembro privado al que accede vive solo como una cadena en el blob de un atributo personalizado, vinculado por el JIT. Así lo reconstruye Glass.NET.

[UnsafeAccessor], añadido en .NET 8, es la forma autorizada de alcanzar un miembro no público sin reflexión. Declaras un método static extern, lo decoras con el tipo de acceso que quieres y el nombre del miembro, y el runtime lo vincula al campo, método o constructor real en tiempo de JIT: sin MethodInfo, sin delegado, sin boxing, y el sitio de llamada es una llamada directa cualquiera. Así es como los serializadores, los arneses de prueba y partes del propio BCL alcanzan internos a los que tienen derecho sin pagar el coste de la reflexión.

También es una de las cosas más extrañas que un descompilador tiene que leer de vuelta, porque el método que debe reconstruir no tiene ningún cuerpo, y la única pieza de información que le da sentido —el nombre del miembro privado— no vive en ningún sitio salvo una cadena dentro del blob de un atributo personalizado. Un descompilador que recorre instrucciones IL no encuentra nada; uno que recorre la tabla de referencias de miembros no encuentra ningún enlace al objetivo. Todo lo que importa está en metadatos que el JIT lee y que el flujo de instrucciones nunca menciona.

Esta entrada lee los metadatos en crudo de un accessor de campo, uno de método y uno de constructor, muestra exactamente dónde se almacena el nombre privado y recorre cómo Glass.NET convierte cada uno de vuelta en la declaración static extern que escribió el autor.

1 · el cuerpo del método — vacío.method static string& GetSecret( class UserClass u) cil managedRVA 0 · sin .locals · sin instrucciones2 · el blob del atributo — el único enlaceUnsafeAccessorAttribute(Field) Name = "_secret"una cadena UTF-8 — no un token FieldRef3 · el sitio de llamada — normalldloc.0 // UserClasscall string& GetSecret(class UserClass)ninguna mención de _secret aquílo que Glass reconstruye[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secret")]static extern ref string GetSecret(UserClass u);El JIT lee 1 + 2, encuentra _secret en el tipo del primer parámetro, comprueba las firmas y vincula un accessor directo.Quita el atributo y el método es un extern vacío que lanza en runtime; quita el Name y el objetivo de vinculación desaparece.

Un accessor de campo es un método sin cuerpo que devuelve un byref

Empieza con el ejemplo más pequeño posible: un tipo con un campo privado y un accessor que devuelve una ref a él.

public class UserClass
{
    private string _secret = "hidden";
}

public static class Accessors
{
    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secret")]
    public static extern ref string GetSecret(UserClass u);
}

GetSecret no tiene ningún cuerpo que hayas escrito, y el compilador no emite ninguno. En IL es un método administrado cuya definición completa es la firma y el atributo:

.method public hidebysig static
        string& GetSecret (class UserClass u) cil managed
{
  .custom instance void [System.Runtime]System.Runtime.CompilerServices.UnsafeAccessorAttribute::.ctor(
          valuetype [System.Runtime]System.Runtime.CompilerServices.UnsafeAccessorKind)
    = ( 01 00 03 00 00 00 01 00 54 0E 04 4E 61 6D 65 07 5F 73 65 63 72 65 74 )
} // end of method Accessors::GetSecret

No hay .maxstack, no hay .locals, no hay ninguna instrucción: el RVA del método es 0. Eso es lo que compila static extern: un método administrado para el que se espera que el runtime suministre un cuerpo. Para P/Invoke el runtime suministra un stub de marshalling; para [UnsafeAccessor] suministra un thunk de acceso directo. La implementación no es pinvokeimpl y no hay fila ImplMap: esa es la señal que lo separa de [DllImport], que es la otra cosa que puede ser un método administrado extern sin cuerpo.

El tipo de retorno es string& —ELEMENT_TYPE_BYREF string—. Un accessor de campo devuelve una referencia administrada al campo, que es lo que permite al llamante leerlo y escribirlo; ref string en C# es string& en IL. Un descompilador que lee el byref y renderiza ref string acierta; uno que lo reduce a string produce un accessor de copia de solo lectura que ya no actúa como alias del campo.

El nombre privado está en el blob, y solo ahí

Decodifica ese blob de atributo byte a byte, porque es el único lugar donde aparece _secret:

01 00                      ; prólogo (versión del blob del atributo personalizado)
03 00 00 00                ; arg del ctor: UnsafeAccessorKind = Field (3)
01 00                      ; número de argumentos con nombre = 1
54                         ; el argumento con nombre es una PROPERTY (0x54)
0E                         ; tipo de la propiedad = ELEMENT_TYPE_STRING
04 4E 61 6D 65             ; nombre de la propiedad : longitud 4, "Name"
07 5F 73 65 63 72 65 74    ; valor de la propiedad  : longitud 7, "_secret"

UnsafeAccessorKind es un enum, así que su argumento de ctor se serializa como su int32 subyacente: 03 00 00 00 es Field. El Name es una cadena serializada: un prefijo de longitud y bytes UTF-8 en crudo. En ningún lugar del método, ni en ningún otro lugar de los metadatos del módulo, hay un token FieldRef o MemberRef que apunte a UserClass._secret. La vinculación es por cadena, resuelta por el JIT contra el tipo del primer parámetro. Para un descompilador este es el meollo: el nombre del miembro debe leerse del blob serializado y colocarse de vuelta en el atributo regenerado, porque el grafo de llamadas, la tabla de referencias de miembros y el flujo de instrucciones dicen todos que el accessor no referencia nada.

Un accessor de método: el primer parámetro es el receptor

Alcanzar un método privado tiene la misma forma, con los parámetros propios del objetivo añadidos tras la instancia:

public class UserClass
{
    private int Compute(int x, int y) => x * y + 1;
}

[UnsafeAccessor(UnsafeAccessorKind.Method, Name = "Compute")]
public static extern int CallCompute(UserClass u, int x, int y);
.method public hidebysig static
        int32 CallCompute (class UserClass u, int32 x, int32 y) cil managed
{
  .custom instance void [...]UnsafeAccessorAttribute::.ctor(valuetype [...]UnsafeAccessorKind)
    = ( 01 00 01 00 00 00 01 00 54 0E 04 4E 61 6D 65 07 43 6F 6D 70 75 74 65 )
}

Ahora el kind es 01 00 00 00 —Method— y el valor de Name es 43 6F 6D 70 75 74 65, "Compute". La convención que el runtime impone es que para Method y Field el primer parámetro es la instancia cuyo miembro se accede, y los parámetros restantes deben coincidir con la firma del método objetivo. Esa convención es estructural, no sintáctica: no hay ninguna palabra clave que reconstruir, así que Glass renderiza los parámetros exactamente como aparecen. Lo que debe acertar es que la firma de CallCompute tras el receptor —(int32 x, int32 y) → int32— es la firma contra la que el atributo vincula, así que la declaración regenerada tiene que preservar los tipos de parámetro y retorno con precisión o la vinculación del runtime fallaría al recompilar.

Una llamada a él no tiene nada especial:

ldloc.0            // UserClass u
ldc.i4.6
ldc.i4.7
call int32 Accessors::CallCompute(class UserClass, int32, int32)

De nuevo: el token de llamada nombra CallCompute, nunca Compute. El nombre del método privado sobrevive solo en el atributo del propio accessor.

Un accessor de constructor: el nombre es el tipo de retorno

Para UnsafeAccessorKind.Constructor la forma se invierte: no hay parámetro de instancia, el tipo de retorno del accessor es el tipo que se construye, y Name no se usa (un constructor no tiene nombre de miembro propio):

public class UserClass
{
    private UserClass(string seed) { _secret = seed; }
}

[UnsafeAccessor(UnsafeAccessorKind.Constructor)]
public static extern UserClass CreateUser(string seed);
.method public hidebysig static
        class UserClass CreateUser (string seed) cil managed
{
  .custom instance void [...]UnsafeAccessorAttribute::.ctor(valuetype [...]UnsafeAccessorKind)
    = ( 01 00 00 00 00 00 00 00 )
}

El blob ahora es solo el kind —00 00 00 00 para Constructor— seguido de 00 00, cero argumentos con nombre. No hay Name, porque el runtime encuentra el constructor haciendo coincidir la lista de parámetros contra el tipo nombrado en el retorno. Glass lee el kind como Constructor, ve el recuento vacío de argumentos con nombre y deliberadamente no emite ningún Name =: añadir uno sería incorrecto, y algunos runtimes rechazan un accessor de constructor con nombre. El tipo objetivo viene de la firma de retorno class UserClass, que la reconstrucción conserva como tipo de retorno del método.

UnsafeAccessorKind.StaticMethod y StaticField completan el conjunto: eliminan el parámetro de instancia (el objetivo es estático) y sus blobs llevan los kinds 02 y 04 respectivamente con un Name. .NET 9 extendió la característica a objetivos genéricos, así que también te encontrarás accessors con parámetros de tipo y una firma genérica correspondiente; la regla de reconstrucción no cambia: lee el kind y el Name del blob, conserva la firma tal cual.

Leer uno de vuelta con Glass

Como la parte interesante es un atributo personalizado y un cuerpo vacío, la vista de IL es la forma más rápida de confirmar a qué vincula realmente un accessor. Apunta Glass al ensamblado y vuelca el miembro individual:

$ glass export ./Accessors.dll --member "M:Accessors.GetSecret(UserClass)" --il

Eso imprime el método sin cuerpo y el UnsafeAccessorAttribute decodificado, de modo que puedes ver el kind y el Name sin decodificar el blob a mano. Quita --il y Glass reconstruye el C#:

$ glass export ./Accessors.dll --member "M:Accessors.GetSecret(UserClass)"
[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secret")]
public static extern ref string GetSecret(UserClass u);

La declaración es el método completo: sin cuerpo, el ref preservado, el nombre privado extraído del blob y colocado de vuelta donde el autor lo escribió. Glass usa el mismo motor ICSharpCode.Decompiler que la interfaz, así que obtienes el resultado idéntico en la vista lado a lado cuando abres el ensamblado en la aplicación y seleccionas el accessor. Todo aquí es estático: Glass lee los metadatos y reconstruye el C#, y nunca hace JIT del accessor ni ejecuta el tipo objetivo, que es precisamente por lo que es seguro apuntarlo a una dependencia que aún estás decidiendo si confiar.

Entender cómo se descompila [UnsafeAccessor] es cada vez más práctico, porque el patrón se está extendiendo del BCL a bibliotecas convencionales que quieren acceso sin reflexión a internos que poseen. Cuando depuras tu propio accessor que vincula silenciosamente a la sobrecarga equivocada, o lees cómo un serializador alcanza un setter privado, la respuesta nunca está en el cuerpo del método: no hay ninguno. Está en el blob del atributo y la firma, y eso es exactamente lo que Glass muestra. Descarga la última versión desde la página de descarga de Glass.NET y lee el próximo extern sin cuerpo que te encuentres.

Prueba Nebula.NET

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