Orleans-Grains obfuskieren, ohne das Cluster-Routing zu zerstören
Orleans routet jeden Grain-Aufruf über Zeichenketten aus dem Cluster-Manifest: einen GrainInterfaceType und einen GrainType, standardmäßig aus den Namen deiner .NET-Typen abgeleitet. Benenne einen Grain um, und die Identität verschiebt sich, verwaist den persistierten Zustand und zerstört Silo-übergreifende Aufrufe. So entkoppelst du die Identität mit [Alias]/[GrainType] und obfuskierst trotzdem aggressiv.
Eine Orleans-Anwendung ist ein starker Obfuskierungskandidat und leicht zu zerbrechen. Die Grains sind das Produkt — die zustandsbehafteten Aktoren, die deine Preis-, Abrechnungs-, Matching- oder Betrugserkennungslogik enthalten und headless auf einem Server laufen, den du vielleicht nicht kontrollierst — und nahezu der gesamte Code lässt sich frei umbenennen, in Zeichenketten verschlüsseln und virtualisieren. Doch Orleans hat eine Naht, in die ein naiver Durchlauf geradewegs hineinläuft, und der Fehlermodus ist die leise Sorte: Der Cluster startet, ein Client verbindet sich, ein Aufruf wird verteilt, und der Grain, der ihn gestern bearbeitet hat, ist plötzlich nicht registriert, oder sein persistierter Zustand ist verschwunden. Nichts in deinem eigenen Code hat eine Ausnahme geworfen; Orleans hat einfach nicht gefunden, was du umbenannt hast.
Die Ursache ist spezifisch dafür, wie Orleans entscheidet, was ein Grain ist, und sobald du sie siehst, besteht die Lösung aus einer Handvoll Attribute. Dieser Artikel handelt von diesem Mechanismus — wie Orleans die Identität eines Grains aus seinem Typ ableitet, wohin diese Identitäten reisen und wie du das wertvolle Innere mit Nebula.NET schützt, während die Identitäten genau dort bleiben, wo der Cluster sie erwartet.
Kurzfassung
- Orleans routet über Zeichenketten aus dem Cluster-Manifest, nicht über die .NET-Typidentität: einen
GrainInterfaceType(welches Interface) und einenGrainType(welche Grain-Klasse), beide standardmäßig aus den Namen deiner Typen abgeleitet. - Eine
GrainIdbeginnt mit demGrainType, indexiert also den persistierten Zustand und die Reminders. Ändere denGrainType, und dieser Zustand verwaist. - Die Serialisierung ist numerisch — der moderne Serialisierer kodiert Felder über ihr
[Id(n)]-Tag, sodass Felder umzubenennen sicher ist. Nur die Typidentität (ihr[Alias]oder vollständiger Name) ist namensabhängig. - Die robuste Lösung besteht darin, die Identität vom Symbol zu entkoppeln: Zurre
[GrainType],[GrainInterfaceType]und[Alias]auf feste Zeichenketten fest, und benenne dann die Typen frei um. - Alles hinter dem Grain — Services, Hilfsklassen, Algorithmen — wird umbenannt, verschlüsselt und virtualisiert, ohne dass etwas zu behalten wäre.
Warum eine Orleans-Anwendung überhaupt obfuskieren
Die Grain-Klassen sind dort, wo dein geistiges Eigentum lebt: die Methode, die eine Transaktion bewertet, die Zustandsmaschine, die ein Geschäft abrechnet, der Aktor, der einen Preis neu berechnet, wenn sich der Markt bewegt. Dieser Code wird als DLL auf einen Silo-Host ausgeliefert — häufig einen, den dein Kunde betreibt — und jeder mit Dateizugriff kann ihn in einem Decompiler öffnen und als sauberes C# zurücklesen. Die Grain-Schicht ist auch dort, wo sich sensible Konstanten ballen: URLs interner Endpunkte, Partner-Zugangsdaten, Signaturmaterial, Anbieternamen. Die Kosten dafür zu erhöhen, deine eigene ausgelieferte Logik aus diesem Binary zurückzulesen, ist genau der legitime Fall für Obfuskierung.
Wie Orleans die Identität eines Grains aufbaut
Hier ein gewöhnliches Grain-Interface, seine Implementierung und ein serialisierbarer Zustandstyp, jeweils auf die moderne Orleans-Art annotiert:
namespace Contoso.Trading.Abstractions;
public interface IOrderGrain : IGrainWithStringKey
{
Task<decimal> Settle(decimal amount);
}
namespace Contoso.Trading.Grains;
public sealed class OrderGrain : Grain, IOrderGrain
{
private readonly IPersistentState<OrderState> _state;
public OrderGrain([PersistentState("order")] IPersistentState<OrderState> state)
=> _state = state;
public async Task<decimal> Settle(decimal amount)
{
// proprietär — der Grund, warum es diesen Grain gibt
var net = _state.State.ApplySettlement(amount);
await _state.WriteStateAsync();
return net;
}
}
[GenerateSerializer]
public sealed class OrderState
{
[Id(0)] public decimal Balance { get; set; }
[Id(1)] public int Version { get; set; }
public decimal ApplySettlement(decimal amount) { /* ... */ return Balance; }
}
Ein Aufrufer löst den Grain über das Interface auf und ruft ihn auf:
var grain = client.GetGrain<IOrderGrain>("order-7b1e");
var net = await grain.Settle(149.95m);
Nichts in diesem Aufruf nennt ein Silo, eine Adresse oder einen Routing-Schlüssel. Orleans leitet alles aus der als Zeichenketten ausgedrückten Typidentität ab. Genau genommen zwei Zeichenketten, aus deinen Typen berechnet und in das Cluster-Manifest veröffentlicht, das alle Silos und Clients teilen:
- Ein
GrainInterfaceTypefürIOrderGrain— standardmäßig aus dem Interface-Namen abgeleitet ("ordergrain"plus Namespace-Disambiguierung). Er sagt dem Cluster, auf welchen Vertrag ein Aufruf zielt, und er ist der Weg, wie die generierte Grain-Referenz eines Clients mit einer Implementierung irgendwo im Cluster abgeglichen wird. - Ein
GrainTypefürOrderGrain— standardmäßig aus dem Klassennamen abgeleitet ("ordergrain"). Er nennt, welche Grain-Klasse aktiviert werden soll, um den Aufruf zu bearbeiten, und er steuert die Platzierung.
Der Aufruf selbst wird zu einer Nachricht, die den GrainInterfaceType, einen Methodenbezeichner und eine Ziel-GrainId trägt. Und die GrainId ist die stille: Sie ist GrainType + / + dein Schlüssel —
ordergrain/order-7b1e
— die GrainType-Zeichenkette ist also buchstäblich das Präfix der Identität, unter der Orleans die Aktivierung platziert, [PersistentState] speichert und Reminders registriert. Der Speicheranbieter schreibt OrderState unter einem Schlüssel, der aus dieser GrainId aufgebaut ist. Ändere den GrainType, und jede zuvor geschriebene Zeile zeigt auf einen Grain, den der Cluster nicht mehr kennt.
Was nicht namensabhängig ist: die Serialisierung
In OrderState versteckt sich eine Erleichterung. Der moderne Orleans-Serialisierer ist numerisch: Der Codegenerator gibt einen Serialisierer aus, der Feld 0, Feld 1 usw. liest und schreibt, indexiert über das [Id(n)]-Tag — niemals über den Feldnamen. Nach der Obfuskierung werden das Feldsymbol Balance und der generierte Serialisierer, der es referenziert, gemeinsam innerhalb desselben Assemblys umbenannt, und die Drahtbytes bleiben nummeriert. Die Eigenschaften eines [GenerateSerializer]-Typs umzubenennen ist also völlig sicher, solange die [Id(n)]-Tags bleiben. Der einzige namensabhängige Teil ist die Typreferenz, die der Serialisierer schreibt, damit der Empfänger weiß, was er konstruieren soll — und diese verwendet den [Alias] des Typs oder, in dessen Abwesenheit, seinen vollständigen Namen.
Die robuste Lösung: die Identität vom Symbol entkoppeln
Der naive Instinkt ist, jeden Grain- und serialisierbaren Typ in die Keep-List zu setzen. Das funktioniert, lässt aber die wertvollsten Klassen deines Assemblys lesbar. Der bessere Zug ist, die Identität von Orleans unabhängig vom .NET-Typnamen zu machen, sodass das Symbol frei zerstört werden kann, während das Manifest weiterhin eine feste Zeichenkette ankündigt. Drei Attribute erledigen das:
namespace Contoso.Trading.Abstractions;
[GrainInterfaceType("order")] // zurrt die Interface-Identität fest
public interface IOrderGrain : IGrainWithStringKey
{
[Alias("settle")] // zurrt die Methoden-Identität fest
Task<decimal> Settle(decimal amount);
}
[GrainType("order")] // zurrt die Grain-Identität + GrainId-Präfix fest
public sealed class OrderGrain : Grain, IOrderGrain { /* ... */ }
[GenerateSerializer, Alias("order-state")] // zurrt die serialisierte Typidentität fest
public sealed class OrderState
{
[Id(0)] public decimal Balance { get; set; }
[Id(1)] public int Version { get; set; }
}
Damit angekündigt der Cluster "order", gleicht Aufrufe auf "order" ab, baut GrainIds beginnend mit "order" und schreibt Zustand unter "order" — alles unabhängig davon, wie die Klassen heißen. Nebula.NET ist jetzt frei, OrderGrain in a, IOrderGrain in b, Settle in c und OrderState in d umzubenennen, und nichts auf dem Draht oder im Speicher bewegt sich.
Migrationshinweis: Zurre jede Identität zuerst auf den aktuellen Standardwert fest — die Zeichenkette, die der nicht obfuskierte Build bereits angekündigt hat — damit bestehende
GrainIds, Reminders und persistierter Zustand unverändert auflösen. Erst nachdem du bestätigt hast, dass sich nichts bewegt hat, solltest du obfuskieren. Auf eine neue Zeichenkette festzuzurren ist eine Datenmigration, kein Obfuskierungsschritt.
Die Keep-List (wenn du keine Attribute hinzufügen kannst)
Wenn du ein Grain-Assembly obfuskierst, dessen Quellcode dir nicht gehört, oder wenn du die Typen schlicht nicht anfassen kannst, falle darauf zurück, die Identitäten per Namen zu behalten. Modelliere die Grain-Interfaces unter einem einzigen Namespace, und nebula.config.json lautet so:
{
"schemaVersion": 1,
"inputs": [
"publish/Contoso.Trading.Grains.dll",
"publish/Contoso.Trading.Abstractions.dll"
],
"outputDirectory": "protected",
"preservePublicApi": false,
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "Contoso.Trading.Abstractions.*", "action": "keep", "scope": "type-and-members" },
{ "pattern": "*State", "action": "keep", "scope": "type" },
{ "pattern": "Contoso.Trading.*", "action": "rename" }
]
}
}
Die erste Regel zurrt jedes Grain-Interface und seine Methoden fest (der Methodenname speist die Methoden-Identität). Die zweite behält die serialisierbaren Zustandstypen per Namen, damit ihre Standard-Typreferenz überlebt — ein gröberer Ersatz für [Alias]. Alles andere — Grain-Klassen, Services, Hilfsklassen — wird umbenannt. Zeichenkettenverschlüsselung und Kontrollfluss-Obfuskierung gelten überall, auch für die behaltenen Typen, weil keine von beiden Namen berührt. Das schützt weniger als der Attribut-Ansatz, weil die Namen der Grain-Klassen durchsickern; bevorzuge die Attribute, wann immer du den Code bearbeiten kannst.
Das Audit: was sich bewegt, was nicht
Geh jede Identität durch, die das Assembly verlässt, und der Plan schreibt sich von selbst.
- Grain-Interface-Typen und ihre Methoden — bauen den
GrainInterfaceTypeund die Methoden-Identitäten, die ein Client und jedes Silo abgleichen. Mit[GrainInterfaceType]+[Alias]festzurren oder per Namen behalten. - Grain-Klassen — bauen den
GrainType, der jedeGrainIdpräfixiert und persistierten Zustand und Reminders indexiert. Mit[GrainType]festzurren oder per Namen behalten. [GenerateSerializer]-Typen — auf dem Draht per Alias oder vollständigem Namen identifiziert; Felder per[Id(n)], nicht per Namen. Den Typ mit[Alias]festzurren und die[Id]-Tags behalten; die Felder werden frei umbenannt.- Grain-Klassen-Innenräume — der
Settle-Rumpf, die privaten Hilfsklassen, die Services, die er aufruft. Innerhalb des Prozesses über DI und Typidentität aufgelöst; nichts auf dem Draht nennt sie. Umbenennen, verschlüsseln, virtualisieren. - Anbieter- und Speichernamen —
"order"in[PersistentState("order")], Stream-Namespaces, String-Literale. Daten, die du zur Laufzeit reproduzierst; Zeichenkettenverschlüsselung lässt den Laufzeitwert unangetastet. Keine Aktion nötig.
Eine einzige Oberfläche zum Festzurren also — die Identitäten von Grain und Interface — und das gesamte Innere ist Freiwild.
Das Innere schützen
Eine Identität festzuzurren bedeutet nicht, irgendetwas lesbar zu lassen. Die Manifest-Zeichenketten bleiben stabil, während alles hinter dem Grain undurchsichtig wird. Zeichenkettenverschlüsselung verbirgt die internen URLs, Zugangsdaten und Anbieternamen, die die Grain-Schicht ansammelt. Die stärksten Transformationen — Code-Virtualisierung und Ganzmethoden-Verschlüsselung, beides Pro-Features in Nebula.NET — gehen auf die Kronjuwelen: die Abrechnungs-, Bewertungs- oder Preismethoden, angewendet auf diese Handvoll Methoden statt auf das gesamte Assembly:
[GrainType("order")]
public sealed class OrderGrain : Grain, IOrderGrain
{
[Obfuscation(Feature = "virtualization")] // Pro — der Algorithmus, nicht die Verrohrung
public async Task<decimal> Settle(decimal amount) { /* ... */ return 0m; }
}
Umbenennung und Kontrollfluss-Obfuskierung laufen breit darunter und verwandeln den Rest der Grain-Innenräume in bedeutungslose Symbole und verworrene Verzweigungen, während die Identität, nach der der Cluster routet, genau dort bleibt, wo sie war.
Den Schutz in den Build einbinden
Schütze die veröffentlichte Ausgabe, und zwar nur auf dem Build-Server, damit das lokale Debugging schnell und lesbar bleibt:
dotnet publish Contoso.Trading.Silo -c Release -o publish
nebula protect --config nebula.config.json
<Target Name="NebulaProtect" AfterTargets="Publish"
Condition="'$(CI)' == 'true'">
<Exec Command="nebula protect --config nebula.config.json" />
</Target>
Liefere den Ordner protected/ aus, nicht den rohen Publish-Ordner. nebula protect gibt bei Fehlschlag einen Exit-Code ungleich null zurück, sodass ein kaputter Schutzschritt den Build zum Scheitern bringt, statt ein Silo auszuliefern, das einen Grain umbenannt hat, nach dem der Rest des Clusters noch routet.
Überprüfen, dass es wirklich funktioniert
Unit-Tests fangen dies nicht ab: Ein TestCluster, der Grains in einem einzigen Prozess aus demselben Binary baut, sieht konsistente Identitäten und besteht sogar dann, wenn sich die Identität über ein echtes, heterogenes Deployment verschieben würde. Zwei Prüfungen fangen es ab. Erstens: Führe es gegen einen Multi-Silo-Cluster aus, der aus den geschützten DLLs gebaut wurde, idealerweise mit einem Silo noch auf dem vorherigen Build, um ein rollierendes Upgrade nachzuahmen, und bestätige, dass ein Client-Aufruf platziert wird und ein Grain aktiviert. Ein Aufruf, der keinen registrierten Grain-Typ findet, oder ein Grain, dessen zuvor persistierter Zustand leer zurückkommt, ist die exakte Signatur einer verschobenen Identität — vergleiche den GrainType/GrainInterfaceType, den das Manifest ankündigt, mit dem, was das andere Silo erwartet.
Zweitens: Öffne das ausgelieferte Assembly in einem Decompiler und lies es so, wie es ein Angreifer tun wird. Glass.NET ist der kostenlose, rein statische Begleiter für diesen Durchgang: Lade die geschützte DLL, bestätige, dass die Zeichenketten [GrainType("order")], [GrainInterfaceType("order")] und [Alias] noch vorhanden sind — das müssen sie sein, um mit dem Manifest übereinzustimmen — und bestätige dann, dass im umbenannten OrderGrain und in den Services, die er aufruft, nichts mehr zu lesen ist.
Das Fazit
Orleans identifiziert einen Grain über Zeichenketten — einen GrainInterfaceType und einen GrainType, standardmäßig aus den Namen deiner .NET-Typen abgeleitet, im Cluster-Manifest veröffentlicht und über Silos und Clients hinweg abgeglichen. Der GrainType präfixiert auch jede GrainId, indexiert also persistierten Zustand und Reminders. Benenne einen Grain um, und die Identität verschiebt sich auf einem frisch kompilierten Silo: Der Aufruf kann nicht platziert werden und der alte Zustand verwaist, ohne dass irgendetwas in deinem Code eine Ausnahme wirft. Die Serialisierung ist glücklicherweise numerisch — [Id(n)]-Tags, keine Feldnamen — sodass Felder umzubenennen sicher ist. Zurre die Identitäten mit [GrainType], [GrainInterfaceType] und [Alias] auf die Werte fest, die der nicht obfuskierte Build bereits angekündigt hat, und das Symbol ist frei, zerstört zu werden: Übergib das gesamte Grain-Innere an Nebula.NET zum Umbenennen, Zeichenketten-Verschlüsseln und Virtualisieren, stelle dann einen geschützten Multi-Silo-Cluster auf, beobachte, wie der richtige Grain aktiviert, und lies die ausgelieferte DLL, um zu bestätigen, dass die Logik dahinter verschwunden ist.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.