Skip to content
← Tous les articles
· Delta1 Labs DebuggingNebula

Garder les affichages du débogueur lisibles après renommage

Une chaîne de format [DebuggerDisplay] est un littéral de compilation qui survit intact à l'obfuscation — et pourtant la fenêtre Espion affiche {CustomerName} #{Id} ou une erreur après renommage. Cet article explique pourquoi : la chaîne n'est pas du texte que le débogueur imprime, c'est une petite expression que son évaluateur lie par nom de membre au point d'arrêt, si bien que renommer les membres qu'elle nomme fait échouer la recherche. Il cadre ensuite Nebula.NET pour que vos propres builds de staging restent lisibles dans le débogueur sans laisser ces noms dans le binaire distribué.

Vous attachez le débogueur à votre propre build de staging pour traquer un bug. Vous survolez un Invoice, et la fenêtre Espion — qui à la dernière version affichait Acme #4821 — montre maintenant le texte littéral {CustomerName} #{Id}, ou un error CS1061: 'a' does not contain a definition for 'CustomerName' en rouge. L’objet est intact. Chaque champ a la bonne valeur. L’obfuscation a fait exactement ce que vous avez demandé. Le débogueur a simplement perdu la seule chose que vous lui aviez dit d’afficher.

La vraie question

Une chaîne de format [DebuggerDisplay] est un littéral de chaîne de compilation. Le renommage ne touche pas les littéraux de chaîne — c’est toute la raison pour laquelle le ToString() d’un record ou un modèle de message Serilog survivent à l’obfuscation. Alors si la chaîne de format est intacte, pourquoi l’affichage est-il cassé ? Parce que la chaîne n’est pas du texte que le débogueur imprime. C’est un petit programme que le débogueur exécute au point d’arrêt, et ce programme cherche des membres par nom — ce que le renommage réécrit précisément.

La chaîne de format est un littéral — et c’est là le piège

Prenons un type annoté ordinaire.

[DebuggerDisplay("{CustomerName} #{Id}")]
public sealed class Invoice
{
    public string CustomerName { get; init; }
    public int Id { get; init; }
    public decimal Total { get; init; }
}

L’attribut est stocké dans les métadonnées comme une ligne d’attribut personnalisé sur Invoice, et l’argument du constructeur — votre chaîne de format — vit comme des octets UTF-8 préfixés par leur longueur dans le tas #Blob :

.custom instance void [System.Private.CoreLib]
        System.Diagnostics.DebuggerDisplayAttribute::.ctor(string) = (
    01 00 14 7B 43 75 73 74 6F 6D 65 72 4E 61 6D 65   // ...{CustomerName
    7D 20 23 7B 49 64 7D 00 00 )                       // } #{Id}..
)

