Skip to content
← Todas las publicaciones
· Delta1 Labs ReflectionNebula

Por qué un nombre de tipo almacenado se rompe al renombrar

Una aplicación de plugins que resuelve "Acme.Exporters.PdfExporter, Acme.Exporters" con Type.GetType y Activator.CreateInstance funciona en depuración y falla en producción en cuanto la ofuscas. La causa es un desajuste entre un token de metadatos y una simple cadena, y la solución es un registro resistente al renombrado que no conserva ningún nombre.

Este es un cargador de plugins que se ha distribuido en mil aplicaciones .NET. La aplicación lee el nombre de tipo de un exportador desde la configuración, lo resuelve y crea una instancia:

// appsettings: "Exporter": "Acme.Exporters.PdfExporter, Acme.Exporters"
string typeName = config["Exporter"];
Type? t = Type.GetType(typeName);
var exporter = (IExporter)Activator.CreateInstance(t!)!;
exporter.Export(report);

Supera todas las pruebas. Ofuscas la compilación, la publicas, y el primer cliente que selecciona el exportador de PDF obtiene una NullReferenceException, porque Type.GetType devolvió null. Nada en la lógica cambió. El tipo sigue en el ensamblado. Entonces, ¿qué se movió?

La pregunta de verdad: ¿token o cadena?

El renombrado es la columna vertebral de la ofuscación: reescribe PdfExporter como a, Acme.Exporters como nada, por todo el ensamblado. La razón por la que una llamada a método normal sobrevive a esto es que el compilador nunca almacenó el nombre de lo que llama: almacenó un token de metadatos, un identificador numérico hacia las tablas de tipos y miembros del ensamblado. Cuando el ofuscador renombra un tipo, reescribe la fila destino del token y cada token que apunta a ella al mismo tiempo. El enlace es numérico, así que no puede desviarse.

Una cadena no es un token. Type.GetType("Acme.Exporters.PdfExporter, Acme.Exporters") entrega al cargador una serie de caracteres y le pide que busque en los metadatos en tiempo de ejecución un tipo cuyo espacio de nombres y nombre deletreen eso. La cadena vive en el heap de cadenas de usuario del ensamblado como datos inertes. El renombrado reescribe las columnas Name y Namespace del tipo en la tabla TypeDef, pero no tiene motivo para tocar un literal de cadena, ni forma segura de saber que ese literal concreto pretendía nombrar ese tipo concreto. Así que la cadena sigue diciendo Acme.Exporters.PdfExporter, la fila TypeDef ahora dice a, la búsqueda no coincide con nada y obtienes null.

Ese es todo el fallo. Es la misma línea de fractura que la reflexión por nombre de miembro, pero un nivel más arriba: aquí lo que se transporta como cadena es la propia identidad del tipo.

Verlo en el IL

Compara cómo compilan las dos formas de nombrar un tipo. Un typeof(PdfExporter) se reduce a una carga de token:

ldtoken    Acme.Exporters.PdfExporter
call       class System.Type System.Type::GetTypeFromHandle(valuetype System.RuntimeTypeHandle)

El operando de ldtoken es un token hacia la tabla TypeDef/TypeRef. Renombra el tipo y el ofuscador reescribe la fila y este operando juntos: el identificador sigue apuntando al tipo correcto.

Type.GetType(string) se reduce a una carga de cadena:

ldstr      "Acme.Exporters.PdfExporter, Acme.Exporters"
call       class System.Type System.Type::GetType(string)

El operando de ldstr apunta al heap de cadenas de usuario. El ofuscador lo deja intacto. (El cifrado de cadenas sustituiría este ldstr por una llamada de descifrado, pero el valor descifrado es el mismo texto, así que cambia la imagen estática, no la búsqueda, y la resolución sigue fallando.) Mientras tanto la fila TypeDef que la cadena debía encontrar ha cambiado bajo sus pies:

typeof(PdfExporter) — sobreviveldtoken Acme.Exporters.PdfExporter→ token #02000007renombrar reescribe fila Y token juntosTypeDef #02000007 → name "a"GetTypeFromHandle(#02000007) ✓ resuelveType.GetType(string) — se rompeldstr "Acme.Exporters.PdfExporter"→ heap #US (datos inertes)renombrar reescribe SOLO la fila — cadena intactafila TypeDef ahora "a"; cadena con nombre viejobuscar "…PdfExporter" ✗ → null
Un tipo referenciado por token se mueve con el renombrado; un tipo nombrado por cadena se busca por un nombre que ya no existe.

Fíjate en lo que no se rompió: Activator.CreateInstance(t). Una vez que tienes un Type real, Activator llama a su constructor por token, y los constructores nunca se renombran. Todo el fallo se concentra en el único paso de cadena a Type.

La solución: resolver por token, almacenar una clave

