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

Was in einer .NET-Aspire-Lösung zu obfuskieren ist

Ein Aspire-AppHost ist Orchestrierung zur Entwicklungszeit, die Sie nie ausliefern; die Assemblys, die in die Produktion gelangen, sind die einzelnen Dienste. Hier ist, warum Umbenennung über die Dienstgrenze hinweg sicher ist, welche Assemblys zu schützen sind und welche wenigen Member Sie dennoch bewahren müssen.

Ein Team führt .NET Aspire ein, richtet einen AppHost ein und erreicht den Punkt des Auslieferns. Die erste Frage ist fast immer die falsche: „Wie obfuskiere ich meine Aspire-Anwendung?” Es gibt keine einzelne Aspire-Anwendung zu obfuskieren. Eine Aspire-Lösung ist eine Menge gewöhnlicher .NET-Dienste plus ein Modell zur Entwicklungszeit, das beschreibt, wie sie zusammenpassen. Zu wissen, welche dieser Assemblys tatsächlich einen Kunden erreichen — und welche nie Ihre Build-Maschine verlassen — entscheidet die gesamte Schutzstrategie, und es ist einfacher, als es aussieht.

Der AppHost ist ein Bauplan, kein Binary, das Sie ausliefern

Öffnen Sie eine frisch erstellte Aspire-Lösung, und Sie erhalten drei Arten von Projekt: den AppHost, eine geteilte ServiceDefaults-Bibliothek und einen oder mehrere Dienste (eine API, ein Web-Frontend, Worker). Es ist verlockend, den AppHost als die Anwendung zu behandeln, weil Sie dort F5 drücken. Das ist er nicht. Der AppHost ist ein Orchestrierungsmodell. Seine ganze Aufgabe ist es, einen Graphen von Ressourcen und ihren Beziehungen zu bauen:

var builder = DistributedApplication.CreateBuilder(args);

var api = builder.AddProject<Projects.ApiService>("apiservice");

builder.AddProject<Projects.Web>("webfrontend")
       .WithReference(api);

builder.Build().Run();

Diese Projects.ApiService- und Projects.Web-Typen sind nichts, was Sie geschrieben haben. Der Quellcode-Generator von Aspire gibt pro referenziertem Projekt einen Metadaten-Typ in die AppHost-Assembly aus, der den Projektpfad trägt, damit der Host ihn starten kann. Der AppHost nutzt sie zur Entwicklungszeit, um Prozesse zu starten, und zur Veröffentlichungszeit, um ein Deployment-Manifest (aspire-manifest.json) auszugeben, das ein Deployment-Werkzeug konsumiert. In keinem dieser Modi reist die AppHost-Assembly als laufender Code in die Produktion, den Ihr Kunde auseinandernehmen könnte. Es ist ein Build-Artefakt.

So schreibt sich die erste Regel von selbst: obfuskieren Sie den AppHost nicht. In einem Ressourcengraphen steckt kein geistiges Eigentum, das ein Angreifer nicht aus der Beobachtung der ausgelieferten Topologie rekonstruieren könnte, die generierten Projects.*-Typen sind Compiler-Installationswerk, und der Manifest-Schritt will eine saubere, vorhersagbare Assembly. Schließen Sie ihn aus und geben Sie das Schutzbudget dort aus, wo Code tatsächlich ausgeliefert wird.

Dienste sprechen über Namen, nicht über Typen

Die Eigenschaft, die Aspire angenehm zu obfuskieren macht, ist, wie Dienste einander finden. Wenn das Web-Frontend die API aufruft, hält es keine Referenz auf einen API-Typ. Es führt einen HTTP-Aufruf an einen logischen Namen aus:

builder.Services.AddHttpClient<ApiClient>(c =>
    c.BaseAddress = new("https+http://apiservice"));

apiservice ist der Name, den Sie der Ressource im AppHost gegeben haben, nichts weiter. Zur Laufzeit löst die Dienstermittlung ihn aus der Konfiguration auf, die der Orchestrator beim Start des Prozesses als Umgebungsvariablen injiziert — ein Schlüssel pro Endpunkt:

