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

Kann Obfuskierung eine Verbindungszeichenfolge verbergen? Was Nebula schützt – und was nicht

Eine Verbindungszeichenfolge, ein API-Schlüssel oder ein Signaturgeheimnis, das innerhalb Ihrer .NET-Anwendung ausgeliefert wird, ist prinzipiell wiederherstellbar: Der Prozess muss es verwenden, also muss der Prozess es vorhalten. Dies ist ein ehrlicher Vergleich der drei Orte, an denen sich ein Geheimnis in einer ausgelieferten Assembly versteckt, was die String- und Ressourcenverschlüsselung von Nebula.NET an jedem davon genau ändert, wo die Obergrenze liegt und welche Schichtung ein Geheimnis wirklich aus der Reichweite eines Angreifers hält.

Jedes Schutzwerkzeug bekommt dieselbe Frage, meist als Forderung formuliert: „Ich habe eine Verbindungszeichenfolge in meiner Desktop-App – kannst du dafür sorgen, dass niemand sie lesen kann?” Die ehrliche Antwort ist ein Vergleich, kein Ja. Ein Geheimnis, das innerhalb von Client-seitigem Code ausgeliefert wird, ist prinzipiell wiederherstellbar, denn der Prozess muss es verwenden, was bedeutet, dass der Prozess den Klartext in irgendeinem Moment vorhalten muss. Was Obfuskierung ändert, sind die Kosten der Wiederherstellung – von „Doppelklick auf einen Ressourcen-Viewer” zu „Debugger anhängen, die Entschlüsselung finden, sie reproduzieren” – und ob die Zeichenfolge im Klartext dasteht, damit ein strings.exe-Dump oder ein Web-Crawler sie findet.

Dieser Beitrag ist der vollständige Vergleich. Wo sich eine Verbindungszeichenfolge in einer ausgelieferten Assembly tatsächlich versteckt, was die String- und Ressourcenverschlüsselung von Nebula.NET mit jedem Versteck macht, wo die Obergrenze liegt und warum, und die Schichtung, die das Geheimnis vollständig aus der Binärdatei heraushält, wenn das möglich ist.

Die drei Orte, an denen sich ein Geheimnis versteckt

Eine Verbindungszeichenfolge, ein API-Schlüssel, ein symmetrischer Schlüssel für eine eingebettete Datendatei – sie alle gelangen über einen von drei Wegen in die ausgelieferte Assembly, und jeder dekompiliert sich anders.

Als Literal im Code. Der häufigste und der am stärksten exponierte:

const string Conn = "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;";

Der C#-Compiler gibt das als einzelnes ldstr in den String-Heap aus. Es ist nicht verschlüsselt, nicht kodiert, nicht verborgen – es ist UTF-16-Text in einer wohlbekannten Tabelle:

ldstr      "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;"

Als eingebettete appsettings.json-Ressource. Sie markieren die Datei als EmbeddedResource, damit sie innerhalb der DLL mitreist:

<ItemGroup>
  <EmbeddedResource Include="appsettings.Production.json" />
</ItemGroup>

Nun ist das JSON – Verbindungszeichenfolgen und alles – ein längenpräfigierter Blob in der ManifestResource-Tabelle. Kein Dekompiler nötig; System.Resources liest es, und jeder Ressourcen-Viewer ebenso.

Als über die Konfiguration gebundener Wert. Die Zeichenfolge lebt in appsettings.json auf der Festplatte und wird von IConfiguration in ein Options-POCO gelesen. Dies ist das einzige der drei, das nicht in der Assembly ist – aber es ist eine Klartextdatei direkt neben der Binärdatei, was eine andere Exposition ist, keine geringere.

Beachten Sie die Teilung: Die ersten beiden liefern das Geheimnis innerhalb der Binärdatei aus, wo Obfuskierung wirken kann; das dritte liefert es neben der Binärdatei aus, wo Obfuskierung es überhaupt nicht erreichen kann. Diese Unterscheidung bestimmt den ganzen Vergleich.

