El coste en ejecución del cifrado de cadenas en un bucle caliente
Los literales de cadena cifrados se descifran en el punto de uso. En un bucle ajustado eso se acumula. Aquí tienes cómo medir el coste con BenchmarkDotNet y acotar el cifrado de cadenas en nebula.config.json.
El cifrado de cadenas es una de las transformaciones más baratas y de mayor valor que aplica Nebula.NET: convierte cada literal legible de tu ensamblado — endpoints de API, cadenas de formato, mensajes de licencia, los nombres de las cosas — en un blob codificado que solo se decodifica en tiempo de ejecución. Abre el binario protegido en un descompilador y el mapa que antes dibujaban esos literales ha desaparecido. Para la inmensa mayoría del código, es gratis en todos los sentidos que importan.
El único sitio donde no es gratis es un bucle caliente. Un literal cifrado se descifra en el punto de uso, y «el punto de uso» puede estar dentro de un método que se ejecuta millones de veces. Un descifrado que cuesta unos pocos nanosegundos es invisible una vez; multiplicado a lo largo de un bucle interno ajustado se convierte en algo que puedes medir. Esta entrada es el cómo-hacerlo: a qué compila realmente «descifrado en el uso», cómo medir el coste con honestidad usando BenchmarkDotNet, cómo cambia el panorama la caché de descifrado y cómo acotar el cifrado de cadenas en nebula.config.json para proteger las cadenas valiosas sin penalizar las calientes.
A qué compila «descifrado en el uso»
Antes de la protección, un literal es una sola instrucción IL. Este método:
public bool IsAdmin(string role) => role == "administrator";
compila el literal a un único ldstr, que el runtime resuelve a una cadena internada con cero trabajo:
ldarg.1
ldstr "administrator"
call bool [System.Runtime]System.String::op_Equality(string, string)
ret
Tras el cifrado de cadenas, Nebula sustituye el ldstr por una llamada a una rutina de decodificación generada que toma un token opaco y devuelve el texto plano. Conceptualmente, el IL queda así:
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
El literal ya no está en los metadatos como texto; vive en una tabla cifrada, y Strings::Get decodifica la entrada de ese token cuando la línea se ejecuta. Ese descifrado es todo el coste en tiempo de ejecución del cifrado de cadenas — y toda la cuestión de si llegarás a notarlo es con qué frecuencia se ejecuta ese call.
Dónde ya te salvó el compilador
Aquí está el detalle que hace que el cifrado de cadenas sea barato en la práctica: la mayoría de los literales no se descifran en cada uso, porque el compilador de C# los iza antes de que Nebula los vea siquiera. Un literal referenciado en el cuerpo de un método se eleva con frecuencia a un campo estático inicializado una sola vez. Cuando eso ocurre, el descifrado se ejecuta una única vez en el primer acceso y cada uso posterior lee el campo.
Así que el bucle al que temes a menudo no tiene el coste que temes:
// 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]);
El coste se vuelve real en la forma contraria — donde un literal distinto se construye o se selecciona dentro del cuerpo del bucle en la ruta caliente, sobre todo cuando alimenta un formateo o una construcción de cadenas que ya domina el bucle:
// 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 respuesta honesta a «¿cuál es la forma de mi ruta caliente?» no es algo que puedas leer en el código fuente. Lo mides.
Medirlo con BenchmarkDotNet
No razones sobre nanosegundos a partir de un descompilador; haz un benchmark del método real antes y después de la protección. El patrón es construir el método de ambas formas y pasar la misma carga de trabajo por cada una. Un esbozo mínimo:
[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;
}
}
Ejecútalo contra una compilación producida por nebula protect y lee el delta, no los números absolutos:
nebula protect --config nebula.config.json --out bin/Protected
Un resultado representativo en un bucle cuyo literal está izado parece ruido — el descifrado ocurrió una vez, fuera de la ruta medida:
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 2.43 ms | 1.01 | 0 B |
Un bucle que descifra un literal distinto por iteración cuenta otra historia, y ese es exactamente el método que quieres encontrar y acotar:
| Method | Mean | Ratio | Allocated |
|---------- |----------:|------:|----------:|
| Plain | 2.41 ms | 1.00 | 0 B |
| Protected | 9.80 ms | 4.07 | 48,000 B |
La columna de ratio es toda la decisión. Un ratio de 1.01 significa déjalo cifrado — aquí la protección es gratis. Un ratio de 4.07 en un método que domina tu tiempo de ejecución significa acótalo fuera. No estás eligiendo entre «protegido» y «rápido» para todo el ensamblado; lo eliges por ruta caliente, con un número.
Cómo cambia el panorama la caché
Nebula.NET no descifra a ciegas en cada llamada. Donde la referencia de una cadena descifrada es estable, el runtime almacena en caché el texto plano tras el primer descifrado y lo sirve desde la caché a partir de ahí, de modo que un literal que resuelve al mismo valor amortiza su coste por muy a menudo que se ejecute la línea. Por eso el caso del literal izado se mide como ruido y por eso la mayoría de las cadenas cifradas nunca aparecen en un perfilado.
La caché ayuda exactamente donde el literal es estable y no ayuda nada donde se produce un valor distinto en cada iteración — un formato interpolado por fila, una clave compuesta, un mensaje construido a partir de partes. Esa es la forma que hay que buscar: no «un literal en un bucle», sino «un valor descifrado distinto por iteración en una ruta que ya domina el tiempo de ejecución». Todo lo demás, déjalo cifrado y olvídate.
Acotar el cifrado de cadenas en nebula.config.json
Una vez que un benchmark ha señalado un método caliente, excluye ese ámbito del cifrado de cadenas y deja protegido el resto del ensamblado. Nebula.NET toma patrones include/exclude bajo stringEncryption, evaluados de modo que una exclusión explícita gana. Acota por espacio de nombres o tipo cuando el código caliente vive junto:
{
"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 }
}
Todo en Acme.Pricing.* mantiene sus cadenas cifradas excepto el espacio de nombres caliente medido y el único formateador que el benchmark marcó. Cuando la ruta caliente es un solo método en lugar de un espacio de nombres entero, márcalo en el código y exclúyelo por atributo — la regla vive entonces junto al método que describe y sobrevive a las refactorizaciones:
[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 en cambio quieres la postura inversa — cifrar solo las cadenas genuinamente sensibles y dejar todo lo demás como literales en texto plano — cambia a un include y nombra los ámbitos valiosos:
"stringEncryption": {
"enabled": true,
"include": [ "Acme.Pricing.Licensing.*", "Acme.Pricing.Security.*" ]
}
Esa es la postura correcta cuando un perfilado muestra mucho código caliente con muchas cadenas y solo un conjunto pequeño y bien contenido de secretos. La mayoría de los proyectos hacen lo contrario — cifrar ampliamente, excluir las una o dos rutas calientes medidas — porque el valor por defecto de «protégelo todo» es el seguro y las exclusiones son raras.
Una regla general
Separa las cadenas valiosas de las cadenas calientes, porque casi nunca son las mismas cadenas. Tus secretos — endpoints, material de claves, mensajes de comprobación de licencia, los nombres de tus tipos propietarios — viven en código de configuración, rutas de autenticación y lógica de licencias que se ejecutan ocasionalmente. Tus cadenas calientes — un estado comparado por fila, un formato aplicado por petición — viven en bucles y no llevan ningún secreto. El cifrado de cadenas se gana su sitio en el primer conjunto y solo te penaliza en el segundo.
Así que el flujo de trabajo es: cifra las cadenas en todo el ensamblado por defecto, perfila o haz benchmark de los dos o tres métodos que dominan tu tiempo de ejecución y, si uno de ellos muestra un coste de descifrado real en BenchmarkDotNet, excluye ese ámbito y nada más. Terminas con cada secreto cifrado, un descompilador que no revela nada útil y una ruta caliente que se ejecuta a velocidad de literal en texto plano — que es todo el objetivo de acotar en lugar de conmutar. Combínalo con ofuscación de flujo de control en los métodos de licencias donde viven esas cadenas, y verifica el resultado protegido en Glass.NET antes de publicar.
Consulta Nebula.NET para el conjunto completo de transformaciones y la referencia de nebula.config.json.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.