Skip to content
← Tous les articles
· Delta1 Labs ObfuscationNebula

L'obfuscation peut-elle cacher une chaîne de connexion ? Ce que Nebula protège, et ce qu'il ne peut pas

Une chaîne de connexion, une clé d'API ou un secret de signature livré à l'intérieur de votre application .NET est récupérable en principe : le processus doit l'utiliser, donc le processus doit le détenir. Voici une comparaison honnête des trois endroits où un secret se cache dans un assemblage livré, ce que le chiffrement de chaînes et de ressources de Nebula.NET change exactement pour chacun, où se situe le plafond, et la stratification qui garde réellement un secret hors de portée d'un attaquant.

Tout outil de protection reçoit la même question, en général formulée comme une exigence : « J’ai une chaîne de connexion dans mon application de bureau, peux-tu faire que personne ne puisse la lire ? » La réponse honnête est une comparaison, pas un oui. Un secret livré à l’intérieur d’un code côté client est récupérable en principe, car le processus doit l’utiliser, ce qui veut dire que le processus doit détenir le texte en clair à un instant donné. Ce que l’obfuscation change, c’est le coût de la récupération — passer de « double-cliquer sur une visionneuse de ressources » à « attacher un débogueur, trouver le déchiffrement, le reproduire » — et le fait que la chaîne soit en clair pour qu’un vidage de strings.exe ou un robot d’indexation la trouve.

Cet article est la comparaison complète. Où se cache réellement une chaîne de connexion dans un assemblage livré, ce que le chiffrement de chaînes et de ressources de Nebula.NET fait à chaque cachette, où se situe le plafond et pourquoi, et la stratification qui garde le secret entièrement hors du binaire quand c’est possible.

Les trois endroits où se cache un secret

Une chaîne de connexion, une clé d’API, une clé symétrique pour un fichier de données embarqué : toutes atteignent l’assemblage livré par l’une de trois voies, et chacune se décompile différemment.

Comme littéral dans le code. La plus courante et la plus exposée :

const string Conn = "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;";

Le compilateur C# l’émet sous la forme d’un unique ldstr dans le tas de chaînes. Il n’est ni chiffré, ni encodé, ni caché : c’est du texte UTF-16 dans une table bien connue :

ldstr      "Server=db.internal;Database=App;User Id=svc;Password=S3cr3t!;"

Comme ressource appsettings.json embarquée. Vous marquez le fichier comme EmbeddedResource pour qu’il voyage dans la DLL :

<ItemGroup>
  <EmbeddedResource Include="appsettings.Production.json" />
</ItemGroup>

Désormais le JSON — chaînes de connexion comprises — est un blob préfixé par sa longueur dans la table ManifestResource. Aucun décompilateur nécessaire ; System.Resources le lit, et toute visionneuse de ressources aussi.

Comme valeur liée via la configuration. La chaîne vit dans appsettings.json sur le disque et IConfiguration la lit dans un POCO d’options. C’est le seul des trois qui n’est pas dans l’assemblage, mais c’est un fichier en clair posé à côté du binaire, ce qui est une exposition différente, pas moindre.

Notez la séparation : les deux premiers livrent le secret à l’intérieur du binaire, là où l’obfuscation peut agir ; le troisième le livre à côté du binaire, là où l’obfuscation ne peut pas atteindre du tout. Cette distinction régit toute la comparaison.

DEFAULT EXPOSUREAFTER NEBULARUNTIME CEILINGconst literalin code (ldstr)"...Password=S3cr3t!"plaintext in string heapstringEncryption →decode call, no literalheld decryptedin memory at useembeddedappsettings.jsonJSON blob in manifestany resource viewer reads itresourceEncryption →ciphertext, resolver decryptsdecrypted whenthe config is readon-diskconfig fileplaintext file beside thebinary — outside the DLLobfuscation cannotreach it — move it outread into processmemory on loadRed = readable in one step · Green = raised to reverse-engineering · Grey = not in the assembly

Ce que voit un décompilateur avant protection

Ouvrez une build non protégée dans Glass.NET (ou n’importe quel décompilateur) et le cas du littéral ne demande aucun effort. La vue IL montre le ldstr ; la vue du tas de chaînes liste la valeur. Vous n’avez même pas à trouver la méthode : le navigateur de métadonnées d’un décompilateur liste toutes les chaînes de l’assemblage, et Server=…;Password=…; se range juste à côté de vos messages d’erreur.

