Skip to content
← Alle Beiträge
· Delta1 Labs DecompilationGlass

Blobs benutzerdefinierter Attribute decodieren: von #Blob-Bytes zurück zu [Cache(30, ...)]

Die Anwendung eines Attributs wird nicht als Quellcode gespeichert. Sie ist ein binärer Blob im #Blob-Heap: ein Prolog, die nach der Konstruktorsignatur serialisierten Positionsargumente und dann eine gezählte Liste benannter Feld- und Eigenschaftswerte. Hier ist das exakte Byte-Layout und wie Glass.NET es wieder in ein C#-Attribut verwandelt.

Die meisten C#-Konstrukte werden in IL-Anweisungen übersetzt. Attribute nicht: Die Anwendung eines Attributs kompiliert zu Daten, einem kompakten Binärsatz, der im #Blob-Heap gespeichert und von einer Zeile der Metadatentabelle CustomAttribute referenziert wird. Es gibt keinen Code zum Zurücklesen, nur Bytes zum Decodieren, und die Decodierung wird von einer Signatur gesteuert, die an einem ganz anderen Ort liegt. Das Feld-oder-Eigenschaft-Tag eines benannten Arguments falsch zu bestimmen oder den eingebetteten Typnamen einer Enumeration falsch zu lesen, erzeugt ein Attribut, das plausibel aussieht und an das falsche Element bindet. Dieser Beitrag geht das exakte Byte-Layout durch und zeigt, was Glass.NET rekonstruiert.

Der Quellcode

Ein einzelnes Attribut mit zwei Positionsargumenten und zwei benannten Argumenten (eines eine Eigenschaft, eines ein Feld) genügt, um jeden Teil des Formats auszureizen:

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

Die Anwendung auf ProductService sagt: rufe den Konstruktor (int, string) mit 30 und "catalog" auf, setze dann die Eigenschaft SlidingExpiration auf true und das Feld Priority auf 5. Keiner dieser Elementnamen oder Werte wird als Text in Quellcodeform gespeichert; sie werden in einen Blob serialisiert, dessen Form durch ECMA-335 §II.23.3 festgelegt ist.

Was die Metadaten wirklich enthalten

ildasm und die IL-Ansicht von Glass stellen die Anwendung beide als Konstruktorreferenz gefolgt vom rohen Blob dar:

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

Zweiundfünfzig Bytes. Jedes Feld des Attributs steckt darin, in strikter Reihenfolge, ohne Trennzeichen und ohne Namen für die Positionsargumente. Hier ist derselbe Blob, aufgeteilt:

BytesBedeutung
01 00Prolog — immer 0x0001, Little-Endian
1E 00 00 00Festes Argument 1: int32 = 30
07 + 63 61 74 61 6C 6F 67Festes Argument 2: SerString, Länge 7, UTF-8 “catalog”
02 00NumNamed = 2 benannte Argumente folgen
54Tag des benannten Arguments 1: PROPERTY
02Elementtyp BOOLEAN
11 + 53 6C 69 64 …Name SerString, Länge 17, “SlidingExpiration”
01Wert: true
53Tag des benannten Arguments 2: FIELD
08Elementtyp I4 (int32)
08 + 50 72 69 6F …Name SerString, Länge 8, “Priority”
05 00 00 00Wert: 5

Der Prolog und die festen Argumente

Die ersten beiden Bytes sind ein Versions-Prolog, stets 0x0001. Danach kommen die festen Argumente (die Positionsparameter des Konstruktors), hintereinander in Deklarationsreihenfolge serialisiert, ohne Typ-Tags und ohne Namen. Der Blob speichert 1E 00 00 00 und 07 catalog; er vermerkt nicht, dass das erste seconds oder das zweite region ist. Die einzige Möglichkeit zu wissen, dass die vier Bytes 1E 00 00 00 ein int32 sind und die nächste Gruppe eine Zeichenfolge, ist, die Konstruktorsignatur aus dem MethodDef/MemberRef zu lesen, auf das die CustomAttribute-Zeile zeigt. Feste Argumente werden über eine externe Signatur decodiert; der Blob allein ist mehrdeutig.

Zeichenfolgen verwenden die SerString-Codierung: eine komprimierte vorzeichenlose Länge (hier ein einzelnes Byte 0x07) gefolgt von so vielen UTF-8-Bytes. Eine komprimierte Länge belegt je nach Größe ein, zwei oder vier Bytes (dasselbe Schema, das in allen Metadaten-Heaps verwendet wird), und eine Null-Zeichenfolge ist das einzelne Byte 0xFF, verschieden vom 0x00 einer leeren Zeichenfolge.

Die benannten Argumente sind selbstbeschreibend

Nach den festen Argumenten kommt eine 2-Byte-Anzahl —02 00 hier— und dann jedes benannte Argument, das anders als die festen seine eigene Typinformation trägt. Jedes beginnt mit einem Tag-Byte, das genau die Information ist, die die C#-Syntax wegwirft:

  • 0x53 = FIELD
  • 0x54 = PROPERTY

Im Quellcode sehen SlidingExpiration = true und Priority = 5 gleich aus: beide sind Name = value. Im Blob unterscheiden sie sich am Byte-Offset null jedes benannten Arguments. Auf das Tag folgen ein Elementtyp-Byte (0x02 für BOOLEAN, 0x08 für I4, 0x0E für STRING, …), ein SerString für den Elementnamen und der nach diesem Elementtyp serialisierte Wert.

