7.1 實現程式記憶體塊列舉

lyshark發表於2023-09-22
記憶體

在Windows作業系統中，每個程式的虛擬地址空間都被劃分為若干記憶體塊，每個記憶體塊都具有一些屬性，如記憶體大小、保護模式、型別等。這些屬性可以透過VirtualQueryEx函式查詢得到。

該函式可用於查詢程式虛擬地址空間中的記憶體資訊的函式。它的作用類似於Windows作業系統中的Task Manager中的程式選項卡，可以顯示出一個程式的記憶體使用情況、模組列表等資訊。使用VirtualQueryEx函式，可以列舉一個程式的所有記憶體塊。該函式需要傳入要查詢的程式的控制程式碼、基地址和一個MEMORY_BASIC_INFORMATION結構體指標。它會返回當前記憶體塊的基地址、大小、狀態（free/commit/reserve）、保護模式等資訊。

在實現對記憶體塊的列舉之前，我們先透過ReadProcessMemory函式實現一個記憶體遠端記憶體讀取功能，如下程式碼所示，首先，透過OpenProcess函式開啟程式控制程式碼，獲得當前程式的操作許可權。然後，呼叫EnumMemory函式，傳入程式控制程式碼以及起始地址和終止地址引數，依次讀取每一頁記憶體，透過迴圈列印其記憶體資料。

#include <iostream>
#include <windows.h>

// 列舉記憶體實現
void EnumMemory(HANDLE Process, DWORD BeginAddr, DWORD EndAddr)
{
  // 每次讀入長度
  const DWORD pageSize = 1024;

  BYTE page[pageSize];
  DWORD tmpAddr = BeginAddr;
  while (tmpAddr <= EndAddr)
  {
    ReadProcessMemory(Process, (LPCVOID)tmpAddr, &page, pageSize, 0);
    for (int x = 0; x < pageSize; x++)
    {
      if (x % 15 == 0)
      {
        printf("| 0x%08X \n", tmpAddr + x);
      }
      printf("0x%02X ", page[x]);
    }
    tmpAddr += pageSize;
  }
}

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

  // 開啟當前程式
  process = OpenProcess(PROCESS_ALL_ACCESS, false, GetCurrentProcessId());

  // 列舉記憶體 從0x401000 - 0x7FFFFFFF
  EnumMemory(process, 0x00401000, 0x7FFFFFFF);

  system("pause");
  return 0;
}

上述程式碼簡單明瞭，易於理解，但並沒有實現過濾特定記憶體屬性的功能。如果需要對特定型別的記憶體進行分析，需要結合VirtualQueryEx函式實現記憶體屬性的查詢和過濾。

接著我們進入本章的重點，實現列舉程式記憶體塊，要實現該功能首先讀者必須要了解一個結構體_SYSTEM_INFO該結構體是系統資訊結構，可用於儲存系統硬體和系統配置資訊，而我們所需要的記憶體塊資料同樣可以使用該結構進行儲存。

根據具體需求，可以透過呼叫GetSystemInfo函式來獲得_SYSTEM_INFO結構體的資訊。GetSystemInfo函式可以返回系統的硬體資訊，包括有多少個處理器，每個處理器有多少個核心，系統頁大小等資訊，該結構體的定義如下所示；

    typedef struct _SYSTEM_INFO {
      union {
      DWORD dwOemId;                          // 相容性保留
      struct {
        WORD wProcessorArchitecture;          // 作業系統處理器體系結構
        WORD wReserved;                       // 保留
      } DUMMYSTRUCTNAME;
      } DUMMYUNIONNAME;
      DWORD     dwPageSize;                   // 頁面大小和頁面保護和承諾的粒度
      LPVOID    lpMinimumApplicationAddress;  // 指向應用程式和dll可訪問的最低記憶體地址的指標
      LPVOID    lpMaximumApplicationAddress;  // 指向應用程式和dll可訪問的最高記憶體地址的指標
      DWORD_PTR dwActiveProcessorMask;        // 處理器掩碼
      DWORD     dwNumberOfProcessors;         // 當前組中邏輯處理器的數量
      DWORD     dwProcessorType;              // 處理器型別，相容性保留
      DWORD     dwAllocationGranularity;      // 虛擬記憶體的起始地址的粒度
      WORD      wProcessorLevel;              // 處理器級別
      WORD      wProcessorRevision;           // 處理器修訂
    } SYSTEM_INFO, *LPSYSTEM_INFO;

接著就是要查詢記憶體塊的狀態了，我們可透過VirtualQueryEx函式實現查詢程式虛擬地址空間中的記憶體資訊，其原型定義如下：

