Skip to content
← Tous les articles
· Delta1 Labs UnsafeAccessorGlass

Décompiler [UnsafeAccessor] : la méthode extern sans corps et un nom privé dans son attribut

Une méthode UnsafeAccessor n'a aucun corps IL : le membre privé qu'elle atteint ne vit que comme une chaîne dans le blob d'un attribut personnalisé, liée par le JIT. Voici comment Glass.NET la reconstruit.

[UnsafeAccessor], ajouté dans .NET 8, est la façon sanctionnée d’atteindre un membre non public sans réflexion. Vous déclarez une méthode static extern, vous la décorez avec le type d’accès souhaité et le nom du membre, et le runtime la lie au champ, à la méthode ou au constructeur réel au moment du JIT : pas de MethodInfo, pas de délégué, pas de boxing, et le site d’appel est un appel direct ordinaire. C’est ainsi que les sérialiseurs, les harnais de test et des parties du BCL lui-même atteignent des éléments internes auxquels ils ont droit sans payer le coût de la réflexion.

C’est aussi l’une des choses les plus étranges qu’un décompilateur doive relire, car la méthode qu’il doit reconstruire n’a aucun corps, et la seule information qui lui donne un sens — le nom du membre privé — ne vit nulle part sauf dans une chaîne à l’intérieur du blob d’un attribut personnalisé. Un décompilateur qui parcourt les instructions IL ne trouve rien ; un décompilateur qui parcourt la table des références de membres ne trouve aucun lien vers la cible. Tout ce qui compte se trouve dans des métadonnées que le JIT lit et que le flux d’instructions ne mentionne jamais.

Cet article lit les métadonnées brutes d’un accesseur de champ, d’un accesseur de méthode et d’un accesseur de constructeur, montre exactement où le nom privé est stocké, et détaille comment Glass.NET reconvertit chacun en la déclaration static extern écrite par l’auteur.

1 · le corps de la méthode — vide.method static string& GetSecret( class UserClass u) cil managedRVA 0 · pas de .locals · aucune instruction2 · le blob de l'attribut — le seul lienUnsafeAccessorAttribute(Field) Name = "_secret"une chaîne UTF-8 — pas un jeton FieldRef3 · le site d'appel — ordinaireldloc.0 // UserClasscall string& GetSecret(class UserClass)aucune mention de _secret icice que Glass reconstruit[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secret")]static extern ref string GetSecret(UserClass u);Le JIT lit 1 + 2, trouve _secret sur le type du premier paramètre, vérifie les signatures et lie un accesseur direct.Retirez l'attribut et la méthode est un extern vide qui lève à l'exécution ; retirez le Name et la cible de liaison disparaît.

Un accesseur de champ est une méthode sans corps qui renvoie un byref

Commencez par l’exemple le plus petit possible : un type avec un champ privé, et un accesseur qui renvoie une ref vers lui.

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 n’a aucun corps que vous ayez écrit, et le compilateur n’en émet aucun. En IL, c’est une méthode managée dont la définition entière est la signature et l’attribut :

.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

Il n’y a pas de .maxstack, pas de .locals, aucune instruction — le RVA de la méthode est 0. Voilà ce que static extern compile : une méthode managée dont le runtime est censé fournir le corps. Pour P/Invoke, le runtime fournit un stub de marshalling ; pour [UnsafeAccessor], il fournit un thunk d’accès direct. L’implémentation n’est pas pinvokeimpl et il n’y a pas de ligne ImplMap — c’est le signal qui la sépare de [DllImport], l’autre chose que peut être une méthode managée extern sans corps.

Le type de retour est string& — ELEMENT_TYPE_BYREF string. Un accesseur de champ renvoie une référence managée vers le champ, ce qui permet à l’appelant de le lire et de l’écrire ; ref string en C# est string& en IL. Un décompilateur qui lit le byref et rend ref string a raison ; un qui le réduit à string produit un accesseur de copie en lecture seule qui n’est plus un alias du champ.

Le nom privé est dans le blob, et seulement là

Décodez ce blob d’attribut octet par octet, car c’est le seul endroit où apparaît _secret :

01 00                      ; prologue (version du blob d'attribut personnalisé)
03 00 00 00                ; arg du ctor : UnsafeAccessorKind = Field (3)
01 00                      ; nombre d'arguments nommés = 1
54                         ; l'argument nommé est une PROPERTY (0x54)
0E                         ; type de la propriété = ELEMENT_TYPE_STRING
04 4E 61 6D 65             ; nom de la propriété   : longueur 4, "Name"
07 5F 73 65 63 72 65 74    ; valeur de la propriété : longueur 7, "_secret"

UnsafeAccessorKind est un enum, donc son argument de ctor est sérialisé comme son int32 sous-jacent : 03 00 00 00 est Field. Le Name est une chaîne sérialisée : un préfixe de longueur et des octets UTF-8 bruts. Nulle part dans la méthode, et nulle part ailleurs dans les métadonnées du module, il n’existe de jeton FieldRef ou MemberRef pointant vers UserClass._secret. La liaison se fait par chaîne, résolue par le JIT contre le type du premier paramètre. Pour un décompilateur, c’est le nœud du problème : le nom du membre doit être lu dans le blob sérialisé et replacé dans l’attribut régénéré, car le graphe d’appels, la table des références de membres et le flux d’instructions disent tous que l’accesseur ne référence rien.

Un accesseur de méthode : le premier paramètre est le récepteur

Atteindre une méthode privée a la même forme, avec les paramètres propres de la cible ajoutés après l’instance :

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 )
}

