1.15 自实现GetProcAddress

实现,getprocaddress · 浏览次数 : 161

小编点评

# 自定义读入LoadLibrary = 10452 fnGetProcAddress = 0x10452; GetKernel32Addr = 0x10452; pfnLoadLibraryA = 0x1045a; pfnGetModuleHandleA = 0x1045b; VirtualProtect = 0x1045c; ExitProcess = 0x1045d; User32 = > 10452 MessageBox = > 1045a 你点击了YES

正文

在正常情况下,要想使用GetProcAddress函数,需要首先调用LoadLibraryA函数获取到kernel32.dll动态链接库的内存地址,接着在调用GetProcAddress函数时传入模块基址以及模块中函数名即可动态获取到特定函数的内存地址,但在有时这个函数会被保护起来,导致我们无法直接调用该函数获取到特定函数的内存地址,此时就需要自己编写实现LoadLibrary以及GetProcAddress函数,该功能的实现需要依赖于PEB线程环境块,通过线程环境块可遍历出kernel32.dll模块的入口地址,接着就可以在该模块中寻找GetProcAddress函数入口地址,当找到该入口地址后即可直接调用实现动态定位功能。

首先通过PEB/TEB找到自身进程的所有载入模块数据,获取TEB也就是线程环境块。在编程的时候TEB始终保存在寄存器 FS 中。

0:000> !teb
TEB at 00680000
    ExceptionList:        008ff904
    StackBase:            00900000
    StackLimit:           008fc000
    RpcHandle:            00000000
    Tls Storage:          0068002c
    PEB Address:          0067d000

0:000> dt _teb 00680000
ntdll!_TEB
   +0x000 NtTib            : _NT_TIB
   +0x01c EnvironmentPointer : (null) 
   +0x020 ClientId         : _CLIENT_ID
   +0x028 ActiveRpcHandle  : (null) 
   +0x02c ThreadLocalStoragePointer : 0x0068002c Void
   +0x030 ProcessEnvironmentBlock : 0x0067d000 _PEB      // 偏移为30,PEB

从该命令的输出可以看出,PEB 结构体的地址位于 TEB 结构体偏移0x30 的位置,该位置保存的地址是 0x0067d000。也就是说,PEB 的地址是 0x0067d000,通过该地址来解析 PEB并获得 LDR结构。

0:000> dt nt!_peb 0x0067d000
ntdll!_PEB
   +0x000 InheritedAddressSpace : 0 ''
   +0x001 ReadImageFileExecOptions : 0 ''
   +0x002 BeingDebugged    : 0x1 ''
   +0x003 BitField         : 0x4 ''
   +0x003 ImageUsesLargePages : 0y0
   +0x003 IsProtectedProcess : 0y0
   +0x003 IsImageDynamicallyRelocated : 0y1
   +0x003 SkipPatchingUser32Forwarders : 0y0
   +0x003 IsPackagedProcess : 0y0
   +0x003 IsAppContainer   : 0y0
   +0x003 IsProtectedProcessLight : 0y0
   +0x003 IsLongPathAwareProcess : 0y0
   +0x004 Mutant           : 0xffffffff Void
   +0x008 ImageBaseAddress : 0x00f30000 Void
   +0x00c Ldr              : 0x774c0c40 _PEB_LDR_DATA    // LDR

从如上输出结果可以看出,LDRPEB 结构体偏移的 0x0C 处,该地址保存的地址是 0x774c0c40 通过该地址来解析 LDR 结构体。WinDBG 输出如下内容:

0:000> dt _peb_ldr_data 0x774c0c40
ntdll!_PEB_LDR_DATA
   +0x000 Length           : 0x30
   +0x004 Initialized      : 0x1 ''
   +0x008 SsHandle         : (null) 
   +0x00c InLoadOrderModuleList : _LIST_ENTRY [ 0x9e3208 - 0x9e5678 ]
   +0x014 InMemoryOrderModuleList : _LIST_ENTRY [ 0x9e3210 - 0x9e5680 ]
   +0x01c InInitializationOrderModuleList : _LIST_ENTRY [ 0x9e3110 - 0x9e35f8 ]
   +0x024 EntryInProgress  : (null) 
   +0x028 ShutdownInProgress : 0 ''
   +0x02c ShutdownThreadId : (null) 

0:000> dt _LIST_ENTRY
ntdll!_LIST_ENTRY
   +0x000 Flink            : Ptr32 _LIST_ENTRY
   +0x004 Blink            : Ptr32 _LIST_ENTRY