Services__apiservice__https__0 = https://10.0.3.14:8443
Services__apiservice__http__0  = http://10.0.3.14:8080

Lesen Sie das genau, denn es ist das ganze Argument. Die Verbindung zwischen zwei Diensten ist eine Konfigurations-Zeichenkette und eine Endpunkt-URL. Es ist kein per Reflexion erhaltener Typname, kein Assembly-Name, keine Methode. Wenn Nebula ApiService.OrderController.PlaceOrder zu a.b.c umbenennt, ruft das Web-Frontend immer noch https+http://apiservice/orders auf und löst apiservice immer noch aus demselben injizierten Schlüssel auf. Die Umbenennung kann die andere Seite der Prozessgrenze nicht erreichen, weil die Prozessgrenze eine HTTP-Grenze ist und nichts Verwaltetes sie überquert.

AppHostnur Dev + Veröffentlichung · nicht ausgeliefertgibt aspire-manifest.json auswebfrontend.dllobfuskiert · eigener Seedapiservice.dllobfuskiert · eigener SeedHTTPhttps+http://apiserviceaufgelöst aus Services__apiservice__https__0Über die HTTP-Grenze hinweg bewahrenJSON-DTOs (Eigenschaftsnamen) · Options-Klassengebundene Config-Schlüssel · vom Framework erreichte Endpunkte
Der AppHost wird nie ausgeliefert; jede Dienst-Assembly wird mit ihrem eigenen Seed obfuskiert. Die einzige Kopplung ist ein logischer Name, aufgelöst aus injizierter Konfiguration, daher ist die Umbenennung bis zur Serialisierungsgrenze sicher.

Das ist eine wirklich bessere Position als die eines In-Process-Monolithen. In einem Monolithen müssen zwei Komponenten, die einen verwalteten Typ teilen, mit einer einzigen koordinierten Abbildung umbenannt werden, sonst driftet die Identität des geteilten Typs auseinander. Die Dienste von Aspire teilen zur Laufzeit nie einen verwalteten Typ — sie teilen einen Wire-Vertrag — sodass Sie apiservice.dll und webfrontend.dll mit unabhängigen Seeds ganz ohne Koordination obfuskieren können.

Die drei Dinge, die trotzdem beißen

Die Unabhängigkeit endet genau bei den Daten, die den Draht überqueren, und bei dem geteilten Projekt, gegen das beide Dienste kompilieren. Drei Oberflächen brauchen Sorgfalt.

Serialisierte DTOs. Der HTTP-Vertrag ist JSON, und System.Text.Json bindet nach Eigenschaftsnamen. Wenn apiservice ein OrderResult zurückgibt und webfrontend es deserialisiert, stimmen beide Seiten auf "orderId", "total" usw. überein — nach Namen. Benennen Sie die Eigenschaft auf einer der beiden Seiten um, und das Feld verschwindet stillschweigend aus der Nutzlast:

// vorher — serialisiert { "orderId": 4012, "total": 59.90 }
public sealed class OrderResult
{
    public int OrderId { get; set; }
    public decimal Total { get; set; }
}
// nach einer blinden Umbenennung — der JSON-Schlüssel ändert sich mit dem Eigenschaftsnamen
.property instance int32 a() { .get instance int32 OrderResult::get_a() }
// System.Text.Json schreibt nun { "a": 4012, ... } und der Aufrufer sieht null

Die Korrektur ist dieselbe Keep-Regel, die jeder serialisierte Web-Typ braucht: schließen Sie die DTO-Eigenschaften von der Umbenennung aus, oder fixieren Sie die Namen mit [JsonPropertyName], damit der Wire-Schlüssel vom Member-Namen entkoppelt ist. Die Keep-Liste von Nebula handhabt das deklarativ — gleichen Sie den DTO-Namensraum ab und bewahren Sie die öffentlichen Eigenschaftsnamen, während die Methodenrümpfe und alles Interne vollständig obfuskiert bleiben.

