利用 ZwCreateThreadEx 注入 DLL

已于 2024-11-09 17:15:03 修改
阅读量864 收藏 3
点赞数 1
分类专栏： Windows 基础编程 业余学习 文章标签： windows c++ 测试工具 微软
于 2023-10-09 18:09:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59075481/article/details/133710618
版权

传统的 CreateRemoteThreadEx 注入方式极容易被查杀，不便于测试环境。

我们可以采取很多方法来注入 DLL 比如较新的早鸟(EarlyBird)技术，就是利用 APC 配合未公开函数进行劫持注入。

这里我们给出一个利用 ntdll 导出的未文档化函数 ZwCreateThreadEx 实现远程进程注入。

ZwCreateThreadEx 函数在 32 和 64 上的定义不相同，参见：

x86-64:

typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        ULONG CreateThreadFlags,
        SIZE_T ZeroBits,
        SIZE_T StackSize,
        SIZE_T MaximumStackSize,
        LPVOID pUnkown
        );

x86-32:

typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        BOOL CreateSuspended,
        DWORD dwStackSize,
        DWORD dw1,
        DWORD dw2,
        LPVOID pUnkown
        );

其中，lpStartAddress 支持提供内存地址用于执行 Payload 函数，lpParameter 传入结构体指针，用于在回调中使用。

我们常常使用进程名作为特征，遍历进程的 PID 以及句柄，然后执行注入过程，

这里我们使用 CreateToolhelp32Snapshot 遍历目标进程的 PID，需要注意的是我们可能遇到内存中已经崩溃的进程，这种时候会导致注入器不断尝试注入过程，但始终失败。

PROCESSENTRY32W 结构体中的 cntThreads 包含进程的线程计数信息，崩溃的进程没有主线程，于是，可以加上这个条件来过滤。

std::vector<DWORD> pids;// 容器对象用于存储 PID
// 创建进程快照
HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32W pe = { 0 };
pe.dwSize = sizeof(PROCESSENTRY32W);
// 使用 Process32FirstW 和 Process32NextW 的组合来遍历快照信息
if (Process32FirstW(hp, &pe)) {
    do {
        // wcscmp 比较进程名称是否相同，
        // pe.cntThreads >= 1 可以过滤已经崩溃的进程
        if (!wcscmp(pe.szExeFile, exepth) && pe.cntThreads >= 1) {
            pids.push_back(pe.th32ProcessID);// 压入 PID 信息
        }
    } while (Process32NextW(hp, &pe));
}
// 关闭句柄
CloseHandle(hp);

现在我们有了 PID 有了 注入执行函数，但是进程可能需要提升至管理员权限并开启 DEBUG 权限才能注入DLL，我们使用 AdjustTokenPrivileges 函数实现获取进程 DEBUG 权限：

BOOL EnableDebugPrivilege(
    BOOL bEnablePrivilege   // to enable or disable privilege
)
{
    HANDLE hProcess = NULL;
    TOKEN_PRIVILEGES tp{};
    LUID luid;
    hProcess = GetCurrentProcess();
    HANDLE hToken = NULL;
    OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken);

    if (!LookupPrivilegeValueW(
        NULL,            // lookup privilege on local system
        SE_DEBUG_NAME,   // privilege to lookup 
        &luid))        // receives LUID of privilege
    {
        printf("LookupPrivilegeValue error: %u\n", GetLastError());
        CloseHandle(hToken);
        return FALSE;
    }

    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    if (bEnablePrivilege)
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    else
        tp.Privileges[0].Attributes = 0;

    // Enable the privilege or disable all privileges.

    if (!AdjustTokenPrivileges(
        hToken,
        FALSE,
        &tp,
        sizeof(TOKEN_PRIVILEGES),
        (PTOKEN_PRIVILEGES)NULL,
        (PDWORD)NULL))
    {
        printf("AdjustTokenPrivileges error: %u\n", GetLastError());
        CloseHandle(hToken);
        return FALSE;
    }

    if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)

    {
        printf("The token does not have the specified privilege. \n");
        CloseHandle(hToken);
        return FALSE;
    }
    CloseHandle(hToken);
    return TRUE;
}