现在来手动遍历第一条链表,输入命令0x9e3208:在链表偏移 0x18 的位置是模块的映射地址,即 ImageBase;在链表
偏移 0x28 的位置是模块的路径及名称的地址;在链表偏移 0x30 的位置是模块名称的地址。

0:000> dd 0x9e3208
009e3208  009e3100 774c0c4c 009e3108 774c0c54
009e3218  00000000 00000000 00f30000 00f315bb
009e3228  00007000 00180016 009e1fd4 00120010
009e3238  009e1fda 000022cc 0000ffff 774c0b08

0:000> du 009e1fd4
009e1fd4  "C:\main.exe"
0:000> du 009e1fda
009e1fda  "main.exe"

读者可自行验证,如下所示的确是模块的名称。既然是链表,就来下一条链表的信息,009e3100保存着下一个链表结构。依次遍历就是了。

0:000> dd 009e3100
009e3100  009e35e8 009e3208 009e35f0 009e3210
009e3110  009e39b8 774c0c5c 773a0000 00000000
009e3120  0019c000 003c003a 009e2fe0 00140012

0:000> du 009e2fe0 
009e2fe0  "C:\Windows\SYSTEM32\ntdll.dll"

上述地址009e3100介绍的结构,是微软保留结构,只能从网上找到一个结构定义,然后自行看着解析就好了。

