PhantomCtx

PhantomCtx est un outil qui automatise le détournement de contexte d'activation dans le but de charger une DLL arbitraire dans la grande majorité des exécutables signés (par exemple Microsoft, Adobe, Mozilla).

Le chargeur se présente comme une alternative moderne au détournement et au sideloading de DLL traditionnels : contrairement aux approches conventionnelles, il ne nécessite pas de binaire vulnérable. La technique peut être réalisée tant que l'exécutable cible résout une DLL via sa table d'adresses d'importation (IAT) ou, dans le pire des cas, via LoadLibrary sans chemin absolu.```c C:\PhantomCtx\x64>.\PhantomCtx.exe

            +----------------------------------+
            |         PhantomCtx v1.0          |
            +----------------------------------+

Usage: PhantomCtx.exe -m [MODE] [OPTIONS]

Modes: -m recon Displays information about the Activation Context DLL redirections of a running process or one to be spawned.

    -m spawn        Perform Activation Context Hijacking using an on-disk executable
                    (preferably a signed binary for OPSEC purposes).

    -m runtime      Perform Activation Context Hijacking on an already running process.

Pour une analyse plus approfondie de son fonctionnement interne et de la manière dont il contourne les solutions EDR agressives, consultez l'article sur [mon blog technique](https://rexmax.dev/posts/phantomctx-new-approach-to-activation-context-hijacking-for-edr-evasion/).

# Table des matières