DEFAULT EXPOSUREAFTER NEBULARUNTIME CEILINGconst literalin code (ldstr)"...Password=S3cr3t!"plaintext in string heapstringEncryption →decode call, no literalheld decryptedin memory at useembeddedappsettings.jsonJSON blob in manifestany resource viewer reads itresourceEncryption →ciphertext, resolver decryptsdecrypted whenthe config is readon-diskconfig fileplaintext file beside thebinary — outside the DLLobfuscation cannotreach it — move it outread into processmemory on loadRed = readable in one step · Green = raised to reverse-engineering · Grey = not in the assembly

Was ein Dekompiler vor dem Schutz sieht

Öffnen Sie einen ungeschützten Build in Glass.NET (oder einem beliebigen Dekompiler), und der Literal-Fall erfordert überhaupt keine Mühe. Die IL-Ansicht zeigt das ldstr; die String-Heap-Ansicht listet den Wert. Sie müssen nicht einmal die Methode finden – der Metadaten-Browser eines Dekompilers listet jede Zeichenfolge in der Assembly auf, und Server=…;Password=…; steht gleich neben Ihren Fehlermeldungen.

Der Fall der eingebetteten Ressource ist schlimmer, weil er nicht einmal einen Dekompiler erfordert. Klappen Sie den Ressourcen-Knoten der Assembly auf, und die Ressource appsettings.Production.json ist genau dort; ein Klick gibt das JSON aus. Die BCL liefert sogar den Reader mit, sodass ein fünfzeiliges Programm sie wiederherstellt:

var asm = Assembly.LoadFile(path);
using var s = asm.GetManifestResourceStream("MyApp.appsettings.Production.json");
using var r = new StreamReader(s!);
Console.WriteLine(r.ReadToEnd()); // connection strings and all

„Ich habe es in die DLL kompiliert” ist kein Schutz. Es ist ein etwas weniger offensichtlicher Dateiname.

Was Nebula konkret ändert

Nebula.NET wirkt auf die beiden Assembly-internen Fälle. Die String-Verschlüsselung schreibt das Literal um. Das ldstr wird durch einen Aufruf an eine generierte Entschlüsselungsroutine ersetzt, die ein undurchsichtiges Token entgegennimmt und den Klartext am Verwendungspunkt zurückgibt:

ldc.i4     0x3f91a7
call       string <Nebula>.Decode(int32)

Die Verbindungszeichenfolge im Klartext ist aus dem String-Heap verschwunden. Ein Metadaten-Browser listet nun einen kodierten Blob; ein strings-Dump findet nichts; ein Dekompiler zeigt einen Aufruf in geschützten Code statt eines Werts. Sie grenzen es in nebula.config.json ein, sodass die wertvollen Literale abgedeckt werden, ohne einen gemessenen heißen Pfad zu belasten:

{
  "schemaVersion": 1,
  "inputs": [ "bin/Release/net8.0/MyApp.dll" ],
  "outputDirectory": "protected",

  "stringEncryption": {
    "enabled": true,
    "include": [ "MyApp.Data.*", "MyApp.Security.*" ]
  },

  "resourceEncryption": {
    "enabled": true,
    "include": [ "MyApp.appsettings.Production.json" ],
    "exclude": [ "*.g.resources" ]
  },

  "controlFlow": { "enabled": true }
}

Die Ressourcenverschlüsselung kümmert sich um das eingebettete JSON. Der Durchlauf ersetzt die Klartext-Ressourcenbytes zur Buildzeit durch Chiffretext und installiert einen Resolver, sodass GetManifestResourceStream – und damit der Konfigurationsanbieter, der es liest – einen entschlüsselnden Stream für die geschützten Namen erhält. Ihre Aufrufstelle bleibt unverändert:

