Skip to content
← Tous les articles
· Delta1 Labs Anti-dumpNebula

Empêcher un vidage mémoire de récupérer votre assembly

Le renommage et le chiffrement de chaînes sont annulés si un attaquant se contente de vider votre processus en cours sur le disque. Comment l'anti-dump de Nebula.NET relocalise et efface les en-têtes PE et de métadonnées en mémoire pour qu'une image extraite soit inutilisable : avec les offsets réels, du C#, un SVG du chemin d'extraction et les limites honnêtes.

Renommez chaque type, chiffrez chaque chaîne, aplatissez chaque branche — et un attaquant peut tout contourner d’un seul geste : laisser votre programme démarrer, puis copier l’assembly directement depuis sa propre mémoire et ouvrir cette copie dans un décompilateur. Le runtime a déjà fait le plus dur. Les chaînes sont déchiffrées à la première utilisation, les métadonnées sont résolues, le JIT détient les vrais tokens. Un vidage de processus capture un module qui, à certains égards, est plus propre que le fichier que vous avez distribué.

C’est l’attaque contre laquelle l’obfuscation seule ne fait rien, et la contre-mesure — l’anti-dump — est l’une des protections les plus mal comprises de la boîte. Voici précisément ce dont dépend un outil de vidage, comment Nebula.NET le lui retire, et où la technique s’arrête.

Ce que fait réellement un outil de vidage

Un assembly managé est un fichier PE. Quand le CLR le charge, le chargeur mappe ce PE dans l’espace d’adressage du processus sous forme d’image : chaque section atterrit à son adresse virtuelle, de sorte qu’un pointeur en mémoire est simplement base + RVA. Un outil de vidage exploite ce découpage régulier. Les étapes sont mécaniques :

  1. Énumérer les modules chargés (ou parcourir la mémoire validée à la recherche d’un en-tête DOS MZ suivi d’une signature PE\0\0).
  2. Parcourir les en-têtes jusqu’à l’en-tête CLI (l’IMAGE_COR20_HEADER, entrée 14 du répertoire de données) et, à partir de là, lire le répertoire MetaData : le RVA et la taille de la racine des métadonnées qui commence par la signature ASCII BSJB.
  3. Extraire l’image mappée de la mémoire, la « démapper » (réécrire les RVA de section en offsets de fichier bruts pour que les octets reforment un PE valide sur disque) et écrire un .dll.
  4. L’ouvrir dans dnSpy/ILSpy. Chaque nom que vous avez renommé reste renommé — mais chaque chaîne que votre code a déjà touchée s’y trouve en clair, et le module s’exécute.

Toute l’attaque repose sur une hypothèse : que les en-têtes PE et la racine des métadonnées sont toujours en mémoire, sous forme canonique, là où un scanner peut les trouver. L’anti-dump brise cette hypothèse.

L’idée : déplacer les métadonnées, effacer l’original

Vous ne pouvez pas simplement mettre à zéro les métadonnées après le chargement — le CLR en a besoin pour la réflexion, l’instanciation des génériques et la résolution des types d’exception pendant toute la vie du processus. C’est pourquoi Nebula fait quelque chose de plus chirurgical, dans un stub de démarrage qui s’exécute avant tout votre code :

  1. Trouver l’adresse de base de ce module lui-même.
  2. Allouer une nouvelle région privée, y copier les métadonnées et réécrire le RVA MetaData de l’en-tête CLI en mémoire pour que le runtime suive la copie. Le CLR continue de fonctionner : il lit le pointeur patché.
  3. Effacer l’original : écraser la signature BSJB et les champs d’en-tête de l’image mappée sur lesquels un scanner s’appuie.

Désormais, un outil de vidage qui extrait l’image mappée copie une région effacée. L’en-tête CLI pointe vers des métadonnées qui ont été écrasées ; la signature BSJB a disparu. Le fichier extrait n’est pas un assembly chargeable, et un outil qui suit le répertoire atterrit sur des déchets — tandis que votre processus, suivant le pointeur relocalisé, s’exécute normalement.

Pour faire tout cela, le stub doit lire la chaîne d’en-têtes à la main. Les offsets sont fixes et valent la peine d’être connus, car ce sont exactement ce que lit aussi l’outil de l’attaquant :

// Illustratif : comment le stub de démarrage localise son propre en-tête CLI et les métadonnées.
// L'injection réelle est native d'abord, obfusquée, et s'exécute avant votre Main.
static unsafe (IntPtr metaRoot, int metaSize) FindMetadata(Module module)
{
    byte* base_ = (byte*)Marshal.GetHINSTANCE(module);   // base de l'image mappée
    int e_lfanew = *(int*)(base_ + 0x3C);                // -> signature PE
    byte* nt = base_ + e_lfanew;                         // "PE\0\0"
    short magic = *(short*)(nt + 0x18);                  // magic de l'en-tête optionnel
    // les répertoires de données commencent à 0x60 (PE32) ou 0x70 (PE32+)
    int ddOffset = (magic == 0x20B) ? 0x70 : 0x60;
    byte* dataDirs = nt + 0x18 + ddOffset;
    // entrée 14 = IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR (en-tête CLI)
    int cor20Rva = *(int*)(dataDirs + 14 * 8);
    byte* cor20 = base_ + cor20Rva;                      // IMAGE_COR20_HEADER
    int metaRva = *(int*)(cor20 + 8);                    // MetaData.VirtualAddress
    int metaSize = *(int*)(cor20 + 12);                  // MetaData.Size
    return ((IntPtr)(base_ + metaRva), metaSize);        // commence par 'BSJB'
}