- [Mécanisme interne](#mécanisme-interne)
  - [Une nouvelle méthode de détournement du contexte d'activation axée sur l'évasion EDR](#une-nouvelle-méthode-de-détournement-du-contexte-dactivation-axée-sur-lévasion-edr)
- [Comment compiler](#comment-compiler)
- [Utilisation : workflow basé sur les modules](#utilisation-workflow-basé-sur-les-modules)
  - [Reconnaissance (Recon)](#reconnaissance-recon)
  - [Lancement (Spawn) (recommandé)](#lancement-spawn-recommandé)
  - [Runtime](#runtime)
- [Exemple : Détournement du contexte d'activation + DLL Proxying de mpnotify.exe](#exemple-détournement-du-contexte-dactivation--dll-proxying-de-mpnotifyexe)
- [Avertissement](#avertissement)
- [Références](#références)

# Mécanisme interne

`PhantomCtx` abuse d'une fonctionnalité **légitime** de Windows présente dans la plupart des processus, appelée **Contextes d'activation** (Activation Contexts). Selon Microsoft :

>[_Les contextes d'activation_](https://learn.microsoft.com/fr-fr/windows/win32/sbscs/a-sbscs-gly) sont des structures de données en mémoire contenant des informations que le système peut utiliser pour rediriger une application **vers le chargement d'une version spécifique d'une DLL**, d'une instance d'objet COM ou d'une version de fenêtre personnalisée...

Lorsque le chargeur Windows résout une DLL (via `LoadLibrary` ou la table d'importation), il suit un ordre de résolution défini :

1. Redirection de DLL
2. Ensembles d'API (API sets)
3. **Redirection de manifeste SxS**
4. Liste des modules chargés
5. DLL connues (Known DLLs)
6. Graphe de dépendances du package du processus  
7 – 12. Ordre de recherche standard des fichiers sur disque

`PhantomCtx` cible l'étape 3 : **Redirection de manifeste SxS**. Les contextes d'activation sont dérivés des fichiers [Side-by-Side](https://en.wikipedia.org/wiki/Side-by-side_assembly) (`.manifest`) associés aux exécutables, généralement intégrés dans les binaires PE. En interne, un contexte d'activation contient une **Table des matières (Table of Contents - ToC)** indexant plusieurs sections, dont la **section de redirection de DLL**. Le chargeur accède généralement aux contextes d'activation via `PEB.ActivationContextData`.

Les recherches de [Kurosh Dabbagh Escalante](https://github.com/Kudaes) ont montré qu'un contexte d'activation malveillant peut être construit à l'aide de `CreateActCtxW`, écrit en mémoire `RW` dans un processus cible, puis activé en écrasant `PEB.ActivationContextData` pour pointer vers la structure fabriquée.

Une fois détourné, le chargeur résout les redirections de DLL définies dans le contexte d'activation malveillant, **redirigeant la résolution de bibliothèques** vers des chemins contrôlés par l'attaquant.

Le chargeur nommé `Eclipse`, développé dans le cadre de ses recherches, se trouve dans son [dépôt officiel](https://github.com/Kudaes/Eclipse).

## Une nouvelle méthode de détournement du contexte d'activation axée sur l'évasion EDR

Après de multiples tests, `Eclipse` a été détecté par des EDR agressifs comme Elastic aux points suivants :

- `Injection de code par processus suspendu potentiel` : création de processus suspendu suivie de `NtWriteVirtualMemory` pour copier le bloc AC dans le processus distant.
- `Écriture dans la mémoire d'un processus distant par un module de faible réputation` : `NtWriteVirtualMemory` sans `CreateProcess` dans la pile d'appels et un module de faible réputation, nécessaire pour écraser `PEB.ActivationContextData`.
- `Écriture mémoire à distance vers un processus cible de confiance` : `WriteProcessMemory` sans `CreateProcess` dans la pile d'appels, limité aux binaires système/utilisateur installés.

Après une journée de recherche à la recherche d'approches alternatives à implémenter dans `PhantomCtx`, j'ai découvert que **la région mémoire du contexte d'activation d'origine est une vue de section mappée lors de la création du processus**. Il est possible de **démapper cette vue de section à l'aide de** `NtUnmapViewOfSection`, puis de créer une nouvelle vue de section en lecture seule adossée à notre contexte d'activation malveillant, en la mappant à la **même adresse mémoire exacte** où se trouvait l'originale.

Par conséquent, il n'est **plus nécessaire** que le chargeur écrase le pointeur `PEB.ActivationContextData`. Cela élimine l'obligation d'utiliser `NtAllocateVirtualMemory` et `NtWriteVirtualMemory`, contournant ainsi toutes les règles de surveillance EDR liées aux écritures mémoire et aux injections dans des processus distants.

De plus, pour accroître la difficulté de détection, `PhantomCtx` n'utilise pas `CreateActCtxW`, ce qui supprime la nécessité de gérer les fichiers `.manifest` pendant l'attaque. Selon le mode choisi, il peut **voler le contexte d'activation d'un autre processus distant** contenant une section de redirection de DLL valide à l'aide de `NtReadVirtualMemory`, reconstruire localement les entrées de redirection de DLL, le patcher, puis remplacer l'original.

# Comment compiler

Pour compiler l'outil, il est recommandé d'utiliser Visual Studio ou un compilateur compatible.

Si vous utilisez VS, ouvrez l'`Invite de commandes Native Tools x64 pour VS`, accédez au répertoire racine du projet et compilez-le avec `compile.bat` :```
C:\PhantomCtx>.\compile.bat
[INFO] Created output directory: x64
[INFO] Compiling PhantomCtx...
main.c
utils.c
recon.c
actctx.c
c_runtime.c
dynamic_resolution.c
process_utils.c
spawn.c
runtime.c
Generating Code...
[SUCCESSFUL] Build successful: x64\PhantomCtx.exe

Utilisation : Workflow basé sur les modules

L'outil est conçu avec une architecture modulaire pour simplifier le développement tout en offrant à l'opérateur un workflow clair et basé sur des étapes.

Chaque module remplit un rôle spécifique dans le workflow d'exploitation.

Veuillez prendre un moment pour examiner l'objectif de chacun afin de tirer pleinement parti des capacités de l'outil !!!

L'attaque peut être effectuée soit sur un processus à lancer (recommandé) soit sur un processus déjà en cours d'exécution. L'outil est conçu pour gérer les deux scénarios.```c C:\PhantomCtx\x64>.\PhantomCtx.exe