看流星社区

 找回密码
 注册账号
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
赞助广告位 请点击这里联系站长 QQ20209081
赞助广告位 请点击这里联系站长 QQ20209081
赞助广告位 请点击这里联系站长 QQ20209081
查看: 157|回复: 0

C++ X64X86通用驱动读写API源码

[复制链接]
发表于 2019-9-10 14:18:55 | 显示全部楼层 |阅读模式



  1. //#include  <windows.h>
  2. //#include <algorithm>  
  3. //#include <string.h>
  4. //#include <iostream>
  5. //#include"tlhelp32.h"
  6. //#include <Psapi.h>
  7. //#include<ntstatus.h>
  8. //#include "xxxx.h"

  9. #include "pch.h"

  10. //==================================X64常用内存读写库==========================

  11. DWORD GetModuleSizeX64(DWORD Pid, const TCHAR* ModuleName)//获取模块大小,只能搞64位=64位,32位无法对64位操作
  12. {
  13.          /*初始化DLL列表*/
  14.          HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, Pid);
  15.          if (hProcess == INVALID_HANDLE_VALUE || !hProcess)return NULL;
  16.          DWORD dwBuffSize = 0;
  17.          BOOL bRet = EnumProcessModulesEx(hProcess, NULL, 0, &dwBuffSize, LIST_MODULES_ALL);
  18.          HMODULE * pModuleHandlerArr = (HMODULE*) new char[dwBuffSize];
  19.          bRet = EnumProcessModulesEx(hProcess, pModuleHandlerArr, dwBuffSize, &dwBuffSize, LIST_MODULES_ALL);
  20.          // 模块名称
  21.         TCHAR szModuleName[MAX_PATH];
  22.          TCHAR szBaseName[MAX_PATH];//新建
  23.         // 保存模块信息
  24.         MODULEINFO stcModuleInfo = { 0 };
  25.          // 遍历模块列表
  26.         int nCount = dwBuffSize / sizeof(HMODULE);
  27.          for (int i = 0; i < nCount; ++i)
  28.          {
  29.                  // 根据进程句柄和模块句柄,获取模块信息
  30.                 GetModuleInformation(hProcess, pModuleHandlerArr, &stcModuleInfo, sizeof(stcModuleInfo));
  31.                  GetModuleBaseNameA(hProcess, pModuleHandlerArr, szBaseName, MAX_PATH);
  32.                  //printf("\n%x\n", (DWORD)stcModuleInfo.SizeOfImage); //模块内存大小
  33.                 if (strcmp(szBaseName, ModuleName) == 0)
  34.                  {
  35.                         delete[] pModuleHandlerArr;// 释放数组
  36.                         pModuleHandlerArr = nullptr;
  37.                         return  stcModuleInfo.SizeOfImage;
  38.                  }
  39.          }
  40.          return NULL;
  41. }

  42. HMODULE GetModuleBaseX64(DWORD Pid, const TCHAR* ModuleName)
  43. {/*初始化DLL列表*/ // 这个程序不能删除,基础功能

  44.         HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, Pid);
  45.          if (hProcess == INVALID_HANDLE_VALUE || !hProcess)return NULL;

  46.          DWORD dwBuffSize = 0;
  47.          BOOL bRet = EnumProcessModulesEx(hProcess, NULL, 0, &dwBuffSize, LIST_MODULES_ALL);
  48.          HMODULE * pModuleHandlerArr = (HMODULE*) new char[dwBuffSize];

  49.          bRet = EnumProcessModulesEx(hProcess, pModuleHandlerArr, dwBuffSize, &dwBuffSize, LIST_MODULES_ALL);

  50.          // 模块名称
  51.         TCHAR szModuleName[MAX_PATH];
  52.          TCHAR szBaseName[MAX_PATH];//新建
  53.         // 保存模块信息
  54.         MODULEINFO stcModuleInfo = { 0 };
  55.          // 遍历模块列表
  56.         int nCount = dwBuffSize / sizeof(HMODULE);
  57.          for (int i = 0; i < nCount; ++i)
  58.          {
  59.                  // 根据进程句柄和模块句柄,获取模块信息
  60.                 GetModuleInformation(hProcess, pModuleHandlerArr, &stcModuleInfo, sizeof(stcModuleInfo));

  61.                  // 根据进程句柄和模块句柄,获取模块的路径(包括模块名)
  62.                  //GetModuleFileNameEx(hProcess, pModuleHandlerArr, szModuleName, MAX_PATH); //获取模块的路径
  63.                 GetModuleBaseNameA(hProcess, pModuleHandlerArr, szBaseName, MAX_PATH);
  64.                  printf("\n%x\n", (DWORD)stcModuleInfo.lpBaseOfDll); //获取模块基地址
  65.                 printf("\n%x\n", (DWORD)stcModuleInfo.EntryPoint); //获取模块入口地址
  66.                 printf("\n%x\n", (DWORD)stcModuleInfo.SizeOfImage); //模块内存大小

  67.                 if (strcmp(szBaseName, ModuleName) == 0)
  68.                  {
  69.                          printf("基地址是:%s\n\n", szBaseName);
  70.                          printf("基地址是:%X\n\n", (DWORD)stcModuleInfo.lpBaseOfDll);
  71.                          delete[] pModuleHandlerArr;// 释放数组
  72.                         pModuleHandlerArr = nullptr;
  73.                          return  (HMODULE)stcModuleInfo.lpBaseOfDll;
  74.                  }
  75.                  // 基址
  76.                 //CString szTemp;
  77.                  //szTemp.Format(L"%08X", stcModuleInfo.lpBaseOfDll);

  78.                  //// 入口点
  79.                 //szTemp.Format(L"%08X", stcModuleInfo.EntryPoint);

  80.                  //// 内存大小
  81.                 //szTemp.Format(L"%d", stcModuleInfo.SizeOfImage);

  82.                  //// 模块路径
  83.                 //szModuleName;

  84.          }
  85.          return NULL;
  86. }

  87. HMODULE GetModuleBaseAddr(DWORD Pid, CONST TCHAR* moduleName)//获取进程模块入口地址  1.进程pid  2.模块的名称  xxx.exe 或者xxx.dll
  88. {

  89.          MODULEENTRY32 moduleEntry;  //模块信息的结构体
  90.         HANDLE handle = NULL;
  91.          handle = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, Pid); //  获取进程快照中包含在th32ProcessID中指定的进程的所有的模块
  92.         printf("handle %X \n", (DWORD)handle);
  93.          if (!handle) {                           //handle 类似指针,指向进程模块信息
  94.                 CloseHandle(handle);
  95.                  return NULL;
  96.          }
  97.          ZeroMemory(&moduleEntry, sizeof(MODULEENTRY32)); //清空
  98.         moduleEntry.dwSize = sizeof(MODULEENTRY32);
  99.          if (!Module32First(handle, &moduleEntry)) {  //结果传到 结构体指针moduleEntry
  100.                  CloseHandle(handle);
  101.                  return NULL;
  102.          }
  103.          do {
  104.                  if (strcmp(moduleEntry.szModule, moduleName) == 0) {  //wcscmp宽字节比较  moduleEntry.szModule模块名字
  105.                         //printf("基地址是 %X \n", (DWORD)moduleEntry.hModule);
  106.                          return moduleEntry.hModule; //返回模块入口地址
  107.                 }
  108.          } while (Module32Next(handle, &moduleEntry));
  109.          CloseHandle(handle);
  110.          return 0;
  111. }

  112. BOOL EnableSeDebugPrivilege(IN const CHAR*  PriviledgeName, BOOL IsEnable)
  113. {
  114.          // 打开权限令牌
  115.         HANDLE  ProcessHandle = GetCurrentProcess();
  116.          HANDLE  TokenHandle = NULL;
  117.          TOKEN_PRIVILEGES TokenPrivileges = { 0 };
  118.          if (!OpenProcessToken(ProcessHandle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &TokenHandle))
  119.          {
  120.                  return FALSE;
  121.          }
  122.          LUID                         v1;
  123.          if (!LookupPrivilegeValue(NULL, PriviledgeName, &v1))                // 通过权限名称查找uID
  124.          {
  125.                  CloseHandle(TokenHandle);
  126.                  TokenHandle = NULL;
  127.                  return FALSE;
  128.          }

  129.          TokenPrivileges.PrivilegeCount = 1;                // 要提升的权限个数
  130.         TokenPrivileges.Privileges[0].Attributes = IsEnable == TRUE ? SE_PRIVILEGE_ENABLED : 0;    // 动态数组,数组大小根据Count的数目
  131.         TokenPrivileges.Privileges[0].Luid = v1;
  132.          if (!AdjustTokenPrivileges(TokenHandle, FALSE, &TokenPrivileges,
  133.                  sizeof(TOKEN_PRIVILEGES), NULL, NULL))
  134.          {
  135.                  CloseHandle(TokenHandle);
  136.                  TokenHandle = NULL;
  137.                  return FALSE;
  138.          }
  139.          CloseHandle(TokenHandle);
  140.          TokenHandle = NULL;
  141.          return TRUE;
  142. }

  143. //==============================================x86x64内存读写wow64函数指针获取=====================================================
  144. LPFN_NTWOW64READVIRTUALMEMORY64       __NtWow64ReadVirtualMemory64;
  145. LPFN_NTWOW64WRITEVIRTUALMEMORY64          __NtWow64WriteVirtualMemory64;
  146. BOOL GetNTWOW64MemoryProcAddress()
  147. {
  148.          HMODULE NtdllModuleBase = NULL;
  149.          NtdllModuleBase = GetModuleHandle("Ntdll.dll");
  150.          if (NtdllModuleBase == NULL)
  151.          {
  152.                  return FALSE;
  153.          }
  154.          __NtWow64ReadVirtualMemory64 = (LPFN_NTWOW64READVIRTUALMEMORY64)GetProcAddress(NtdllModuleBase,
  155.                  "NtWow64ReadVirtualMemory64");
  156.          printf("__NtWow64ReadVirtualMemory64  %lx\n", __NtWow64ReadVirtualMemory64);
  157.          __NtWow64WriteVirtualMemory64 = (LPFN_NTWOW64WRITEVIRTUALMEMORY64)GetProcAddress(NtdllModuleBase,
  158.                  "NtWow64WriteVirtualMemory64");
  159.          return         TRUE;
  160. }

  161. char* UTF8ToUnicode(char* szUTF8)//编码转换,已经修复delet释放bug
  162. {
  163.          int wcscLen = MultiByteToWideChar(CP_UTF8, NULL, szUTF8, strlen(szUTF8), NULL, 0);//得到所需空间的大小
  164.         wchar_t wszcString[1024] = { 0 };//这个大小的转换我这里是为了写辅助的。溢出数据自己修改
  165.         MultiByteToWideChar(CP_UTF8, NULL, szUTF8, strlen(szUTF8), wszcString, wcscLen);   //转换
  166.         wszcString[wcscLen] = '\0';
  167.          int len = WideCharToMultiByte(CP_ACP, 0, wszcString, wcslen(wszcString), NULL, 0, NULL, NULL);
  168.          char m_char[1024] = { 0 };//这个大小的转换我这里是为了写辅助的。
  169.         WideCharToMultiByte(CP_ACP, 0, wszcString, wcslen(wszcString), m_char, len, NULL, NULL);
  170.          m_char[len] = '\0';
  171.          return m_char;
  172. }

  173. char* UnicodeToUTF8(wchar_t* wszcString)//编码转换,已经修复 注意内存delet释放bug
  174. {
  175.          int utf8Len = ::WideCharToMultiByte(CP_UTF8, NULL, wszcString, wcslen(wszcString), NULL, 0, NULL, NULL);    //得到所需空间的大小
  176.         char szUTF8[1024] = { 0 };//这个大小的转换我这里是为了写辅助的。
  177.         WideCharToMultiByte(CP_UTF8, NULL, wszcString, wcslen(wszcString), szUTF8, utf8Len, NULL, NULL);    //转换
  178.         szUTF8[utf8Len] = '\0';
  179.          return szUTF8;
  180. }

  181. int Wow64ReadInt(ULONG ProcessID, ULONG64 BaseAddress)
  182. {
  183.          BOOL     IsWow64 = FALSE;
  184.          HANDLE   ProcessHandle = NULL;
  185.          ULONG64  BufferData = NULL;//=====================
  186.          ULONG64  ReturnLen = 4;//默认
  187.         ULONG64  BufferLen = 4;//默认
  188.         if (BaseAddress == NULL)
  189.          {
  190.                  return FALSE;
  191.          }
  192.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  193.          {
  194.                  return FALSE;
  195.          }
  196.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  197.          if (ProcessHandle == NULL)
  198.          {
  199.                  return FALSE;
  200.          }

  201.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  202.          {
  203.                  goto Exit;
  204.          }
  205.          __try
  206.          {
  207.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, BufferLen, &ReturnLen);
  208.                  printf("8字节数据是:%lld\r\n", BufferData);

  209.          }
  210.          __except (EXCEPTION_EXECUTE_HANDLER)
  211.          {
  212.                  printf("异常\r\n");
  213.                  goto Exit;
  214.          }
  215. Exit:
  216.          if (ProcessHandle != NULL)
  217.          {
  218.                  CloseHandle(ProcessHandle);
  219.                  ProcessHandle = NULL;
  220.          }
  221.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  222.          return BufferData;
  223. }

  224. char *  Wow64ReadAscii(ULONG ProcessID, ULONG64 BaseAddress, DWORD Len) //写入ASCII 参数三是长度
  225. {
  226.          BOOL     IsWow64 = FALSE;
  227.          HANDLE   ProcessHandle = NULL;
  228.          char  BufferData[4096] = { 0 };//=====================
  229.          ULONG64  ReturnLen = 4;//默认

  230.         if (BaseAddress == NULL)
  231.          {
  232.                  return FALSE;
  233.          }
  234.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  235.          {
  236.                  return FALSE;
  237.          }
  238.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  239.          if (ProcessHandle == NULL)
  240.          {
  241.                  return FALSE;
  242.          }

  243.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  244.          {
  245.                  goto Exit;
  246.          }
  247.          __try
  248.          {
  249.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, Len, &ReturnLen);

  250.                  printf("字符串是:%s \n", BufferData);
  251.          }
  252.          __except (EXCEPTION_EXECUTE_HANDLER)
  253.          {
  254.                  printf("异常\r\n");
  255.                  goto Exit;
  256.          }
  257. Exit:
  258.          if (ProcessHandle != NULL)
  259.          {
  260.                  CloseHandle(ProcessHandle);
  261.                  ProcessHandle = NULL;
  262.          }
  263.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  264.          return BufferData;
  265. }

  266. wchar_t *  Wow64ReadUnicode(ULONG ProcessID, ULONG64 BaseAddress, DWORD Len) //写入ASCII 参数三是长度
  267. {
  268.          setlocale(LC_ALL, "chs"); // unicode 必加 只有添加这一句下面的打印1,2与调试打印成功
  269.         BOOL     IsWow64 = FALSE;
  270.          HANDLE   ProcessHandle = NULL;
  271.          wchar_t  BufferData[4096] = { 0 };//=====================
  272.          ULONG64  ReturnLen = 4;//默认

  273.         if (BaseAddress == NULL)
  274.          {
  275.                  return FALSE;
  276.          }
  277.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  278.          {
  279.                  return FALSE;
  280.          }
  281.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  282.          if (ProcessHandle == NULL)
  283.          {
  284.                  return FALSE;
  285.          }

  286.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  287.          {
  288.                  goto Exit;
  289.          }
  290.          __try
  291.          {
  292.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, Len * 5, &ReturnLen); //unicode编码要乘以2

  293.                  //printf("字符串是:%s \n", BufferData);
  294.          }
  295.          __except (EXCEPTION_EXECUTE_HANDLER)
  296.          {
  297.                  printf("异常\r\n");
  298.                  goto Exit;
  299.          }
  300. Exit:
  301.          if (ProcessHandle != NULL)
  302.          {
  303.                  CloseHandle(ProcessHandle);
  304.                  ProcessHandle = NULL;
  305.          }
  306.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  307.          return BufferData;
  308. }

  309. float Wow64ReadFloat(ULONG ProcessID, ULONG64 BaseAddress)
  310. {
  311.          BOOL     IsWow64 = FALSE;
  312.          HANDLE   ProcessHandle = NULL;
  313.          FLOAT  BufferData = NULL;//=====================
  314.          ULONG64  ReturnLen = 4;//默认
  315.         ULONG64  BufferLen = 4;//默认
  316.         if (BaseAddress == NULL)
  317.          {
  318.                  return FALSE;
  319.          }
  320.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  321.          {
  322.                  return FALSE;
  323.          }
  324.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  325.          if (ProcessHandle == NULL)
  326.          {
  327.                  return FALSE;
  328.          }

  329.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  330.          {
  331.                  goto Exit;
  332.          }
  333.          __try
  334.          {
  335.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, BufferLen, &ReturnLen);

  336.                  printf("单精度数据是:%f \n", BufferData);
  337.          }
  338.          __except (EXCEPTION_EXECUTE_HANDLER)
  339.          {
  340.                  printf("异常\r\n");
  341.                  goto Exit;
  342.          }
  343. Exit:
  344.          if (ProcessHandle != NULL)
  345.          {
  346.                  CloseHandle(ProcessHandle);
  347.                  ProcessHandle = NULL;
  348.          }
  349.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  350.          return BufferData;
  351. }

  352. double Wow64ReadDouble(ULONG ProcessID, ULONG64 BaseAddress)
  353. {
  354.          BOOL     IsWow64 = FALSE;
  355.          HANDLE   ProcessHandle = NULL;
  356.          DOUBLE  BufferData = NULL;//=====================
  357.          ULONG64  ReturnLen = 8;//默认
  358.         ULONG64  BufferLen = 8;//默认
  359.         if (BaseAddress == NULL)
  360.          {
  361.                  return FALSE;
  362.          }
  363.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  364.          {
  365.                  return FALSE;
  366.          }
  367.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  368.          if (ProcessHandle == NULL)
  369.          {
  370.                  return FALSE;
  371.          }

  372.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  373.          {
  374.                  goto Exit;
  375.          }
  376.          __try
  377.          {
  378.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, BufferLen, &ReturnLen);
  379.                  printf("浮点数数据是:%lf \n", BufferData);
  380.          }
  381.          __except (EXCEPTION_EXECUTE_HANDLER)
  382.          {
  383.                  printf("异常\r\n");
  384.                  goto Exit;
  385.          }
  386. Exit:
  387.          if (ProcessHandle != NULL)
  388.          {
  389.                  CloseHandle(ProcessHandle);
  390.                  ProcessHandle = NULL;
  391.          }
  392.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  393.          return BufferData;
  394. }

  395. LONG64 Wow64ReadInt64(ULONG ProcessID, ULONG64 BaseAddress)
  396. {
  397.          BOOL     IsWow64 = FALSE;
  398.          HANDLE   ProcessHandle = NULL;
  399.          ULONG64  BufferData = NULL;//=====================
  400.          ULONG64  ReturnLen = 8;//默认
  401.         ULONG64  BufferLen = 8;//默认
  402.         if (BaseAddress == NULL)
  403.          {
  404.                  return FALSE;
  405.          }
  406.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  407.          {
  408.                  return FALSE;
  409.          }
  410.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  411.          if (ProcessHandle == NULL)
  412.          {
  413.                  return FALSE;
  414.          }

  415.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  416.          {
  417.                  goto Exit;
  418.          }
  419.          __try
  420.          {
  421.                  NTSTATUS Status = __NtWow64ReadVirtualMemory64(ProcessHandle, BaseAddress, &BufferData, BufferLen, &ReturnLen);
  422.                  printf("8字节数据是:%lld\r\n", BufferData);

  423.          }
  424.          __except (EXCEPTION_EXECUTE_HANDLER)
  425.          {
  426.                  printf("异常\r\n");
  427.                  goto Exit;
  428.          }
  429. Exit:
  430.          if (ProcessHandle != NULL)
  431.          {
  432.                  CloseHandle(ProcessHandle);
  433.                  ProcessHandle = NULL;
  434.          }
  435.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  436.          return BufferData;
  437. }

  438. BOOL Wow64WriteInt(ULONG ProcessID, ULONG64 BaseAddress, INT Value)
  439. {
  440.          BOOL     IsWow64 = FALSE;
  441.          HANDLE   ProcessHandle = NULL;
  442.          ULONG64  ReturnLen = 4;//默认
  443.         ULONG64  BufferLen = 4;//默认
  444.         if (BaseAddress == NULL)
  445.          {
  446.                  return FALSE;
  447.          }
  448.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  449.          {
  450.                  return FALSE;
  451.          }
  452.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  453.          if (ProcessHandle == NULL)
  454.          {
  455.                  return FALSE;
  456.          }
  457.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  458.          {
  459.                  goto Exit;
  460.          }
  461.          __try
  462.          {
  463.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, &Value, BufferLen, &ReturnLen);
  464.          }
  465.          __except (EXCEPTION_EXECUTE_HANDLER)
  466.          {
  467.                  printf("异常\r\n");
  468.                  goto Exit;
  469.          }
  470. Exit:
  471.          if (ProcessHandle != NULL)
  472.          {
  473.                  CloseHandle(ProcessHandle);
  474.                  ProcessHandle = NULL;
  475.          }
  476.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  477.          return TRUE;
  478. }

  479. BOOL Wow64WriteFloat(ULONG ProcessID, ULONG64 BaseAddress, FLOAT Value)
  480. {
  481.          BOOL     IsWow64 = FALSE;
  482.          HANDLE   ProcessHandle = NULL;
  483.          ULONG64  ReturnLen = 4;//默认
  484.         ULONG64  BufferLen = 4;//默认
  485.         if (BaseAddress == NULL)
  486.          {
  487.                  return FALSE;
  488.          }
  489.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  490.          {
  491.                  return FALSE;
  492.          }
  493.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  494.          if (ProcessHandle == NULL)
  495.          {
  496.                  return FALSE;
  497.          }
  498.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  499.          {
  500.                  goto Exit;
  501.          }
  502.          __try
  503.          {
  504.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, &Value, BufferLen, &ReturnLen);
  505.          }
  506.          __except (EXCEPTION_EXECUTE_HANDLER)
  507.          {
  508.                  printf("异常\r\n");
  509.                  goto Exit;
  510.          }
  511. Exit:
  512.          if (ProcessHandle != NULL)
  513.          {
  514.                  CloseHandle(ProcessHandle);
  515.                  ProcessHandle = NULL;
  516.          }
  517.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  518.          return TRUE;
  519. }

  520. BOOL Wow64WriteDouble(ULONG ProcessID, ULONG64 BaseAddress, DOUBLE Value)
  521. {
  522.          BOOL     IsWow64 = FALSE;
  523.          HANDLE   ProcessHandle = NULL;
  524.          ULONG64  ReturnLen = 8;//默认
  525.         ULONG64  BufferLen = 8;//默认
  526.         if (BaseAddress == NULL)
  527.          {
  528.                  return FALSE;
  529.          }
  530.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  531.          {
  532.                  return FALSE;
  533.          }
  534.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  535.          if (ProcessHandle == NULL)
  536.          {
  537.                  return FALSE;
  538.          }
  539.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  540.          {
  541.                  goto Exit;
  542.          }
  543.          __try
  544.          {
  545.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, &Value, BufferLen, &ReturnLen);
  546.          }
  547.          __except (EXCEPTION_EXECUTE_HANDLER)
  548.          {
  549.                  printf("异常\r\n");
  550.                  goto Exit;
  551.          }
  552. Exit:
  553.          if (ProcessHandle != NULL)
  554.          {
  555.                  CloseHandle(ProcessHandle);
  556.                  ProcessHandle = NULL;
  557.          }
  558.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  559.          return TRUE;
  560. }

  561. BOOL Wow64WriteInt64(ULONG ProcessID, ULONG64 BaseAddress, INT64 Value)
  562. {
  563.          BOOL     IsWow64 = FALSE;
  564.          HANDLE   ProcessHandle = NULL;
  565.          ULONG64  ReturnLen = 8;//默认
  566.         ULONG64  BufferLen = 8;//默认
  567.         if (BaseAddress == NULL)
  568.          {
  569.                  return FALSE;
  570.          }
  571.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  572.          {
  573.                  return FALSE;
  574.          }
  575.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  576.          if (ProcessHandle == NULL)
  577.          {
  578.                  return FALSE;
  579.          }
  580.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  581.          {
  582.                  goto Exit;
  583.          }
  584.          __try
  585.          {
  586.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, &Value, BufferLen, &ReturnLen);

  587.          }
  588.          __except (EXCEPTION_EXECUTE_HANDLER)
  589.          {
  590.                  printf("异常\r\n");
  591.                  goto Exit;
  592.          }
  593. Exit:
  594.          if (ProcessHandle != NULL)
  595.          {
  596.                  CloseHandle(ProcessHandle);
  597.                  ProcessHandle = NULL;
  598.          }
  599.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  600.          return TRUE;
  601. }

  602. BOOL Wow64WriteAscii(ULONG ProcessID, ULONG64 BaseAddress, const char* Value)
  603. {
  604.          BOOL     IsWow64 = FALSE;
  605.          HANDLE   ProcessHandle = NULL;
  606.          ULONG64  ReturnLen = NULL;//默认
  607.         ULONG64  BufferLen = strlen(Value);//获取字符串长度
  608.         printf("BufferLen  %d\n", BufferLen);
  609.          if (BaseAddress == NULL)
  610.          {
  611.                  return FALSE;
  612.          }
  613.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  614.          {
  615.                  return FALSE;
  616.          }
  617.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  618.          if (ProcessHandle == NULL)
  619.          {
  620.                  return FALSE;
  621.          }
  622.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  623.          {
  624.                  goto Exit;
  625.          }
  626.          __try
  627.          {
  628.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, (PVOID64)Value, BufferLen, &ReturnLen);//32位和64位区别

  629.         }
  630.          __except (EXCEPTION_EXECUTE_HANDLER)
  631.          {
  632.                  printf("异常\r\n");
  633.                  goto Exit;
  634.          }
  635. Exit:
  636.          if (ProcessHandle != NULL)
  637.          {
  638.                  CloseHandle(ProcessHandle);
  639.                  ProcessHandle = NULL;
  640.          }
  641.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  642.          return TRUE;
  643. }

  644. BOOL Wow64WriteUTF8(ULONG ProcessID, ULONG64 BaseAddress, const wchar_t  * GBK_Str)//为了兼容,写入的是unicode,函数内部会进行转换操作的。
  645. {
  646.          BOOL     IsWow64 = FALSE; //64位程序备用
  647.         HANDLE   ProcessHandle = NULL;
  648.          ULONG64  ReturnLen = NULL;//默认
  649.         char strUTF8[4096] = { 0 };
  650.          char *unGunG = UnicodeToUTF8((wchar_t*)GBK_Str);
  651.          ULONG64  BufferLen = strlen(unGunG);//获取字符串长度   宽字符用 wcslen
  652.          RtlMoveMemory(strUTF8, unGunG, BufferLen);

  653.          printf("BufferLen  %d\n", BufferLen);
  654.          if (BaseAddress == NULL)
  655.          {
  656.                  return FALSE;
  657.          }
  658.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  659.          {
  660.                  return FALSE;
  661.          }
  662.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  663.          if (ProcessHandle == NULL)
  664.          {
  665.                  return FALSE;
  666.          }
  667.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  668.          {
  669.                  goto Exit;
  670.          }
  671.          __try
  672.          {
  673.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, &strUTF8, BufferLen, &ReturnLen);//32位和64位区别

  674.         }
  675.          __except (EXCEPTION_EXECUTE_HANDLER)
  676.          {
  677.                  printf("异常\r\n");
  678.                  goto Exit;
  679.          }
  680. Exit:
  681.          if (ProcessHandle != NULL)
  682.          {
  683.                  CloseHandle(ProcessHandle);
  684.                  ProcessHandle = NULL;
  685.          }
  686.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  687.          return TRUE;
  688. }

  689. BOOL Wow64WriteUnicode(ULONG ProcessID, ULONG64 BaseAddress, const wchar_t * Value)
  690. {
  691.          BOOL     IsWow64 = FALSE;
  692.          HANDLE   ProcessHandle = NULL;
  693.          ULONG64  ReturnLen = NULL;//默认
  694.         ULONG64  BufferLen = wcslen(Value) * 2;//获取字符串长度   宽字符用 wcslen
  695.          printf("BufferLen  %d\n", BufferLen);
  696.          if (BaseAddress == NULL)
  697.          {
  698.                  return FALSE;
  699.          }
  700.          if (EnableSeDebugPrivilege("SeDebugPrivilege", TRUE) == FALSE)
  701.          {
  702.                  return FALSE;
  703.          }
  704.          ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, ProcessID);
  705.          if (ProcessHandle == NULL)
  706.          {
  707.                  return FALSE;
  708.          }
  709.          if (__NtWow64ReadVirtualMemory64 == NULL || __NtWow64WriteVirtualMemory64 == NULL)
  710.          {
  711.                  goto Exit;
  712.          }
  713.          __try
  714.          {
  715.                  __NtWow64WriteVirtualMemory64(ProcessHandle, BaseAddress, (PVOID64)Value, BufferLen, &ReturnLen);//32位和64位区别

  716.         }
  717.          __except (EXCEPTION_EXECUTE_HANDLER)
  718.          {
  719.                  printf("异常\r\n");
  720.                  goto Exit;
  721.          }
  722. Exit:
  723.          if (ProcessHandle != NULL)
  724.          {
  725.                  CloseHandle(ProcessHandle);
  726.                  ProcessHandle = NULL;
  727.          }
  728.          EnableSeDebugPrivilege("SeDebugPrivilege", FALSE);
  729.          return TRUE;
  730. }

  731. //===============================x86  r3层普通API 内存读写=================================================
  732. BOOL WriteInt64(DWORD ProcessID, DWORD Addr, __int64 Value)
  733. {
  734.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  735.          if (Process_handle == NULL)
  736.          {
  737.                  printf("获取进程句柄失败\n");
  738.          }
  739.          else
  740.          {
  741.                  printf("获取进程句柄成功\n");
  742.          }
  743.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 8, NULL);
  744.          CloseHandle(Process_handle);
  745.          return ret;
  746. }

  747. BOOL WriteInt(DWORD ProcessID, DWORD Addr, int Value)
  748. {
  749.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  750.          if (Process_handle == NULL)
  751.          {
  752.                  printf("获取进程句柄失败\n");
  753.          }
  754.          else
  755.          {
  756.                  printf("获取进程句柄成功\n");
  757.          }

  758.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 4, NULL);
  759.          CloseHandle(Process_handle);
  760.          return ret;
  761. }

  762. BOOL WriteShort(DWORD ProcessID, DWORD Addr, short Value) //2字节整数
  763. {
  764.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  765.          if (Process_handle == NULL)
  766.          {
  767.                  printf("获取进程句柄失败\n");
  768.          }
  769.          else
  770.          {
  771.                  //printf("获取进程句柄成功\n");
  772.          }
  773.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 2, NULL);
  774.          CloseHandle(Process_handle);
  775.          return ret;
  776. }

  777. BOOL WriteByte(DWORD ProcessID, DWORD Addr, byte Value)
  778. {
  779.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  780.          if (Process_handle == NULL)
  781.          {
  782.                  printf("获取进程句柄失败\n");
  783.          }
  784.          else
  785.          {
  786.                  //printf("获取进程句柄成功\n");
  787.          }
  788.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 2, NULL);
  789.          CloseHandle(Process_handle);
  790.          return ret;
  791. }
  792. //
  793. BOOL WriteFloat(DWORD ProcessID, DWORD Addr, float Value)
  794. {
  795.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  796.          if (Process_handle == NULL)
  797.          {
  798.                  printf("获取进程句柄失败\n");
  799.          }
  800.          else
  801.          {
  802.                  //printf("获取进程句柄成功\n");
  803.          }
  804.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 4, NULL);
  805.          CloseHandle(Process_handle);
  806.          return ret;
  807. }

  808. BOOL WriteDouble(DWORD ProcessID, DWORD Addr, double Value)
  809. {
  810.          //printf("打印输出进程pid :%x \n", game_pid);
  811.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  812.          if (Process_handle == NULL)
  813.          {
  814.                  printf("获取进程句柄失败\n");
  815.          }
  816.          else
  817.          {
  818.                  printf("获取进程句柄成功\n");
  819.          }
  820.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 8, NULL);
  821.          CloseHandle(Process_handle);
  822.          return ret;
  823. }

  824. BOOL WriteAcsii(DWORD ProcessID, DWORD Addr, const  char * str)
  825. {
  826.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  827.          if (Process_handle == NULL)
  828.          {
  829.                  printf("获取进程句柄失败\n");
  830.          }
  831.          else
  832.          {
  833.                  printf("获取进程句柄成功\n");
  834.          }
  835.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, (LPVOID)str, strlen(str), NULL);//strlen字符长度
  836.         CloseHandle(Process_handle);
  837.          return ret;
  838. }

  839. BOOL WriteUnicode(DWORD ProcessID, DWORD Addr, const wchar_t * str)
  840. {
  841.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  842.          if (Process_handle == NULL)
  843.          {
  844.                  printf("获取进程句柄失败\n");
  845.          }
  846.          else
  847.          {
  848.                  printf("获取进程句柄成功\n");
  849.          }
  850.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, (LPVOID)str, wcslen(str) * 2 + 2, NULL);//wcslen宽字符长度+2
  851.          printf("iiiiiiiiiii    %d\n", wcslen(str));
  852.          CloseHandle(Process_handle);
  853.          return ret;
  854. }

  855. BOOL WriteUnicode(DWORD ProcessID, DWORD Addr, wchar_t * str)
  856. {
  857.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  858.          if (Process_handle == NULL)
  859.          {
  860.                  printf("获取进程句柄失败\n");
  861.          }
  862.          else
  863.          {
  864.                  printf("获取进程句柄成功\n");
  865.          }
  866.          BOOL ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, (LPVOID)str, wcslen(str) * 2 + 2, NULL);//wcslen宽字符长度+2
  867.          printf("iiiiiiiiiii    %d\n", sizeof(str));
  868.          CloseHandle(Process_handle);
  869.          return ret;
  870. }

  871. DWORD GetPidByHwnd(HWND hwnd)
  872. {
  873.          DWORD Pid = NULL;
  874.          GetWindowThreadProcessId(hwnd, &Pid); //lpdword指针类型
  875.         return  Pid;
  876. }

  877. DWORD FloatToDword(float value)//单浮点数转整数
  878. {
  879.          DWORD  val = NULL;
  880.          memcpy(&val, &value, 4);
  881.          return val;
  882. }

  883. QWORD DoubleToDword(double value)//双浮点数转整数
  884. {
  885.          QWORD  val = NULL;
  886.          memcpy(&val, &value, 8);
  887.          return val;
  888. }

  889. int Int64To32(__int64 value)//部分接口
  890. {
  891.          DWORD  val = NULL;
  892.          memcpy(&val, &value, 4);
  893.          return val;
  894. }

  895. int DwordToInt(DWORD value)//无符号转有符号
  896. {
  897.          int  val = NULL;
  898.          memcpy(&val, &value, 4);
  899.          return val;
  900. }

  901. DWORD IntToDword(int value)//无符号转有符号
  902. {
  903.          DWORD  val = NULL;
  904.          memcpy(&val, &value, 4);
  905.          return val;
  906. }

  907. BOOL WriteIntEx(DWORD ProcessID, DWORD Addr, __int64 Value, int NumByte)
  908. {
  909.          HANDLE  Process_handle = OpenProcess(PROCESS_ALL_ACCESS, NULL, ProcessID); //1.渴望得到的访问权限(标志),全局   
  910.          if (Process_handle == NULL)
  911.                  printf("获取进程句柄失败\n");
  912.          else
  913.                  printf("获取进程句柄成功\n");
  914.          BOOL ret = NULL;
  915.          if (NumByte == 4)
  916.          {
  917.                  int  real_val = (int)Value;
  918.                  ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &real_val, 4, NULL);
  919.          }
  920.          else if (NumByte == 2)
  921.          {
  922.                  short  real_val = (short)Value;
  923.                  ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &real_val, 2, NULL);
  924.          }
  925.          else if (NumByte == 1)
  926.          {
  927.                  short  real_val = (short)Value;
  928.                  ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &real_val, 1, NULL);
  929.          }
  930.          else if (NumByte == 8)
  931.          {
  932.                  ret = WriteProcessMemory(Process_handle, (LPVOID)Addr, &Value, 8, NULL);
  933.          }
  934.          CloseHandle(Process_handle);
  935.          return ret;
  936. }

  937. byte ReadByte(DWORD ProcessID, DWORD  addr) //写入4字节整数
  938. {
  939.          byte Value = NULL;
  940.          HANDLE Hprocess = NULL;
  941.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  942.         if (Hprocess == 0)
  943.                  printf("打开进程失败!\n");
  944.          else
  945.          {
  946.                  printf("打开进程成功!\n");
  947.                  ReadProcessMemory(Hprocess, (LPVOID)(addr), &Value, 1, NULL);//注意参数 4字节
  948.         }
  949.          CloseHandle(Hprocess);//关闭进程句柄
  950.         return Value;
  951. }

  952. short ReadShort(DWORD ProcessID, DWORD  addr) //写入4字节整数
  953. {
  954.          short Value = NULL;
  955.          HANDLE Hprocess = NULL;
  956.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  957.         if (Hprocess == 0)
  958.                  printf("打开进程失败!\n");
  959.          else
  960.          {
  961.                  printf("打开进程成功!\n");
  962.                  ReadProcessMemory(Hprocess, (LPVOID)(addr), &Value, 2, NULL);//注意参数 4字节
  963.         }
  964.          CloseHandle(Hprocess);//关闭进程句柄
  965.         return Value;
  966. }

  967. int ReadInt(DWORD ProcessID, DWORD  addr) //写入4字节整数
  968. {
  969.          int Value = NULL;
  970.          HANDLE Hprocess = NULL;
  971.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  972.         if (Hprocess == 0)
  973.                  printf("打开进程失败!\n");
  974.          else
  975.          {
  976.                  printf("打开进程成功!\n");
  977.                  ReadProcessMemory(Hprocess, (LPVOID)(addr), &Value, 4, NULL);//注意参数 4字节
  978.         }
  979.          CloseHandle(Hprocess);//关闭进程句柄
  980.         return Value;
  981. }

  982. DWORD ReadDword(DWORD ProcessID, DWORD  addr) //写入4字节整数
  983. {
  984.          DWORD Value = NULL;
  985.          HANDLE Hprocess = NULL;
  986.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  987.         if (Hprocess == 0)
  988.                  printf("打开进程失败!\n");
  989.          else
  990.          {
  991.                  printf("打开进程成功!\n");
  992.                  ReadProcessMemory(Hprocess, (LPVOID)(addr), &Value, 4, NULL);//注意参数 4字节

  993.         }
  994.          CloseHandle(Hprocess);//关闭进程句柄
  995.         return Value;
  996. }

  997. __int64 ReadInt64(DWORD ProcessID, DWORD  addr) //写入8字节整数,地址还是4字节
  998. {
  999.          __int64 Value = NULL;
  1000.          HANDLE Hprocess = NULL;
  1001.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1002.         if (Hprocess == 0)
  1003.                  printf("打开进程失败!\n");
  1004.          else
  1005.          {
  1006.                  printf("打开进程成功!\n");
  1007.                  ReadProcessMemory(Hprocess, (LPVOID)(addr), &Value, 8, NULL);//注意参数 4字节

  1008.         }
  1009.          CloseHandle(Hprocess);//关闭进程句柄
  1010.         return Value;
  1011. }

  1012. void * ReadAscii(DWORD ProcessID, DWORD  addr, DWORD Len) //写入8字节整数,地址还是4字节
  1013. {
  1014.          char  Value[1024] = { 0 };
  1015.          char ByteBuffer = NULL;
  1016.          HANDLE Hprocess = NULL;
  1017.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1018.         if (Hprocess == 0)
  1019.                  printf("打开进程失败!\n");
  1020.          else
  1021.          {
  1022.                  printf("打开进程成功!\n");

  1023.                  for (size_t i = 0; i < 1024; i++)//遍历长度,上限1024
  1024.                  {
  1025.                          ReadProcessMemory(Hprocess, (LPCVOID)(addr + i), &ByteBuffer, 1, NULL);//注意参数 4字节
  1026.                         //printf("遍历I数值!  %d  \n", i);
  1027.                          if (ByteBuffer == 0)
  1028.                          {
  1029.                                  if (Len == 0)//如果是0自动长度
  1030.                                 {
  1031.                                          ReadProcessMemory(Hprocess, (LPCVOID)(addr), &Value, i + 1, NULL); //   字节\0
  1032.                                          break;

  1033.                                  }
  1034.                                  else {
  1035.                                          ReadProcessMemory(Hprocess, (LPCVOID)(addr), &Value, Len, NULL); //   字节\0
  1036.                                          break;
  1037.                                  }

  1038.                          }

  1039.                  }
  1040.          }
  1041.          CloseHandle(Hprocess);//关闭进程句柄
  1042.         return Value;
  1043. }

  1044. wchar_t * ReadUnicode(DWORD ProcessID, DWORD  addr, DWORD Len) //控制台程序不支持unicode打印输出
  1045. {
  1046.          wchar_t  StrValue[1024] = { 0 };
  1047.          wchar_t ShortBuffer = NULL;
  1048.          HANDLE Hprocess = NULL;
  1049.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1050.         if (Hprocess == 0)
  1051.                  printf("打开进程失败!\n");
  1052.          else
  1053.          {
  1054.                  printf("打开进程成功!\n");

  1055.                  for (size_t i = 0; i < 1024; i = i + 2)//遍历长度,上限1024
  1056.                  {
  1057.                          ReadProcessMemory(Hprocess, (LPCVOID)(addr + i), &ShortBuffer, 2, NULL);//注意参数 4字节
  1058.                         if (ShortBuffer == '\0')
  1059.                          {
  1060.                                  if (Len == 0)//如果是0自动长度
  1061.                                 {
  1062.                                          ReadProcessMemory(Hprocess, (LPCVOID)(addr), &StrValue, i + 2, NULL); //   字节\0
  1063.                                          printf("打印    %s  \n", StrValue);
  1064.                                          //printf("打印i  :  %d  \n", i);
  1065.                                          break;
  1066.                                  }
  1067.                                  else {
  1068.                                          ReadProcessMemory(Hprocess, (LPCVOID)(addr), &StrValue, Len, NULL); //   字节\0
  1069.                                          break;
  1070.                                  }
  1071.                          }
  1072.                  }
  1073.          }
  1074.          CloseHandle(Hprocess);//关闭进程句柄
  1075.         return StrValue;
  1076. }

  1077. int ReadIntEx(DWORD ProcessID, DWORD  BaseAddr, DWORD OffsetArray[], DWORD Num) //第二个是基地址 第三个参数是偏移数组 第四个偏移数量
  1078. {
  1079.          int Value = NULL;
  1080.          HANDLE Hprocess = NULL;
  1081.          DWORD nBuffer = NULL;
  1082.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1083.         if (Hprocess != 0)
  1084.          {
  1085.                  ReadProcessMemory(Hprocess, (LPVOID)(BaseAddr), &Value, 4, NULL);//注意参数 4字节
  1086.                 for (size_t i = 0; i < Num; i++)//word占2字节
  1087.                 {
  1088.                          ReadProcessMemory(Hprocess, (LPVOID)(Value + OffsetArray), &Value, 4, NULL);//注意参数 4字节
  1089.                 }
  1090.          }
  1091.          else         printf("打开进程失败!\n");
  1092.          CloseHandle(Hprocess);//关闭进程句柄
  1093.         return Value;
  1094. }

  1095. float ReadFloatEx(DWORD ProcessID, DWORD  BaseAddr, DWORD OffsetArray[], DWORD Num) //第二个是基地址 第三个参数是偏移数组 第四个偏移数量
  1096. {
  1097.          DWORD Value = NULL;
  1098.          HANDLE Hprocess = NULL;
  1099.          DWORD nBuffer = NULL;
  1100.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1101.         if (Hprocess != 0)
  1102.          {
  1103.                  ReadProcessMemory(Hprocess, (LPVOID)(BaseAddr), &Value, 4, NULL);//注意参数 4字节
  1104.                 for (size_t i = 0; i < Num; i++)//word占2字节
  1105.                 {
  1106.                          printf("str       %d\n", Value);
  1107.                          ReadProcessMemory(Hprocess, (LPVOID)(Value + OffsetArray), &Value, 4, NULL);//注意参数 4字节
  1108.                 }
  1109.          }
  1110.          else         printf("打开进程失败!\n");
  1111.          CloseHandle(Hprocess);//关闭进程句柄
  1112.         return (float)Value;
  1113. }

  1114. double ReadDoubleEx(DWORD ProcessID, DWORD  BaseAddr, DWORD OffsetArray[], DWORD Num) //第二个是基地址 第三个参数是偏移数组 第四个偏移数量
  1115. {
  1116.          double ValueDouble = NULL;
  1117.          HANDLE Hprocess = NULL;
  1118.          DWORD nBuffer = NULL;
  1119.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1120.         if (Hprocess != 0)
  1121.          {
  1122.                  ReadProcessMemory(Hprocess, (LPVOID)(BaseAddr), &nBuffer, 4, NULL);//注意参数 4字节
  1123.                 int  i = NULL;
  1124.                  for (i = 0; i < Num - 1; i++)//word占2字节
  1125.                 {
  1126.                          ReadProcessMemory(Hprocess, (LPVOID)(nBuffer + OffsetArray), &nBuffer, 4, NULL);//注意参数 4字节
  1127.         /*                printf("double       %x\n", OffsetArray);*/
  1128.                  }
  1129.                  ReadProcessMemory(Hprocess, (LPVOID)(nBuffer + OffsetArray), &ValueDouble, 8, NULL);//Value64最终结果
  1130.         }
  1131.          else         printf("打开进程失败!\n");
  1132.          CloseHandle(Hprocess);//关闭进程句柄
  1133.         return ValueDouble;
  1134. }

  1135. __int64 ReadIntEx64(DWORD ProcessID, DWORD  BaseAddr, DWORD OffsetArray[], DWORD Num) //第二个是基地址 第三个参数是偏移数组 第四个偏移数量
  1136. {
  1137.          __int64 value64 = NULL;
  1138.          HANDLE Hprocess = NULL;
  1139.          DWORD nBuffer = NULL;
  1140.          Hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessID);//打开进程
  1141.         if (Hprocess != 0)
  1142.          {
  1143.                  ReadProcessMemory(Hprocess, (LPVOID)(BaseAddr), &nBuffer, 4, NULL);//注意参数 4字节
  1144.                 int  i = NULL;
  1145.                  for (i = 0; i < Num - 1; i++)//word占2字节
  1146.                 {
  1147.                          ReadProcessMemory(Hprocess, (LPVOID)(nBuffer + OffsetArray), &nBuffer, 4, NULL);//注意参数 4字节
  1148.         /*                printf("double       %x\n", OffsetArray);*/
  1149.                  }
  1150.                  ReadProcessMemory(Hprocess, (LPVOID)(nBuffer + OffsetArray), &value64, 8, NULL);//Value64最终结果
  1151.         }
  1152.          else         printf("打开进程失败!\n");
  1153.          CloseHandle(Hprocess);//关闭进程句柄
  1154.         return value64;
  1155. }

  1156. int EnableDebugPriv(const char *name)
  1157. {
  1158.          HANDLE hToken;        //进程令牌句柄
  1159.         TOKEN_PRIVILEGES tp;  //TOKEN_PRIVILEGES结构体,其中包含一个【类型+操作】的权限数组
  1160.         LUID luid;           //上述结构体中的类型值
  1161.         //打开进程令牌环
  1162.         //GetCurrentProcess()获取当前进程的伪句柄,只会指向当前进程或者线程句柄,随时变化
  1163.         if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
  1164.          {
  1165.                  fprintf(stderr, "OpenProcessToken error\n");
  1166.                  return -1;
  1167.          }
  1168.          //获得本地进程name所代表的权限类型的局部唯一ID
  1169.          if (!LookupPrivilegeValue(NULL, name, &luid))
  1170.          {
  1171.                  fprintf(stderr, "LookupPrivilegeValue error\n");
  1172.          }

  1173.          tp.PrivilegeCount = 1;                               //权限数组中只有一个“元素”
  1174.         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;  //权限操作
  1175.         tp.Privileges[0].Luid = luid;                        //权限类型

  1176.         //调整进程权限
  1177.         if (!AdjustTokenPrivileges(hToken, 0, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
  1178.          {
  1179.                  fprintf(stderr, "AdjustTokenPrivileges error!\n");
  1180.                  return -1;
  1181.          }
  1182.          return 0;
  1183. }


  1184. DWORD  GetPidByName( const char * ProcessName) //根据进程名字获取进程ID
  1185. {
  1186.          HANDLE ProcessAll = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
  1187.          PROCESSENTRY32 processInfo = { 0 };
  1188.          processInfo.dwSize = sizeof(PROCESSENTRY32);
  1189.          do {
  1190.                  if (strcmp(ProcessName, processInfo.szExeFile) == 0) {
  1191.                          return processInfo.th32ProcessID;
  1192.                  }

  1193.          } while (Process32Next(ProcessAll, &processInfo));
  1194.          return NULL;
  1195. }
  1196. //======================================注入==========================
  1197. VOID InjectDll(const CHAR pathStr[0x1000], const CHAR ProcessName[256])
  1198. {

  1199.          //CHAR  pathStr[0x1000] = { "K:\\我的文档\\visual studio 2012\\Projects\\InjectChat\\Debug\\WeChatDll.dll" };
  1200.          DWORD PID = GetPidByName((CHAR*)ProcessName);
  1201.          if (PID == 0)
  1202.          {
  1203.                  MessageBox(NULL, "没有找到微信进程或者微信没有启动", "错误", 0);
  1204.                  return;
  1205.          }

  1206.          HANDLE hProcsee = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
  1207.          if (hProcsee == NULL) {
  1208.                  MessageBox(NULL, "没有找到微信进程", "错误", 0);
  1209.                  return;
  1210.          }

  1211.          LPVOID dllAdd = VirtualAllocEx(hProcsee, NULL, strlen(pathStr), MEM_COMMIT, PAGE_READWRITE);
  1212.          if (dllAdd == NULL) {
  1213.                  MessageBox(NULL, "内存写入", "错误", 0);
  1214.          }


  1215.          if (WriteProcessMemory(hProcsee, dllAdd, pathStr, strlen(pathStr), NULL) == 0) {
  1216.                  MessageBox(NULL, "内存写入", "错误", 0);
  1217.                  return;
  1218.          }

  1219.          HMODULE K32 = GetModuleHandle("Kernel32.dll");
  1220.          LPVOID LoadAdd = GetProcAddress(K32, "LoadLibraryA");
  1221.          HANDLE exec = CreateRemoteThread(hProcsee, NULL, 0, (LPTHREAD_START_ROUTINE)LoadAdd, dllAdd, 0, NULL);
  1222.          if (NULL == exec) {
  1223.                  MessageBox(NULL, "远程注入失败", "错误", 0);
  1224.                  return;
  1225.          }
  1226.          WaitForSingleObject(exec, INFINITE);
  1227.          CloseHandle(hProcsee);
  1228. }

  1229. VOID InjectSellCode(HWND hwnd, BYTE SellCode[])
  1230. {
  1231.          EnableDebugPriv(SE_DEBUG_NAME);
  1232.          //CHAR  pathStr[0x1000] = { "K:\\我的文档\\visual studio 2012\\Projects\\InjectChat\\Debug\\WeChatDll.dll" };
  1233.          DWORD processid = NULL;
  1234.          GetWindowThreadProcessId(hwnd, &processid);//获取进程id

  1235.          if (processid == 0)
  1236.          {
  1237.                  MessageBox(NULL, "没有找到微信进程或者微信没有启动", "错误", 0);
  1238.                  return;
  1239.          }

  1240.          HANDLE hProcsee = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processid);
  1241.          if (hProcsee == NULL) {
  1242.                  MessageBox(NULL, "没有找到微信进程", "错误", 0);
  1243.                  return;
  1244.          }


  1245.          //LPVOID dllAdd = VirtualAllocEx(hProcsee, NULL, 1024, MEM_COMMIT| MEM_TOP_DOWN, PAGE_EXECUTE_READWRITE);//64位申请空间的时候可能会有bug
  1246.          LPVOID dllAdd = VirtualAllocEx(hProcsee, NULL, 1024, MEM_COMMIT, PAGE_EXECUTE_READWRITE);//64位申请空间的时候可能会有bug
  1247.          if (dllAdd == NULL) {
  1248.                  MessageBox(NULL, "内存申请失败", "0", 0);
  1249.          }


  1250.          if (WriteProcessMemory(hProcsee, dllAdd, SellCode, 1023, NULL) == 0) {       //可能这里的问题
  1251.                 MessageBox(NULL, "内存写入", "错误", 0);
  1252.                  return;
  1253.          }

  1254.          printf("申请的内存空间是 %llx\n", dllAdd);

  1255.          HANDLE exec = CreateRemoteThread(hProcsee, NULL, 0, (LPTHREAD_START_ROUTINE)dllAdd, NULL, 0, NULL); //有一个参数的
  1256.         if (NULL == exec) {
  1257.                  MessageBox(NULL, "远程注入失败", "错误", 0);
  1258.                  return;
  1259.          }

  1260.          //WaitForSingleObject(exec, INFINITE);
  1261.          CloseHandle(hProcsee);
  1262. }

  1263. BOOL UnloadDll(DWORD dwPid, CHAR   strDllName[256])
  1264. {
  1265.          //获取宿主进程的句柄,注意那几个参数,不然会出错
  1266.         HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,
  1267.                  FALSE, dwPid);
  1268.          if (hProcess == NULL) {
  1269.                  ::MessageBox(NULL, "无法获取进程句柄", "错误", MB_OK | MB_ICONERROR);
  1270.                  return FALSE;
  1271.          }

  1272.          DWORD   dwSize = 0;
  1273.          DWORD   dwWritten = 0;
  1274.          DWORD   dwHandle = 0;

  1275.          dwSize = sizeof(strDllName) + 1;//dll的全路径名的长度,待会分配内存要用到的

  1276.         //向宿主进程分配内存,返回一个指针
  1277.         LPVOID lpBuf = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);

  1278.          //如果在宿主进程空间写失败就直接报错闪人
  1279.         if (!WriteProcessMemory(hProcess, lpBuf, strDllName, dwSize, (SIZE_T*)&dwWritten))
  1280.          {
  1281.                  VirtualFreeEx(hProcess, lpBuf, dwSize, MEM_DECOMMIT);
  1282.                  CloseHandle(hProcess);
  1283.                  MessageBox(NULL, "在目标进程中写入失败", "错误", MB_OK | MB_ICONERROR);
  1284.                  return FALSE;
  1285.          }

  1286.          //获取GetModuleHandleA函数地址
  1287.         LPVOID pFun = GetProcAddress(GetModuleHandle("Kernel32"), "GetModuleHandleA");

  1288.          //在宿主进程中创建一个远程线程,线程函数为上面导出的GetModuleHandleA,参数为lpBuf指针,还
  1289.         //记得我们获取的dll全路径不
  1290.         HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFun,
  1291.                  lpBuf, 0, NULL);
  1292.          //如果创建线程失败,直接报错闪人
  1293.         if (hThread == NULL) {
  1294.                  CloseHandle(hProcess);
  1295.                  ::MessageBox(NULL, "在目标进程创建远程线程失败", "错误", MB_OK | MB_ICONERROR);
  1296.                  return FALSE;
  1297.          }

  1298.          //   等待GetModuleHandle运行完毕   
  1299.          WaitForSingleObject(hThread, INFINITE);
  1300.          //   获得GetModuleHandle的返回值   
  1301.          GetExitCodeThread(hThread, &dwHandle);

  1302.          //   释放目标进程中申请的空间   
  1303.          VirtualFreeEx(hProcess, lpBuf, dwSize, MEM_DECOMMIT);
  1304.          CloseHandle(hThread);

  1305.          //   使目标进程调用FreeLibraryAndExit,卸载DLL,实际也可以用FreeLibrary,但是我发现前者好一点
  1306.         pFun = GetProcAddress(GetModuleHandle("Kernel32"), "FreeLibraryAndExitThread");
  1307.          hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFun,
  1308.                  (LPVOID)dwHandle, 0, NULL);
  1309.          //   等待FreeLibraryAndExitThread执行完毕   
  1310.          WaitForSingleObject(hThread, INFINITE);
  1311.          CloseHandle(hThread);
  1312.          CloseHandle(hProcess);

  1313.          return TRUE;  //操作成功
  1314. }

  1315. //提升进程访问权限
  1316. bool enableDebugPriv()
  1317. {
  1318.          HANDLE  hToken;
  1319.          LUID    sedebugnameValue;
  1320.          TOKEN_PRIVILEGES tkp;
  1321.          if (!OpenProcessToken(GetCurrentProcess(),
  1322.                  TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)
  1323.                  )
  1324.          {
  1325.                  return false;
  1326.          }
  1327.          if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue))
  1328.          {
  1329.                  CloseHandle(hToken);
  1330.                  return false;
  1331.          }
  1332.          tkp.PrivilegeCount = 1;
  1333.          tkp.Privileges[0].Luid = sedebugnameValue;
  1334.          tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  1335.          if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL))
  1336.          {
  1337.                  CloseHandle(hToken);
  1338.                  return false;
  1339.          }
  1340.          return true;
  1341. }

  1342. //======================================结尾部分
  1343. HANDLE GetModule()
  1344. {
  1345.          HANDLE hProcess;                        //进程句柄
  1346.         HANDLE hModule;                         //模块句柄
  1347.         BOOL bProcess = FALSE;                  //获取进程信息的函数返回值
  1348.         BOOL bModule = FALSE;                   //获取模块信息的函数返回值
  1349.         PROCESSENTRY32 pe32;                    //保存进程信息
  1350.         MODULEENTRY32  me32;                    //保存模块信息

  1351.         int i = 0;
  1352.          int j = 0;

  1353.          //获取进程调试权限,如果失败,则提示获取权限失败,失败的话,有的进程信息就会获取不到
  1354.         if (EnableDebugPriv(SE_DEBUG_NAME))
  1355.          {
  1356.                  fprintf(stderr, "Add Privilege error\n");
  1357.          }

  1358.          hProcess = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//获取进程快照
  1359.         if (hProcess == INVALID_HANDLE_VALUE)
  1360.          {
  1361.                  printf("获取进程快照失败\n");
  1362.                  exit(1);
  1363.          }

  1364.          bProcess = Process32First(hProcess, &pe32);              //获取第一个进程信息
  1365.         while (bProcess)                                         //循环获取其余进程信息
  1366.         {
  1367.                  printf("%d :\t Father's PID(%d)\tPID(%d)\t%s\n", i, pe32.th32ParentProcessID, pe32.th32ProcessID, pe32.szExeFile);
  1368.                  i++;
  1369.                  j = 0;
  1370.                  if (0 != pe32.th32ParentProcessID)                   //获取进程PID不为0的模块信息
  1371.                 {
  1372.                          hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pe32.th32ProcessID);  //获取模块快照
  1373.                         if (hModule != INVALID_HANDLE_VALUE)
  1374.                          {
  1375.                                  bModule = Module32First(hModule, &me32);      //获取第一个模块信息,即进程相应可执行文件的信息
  1376.                                 while (bModule)
  1377.                                  {
  1378.                                          printf("模块:\n%d\t%s\n", j, me32.szExePath);
  1379.                                          j++;
  1380.                                          bModule = Module32Next(hModule, &me32);  //获取其他模块信息
  1381.                                 }
  1382.                                  CloseHandle(hModule);
  1383.                          }
  1384.                  }

  1385.                  bProcess = Process32Next(hProcess, &pe32);           //继续获取其他进程信息
  1386.                 printf("\n\n");
  1387.                  getchar();
  1388.          }

  1389.          CloseHandle(hProcess);
  1390.          return 0;
  1391. }

  1392. PVOID GetRemoteProcAddress32(HANDLE hProc, HMODULE hModule, LPCSTR lpProcName)//这个函数只支持32位的
  1393. {
  1394.          PVOID pAddress = NULL;
  1395.          SIZE_T OptSize;
  1396.          IMAGE_DOS_HEADER DosHeader;
  1397.          SIZE_T ProcNameLength = lstrlenA(lpProcName) + sizeof(CHAR);//'\0'  

  1398.          //读DOS头  
  1399.          if (ReadProcessMemory(hProc, hModule, &DosHeader, sizeof(DosHeader), &OptSize))
  1400.          {
  1401.                  IMAGE_NT_HEADERS NtHeader;

  1402.                  //读NT头  
  1403.                  if (ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + DosHeader.e_lfanew), &NtHeader, sizeof(NtHeader), &OptSize))
  1404.                  {
  1405.                          IMAGE_EXPORT_DIRECTORY ExpDir;
  1406.                          SIZE_T ExportVirtualAddress = NtHeader.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;

  1407.                          //读输出表  
  1408.                          if (ExportVirtualAddress && ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + ExportVirtualAddress), &ExpDir, sizeof(ExpDir), &OptSize))
  1409.                          {

  1410.                                  if (ExpDir.NumberOfFunctions)
  1411.                                  {

  1412.                                          //x64待定:地址数组存放RVA的数据类型是4字节还是8字节???  
  1413.                                          SIZE_T *pProcAddressTable = (SIZE_T *)GlobalAlloc(GPTR, ExpDir.NumberOfFunctions * sizeof(SIZE_T));

  1414.                                          //读函数地址表  
  1415.                                          if (ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + ExpDir.AddressOfFunctions), pProcAddressTable, ExpDir.NumberOfFunctions * sizeof(PVOID), &OptSize))
  1416.                                          {
  1417.                                                  //x64待定:名称数组存放RVA的数据类型是4字节还是8字节???  
  1418.                                                  SIZE_T *pProcNamesTable = (SIZE_T *)GlobalAlloc(GPTR, ExpDir.NumberOfNames * sizeof(SIZE_T));

  1419.                                                  //读函数名称表  
  1420.                                                  if (ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + ExpDir.AddressOfNames), pProcNamesTable, ExpDir.NumberOfNames * sizeof(PVOID), &OptSize))
  1421.                                                  {
  1422.                                                          CHAR *pProcName = (CHAR *)GlobalAlloc(GPTR, ProcNameLength);

  1423.                                                          //遍历函数名称  
  1424.                                                          for (DWORD i = 0; i < ExpDir.NumberOfNames; i++)
  1425.                                                          {

  1426.                                                                  if (ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + pProcNamesTable), pProcName, ProcNameLength, &OptSize))
  1427.                                                                  {
  1428.                                                                          if (RtlEqualMemory(lpProcName, pProcName, ProcNameLength))
  1429.                                                                          {
  1430.                                                                                  //x64待定:函数在地址数组索引的数据类型是2字节还是???  
  1431.                                                                                  WORD NameOrdinal;

  1432.                                                                                  //获取函数在地址表的索引  
  1433.                                                                                  if (ReadProcessMemory(hProc, (PVOID)((SIZE_T)hModule + ExpDir.AddressOfNameOrdinals + sizeof(NameOrdinal) * i), &NameOrdinal, sizeof(NameOrdinal), &OptSize))
  1434.                                                                                  {
  1435.                                                                                          pAddress = (PVOID)((SIZE_T)hModule + pProcAddressTable[NameOrdinal]);
  1436.                                                                                  }
  1437.                                                                                  break;//for  
  1438.                                                                          }
  1439.                                                                  }
  1440.                                                          }
  1441.                                                          GlobalFree(pProcName);
  1442.                                                  }
  1443.                                                  GlobalFree(pProcNamesTable);
  1444.                                          }
  1445.                                          GlobalFree(pProcAddressTable);
  1446.                                  }
  1447.                          }
  1448.                  }
  1449.          }
  1450.          return pAddress;
  1451. }

复制代码
点击按钮快速添加回复内容: 支持 高兴 激动 给力 加油 苦寻 生气 回帖 路过 感恩
您需要登录后才可以回帖 登录 | 注册账号

本版积分规则

小黑屋|手机版|Archiver|看流星社区 |网站地图

GMT+8, 2019-11-12 06:25

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

快速回复 返回顶部 返回列表