wow32注入64位进程

最新推荐文章于 2024-09-04 17:03:22 发布
最新推荐文章于 2024-09-04 17:03:22 发布
阅读量1.9k 收藏 3
点赞数 2
分类专栏： 软件调试

转载地址：http://www.cnblogs.com/lanrenxinxin/p/4821152.html


在之前写注入都是32位exe文件注入32位dll到32位exe文件中，或者都是64位。但是之前看到关于32位进程注入64位进程的方法，将学习笔记记录下来。

之前的文章：注入小结

我们需要借助GitHub上的开源库rewolf-wow64ext 这个库的目的就是让运行在Wow64环境中的x86应用程序可以直接调用x64下ntdll.dll中的Native API。通过这个开源项目我们大致可以知道：

    ①在x64下的进程，不管是32位或者是64位，实际上都映射了两个地址空间，一个是32位，一个是64位。相当于一个进程的两种工作模式，而且这两种工作模式是可以进行切换的;

    ②Wow64进程中的r12寄存器指向64位的TEB结构(TEB64);

    ③每个32位进程都会加重ntdll32.dll和ntdll.dll模块。其中ntdll.dll是64位模块，我们可以将进程的32位模式改为64位模式，然后再去操作64位进程。

新增：

原因：

32位进程难以注入DLL进64位进程是由于两个进程内LoadLibrary的地址不同，32位进程无法知道64位进程的LoadLibrary函数地址。使用wow64ext这个库在Wow64环境下可以让32位进程获取到64位的ntdll.dll的导出函数（得到的地址与64进程的地址是一样的）。


具体的操作：

    ① 进程的32位模式改成64位模式

#define X64_Start() X64_Start_with_CS(0x33)
#define X64_End() X64_End_with_CS(0x23)

 在wow64ext中对x64 api进程调用时，使用X64_Start_with_CS(0x33)设置进程的'运行模式"为64位。

复制代码 
#define EMIT(a) __asm __emit (a)

#define X64_Start_with_CS(_cs) \
    { \
    EMIT(0x6A) EMIT(_cs)                         /*  push   _cs             */ \
    EMIT(0xE8) EMIT(0) EMIT(0) EMIT(0) EMIT(0)   /*  call   $+5             */ \
    EMIT(0x83) EMIT(4) EMIT(0x24) EMIT(5)        /*  add    dword [esp], 5  */ \
    EMIT(0xCB)                                   /*  retf                   */ \
    }

#define X64_End_with_CS(_cs) \
    { \
    EMIT(0xE8) EMIT(0) EMIT(0) EMIT(0) EMIT(0)                                 /*  call   $+5                   */ \
    EMIT(0xC7) EMIT(0x44) EMIT(0x24) EMIT(4) EMIT(_cs) EMIT(0) EMIT(0) EMIT(0) /*  mov    dword [rsp + 4], _cs  */ \
    EMIT(0x83) EMIT(4) EMIT(0x24) EMIT(0xD)                                    /*  add    dword [rsp], 0xD      */ \
    EMIT(0xCB)                                                                 /*  retf                         */ \
    }
复制代码

可以看到主要是借助retf将CS寄存器的值设置为0x33。这里提一下题外话，可以百度一下ret，iret和retf三者之间的区别。

②获得目标函数所在模块(ntdll.dll)在x64模式下的加载基地址：

复制代码 
#define X64_Push(r) EMIT(0x48 | ((r) >> 3)) EMIT(0x50 | ((r) & 7))

DWORD64 getTEB64()
{
    reg64 reg;
    reg.v = 0;   
    X64_Start();
    // R12 register should always contain pointer to TEB64 in WoW64 processes
    X64_Push(_R12);
    // below pop will pop QWORD from stack, as we're in x64 mode now
    __asm pop reg.dw[0]
    X64_End();
    return reg.v;
}
复制代码

关于TEB的获得是通过r12-->TEB64--->PEB--->LDR匹配到ntdll.dll来找到ntdll.dll的加载基地址。

③解析PE结构找到目标函数在"x64模式"下的真实地址(GetProcAddr())。

