Introducción a la API de Windows Para el desarrollo de malware, parte 2.

Que tal amigos, en la sesión pasada vimos algunos ejemplos de la interacción de WinAPI para poder interactuar con la el sistema operativo, en esta ocasión seguiremos con la misma linea, veamos dos ejemplos más.

Obtención de procesos.

Para poder ver los procesos y subprocesos del sistema operativo aremos uso de la función GetCurrentProcessId() esta función devuelve un número que representa el ID del proceso actual consultado, el ID es un valor único de Windows asignado a cada proceso.

Esta función no recibe parámetros y devuelve un DWORD (Un entero sin signo de 32 bits) Veámoslo aplicado.

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

int main(){

    DWORD pid = GetCurrentProcessId();
    std:cout << "El ID del proceso es: " << pid << std::endl;
    return 0;
}

Este pequeño ejemplo al ejecutarse nos devolvera el ID del proceso actual, en la entrega pasada vimos con CreateProcessA como crear procesos si podemos saber el ID de los procesos esto es veneficioso para hacer inyecciones.

Acceder a otro proceso con OpenProcess()

OpenProcess() es una de las funciones más usadas cuando trabajas con procesos en Windows. Esta función podemos verla mas a detalle:

HANDLE OpenProcess(
  DWORD dwDesiredAccess,  // Qué permisos quieres sobre el proceso
  BOOL bInheritHandle,    // Si los procesos hijos heredan el handle
  DWORD dwProcessId       // PID del proceso que quieres abrir
);

dwDesiredAccess:

PROCESS_QUERY_INFORMATION: Permisos para consultar información básica del proceso.

PROCESS_TERMINATE: Permite terminar el proceso.

PROCESS_VM_READ: Permite leer la memoria del proceso.

PROCESS_VM_WRITE: Permite escribir en la memoria del proceso.

PROCESS_ALL_ACCESS: Teda todos los permisos

bInheriHandle: TRUE para que los procesos hijos puedan heredar ese handle, generalmetne se usa en FALSE.

dwProcessId: El PID del proceso, que se puede obtener con GetCurrentProcessId().

Esto nos va devolver un HANDLE para identificar el proceso abierto, si falla nos devolverá un NULL, también podemos llamar a GetLastError() para saber por qué falló.

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

int main(){
    DWORD pid;
    std::cout << "Ingresa el numero de PROCESO: "
    std::cin >> pid;

    HANDLE hProcess = OpenProcess(
        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 
        FALSE,
        pid
    );

    if (hProcess == NULL) {
        std::cerr<< "Fallo en abrir el proceso: " << GetLastError() << std::endl;
        return 1;
    }

    std::cout << "Proceso habierto exitosamente el handle es: " << hProcess << " " << std::endl;
}

Este ejemplo nos seria muy util para escalar privilegios matando o controlado otros procesos, inyección de código, leyendo y escribiendo en memoria. Veamos esto como un “puente” a otro proceso para poder manipularlo siempre y cuando se tengan permisos suficientes.

Asignar memoria en otro proceso.

Para la asignación de memoria en otro proceso vamos hacer uso de VirtualAllocEx que es la versión “remota” de el ya conocido VirtualAlloc.

La estructura es la siguiente:

LPVOID VirtualAllocEx(
  HANDLE hProcess,      // handle al proceso remoto
  LPVOID lpAddress,     // dirección base sugerida (puede ser NULL)
  SIZE_T dwSize,        // tamaño de memoria a asignar
  DWORD flAllocationType, // tipo de asignación (ej. MEM_COMMIT | MEM_RESERVE)
  DWORD flProtect         // permisos de la memoria (ej. PAGE_EXECUTE_READWRITE)
);

hProcess: Es el handle del proceso donde quieres reservar memoria.

lpAddress: Dirección base donde te gustaría que se reserve memoria, NULL para dejar que Windows elija.

dwSize: Numero de bytes a reservar.

flAllocationType: La manera en que se reservara la memoria.

flProtect: Permisos de la memoria.

Esto nos va a devolver un puntero a la memoria asignada dentro de proceso remoto.

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

int main(){
   /*DWORD pid = ####; podemos pasarle el numero del proceso de esta forma o podemos hacerlo de la forma manual
     personalmente me gusta ser explicito en ejemplos así que lo hare de manera manual*/

      DWORD pid;
      std:cout << "Ingresa el numero del proceso";
      std::cin >> pid;

      HANDLE hProcess = OpenProcess(
             PROCESS_VM_OPERATION | PROCESS_VM_WRITE, 
             FALSE, 
             pid
      );

      LPVOID remoteMem = VirtualAllocEx(
          hProcess,                
          NULL,                    
          1024,                    
          MEM_COMMIT | MEM_RESERVE,
          PAGE_EXECUTE_READWRITE   
      );

      if (remoteMem) {
          std::cout << "Memoria asignada en: " << remoteMem << std::endl;
      } else {
          std::cerr << "VirtualAllocEx fallo. Error: " << GetLastError() << std::endl;
      }
}

Como se puede ver aquí usamos funciones y pasos ya estudiados para poder hacer la asignación remota de la memoria, para este paso ya se debe tener identificado el numero del proceso que vamos a asignar memoria y conocimiento de las funciones de WinAPI, este es un paso crítico para técnicas de inyección avanzada.

Con esto terminaremos los ejemplos en esta ocación, estudialos y observa la memoria de no solo asignar memoria en otros procesos si no tambien de poder hacer algo un poco mas malicioso.

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