Skip to content
← Tous les articles
· Delta1 Labs ReflectionNebula

Pourquoi un nom de type stocké casse après le renommage

Une application à plugins qui résout "Acme.Exporters.PdfExporter, Acme.Exporters" avec Type.GetType et Activator.CreateInstance fonctionne en débogage et échoue en production dès que vous l'obfusquez. La cause est une incohérence entre un jeton de métadonnées et une simple chaîne, et la solution est un registre résistant au renommage qui ne conserve aucun nom.

Voici un chargeur de plugins qui a été livré dans un millier d’applications .NET. L’application lit le nom de type d’un exporteur depuis la configuration, le résout et crée une instance :

// 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);

Il passe tous les tests. Vous obfusquez la build, la livrez, et le premier client qui choisit l’exporteur PDF obtient une NullReferenceException, parce que Type.GetType a renvoyé null. Rien dans la logique n’a changé. Le type est toujours dans l’assembly. Alors, qu’est-ce qui a bougé ?

La vraie question : jeton ou chaîne ?

Le renommage est l’épine dorsale de l’obfuscation : il réécrit PdfExporter en a, Acme.Exporters en rien, à travers tout l’assembly. Si un appel de méthode normal survit à cela, c’est que le compilateur n’a jamais stocké le nom de ce qu’il appelle : il a stocké un jeton de métadonnées, un identifiant numérique vers les tables de types et de membres de l’assembly. Quand l’obfuscateur renomme un type, il réécrit la ligne cible du jeton et chaque jeton qui pointe vers elle en même temps. Le lien est numérique, il ne peut donc pas dériver.

Une chaîne n’est pas un jeton. Type.GetType("Acme.Exporters.PdfExporter, Acme.Exporters") remet au chargeur une suite de caractères et lui demande de chercher dans les métadonnées à l’exécution un type dont l’espace de noms et le nom épellent cela. La chaîne vit dans le tas des chaînes utilisateur de l’assembly comme une donnée inerte. Le renommage réécrit les colonnes Name et Namespace du type dans la table TypeDef, mais il n’a aucune raison de toucher à un littéral de chaîne, ni aucun moyen sûr de savoir que ce littéral précis était censé nommer ce type précis. Donc la chaîne dit toujours Acme.Exporters.PdfExporter, la ligne TypeDef dit maintenant a, la recherche ne correspond à rien, et vous obtenez null.

C’est tout le bogue. C’est la même ligne de fracture que la réflexion par nom de membre, mais un cran plus haut : ici, c’est l’identité même du type qui est transportée sous forme de chaîne.

Le voir dans l’IL

Comparez la compilation des deux façons de nommer un type. Un typeof(PdfExporter) se réduit à un chargement de jeton :

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

L’opérande de ldtoken est un jeton vers la table TypeDef/TypeRef. Renommez le type et l’obfuscateur réécrit la ligne et cet opérande ensemble : l’identifiant pointe toujours vers le bon type.

Type.GetType(string) se réduit à un chargement de chaîne :

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

L’opérande de ldstr pointe vers le tas des chaînes utilisateur. L’obfuscateur n’y touche pas. (Le chiffrement des chaînes remplacerait ce ldstr par un appel de déchiffrement, mais la valeur déchiffrée est le même texte : cela change l’image statique, pas la recherche, et la résolution échoue toujours.) Pendant ce temps, la ligne TypeDef que la chaîne devait trouver a changé sous ses pieds :

typeof(PdfExporter) — survitldtoken Acme.Exporters.PdfExporter→ token #02000007renommer réécrit ligne ET jeton ensembleTypeDef #02000007 → name "a"GetTypeFromHandle(#02000007) ✓ résoutType.GetType(string) — casseldstr "Acme.Exporters.PdfExporter"→ tas #US (donnée inerte)renommer réécrit SEULEMENT la ligne — chaîne intacteligne TypeDef maintenant "a"; chaîne ancien nomrecherche "…PdfExporter" ✗ → null
Un type référencé par jeton bouge avec le renommage ; un type nommé par chaîne est recherché par un nom qui n'existe plus.

Remarquez ce qui n’a pas cassé : Activator.CreateInstance(t). Dès que vous détenez un Type réel, Activator appelle son constructeur par jeton, et les constructeurs ne sont jamais renommés. Tout l’échec se concentre sur l’unique étape de chaîne vers Type.