④通过函数地址调用"x64模式"下的目标函数。这里要注意x64函数调用约定的改变，前4个参数通过rcx,rdx,r8,r9来传递，之后通过堆栈传递。X64Call()已经封装好了。

接下来我们可以开始实际的工作了。

复制代码 
NTSTATUS
NTAPI
RtlCreateUserThread(
    _In_ HANDLE processHandle,
    _In_ SECURITY_DESCRIPTOR* securityDescriptor,
    _In_ BOOLEAN createSuspended,
    _In_ ULONG stackZeroBits,
    _Inout_opt_ size_t* stackReserved,
    _Inout_opt_ size_t* stackCommit,
    _In_ const void* startAddress,
    _In_ void* startParameter,
    _Inout_ HANDLE* threadHandle,
    _Inout_opt_ CLIENT_ID* clientID
    );
复制代码
复制代码 
NTSTATUS
NTAPI
LdrLoadDll(
    _In_opt_ PWSTR SearchPath,
    _In_opt_ PULONG LoadFlags,
    _In_ PUNICODE_STRING Name,
    _Out_opt_ PVOID *BaseAddress
    );
复制代码 
VOID
NTAPI
RtlExitUserThread(
    _In_ NTSTATUS Status
    );

不同于之前利用CreateRemoteThread()来创建线程。因为CreateRemoteThread()是由Kernel32.dll导出的，wow64ext这个库只针对ntdll.dll(同理LoadLibrary也不能调用)。所以采用ntdll中未文档化的RtlCreateUserThread()来创建远程线程，LdrLoadDll()加载dll，在远程线程中调用RtlExitUserThread()终止远程线程。

复制代码 
// Wow64Injectx64.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Wow64Injectx64.h"
#include <memory>
#include <string>
#include <Windows.h>
#include "wow64ext.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#pragma comment(lib,"wow64ext.lib")

// 唯一的应用程序对象
CWinApp theApp;

using namespace std;

typedef struct _UNICODE_STRING {
    USHORT    Length;     //UNICODE占用的内存字节数，个数*2；
    USHORT      MaximumLength; 
    DWORD64   Buffer;     //注意这里指针的问题
} UNICODE_STRING ,*PUNICODE_STRING;



unsigned char shell_code[] = {
    0x48, 0x89, 0x4c, 0x24, 0x08,                               // mov       qword ptr [rsp+8],rcx 
    0x57,                                                       // push      rdi
    0x48, 0x83, 0xec, 0x20,                                     // sub       rsp,20h
    0x48, 0x8b, 0xfc,                                           // mov       rdi,rsp
    0xb9, 0x08, 0x00, 0x00, 0x00,                               // mov       ecx,8
    0xb8, 0xcc, 0xcc, 0xcc, 0xcc,                               // mov       eac,0CCCCCCCCh
    0xf3, 0xab,                                                 // rep stos  dword ptr [rdi]
    0x48, 0x8b, 0x4c, 0x24, 0x30,                               // mov       rcx,qword ptr [__formal]
    0x49, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       r9,0  //PVOID*  BaseAddr opt
    0x49, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       r8,0  //PUNICODE_STRING Name
    0x48, 0xba, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       rdx,0
    0x48, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       rcx,0
    0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       rax,0 
    0xff, 0xd0,                                                 // call      rax   LdrLoadDll
    0x48, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       rcx,0
    0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov       rax,0
    0xff, 0xd0                                                  // call      rax
};


enum  InjectResult{
    OK,
    Error_NoSuchFile,
    Error_OpenProcess,
    Error_VirtualAllocEx,
    Error_GetProcAddress,
    Error_WriteProcessMemory,
    Error_CreateRemoteThread
};


InjectResult Wow64Injectx64(DWORD processid,const TCHAR* file_path);

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    cout<<"查看要注入进程的ID"<<endl;   
    ULONG_PTR ProcessID = 0;
    
    printf("Input ProcessID\r\n");
    cin>>ProcessID;
    WCHAR file_path[] = L"E:\\Messagebox.dll";

    
    if (OK==Wow64Injectx64(ProcessID,file_path))
    {
        printf("Inject Success!\n");
    }
    return 0;
}