Le cas de la ressource embarquée est pire, car il ne demande même pas de décompilateur. Dépliez le nœud ressources de l’assemblage et la ressource appsettings.Production.json est là ; un clic vide le JSON. La BCL fournit même le lecteur, si bien qu’un programme de cinq lignes la récupère :

var asm = Assembly.LoadFile(path);
using var s = asm.GetManifestResourceStream("MyApp.appsettings.Production.json");
using var r = new StreamReader(s!);
Console.WriteLine(r.ReadToEnd()); // connection strings and all

« Je l’ai compilé dans la DLL » n’est pas une protection. C’est un nom de fichier un peu moins évident.

Ce que Nebula change, concrètement

Nebula.NET agit sur les deux cas internes à l’assemblage. Le chiffrement de chaînes réécrit le littéral. Le ldstr est remplacé par un appel à une routine de déchiffrement générée qui prend un jeton opaque et renvoie le texte en clair au point d’utilisation :

ldc.i4     0x3f91a7
call       string <Nebula>.Decode(int32)

La chaîne de connexion en clair a disparu du tas de chaînes. Un navigateur de métadonnées liste désormais un blob encodé ; un vidage strings ne trouve rien ; un décompilateur montre un appel vers du code protégé au lieu d’une valeur. Vous le cadrez dans nebula.config.json pour que les littéraux de valeur soient couverts sans pénaliser un chemin chaud déjà mesuré :

{
  "schemaVersion": 1,
  "inputs": [ "bin/Release/net8.0/MyApp.dll" ],
  "outputDirectory": "protected",

  "stringEncryption": {
    "enabled": true,
    "include": [ "MyApp.Data.*", "MyApp.Security.*" ]
  },

  "resourceEncryption": {
    "enabled": true,
    "include": [ "MyApp.appsettings.Production.json" ],
    "exclude": [ "*.g.resources" ]
  },

  "controlFlow": { "enabled": true }
}

Le chiffrement de ressources s’occupe du JSON embarqué. La passe remplace les octets de la ressource en clair par du texte chiffré au moment de la compilation et installe un résolveur pour que GetManifestResourceStream — et donc le fournisseur de configuration qui le lit — reçoive un flux qui déchiffre les noms protégés. Votre site d’appel est inchangé :

var config = new ConfigurationBuilder()
    .AddJsonStream(Assembly.GetExecutingAssembly()
        .GetManifestResourceStream("MyApp.appsettings.Production.json")!)
    .Build();

Cela se lie toujours, car le résolveur déchiffre de façon transparente. La seule chose qui a changé, c’est ce qu’une visionneuse statique voit sur le disque : du texte chiffré, pas une chaîne de connexion. Exécutez-le avec :

nebula protect --config nebula.config.json --out bin/Protected

Les deux passes font la même chose dans des parties différentes du PE : elles suppriment la divulgation triviale — la valeur que vous pouviez lire en une étape — et forcent toute récupération à passer par le code obfusqué, où elle coûte un effort réel. C’est toute la revendication, honnête.

Le plafond, et pourquoi il existe

Voici la partie qu’un éditeur devrait énoncer sans détour : le chiffrement ne rend pas un secret côté client irrécupérable. La clé de déchiffrement est livrée dans l’assemblage elle aussi, car le processus doit déchiffrer la valeur pour l’utiliser. Nebula dérive cette clé à travers le même chemin de code protégé qui garde vos méthodes — ce n’est pas une constante dans un champ — de sorte que la récupérer revient à rétro-concevoir du code à flux aplati et à chaînes chiffrées plutôt qu’à lire un littéral. C’est une forte hausse du coût. Ce n’est pas l’infini.

La limite la plus nette est l’exécution. À l’instant où votre code fait ceci :

using var conn = new SqlConnection(decryptedConnString);

la chaîne de connexion en clair existe comme un string vivant sur le tas managé. Un attaquant capable d’exécuter votre processus — ce que, sur une machine cliente, il peut — peut attacher un débogueur, s’arrêter sur SqlConnection..ctor et lire l’argument. Aucune décompilation requise. Il en va de même pour le appsettings.json déchiffré : une fois que le fournisseur de configuration l’a lu, les valeurs sont des objets en mémoire. L’obfuscation relève la barre contre l’inspection statique et contre les vidages occasionnels. Elle ne peut pas gagner contre un débogueur attaché à un processus sur le point d’utiliser le secret, car à ce moment le secret est, par nécessité, en clair.

