Ofuscar una aplicación .NET localizada sin romper los recursos
Una aplicación localizada resuelve sus traducciones por nombre en tiempo de ejecución, y ese es justo el tipo de búsqueda que la ofuscación puede romper en silencio. La sorpresa es que los dos estilos de localización más habituales se comportan de forma opuesta al renombrar: un accesor .resx clásico generado por el diseñador es seguro porque el nombre base de su ResourceManager es un literal de cadena ya incrustado, mientras que IStringLocalizer<T> es frágil porque la fábrica deriva el nombre base del nombre completo del tipo marcador: renombra ese tipo y la búsqueda falla, el ensamblado satélite nunca se consulta y el localizador devuelve en silencio la clave del recurso en lugar de la traducción. Este artículo lee lo que emite cada estilo, muestra por qué uno sobrevive y el otro no, y da las reglas de conservación precisas de Nebula.NET para que tus traducciones sigan cargándose en todas las culturas.
La localización es un subsistema basado en nombres, y «por nombre» es justo la expresión que debería hacer que cualquiera coja un ofuscador con cuidado. Cada cadena traducida que muestra tu aplicación se resolvió en tiempo de ejecución haciendo coincidir una clave con un conjunto de recursos, y los conjuntos de recursos se encuentran por nombre: un nombre base que el runtime convierte en un flujo .resources incrustado y, para las culturas no predeterminadas, en un ensamblado satélite que sondea en disco. La ofuscación renombra cosas. La pregunta es si alguno de los nombres que renombra es uno que la tubería de localización busca.
La respuesta está realmente dividida. El viejo y aburrido accesor .resx del diseñador es seguro por un motivo que vale la pena entender. El moderno IStringLocalizer<T> es frágil por un motivo que vale la pena entender aún mejor, porque falla en silencio: sin excepción, sin registro, solo tus claves en inglés asomando en una compilación en francés. Esto es lo que emite cada uno, por qué divergen y las reglas de conservación exactas que hacen seguros a ambos con Nebula.NET.
De dónde viene realmente el nombre del recurso
Empieza por la ruta clásica: un Strings.resx con su Strings.Designer.cs generado. La parte que importa es cómo construye el accesor su ResourceManager:
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
var temp = new global::System.Resources.ResourceManager(
"MyApp.Resources.Strings", // base name — a string literal
typeof(Strings).Assembly); // assembly — a token reference
resourceMan = temp;
}
return resourceMan;
}
}
El nombre base es un literal. El diseñador incrusta "MyApp.Resources.Strings" en el IL como ldstr, y ese literal es lo que ResourceManager usa para añadirle la cultura: MyApp.Resources.Strings.fr.resources para el francés, encontrado en el manifiesto incrustado para la cultura neutra y en fr/MyApp.resources.dll para el satélite. Renombra el tipo Strings a a y el literal no se mueve; sigue diciendo "MyApp.Resources.Strings". El typeof(Strings) se reescribe por token como toda referencia a tipo, así que sigue apuntando al tipo renombrado y sigue devolviendo el ensamblado correcto. Ambas mitades sobreviven. Incluso el cifrado de cadenas lo deja funcionando, porque el literal se descifra antes de llegar al constructor: ResourceManager recibe el nombre base en texto plano exactamente como se escribió.
Ahora la ruta moderna. IStringLocalizer<HomeController> se resuelve a través de ResourceManagerStringLocalizerFactory, y la fábrica no recibe un literal. Calcula el nombre base a partir del tipo marcador:
// Program.cs
builder.Services.AddLocalization(o => o.ResourcesPath = "Resources");
// HomeController.cs
public HomeController(IStringLocalizer<HomeController> loc) => _loc = loc;
// ...
ViewData["Title"] = _loc["PageTitle"];
Por detrás, la fábrica lee typeof(HomeController).FullName, quita el espacio de nombres raíz del ensamblado e inserta ResourcesPath para producir un nombre base como MyApp.Resources.Controllers.HomeController. Ese nombre base es la clave de búsqueda: aquello según lo cual debe estar nombrado un flujo .resources. Se deriva del identificador del tipo en tiempo de ejecución, que es precisamente el identificador que reescribe la ofuscación.
El fallo es silencioso, que es el verdadero peligro
Si IStringLocalizer lanzara una excepción cuando no encuentra un conjunto de recursos, este sería un error ruidoso que arreglarías en la primera prueba de humo. No lanza excepción. El contrato de IStringLocalizer es que un recurso ausente es una condición recuperable: devuelve un LocalizedString cuya bandera ResourceNotFound es true y cuyo Value es la clave que pasaste:
var s = _loc["PageTitle"];
// After a renamed marker type:
// s.ResourceNotFound == true
// s.Value == "PageTitle" // the key, shown verbatim in the UI
Así que un usuario francés ve PageTitle donde debería ir el título, cada satélite que enviaste sigue en disco y es perfectamente válido, y nada en los registros apunta a ello. La compilación en cultura neutra a menudo también parece correcta, porque muchos equipos ponen el texto en inglés en la clave o en un respaldo neutro, así que la regresión solo aparece en las culturas exactas en las que menos probablemente haga clic un revisor. Este es el argumento más fuerte para tratar la localización como un objetivo de protección con sus propias reglas de conservación, en lugar de confiar en que la autodetección lo cubra.
Las reglas de conservación
Nebula autodetecta el uso habitual de ResourceManager, así que el accesor .resx clásico suele estar cubierto por ti, e incluso un tipo accesor renombrado está bien porque, como se mostró arriba, su nombre base es un literal. La ruta que necesita una decisión explícita es IStringLocalizer<T>: los tipos marcadores deben conservar sus nombres completos, porque la fábrica convierte FullName en la clave de búsqueda.
Fija exactamente esos tipos marcadores y nada más. En nebula.config.json, pon las reglas keep estrechas por encima del rename general que lo abarca todo: gana la primera coincidencia:
{
"schemaVersion": 1,
"inputs": [ "bin/Release/net8.0/MyApp.dll" ],
"outputDirectory": "protected",
"preservePublicApi": true,
"encryptStrings": true,
"controlFlowObfuscation": true,
"renaming": {
"rules": [
{ "pattern": "MyApp.Controllers.*", "action": "keep" },
{ "pattern": "MyApp.Resources.*", "action": "keep" },
{ "pattern": "MyApp.*", "action": "rename" }
]
}
}
Dos cosas a notar. Primero, keep fija el nombre, no el cuerpo: un controlador conservado sigue teniendo sus campos privados renombrados, sus cuerpos de método aplanados por flujo de control y sus cadenas cifradas; renunciaste a renombrar un identificador de tipo, no a la protección de su código. Segundo, conserva la hoja, no la rama. Si solo un puñado de tipos se usan como marcadores de IStringLocalizer<T>, fija esos tipos en lugar de un espacio de nombres entero. Para una alternativa quirúrgica y local al código, marca el tipo marcador exacto con un atributo que viva junto a él:
[Obfuscation(Feature = "renaming", Exclude = true)] // used as IStringLocalizer<T> marker
public class HomeController : Controller { /* ... */ }
Una conservación más sutil se aplica si localizas anotaciones de datos mediante tipos de recursos: [Display(Name = "Field_Email", ResourceType = typeof(Strings))]. El typeof(Strings) es una referencia de token segura, pero Name = "Field_Email" se resuelve reflejando en busca de una propiedad estática con ese nombre en el tipo de recurso. Eso hace que los miembros del accesor generado sean críticos: conserva los miembros públicos de cualquier tipo accesor de recursos al que hagas referencia desde un ResourceType, no solo el nombre del tipo. IViewLocalizer no necesita nada: deriva su nombre base de la ruta de la vista, que ningún renombrado toca.
Los ensamblados satélite no requieren ningún trabajo. Un satélite es un ensamblado solo de recursos —flujos .resources de cada cultura y ningún IL tuyo—, así que no hay nada en él que renombrar ni aplanar. Deja fr/MyApp.resources.dll y compañía fuera de tus entradas de Nebula y envíalos tal como se compilaron. Siguen resolviéndose porque Nebula conserva el nombre del ensamblado principal (de modo que el runtime sondea la subcarpeta de cultura correcta) y porque, en la ruta clásica, el nombre base que pide el ensamblado principal no cambia.
Verifica en la cultura, no solo en inglés
La rotura de localización se esconde de una ejecución en cultura predeterminada, así que la prueba de aceptación tiene que cambiar de cultura y afirmar sobre un valor traducido, no simplemente que volvió una cadena:
[Theory]
[InlineData("fr")]
[InlineData("de")]
public void Localizer_returns_translation_not_key(string culture)
{
CultureInfo.CurrentUICulture = new CultureInfo(culture);
var s = _loc["PageTitle"];
Assert.False(s.ResourceNotFound); // the real assertion
Assert.NotEqual("PageTitle", s.Value); // guards against the silent key fallback
}
Ejecuta esa suite contra la compilación protegida, no la de depuración: todo el objetivo es ejercitar el ensamblado renombrado. Acompáñala con una comprobación estática en Glass.NET, el compañero gratuito solo estático: abre el MyApp.dll protegido, confirma que tu motor interno se lee como a, b, c, y confirma que tus tipos marcadores de IStringLocalizer<T> conservaron sus nombres completos y espacios de nombres para que la fábrica derive el nombre base contra el que se construyeron los satélites. Para la disciplina general detrás de las listas de conservación mínimas, consulta listas de conservación y exclusiones de renombrado; para el catálogo más amplio de roturas por nombre, qué rompe la ofuscación.
En resumen
La localización se resuelve por nombre, así que la única pregunta que plantea la ofuscación es cuáles de los nombres son las claves de búsqueda. En la ruta .resx clásica no son identificadores en absoluto —el nombre base es un literal incrustado—, así que el tipo accesor se renombra libremente e incluso el cifrado de cadenas lo deja funcionando. En la ruta IStringLocalizer<T> el nombre base se deriva del nombre completo del tipo marcador en tiempo de ejecución, así que renombrar ese tipo desplaza la búsqueda fuera de cada flujo .resources que enviaste y el localizador sirve en silencio la clave. Conserva el puñado de tipos marcadores (y los miembros públicos de cualquier tipo de recurso que alcances mediante un ResourceType de anotación de datos), deja los ensamblados satélite fuera de las entradas y sin tocar, protege todo lo demás por completo, y demuéstralo con una prueba que cambie de cultura y afirme sobre la traducción, no sobre si volvió una cadena.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.