完整注入器代码：

此注入器支持参数：

DllInjectTool.exe <要注入的目标进程名(含后缀)> <要注入完整 DLL 路径>

#include <iostream>
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <shlwapi.h>

#pragma comment(lib, "Shlwapi.lib")
#pragma comment(lib, "advapi32.lib")
BOOL ProcessHasLoadDll(
    DWORD pid, 
    const TCHAR* dll
);

BOOL ZwCreateThreadExInjectDll(
    DWORD dwProcessId,
    const wchar_t* pszDllFileName
);

BOOL EnableDebugPrivilege(
    BOOL bEnablePrivilege
);

int wmain(int argc, wchar_t* argv[])
{
    SetConsoleTitleW(L"LoadLibraryTool v.1.0");
    printf("LoadLibraryTool v.1.0 通用 DLL 注入工具；@Rio-CTH\n");
    if (argc != 3)
    {
        std::cout << "错误：参数不合法！" << std::endl;
        std::cin.get();
        return -1;
    }
    const size_t exepthlen =
        wcslen(argv[1]) * sizeof(wchar_t);
    const size_t dllpthlen = 
        wcslen(argv[2]) * sizeof(wchar_t);

    if (exepthlen < 5 || dllpthlen < 1)
    {
        std::cout << "错误：文件路径错误！" << std::endl;
        std::cin.get();
        return -1;
    }
    wchar_t* exepth = new wchar_t[exepthlen];
    wchar_t* dllpth = new wchar_t[dllpthlen];
    //wchar_t pszPath[MAX_PATH] = { 0 };
    wcscpy_s(exepth, exepthlen, argv[1]);
    wcscpy_s(dllpth, dllpthlen, argv[2]);
    //wcscpy_s(pszPath, dllpthlen, argv[2]);
    //BOOL exeextflag = PathFileExistsW(exepth);
    if (!wcsstr(exepth, L".exe"))
    {
        std::cout << "错误：目标进程名必须包含.exe后缀！" << std::endl;
        std::cin.get();
        return -1;
    }

    BOOL dllextflag = PathFileExistsW(dllpth);
    if (FALSE == dllextflag)
    {
        std::cout << "错误：文件不存在或者无法访问！" << std::endl;
        std::cin.get();
        return -1;
    }

    if (PathGetDriveNumberW(dllpth) == -1)
    {
        TCHAR szPath[_MAX_PATH] = { 0 };
        TCHAR szDrive[_MAX_DRIVE] = { 0 };
        TCHAR szDir[_MAX_DIR] = { 0 };
        TCHAR szFname[_MAX_FNAME] = { 0 };
        TCHAR szExt[_MAX_EXT] = { 0 };
        //TCHAR DataBinPath[MAX_PATH] = { 0 };
        TCHAR CurBinPath[MAX_PATH] = { 0 };
        GetModuleFileNameW(NULL, szPath, sizeof(szPath) / sizeof(TCHAR));
        ZeroMemory(CurBinPath, sizeof(CurBinPath));
        _wsplitpath_s(szPath, szDrive, szDir, szFname, szExt);
        wsprintf(CurBinPath, L"%s%s", szDrive, szDir);
        //wcscpy_s(DataBinPath, CurBinPath);
        wcscat_s(CurBinPath, dllpth);
        //wprintf(L"[WorkstationDirectory]: %s\n", DataBinPath);
        dllextflag = PathFileExistsW(CurBinPath);
        if (FALSE == dllextflag)
        {
            std::cout << "错误：文件不存在或者无法访问！" << std::endl;
            std::cin.get();
            return -1;
        }
        dllpth = CurBinPath;
    }

    EnableDebugPrivilege(TRUE);

    std::vector<DWORD> pids;
    HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32W pe = { 0 };
    pe.dwSize = sizeof(PROCESSENTRY32W);
    if (Process32FirstW(hp, &pe)) {
        do {
            if (!wcscmp(pe.szExeFile, exepth) && pe.cntThreads >= 1) {
                pids.push_back(pe.th32ProcessID);
            }
        } while (Process32NextW(hp, &pe));
    }
    CloseHandle(hp);

    for (int i = 0; i < pids.size(); i++) {
        if (ProcessHasLoadDll(pids[i], dllpth) != NULL)
        {
            std::cout << "警告：PID 为 " << pids[i] << " 的进程已经包含目标 DLL。" << std::endl;
            continue;
        }

        if (ZwCreateThreadExInjectDll(pids[i], dllpth) == FALSE)
        {
            std::cout << "错误：注入 PID 为 " << pids[i] << " 的进程时失败。" << std::endl;
            std::cout << "原因：" << GetLastError() << std::endl;
        }
    }

    if (pids.size() == 0)
    {
        std::wcout << "错误：未找到目标进程：" << exepth << std::endl;
        std::cin.get();
        EnableDebugPrivilege(FALSE);
        return -1;
    }
    // 销毁过程
    pids.clear();
    pids.shrink_to_fit();
    std::cout << "操作已经完成。" << std::endl;
    std::cin.get();
    EnableDebugPrivilege(FALSE);
    return 0;
}