InjectResult Wow64Injectx64(DWORD processid,const TCHAR* file_path)
{
    
    if (!PathFileExists(file_path))
    {
        return Error_NoSuchFile;
    }

    HANDLE handle = OpenProcess(PROCESS_ALL_ACCESS,FALSE,processid);
    if (INVALID_HANDLE_VALUE == handle)
    {
        return Error_OpenProcess;
    }

    size_t file_path_mem_length = (size_t)::_tcslen(file_path);
    size_t paramemter_size = (file_path_mem_length+1)*sizeof(TCHAR) + sizeof(UNICODE_STRING) + sizeof(DWORD64);
    DWORD64 paramemter_mem_addr = (DWORD64)VirtualAllocEx64(handle,NULL,paramemter_size,MEM_COMMIT,PAGE_READWRITE);
    DWORD64  shell_code_addr = (DWORD64)VirtualAllocEx64(handle,NULL,sizeof(shell_code),MEM_COMMIT,PAGE_EXECUTE_READWRITE);
    if ((!paramemter_mem_addr) || (!shell_code_addr))
    {
        return Error_VirtualAllocEx;
    }
    
    char * paramemter_mem_local = new char[paramemter_size];
    memset(paramemter_mem_local,0,paramemter_size);

    PUNICODE_STRING ptr_unicode_string = (PUNICODE_STRING)(paramemter_mem_local + sizeof(DWORD64));
    ptr_unicode_string->Length = file_path_mem_length;
    ptr_unicode_string->MaximumLength = file_path_mem_length*2;
    wcscpy((WCHAR*)(ptr_unicode_string+1),file_path);
    ptr_unicode_string->Buffer = (DWORD64)((char*)paramemter_mem_addr+sizeof(DWORD64)+sizeof(UNICODE_STRING));

    DWORD64 ntdll64 = GetModuleHandle64(L"ntdll.dll");
    DWORD64 ntdll_LdrLoadDll = GetProcAddress64(ntdll64,"LdrLoadDll");
    DWORD64 ntdll_RtlCreateUserThread = GetProcAddress64(ntdll64,"RtlCreateUserThread");
    DWORD64 ntdll_RtlExitThread = GetProcAddress64(ntdll64,"RtlExitUserThread");
    if (NULL == ntdll_LdrLoadDll || NULL==ntdll_RtlCreateUserThread || NULL==ntdll_RtlExitThread)
    {
        return Error_GetProcAddress;
    }

    //r9
    memcpy(shell_code+32,&paramemter_mem_addr,sizeof(DWORD64));

    //r8
    DWORD64 ptr = paramemter_mem_addr+sizeof(DWORD64);
    memcpy(shell_code+42,&ptr,sizeof(PUNICODE_STRING));

    //LdrLoaddll
    memcpy(shell_code+72,&ntdll_LdrLoadDll,sizeof(DWORD64));

    //RtlExitUserThread
    memcpy(shell_code+94,&ntdll_RtlExitThread,sizeof(DWORD64));
    size_t write_size = 0;
    if (!WriteProcessMemory64(handle,paramemter_mem_addr,paramemter_mem_local,paramemter_size,NULL) ||
        !WriteProcessMemory64(handle,shell_code_addr,shell_code,sizeof(shell_code),NULL))
    {
        return Error_WriteProcessMemory;
    }
    DWORD64 hRemoteThread = 0;
    struct {
        DWORD64 UniqueProcess;
        DWORD64 UniqueThread;
    } client_id;
    int a = X64Call(ntdll_RtlCreateUserThread,10,
        (DWORD64)handle,                    // ProcessHandle
        (DWORD64)NULL,                      // SecurityDescriptor
        (DWORD64)FALSE,                     // CreateSuspended
        (DWORD64)0,                         // StackZeroBits
        (DWORD64)NULL,                      // StackReserved
        (DWORD64)NULL,                      // StackCommit
        shell_code_addr,                    // StartAddress
        (DWORD64)NULL,                      // StartParameter
        (DWORD64)&hRemoteThread,            // ThreadHandle
        (DWORD64)&client_id);               // ClientID)
    if (INVALID_HANDLE_VALUE == (HANDLE)hRemoteThread)
    {
        return Error_CreateRemoteThread;
    }
    return OK;
}
复制代码

 