La solution : résoudre par jeton, stocker une clé

La solution robuste est de cesser de transporter un nom de type CLR comme donnée. Transportez une clé stable que vous choisissez — une qui n’a rien à voir avec le nom du type dans l’assembly — et associez-la au type via 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)!;

Chaque typeof() ici compile vers un jeton. Après le renommage, PdfExporter s’appelle a et le dictionnaire renvoie toujours le bon Type, car l’obfuscateur a réécrit le jeton en renommant la ligne. Les clés "pdf", "csv", "xlsx" sont votre vocabulaire, pas celui de l’exécution : le renommage ne les regarde jamais, et vous pouvez même laisser le chiffrement des chaînes activé dessus, puisque leur valeur est un contrat que vous contrôlez, pas un identifiant fuité. Vous ne conservez aucun nom de type sur votre keep-list. C’est le résultat idéal : renommage complet, aucun trou lisible, et il survit en plus aux futurs remaniements des noms de type.

Quand vous ne pouvez vraiment pas découpler — les noms de type sont un contrat publié, ou un hôte en dehors de votre assembly les résout — conservez exactement ces noms et rien d’autre. Dans nebula.config.json, un keep portant uniquement sur le nom se place au-dessus du catch-all de renommage :

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

Ou épinglez-le à la déclaration avec un attribut, qui garde la règle près du code qu’elle protège :

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

Dans les deux cas, le keep porte uniquement sur le nom : les corps de méthodes de PdfExporter restent obfusqués en flux de contrôle et ses littéraux de chaîne restent chiffrés. Vous avez empêché son nom de bouger pour que la chaîne puisse le trouver ; vous n’avez pas exempté sa logique de la protection. Mais rappelez-vous le coût permanent de la discipline du keep-list : chaque nom conservé est une étiquette en clair dans les métadonnées. Un registre indexé sur "pdf" ne fuit rien ; un PdfExporter conservé fuit le nom de la classe. Préférez le registre partout où vous êtes maître de la résolution.

Quand ça mord encore

Quelques cas limites piègent même après avoir compris le mécanisme :

  • Renommages du seul espace de noms. Même Type.GetType("Acme.Exporters.PdfExporter") sans suffixe d’assembly casse, car l’espace de noms est aussi renommé. On suppose parfois que seul le nom feuille compte.
  • Types imbriqués. Le nom d’un type imbriqué dans une chaîne utilise un séparateur + (Outer+Inner). Renommer les deux parties casse la chaîne de la même façon, et la forme + est facile à oublier quand on écrit un motif keep.
  • Types génériques. Le nom de réflexion d’un générique porte une arité avec accent grave (List\1). Si vous stockez MyCache`1` et le renommez, l’arité reste mais le nom bouge : le même échec.
  • Plugins dans d’autres assemblies. Si le type vit dans un assembly qui ne fait pas partie de cette exécution d’obfuscation — un plugin tiers — votre exécution ne le renomme jamais, donc son nom est stable et Type.GetType continue de fonctionner. Le motif de registre vous aide tout de même, mais la casse ne concerne que les types que vous obfusquez vous-même.
  • Nom d’assembly dans la chaîne. La partie identité d’assembly (, Acme.Exporters) est comparée au nom de l’assembly, que le renommage ne change pas, donc cette moitié de la chaîne va bien. C’est toujours la partie du type qui dérive.

À retenir

Un jeton de métadonnées bouge avec le renommage ; une chaîne non. Chaque fois que votre propre code nomme un de vos propres types sous forme de texte — Type.GetType, un nom de type dans la configuration, un discriminant persisté — le renommage l’invalide en silence tout en laissant au vert tous les tests sur la build non obfusquée. La solution durable n’est pas une entrée de keep-list ; c’est de résoudre via typeof() et de transporter une clé que vous avez choisie, de sorte que la seule chose à franchir la frontière de stockage soit un mot que l’exécution n’a jamais à comparer à un nom renommé. Voyez le catalogue des pièges complémentaire pour les autres échecs par nom, et Nebula.NET pour les passes de renommage et de chiffrement de chaînes décrites ici.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.