Byte layout of a custom attribute blob: prolog, fixed arguments decoded by constructor signature, a named-argument count, and self-describing named arguments Prolog 01 00 Fixed args — no tags, no names 1E 00 00 00 · 07 "catalog" NumNamed 02 00 decoded against the (int32, string) constructor signature Named arg 1 — self-describing 54 PROPERTY tag 02 BOOLEAN element type 11 "SlidingExpiration" 01 value = true Named arg 2 — self-describing 53 FIELD tag 08 I4 element type 08 "Priority" 05 00 00 00 value = 5

Die Asymmetrie ist die ganze Geschichte: Feste Argumente stützen sich auf eine externe Signatur, benannte Argumente beschreiben sich selbst. Ein Decoder muss mitten im Blob die Strategie wechseln.

Die heiklen Fälle: Enumerationen, Type und Arrays

Drei Argumentarten erschweren die Regel „Elementtyp-Byte, dann Wert”, und dort geraten naive Decoder ins Driften.

Enumerationen. Ein Enum-Argument hat kein primitives Elementtyp-Byte. Es wird als 0x55 codiert, gefolgt von einem SerString, der den Enum-Typ benennt, und dann dem Wert, serialisiert als der zugrunde liegende Ganzzahltyp der Enumeration. Angenommen, CacheAttribute akzeptierte auch eine CachePriority-Enumeration:

[Cache(30, "catalog", Level = CachePriority.High)]

Die Bytes des benannten Arguments wären 54 (Eigenschaft) 55 (Enum) dann "...CachePriority" als SerString, dann 02 00 00 00 für den zugrunde liegenden int-Wert 2. Der Blob speichert die Zahl, nicht den Elementnamen High. Um CachePriority.High darzustellen, löst Glass den Enum-Typ über seinen eingebetteten Namen auf und ordnet 2 dem Element zu, oder gibt (CachePriority)2 aus, wenn kein Element einer Flag-Kombination entspricht.

System.Type. Ein typeof(...)-Argument wird als Elementtyp 0x50 serialisiert, gefolgt von einem SerString des Typnamens (assembly-qualifiziert, wenn er anderswo liegt). Glass parst diesen Namen wieder zu einem typeof(T)-Ausdruck, statt ein Zeichenfolgenliteral stehen zu lassen.

Arrays. Ein Array-Argument ist SZARRAY (0x1D), der Elementtyp, eine 4-Byte-Elementanzahl, dann die Elemente der Reihe nach gepackt (0xFFFFFFFF kennzeichnet ein Null-Array, verschieden von einem der Länge null). Jedes Element wird nach dem Elementtyp serialisiert, ein string[] ist also eine Anzahl gefolgt von so vielen SerStrings.

Was Glass rekonstruiert

Glass liest die CustomAttribute-Zeile, löst den Konstruktor auf, um die Typen der festen Argumente wiederzugewinnen, decodiert den Blob in zwei Durchgängen (signaturgesteuert für feste Argumente, selbstbeschreibend für benannte Argumente), berücksichtigt jedes FIELD/PROPERTY-Tag, um das richtige Element zu binden, und löst Enum- und Type-Namen auf. Aus den obigen 52 Bytes erzeugt es genau die ursprüngliche Anwendung:

[Cache(30, "catalog", SlidingExpiration = true, Priority = 5)]
sealed class ProductService { }

Ein Decoder, der das Tag-Byte des benannten Arguments überspränge oder die eingebettete Typzeichenfolge der Enumeration als Positionswert behandelte, gäbe etwas aus, das kompiliert, aber das falsche Element oder die falsche Konstante benennt: dieselbe Klasse stillen, auf dem Bildschirm unsichtbaren Fehlers wie das Weglassen eines Überlauf-Suffixes.

Selbst nachlesen

Öffnen Sie ein beliebiges Assembly in Glass, wählen Sie einen dekorierten Typ oder eine dekorierte Methode und wechseln Sie zur IL-Ansicht, um den rohen .custom-Blob neben dem rekonstruierten C# zu sehen. Richten Sie den Prolog 01 00 aus, zählen Sie die festen Argumente gegen die Konstruktorsignatur, finden Sie die Anzahl benannter Argumente 02 00 und beobachten Sie, wie die Tags 53/54 zwischen Feld und Eigenschaft wählen. Für ein schnelles Experiment fügen Sie einem Attribut eine Eigenschaft mit Enum-Typ hinzu und kompilieren neu: Sie sehen den Elementtyp 0x55 und den eingebetteten Typnamen im Blob erscheinen, mit dem numerischen Wert dort gespeichert, wo der Elementname nie steht.

Glass.NET ist ein kostenloser .NET-Decompiler zum Inspizieren von Assemblys, die Sie inspizieren dürfen: Ihre eigenen Builds, Ihre Abhängigkeiten und Drittanbieter-Binärdateien, die Sie analysieren dürfen. Einen Blob eines benutzerdefinierten Attributs getreu zu decodieren, bis hinunter zum Feld-oder-Eigenschaft-Tag, ist der Unterschied zwischen dem Lesen von Metadaten und dem Raten.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.