SIZE_T VirtualQueryEx(
  HANDLE                    hProcess,
  LPCVOID                   lpAddress,
  PMEMORY_BASIC_INFORMATION lpBuffer,
  SIZE_T                    dwLength
);

引數說明：

  • hProcess：程式控制程式碼。需要查詢的程式的控制程式碼
  • lpAddress：基地址。需要查詢的記憶體塊的基地址
  • lpBuffer：記憶體資訊緩衝區。 PMEMORY_BASIC_INFORMATION 結構指標，用於儲存查詢結果。它包含了取得的記憶體塊資訊，如基地址、保護屬性、狀態、大小等
  • dwLength：緩衝區大小。緩衝區的大小，以位元組為單位。如果緩衝區太小，則函式將返回指定的記憶體塊資訊長度存放到此處，不會寫入完整的資訊

該函式返回實際填充到緩衝區中的位元組數。如果函式失敗，則返回0。當我們需要了解特定程式的記憶體使用情況時，可以使用VirtualQueryEx()函式列舉程式記憶體中的所有記憶體塊，並按需查詢其中的屬性值。

#include <iostream>
#include <windows.h>
#include <Psapi.h>

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

// 列舉特定程式記憶體塊資訊
VOID ScanProcessMemory(HANDLE hProc)
{
  SIZE_T stSize = 0;
  PBYTE pAddress = (PBYTE)0;
  SYSTEM_INFO sysinfo;
  MEMORY_BASIC_INFORMATION mbi = { 0 };

  //獲取頁的大小
  ZeroMemory(&sysinfo, sizeof(SYSTEM_INFO));
  GetSystemInfo(&sysinfo);

  // 得到的映象基地址
  pAddress = (PBYTE)sysinfo.lpMinimumApplicationAddress;

  printf("------------------------------------------------------------------------ \n");
  printf("開始地址 \t 結束地址 \t 大小 \t 狀態 \t 記憶體型別 \t 頁面屬性 \n");
  printf("------------------------------------------------------------------------ \n");
  
  // 判斷只要當前地址小於最大地址就迴圈
  while (pAddress < (PBYTE)sysinfo.lpMaximumApplicationAddress)
  {
    // 對結構體進行初始化
    ZeroMemory(&mbi, sizeof(MEMORY_BASIC_INFORMATION));

    // 查詢記憶體屬性
    stSize = VirtualQueryEx(hProc, pAddress, &mbi, sizeof(MEMORY_BASIC_INFORMATION));

    if (stSize == 0)
    {
      pAddress += sysinfo.dwPageSize;
      continue;
    }

    // 輸出查詢結果
    printf("0x%08X \t 0x%08X \t %8d K \t ", mbi.BaseAddress, ((DWORD)mbi.BaseAddress + (DWORD)mbi.RegionSize), mbi.RegionSize >> 10);

    // 輸出狀態
    switch (mbi.State)
    {
      case MEM_FREE: printf("空閒 \t"); break;
      case MEM_RESERVE: printf("保留 \t"); break;
      case MEM_COMMIT: printf("提交 \t"); break;
      default: printf("未知 \t"); break;
    }

    // 輸出型別
    switch (mbi.Type)
    {
      case MEM_PRIVATE:   printf("私有  \t"); break;
      case MEM_MAPPED:    printf("對映  \t"); break;
      case MEM_IMAGE:     printf("映象  \t"); break;
      default: printf("未知  \t"); break;
    }

    if (mbi.Protect == 0)
    {
      printf("---");
    }
    else if (mbi.Protect & PAGE_EXECUTE)
    {
      printf("E--");
    }
    else if (mbi.Protect & PAGE_EXECUTE_READ)
    {
      printf("ER-");
    }
    else if (mbi.Protect & PAGE_EXECUTE_READWRITE)
    {
      printf("ERW");
    }
    else if (mbi.Protect & PAGE_READONLY)
    {
      printf("-R-");
    }
    else if (mbi.Protect & PAGE_READWRITE)
    {
      printf("-RW");
    }
    else if (mbi.Protect & PAGE_WRITECOPY)
    {
      printf("WCOPY");
    }
    else if (mbi.Protect & PAGE_EXECUTE_WRITECOPY)
    {
      printf("EWCOPY");
    }

    printf("\n");

    // 每次迴圈累加記憶體塊的位置
    pAddress = (PBYTE)mbi.BaseAddress + mbi.RegionSize;
  }
}

int main(int argc, char* argv[])
{
  // 開啟程式
  HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());

  // 開始列舉
  ScanProcessMemory(hProc);
  CloseHandle(hProc);

  system("pause");
  return 0;
}