Le kind est maintenant 01 00 00 00 — Method — et la valeur de Name est 43 6F 6D 70 75 74 65, "Compute". La convention que le runtime impose est que pour Method et Field, le premier paramètre est l’instance dont le membre est accédé, et les paramètres restants doivent correspondre à la signature de la méthode cible. Cette convention est structurelle, pas syntaxique : il n’y a aucun mot-clé à reconstruire, donc Glass rend les paramètres exactement tels qu’ils apparaissent. Ce qu’il doit obtenir correctement, c’est que la signature de CallCompute après le récepteur — (int32 x, int32 y) → int32 — est la signature contre laquelle l’attribut se lie, donc la déclaration régénérée doit préserver les types de paramètre et de retour avec précision, sinon la liaison du runtime échouerait à la recompilation.

Un appel vers elle n’a rien de remarquable :

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

Encore une fois : le jeton d’appel nomme CallCompute, jamais Compute. Le nom de la méthode privée ne survit que dans l’attribut de l’accesseur lui-même.

Un accesseur de constructeur : le nom est le type de retour

Pour UnsafeAccessorKind.Constructor, la forme s’inverse : il n’y a pas de paramètre d’instance, le type de retour de l’accesseur est le type construit, et Name n’est pas utilisé (un constructeur n’a pas de nom de membre propre) :

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 )
}

Le blob n’est maintenant que le kind — 00 00 00 00 pour Constructor — suivi de 00 00, zéro argument nommé. Il n’y a pas de Name, car le runtime trouve le constructeur en faisant correspondre la liste de paramètres au type nommé dans le retour. Glass lit le kind comme Constructor, voit le décompte vide d’arguments nommés et n’émet délibérément aucun Name = : en ajouter un serait faux, et certains runtimes rejettent un accesseur de constructeur nommé. Le type cible provient de la signature de retour class UserClass, que la reconstruction conserve comme type de retour de la méthode.

UnsafeAccessorKind.StaticMethod et StaticField complètent l’ensemble : ils suppriment le paramètre d’instance (la cible est statique) et leurs blobs portent les kinds 02 et 04 respectivement avec un Name. .NET 9 a étendu la fonctionnalité aux cibles génériques, donc vous rencontrerez aussi des accesseurs avec des paramètres de type et une signature générique correspondante ; la règle de reconstruction ne change pas : lisez le kind et le Name dans le blob, conservez la signature telle quelle.

En relire un avec Glass

Comme la partie intéressante est un attribut personnalisé et un corps vide, la vue IL est le moyen le plus rapide de confirmer à quoi un accesseur se lie réellement. Pointez Glass sur l’assembly et videz le membre individuel :

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

Cela imprime la méthode sans corps et le UnsafeAccessorAttribute décodé, de sorte que vous pouvez voir le kind et le Name sans décoder le blob à la main. Retirez --il et Glass reconstruit le C# :

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

La déclaration est la méthode entière : pas de corps, le ref préservé, le nom privé extrait du blob et replacé là où l’auteur l’avait écrit. Glass utilise le même moteur ICSharpCode.Decompiler que l’interface, donc vous obtenez le résultat identique dans la vue côte à côte quand vous ouvrez l’assembly dans l’application et sélectionnez l’accesseur. Tout ici est statique : Glass lit les métadonnées et reconstruit le C#, et ne fait jamais le JIT de l’accesseur ni n’exécute le type cible — ce qui est précisément pourquoi il est sûr de le pointer vers une dépendance dont vous décidez encore si vous lui faites confiance.

Comprendre comment [UnsafeAccessor] se décompile est de plus en plus pratique, car le motif se répand du BCL vers des bibliothèques courantes qui veulent un accès sans réflexion à des éléments internes qu’elles possèdent. Quand vous déboguez votre propre accesseur qui se lie silencieusement à la mauvaise surcharge, ou que vous lisez comment un sérialiseur atteint un setter privé, la réponse n’est jamais dans le corps de la méthode : il n’y en a pas. Elle est dans le blob de l’attribut et la signature, et c’est exactement ce que Glass fait apparaître. Téléchargez la dernière version depuis la page de téléchargement de Glass.NET et lisez le prochain extern sans corps que vous rencontrez.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.