r3xmax/phantomctxHerramienta de Evasión de Secuestro del Contexto de Activación
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
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]