Chaque nombre là est un offset PE/CLI réel : e_lfanew à 0x3C, le magic de l’en-tête optionnel à 0x18 dans les en-têtes NT, l’en-tête CLI à l’index 14 du répertoire de données, et le répertoire MetaData à l’offset 8 dans l’IMAGE_COR20_HEADER de 72 octets. L’étape de relocalisation fait ensuite un VirtualProtect sur la page d’en-tête pour la rendre inscriptible, réécrit *(int*)(cor20 + 8) vers le nouveau RVA et écrase les quatre premiers octets de l’ancienne racine des métadonnées (le magic BSJB) pour qu’aucun scanner ne puisse la retrouver.

Image mappée en mémoire du processusen-têtes PEen-tête CLI (14)métadonnées (BSJB)le vidage extrait base + RVA.dll extrait écrit sur disqueAprès le stub de démarrage anti-dumpen-têtes PEen-tête CLI patchéeffacé (sans BSJB)métadonnées relocaliséesle CLR suit le nouveau pointeur
Un outil de vidage lit base + RVA directement dans l'image mappée. L'anti-dump relocalise les métadonnées et efface la racine BSJB sur place, de sorte que la copie extraite n'a pas de métadonnées lisibles tandis que le processus vivant suit l'en-tête CLI patché.

Pourquoi il doit s’exécuter en premier

Toute la valeur de l’anti-dump tient au moment. Si un attaquant prend un instantané du processus avant que votre stub ne s’exécute, les en-têtes sont encore intacts et vous n’avez rien protégé. C’est pourquoi Nebula ne l’émet pas comme du C# ordinaire qui se trouve s’exécuter tôt : il câble l’effacement dans le chemin de chargement du module (une entrée native d’abord qui s’exécute avant le Main managé), de sorte qu’au moment où une partie de votre code, ou le point d’arrêt de quiconque, devient atteignable, les en-têtes sont déjà déplacés et effacés.

Cela signifie aussi que le stub ne peut pas être une méthode propre et localisable. Un unique AntiDump() qu’un attaquant peut localiser et NOP-er dans un débogueur met en échec l’ensemble, donc la logique de relocalisation est obfusquée, insérée en ligne dans le chemin de chargement, et ses constantes sont dérivées plutôt que stockées : la même discipline qui rend l’anti-tamper digne d’être distribué.

L’activer

L’anti-dump est un interrupteur dans la configuration de protection, appliqué comme une passe au démarrage :

{
  "renaming": { "mode": "dictionary" },
  "encryptStrings": true,
  "antiDump": { "enabled": true },
  "antiTamper": { "enabled": true },
  "antiDebug": { "enabled": true }
}
nebula protect ./bin/Release/net8.0/Billing.dll \
  --config nebula.config.json \
  --out ./protected/

Il n’y a pas de portée par méthode ici — l’anti-dump est par nature à l’échelle du module, car il opère sur les propres en-têtes du module. Le coût est de quelques microsecondes au démarrage et une allocation privée de la taille de votre flux de métadonnées, payée une fois par processus. Installez le CLI avec dotnet tool install --global Delta1Labs.Nebula.Tool.

Où il s’arrête — honnêtement

L’anti-dump a une tâche précise et un angle mort précis, et vendre au-delà de l’un ou l’autre est la manière dont on finit par surestimer sa confiance en production.

  • Il met en échec les scanners, pas les reconstructeurs. Un outil de vidage qui extrait l’image mappée brute est bloqué. Un outil qui reconstruit un module à partir des structures d’exécution propres au CLR — parcourant les tables de types et de méthodes via la surface de débogage/DAC plutôt que de lire vos en-têtes PE — ne regarde jamais les octets que vous avez effacés. Ces outils sont plus lents et plus maladroits, et produisent souvent un module cassé, mais l’anti-dump ne les arrête pas à lui seul. Associez-le à l’anti-debug pour que l’attachement du type de processus qui pilote un outil de vidage DAC soit lui-même détecté.
  • Il ne rechiffre pas ce que le runtime a déchiffré. Une fois que votre code s’est exécuté, les chaînes déchiffrées et les corps de méthode compilés par le JIT vivent en mémoire en clair. L’anti-dump rend le module difficile à extraire comme un assembly valide ; il ne nettoie pas tous les secrets du tas. Délimitez les chaînes sensibles pour qu’elles soient déchiffrées tard et non retenues, et appuyez-vous sur la virtualisation de code pour la poignée de méthodes dont la logique — et pas seulement les noms — ne doit jamais être récupérée.
  • Dépendant du découpage. Les bundles mono-fichier, les images ReadyToRun et NativeAOT changent le découpage PE/CLI que parcourt le stub ; Nebula adapte la passe au type de sortie, mais vérifiez que votre build protégé démarre réellement dans la forme de déploiement cible avant de vous y fier.

Le modèle mental est le même qui traverse chaque protection de la suite. L’anti-dump ne rend pas votre assembly impossible à extraire — rien qui s’exécute sur une machine que vous ne contrôlez pas ne le fait. Il supprime l’extraction la moins chère : celle du « exécute-le, vide-le, ouvre-le » en un clic qui transforme un processus vivant déchiffré en un fichier propre en moins d’une minute. Ce chemin est la manière dont se produit l’essentiel du pillage occasionnel de l’IP managée, et le fermer force l’attaquant vers les outils lents et fragiles, ce qui, combiné à l’anti-tamper et à l’anti-debug, fait la différence entre une minute de travail et un projet dont il doit décider s’il vaut sa semaine.

Consultez la documentation de Nebula.NET pour ajouter l’anti-dump à votre profil de protection, puis videz votre propre build protégé et observez le fichier extrait refuser de s’ouvrir.

Essayez Nebula.NET

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