執行上述程式碼片段則首先透過GetCurrentProcessId()得到自身程式的PID號，接著透過呼叫ScanProcessMemory函式實現對自身程式記憶體塊的列舉功能，最終輸出如下圖所示的效果；

當然了雖然上述程式碼可以實現對記憶體塊的列舉功能，但是在實際的開發場景中我們還是需要將列舉結果儲存起來以便後期呼叫，此時我們可以考慮在全域性定義vector容器，容器的屬性為每一個記憶體塊的MEMORY_BASIC_INFORMATION屬性，當需要查詢時只需要列舉這個容器並迴圈輸出該容器內的資料即可，改進後的程式碼如下所示；

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

using namespace std;

// 列舉指定程式所有記憶體塊
static bool ScanProcessMemory(HANDLE hProcess, OUT vector<MEMORY_BASIC_INFORMATION>& memories)
{
  // 如果 hProcess 為空則結束執行
  assert(hProcess != nullptr);

  // 初始化容器並設定容量
  memories.clear();
  memories.reserve(200);

  // 獲取 PageSize 和地址粒度
  SYSTEM_INFO sysInfo = { 0 };
  GetSystemInfo(&sysInfo);

  // 定義基本的記憶體結構
  const char* p = (const char*)sysInfo.lpMinimumApplicationAddress;
  MEMORY_BASIC_INFORMATION memInfo = { 0 };

  // 開始遍歷記憶體
  while (p < sysInfo.lpMaximumApplicationAddress)
  {
    // 獲取程式虛擬記憶體塊緩衝區位元組數
    size_t size = VirtualQueryEx(
      hProcess,                             // 程式控制程式碼
      p,                                    // 要查詢記憶體塊的基地址指標
      &memInfo,                             // 接收記憶體塊資訊的 MEMORY_BASIC_INFORMATION 物件
      sizeof(MEMORY_BASIC_INFORMATION32)    // 緩衝區大小
      );

    if (size != sizeof(MEMORY_BASIC_INFORMATION32))
    {
      break;
    }

    // 將記憶體塊資訊追加到容器內
    memories.push_back(memInfo);

    // 移動指標
    p += memInfo.RegionSize;
  }

  // 容器大於0則返回
  return memories.size() > 0;
}

int main(int argc, char* argv[])
{
  // 存放程式記憶體塊的陣列
  vector<MEMORY_BASIC_INFORMATION> vec;

  // 開啟自身程式
  HANDLE handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());

  // 遍歷該程式的記憶體
  if (ScanProcessMemory(handle, vec))
  {
    printf("------------------------------------------------------------------------ \n");
    printf("開始地址 \t 結束地址 \t 大小 \t 狀態 \t 記憶體型別 \t 頁面屬性 \n");
    printf("------------------------------------------------------------------------ \n");
    
    // 此處迴圈遍歷結構
    for (int i = 0; i < vec.size(); i++)
    {
      printf("0x%08X \t 0x%08X \t %8d K \t ", vec[i].BaseAddress, ((DWORD)vec[i].BaseAddress + (DWORD)vec[i].RegionSize), vec[i].RegionSize >> 10);

      switch (vec[i].State)
      {
      case MEM_FREE: printf("空閒 \t"); break;
      case MEM_RESERVE: printf("保留 \t"); break;
      case MEM_COMMIT: printf("提交 \t"); break;
      default: printf("未知 \t"); break;
      }

      switch (vec[i].Type)
      {
      case MEM_PRIVATE: printf("私有  \t"); break;
      case MEM_MAPPED: printf("對映  \t"); break;
      case MEM_IMAGE: printf("映象  \t"); break;
      default: printf("未知  \t"); break;
      }

      if (vec[i].Protect == 0)
      {
        printf("---");
      }
      else if (vec[i].Protect & PAGE_EXECUTE)
      {
        printf("E--");
      }
      else if (vec[i].Protect & PAGE_EXECUTE_READ)
      {
        printf("ER-");
      }
      else if (vec[i].Protect & PAGE_EXECUTE_READWRITE)
      {
        printf("ERW");
      }
      else if (vec[i].Protect & PAGE_READONLY)
      {
        printf("-R-");
      }
      else if (vec[i].Protect & PAGE_READWRITE)
      {
        printf("-RW");
      }
      else if (vec[i].Protect & PAGE_WRITECOPY)
      {
        printf("WCOPY");
      }
      else if (vec[i].Protect & PAGE_EXECUTE_WRITECOPY)
      {
        printf("EWCOPY");
      }
      printf("\n");
    }
  }
  system("pause");
  return 0;
}