Ce n’est pas une faiblesse propre à Nebula ; c’est la nature des secrets côté client. Tout outil qui prétend le contraire vend la prétention, pas la protection.

La stratification qui fonctionne vraiment

À cause de ce plafond, la vraie stratégie est une hiérarchie, et l’obfuscation en est le dernier niveau, pas le premier.

Niveau 1 : ne livrez pas le secret. Une chaîne de connexion vers un serveur que vous contrôlez, une clé d’API tierce, tout ce qui authentifie le client auprès d’un backend : cela ne devrait pas être dans le binaire du tout. Gardez-le hors du code source avec user-secrets en développement, fournissez-le depuis une variable d’environnement ou l’identité managée de votre plateforme en production, ou — mieux — ne confiez jamais au client un identifiant à longue durée de vie et, à la place, intermédiez l’accès pour que le serveur émette un jeton éphémère et à portée restreinte. Un secret qui n’est jamais dans l’artefact n’a pas de coût de récupération parce qu’il n’y a rien à récupérer. L’obfuscation est sans objet pour le Niveau 1, et c’est là tout l’intérêt : la protection la plus forte est l’absence.

Niveau 2 : pour le secret que vous devez vraiment embarquer, augmentez le coût. Certains secrets doivent être livrés : la clé publique que votre app utilise pour vérifier une licence, une clé symétrique qui déchiffre un fichier de données propriétaire embarqué, un certificat épinglé. Ceux-là ne peuvent pas être déplacés vers un serveur, car l’app doit fonctionner hors ligne ou ne doit pas faire confiance au réseau pour cette vérification. Pour ceux-là, Nebula est exactement le bon outil. Chiffrez le littéral, chiffrez la ressource, aplatissez le flux de contrôle autour de la dérivation et — pour la routine de plus grande valeur — virtualisez la méthode pour que la dérivation de clé s’exécute sur un jeu d’instructions interprété plutôt que sur de l’IL lisible. Vous ne rendez pas la récupération impossible ; vous la rendez assez chère pour qu’elle n’en vaille pas la peine au regard de ce que le secret protège.

La décision est un court tableau.

Le secretPeut-il quitter le binaire ?Traitement
Chaîne de connexion BD, clé d’API backendOui — authentifie auprès de votre serveurNiveau 1 : intermédiez-le, émettez des jetons éphémères
Clé tierce liée à votre compteEn généralNiveau 1 : faites proxy de l’appel par votre backend
Clé publique de vérification de licenceNon — doit vérifier hors ligneNiveau 2 : livrez-la, chiffrez les chaînes + flux de contrôle
Clé symétrique d’un fichier de données embarquéNon — l’app doit déchiffrer en localNiveau 2 : chiffrez la ressource + virtualisez la dérivation

L’erreur est de sauter le Niveau 1 et de demander à l’obfuscation de faire son travail. L’obfuscation rend coûteux à extraire un secret qui doit être livré. Elle ne fait rien pour justifier la livraison d’un secret qui n’avait jamais à être là.

Vérifiez ce que vous avez livré

Après une build protégée, confirmez que les deux cas internes à l’assemblage sont réellement fermés. Ouvrez protected/MyApp.dll dans Glass.NET : le tas de chaînes ne devrait plus lister votre chaîne de connexion, et la ressource appsettings.Production.json devrait se vider en texte chiffré, pas en JSON. Faites-en une barrière de CI : un script qui ouvre la sortie protégée, vérifie qu’aucune ressource ne se décode en JSON reconnaissable et qu’aucun littéral ne correspond à un motif Password=, et fait échouer la build si l’un ou l’autre le fait. Cela attrape le jour où quelqu’un ajoute un nouveau littéral porteur de secret dans un espace de noms que votre liste include ne couvre pas.

Un binaire protégé qui fait encore un grep-match avec votre mot de passe signifie que la passe ne l’a pas atteint ; un binaire propre signifie que vous avez fait tout ce que l’obfuscation côté client peut faire — et dit la vérité sur l’endroit où cela s’arrête.

Voir Nebula.NET pour le pipeline complet de transformations et la référence de nebula.config.json, chiffrer les ressources embarquées pour la passe de ressources en détail, et Glass.NET pour vérifier ce qu’un décompilateur peut encore lire.

Essayez Nebula.NET

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