La solución robusta es dejar de transportar un nombre de tipo del CLR como dato. Transporta una clave estable que tú eliges —una que no tenga nada que ver con cómo se llama el tipo en el ensamblado— y asígnala al tipo mediante typeof():

static readonly Dictionary<string, Type> Exporters = new()
{
    ["pdf"] = typeof(PdfExporter),
    ["csv"] = typeof(CsvExporter),
    ["xlsx"] = typeof(XlsxExporter),
};

// appsettings: "Exporter": "pdf"
Type t = Exporters[config["Exporter"]];
var exporter = (IExporter)Activator.CreateInstance(t)!;

Cada typeof() aquí compila a un token. Tras el renombrado, PdfExporter se llama a y el diccionario sigue devolviendo el Type correcto, porque el ofuscador reescribió el token al renombrar la fila. Las claves "pdf", "csv", "xlsx" son tu vocabulario, no el del entorno de ejecución: el renombrado nunca las mira, e incluso puedes dejar el cifrado de cadenas activado sobre ellas porque su valor es un contrato que controlas, no un identificador filtrado. No conservas ningún nombre de tipo en tu keep-list. Ese es el resultado ideal: renombrado completo, sin agujeros legibles, y además sobrevive a futuras refactorizaciones de los nombres de tipo.

Cuando realmente no puedas desacoplar —los nombres de tipo son un contrato publicado, o un host fuera de tu ensamblado los resuelve— conserva exactamente esos nombres y nada más. En nebula.config.json, un keep solo de nombre se sitúa por encima del catch-all de renombrado:

{
  "inputs": [ "bin/Release/net8.0/Acme.App.dll" ],
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "renaming": {
    "rules": [
      { "pattern": "Acme.Exporters.*Exporter", "action": "keep" },
      { "pattern": "Acme.*", "action": "rename" }
    ]
  }
}

O fíjalo en la declaración con un atributo, que mantiene la regla junto al código que protege:

[Obfuscation(Feature = "renaming", Exclude = true)]
public sealed class PdfExporter : IExporter { /* ... */ }

En cualquier caso el keep es solo de nombre: los cuerpos de los métodos de PdfExporter siguen con ofuscación de flujo de control y sus literales de cadena siguen cifrados. Has impedido que su nombre se mueva para que la cadena pueda encontrarlo; no has eximido su lógica de la protección. Pero recuerda el coste permanente de la disciplina del keep-list: cada nombre conservado es una etiqueta en texto claro en los metadatos. Un registro con clave "pdf" no filtra nada; un PdfExporter conservado filtra el nombre de la clase. Prefiere el registro siempre que seas dueño de la resolución.

Cuándo sigue mordiendo

Unos cuantos casos límite pillan a la gente incluso después de entender el mecanismo:

  • Renombrados solo de espacio de nombres. Incluso Type.GetType("Acme.Exporters.PdfExporter") sin sufijo de ensamblado se rompe, porque el espacio de nombres también se renombra. A veces se asume que solo importa el nombre hoja.
  • Tipos anidados. El nombre de un tipo anidado en una cadena usa un separador + (Outer+Inner). Renombrar ambas partes rompe la cadena igual, y la forma + es fácil de olvidar al escribir un patrón keep.
  • Tipos genéricos. El nombre de reflexión de un genérico lleva una aridad con tilde invertida (List\1). Si almacenas MyCache`1` y lo renombras, la aridad se mantiene pero el nombre se mueve: el mismo fallo.
  • Plugins en otros ensamblados. Si el tipo vive en un ensamblado que no forma parte de esta ejecución de ofuscación —un plugin de terceros— tu ejecución nunca lo renombra, así que su nombre es estable y Type.GetType sigue funcionando. El patrón de registro sigue ayudándote, pero la rotura solo afecta a los tipos que tú mismo ofuscas.
  • Nombre de ensamblado en la cadena. La parte de identidad del ensamblado (, Acme.Exporters) se compara con el nombre del ensamblado, que el renombrado no cambia, así que esa mitad de la cadena está bien. Siempre es la parte del tipo la que se desvía.

Conclusión

Un token de metadatos se mueve con el renombrado; una cadena no. Cada vez que tu propio código nombra uno de tus propios tipos como texto —Type.GetType, un nombre de tipo en la configuración, un discriminador persistido— el renombrado lo invalida en silencio mientras deja en verde todas las pruebas sobre la compilación sin ofuscar. La solución duradera no es una entrada en el keep-list; es resolver mediante typeof() y transportar una clave que elegiste, de modo que lo único que cruza la frontera de almacenamiento sea una palabra que el entorno de ejecución nunca tiene que comparar con un nombre renombrado. Consulta el catálogo de problemas complementario para los demás fallos por nombre, y Nebula.NET para las pasadas de renombrado y cifrado de cadenas descritas aquí.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.