Die Laufzeitkosten der String-Verschlüsselung in einer heißen Schleife
Verschlüsselte String-Literale werden an der Verwendungsstelle entschlüsselt. In einer engen Schleife summiert sich das. So misst man die Kosten mit BenchmarkDotNet und grenzt die String-Verschlüsselung in nebula.config.json ein.
Die String-Verschlüsselung ist eine der günstigsten und wertvollsten Transformationen, die Nebula.NET anwendet: Sie verwandelt jedes lesbare Literal in Ihrer Assembly — API-Endpoints, Formatstrings, Lizenzmeldungen, die Namen der Dinge — in einen kodierten Blob, der erst zur Laufzeit dekodiert wird. Öffnen Sie die geschützte Binärdatei in einem Decompiler, und die Landkarte, die diese Literale einst zeichneten, ist verschwunden. Für die überwältigende Mehrheit des Codes ist das kostenlos in jeder Hinsicht, die zählt.
Der einzige Ort, an dem es nicht kostenlos ist, ist eine heiße Schleife. Ein verschlüsseltes Literal wird an der Verwendungsstelle entschlüsselt, und „die Verwendungsstelle” kann in einer Methode liegen, die millionenfach läuft. Eine Entschlüsselung, die wenige Nanosekunden kostet, ist einmalig unsichtbar; über eine enge innere Schleife multipliziert wird sie zu etwas Messbarem. Dieser Beitrag ist die Anleitung: wozu „an der Verwendungsstelle entschlüsselt” tatsächlich kompiliert, wie man die Kosten ehrlich mit BenchmarkDotNet misst, wie der Entschlüsselungs-Cache das Bild verändert und wie man die String-Verschlüsselung in nebula.config.json eingrenzt, um die wertvollen Strings zu schützen, ohne die heißen zu belasten.
Wozu „an der Verwendungsstelle entschlüsselt” kompiliert
Vor der Schutzmaßnahme ist ein Literal eine einzige IL-Anweisung. Diese Methode:
public bool IsAdmin(string role) => role == "administrator";
kompiliert das Literal zu einem einzigen ldstr, das die Runtime ohne Arbeit zu einem internierten String auflöst:
ldarg.1
ldstr "administrator"
call bool [System.Runtime]System.String::op_Equality(string, string)
ret
Nach der String-Verschlüsselung ersetzt Nebula das ldstr durch einen Aufruf einer generierten Dekodierungsroutine, die ein opakes Token entgegennimmt und den Klartext zurückgibt. Konzeptionell wird aus dem IL:
ldarg.1
ldc.i4 0x1F3A // token / offset into the encrypted blob
call string Nebula.Runtime.Strings::Get(int32)
call bool [System.Runtime]System.String::op_Equality(string, string)
ret
Das Literal steht nicht mehr als Text in den Metadaten; es lebt in einer verschlüsselten Tabelle, und Strings::Get dekodiert den Eintrag für dieses Token, wenn die Zeile ausgeführt wird. Diese Entschlüsselung ist die gesamten Laufzeitkosten der String-Verschlüsselung — und die ganze Frage, ob Sie es je bemerken werden, ist, wie oft dieser call läuft.
Wo der Compiler Sie bereits gerettet hat
Hier ist das Detail, das die String-Verschlüsselung in der Praxis günstig macht: Die meisten Literale werden nicht bei jeder Verwendung entschlüsselt, weil der C#-Compiler sie hebt, noch bevor Nebula sie sieht. Ein Literal, das im Rumpf einer Methode referenziert wird, wird häufig in ein einmalig initialisiertes statisches Feld gehoben. Wenn das geschieht, läuft die Entschlüsselung beim ersten Zugriff ein einziges Mal, und jede spätere Verwendung liest das Feld.
Die Schleife, vor der Sie sich fürchten, hat also oft nicht die Kosten, die Sie befürchten:
// The literal is effectively hoisted; it is decoded once, not per iteration.
for (int i = 0; i < items.Length; i++)
if (items[i].Kind == "invoice") // "invoice" resolves from a one-time decode
Process(items[i]);
Die Kosten werden in der umgekehrten Form real — wo ein eigenes Literal innerhalb des Schleifenrumpfs auf dem heißen Pfad konstruiert oder ausgewählt wird, besonders wenn es eine String-Formatierung oder -Erstellung speist, die die Schleife ohnehin schon dominiert:
// Hot path: runs per row, millions of times. Each distinct literal is a decode.
foreach (var row in rows)
log.Trace($"row {row.Id} status={row.Status} at {"yyyy-MM-ddTHH:mm:ss"}");
Die ehrliche Antwort auf „welche Form hat mein heißer Pfad?” ist nichts, was Sie aus dem Quellcode ablesen können. Sie messen sie.
Mit BenchmarkDotNet messen
Schließen Sie nicht aus einem Decompiler auf Nanosekunden; benchmarken Sie die echte Methode vor und nach der Schutzmaßnahme. Das Muster besteht darin, die Methode auf beide Arten zu bauen und dieselbe Arbeitslast durch jede zu schicken. Eine minimale Skizze:
[MemoryDiagnoser]
public class HotPathBench
{
private readonly Record[] _rows = Record.Generate(1_000_000);
[Benchmark(Baseline = true)]
public long Plain() => Sum(_rows); // unprotected build
[Benchmark]
public long Protected() => SumProtected(_rows); // same code, string-encrypted
private static long Sum(Record[] rows)
{
long n = 0;
foreach (var r in rows)
if (r.Status == "active") n++; // literal on the hot path
return n;
}
}
Führen Sie es gegen einen von nebula protect erzeugten Build aus und lesen Sie das Delta, nicht die absoluten Zahlen:
nebula protect --config nebula.config.json --out bin/Protected
Ein repräsentatives Ergebnis auf einer Schleife, deren Literal gehoben ist, sieht aus wie Rauschen — die Entschlüsselung geschah einmal, abseits des gemessenen Pfads:
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 2.43 ms | 1.01 | 0 B |
Eine Schleife, die pro Iteration ein eigenes Literal entschlüsselt, erzählt eine andere Geschichte, und das ist genau die Methode, die Sie finden und eingrenzen wollen:
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 9.80 ms | 4.07 | 48,000 B |
Die Ratio-Spalte ist die ganze Entscheidung. Eine Ratio von 1.01 bedeutet: lassen Sie es verschlüsselt — der Schutz ist hier kostenlos. Eine Ratio von 4.07 auf einer Methode, die Ihre Laufzeit dominiert, bedeutet: grenzen Sie sie aus. Sie entscheiden sich nicht zwischen „geschützt” und „schnell” für die ganze Assembly; Sie entscheiden es pro heißem Pfad, mit einer Zahl.
Wie der Cache das Bild verändert
Nebula.NET entschlüsselt nicht blind bei jedem Aufruf. Wo die Referenz eines entschlüsselten Strings stabil ist, cacht die Runtime den Klartext nach der ersten Entschlüsselung und liefert ihn danach aus dem Cache, sodass ein Literal, das zum selben Wert auflöst, seine Kosten amortisiert, egal wie oft die Zeile läuft. Deshalb misst sich der Fall des gehobenen Literals als Rauschen, und deshalb tauchen die meisten verschlüsselten Strings nie in einem Profil auf.
Der Cache hilft genau dort, wo das Literal stabil ist, und hilft überhaupt nicht, wo bei jeder Iteration ein eigener Wert erzeugt wird — ein interpoliertes Format pro Zeile, ein zusammengesetzter Schlüssel, eine aus Teilen gebaute Meldung. Das ist die Form, nach der man jagt: nicht „ein Literal in einer Schleife”, sondern „ein anderer entschlüsselter Wert pro Iteration auf einem Pfad, der die Laufzeit ohnehin schon dominiert”. Alles andere lassen Sie verschlüsselt und vergessen es.
String-Verschlüsselung in nebula.config.json eingrenzen
Sobald ein Benchmark eine heiße Methode benannt hat, schließen Sie diesen Geltungsbereich von der String-Verschlüsselung aus und lassen den Rest der Assembly geschützt. Nebula.NET nimmt include/exclude-Muster unter stringEncryption entgegen, ausgewertet so, dass ein expliziter Ausschluss gewinnt. Grenzen Sie nach Namespace oder Typ ein, wenn der heiße Code beisammenliegt:
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/Acme.Pricing.dll" ],
"outputDirectory": "protected",
"stringEncryption": {
"enabled": true,
"exclude": [
"Acme.Pricing.Engine.Hot.*",
"Acme.Pricing.Serialization.RowFormatter"
]
},
"controlFlow": { "enabled": true }
}
Alles in Acme.Pricing.* behält seine Strings verschlüsselt, außer dem gemessenen heißen Namespace und dem einen Formatter, den der Benchmark markiert hat. Wenn der heiße Pfad eine einzelne Methode statt eines ganzen Namespace ist, markieren Sie sie im Code und schließen Sie sie per Attribut aus — die Regel lebt dann neben der Methode, die sie beschreibt, und übersteht Refactorings:
[Obfuscation(Feature = "stringEncryption", Exclude = true)] // benchmarked: 4.07× per-row decode
public void FormatRows(ReadOnlySpan<Record> rows, TextWriter w) { /* ... */ }
"stringEncryption": {
"enabled": true,
"exclude": [ "hasAttribute:System.Reflection.ObfuscationAttribute" ]
}
Wenn Sie stattdessen die umgekehrte Haltung wollen — nur die wirklich sensiblen Strings verschlüsseln und alles andere als Klartext-Literale lassen — wechseln Sie zu einem include und benennen die wertvollen Geltungsbereiche:
"stringEncryption": {
"enabled": true,
"include": [ "Acme.Pricing.Licensing.*", "Acme.Pricing.Security.*" ]
}
Das ist die richtige Haltung, wenn ein Profil viel stringlastigen heißen Code und nur eine kleine, gut abgegrenzte Menge an Geheimnissen zeigt. Die meisten Projekte machen das Gegenteil — breit verschlüsseln, die ein oder zwei gemessenen heißen Pfade ausschließen — weil die Vorgabe „alles schützen” die sichere ist und die Ausnahmen selten sind.
Eine Faustregel
Trennen Sie wertvolle Strings von heißen Strings, denn es sind fast nie dieselben Strings. Ihre Geheimnisse — Endpoints, Schlüsselmaterial, Meldungen der Lizenzprüfung, die Namen Ihrer proprietären Typen — leben in Setup-Code, Authentifizierungspfaden und Lizenzlogik, die gelegentlich laufen. Ihre heißen Strings — ein pro Zeile verglichener Status, ein pro Anfrage angewandtes Format — leben in Schleifen und tragen kein Geheimnis. Die String-Verschlüsselung verdient ihren Platz bei der ersten Menge und belastet Sie nur bei der zweiten.
Der Arbeitsablauf ist also: Verschlüsseln Sie Strings standardmäßig in der ganzen Assembly, profilen oder benchmarken Sie die zwei oder drei Methoden, die Ihre Laufzeit dominieren, und wenn eine davon in BenchmarkDotNet echte Entschlüsselungskosten zeigt, schließen Sie diesen Geltungsbereich aus und nichts weiter. Sie enden mit jedem Geheimnis verschlüsselt, einem Decompiler, der nichts Nützliches preisgibt, und einem heißen Pfad, der mit Klartext-Literal-Geschwindigkeit läuft — was der gesamte Sinn des Eingrenzens statt des Umschaltens ist. Kombinieren Sie es mit Kontrollfluss-Obfuskation auf den Lizenzmethoden, in denen diese Strings leben, und prüfen Sie das geschützte Ergebnis in Glass.NET, bevor Sie ausliefern.
Siehe Nebula.NET für den vollständigen Satz an Transformationen und die Referenz zu nebula.config.json.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.