var config = new ConfigurationBuilder()
    .AddJsonStream(Assembly.GetExecutingAssembly()
        .GetManifestResourceStream("MyApp.appsettings.Production.json")!)
    .Build();

Dies bindet weiterhin, weil der Resolver transparent entschlüsselt. Was sich geändert hat, ist nur, was ein statischer Viewer auf der Festplatte sieht: Chiffretext, keine Verbindungszeichenfolge. Führen Sie es aus mit:

nebula protect --config nebula.config.json --out bin/Protected

Beide Durchläufe tun dasselbe in verschiedenen Teilen der PE: Sie entfernen die triviale Preisgabe – den Wert, den Sie in einem Schritt lesen konnten – und zwingen jede Wiederherstellung durch den obfuskierten Code, wo sie echten Aufwand kostet. Das ist die gesamte, ehrliche Aussage.

Die Obergrenze, und warum sie existiert

Hier ist der Teil, den ein Anbieter klar aussprechen sollte: Verschlüsselung macht ein Client-seitiges Geheimnis nicht unwiederherstellbar. Der Entschlüsselungsschlüssel wird ebenfalls in der Assembly ausgeliefert, weil der Prozess den Wert entschlüsseln muss, um ihn zu verwenden. Nebula leitet diesen Schlüssel über denselben geschützten Code-Pfad ab, der Ihre Methoden absichert – es ist keine Konstante in einem Feld – sodass ihn wiederherzustellen bedeutet, kontrollflussgeglätteten, stringverschlüsselten Code rückzuentwickeln, statt ein Literal zu lesen. Das ist eine große Kostensteigerung. Es ist nicht unendlich.

Die schärfere Grenze ist die Laufzeit. In dem Moment, in dem Ihr Code dies tut:

using var conn = new SqlConnection(decryptedConnString);

existiert die Verbindungszeichenfolge im Klartext als lebender string auf dem verwalteten Heap. Ein Angreifer, der Ihren Prozess ausführen kann – was er auf einem Client-Rechner kann – kann einen Debugger anhängen, an SqlConnection..ctor anhalten und das Argument lesen. Keine Dekompilierung erforderlich. Dasselbe gilt für das entschlüsselte appsettings.json: Sobald der Konfigurationsanbieter es gelesen hat, sind die Werte Objekte im Speicher. Obfuskierung hebt die Hürde gegen statische Inspektion und gegen beiläufige Dumps. Sie kann nicht gegen einen Debugger gewinnen, der an einen Prozess angehängt ist, der im Begriff ist, das Geheimnis zu verwenden, denn in diesem Moment ist das Geheimnis zwangsläufig Klartext.

Das ist keine Nebula-spezifische Schwäche; es ist die Natur Client-seitiger Geheimnisse. Jedes Werkzeug, das etwas anderes behauptet, verkauft die Behauptung, nicht den Schutz.

Die Schichtung, die tatsächlich funktioniert

Wegen dieser Obergrenze ist die eigentliche Strategie eine Hierarchie, und Obfuskierung ist die letzte Stufe, nicht die erste.

Stufe 1 – liefern Sie das Geheimnis nicht aus. Eine Verbindungszeichenfolge zu einem Server, den Sie kontrollieren, ein Drittanbieter-API-Schlüssel, alles, was den Client gegenüber einem Backend authentifiziert: Das sollte überhaupt nicht in der Binärdatei sein. Halten Sie es mit user-secrets in der Entwicklung aus dem Quellcode heraus, liefern Sie es aus einer Umgebungsvariablen oder der verwalteten Identität Ihrer Plattform in der Produktion – oder, am besten, geben Sie dem Client niemals ein langlebiges Anmeldeinformationselement, sondern vermitteln Sie den Zugang, sodass der Server ein kurzlebiges, eng gefasstes Token ausstellt. Ein Geheimnis, das nie im Artefakt ist, hat keine Wiederherstellungskosten, weil es nichts wiederherzustellen gibt. Obfuskierung ist für Stufe 1 irrelevant, und das ist der Punkt: Der stärkste Schutz ist die Abwesenheit.

