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