完整Demo地址：https://github.com/ChengChengCC/Ark-tools/tree/master/Wow64Injectx64

 

关于Windows x64的学习，《Windows Internals》（中文译版《深入解析Windows操作系统》，潘老师译的）不错。顺便吐槽下学校把那么多的好书都放在阅览室，只能看，不能借，好多全新的书上都是灰！


32位注入32位 64位注入64位进程代码如下：

	HANDLE hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, FALSE, nPID);

	if (hProcess != NULL)
	{
		HANDLE hThread;
		WCHAR   szLibPath[_MAX_PATH] = {0};
		WCHAR   szReadLibPath[_MAX_PATH] = {0};
		void*  pLibRemote = 0;
		DWORD  hLibModule = 0;

		HMODULE hKernel32 = ::GetModuleHandle(L"Kernel32");

		if (!::GetSystemDirectory(szLibPath, _MAX_PATH))
			return FALSE;

		wcscat(szLibPath, L"\\test.dll");

		pLibRemote = ::VirtualAllocEx(hProcess, NULL, sizeof(szLibPath), MEM_COMMIT, PAGE_READWRITE);

		if (pLibRemote == NULL)
			return FALSE;

		::WriteProcessMemory(hProcess, pLibRemote, (void*)szLibPath, wcslen(szLibPath)*sizeof(WCHAR), NULL);
		//::ReadProcessMemory(hProcess, pLibRemote, (void*)szReadLibPath, wcslen(szLibPath)*sizeof(WCHAR), NULL);

		LPTHREAD_START_ROUTINE LoadLibAddr = (LPTHREAD_START_ROUTINE)GetProcAddress(hKernel32, "LoadLibraryW");

		hThread = ::CreateRemoteThread(hProcess, NULL, 0,
			LoadLibAddr,
			pLibRemote, 0, NULL);

		if (hThread != NULL)
		{
			::WaitForSingleObject(hThread, INFINITE);
			::GetExitCodeThread(hThread, &hLibModule);
			::CloseHandle(hThread);
		}


	}



