PhantomCtx

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

Utilizzo: Flusso di lavoro basato su moduli

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.