Le coût d'exécution du chiffrement de chaînes dans une boucle chaude
Les littéraux de chaîne chiffrés sont déchiffrés au point d'utilisation. Dans une boucle serrée, cela s'additionne. Voici comment mesurer le coût avec BenchmarkDotNet et cadrer le chiffrement de chaînes dans nebula.config.json.
Le chiffrement de chaînes est l”une des transformations les moins coûteuses et les plus utiles qu”applique Nebula.NET : il transforme chaque littéral lisible de votre assembly — endpoints d”API, chaînes de format, messages de licence, les noms des choses — en un blob encodé qui n”est décodé qu”à l”exécution. Ouvrez le binaire protégé dans un décompilateur et la carte que dessinaient autrefois ces littéraux a disparu. Pour l”écrasante majorité du code, c”est gratuit dans tous les sens qui comptent.
Le seul endroit où ce n”est pas gratuit est une boucle chaude. Un littéral chiffré est déchiffré au point d”utilisation, et « le point d”utilisation » peut se trouver dans une méthode exécutée des millions de fois. Un déchiffrement qui coûte quelques nanosecondes est invisible une fois ; multiplié sur une boucle interne serrée, il devient quelque chose de mesurable. Cet article est le mode d”emploi : vers quoi « déchiffré à l”utilisation » compile réellement, comment mesurer le coût honnêtement avec BenchmarkDotNet, comment le cache de déchiffrement change la donne et comment cadrer le chiffrement de chaînes dans nebula.config.json pour protéger les chaînes précieuses sans pénaliser les chaudes.
Vers quoi compile « déchiffré à l”utilisation »
Avant la protection, un littéral est une seule instruction IL. Cette méthode :
public bool IsAdmin(string role) => role == "administrator";
compile le littéral en un unique ldstr, que le runtime résout en une chaîne internée sans aucun travail :
ldarg.1
ldstr "administrator"
call bool [System.Runtime]System.String::op_Equality(string, string)
ret
Après le chiffrement de chaînes, Nebula remplace le ldstr par un appel à une routine de décodage générée qui prend un jeton opaque et renvoie le texte en clair. Conceptuellement, l”IL devient :
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
Le littéral n”est plus dans les métadonnées sous forme de texte ; il réside dans une table chiffrée, et Strings::Get décode l”entrée de ce jeton lorsque la ligne s”exécute. Ce déchiffrement est tout le coût d”exécution du chiffrement de chaînes — et toute la question de savoir si vous le remarquerez un jour est à quelle fréquence ce call s”exécute.
Là où le compilateur vous a déjà sauvé
Voici le détail qui rend le chiffrement de chaînes peu coûteux en pratique : la plupart des littéraux ne sont pas déchiffrés à chaque utilisation, car le compilateur C# les hisse avant même que Nebula les voie. Un littéral référencé dans le corps d”une méthode est fréquemment élevé en un champ statique initialisé une seule fois. Dans ce cas, le déchiffrement s”exécute une seule fois au premier accès et chaque utilisation suivante lit le champ.
Ainsi, la boucle que vous craignez n”a souvent pas le coût que vous redoutez :
// 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]);
Le coût devient réel dans la forme inverse — là où un littéral distinct est construit ou sélectionné à l”intérieur du corps de la boucle sur le chemin chaud, surtout quand il alimente un formatage ou une construction de chaînes qui domine déjà la boucle :
// 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"}");
La réponse honnête à « quelle est la forme de mon chemin chaud ? » n”est pas quelque chose que vous pouvez lire dans le code source. Vous la mesurez.
La mesurer avec BenchmarkDotNet
Ne raisonnez pas sur des nanosecondes à partir d”un décompilateur ; faites un benchmark de la vraie méthode avant et après la protection. Le principe est de construire la méthode des deux façons et de faire passer la même charge de travail dans chacune. Une esquisse minimale :
[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;
}
}
Exécutez-le contre une compilation produite par nebula protect et lisez le delta, pas les chiffres absolus :
nebula protect --config nebula.config.json --out bin/Protected
Un résultat représentatif sur une boucle dont le littéral est hissé ressemble à du bruit — le déchiffrement a eu lieu une fois, hors du chemin mesuré :
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 2.43 ms | 1.01 | 0 B |
Une boucle qui déchiffre un littéral distinct par itération raconte une autre histoire, et c”est exactement la méthode que vous voulez trouver et cadrer :
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 9.80 ms | 4.07 | 48,000 B |
La colonne ratio est toute la décision. Un ratio de 1.01 signifie laissez-le chiffré — ici la protection est gratuite. Un ratio de 4.07 sur une méthode qui domine votre temps d”exécution signifie cadrez-la en dehors. Vous ne choisissez pas entre « protégé » et « rapide » pour tout l”assembly ; vous le choisissez par chemin chaud, avec un chiffre.
Comment le cache change la donne
Nebula.NET ne déchiffre pas aveuglément à chaque appel. Là où la référence d”une chaîne déchiffrée est stable, le runtime met en cache le texte en clair après le premier déchiffrement et le sert ensuite depuis le cache, de sorte qu”un littéral qui résout à la même valeur amortit son coût quelle que soit la fréquence d”exécution de la ligne. C”est pourquoi le cas du littéral hissé se mesure comme du bruit et pourquoi la plupart des chaînes chiffrées n”apparaissent jamais dans un profilage.
Le cache aide exactement là où le littéral est stable et n”aide en rien là où une valeur distincte est produite à chaque itération — un format interpolé par ligne, une clé composée, un message construit à partir de morceaux. Voilà la forme à traquer : non pas « un littéral dans une boucle », mais « une valeur déchiffrée différente par itération sur un chemin qui domine déjà le temps d”exécution ». Tout le reste, laissez-le chiffré et oubliez-le.
Cadrer le chiffrement de chaînes dans nebula.config.json
Une fois qu”un benchmark a désigné une méthode chaude, excluez cette portée du chiffrement de chaînes et laissez le reste de l”assembly protégé. Nebula.NET accepte des motifs include/exclude sous stringEncryption, évalués de sorte qu”une exclusion explicite l”emporte. Cadrez par espace de noms ou par type lorsque le code chaud est regroupé :
{
"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 }
}
Tout dans Acme.Pricing.* garde ses chaînes chiffrées sauf l”espace de noms chaud mesuré et l”unique formateur que le benchmark a signalé. Lorsque le chemin chaud est une seule méthode plutôt qu”un espace de noms entier, marquez-la dans le code et excluez-la par attribut — la règle vit alors à côté de la méthode qu”elle décrit et survit aux refactorisations :
[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" ]
}
Si au contraire vous voulez la posture inverse — chiffrer uniquement les chaînes réellement sensibles et laisser tout le reste en littéraux en clair — passez à un include et nommez les portées précieuses :
"stringEncryption": {
"enabled": true,
"include": [ "Acme.Pricing.Licensing.*", "Acme.Pricing.Security.*" ]
}
C”est la bonne posture quand un profilage révèle beaucoup de code chaud riche en chaînes et seulement un ensemble réduit et bien contenu de secrets. La plupart des projets font l”inverse — chiffrer largement, exclure le ou les deux chemins chauds mesurés — car la valeur par défaut « tout protéger » est la plus sûre et les exclusions sont rares.
Une règle empirique
Séparez les chaînes précieuses des chaînes chaudes, car ce ne sont presque jamais les mêmes chaînes. Vos secrets — endpoints, matériel de clés, messages de vérification de licence, les noms de vos types propriétaires — vivent dans du code de configuration, des chemins d”authentification et de la logique de licence qui s”exécutent occasionnellement. Vos chaînes chaudes — un statut comparé par ligne, un format appliqué par requête — vivent dans des boucles et ne portent aucun secret. Le chiffrement de chaînes mérite sa place sur le premier ensemble et ne vous pénalise que sur le second.
Le flux de travail est donc : chiffrez les chaînes dans tout l”assembly par défaut, profilez ou mesurez les deux ou trois méthodes qui dominent votre temps d”exécution et, si l”une d”elles montre un coût de déchiffrement réel dans BenchmarkDotNet, excluez cette portée et rien de plus. Vous obtenez chaque secret chiffré, un décompilateur qui ne révèle rien d”utile et un chemin chaud qui s”exécute à la vitesse d”un littéral en clair — ce qui est tout l”objectif du cadrage plutôt que de la bascule. Associez-le à l”obfuscation de flux de contrôle sur les méthodes de licence où vivent ces chaînes, et vérifiez le résultat protégé dans Glass.NET avant de publier.
Consultez Nebula.NET pour l”ensemble complet des transformations et la référence de nebula.config.json.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.