注入攻防篇09-攻击篇-手工映射(上)-PE解析与内存镜像构建

/**
 * @brief 读取PE文件到内存并验证签名
 * @param filePath PE文件完整路径
 * @param pFileSize 返回文件大小
 * @return 成功返回文件缓冲区，失败返回NULL
 */
LPVOID ReadPEFile(const char* filePath, DWORD* pFileSize)
{
    // 打开文件
    HANDLE hFile = CreateFileA(filePath, GENERIC_READ, FILE_SHARE_READ,
                               NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) return NULL;
    // 获取文件大小
    DWORD fileSize = GetFileSize(hFile, NULL);
    if (fileSize == INVALID_FILE_SIZE || fileSize < sizeof(IMAGE_DOS_HEADER))
    {
        CloseHandle(hFile);
        return NULL;
    }
    // 分配内存并读取
    LPVOID pFileBuffer = VirtualAlloc(NULL, fileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    DWORD bytesRead = 0;
    ReadFile(hFile, pFileBuffer, fileSize, &bytesRead, NULL);
    CloseHandle(hFile);

    // 验证DOS签名 "MZ"
    PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
    if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)  // 0x5A4D = "MZ"
    {
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        return NULL;
    }

    // 通过 e_lfanew 找到NT头，验证NT签名 "PE"
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)pFileBuffer + pDosHeader->e_lfanew);
    if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)  // 0x4550 = "PE"
    {
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        return NULL;
    }
    if (pFileSize) *pFileSize = fileSize;
    return pFileBuffer;
}

/**
 * @brief 构建PE的内存镜像（文件布局 → 内存布局）
 * @param pFileBase PE文件数据（磁盘布局）
 * @param pImageSize 返回镜像大小
 * @return 内存镜像指针，失败返回NULL
 */
LPVOID BuildMemoryImage(LPVOID pFileBase, DWORD* pImageSize)
{
    // 获取PE头信息
    PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBase;
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)pFileBase + pDosHeader->e_lfanew);
    // 分配SizeOfImage大小的内存（不是文件大小！）
    // SizeOfImage是PE在内存中展开后的总大小
    DWORD imageSize = pNtHeaders->OptionalHeader.SizeOfImage;
    LPVOID pMemoryImage = VirtualAlloc(NULL, imageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!pMemoryImage) return NULL;
    // 先清零整个镜像（处理.bss等未初始化区域）
    memset(pMemoryImage, 0, imageSize);
    // 复制PE头（DOS头 + NT头 + 节表）
    // 这部分在文件和内存中布局相同，直接复制
    memcpy(pMemoryImage, pFileBase, pNtHeaders->OptionalHeader.SizeOfHeaders);

    // 复制每个节到内存中的正确位置
    PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHeaders);
    for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
    {
        // 节表里有4个关键字段，决定了"从哪复制到哪"：
        // PointerToRawData = 节在【文件】中的偏移
        // VirtualAddress   = 节在【内存】中的偏移（相对于镜像基址）
        // SizeOfRawData    = 节在文件中占用的大小（按512字节对齐）
        // VirtualSize      = 节的实际内容大小
        // 目标地址：内存镜像基址 + 节的VirtualAddress
        LPVOID pDest = (BYTE*)pMemoryImage + pSection[i].VirtualAddress;
        // 源地址：文件基址 + 节的PointerToRawData
        LPVOID pSrc = (BYTE*)pFileBase + pSection[i].PointerToRawData;
        // 【关键】复制大小：取 min(SizeOfRawData, VirtualSize)
        DWORD copySize = min(pSection[i].SizeOfRawData, pSection[i].Misc.VirtualSize);
        if (copySize > 0)
        {
            memcpy(pDest, pSrc, copySize);
        }
    }
    if (pImageSize) *pImageSize = imageSize;
    return pMemoryImage;
}

/**
 * @brief 读取PE文件到内存并验证签名
 * @param filePath PE文件完整路径
 * @param pFileSize 返回文件大小
 * @return 成功返回文件缓冲区，失败返回NULL
 * @details 读取原始PE文件（磁盘布局），验证DOS和NT签名
 */
LPVOID ReadPEFile(const char* filePath, DWORD* pFileSize)
{
    // 打开文件
    HANDLE hFile = CreateFileA(filePath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,NULL );
    if (hFile == INVALID_HANDLE_VALUE)
    {
        std::cout << "  失败：无法打开文件，错误码: " << GetLastError() << "n";
        return NULL;
    }

    // 获取文件大小
    DWORD fileSize = GetFileSize(hFile, NULL);
    if (fileSize == INVALID_FILE_SIZE || fileSize < sizeof(IMAGE_DOS_HEADER))
    {
        std::cout << "  失败：文件大小无效n";
        CloseHandle(hFile);
        return NULL;
    }

    // 分配内存缓冲区
    LPVOID pFileBuffer = VirtualAlloc(NULL, fileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!pFileBuffer)
    {
        std::cout << "  失败：无法分配本地内存n";
        CloseHandle(hFile);
        return NULL;
    }

    // 读取文件内容
    DWORD bytesRead = 0;
    if (!ReadFile(hFile, pFileBuffer, fileSize, &bytesRead, NULL) || bytesRead != fileSize)
    {
        std::cout << "  失败：无法读取文件内容n";
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        CloseHandle(hFile);
        return NULL;
    }
    CloseHandle(hFile);

    // 验证DOS签名
    PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
    if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
    {
        std::cout << "  失败：无效的DOS签名（应为'MZ'）n";
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        return NULL;
    }

    // 检查PE头偏移
    if (pDosHeader->e_lfanew > fileSize - sizeof(IMAGE_NT_HEADERS))
    {
        std::cout << "  失败：无效的PE头偏移n";
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        return NULL;
    }

    // 验证NT签名
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)pFileBuffer + pDosHeader->e_lfanew);
    if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
    {
        std::cout << "  失败：无效的NT签名（应为'PE'）n";
        VirtualFree(pFileBuffer, 0, MEM_RELEASE);
        return NULL;
    }

    // 返回结果
    if (pFileSize)
    {
        *pFileSize = fileSize;
    }
    return pFileBuffer;
}