typedef struct _LDR_DATA_TABLE_ENTRY
{
  PVOID Reserved1[2];
  LIST_ENTRY InMemoryOrderLinks;
  PVOID Reserved2[2];
  PVOID DllBase;
  PVOID EntryPoint;
  PVOID Reserved3;
  UNICODE_STRING FullDllName;
  BYTE Reserved4[8];
  PVOID Reserved5[3];
  union {
  ULONG CheckSum;
  PVOID Reserved6;
  };
  ULONG TimeDateStamp;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY; 

根据如上流程,想要得到kernel32.dll模块的入口地址,我们可以进行这几步,首先得到TEB地址,并在该地址中寻找PEB线程环境块,并在该环境块内得到LDR结构,在该结构中获取第二条链表地址,输出该链表中的0x10以及0x20即可得到当前模块的基地址,以及完整的模块路径信息,该功能的实现分为32位于64位,如下代码则是实现代码。

#include <iostream>
#include <Windows.h>

// 将不同的节压缩为单一的节
#pragma comment(linker, "/merge:.data=.text") 
#pragma comment(linker, "/merge:.rdata=.text")
#pragma comment(linker, "/section:.text,RWE")

// 得到32位模式下kernel32.dll地址
DWORD GetModuleKernel32()
{
  DWORD *PEB = NULL, *Ldr = NULL, *Flink = NULL, *p = NULL;
  DWORD *BaseAddress = NULL, *FullDllName = NULL;

  __asm
  {
    mov eax, fs:[0x30]      // FS保存着TEB
    mov PEB, eax            // +30定位到PEB
  }

  // 得到LDR
  Ldr = *((DWORD **)((unsigned char *)PEB + 0x0c));

  // 在LDR基础上找到第二条链表
  Flink = *((DWORD **)((unsigned char *)Ldr + 0x14));
  p = Flink;

  p = *((DWORD **)p);

  // 计数器
  int count = 0;

  while (Flink != p)
  {
    BaseAddress = *((DWORD **)((unsigned char *)p + 0x10));
    FullDllName = *((DWORD **)((unsigned char *)p + 0x20));

    if (BaseAddress == 0)
      break;

    // printf("镜像基址 = %08x \r\n 模块路径 = %S \r\n", BaseAddress, (unsigned char *)FullDllName);
    // 第二个模块是kernel32.dll
    if (count == 1)
    {
      // printf("address =%x \n", BaseAddress);
      return reinterpret_cast<DWORD>(BaseAddress);
    }

    p = *((DWORD **)p);
    count = count + 1;
  }

  // 未找到Kernel32模块
  return 0;
}

// 获取64位模式下的kernel32.dll基址
ULONGLONG GetModuleKernel64()
{
  ULONGLONG dwKernel32Addr = 0;

  // 获取TEB的地址
  _TEB* pTeb = NtCurrentTeb();
  // 获取PEB的地址
  PULONGLONG pPeb = (PULONGLONG)*(PULONGLONG)((ULONGLONG)pTeb + 0x60);
  // 获取PEB_LDR_DATA结构的地址
  PULONGLONG pLdr = (PULONGLONG)*(PULONGLONG)((ULONGLONG)pPeb + 0x18);
  // 模块初始化链表的头指针InInitializationOrderModuleList
  PULONGLONG pInLoadOrderModuleList = (PULONGLONG)((ULONGLONG)pLdr + 0x10);

  // 获取链表中第一个模块信息,exe模块
  PULONGLONG pModuleExe = (PULONGLONG)*pInLoadOrderModuleList;
  //printf("EXE Base = > %X \n", pModuleExe[6]);

  // 获取链表中第二个模块信息,ntdll模块
  PULONGLONG pModuleNtdll = (PULONGLONG)*pModuleExe;
  //printf("Ntdll Base = > %X \n", pModuleNtdll[6]);

  // 获取链表中第三个模块信息,Kernel32模块
  PULONGLONG pModuleKernel32 = (PULONGLONG)*pModuleNtdll;
  //printf("Kernel32 Base = > %X \n", pModuleKernel32[6]);

  // 获取kernel32基址
  dwKernel32Addr = pModuleKernel32[6];
  return dwKernel32Addr;
}

int main(int argc, char *argv[])
{
  // 输出32位kernel32
  DWORD kernel32BaseAddress = GetModuleKernel32();
  std::cout << "kernel32 = " << std::hex << kernel32BaseAddress << std::endl;

  // 输出64位kernel32
  ULONGLONG kernel64BaseAddress = GetModuleKernel64();
  std::cout << "kernel64 = " << std::hex << kernel32BaseAddress << std::endl;

  system("pause");
  return 0;
}

如上代码中分别实现了32位于64位两种获取内存模块基址GetModuleKernel32用于获取32位模式,GetModuleKernel64则用于获取64位内存基址,读者可自行调用两种模式,输出如下图所示;

我们通过调用GetModuleKernel32()函数读入kernel32.dll模块入口地址后,则下一步就可以通过循环,遍历该模块的导出表并寻找到GetProcAddress导出函数地址,找到该导出函数内存地址后,则可以通过kernel32模块基址加上dwFunAddrOffset相对偏移,获取到该函数的内存地址,此时通过函数指针就可以将该函数地址读入到内存指针内。

// 封装基地址获取功能
ULONGLONG MyGetProcAddress()
{
  // 获取32位基址
  ULONGLONG dwBase = GetModuleKernel32();
  
  // 获取64位基址
  // ULONGLONG dwBase = GetModuleKernel64();
  
  // 获取DOS头
  PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)dwBase;
  
  // 获取32位NT头
  PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(dwBase + pDos->e_lfanew);
  
  // 获取64位NT头
  // PIMAGE_NT_HEADERS64  pNt = (PIMAGE_NT_HEADERS64)(dwBase + pDos->e_lfanew);
  
  // 获取数据目录表
  PIMAGE_DATA_DIRECTORY pExportDir = pNt->OptionalHeader.DataDirectory;
  pExportDir = &(pExportDir[IMAGE_DIRECTORY_ENTRY_EXPORT]);
  DWORD dwOffset = pExportDir->VirtualAddress;
  
  // 获取导出表信息结构
  PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)(dwBase + dwOffset);
  DWORD dwFunCount = pExport->NumberOfFunctions;
  DWORD dwFunNameCount = pExport->NumberOfNames;
  DWORD dwModOffset = pExport->Name;

  // 获取导出地址表
  PDWORD pEAT = (PDWORD)(dwBase + pExport->AddressOfFunctions);
  
  // 获取导出名称表
  PDWORD pENT = (PDWORD)(dwBase + pExport->AddressOfNames);
  
  // 获取导出序号表
  PWORD pEIT = (PWORD)(dwBase + pExport->AddressOfNameOrdinals);

  for (DWORD dwOrdinal = 0; dwOrdinal < dwFunCount; dwOrdinal++)
  {
    if (!pEAT[dwOrdinal])
    {
      continue;
    }

    // 获取序号
    DWORD dwID = pExport->Base + dwOrdinal;
    
    // 获取导出函数地址
    ULONGLONG dwFunAddrOffset = pEAT[dwOrdinal];

    for (DWORD dwIndex = 0; dwIndex < dwFunNameCount; dwIndex++)
    {
      // 在序号表中查找函数的序号
      if (pEIT[dwIndex] == dwOrdinal)
      {
        // 根据序号索引到函数名称表中的名字
        ULONGLONG dwNameOffset = pENT[dwIndex];
        char* pFunName = (char*)((ULONGLONG)dwBase + dwNameOffset);
        if (!strcmp(pFunName, "GetProcAddress"))
        {
          // 根据函数名称返回函数地址
          return dwBase + dwFunAddrOffset;
        }
      }
    }
  }
  return 0;
}