BOOL EnableDebugPrivilege(
    BOOL bEnablePrivilege   // to enable or disable privilege
)
{
    HANDLE hProcess = NULL;
    TOKEN_PRIVILEGES tp{};
    LUID luid;
    hProcess = GetCurrentProcess();
    HANDLE hToken = NULL;
    OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken);

    if (!LookupPrivilegeValueW(
        NULL,            // lookup privilege on local system
        SE_DEBUG_NAME,   // privilege to lookup 
        &luid))        // receives LUID of privilege
    {
        printf("LookupPrivilegeValue error: %u\n", GetLastError());
        CloseHandle(hToken);
        return FALSE;
    }

    tp.PrivilegeCount = 1;
    tp.Privileges[0].Luid = luid;
    if (bEnablePrivilege)
        tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    else
        tp.Privileges[0].Attributes = 0;

    // Enable the privilege or disable all privileges.

    if (!AdjustTokenPrivileges(
        hToken,
        FALSE,
        &tp,
        sizeof(TOKEN_PRIVILEGES),
        (PTOKEN_PRIVILEGES)NULL,
        (PDWORD)NULL))
    {
        printf("AdjustTokenPrivileges error: %u\n", GetLastError());
        CloseHandle(hToken);
        return FALSE;
    }

    if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)

    {
        printf("The token does not have the specified privilege. \n");
        CloseHandle(hToken);
        return FALSE;
    }
    CloseHandle(hToken);
    return TRUE;
}


BOOL ProcessHasLoadDll(DWORD pid, const TCHAR* dll) {
    /*
    * 参数为TH32CS_SNAPMODULE 或 TH32CS_SNAPMODULE32时,如果函数失败并返回ERROR_BAD_LENGTH，则重试该函数直至成功
    * 进程创建未初始化完成时，CreateToolhelp32Snapshot会返回error 299，但其它情况下不会
    */
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
    while (INVALID_HANDLE_VALUE == hSnapshot) {
        DWORD dwError = GetLastError();
        if (dwError == ERROR_BAD_LENGTH) {
            hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);
            continue;
        }
        else {
            //if (dwError == ERROR_PARTIAL_COPY) {
                //printf("CreateToolhelp32Snapshot failed: %d\ncurrentProcessId: %d \t targetProcessId:\n",
                    //dwError, GetCurrentProcessId(), pid);
            //}
            //else {
                printf("CreateToolhelp32Snapshot failed: %d\ncurrentProcessId: %d \t targetProcessId:%d\n",
                    dwError, GetCurrentProcessId(), pid);
            //}
            return FALSE;
        }
    }
    MODULEENTRY32W mi{};
    mi.dwSize = sizeof(MODULEENTRY32W); //第一次使用必须初始化成员
    BOOL bRet = Module32FirstW(hSnapshot, &mi);
    while (bRet) {
        // mi.szModule是短路径
        if (wcsstr(dll, mi.szModule) || wcsstr(mi.szModule, dll)) {
            //TCHAR* dllWithFullPath = new TCHAR[MAX_MODULE_NAME32 + 1];
            //lstrcpyW(dllWithFullPath, mi.szModule);
            if (hSnapshot != NULL) CloseHandle(hSnapshot);
            return TRUE;
        }
        mi.dwSize = sizeof(MODULEENTRY32W);
        bRet = Module32NextW(hSnapshot, &mi);
    }
    if(hSnapshot != NULL) CloseHandle(hSnapshot);
    return FALSE;
}

