看流星社区

 找回密码
 注册账号
查看: 2212|回复: 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, 2024-3-29 04:37

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

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