// 定义名称指针
typedef ULONGLONG(WINAPI *fnGetProcAddress)(_In_ HMODULE hModule, _In_ LPCSTR lpProcName);
typedef HMODULE(WINAPI *fnLoadLibraryA)(_In_ LPCSTR lpLibFileName);

int main(int argc, char *argv[])
{

  DWORD kernel32BaseAddress = GetModuleKernel32();
  if (kernel32BaseAddress == 0)
  {
    return 0;
  }

  // 获取kernel32基址/获取GetProcAddress的基址
  fnGetProcAddress pfnGetProcAddress = (fnGetProcAddress)MyGetProcAddress();
  std::cout << pfnGetProcAddress << std::endl;

  // 获取Kernel32核心API地址
  fnLoadLibraryA pfnLoadLibraryA = (fnLoadLibraryA)pfnGetProcAddress((HMODULE)kernel32BaseAddress, "LoadLibraryA");
  printf("自定义读入LoadLibrary = %x \n", pfnLoadLibraryA);

  system("pause");
  return 0;
}

输出效果如下图所示,我们即可读入fnLoadLibraryA函数的内存地址;

上述代码的使用也很简单,当我们能够得到GetProcAddress的内存地址后,就可以使用该内存地址动态定位到任意一个函数地址,我们通过得到LoadLibrary函数地址,与GetModuleHandleA函数地址,通过两个函数就可以定位到Windows系统内任意一个函数,我们以调用MessageBox弹窗为例,动态输出一个弹窗,该调用方式如下所示。

// 定义名称指针
typedef ULONGLONG(WINAPI *fnGetProcAddress)(_In_ HMODULE hModule, _In_ LPCSTR lpProcName);
typedef HMODULE(WINAPI *fnLoadLibraryA)(_In_ LPCSTR lpLibFileName);
typedef int(WINAPI *fnMessageBox)(HWND hWnd, LPSTR lpText, LPSTR lpCaption, UINT uType);
typedef HMODULE(WINAPI *fnGetModuleHandleA)(_In_opt_ LPCSTR lpModuleName);
typedef BOOL(WINAPI *fnVirtualProtect)(_In_ LPVOID lpAddress, _In_ SIZE_T dwSize, _In_ DWORD flNewProtect, _Out_ PDWORD lpflOldProtect);
typedef void(WINAPI *fnExitProcess)(_In_ UINT uExitCode);

int main(int argc, char * argv[])
{
  // 获取kernel32基址 / 获取GetProcAddress的基址
  fnGetProcAddress pfnGetProcAddress = (fnGetProcAddress)MyGetProcAddress();
  ULONGLONG dwBase = GetModuleKernel32();
  printf("fnGetProcAddress = %x \n", pfnGetProcAddress);
  printf("GetKernel32Addr = %x \n", dwBase);

  // 获取Kernel32核心API地址
  fnLoadLibraryA pfnLoadLibraryA = (fnLoadLibraryA)pfnGetProcAddress((HMODULE)dwBase, "LoadLibraryA");
  printf("pfnLoadLibraryA = %x \n", pfnLoadLibraryA);

  fnGetModuleHandleA pfnGetModuleHandleA = (fnGetModuleHandleA)pfnGetProcAddress((HMODULE)dwBase, "GetModuleHandleA");
  printf("pfnGetModuleHandleA = %x \n", pfnGetModuleHandleA);

  fnVirtualProtect pfnVirtualProtect = (fnVirtualProtect)pfnGetProcAddress((HMODULE)dwBase, "VirtualProtect");
  printf("pfnVirtualProtect = %x \n", pfnVirtualProtect);

  // 有了核心API之后,即可获取到User32.dll的基地址
  pfnLoadLibraryA("User32.dll");
  HMODULE hUser32 = (HMODULE)pfnGetModuleHandleA("User32.dll");
  fnMessageBox pfnMessageBoxA = (fnMessageBox)pfnGetProcAddress(hUser32, "MessageBoxA");
  printf("User32 = > %x \t MessageBox = > %x \n", hUser32, pfnMessageBoxA);

  HMODULE hKernel32 = (HMODULE)pfnGetModuleHandleA("kernel32.dll");
  fnExitProcess pfnExitProcess = (fnExitProcess)pfnGetProcAddress(hKernel32, "ExitProcess");
  printf("Kernel32 = > %x \t ExitProcess = > %x \n", hKernel32, pfnExitProcess);

  // 弹出信息框
  int nRet = pfnMessageBoxA(NULL, "hello lyshark", "MsgBox", MB_YESNO);
  if (nRet == IDYES)
  {
    printf("你点击了YES \n");
  }

  system("pause");
  pfnExitProcess(0);
  return 0;
}