Konfigurationsbindung. Dienste binden Optionen aus der Konfiguration — einschließlich der Werte für Dienstermittlung und Verbindungszeichenketten, die Aspire injiziert. builder.Services.Configure<SmtpOptions>(config.GetSection("Smtp")) gleicht SmtpOptions.Host nach Eigenschaftsnamen mit dem Schlüssel Smtp:Host ab. Umbenannt, gibt die Bindung einen Standardwert zurück und die Funktion wird zur Laufzeit ohne Ausnahme fehlkonfiguriert. Aus der Konfiguration gebundene Options-Klassen gehören aus demselben Grund wie DTOs in die Keep-Liste.

ServiceDefaults. Dies ist die einzige Assembly, die in verwalteter Form statt über den Draht geteilt wird. Die Program.cs jedes Dienstes ruft sie auf:

builder.AddServiceDefaults();   // OpenTelemetry, Health Checks, Dienstermittlung
// ...
app.MapDefaultEndpoints();      // /health und /alive

AddServiceDefaults ist eine öffentliche Methode in ServiceDefaults.dll, aufgerufen aus jeder Dienst-Assembly. Wenn Sie ServiceDefaults.dll allein obfuskieren und diese öffentliche Methode umbenennen, bricht jeder Aufrufer — die Aufrufstelle in apiservice.dll sucht immer noch nach AddServiceDefaults. Die Antwort ist nicht, den Namen der öffentlichen Methode für immer zu behalten; es ist, die Lösung als Einheit zu obfuskieren, damit der Umbenenner die Methode und alle ihre Aufrufstellen zusammen über die Assemblys hinweg umschreibt. Das ist gewöhnliche Mehrprojekt-Obfuskierung: gruppieren Sie ServiceDefaults mit seinen Konsumenten unter einem Lauf, und das öffentliche Installationswerk kann frei umbenannt werden, weil der Obfuskator beide Enden sieht. Beachten Sie, dass die Endpunkt-Zeichenketten "/health" und "/alive" Literale sind, keine Symbole — die Umbenennung berührt sie nicht und sie funktionieren weiter.

Wohin die schweren Transformationen gehen

Mit bewahrten Grenzen richten Sie den eigentlichen Schutz auf den Code, der Wert trägt, innerhalb jedes Dienstes: Lizenz- und Berechtigungsprüfungen, Preis- und Kontingentlogik, Schlüsselableitung, jeden proprietären Algorithmus. Wenden Sie Kontrollfluss-Abflachung, Zeichenketten-Verschlüsselung und — auf den wenigen Methoden, die die Laufzeitkosten rechtfertigen — Code-Virtualisierung gezielt auf diese Methoden an, genau wie Sie es in einem Build mit einem einzigen Dienst täten. Die Aspire-Form ändert nicht, was Sie schützen; sie ändert nur die Verpackung darum herum. Eine vernünftige Nebula-Konfiguration obfuskiert jedes Dienstprojekt, bewahrt die serialisierte und per Konfiguration gebundene Oberfläche, schließt den AppHost aus und läuft auf der Build-Ausgabe, bevor dotnet publish die Container-Images erzeugt:

{
  "input": "apiservice.dll",
  "keep": [
    "ApiService.Contracts.*",
    "ApiService.Options.*"
  ],
  "controlFlow": "aggressive",
  "stringEncryption": true,
  "virtualize": [ "ApiService.Licensing.*" ]
}

Fazit

Eine Aspire-Lösung ist keine Anwendung mit einer besonderen Schutzgeschichte; es sind mehrere gewöhnliche Dienste, deren Kopplung zufällig zeichenketten-basiert und außerhalb des Prozesses ist, orchestriert von einem AppHost, den Sie nie ausliefern. Das macht die Strategie sauber: lassen Sie den AppHost aus, obfuskieren Sie jeden Dienst mit seinem eigenen Seed, bewahren Sie die JSON- und Konfigurationsoberflächen, die die Grenze überqueren, und obfuskieren Sie ServiceDefaults zusammen mit den Diensten, die es aufrufen. Richten Sie dann die schweren Transformationen auf die Durchsetzungs- und Geschäftslogik innerhalb jedes Prozesses — wo sie von Anfang an hingehörte. Für die vollständige Referenz der Keep-Regeln siehe die Nebula-Konfigurationsdokumentation, und überprüfen Sie das Ergebnis mit Glass.NET.

Nebula.NET testen

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