Stufe 2 – für das Geheimnis, das Sie wirklich einbetten müssen, erhöhen Sie die Kosten. Manche Geheimnisse müssen ausgeliefert werden: der öffentliche Schlüssel, mit dem Ihre App eine Lizenz verifiziert, ein symmetrischer Schlüssel, der eine eingebettete proprietäre Datendatei entschlüsselt, ein gepinntes Zertifikat. Diese können nicht auf einen Server verlagert werden, weil die App offline funktionieren muss oder dem Netzwerk für diese Prüfung nicht vertrauen darf. Für diese ist Nebula genau das richtige Werkzeug. Verschlüsseln Sie das Literal, verschlüsseln Sie die Ressource, glätten Sie den Kontrollfluss um die Ableitung und – für die wertvollste Routine – virtualisieren Sie die Methode, sodass die Schlüsselableitung auf einem interpretierten Befehlssatz statt auf lesbarem IL läuft. Sie machen die Wiederherstellung nicht unmöglich; Sie machen sie teuer genug, dass sie sich im Verhältnis zu dem, was das Geheimnis schützt, nicht lohnt.

Die Entscheidung ist eine kurze Tabelle.

Das GeheimnisKann es die Binärdatei verlassen?Behandlung
DB-Verbindungszeichenfolge, Backend-API-SchlüsselJa – authentifiziert gegenüber Ihrem ServerStufe 1: vermitteln, kurzlebige Tokens ausstellen
Drittanbieter-Schlüssel an Ihr Konto gebundenMeistStufe 1: den Aufruf über Ihr Backend proxyen
Öffentlicher Schlüssel zur LizenzprüfungNein – muss offline verifizierenStufe 2: ausliefern, String-Verschlüsselung + Kontrollfluss
Symmetrischer Schlüssel für eingebettete DatendateiNein – App muss lokal entschlüsselnStufe 2: Ressource verschlüsseln + Ableitung virtualisieren

Der Fehler ist, Stufe 1 zu überspringen und die Obfuskierung zu bitten, deren Arbeit zu erledigen. Obfuskierung macht ein auslieferungspflichtiges Geheimnis teuer zu extrahieren. Sie tut nichts, um die Auslieferung eines Geheimnisses zu rechtfertigen, das nie dort sein musste.

Prüfen Sie, was Sie ausgeliefert haben

Bestätigen Sie nach einem geschützten Build, dass die beiden Assembly-internen Fälle tatsächlich geschlossen sind. Öffnen Sie protected/MyApp.dll in Glass.NET: Der String-Heap sollte Ihre Verbindungszeichenfolge nicht mehr auflisten, und die Ressource appsettings.Production.json sollte als Chiffretext ausgegeben werden, nicht als JSON. Machen Sie es zu einem CI-Gate: ein Skript, das die geschützte Ausgabe öffnet, sicherstellt, dass keine Ressource zu erkennbarem JSON dekodiert und kein Literal mit einem Password=-Muster übereinstimmt, und den Build scheitern lässt, falls eines davon zutrifft. Das fängt den Tag ab, an dem jemand ein neues geheimnistragendes Literal in einen Namespace einfügt, den Ihre include-Liste nicht abdeckt.

Eine geschützte Binärdatei, die immer noch per grep auf Ihr Passwort matcht, bedeutet, dass der Durchlauf sie nicht erreicht hat; eine saubere bedeutet, dass Sie alles getan haben, was Client-seitige Obfuskierung tun kann – und die Wahrheit darüber gesagt haben, wo das endet.

Siehe Nebula.NET für die vollständige Transformations-Pipeline und die nebula.config.json-Referenz, eingebettete Ressourcen verschlüsseln für den Ressourcen-Durchlauf im Detail und Glass.NET zum Prüfen, was ein Dekompiler noch lesen kann.

Nebula.NET testen

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