讀者可編譯並自行執行上述程式碼，觀察輸出效果其與第一個案例中的效果保持一致，此處僅僅只是透過容器中轉了引數傳遞，輸出效果圖如下所示；

對於記憶體塊中的範圍區間同樣可實現繼續查詢，例如在開始地址0x5DF00000-0x5DF01000這個記憶體區間內，可能灰灰劃分為更多的子塊，當Basicinfo.State記憶體屬性中的子塊屬性為MEM_COMMIT時，我們還可以繼續呼叫VirtualQuery函式對這個大記憶體塊內的子記憶體塊進行更加細緻的解析效果，這段程式碼如下所示；

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

int main(int argc, char* argv[])
{
  DWORD Addres = 0, Size = 0;
  MEMORY_BASIC_INFORMATION Basicinfo = {};

  // 遍歷程式所有分頁, 輸出內容
  while (VirtualQuery((LPCVOID)Addres, &Basicinfo, sizeof(MEMORY_BASIC_INFORMATION)))
  {
    Size = Basicinfo.RegionSize;

    printf("[+] 開始地址: 0x%08X \t 結束地址: 0x%08X \t 大小: %7d K \t 型別: ",
      Basicinfo.BaseAddress, ((DWORD)Basicinfo.BaseAddress + (DWORD)Basicinfo.RegionSize), Basicinfo.RegionSize >> 10);

    switch (Basicinfo.Type)
    {
    case MEM_PRIVATE:   printf("私有  \t"); break;
    case MEM_MAPPED:    printf("對映  \t"); break;
    case MEM_IMAGE:     printf("映象  \t"); break;
    default:      printf("未知  \t"); break;
    }

    printf(" \t 狀態: ");
    switch (Basicinfo.State)
    {
    case MEM_FREE:      printf("空閒 \n"); break;
    case MEM_RESERVE:   printf("保留 \n"); break;
    case MEM_COMMIT:    printf("提交 \n"); break;
    default:      printf("未知 \n"); break;
    }

    // 如果是提交狀態的記憶體區域，那麼遍歷所有塊中的資訊
    if (Basicinfo.State == MEM_COMMIT)
    {
      // 遍歷所有基址是 Address
      LPVOID BaseBlockAddress = (LPVOID)Addres;
      DWORD BlockAddress = Addres;
      DWORD dwBlockSize = 0;

      // 遍歷大記憶體塊中的小記憶體塊
      while (VirtualQuery((LPVOID)BlockAddress, &Basicinfo, sizeof(Basicinfo)))
      {
        if (BaseBlockAddress != Basicinfo.AllocationBase)
        {
          break;
        }
        printf("[*] ---> 塊地址: 0x%08X \t ", BlockAddress);
        // 檢視記憶體狀態，對映方式
        switch (Basicinfo.Type)
        {
        case MEM_PRIVATE:   printf("私有  \t "); break;
        case MEM_MAPPED:    printf("對映  \t "); break;
        case MEM_IMAGE:     printf("映象  \t "); break;
        default:      printf("未知  \t "); break;
        }

        if (Basicinfo.Protect == 0)
          printf("---");
        else if (Basicinfo.Protect & PAGE_EXECUTE)
          printf("E--");
        else if (Basicinfo.Protect & PAGE_EXECUTE_READ)
          printf("ER-");
        else if (Basicinfo.Protect & PAGE_EXECUTE_READWRITE)
          printf("ERW");
        else if (Basicinfo.Protect & PAGE_READONLY)
          printf("-R-");
        else if (Basicinfo.Protect & PAGE_READWRITE)
          printf("-RW");
        else if (Basicinfo.Protect & PAGE_WRITECOPY)
          printf("WCOPY");
        else if (Basicinfo.Protect & PAGE_EXECUTE_WRITECOPY)
          printf("EWCOPY");
        printf("\n");

        // 計算所有相同塊大小
        dwBlockSize += Basicinfo.RegionSize;
        // 累加記憶體塊的位置
        BlockAddress += Basicinfo.RegionSize;
      }
      // 有可能大小為空
      Size = dwBlockSize ? dwBlockSize : Basicinfo.RegionSize;
    }
    // 下一個區域記憶體資訊
    Addres += Size;
  }

  system("pause");
  return 0;
}

當上述程式碼執行後，我們就可以獲取到當前記憶體中有多少個記憶體塊，以及每一個記憶體塊的屬性資訊，如下圖所示；

本文作者： 王瑞
本文連結： https://www.lyshark.com/post/c09766a2.html
版權宣告： 本部落格所有文章除特別宣告外，均採用 BY-NC-SA 許可協議。轉載請註明出處！

相關文章