Ces octets 7B 43 75 73 74… épellent {CustomerName. C’est un argument de constructeur opaque, pas un nom de métadonnées — l’obfuscateur n’a aucune raison (ni aucun moyen sûr) d’aller fouiller dans un blob d’attribut arbitraire et d’y réécrire une sous-chaîne. Donc quand Nebula renomme la ligne de propriété CustomerName en b, la chaîne de format continue de dire CustomerName. Le littéral survit parfaitement. C’est là le problème, pas la solution.

Ce que le débogueur en fait

À un point d’arrêt, l’évaluateur d’expressions de Visual Studio lit l’attribut DebuggerDisplay, découpe le format selon ses segments {…} et compile chaque segment comme une expression évaluée contre l’instance — this.CustomerName et this.Id. Il lie ces identifiants aux métadonnées de l’assembly réellement chargé dans le processus : la version renommée. Il n’y a plus de membre nommé CustomerName sur le type chargé ; il s’appelle b. La liaison échoue, et l’évaluateur signale une erreur pour ce segment ou se rabat sur l’affichage des accolades brutes. La valeur "Acme" est là, juste dans le champ b — on n’a simplement pas dit au débogueur d’y regarder.

inv : Invoice(arrêté au point d'arrêt)blob d'attribut — survit"{CustomerName} #{Id}"UTF-8 littéral dans le tas #Bloble renommage ne le réécrit jamaislignes de propriété — renomméesCustomerName → b Id → cles noms vivants changentc'est ce que voit l'évaluateurl'évaluateur lie {CustomerName} → membre 'CustomerName' → échecla fenêtre Espion affiche : {CustomerName} #{Id}
La chaîne de format survit au renommage car c'est un blob d'attribut opaque ; les noms de membre qu'elle référence, non. Le débogueur lie ces noms aux métadonnées renommées et échoue.

C’est la même division qui régit le destructuring de Serilog et la liaison de configuration : une valeur qui est un littéral de compilation survit au renommage, mais un nom résolu à l’exécution le suit. DebuggerDisplay n’est inhabituel qu’en ceci : la résolution a lieu au moment du débogage, et il regroupe les deux moitiés dans un seul attribut — un littéral qui survit et qui nomme des membres que le renommeur a déplacés.

Comparez au cas sans attribut. Retirez entièrement [DebuggerDisplay] et le débogueur se rabat sur le ToString() du type. Pour un record, ToString() est généré par le compilateur avec chaque nom de membre incrusté comme littéral, donc il imprime les mêmes noms avant et après renommage. Un type sans attribut s’affiche bien ; ajouter un DebuggerDisplay qui nomme des membres est ce qui introduit la dépendance par nom au moment du débogage.

Cadrer Nebula pour que vos propres builds restent lisibles

L’essentiel est de savoir à qui servent ces attributs. DebuggerDisplay, DebuggerTypeProxy et DebuggerBrowsable existent pour un humain qui attache un débogueur — et sur le build que vous livrez aux clients, personne ne le fait. Une version durcie avec anti-débogage et un chemin critique virtualisé est construite pour que l’attachement d’un débogueur soit détecté et que le pas-à-pas n’ait aucun sens ; un affichage Espion cassé sur ce build ne vous coûte rien, car vous ne l’ouvrez jamais. La première et meilleure réponse est donc : n’essayez pas de préserver l’affichage sur le build client. Laissez-le se renommer.

Là où l’affichage doit survivre, c’est sur les builds que vous déboguez réellement — local, et un build de staging qui reflète la production. Si ce build de staging est légèrement obfusqué ou pas du tout, c’est réglé ; les noms sont intacts. S’il est entièrement renommé et que vous devez quand même attacher, ne conservez que ce que l’affichage lit — et conservez la feuille, pas le type. Le moyen le moins coûteux est d’acheminer tout l’affichage via un membre et de conserver ce seul nom :

[DebuggerDisplay("{DebugView,nq}")]
public sealed class Invoice
{
    public string CustomerName { get; init; }
    public int Id { get; init; }
    public decimal Total { get; init; }

    [Obfuscation(Feature = "renaming", Exclude = true)]   // the only name the debugger binds
    private string DebugView => $"{CustomerName} #{Id}";
}

Maintenant l’évaluateur ne lie qu’un seul nom — DebugView — que l’attribut conserve. À l’intérieur de cette propriété, CustomerName, Id et Total sont des accès de membre ordinaires compilés en IL ; le renommage les réécrit de manière cohérente avec toutes les autres références, donc ils se renomment toujours en b, c, d partout et ne divulguent rien dans un décompilateur. Vous avez échangé trois noms de propriété conservés contre un nom d’indirection conservé, et le spécificateur ,nq retire les guillemets pour que l’affichage se lise proprement.

Si vous préférez une règle de configuration à un attribut — disons un espace de noms de diagnostic entier de vues de débogage — conservez les membres feuille là et renommez tout le reste :

{
  "schemaVersion": 1,
  "inputs": [ "bin/Release/net8.0/Billing.dll" ],
  "outputDirectory": "protected",
  "encryptStrings": true,
  "controlFlowObfuscation": true,
  "renaming": {
    "rules": [
      { "pattern": "Billing.Diagnostics.DebugViews.*", "action": "keep", "members": "public" },
      { "pattern": "Billing.*",                         "action": "rename" }
    ]
  }
}
nebula protect --config nebula.config.json

Un nom conservé reste un corps entièrement protégé — le membre DebugView conservé garde son obfuscation de flux de contrôle et son chiffrement de chaînes ; seul son nom reste lisible. C’est la discipline standard de la keep-list : conservez l’ensemble minimal de noms que quelque chose résout comme une chaîne, ici au moment du débogage.

Quand ça casse

Trois cas limites valent la peine d’être connus. Premièrement, DebuggerTypeProxy : son argument typeof(InvoiceDebugView) est une référence de type que Nebula réécrit de manière cohérente, donc le proxy s’attache toujours après renommage — mais les noms de propriétés publiques de la classe proxy elle-même sont ce que le débogueur développe dans l’arbre Espion, et ceux-là sont renommés en a, b, c. Si vous voulez cette vue développée lisible, conservez les noms de membre publics du type proxy ; sinon c’est juste plus de bruit dans une fenêtre que vous pouvez laisser se renommer.

Deuxièmement, le chiffrement des chaînes ne couvre pas la chaîne de format. encryptStrings réécrit les chargements ldstr dans les corps de méthode ; l’argument de DebuggerDisplay est une valeur de constructeur dans un blob d’attribut, pas un corps de méthode, donc il reste en clair même sur le build durci. Les noms de membre qu’il mentionne restent à découvert — une petite fuite, et une raison de plus de préférer la seule indirection DebugView (qui ne nomme rien) ou simplement de ne pas emporter l’attribut dans le build distribué.

Troisièmement, les attributs de pas-à-pas sont sans objet, pas cassés. [DebuggerStepThrough] et [DebuggerHidden] n’affectent que le pas-à-pas, que le renommage laisse intact — mais une fois qu’une méthode a son flux de contrôle aplati ou est virtualisée, il ne reste plus d’IL ordinaire à parcourir en pas-à-pas, donc ces attributs n’ont rien sur quoi agir. N’ajoutez pas de règles de conservation pour eux ; il n’y a rien à conserver.

À retenir

Un [DebuggerDisplay] est un littéral qui nomme des membres, et le renommage déplace les membres de sous le littéral. La chaîne de format survit intacte ; l’évaluateur du débogueur lie les noms qu’elle contient aux métadonnées renommées et échoue. Décidez où l’affichage doit réellement fonctionner — vos builds débogables, pas celui durci du client — et sur ceux-là, acheminez-le via un seul membre que vous conservez plutôt que de nommer plusieurs propriétés que vous devez ensuite laisser lisibles. Protégez le reste avec Nebula.NET, puis ouvrez le résultat dans Glass.NET pour confirmer que vos types se lisent comme a, b, c tandis que le seul DebugView dont vos ingénieurs dépendent épelle toujours son nom.

Essayez Nebula.NET

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