BOOL ZwCreateThreadExInjectDll(
    DWORD dwProcessId, 
    const wchar_t* pszDllFileName
)
{
    size_t pathSize = (wcslen(pszDllFileName) + 1) * sizeof(wchar_t);
    // 1.打开目标进程
    HANDLE hProcess = OpenProcess(
        PROCESS_ALL_ACCESS, // 打开权限
        FALSE, // 是否继承
        dwProcessId); // 进程PID
    if (NULL == hProcess)
    {
        printf("错误：打开目标进程失败！\n");
        return FALSE;
    }
    // 2.在目标进程中申请空间
    LPVOID lpPathAddr = VirtualAllocEx(
        hProcess, // 目标进程句柄
        0, // 指定申请地址
        pathSize, // 申请空间大小
        MEM_RESERVE | MEM_COMMIT, // 内存的状态
        PAGE_READWRITE); // 内存属性
    if (NULL == lpPathAddr)
    {
        printf("错误：在目标进程中申请空间失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }
    // 3.在目标进程中写入Dll路径
    if (FALSE == WriteProcessMemory(
        hProcess, // 目标进程句柄
        lpPathAddr, // 目标进程地址
        pszDllFileName, // 写入的缓冲区
        pathSize, // 缓冲区大小
        NULL)) // 实际写入大小
    {
        printf("错误：目标进程中写入Dll路径失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }

    //4.加载ntdll.dll
    HMODULE hNtdll = GetModuleHandleW(L"ntdll.dll");
    if (NULL == hNtdll)
    {
        printf("错误：加载ntdll.dll失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }

    //5.获取LoadLibraryA的函数地址
    //FARPROC可以自适应32位与64位
    FARPROC pFuncProcAddr = GetProcAddress(GetModuleHandle(L"Kernel32.dll"),
        "LoadLibraryW");
    if (NULL == pFuncProcAddr)
    {
        printf("错误：获取LoadLibrary函数地址失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }

    //6.获取ZwCreateThreadEx函数地址,该函数在32位与64位下原型不同
    //_WIN64用来判断编译环境 ，_WIN32用来判断是否是Windows系统
#ifdef _WIN64
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        ULONG CreateThreadFlags,
        SIZE_T ZeroBits,
        SIZE_T StackSize,
        SIZE_T MaximumStackSize,
        LPVOID pUnkown
        );
#else
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        BOOL CreateSuspended,
        DWORD dwStackSize,
        DWORD dw1,
        DWORD dw2,
        LPVOID pUnkown
        );
#endif 
    typedef_ZwCreateThreadEx ZwCreateThreadEx =
        (typedef_ZwCreateThreadEx)GetProcAddress(hNtdll, "ZwCreateThreadEx");
    if (NULL == ZwCreateThreadEx)
    {
        printf("错误：获取ZwCreateThreadEx函数地址失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }
    //7.在目标进程中创建远线程
    HANDLE hRemoteThread = NULL;
    DWORD lpExitCode = 0;
    DWORD dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL,
        hProcess,
        (LPTHREAD_START_ROUTINE)pFuncProcAddr, lpPathAddr, 0, 0, 0, 0, NULL);
    if (NULL == hRemoteThread)
    {
        printf("错误：目标进程中创建线程失败！\n");
        CloseHandle(hProcess);
        return FALSE;
    }

    // 8.等待线程结束
    WaitForSingleObject(hRemoteThread, -1);
    GetExitCodeThread(hRemoteThread, &lpExitCode);
    if (lpExitCode == 0) 
    {
        printf("错误：目标进程中注入 DLL 失败，请检查提供的 DLL 是否有效！\n");
        CloseHandle(hProcess);
        return FALSE;
    }
    // 9.清理环境
    VirtualFreeEx(hProcess, lpPathAddr, 0, MEM_RELEASE);
    CloseHandle(hRemoteThread);
    CloseHandle(hProcess);
    FreeLibrary(hNtdll);
    return TRUE;
}

测试结果：

注意事项：

当成功创建远程线程，但在远程函数执行时可能出现目标进程异常崩溃的现象。此时，可以通过系统收集的信息进行分析。如果观察到错误类型为“AppCrash” 且错误原因包含 “StackHash” 关键字，则有可能是触发了 DEP 或者 ASLR 导致的。当然，这并不绝对。此时应该检查远程函数是否关注了不同进程中可能由基址随机化导致的内存访问违例（目标模块需要重定位）；然后，再检查注入的代码是否存在潜在的缓冲区溢出或者堆栈损坏，这会导致 DEP。此外，可能还需要检查注入代码中的 api 依赖的模块是否已经在目标进程中初始化，以及是否已经将多级调用的每一层函数的代码均写入到目标进程，并正确重定位（不能只拷贝最外层 Call）。

转载请注明出处：利用 ZwCreateThreadEx 注入 DLLicon-default.png?t=O83Ahttp://t.csdnimg.cn/uuMvK

Windows黑客编程——远程线程注入(2)
Think88666的博客
03-27 1429
本篇采用的技术与前一篇无异，唯一的区别是调用了更底层的API——ZwCreateThreadEx，与CreateRemoteThread相比，该API除了能注入普通进程外，还能注入系统服务进程，实际上CreateRemoteThread底层也是通过ZwCreateThreadEx来实现了，不过该API是微软未公布的，所以不同版本操作系统或编写32位与64位程序，该函数的原型不一定相同。 废话不多说，参考第一篇博文，直接上代码： //定义32位函数指针 typedef DWORD(WINAPI *typ
[网络安全自学篇] 八十五.《Windows黑客编程技术详解》之注入技术详解（全局钩子、远线程钩子、突破Session 0注入、APC注入）
杨秀璋的专栏
06-25 1万+
从这篇文章开始，作者将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充知识点，希望对您有所帮助。第二篇文章主要介绍4种常见的注入技术，包括全局钩子、远线程钩子、突破SESSION 0隔离的远线程注入、APC注入，案例包括键盘钩子、计算器远线程注入实现、APC注入等，希望对您有所帮助。
DLL注入工具：利用 ZwCreateThreadEx 注入 DLL
weixin_41245990的博客
06-05 829
x86-64:x86-32:DWORD dw1,DWORD dw2,其中，lpStartAddress 支持提供内存地址用于执行 Payload 函数，lpParameter 传入结构体指针，用于在回调中使用。
注入技术
qq_41071646的博客
01-08 998
本博客代码 均来自 windows黑客编程技术详解 这章我还是看了好久 而且我在windows10下成功运行但是没有弹出来窗口 不知道怎么回事   但是注入是成功的   那么我还是看了看这章的内容 全局钩子的注入 其实也就是利用了微软提供的钩子函数 这里 的函数是 setwindowshookex  这个函数 第一个参数是 钩子类型 第二个是 钩子程序的指针  也就是我们提供钩子函数的地方...
Win10_X64远线程注入dll(非CreateRemoteThread)
Anansi的博客
09-27 3268
谈到远线程注入，首先肯定会想到使用CreateRemoteThread，但这个API无法对系统进程进行注入，而且根据我个人的验证发现这个函数在win10下也无法正常将dll注入进记事本进程（淦！）。好在在我的不懈努力的百度、google下发现了另一种思路，那就是使用ZwCreateThread这个内核API，CreateRemoteThread在底层也调用了这个API，CreateRemoteThread底层会调用内核函数ZwCreateThreadEx，而系统调用此函数时，如果发现是系统进程，会把函数的第
win10_x64下shellcode提权工具(SYSTEM权限)
Anansi的博客
11-22 3682
之前写过一篇远线程注入与一篇shellcode编写的文章： Win10_X64远线程注入dll(非CreateRemoteThread) Windows 10_X64环境shellcode编写 上一次是通过远线程注入，将指定的dll模块加载进我们指定的进程，这一次将我们写好的shellcode注入进指定的进程，从而执行任意代码。 首先我们要清楚如何获取一个具有system权限的cmd，想要获取一个具有system权限的cmd，首先这个cmd得是一个具有system权限进程的子进程，windows下具有sys
关于进程劫持注入的一点分析与思考
輚至消亡
04-03 2660
1. 劫持进程实现注入 今天我尝试对win10 x64上的计算器进程进行进程劫持注入。 劫持进程实现注入要执行如下步骤: 以挂起方式启动目标进程 采用其他注入方式将DLL注入目标进程 继续目标进程的主线程使目标进程继续运行 这种注入方式的优点: 被注入的进程来不及做任何防御就会被注入。 因为以挂起方式启动进程，该进程的地址空间内除了目标进程的exe模块和ntdll.dll模块外 还来不及解析导入表将所需dll全部导入，也就是说作为防护的dll模块或者线程可能也来不及导入和执行，这大大提高了注入
利用输入法注入DLL
05-19
好了，利用输入法来注入DLL基本上就是这样了，详细的用法大家可以看压缩包中的第8个文 件夹，其中服务输入法是VC写的，控制程序是VB的，代码都是有注释的。测试发现该方法能 过目前所有杀软，也能注入冰刃。当然...
【安全技术】关于几种dll注入方式的学习
HBohan的博客
10-11 1171
何为dll注入 DLL注入技术，一般来讲是向一个正在运行的进程插入/注入代码的过程。我们注入的代码以动态链接库（DLL）的形式存在。DLL文件在运行时将按需加载（类似于UNIX系统中的共享库(share object，扩展名为.so)）。然而实际上，我们可以以其他的多种形式注入代码（正如恶意软件中所常见的，任意PE文件，shellcode代码/程序集等）。 全局钩子注入 在Windows大部分应用都是基于消息机制，他们都拥有一个消息过程函数，根据不同消息完成不同功能，windows通过钩子机制来截获和监视.
内核线程注入x64
11-22
内核线程注入是一种高级的系统编程技术，主要用于在操作系统内核层面对进程进行操作，例如注入DLL（动态链接库）或执行特定的ShellCode。本文将深入探讨在64位Windows 7环境下，如何利用驱动程序实现内核线程注入。 ...
Win10远程线程注入DLL源码.zip
11-30
原理跟32位进程注入没太大区别，首先获取ntdll下的RtlInitUnicodeString，LdrLoadDll，NtCreateThreadEx地址，最后分配内存写入Code数据创建远程线程跑起来！
驱动无模块注入1.zip
06-23
这可能包括使用 ZwCreateThreadEx 或者 NtQueueApc 这样的函数来创建或注入线程，或者利用内存操作函数读写目标进程的内存空间。 "Inject.sln" 文件很可能是该技术的Visual Studio解决方案文件，用于编译和调试驱动...
安全之路 —— 利用内核函数实现注入系统进程
dengdao1372的博客
03-26 413
简介 在之前的文章中曾说过利用CreateRemoteThread函数进行远线程注入是最经典的一种方式。但是这种方式却无法成功注入系统进程，因为系统进程是处在SESSION0高权限级别的会话层，用户进程在执行CreateRemoteThread函数时会失败。所以经过前辈们的研究发现，CreateRemoteThread底层会调用内核函数ZwCreateThreadEx，而系统调用此函数...
如何控制企业微信
热门推荐
weixin_44678558的博客
12-26 2万+
在GitHub上有一个项目叫《vworkApi》它是基于PC端的企业微信HOOK封装的、REST风格的接口，开发者可通过。可进行二次开发，实现微信机器人、群管理等强大的功能！
InjectDllTool：动态注入DLL的高效工具
gitblog_00072的博客
04-04 1440
InjectDllTool：动态注入DLL的高效工具 去发现同类优质开源项目:https://gitcode.com/ **** 是一款轻量级、易于使用的开源工具，主要用于在运行中的Windows进程中动态地注入和卸载DLL文件。这个项目的目的是帮助开发者、安全研究人员以及系统管理员进行代码调试、性能测试或系统级别的探索与优化。 技术解析 InjectDllTool是用C++语言编写的，利用了Wi...
2024年最新的Python操控企业微信教程
weixin_44678558的博客
01-15 6197
在GitHub上有一个项目叫《vworkApi》它是基于PC端的企业微信HOOK封装的、REST风格的接口，开发者可通过。可进行二次开发，实现微信机器人、群管理等强大的功能！
关于dll注入方式的学习（突破session 0的远程线程注入）
2201_75856701的博客
03-02 376
举个RING权限的最简单的例子：一个停止响应的应用程式，它运行在比RING0更低的指令环上，你不必大费周章的想着如何使系统回复运作，这期间，只需要启动任务管理器便能轻松终止它，因为它运行在比程式更低的RING0指令环中，拥有更高的权限，可以直接影响到RING0以上运行的程序，当然有利就有弊，RING保证了系统稳定运行的同时，也产生了一些十分麻烦的问题。比如一些OS虚拟化技术，在处理RING指令环时便遇到了麻烦，系统是运行在RING0指令环上的，但是虚拟的OS毕竟也是一个系统，也需要与系统相匹配的权限。
深入理解 ZwCreateFile
zacklin的专栏
04-16 8332
前言： 任何编码的东西必须充分的了解规则！ 我试探性的搜索了下关于这个native api的相关的问题，很郁闷的发现，这些问题90%都是没有真正理解了这个函数导致的！ 有的人连函数干嘛的都不知道就着急的写驱动，真是不可一世！所谓兼收并蓄为的是厚积薄发，其间如履薄冰。说的很贴切！ 对此我一直支持achills师傅的思想！搞明白了最基本的和必须的东西，一切后续的东西迎刃而解！ 这个文章我没有
Stream API
最新发布
m0_73837751的博客
11-13 1182
Stream API是 Java 8 引入的一个用于操作集合数据的框架。它并不是数据的存储结构，而是一个高效的数据处理工具。Stream 提供了一种声明式、链式的方式，让我们能够对集合、数组等数据进行过滤、映射、排序、聚合等一系列复杂操作，并支持并行处理。核心特点：声明式代码：通过链式操作替代繁琐的循环，使代码更加简洁。延迟执行：Stream 的中间操作不会立即执行，而是在需要结果时（终端操作）才会触发整个链式操作。并行处理：利用多核 CPU 的优势进行并行处理，大大提升数据处理的效率。
Windows远程注入DLL技术详解
"远程注入DLL技术，用于在其他进程中加载并执行自定义的DLL文件，以达到隐蔽执行代码的目的。该技术涉及多个Windows API函数，包括CreateRemoteThread、LoadLibrary和DllMain等。" 远程注入DLL是一种高级的编程技术...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

涟幽516

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值