运行上述代码,通过动态调用的方式获取到MessageBox函数内存地址,并将该内存放入到pfnMessageBoxA指针内,最后直接调用该指针即可输出如下图所示的效果图;

与1.15 自实现GetProcAddress相似的内容:

1.15 自实现GetProcAddress

在正常情况下,要想使用`GetProcAddress`函数,需要首先调用`LoadLibraryA`函数获取到`kernel32.dll`动态链接库的内存地址,接着在调用`GetProcAddress`函数时传入模块基址以及模块中函数名即可动态获取到特定函数的内存地址,但在有时这个函数会被保护起来,导致我们无法直接调用该函数获取到特定函数的内存地址,此时就需要自己编写实现`LoadLibrary`

华为云API Arts:用“1+1+5”的模式,为你带来API-First体验

摘要:华为云API Arts是API全生命周期一体化协作平台,支持开发者一站式高效实现API设计、API开发、API测试、API托管、API运维、API变现,助力企业数字化转型。 本文分享自华为云社区《API+DevOps:华为云API Arts一体化平台,端到端呵护您的API》,作者:华为云Paa

一文详解TensorFlow模型迁移及模型训练实操步骤

摘要:本文介绍将TensorFlow网络模型迁移到昇腾AI平台,并执行训练的全流程。然后以TensorFlow 1.15训练脚本为例,详细介绍了自动迁移、手工迁移以及模型训练的操作步骤。 本文分享自华为云社区《将TensorFlow模型快速迁移到昇腾平台》,作者:昇腾CANN。 当前业界很多训练脚本

(转载)自动化测试在美团外卖的实践与落地

(转载)自动化测试在美团外卖的实践与落地 侵删 原文链接: https://tech.meituan.com/2022/09/15/automated-testing-in-meituan.html 美团这个技术博客不少内容都不错的,推荐阅读 1. 项目背景 美团外卖的业务场景比较多元化,除了外卖自

Karmada v1.5发布:多调度组助力成本优化

摘要:在最新发布的1.5版本中,Karmada 提供了多调度组的能力,利用该能力,用户可以实现将业务优先调度到成本更低的集群,或者在主集群故障时,优先迁移业务到指定的备份集群。 本文分享自华为云社区《Karmada v1.5发布!多调度组助力成本优化》,作者:华为云云原生团队。 Karmada 是开

[转帖]IPMItool 简单介绍

IPMItool是一个用于管理和配置,支持智能平台管理接口(IPMI)1.5版和2.0版规范的设备的实用程序。 IPMI是一个开放的标准,监控,记录,回收,库存和硬件实现独立于主CPU,BIOS,以及操作系统的控制权。 服务处理器(或底板管理控制器,BMC)的背后是平台管理的大脑,其主要目的是处理自

CANN训练:模型推理时数据预处理方法及归一化参数计算

摘要:在做基于Ascend CL模型推理时,通常使用的有OpenCV、AIPP、DVPP这三种方式,或者是它们的混合方式,本文比较了这三种方式的特点,并以Resnet50的pytorch模型为例,结合训练营提供的sample,说明了分别是如何实现预处理的。 本文分享自华为云社区《【2023 · CA

新版Bing 搜索后台的.NET 技术栈

微软在今天在Redmond 线下举办媒体一场活动,发布了新版的微软必应,在桌面上推出了测试版,移动版也即将推出。微软首席执行官纳德拉称Al-powered搜索为公司自云15年以来最大的事情。 2023年1月初,微软已经在讨论将OpenAI的技术纳入Word、PowerPoint、Outlook和其他

【玩转鲲鹏DevKit系列】何如快速迁移有源码应用

本文分享自华为云社区《【玩转鲲鹏DevKit系列】何如快速迁移有源码应用》,作者:华为云社区精选 。 源码(也称源程序)是程序员编写的计算机程序的文本形式,不同的编程语言有不同的语法和规则,常见类型包含解释型语言(JAVA/Python 等 )编译型语言(C/C++/GO等)、汇编语言等。程序员可以

今天又和Redis超时杠上了

摘要:究竟是不是cpu占比高的问题导致redis超时的呢? 本文分享自华为云社区《我又和redis超时杠上了》,作者:蓝胖子的编程梦 。 背景 经过上次redis超时排查,并联系云服务商解决之后,redis超时的现象好了一阵子,但是最近又有超时现象报出,但与上次不同的是,这次超时的现象发生在业务高峰