/**
 * @brief 构建PE的内存镜像(文件布局 → 内存布局)
 *
 * 【为什么需要这一步】
 * PE文件在磁盘上是紧凑排列(节省空间),在内存中需要按VirtualAddress对齐。
 *
 * 【类比】
 * - 磁盘文件 = 压缩包(紧凑,但不能直接用)
 * - 内存镜像 = 解压后的文件夹(占空间,但可以执行)
 *
 * 【操作步骤】
 * 1. 分配SizeOfImage大小内存(不是文件大小!)
 * 2. 复制PE头(包含DOS头+NT头+节表)
 * 3. 复制每个节到VirtualAddress位置(使用 min(SizeOfRawData, VirtualSize))
 * 4. .bss节用0填充(VirtualSize > SizeOfRawData的部分)
 *
 * 【重要】复制大小计算：
 * - 错误做法: if (SizeOfRawData <= VirtualSize) → 会导致.text等节完全不复制
 * - 正确做法: copySize = min(SizeOfRawData, VirtualSize)
 * - 原因: 文件对齐(0x200)和内存对齐(0x1000)不同
 *   例如: .text节 VirtualSize=0x1CC2, SizeOfRawData=0x1E00
 *         如果用 <= 判断会跳过,导致代码段全是0!
 *
 * 【内存布局示意】
 * ┌─────────────┐  ← pMemoryImage (基址0x0)
 * │ PE头        │  拷贝SizeOfHeaders字节
 * ├─────────────┤  ← +VirtualAddress[0] (例如0x1000)
 * │ .text节     │  拷贝SizeOfRawData字节
 * ├─────────────┤  ← +VirtualAddress[1] (例如0x3000)
 * │ .data节     │  拷贝SizeOfRawData字节
 * ├─────────────┤
 * │ .bss节      │  用0填充VirtualSize字节(未初始化数据)
 * └─────────────┘  ← +SizeOfImage
 *
 * @param pFileBase PE文件数据(磁盘布局)
 * @param pImageSize 返回镜像大小
 * @return 内存镜像指针,失败返回NULL
 */
LPVOID BuildMemoryImage(LPVOID pFileBase, DWORD* pImageSize)
{
    // 获取PE头信息
    PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pFileBase;
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)pFileBase + pDosHeader->e_lfanew);

    // 分配SizeOfImage大小的内存(不是文件大小!)
    // SizeOfImage是PE在内存中展开后的总大小
    DWORD imageSize = pNtHeaders->OptionalHeader.SizeOfImage;
    LPVOID pMemoryImage = VirtualAlloc(NULL, imageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (!pMemoryImage)
    {
        return NULL;
    }

    // 先清零整个镜像(处理.bss等未初始化区域)
    memset(pMemoryImage, 0, imageSize);

    // 复制PE头(DOS头+NT头+节表)
    // 这部分在文件和内存中布局相同,直接复制
    memcpy(pMemoryImage, pFileBase, pNtHeaders->OptionalHeader.SizeOfHeaders);
    std::cout << "  复制PE头: " << std::dec << pNtHeaders->OptionalHeader.SizeOfHeaders << " 字节n";

    // 复制每个节到内存中的正确位置
    PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHeaders);
    for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
    {
        // 目标地址:内存镜像基址 + 节的VirtualAddress
        LPVOID pDest = (BYTE*)pMemoryImage + pSection[i].VirtualAddress;

        // 源地址:文件基址 + 节的PointerToRawData
        LPVOID pSrc = (BYTE*)pFileBase + pSection[i].PointerToRawData;

        // 复制大小:取 min(SizeOfRawData, VirtualSize)
        // 原因:文件对齐(0x200)和内存对齐(0x1000)不同,SizeOfRawData 可能 > VirtualSize
        // 例如:.text节 VirtualSize=0x1CC2, SizeOfRawData=0x1E00(向上对齐到512倍数)
        DWORD copySize = min(pSection[i].SizeOfRawData, pSection[i].Misc.VirtualSize);
        if (copySize > 0)
        {
            memcpy(pDest, pSrc, copySize);
        }

        // 处理.bss节:VirtualSize > copySize的部分用0填充
        // 例如:.data节中的未初始化全局变量
        if (pSection[i].Misc.VirtualSize > copySize)
        {
            DWORD bssSize = pSection[i].Misc.VirtualSize - copySize;
            memset((BYTE*)pDest + copySize, 0, bssSize);
        }

        // 输出节信息(Name字段不保证null结尾,需要安全处理)
        char sectionName[9] = {0};
        memcpy(sectionName, pSection[i].Name, 8);
        std::cout << "  映射节区: " << sectionName;
        for (int j = 0; j < 8 - strlen(sectionName); j++)
        {
            std::cout << " ";
        }
        std::cout << " VirtualAddress=0x" << std::hex << pSection[i].VirtualAddress;
        std::cout << " VirtualSize=" << std::dec << pSection[i].Misc.VirtualSize;
        std::cout << " (复制了 " << copySize << " 字节)n";
    }

    // 返回结果
    if (pImageSize)
    {
        *pImageSize = imageSize;
    }
    return pMemoryImage;
}