[UnsafeAccessor] dekompilieren: die extern-Methode ohne Rumpf und ein privater Name in ihrem Attribut
Eine UnsafeAccessor-Methode hat überhaupt keinen IL-Rumpf — das private Member, das sie erreicht, lebt nur als Zeichenkette im Blob eines benutzerdefinierten Attributs, vom JIT gebunden. So liest Glass.NET sie zurück.
[UnsafeAccessor], in .NET 8 hinzugekommen, ist der sanktionierte Weg, ein nicht-öffentliches Member ohne Reflexion zu erreichen. Man deklariert eine static extern-Methode, dekoriert sie mit der gewünschten Zugriffsart und dem Namen des Members, und die Runtime bindet sie zur JIT-Zeit an das echte Feld, die echte Methode oder den echten Konstruktor: kein MethodInfo, kein Delegat, kein Boxing, und die Aufrufstelle ist ein ganz gewöhnlicher direkter Aufruf. So erreichen Serialisierer, Test-Harnesses und Teile des BCL selbst interne Elemente, auf die sie Anspruch haben, ohne die Reflexions-Kosten zu zahlen.
Es ist außerdem eines der merkwürdigeren Dinge, die ein Dekompiler zurücklesen muss, denn die Methode, die er rekonstruieren soll, hat überhaupt keinen Rumpf, und das einzige Stück Information, das ihr Bedeutung gibt — der Name des privaten Members — lebt nirgendwo außer in einer Zeichenkette innerhalb des Blobs eines benutzerdefinierten Attributs. Ein Dekompiler, der IL-Instruktionen durchläuft, findet nichts; ein Dekompiler, der die Member-Referenztabelle durchläuft, findet keine Verbindung zum Ziel. Alles Wesentliche steckt in Metadaten, die der JIT liest und die der Instruktionsstrom nie erwähnt.
Dieser Beitrag liest die rohen Metadaten eines Feld-Accessors, eines Methoden-Accessors und eines Konstruktor-Accessors, zeigt genau, wo der private Name gespeichert ist, und erklärt Schritt für Schritt, wie Glass.NET jeden in die static extern-Deklaration zurückverwandelt, die der Autor geschrieben hat.
Ein Feld-Accessor ist eine Methode ohne Rumpf, die ein byref zurückgibt
Beginnen wir mit dem kleinstmöglichen Beispiel: ein Typ mit einem privaten Feld und ein Accessor, der eine ref darauf zurückgibt.
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 hat keinen Rumpf, den Sie je geschrieben hätten, und der Compiler emittiert keinen. In IL ist es eine verwaltete Methode, deren gesamte Definition die Signatur und das Attribut ist:
.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
Es gibt kein .maxstack, kein .locals, keine Instruktion — der RVA der Methode ist 0. Das ist es, wozu static extern kompiliert: eine verwaltete Methode, für die die Runtime einen Rumpf liefern soll. Bei P/Invoke liefert die Runtime einen Marshalling-Stub; bei [UnsafeAccessor] liefert sie einen Direktzugriffs-Thunk. Die Implementierung ist nicht pinvokeimpl, und es gibt keine ImplMap-Zeile — das ist das Signal, das sie von [DllImport] trennt, dem anderen, was eine verwaltete extern-Methode ohne Rumpf sein kann.
Der Rückgabetyp ist string& — ELEMENT_TYPE_BYREF string. Ein Feld-Accessor gibt eine verwaltete Referenz auf das Feld zurück, was dem Aufrufer erlaubt, es zu lesen und zu schreiben; ref string in C# ist string& in IL. Ein Dekompiler, der das byref liest und ref string rendert, liegt richtig; einer, der es auf string reduziert, erzeugt einen schreibgeschützten Kopier-Accessor, der das Feld nicht mehr aliast.
Der private Name steht im Blob, und nur dort
Dekodieren Sie diesen Attribut-Blob Byte für Byte, denn es ist die einzige Stelle, an der _secret erscheint:
01 00 ; Prolog (Version des Blobs des benutzerdefinierten Attributs)
03 00 00 00 ; ctor-Argument: UnsafeAccessorKind = Field (3)
01 00 ; Anzahl der benannten Argumente = 1
54 ; das benannte Argument ist eine PROPERTY (0x54)
0E ; Typ der Eigenschaft = ELEMENT_TYPE_STRING
04 4E 61 6D 65 ; Name der Eigenschaft : Länge 4, "Name"
07 5F 73 65 63 72 65 74 ; Wert der Eigenschaft : Länge 7, "_secret"
UnsafeAccessorKind ist ein Enum, also wird sein ctor-Argument als zugrunde liegendes int32 serialisiert: 03 00 00 00 ist Field. Der Name ist eine serialisierte Zeichenkette: ein Längenpräfix und rohe UTF-8-Bytes. Nirgends in der Methode und nirgends sonst in den Metadaten des Moduls gibt es ein FieldRef- oder MemberRef-Token, das auf UserClass._secret zeigt. Die Bindung erfolgt per Zeichenkette, vom JIT gegen den Typ des ersten Parameters aufgelöst. Für einen Dekompiler ist das der Kern: Der Member-Name muss aus dem serialisierten Blob gelesen und zurück in das regenerierte Attribut gesetzt werden, denn der Aufrufgraph, die Member-Referenztabelle und der Instruktionsstrom sagen alle, dass der Accessor nichts referenziert.
Ein Methoden-Accessor: der erste Parameter ist der Empfänger
Eine private Methode zu erreichen hat dieselbe Form, mit den eigenen Parametern des Ziels nach der Instanz angehängt:
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 )
}
Der Kind ist nun 01 00 00 00 — Method — und der Wert von Name ist 43 6F 6D 70 75 74 65, "Compute". Die Konvention, die die Runtime erzwingt, ist, dass bei Method und Field der erste Parameter die Instanz ist, deren Member zugegriffen wird, und die übrigen Parameter mit der Signatur der Zielmethode übereinstimmen müssen. Diese Konvention ist strukturell, nicht syntaktisch: Es gibt kein Schlüsselwort zu rekonstruieren, also rendert Glass die Parameter genau so, wie sie erscheinen. Was es richtig treffen muss, ist, dass die Signatur von CallCompute nach dem Empfänger — (int32 x, int32 y) → int32 — die Signatur ist, gegen die das Attribut bindet, also muss die regenerierte Deklaration die Parameter- und Rückgabetypen exakt bewahren, sonst würde die Runtime-Bindung beim Neukompilieren fehlschlagen.
Ein Aufruf darauf ist unauffällig:
ldloc.0 // UserClass u
ldc.i4.6
ldc.i4.7
call int32 Accessors::CallCompute(class UserClass, int32, int32)
Wiederum: Das Aufruf-Token nennt CallCompute, niemals Compute. Der Name der privaten Methode überlebt nur im Attribut des Accessors selbst.
Ein Konstruktor-Accessor: der Name ist der Rückgabetyp
Bei UnsafeAccessorKind.Constructor kehrt sich die Form um: Es gibt keinen Instanz-Parameter, der Rückgabetyp des Accessors ist der konstruierte Typ, und Name wird nicht verwendet (ein Konstruktor hat keinen eigenen Member-Namen):
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 )
}
Der Blob ist nun nur der Kind — 00 00 00 00 für Constructor — gefolgt von 00 00, null benannten Argumenten. Es gibt kein Name, denn die Runtime findet den Konstruktor, indem sie die Parameterliste gegen den im Rückgabetyp genannten Typ abgleicht. Glass liest den Kind als Constructor, sieht die leere Anzahl benannter Argumente und emittiert absichtlich kein Name =: eines hinzuzufügen wäre falsch, und manche Runtimes lehnen einen benannten Konstruktor-Accessor ab. Der Zieltyp stammt aus der Rückgabesignatur class UserClass, die die Rekonstruktion als Rückgabetyp der Methode beibehält.
UnsafeAccessorKind.StaticMethod und StaticField runden den Satz ab: Sie lassen den Instanz-Parameter weg (das Ziel ist statisch), und ihre Blobs tragen die Kinds 02 bzw. 04 mit einem Name. .NET 9 erweiterte das Feature auf generische Ziele, sodass Sie auch Accessoren mit Typparametern und einer passenden generischen Signatur antreffen werden; die Rekonstruktionsregel ändert sich nicht: Lesen Sie Kind und Name aus dem Blob, bewahren Sie die Signatur unverändert.
Einen mit Glass zurücklesen
Da der interessante Teil ein benutzerdefiniertes Attribut und ein leerer Rumpf ist, ist die IL-Ansicht der schnellste Weg, zu bestätigen, woran ein Accessor tatsächlich bindet. Richten Sie Glass auf das Assembly und geben Sie das einzelne Member aus:
$ glass export ./Accessors.dll --member "M:Accessors.GetSecret(UserClass)" --il
Das druckt die Methode ohne Rumpf und das dekodierte UnsafeAccessorAttribute, sodass Sie den Kind und den Name sehen können, ohne den Blob von Hand zu dekodieren. Lassen Sie --il weg, und Glass rekonstruiert den C#-Code:
$ glass export ./Accessors.dll --member "M:Accessors.GetSecret(UserClass)"
[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_secret")]
public static extern ref string GetSecret(UserClass u);
Die Deklaration ist die gesamte Methode: kein Rumpf, das ref bewahrt, der private Name aus dem Blob gezogen und dorthin zurückgesetzt, wo der Autor ihn geschrieben hat. Glass verwendet dieselbe ICSharpCode.Decompiler-Engine wie die Oberfläche, sodass Sie in der Seite-an-Seite-Ansicht das identische Ergebnis erhalten, wenn Sie das Assembly in der Anwendung öffnen und den Accessor auswählen. Alles hier ist statisch: Glass liest die Metadaten und rekonstruiert den C#-Code, und es JITtet den Accessor nie und führt den Zieltyp nie aus — was genau der Grund ist, warum es sicher ist, es auf eine Abhängigkeit zu richten, bei der Sie noch entscheiden, ob Sie ihr vertrauen.
Zu verstehen, wie [UnsafeAccessor] dekompiliert, wird zunehmend praktisch, denn das Muster breitet sich vom BCL in gängige Bibliotheken aus, die reflexionsfreien Zugriff auf interne Elemente wollen, die ihnen gehören. Wenn Sie Ihren eigenen Accessor debuggen, der still an die falsche Überladung bindet, oder lesen, wie ein Serialisierer einen privaten Setter erreicht, liegt die Antwort nie im Methodenrumpf: Es gibt keinen. Sie liegt im Attribut-Blob und der Signatur, und genau das macht Glass sichtbar. Holen Sie sich die neueste Version von der Glass.NET-Downloadseite und lesen Sie das nächste extern ohne Rumpf, dem Sie begegnen.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.