iihacker_cat
关注
专栏目录
用TortoiseGit工具push上传程序和下拉程序pull
luopeng12345的博客
11-20 673
首先git commit 上面写你些改的地方。下面把.c和.h文件留下，其他文件不勾选。对应图片 然后TortoiseGit里面找到pageant加载密钥，然后回到要上传的文件，点击push即可
X32进程注入x64DLL到x64进程
被遗弃的庸才博客
12-16 1727
在x32程序中获得x64函数地址是找到这个项目，之后根据自己的理解稍微改了改代码，测试之后能够正常的注入，代码如下 #include "stdafx.h" #include "x32Injectx64.h" #include <Windows.h> #include "wow64ext.h" #pragma comment(lib,"wow64ext.lib") CWinApp...
32位程序调用64位函数————开源代码rewolf-wow64ext学习笔记
weixin_30636089的博客
01-07 697
rewolf-wow64ext的目的就是让运行在Wow64环境中的x86应用程序可以直接调用x64下ntdll.dll中的Native API。 学习中可以得到几个结论 在X64环境下的进程，32位程序，映射了两个地址空间，一个32位，一个64位。而且这两种工作模式是可以切换的的。 WOW64进程中的R12寄存器指向其64位的TEB结构（线程环境块）。 我们可以将进程的32位模式...
Wow64（32位进程）注入DLL到64位进程
jiangqin115的专栏
07-04 5941
http://blog.poxiao.me/p/wow64-process-inject-dll-into-x64-process/#Wow64环境下32位进程注入64位进程 DLL注入 向其他进程注入DLL通常的做法是通过调用CreateRemoteThread这个API在目标进程内创建一个远程线程，用这个线程来调用LoadLibraryA或LoadLibraryW（下文统称Load
修复wow64cpu.dll缺失或损坏导致的程序启动失败
最新发布
czl922的博客
09-04 511
确保下载的DLL文件来源可信，以避免潜在的安全风险。但请注意，并非所有DLL文件都需要注册，且wow64cpu.dll作为系统文件，通常不需要手动注册。：点击“开始”菜单，输入“cmd”，在搜索结果中右键点击“命令提示符”，选择“以管理员身份运行”。对于不熟悉手动操作的用户，可以使用第三方DLL修复工具来自动检测和修复缺失或损坏的DLL文件。：点击“一键修复”按钮，工具将自动下载并替换缺失的DLL文件，或者修复损坏的文件。：打开工具后，按照提示进行系统扫描，工具会自动检测并列出缺失或损坏的DLL文件。
32位程序注入64位DLL到64位进程
weixin_30588907的博客
06-16 1941
向其它进程注入DLL通常的做法是通过调用CreateRemoteThread这个API在目标进程内创建一个远程线程。用这个线程来调用LoadLibraryA或LoadLibraryW（下文统称LoadLibrary）以实现让目标进程载入指定的DLL文件。使用CreateRemoteThread创建一个远程线程须要传入一个线程过程函数的地址，而且这个函数地址是须要在目标进程中有效的...
32位dll转64位工具_32位和64位操作系统之间的区别
weixin_39787089的博客
11-20 1097
在计算中，存在两种类型的处理器，即32位和64位。 这些处理器告诉我们处理器可以从CPU寄存器访问多少内存。一个32位系统可以访问232( 232 )个内存地址，即4GB的RAM或物理内存。一个64位系统可以访问264( 264 )个内存地址，也就是说，实际上是180亿(18-Quintillion)GB的RAM。简而言之，任何大于4GB的内存都可以很容易地被它处理。在1990年代和2000年代初...
32位进程注入64位进程和32位进程.zip_32注入64_64 注入_64位注入_process inject_进程注入
07-14
2. **64位注入32位进程**：相对而言，64位进程可以更容易地注入32位进程，因为64位系统完全支持32位代码执行。同样，可以使用DLL注入方法，创建64位DLL并将其注入到32位进程中。然而，需要注意的是，64位代码不能...
32位进程枚举64位进程模块信息
06-02
' WOW64的32位程序其实拥有64位程序的全部功能,包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等....' 因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程,只是自己以为是32...
dll.rar_64位 注入_64位进程_DLL注入 64位_注入 64
09-23
描述中的“32位进程注入64位进程和32位进程”指出，该主题不仅涉及64位环境下的DLL注入，还涵盖了跨架构注入，即32位进程向64位进程注入代码的情况。由于32位和64位系统之间的兼容性问题，这种跨架构注入更为复杂。...
InjectCode:远程线程注入DLL库，支持windows 32位和64位平台
06-26
注入代码 InjectCode 项目是一个支持 Windows 32 位和 64 位 DLL 远程线程注入库。 测试平台 视窗 8 x64 视窗 8 x32 视窗 7 SP1 x64 视窗 7 SP1 x32 视窗 2008 R2 视窗 2003 SP2 x64 视窗 2003 SP2 x32 Windows XP SP2 x64 Windows XP SP2 x32 工作原理 步骤 1. 通过进程名称查找目标进程。 step 2. 查找先后注入的进程。 setp 3.判断程序是否可以注入中位数。 setp 4. 创建一个远程线程将注入到目标进程的dll。
32bit程序调用64bit dll解决办法的例子程序
04-09
32bit程序调用64bit dll 的解决办法 32bit程序不能直接调用64bit的dll，我们采用COM进程外组件的方式来实现间接调用。具体参考： http://blog.csdn.net/shakesky/article/details/23265811
易语言-易语言目前最快的JSON解析 simdjson
06-25
今天更新一下, 解决之前贴子中提到的一些问题: 1. 封装了几个自定义的函数, 例如 move_to_root, array_get_length, array_move_to_index, 这样可以少调用一些 X64Call; 2. 简单实现了对于类似 [0].A.B[0].C 的路径的解析取值. 接下来说一下遇到的问题和一些体验: 1. 我构造的测试数据大小是大约是 96MB, 在我的机器上可以正常解析, 再大一些(例如 128MB)会崩溃, 崩溃位于 ParsedJson.allocateCapacity , 琢磨了下没琢磨明白 (温馨提示: 真要是这种大小级别了还是建议各位用 SAX 方式); 2. 除了上面这点, 还有个已知的比较隐蔽 BUG, 貌似是 print_ 这个函数的锅: 静态编译之后, 在 demo 中如果 print_ 递归打印了一个 Object 例如 [0], 再点击解析就会在 iterator_free 崩溃. 如果只是取值就不崩溃. 3. 这个库会拷贝数据, 在针对过长的数据的时候这不是好做法, 感觉这个库更像是科研性质, 和那些千锤百炼的老牌库相比, 目前可能只有速度占优势了; 4. 机器或者其它方面的限制, 我用易语言跑不出宣传文章中的千兆字节每秒, 不过几百 MB/s 还是有的; 5. 由于解析的时候它会拷贝数据, 我不清楚有没有可能会产生 64-bit 的内存地址, 暂时就是指针到文本当 32-bit 用, 但心里很没底, 希望 eWOW64Ext 作者有空可以帮忙看一下... @shier2817  谢谢! 6. 库用的是 10.0.17134.0 版本的 SDK /MT 编译的, 但已经无法支持 WindowXP, 低版本的 SDK 编译不过去, 对这些指令不熟悉所以没有去探究原因(也许就是不支持, 详情请翻阅 MSDN); 7. 关于编译模式: 用 MinSizeRel 生成的话, 会导致 double 取值异常, 具体原因未深究, 所以默认使用了 Release . 我将会在附件中附上三种编译模式生成的文件供各位研究: RelWithDebInfo, MinSizeRel, Release; 8. 我对于 WOW64Ext 方面的知识不了解, 所以无法保证代码的稳定性, 抛砖引玉, 所以如果你希望封装完整的模块和工具, 可以进群与我交流.
32位进程调用64位DLL函数.rar
04-03
32位进程调用64位DLL函数.rar
易语言-32位进程枚举64位进程模块信息
06-29
' WOW64的32位程序其实拥有64位程序的全部功能,包括32注入64位、枚举64位进程模块、Hook64位模块、调用64位API等等等等.... ' 因为WOW64程序不是完全的虚拟化的，是伪虚拟化，本身就是一个64位进程,只是自己以为是32...
CreateRemoteThread:从32位进程到64位进程
04-17
《CreateRemoteThread：跨越32位与64位进程的深度探索》 在Windows操作系统中，进程间的通信和控制是一项重要的技术，其中`CreateRemoteThread`函数是实现这一功能的关键工具之一。它允许一个进程在另一个进程中...
易语言32位dll注入到64位程序_ENVI5.3和IDL8.5安装教程（内含安装程序）
weixin_39793105的博客
12-01 745
最近因为用到了一些国外的IDL程序，程序运行环境是IDL8.5,所以就整理一下安装过程和资源，发现资源实在是难找。5.5的试用方法也有，但是激活时灵时不灵的。就先用着5.3吧。下载的资源我放在公众号里了，可以去下载。本着交流学习的目的。如果涉及到侵权，联系我，我会第一时间开始最近因为用到了一些国外的IDL程序，程序运行环境是IDL8.5,所以就整理一下安装过程和资源，发现资源实在是难找。5.5的试...
32位dll注入64位进程
03-30
很抱歉，我是AI语言模型，无法提供恰当的答案。但是，我可以向您提供以下信息： 在32位DLL注入64位进程方面，需要使用一些特殊的技术和工具。这是因为32位和64位进程具有不同的内存结构和处理方式。以下是一些可能有用的资源： 1. Wow64DisableWow64FsRedirection和Wow64RevertWow64FsRedirection函数 - 这些函数可用于禁用和启用Windows 32位应用程序文件系统重定向，以便在64位进程中加载32位DLL。 2. CreateRemoteThreadEx函数 - 这个函数可以用来在64位进程的上下文中创建一个新的线程，并在其中载入32位DLL。 3. 使用第三方工具 - 一些工具，如Injector、Process Hacker和NtCreateThreadEx等，可用于注入32位DLL到64位进程中。 需要注意的是，这种操作可能不受支持，而且可能导致系统不稳定。因此，应该谨慎地使用这些技术和工具，并确保对其进行彻底的测试和验证。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值