Skip to content
← Alle Beiträge
· Delta1 Labs DekompiliererGlass.NET.NETNuGet

Referenzen aus einer NuGet-Lockfile in Glass.NET auflösen

Ein Dekompilierer ist nur so genau wie die Referenzen, die er auflösen kann. Richte Glass.NET auf deine packages.lock.json und es lädt die exakt fixierten Paketversionen — so werden Typen, Basisklassen und Überladungen gegen das aufgelöst, was wirklich wiederhergestellt wurde, nicht gegen eine Vermutung.

Ein Dekompilierer verdient sich dein Vertrauen Referenz für Referenz. Öffne eine Assembly, die ganz für sich allein steht, und das C# kommt sauber zurück. Öffne eine echte — einen Dienst, der sich auf ein Dutzend NuGet-Pakete stützt — und die Qualität der Rekonstruktion hängt plötzlich von etwas außerhalb der Datei ab, die du geöffnet hast: Kann der Dekompilierer die referenzierten Assemblys finden, und die richtigen Versionen davon?

Wenn er es nicht kann, sind die Symptome vertraut. Eine Methode gibt JToken zurück, aber der Dekompilierer entfaltet den Typ nicht und folgt ihm nicht bis zu seiner Basis. Eine Überladung, die sich nur durch den Typ eines Parameters aus einer Abhängigkeit unterscheidet, löst sich zu // unresolved oder zum falschen Kandidaten auf. Gehe-zu-Definition auf einem externen Symbol läuft ins Leere. Nichts davon ist Glass, das schlecht rät — es ist Glass, das ehrlich ist: Eine Referenz, die es nicht laden kann, ist eine Referenz, durch die es nicht hindurchsehen kann.

Glass.NET — der kostenlose, streng statische .NET-Dekompilierer — schließt diese Lücke, indem es deine packages.lock.json liest. Die Lockdatei ist das eine Artefakt, das maßgeblich sagt, welche exakten Paketversionen dein Projekt wiederhergestellt hat. Gib sie an Glass weiter, und jede externe Referenz löst sich zu der Assembly auf, die wirklich ausgeliefert wurde, nicht zu einer Näherung.

Warum ein Name nicht genügt

Eine kompilierte Assembly bettet ihre Abhängigkeiten nicht ein. Sie bettet Referenzen auf sie ein. Zwei Metadatentabellen tragen die ganze Geschichte:

  • AssemblyRef — eine Zeile pro referenzierter Assembly: ihr Name, ihre Version, Kultur und ihr Public-Key-Token.
  • TypeRef — eine Zeile pro externem Typ, den der Code berührt: der Name und Namensraum des Typs sowie ein Zeiger zurück auf die AssemblyRef-Zeile, die ihn besitzt.

Das genügt, um einen Typ an einer Aufrufstelle zu benennen. Es genügt nicht, um ihn zu verstehen. Die Basisklasse, die Schnittstellenliste, die Mitglieder, die Konstantenwerte, die Typweiterleitungen — all das lebt in den eigenen TypeDef-Metadaten der referenzierten Assembly, die die referenzierende Assembly niemals kopiert. Ein Dekompilierer, der nur den TypeRef hat, kann also Newtonsoft.Json.Linq.JObject ausgeben, aber nicht wissen, dass JObject : JContainer : JToken, kann seine Mitglieder nicht auflisten und kann nicht auflösen, welche op_Explicit-Konvertierung ein Cast ausgewählt hat. Um durch die Referenz hindurchzusehen, muss er die echte Assembly laden.

Betrachte diese winzige Methode, kompiliert gegen Newtonsoft.Json:

using Newtonsoft.Json.Linq;

public static class Config
{
    public static string? ReadName(string json)
    {
        JObject root = JObject.Parse(json);
        return (string?)root["name"];
    }
}

Ihr IL ist eindeutig darüber, was sie aufruft — jedes externe Mitglied ist ein vollständig qualifiziertes Token:

.method public hidebysig static string ReadName(string json) cil managed
{
  .maxstack  2
  .locals init (class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject V_0)
  ldarg.0
  call       class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject
             [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject::Parse(string)
  stloc.0
  ldloc.0
  ldstr      "name"
  callvirt   instance class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken
             [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::get_Item(object)
  call       string [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::
             op_Explicit(class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken)
  ret
}

Lies die Tokens und beachte, was bereits in deiner Assembly ist und was nicht. Das Präfix [Newtonsoft.Json] ist ein AssemblyRef. get_Item ist auf JToken deklariert, wird aber über JObject aufgerufen — das IL funktioniert nur, weil JObject es erbt, und diese Vererbung ist in Newtonsoft.Json festgehalten, nicht hier. Das abschließende op_Explicit ist eine von mehreren expliziten Konvertierungen auf JToken; die Signatur des Tokens benennt die string-zurückgebende, aber um es als sauberen (string?)-Cast darzustellen und dich hineinspringen zu lassen, braucht Glass die Definition des Typs. Ohne die Assembly zeigt Glass die Form, die es aus den Tokens beweisen kann, und markiert den Rest als extern. Mit ihr füllen sich der Cast, die Vererbung und die Mitgliederliste.

Die Versionsfalle: Was der AssemblyRef sagt vs. was wiederhergestellt wurde

Du könntest meinen, die AssemblyRef-Version löse das „welche”-Problem. Meist tut sie das nicht. .NET-Bibliotheken halten ihre Assembly-Version über Patch-Releases hinweg bewusst stabil — Newtonsoft.Json schleppt die Assembly-Version 13.0.0.0 über viele 13.0.x-NuGet-Releases mit sich — sodass die in deinen AssemblyRef eingebrannte Zahl nicht die Paketversion ist, die wiederhergestellt wurde. Füge eine gleitende Referenz wie <PackageReference Include="Newtonsoft.Json" Version="13.*" /> hinzu, und die Lücke wird größer: Das Projekt kompilierte gegen die jeweils aktuelle 13.0.x, der AssemblyRef sagt immer noch 13.0.0.0, und eine Suche, die nur nach „einem Newtonsoft.Json namens 13.0.0.0” in deinem Cache sucht, könnte jeden von mehreren Ordnern binden.

packages.lock.json ist das Artefakt, das die Mehrdeutigkeit beseitigt. Wenn RestorePackagesWithLockFile aktiv ist, schreibt NuGet die exakt aufgelöste Version und einen Content-Hash für jedes Paket — direkt und transitiv:

{
  "version": 1,
  "dependencies": {
    "net8.0": {
      "Newtonsoft.Json": {
        "type": "Direct",
        "requested": "[13.*, )",
        "resolved": "13.0.3",
        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lAReUcg2cFTjaQ=="
      }
    }
  }
}

"resolved": "13.0.3" ist die Tatsache, die Glass will. Sie bildet direkt auf ~/.nuget/packages/newtonsoft.json/13.0.3/ in deinem lokalen Cache ab, sodass Glass jene Assembly lädt — die, die dein Build tatsächlich verwendet hat — und keinen nahen Nachbarn.

AssemblyRefNewtonsoft.Json 13.0.0.0Cache: 13.0.1Cache: 13.0.2Cache: 13.0.3Cache: 13.0.3-betawelcher?packages.lock.jsonresolved: 13.0.3exakte Übereinstimmung

Richte Glass auf die Lockdatei

Über die CLI

Der decompile-Befehl von Glass nimmt eine Lockdatei und löst jede Referenz aus ihr auf, bevor er eine einzige Zeile rekonstruiert:

glass decompile ./bin/Release/net8.0/Billing.dll \
      --lockfile ./packages.lock.json \
      --out ./recovered

Glass liest die Lockdatei, geht jeden resolved-Eintrag bis zum passenden Ordner ~/.nuget/packages/<id>/<version>/lib/<tfm>/ durch und lädt diese Assemblys als Referenzmenge. Wenn ein Paket seine eigenen von der Lockdatei fixierten transitiven Abhängigkeiten mitschleppt, stehen auch diese in der Datei, sodass sich der Abschluss in einem Durchgang auflöst — keine Netzwerk-Wiederherstellung, keine Ausführung. Alles, was die Lockdatei nicht abdecken kann (eine Framework-Referenz, eine lokale Projektausgabe neben der DLL), löst sich weiterhin über die normale Suche von Glass auf: das Anwendungsverzeichnis, dann die Reference-Packs des gemeinsamen Frameworks für das Ziel-TFM.

Du kannst bestätigen, was aufgelöst wurde, bevor du der Ausgabe vertraust. glass sbom liest dieselben Eingaben und druckt die zusammengeführte Referenzmenge mit den exakten Versionen, die Glass gebunden hat, sodass du „was die Lockdatei sagte” gegen „was Glass geladen hat” abgleichen und eine Lücke erkennen kannst — etwa ein im Cache fehlendes Paket — anstatt sie drei Dateien tief als unaufgelösten Typ zu entdecken.

In der Oberfläche

Öffne Billing.dll auf die übliche Weise — zieh sie auf das Fenster oder File ▸ Open Assembly. Wenn eine packages.lock.json im Projektbaum neben der Binärdatei liegt, bemerkt Glass sie und bietet Resolve references from lockfile im Kontextmenü der Assembly (und im Benachrichtigungsstreifen) an. Nimm es an, und der references-Knoten füllt sich neu: Einträge, die kursiv-und-unaufgelöst waren, werden solide, jeder mit der exakten Version aus der Lockdatei beschriftet. Nun zeigt sich der Nutzen überall dort, wo die Oberfläche einen externen Typ berührt:

  • Go to Definition (F12) auf JObject öffnet den echten Typ aus 13.0.3, mit seiner Basiskette und seinen Mitgliedern, statt bei einem externen Stub haltzumachen.
  • Das dekompilierte C# für ReadName zeigt ein sauberes (string?)root["name"], weil sich der Indexer und die explizite Konvertierung gegen den geladenen Typ aufgelöst haben.
  • Find All References und die Aufrufhierarchie können Aufrufen über die Grenze hinweg in die Abhängigkeit hinein folgen, sodass „wo wird dieser Wert eigentlich validiert?” ein paar Klicks statt einer Vermutung ist.

Falls du je wissen musst, ob ein bestimmtes Detail aus der echten Assembly stammt oder daraus, dass Glass die Form allein aus den Tokens ableitet, lass das Mitglied in die IL-Ansicht fallen. Die Tokens dort sind die Grundwahrheit, auf der die Auflösung aufbaut, und sie lesen sich gleich, egal ob die Referenz geladen wurde oder nicht — genau deshalb sind sie das, worauf man zurückgreift.

Wann die Lockdatei sich lohnt

  • Eine ausgelieferte Drittanbieter-DLL prüfen. Du hast die .dll des Anbieters und daneben die packages.lock.json seines Builds. Gegen die Lockdatei aufzulösen gibt dir seinen exakten Abhängigkeitsgraphen, sodass deine Lektüre seines Codes zu den Assemblys passt, die er wirklich gebunden hat — ohne Abweichung durch das, was zufällig in deinem Cache liegt.
  • Eine Bibliothek wiederherstellen, deren Quellcode verloren ging. Wenn du eine dekompilierte Assembly in ein baubares Projekt exportierst, sind genaue Referenzen das, was das Ergebnis tatsächlich kompilieren lässt. Zuerst aus der Lockdatei aufzulösen bedeutet, dass das wiederhergestellte Projekt auf dieselben Paketversionen zeigt wie das Original.
  • Einen versionsspezifischen Fehler reproduzieren. Ein Defekt, der nur mit einem Patch einer Abhängigkeit auftritt, ist unsichtbar, wenn dein Dekompilierer einen anderen Patch gebunden hat. Auf die resolved-Version der Lockdatei zu fixieren macht den Code, den du liest, zu dem Code, der sich fehlerhaft verhielt.

Der rote Faden ist derselbe, der unter jedem Glass-Arbeitsablauf verläuft: Es liest, es führt niemals aus. Referenzen aus einer Lockdatei aufzulösen bleibt reine statische Analyse — Glass liest die Lockdatei, liest die Metadaten des zwischengespeicherten Pakets und rekonstruiert C#. Nichts wird aus dem Netzwerk wiederhergestellt, nichts wird ausgeführt. Du bekommst einfach eine Dekompilierung, die ehrlich über das eine ist, was eine einsame .dll dir aus sich heraus nie sagen kann: gegen welche Abhängigkeit sie wirklich gebaut wurde.

Glass.NET ist kostenlos — keine Lizenz, keine Sitze, keine Anmeldung. Richte es auf deine eigenen Binärdateien, auf Abhängigkeiten, die du prüfen darfst, oder auf Code, an dem du den Compiler lernst, und lass die Lockdatei die Referenzen exakt machen.

Nebula.NET testen

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