深入分析PE结构(三)

分享者才是学习中最大的受益者！

0x0新增节

前言

手动新增一个节表和节，保证修改后的程序能正确执行.

PE结构

image-20220204152216145

整体过程

SizeOfHeaders：DOS + DOS stub(垃圾数据) + NT头(PE标记 + 标准PE头 + 可选PE头) + 已存在节表 —>>对齐之后的大小

SizeOfHeaders是不能随便变的，代价太大了

1、新增一个节

2、在新增一个节表(40个字节)

判断条件：

我们要保证在我们新增的这个节表后边，还有40个0的空间，所以我们要计算的是节表剩下的空间够不够80个字节，还有没有两个节表

导出我们的计算公式：

SizeOfHeader - (DOS + DOS stub(垃圾数据) + PE标记 + 标准PE头 + 可选PE头 + 已存在节表) >= 2个节表的大小(80个字节)

3、需要修改的数据

  1. 1) 添加一个新的节(可以copy一份)
  3. 2) 在新增节后面 填充一个节大小的000
  5. 3) 修改标准PE头中节的数量(NumberOfSections参数)
  7. 4) 修改内存中整个PE文件的映射的尺寸(可选PE头中sizeOfImage参数)
  9. 5) 再原有数据的最后，新增一个节的数据(内存对齐的整数倍)
  11. 6）修正新增节表的属性

手动分析-1

先把我们要操作的exe复制一份出来，一会可以用作参考

判断空间

节表从这里开始

image-20220131174500396

判断有几个节

  1. 0008

有8个节，所以有8个节表

image-20220131174653422

一个节表40个字节

第一个节表

image-20220131180040301

第二个节表

image-20220131180114356

这下面都是空白区，足够80个字节(2个节表)了

image-20220131180218835

添加新节表

把第一个.text节表 粘贴过来 放到最后面

image-20220131180513970

修改NumberOfSections参数

修改标准PE头中节的数量(NumberOfSections参数)

image-20220131180747473

修改内存中整个PE文件的映射的尺寸(可选PE头中sizeOfImage参数)

注：在可选PE头中的后56个字节

image-20220131180858866

标准PE头

image-20220131181100362

修改sizeOfImage参数

我们找到sizeOfImage了

  1. 0002E000

image-20220131181440911

进行修改，给1000个字节

  1. 0002F000

image-20220131183635101

填充新节

开始插入，进行添加节

16进制1000个字节对应十进制4096

image-20220203200747703

image-20220203200818355

这里注意：别碰原来的数据

image-20220203201046757

修改新增的节表

注意是小端存储！

image-20220203201537193

拿出之前复制的exe，进行参考

image-20220203201857395

第一个参数是：Name，8个字节

image-20220203202000763

第二个参数是：VirtualSize，它是内存中大小(对齐前的长度).

这里有个小技巧，我们可以把它和文件中大小(对齐后的长度)写成一样的大小

我们要加的值是1000

  1. 00 10 00 00

image-20220203203124094

第三个参数是：VirtualAddress，它是内存中偏移(该块的RVA)

我们要看最后一个节表

image-20220203204758797

这里要看他两谁大

  1. 内存中大小(对齐前的长度)
  2. 文件中大小(对齐后的长度)

要用内存中偏移(该块的RVA)+上面两者大的那个

  1. 0002D000 + 1000 = 0002E000

然后 按照1000进行对齐，在根据小端存储

最后的结果就是

  1. 00 E0 02 00

第四个参数是：SizeOfRawData，它是文件中大小(对齐后的长度)

我们要加的值是1000

  1. 00 10 00 00

第五个参数是：PointerToRawData，它是文件中偏移.

继续看最后一个节表

image-20220203210121424

要用文件中偏移+文件中大小(对齐后的长度)

  1. 00013A00 + 00000000 = 00013A00

然后使用小端存储

  1. 00 3A 01 00

image-20220203212603538

最后是节表的属性

因为这个节，是我从.texe复制过来的，所以我就不用改了

保存 尝试执行

重新看一下

9个节 没有问题

image-20220203211002867

image-20220203212943505

手动分析-2

考虑另一种极端情况

打开notepad.exe

我们可以看到节表后又跟了一堆数据，他们是有用的数据，我们不能去动

image-20220204151701261

这块数据不能干掉，也不能动，但是我们没地方进行新增节

同时节表是连续存储的，不可以断掉的

重新看PE结构

image-20220204152259001

我们的思路就是

把PE结构中间的垃圾数据给干掉，然后把下面的PE标记往上提

只需要修改一个参数：DOS头中的e_lfanew1参数

image-20220204153239390

进行覆盖数据

image-20220204153857044

覆盖成功

image-20220204154008276

原先这块数据就没有用了 全部补0即可

image-20220204154037750

image-20220204154136028

最后修改DOS头中的e_lfanew1参数 把它指向40即可

image-20220204154326479

双击 依然可以正常运行

image-20220204154433908

核心代码

  1. DWORD ReadPEFile(IN LPSTR lpszFile, OUT LPVOID* pFileBuffer)
  2. {
  4.     FILE* pFile = NULL;
  5.     DWORD fileSize = 0; 
  6.     LPVOID pTempFileBuffer = NULL;
  8.     //打开文件
  9.     pFile = fopen(lpszFile,"rb"); //lpszFile是当作参数传递进来
  10.     if (!pFile)
  11.     {
  12.         printf("打开文件失败!\r\n");
  13.         return 0;
  14.     }
  16.     //读取文件内容后，获取文件的大小
  17.     fseek(pFile,0,SEEK_END);
  18.     fileSize = ftell(pFile);
  19.     fseek(pFile,0,SEEK_SET);
  21.     //动态申请内存空间
  22.     pTempFileBuffer = malloc(fileSize); 
  24.     if (!pTempFileBuffer)
  25.     {
  26.         printf("内存分配失败!\r\n");
  27.         fclose(pFile);
  28.         return 0;
  29.     }
  31.     //根据申请到的内存空间，读取数据
  33.     size_t n = fread(pTempFileBuffer,fileSize,1,pFile);
  34.     if (!n)
  35.     {
  36.         printf("读取数据失败!\r\n");
  37.         free(pTempFileBuffer);   // 释放内存空间
  38.         fclose(pFile);           // 关闭文件流
  39.         return 0;
  40.     }
  42.     //数据读取成功，关闭文件
  43.     *pFileBuffer = pTempFileBuffer;  // 将读取成功的数据所在的内存空间的首地址放入指针类型pFileBuffer
  44.     pTempFileBuffer = NULL;  // 初始化清空临时申请的内存空间
  45.     fclose(pFile);           // 关闭文件
  46.     return fileSize;         // 返回获取文件的大小
  47. }
  49. //通过复制FileBuffer并增加1000H到新的ImageBuffer里面
  50. DWORD CopyFileBufferToNewImageBuffer(IN LPVOID pFileBuffer,IN size_t fileSize,OUT LPVOID* pNewImageBuffer)
  51. {
  52.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  53.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  54.     PIMAGE_FILE_HEADER pPEHeder = NULL;
  55.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  56.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  57.     PIMAGE_SECTION_HEADER pLastSectionHeader = NULL;
  58.     LPVOID pTempNewImageBuffer = 0;
  59.     DWORD sizeOfFile = 0;
  60.     DWORD numberOfSection = 0;
  61.     DWORD okAddSections = 0;
  63.     //判断读取pFileBuffer读取是否成功
  64.     if (!pFileBuffer)
  65.     {
  66.         printf("缓冲区指针无效\r\n");
  67.         return 0;
  68.     }
  70.     //判断是否为MZ标志
  72.     if ((*(PWORD)pFileBuffer) != IMAGE_DOS_SIGNATURE)// IMAGE_DOS_SIGNATURE --> MZ
  73.     {
  74.         printf("不是一个有效的MZ标志\r\n");
  75.         return 0;
  76.     }
  78.     //判断是否为PE标志
  79.     pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
  80.     if (*((PWORD)((DWORD)pFileBuffer + pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE) // IMAGE_NT_SIGNATURE --> PE
  81.     {
  82.         printf("不是有效的PE标志\r\n");
  83.         return 0;
  84.     }
  86. //申请开辟内存空间
  88.     sizeOfFile = fileSize+0x1000;
  89.     pTempNewImageBuffer = malloc(sizeOfFile);
  91.     //判断内存空间开辟是否成功
  92.     if (!pTempNewImageBuffer)
  93.     {
  94.         printf("pTempNewImageBuffer开辟内存空间失败\r\n");
  95.         return 0;
  96.     }
  98.     //初始化内存内容
  99.     memset(pTempNewImageBuffer,0,sizeOfFile);
  101.     //初始化完成之后，先把为修改的内存空间全部拷贝到新的内存空间
  102.     memcpy(pTempNewImageBuffer,pFileBuffer,fileSize);
  104.     //定位Dos头地址
  105.     pDosHeader = (PIMAGE_DOS_HEADER)(pTempNewImageBuffer);
  107.     //定位NT头的地址
  108.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pTempNewImageBuffer+pDosHeader->e_lfanew);
  110.     //定位标志PE头地址
  111.     pPEHeder = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader)+0x04);//PE SIGNATURE 站4个字节
  113.     //定位可选PE头地址
  114.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)(((DWORD)pPEHeder)+IMAGE_SIZEOF_FILE_HEADER);//IMAGE_SIZEOF_FILE_HEADER -> 20个字节
  116.     //定位第一个节表地址
  117.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeder->SizeOfOptionalHeader);
  119.     //定位最后一个节表的地址
  120.     pLastSectionHeader = &pSectionHeader[pPEHeder->NumberOfSections-1];
  122.     //判断是否有足够的空间添加一个节表
  123.     //判断条件:
  124.     /*
  125.         SizeOfHeader - (DOS + 垃圾数据 + PE标记 + 标准PE头 + 可选PE头 + 已存在节表) >= 2个节表的大小
  126.         SizeOfHeader在可选PE头里面
  127.     */
  129.     okAddSections = (DWORD)(pOptionHeader->SizeOfHeaders - (pDosHeader->e_lfanew + 0x04 + \
  130.         sizeof(PIMAGE_FILE_HEADER) + pPEHeder->SizeOfOptionalHeader + sizeof(PIMAGE_SECTION_HEADER) \
  131.         * pPEHeder->NumberOfSections));
  133.     if (okAddSections < 2*sizeof(PIMAGE_SECTION_HEADER))
  134.     {
  135.         printf("这个exe文件头不剩余空间不够\r\n");
  136.         free(pTempNewImageBuffer);
  137.         return 0;
  138.     }
  140. //修改
  142.     //初始化新节表信息
  143.     PWORD pNumberOfSection = &amp;pPEHeder->NumberOfSections;
  144.     PDWORD pSizeOfImage = &amp;pOptionHeader->SizeOfImage;
  146.     numberOfSection = pPEHeder->NumberOfSections;
  147.     PVOID pSecName = &amp;pSectionHeader[numberOfSection].Name;
  148.     PDWORD pSecMisc = &amp;pSectionHeader[numberOfSection].Misc.VirtualSize;
  149.     PDWORD pSecVirtualAddress = &amp;pSectionHeader[numberOfSection].VirtualAddress;
  150.     PDWORD pSecSizeOfRawData = &amp;pSectionHeader[numberOfSection].SizeOfRawData;
  151.     PDWORD pSecPointToRawData = &amp;pSectionHeader[numberOfSection].PointerToRawData;
  152.     PDWORD pSecCharacteristics = &amp;pSectionHeader[numberOfSection].Characteristics;
  154.     //修改PE文件头里面的节数量信息
  156.     printf("*pNumberOfSection:%#X \r\n",pPEHeder->NumberOfSections);
  157.     *pNumberOfSection = pPEHeder->NumberOfSections + 1;
  158.     printf("*pNumberOfSection:%#X \r\n",pPEHeder->NumberOfSections);
  160.     //修改PE可选头里面SizeOfImage信息
  161.     printf("*pSizeOfImage:%#X \r\n",pOptionHeader->SizeOfImage);
  162.     *pSizeOfImage = pOptionHeader->SizeOfImage + 0x1000;
  163.     printf("*pSizeOfImage:%#X \r\n",pOptionHeader->SizeOfImage);
  165.     //向节表中添加数据
  167.     memcpy(pSecName,".newSec",8);
  168.     *pSecMisc = 0x1000;
  170.     //使用上面的公式
  171.     //判断出要添加的值
  172.     DWORD add_size = pLastSectionHeader->Misc.VirtualSize > pLastSectionHeader->SizeOfRawData?\
  173.         pLastSectionHeader->Misc.VirtualSize:pLastSectionHeader->SizeOfRawData;
  174.     //上面是个三目运算符
  176.     printf("pLastSectionHeader: %#X \r\n",pLastSectionHeader);
  177.     printf("add_size: %#X \r\n",add_size);
  178.     printf("numberOfSection: %#X \r\n",pPEHeder->NumberOfSections);
  179.     printf("pLastSectionHeader->Misc.VirtualSize: %#X \r\n",pLastSectionHeader->Misc.VirtualSize);
  180.     printf("pLastSectionHeader->SizeOfRawData: %#X \r\n",pLastSectionHeader->SizeOfRawData);
  181.     printf("add_size: %#X \r\n",add_size);
  183.     *pSecVirtualAddress = pLastSectionHeader->VirtualAddress + add_size;
  185.     //SectionAlignment对齐
  187.     if (*pSecVirtualAddress % pOptionHeader->SectionAlignment)
  188.     {
  189.         *pSecVirtualAddress = *pSecVirtualAddress / pOptionHeader->SectionAlignment * \
  190.             pOptionHeader->SectionAlignment + pOptionHeader->SectionAlignment;
  191.     }
  193.     *pSecSizeOfRawData = 0x1000;
  194.     *pSecPointToRawData = pLastSectionHeader->PointerToRawData + pLastSectionHeader->SizeOfRawData;
  196.     //FileAlignment对齐
  198.     if (*pSecPointToRawData % pOptionHeader->FileAlignment)
  199.     {
  200.         *pSecPointToRawData = *pSecPointToRawData / pOptionHeader->FileAlignment * \
  201.             pOptionHeader->FileAlignment + pOptionHeader->FileAlignment;
  202.     }
  204.     *pSecCharacteristics = 0xFFFFFFFF;
  206.     *pNewImageBuffer = pTempNewImageBuffer;
  207.     pTempNewImageBuffer = NULL;
  209.     return sizeOfFile;
  210. }
  212. BOOL MemeryTOFile(IN LPVOID pMemBuffer,IN size_t size,OUT LPSTR lpszFile)
  213. {
  214.     FILE* fp = NULL;
  215.     fp = fopen(lpszFile, "wb+");
  216.     if (!fp)  //  这里我刚开始写漏了一个等于号，变成复制NULL了，导致错误
  217. //  if(fp == NULL)  可以这么写，没问题
  218.     {
  219.         fclose(fp);
  220.         return FALSE;
  221.     }
  222.     fwrite(pMemBuffer,size,1,fp);
  223.     fclose(fp);
  224.     fp = NULL;
  225.     return TRUE;
  226. }
  1. VOID NewSectionsInCodeSec()
  2. {
  3.     LPVOID pFileBuffer = NULL;
  4.     LPVOID pNewImageBuffer = NULL;
  5.     BOOL isOK = FALSE;
  6.     DWORD size1 = 0;
  7.     DWORD size2 = 0;
  9.     //File-->FileBuffer
  10.     size1 = ReadPEFile(FilePath_In,&amp;pFileBuffer);
  11.     if (size1 == 0 || !pFileBuffer)
  12.     {
  13.         printf("文件-->缓冲区失败\r\n");
  14.         return ;
  15.     }
  16.     printf("fileSize - Final: %#X \r\n",size1);
  18.     //FileBuffer-->NewImageBuffer
  19.     size2 = CopyFileBufferToNewImageBuffer(pFileBuffer,size1,&amp;pNewImageBuffer);
  20.     if (size2 == 0 || !pFileBuffer)
  21.     {
  22.         printf("FileBuffer-->NewImageBuffer失败\r\n");
  23.         free(pFileBuffer);
  24.         return ;
  25.     }
  26.     printf("sizeOfFile - Final: %#X \r\n",size2);
  27.     //NewImageBuffer-->文件
  28.     isOK = MemeryTOFile(pNewImageBuffer,size2,FilePath_Out);
  29.     if (isOK)
  30.     {
  31.         printf("新增节表和节存盘成功\r\n");
  32.        return ;
  33.     }
  35.     //释放内存
  36.     free(pFileBuffer);
  37.     free(pNewImageBuffer);
  38. }
  1. // test2.cpp:程序执行代码
  2. #include "stdafx.h"
  3. #include "test.h"
  5. int main(int argc, char* argv[])
  6. {
  7.     NewSectionsInCodeSec();
  8.     printf("Hello World! Cntf\r\n");
  9.     return 0;
  10. }

手动分析-3

继续考虑一种更极端的情况

DOS头到PE标记中的垃圾数据是由编译器生成的，那么如果我们提升了PE标记，空间任然不够我们去新增一个节表

这个时候，我们就要去扩大最后一个节

0x2扩大节

前言

之前我们都是在空白区域，去新增我们的节

但是，当空白区域无法满足我们的要求，我们就要去扩大节

整体流程

  1. 1、拉伸到内存
  3. 2、分配一块新的空间:SizeOfImage + Ex(要扩大的节)  
  5. 3、将最后一个节的SizeOfRawData(文件中对齐后的大小)和VirtualSize(内存中对齐前的大小)改成一样大，改成N
  7. N是SizeOfRawData(文件中对齐后的大小)和VirtualSize(内存中对齐前的大小)两者之间，大的那个值
  9. N = 大的那个值 + Ex
  11. SizeOfRawData = VirtualSize = N 
  13. 4、修改SizeOfImage大小                       
  15.    SizeOfImage = SizeOfImage + Ex

image-20220204160435499

核心代码

  1. // test.h: 头文件
  3. #if !defined(AFX_test_H__C24C6881_E003_41F7_BE14_24DDA1702CCD__INCLUDED_)
  4. #define AFX_test_H__C24C6881_E003_41F7_BE14_24DDA1702CCD__INCLUDED_
  6. #if _MSC_VER > 1000
  7. #pragma once
  8. #endif // _MSC_VER > 1000
  10. #include <string.h>
  11. #include <windows.h>
  12. #include <stdlib.h>
  14. #define FilePath_In         "C:\\notepad.exe"
  15. #define FilePath_Out        "C:\\notepadnewpes.exe"
  17. #define MESSAGEBOXADDR      0x77D5050B
  18. #define SHELLCODELENGTH     0x12 //16进制的，转换为十进制就是18
  20. extern BYTE ShellCode[];
  22. //读文件 --->FileBuffer
  23. DWORD ReadPEFile(IN LPSTR lpszFile,OUT LPVOID* pFileBuffer);
  25. //写到ImageBuffer,FileBuffer ---> ImageBuffer
  26. DWORD CopyFileBufferToImageBuffer(IN LPVOID pFileBuffer,OUT LPVOID* pImageBuffer);
  28. //写到NewImageBuffer, FileBuffer ---> NewImageBuffer
  29. DWORD CopyFileBufferToNewImageBuffer(IN LPVOID pFileBuffer,IN size_t fileSize,OUT LPVOID* pNewImageBuffer);
  31. //写到NewImageBuffer, 这里是从ImageBuffer写入 ---> NewImageBuffer
  32. DWORD FileBufferToModifyImageBuffer(IN LPVOID pFileBuffer,OUT LPVOID* pNewImageBuffer);
  34. DWORD CopyImageBufferToNewBuffer(IN LPVOID pImageBuffer,OUT LPVOID* pNewBuffer);
  36. //写到pNewBuffer里面，从pNewImageBuffer写入 ---> pNewBuffer
  37. //DWORD ModifyImageBufferToNewBuffer(IN LPVOID pNewImageBuffer,OUT LPVOID* pNewBuffer);
  39. //对齐大小
  40. DWORD AlignLength(DWORD Actuall_size,DWORD Align_size);
  42. //将MemBuffer写入到硬盘，这里就是将各种修改好的内存文件，存入到本地硬盘中；
  43. BOOL MemeryTOFile(IN LPVOID pMemBuffer,IN size_t size,OUT LPSTR lpszFile);
  45. //DWORD RvaToFileOffset(IN LPVOID pFileBuffer,IN DWORD dwRva);
  47. //调用函数，添加ShellCode代码
  48. VOID AddCodeInCodeSec();  //这个调用函数用到下面的4个函数
  49. //ReadPEFile CopyFileBufferToImageBuffer CopyImageBufferToNewBuffer MemeryTOFile
  51. //调用函数，新增节表和节操作；
  52. VOID NewSectionsInCodeSec();  //这个调用函数用到下面的3个函数
  53. //ReadPEFile CopyFileBufferToNewImageBuffer MemeryTOFile
  55. //调用函数，扩大最后一个节
  56. VOID ExtendLastSectionsInCodeSec(); //这个调用函数用到下面的4个函数
  57. //ReadPEFile CopyFileBufferToImageBuffer CopyImageBufferToNewImageBuffer MemeryTOFile
  59. #endif // !defined(AFX_test_H__C24C6881_E003_41F7_BE14_24DDA1702CCD__INCLUDED_)
  1. // test.cpp
  3. #include "stdafx.h"
  4. #include "test.h"
  6. //定义一个全局变量
  7. BYTE ShellCode[] =
  8. {
  9.     0x6A,00,0x6A,00,0x6A,00,0x6A,00, //MessageBox push 0的硬编码
  10.     0xE8,00,00,00,00,  // call汇编指令E8和后面待填充的硬编码
  11.     0xE9,00,00,00,00   // jmp汇编指令E9和后面待填充的硬编码
  12. };
  14. //ExeFile->FileBuffer  返回值为计算所得文件大小
  15. //读取一个exe文件，然后输出为FileBuffer
  16. DWORD ReadPEFile(IN LPSTR lpszFile, OUT LPVOID* pFileBuffer)
  17. {
  18.     //下面有个IN和OUT，大致意思就是参数的类型传入进来之后不进行宏扩展；
  19.     //啥也不干，即使理解成干，也是扩展成空白，这个是C++语法中允许的；
  20.     //LPSTR  ---->  typedef CHAR *LPSTR, *PSTR; 意思就是char* 指针；在WINNT.H头文件里面
  21.     FILE* pFile = NULL;
  22.     //定义一个FILE结构体指针，在标准的Stdio.h文件头里面
  23.     //可参考：https://blog.csdn.net/qq_15821725/article/details/78929344
  24.     DWORD fileSize = 0;
  25.     // typedef unsigned long       DWORD;  DWORD是无符号4个字节的整型
  26.     LPVOID pTempFileBuffer = NULL;
  27.     //LPVOID ---->  typedef void far *LPVOID;在WINDEF.H头文件里面；别名的void指针类型
  29.     //打开文件
  30.     pFile = fopen(lpszFile,"rb"); //lpszFile是当作参数传递进来
  31.     if (!pFile)
  32.     {
  33.         printf("打开文件失败!\r\n");
  34.         return 0;
  35.     }
  37.     //读取文件内容后，获取文件的大小
  38.     fseek(pFile,0,SEEK_END);
  39.     fileSize = ftell(pFile);
  40.     fseek(pFile,0,SEEK_SET);
  42.     //动态申请内存空间
  43.     pTempFileBuffer = malloc(fileSize);
  45.     if (!pTempFileBuffer)
  46.     {
  47.         printf("内存分配失败!\r\n");
  48.         fclose(pFile);
  49.         return 0;
  50.     }
  52.     //根据申请到的内存空间，读取数据
  54.     size_t n = fread(pTempFileBuffer,fileSize,1,pFile);
  55.     if (!n)
  56.     {
  57.         printf("读取数据失败!\r\n");
  58.         free(pTempFileBuffer);   // 释放内存空间
  59.         fclose(pFile);           // 关闭文件流
  60.         return 0;
  61.     }
  63.     //数据读取成功，关闭文件
  64.     *pFileBuffer = pTempFileBuffer;  // 将读取成功的数据所在的内存空间的首地址放入指针类型pFileBuffer
  65.     pTempFileBuffer = NULL;  // 初始化清空临时申请的内存空间
  66.     fclose(pFile);           // 关闭文件
  67.     return fileSize;         // 返回获取文件的大小
  68. }
  70. //CopyFileBuffer --> ImageBuffer
  71. //将读取的FileBuffer拉伸加载到ImageBuffer，用作测试验证文件拉伸；
  72. DWORD CopyFileBufferToImageBuffer(IN LPVOID pFileBuffer,OUT LPVOID* pImageBuffer)
  73. {
  74.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  75.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  76.     PIMAGE_FILE_HEADER pPEHeader = NULL;
  77.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  78.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  79.     LPVOID pTempImageBuffer = NULL;
  81.     if (pFileBuffer == NULL)
  82.     {
  83.         printf("FileBuffer 获取失败!\r\n");
  84.         return 0;
  85.     }
  87.     //判断是否是有效的MZ标志
  88.     if (*((PWORD)pFileBuffer) != IMAGE_DOS_SIGNATURE)
  89.     {
  90.         printf("无效的MZ标识\r\n");
  91.         return 0;
  92.     }
  94.     pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
  96.     //判断是否是有效的PE标志
  97.     if (*((PDWORD)((DWORD)pFileBuffer+pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE)
  98.     {
  99.         printf("无效的PE标记\r\n");
  100.         return 0;
  101.     }
  103.     //定位NT头
  104.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pFileBuffer+pDosHeader->e_lfanew);
  106.     //上面偏移完成之后pFileBuffer的指针偏移到了NT头---> pNTHeader
  107.     //****************************************************************************************
  108.     //定位PE文件头
  109.     pPEHeader = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader)+4);
  110.     //根据PE头的结构体内容，PE文件头位置在NT头首地址偏移4个字节即可得到pPEHeader
  111.     //****************************************************************************************
  112.     //定位可选PE头
  113.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader+IMAGE_SIZEOF_FILE_HEADER);
  115.     /*
  116.     要得到可选PE的首地址位置，就根据上面得到的PE文件头位置里面的IMAGE_SIZEOF_FILE_HEADER来定位；
  117.     IMAGE_SIZEOF_FILE_HEADER也是个宏扩展，里面字节描述了PE文件头的大小是20个字节；
  118.     #define IMAGE_SIZEOF_FILE_HEADER  20，所以只要在PE文件头的首地址偏移20个字节即可移动到可选PE头；
  119.     指针相加的时候，此处的类型依然是DWORD
  120.     */
  121.     //****************************************************************************************
  122.     //第一个节表指针
  123.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader);
  124.     /*
  125.     这里要移动到第一个节表指针的首地址，就需要根据上面标准PE文件头中的SizeOfOptionalHeader获取具体可选PE
  126.     头的大小，然后根据这个大小进行偏移即可；
  127.     */
  129.     //根据SizeOfImage申请新的内存空间
  130.     pTempImageBuffer = malloc(pOptionHeader->SizeOfImage);
  132.     if (!pTempImageBuffer)
  133.     {
  134.         printf("再次在堆中申请一块内存空间失败\r\n");
  135.         return 0;
  136.     }
  138.     //因为下面要开始对内存空间进行复制操作，所以需要初始化操作，将其置为0，避免垃圾数据，或者其他异常
  139.     //初始化新的缓冲区
  140.     memset(pTempImageBuffer,0,pOptionHeader->SizeOfImage);
  142.     //根据SizeOfHeaders大小的确定，先复制Dos头
  143.     memcpy(pTempImageBuffer,pDosHeader,pOptionHeader->SizeOfHeaders);
  145.     //上面把已经确定的头都复制好了，那么下面就可以开始复制节的里面的内容，因为节不仅仅是一个，所以需要用到for循环进行操作
  146.     //根据节表循环copy节的内容
  147.     PIMAGE_SECTION_HEADER pTempSectionHeader = pSectionHeader;
  148.     //定义一个临时节表的指针
  149.     for (int i=0;i<pPEHeader->NumberOfSections;i++,pTempSectionHeader++)
  150.     {
  151.         memcpy((void*)((DWORD)pTempImageBuffer + pTempSectionHeader->VirtualAddress),
  152.             (void*)((DWORD)pFileBuffer + pTempSectionHeader->PointerToRawData),pTempSectionHeader->SizeOfRawData);
  153.     }
  155.     //返回数据
  156.     *pImageBuffer = pTempImageBuffer;
  157.     //将复制好后节的首地址保存到指针pImageBuffer中
  158.     pTempImageBuffer = NULL;
  159.     //初始化清空临时使用的pTempImageBuffer
  161.     return pOptionHeader->SizeOfImage;
  162. }
  164. //FileBuffer ---> NewImageBuffer（新增节操作）?
  165. //通过复制FileBuffer并增加1000H到新的NewImageBuffer,用作新增节；
  166. DWORD CopyFileBufferToNewImageBuffer(IN LPVOID pFileBuffer,IN size_t fileSize,OUT LPVOID* pNewImageBuffer)
  167. {
  168.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  169.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  170.     PIMAGE_FILE_HEADER pPEHeder = NULL;
  171.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  172.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  173.     PIMAGE_SECTION_HEADER pLastSectionHeader = NULL;
  174.     LPVOID pTempNewImageBuffer = 0;
  175.     DWORD sizeOfFile = 0;
  176.     DWORD numberOfSection = 0;
  177.     DWORD okAddSections = 0;
  179.     //判断读取pFileBuffer读取是否成功
  180.     if (!pFileBuffer)
  181.     {
  182.         printf("缓冲区指针无效\r\n");
  183.         return 0;
  184.     }
  186.     //判断是否为MZ标志
  188.     if ((*(PWORD)pFileBuffer) != IMAGE_DOS_SIGNATURE)// IMAGE_DOS_SIGNATURE --> MZ
  189.     {
  190.         printf("不是一个有效的MZ标志\r\n");
  191.         return 0;
  192.     }
  194.     //判断是否为PE标志
  195.     pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
  196.     if (*((PWORD)((DWORD)pFileBuffer + pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE) // IMAGE_NT_SIGNATURE --> PE
  197.     {
  198.         printf("不是有效的PE标志\r\n");
  199.         return 0;
  200.     }
  202. //申请开辟内存空间
  204.     sizeOfFile = fileSize+0x1000;
  205.     pTempNewImageBuffer = malloc(sizeOfFile);
  207.     //判断内存空间开辟是否成功
  208.     if (!pTempNewImageBuffer)
  209.     {
  210.         printf("pTempNewImageBuffer开辟内存空间失败\r\n");
  211.         return 0;
  212.     }
  214.     //初始化内存内容
  215.     memset(pTempNewImageBuffer,0,sizeOfFile);
  217.     //初始化完成之后，先把为修改的内存空间全部拷贝到新的内存空间
  218.     memcpy(pTempNewImageBuffer,pFileBuffer,fileSize);
  220.     //定位Dos头地址
  221.     pDosHeader = (PIMAGE_DOS_HEADER)(pTempNewImageBuffer);
  223.     //定位NT头的地址
  224.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pTempNewImageBuffer+pDosHeader->e_lfanew);
  226.     //定位标志PE头地址
  227.     pPEHeder = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader)+0x04);//PE SIGNATURE 站4个字节
  229.     //定位可选PE头地址
  230.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)(((DWORD)pPEHeder)+IMAGE_SIZEOF_FILE_HEADER);//IMAGE_SIZEOF_FILE_HEADER -> 20个字节
  232.     //定位第一个节表地址
  233.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeder->SizeOfOptionalHeader);
  235.     //定位最后一个节表的地址
  236.     pLastSectionHeader = &amp;pSectionHeader[pPEHeder->NumberOfSections-1];
  238.     //判断是否有足够的空间添加一个节表
  239.     //判断条件：
  240.     /*
  241.         SizeOfHeader - (DOS + 垃圾数据 + PE标记 + 标准PE头 + 可选PE头 + 已存在节表) >= 2个节表的大小
  242.         SizeOfHeader在可选PE头里面
  243.     */
  245.     okAddSections = (DWORD)(pOptionHeader->SizeOfHeaders - (pDosHeader->e_lfanew + 0x04 + \
  246.         sizeof(PIMAGE_FILE_HEADER) + pPEHeder->SizeOfOptionalHeader + sizeof(PIMAGE_SECTION_HEADER) \
  247.         * pPEHeder->NumberOfSections));
  249.     if (okAddSections < 2*sizeof(PIMAGE_SECTION_HEADER))
  250.     {
  251.         printf("这个exe文件头不剩余空间不够\r\n");
  252.         free(pTempNewImageBuffer);
  253.         return 0;
  254.     }
  256. //修改
  258.     //初始化新节表信息
  259.     PWORD pNumberOfSection = &amp;pPEHeder->NumberOfSections;
  260.     PDWORD pSizeOfImage = &amp;pOptionHeader->SizeOfImage;
  262.     numberOfSection = pPEHeder->NumberOfSections;
  263.     PVOID pSecName = &amp;pSectionHeader[numberOfSection].Name;
  264.     PDWORD pSecMisc = &amp;pSectionHeader[numberOfSection].Misc.VirtualSize;
  265.     PDWORD pSecVirtualAddress = &amp;pSectionHeader[numberOfSection].VirtualAddress;
  266.     PDWORD pSecSizeOfRawData = &amp;pSectionHeader[numberOfSection].SizeOfRawData;
  267.     PDWORD pSecPointToRawData = &amp;pSectionHeader[numberOfSection].PointerToRawData;
  268.     PDWORD pSecCharacteristics = &amp;pSectionHeader[numberOfSection].Characteristics;
  270.     //修改PE文件头里面的节数量信息
  272.     printf("*pNumberOfSection:%#X \r\n",pPEHeder->NumberOfSections);
  273.     *pNumberOfSection = pPEHeder->NumberOfSections + 1;
  274.     printf("*pNumberOfSection:%#X \r\n",pPEHeder->NumberOfSections);
  276.     //修改PE可选头里面SizeOfImage信息
  277.     printf("*pSizeOfImage:%#X \r\n",pOptionHeader->SizeOfImage);
  278.     *pSizeOfImage = pOptionHeader->SizeOfImage + 0x1000;
  279.     printf("*pSizeOfImage:%#X \r\n",pOptionHeader->SizeOfImage);
  281.     //向节表中添加数据
  283.     memcpy(pSecName,".newSec",8);
  284.     *pSecMisc = 0x1000;
  286.     //判断出要添加的值
  287.     DWORD add_size = pLastSectionHeader->Misc.VirtualSize > pLastSectionHeader->SizeOfRawData?\
  288.         pLastSectionHeader->Misc.VirtualSize:pLastSectionHeader->SizeOfRawData;
  289.     //上面是个三目运算符
  291.     printf("pLastSectionHeader: %#X \r\n",pLastSectionHeader);
  292.     printf("add_size: %#X \r\n",add_size);
  293.     printf("numberOfSection: %#X \r\n",pPEHeder->NumberOfSections);
  294.     printf("pLastSectionHeader->Misc.VirtualSize: %#X \r\n",pLastSectionHeader->Misc.VirtualSize);
  295.     printf("pLastSectionHeader->SizeOfRawData: %#X \r\n",pLastSectionHeader->SizeOfRawData);
  296.     printf("add_size: %#X \r\n",add_size);
  298.     *pSecVirtualAddress = pLastSectionHeader->VirtualAddress + add_size;
  300.     //SectionAlignment对齐
  302.     if (*pSecVirtualAddress % pOptionHeader->SectionAlignment)
  303.     {
  304.         *pSecVirtualAddress = *pSecVirtualAddress / pOptionHeader->SectionAlignment * \
  305.             pOptionHeader->SectionAlignment + pOptionHeader->SectionAlignment;
  306.     }
  308.     *pSecSizeOfRawData = 0x1000;
  309.     *pSecPointToRawData = pLastSectionHeader->PointerToRawData + pLastSectionHeader->SizeOfRawData;
  311.     //FileAlignment对齐
  313.     if (*pSecPointToRawData % pOptionHeader->FileAlignment)
  314.     {
  315.         *pSecPointToRawData = *pSecPointToRawData / pOptionHeader->FileAlignment * \
  316.             pOptionHeader->FileAlignment + pOptionHeader->FileAlignment;
  317.     }
  319.     *pSecCharacteristics = 0xFFFFFFFF;
  321.     *pNewImageBuffer = pTempNewImageBuffer;
  322.     pTempNewImageBuffer = NULL;
  324.     return sizeOfFile;
  325. }
  327. //求对齐后的大小
  328. //Actuall_size  ---> 实际大小
  329. //Align_size  ---> 对齐大小
  330. DWORD AlignLength(DWORD Actuall_size,DWORD Align_size)
  331. {
  332.     if (Actuall_size % Align_size == 0)
  333.     {
  334.         return Actuall_size;
  335.     }
  336.     else
  337.     {
  338.         DWORD n = Actuall_size / Align_size;
  339.         return Align_size*(n+1);
  340.     }
  341. }
  343. //ImageBuffer ---> NewImageBuffer
  344. //将拉伸后加载到内存的ImageBuffer存入到NewImageBuffer，修改数据完成之后，准备存盘操作
  345. DWORD FileBufferToModifyImageBuffer(IN LPVOID pFileBuffer,OUT LPVOID* pNewImageBuffer)
  346. {
  347.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  348.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  349.     PIMAGE_FILE_HEADER pPEHeader = NULL;
  350.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  351.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  352.     PIMAGE_SECTION_HEADER pLastSectionHeader = NULL;
  353.     LPVOID pTempNewImageBuffer = NULL;
  354.     DWORD ImageBuffer_Size = 0;
  355.     DWORD numberOfSection = 0;
  357.     //判断读取pImageBuffer是否成功
  358.     if (!pFileBuffer)
  359.     {
  360.         printf("缓冲区指针无效\r\n");
  361.     }
  363.     //判断是否是有效的MZ头
  364.     if ((*(PWORD)pFileBuffer) != IMAGE_DOS_SIGNATURE)
  365.     {
  366.         printf("不是有效的MZ头\r\n");
  367.         return 0;
  368.     }
  370.     //判断是否是有效的PE头
  371.     pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
  372.     if (*((PWORD)((DWORD)pFileBuffer+pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE)
  373.     {
  374.         printf("不是有效的PE头\r\n");
  375.         return 0;
  376.     }
  378.     //定位NT头
  379.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pFileBuffer+pDosHeader->e_lfanew);
  381.     //定位标准的PE文件头
  382.     pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader+0x04);
  384.     //定位可选PE头
  385.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader+IMAGE_SIZEOF_FILE_HEADER);
  387.     //定位第一个节表地址
  388.     numberOfSection = pPEHeader->NumberOfSections;
  389.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader+pPEHeader->SizeOfOptionalHeader);
  391.     //定位最后一个节表地址
  392.     pLastSectionHeader = &amp;pSectionHeader[numberOfSection-1];
  393.     printf("numberOfSection --> %#X \r\n",numberOfSection);
  394.     printf("*pSectionHeader --> %#X \r\n",pSectionHeader->Misc.VirtualSize);
  395.     printf("*pLastSectionHeader --> %#X \r\n",&amp;pLastSectionHeader);
  397.     //开始操作需要修改的部分
  399.     //最后一个节中内存中对齐前的大小；
  400.     PDWORD pVirtualSize = &amp;pLastSectionHeader->Misc.VirtualSize;
  401.     //最后一个节在文件中对齐后的大小；
  402.     PDWORD pSizeOfRawData = &amp;pLastSectionHeader->SizeOfRawData;
  403.     //文件中SizeOfImage的大小；
  404.     PDWORD pSizeOfImage = &amp;pOptionHeader->SizeOfImage;
  406.     //扩展修改之前的数据
  407. printf("&amp;pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",pVirtualSize);
  408. printf("*pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",*pVirtualSize);
  409. //
  410. printf("&amp;pLastSectionHeader->SizeOfRawData --> %#X \r\n",pSizeOfRawData);
  411. printf("*pLastSectionHeader->SizeOfRawData --> %#X \r\n",*pSizeOfRawData);
  412. //
  413. printf("&amp;pOptionHeader->SizeOfImage --> %#X \r\n",pSizeOfImage);
  414. printf("*pOptionHeader->SizeOfImage --> %#X \r\n",*pSizeOfImage);
  416.     //扩展修改pVirtualSize
  417.     *pVirtualSize = AlignLength(*pVirtualSize,pOptionHeader->SectionAlignment)+0x1000;
  418.     printf("&amp;pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",pVirtualSize);
  419.     printf("*pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",*pVirtualSize);
  420.     printf("&amp;pLastSectionHeader->SizeOfRawData --> %#X \r\n",pSizeOfRawData);
  421.     printf("*pLastSectionHeader->SizeOfRawData --> %#X \r\n",*pSizeOfRawData);
  423.     //扩展修改pSizeOfRawData
  424.     *pSizeOfRawData = AlignLength(*pSizeOfRawData,pOptionHeader->SectionAlignment)+0x1000;
  425.     printf("&amp;pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",pVirtualSize);
  426.     printf("*pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",*pVirtualSize);
  427.     printf("&amp;pLastSectionHeader->SizeOfRawData --> %#X \r\n",pSizeOfRawData);
  428.     printf("*pLastSectionHeader->SizeOfRawData --> %#X \r\n",*pSizeOfRawData);
  429.     printf("&amp;pOptionHeader->SizeOfImage --> %#X \r\n",pSizeOfImage);
  430.     printf("*pOptionHeader->SizeOfImage --> %#X \r\n",*pSizeOfImage);
  432.     //修改SizeOfImage
  433.     *pSizeOfImage += 0x1000;
  434.     printf("&amp;pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",pVirtualSize);
  435.     printf("*pLastSectionHeader->Misc.VirtualSize --> %#X \r\n",*pVirtualSize);
  436.     printf("&amp;pLastSectionHeader->SizeOfRawData --> %#X \r\n",pSizeOfRawData);
  437.     printf("*pLastSectionHeader->SizeOfRawData --> %#X \r\n",*pSizeOfRawData);
  438.     printf("&amp;pOptionHeader->SizeOfImage --> %#X \r\n",pSizeOfImage);
  439.     printf("*pOptionHeader->SizeOfImage --> %#X \r\n",*pSizeOfImage);
  441.     //得到修改之后的大小准备申请内存空间
  443.     ImageBuffer_Size = pOptionHeader->SizeOfImage;
  444.     pTempNewImageBuffer = malloc(ImageBuffer_Size);
  446.     if (!pTempNewImageBuffer)
  447.     {
  448.         printf("分配内存空间失败\r\n");
  449.         return 0;
  450.     }
  452.     //初始化内存空间
  453.     memset(pTempNewImageBuffer,0,ImageBuffer_Size);
  455.     //复制SizeOfHeaders
  456.     memcpy(pTempNewImageBuffer,pDosHeader,pOptionHeader->SizeOfHeaders);
  458.     //创建临时节的结构体指针，遍历数据
  459.     PIMAGE_SECTION_HEADER pTempSectionHeader = pSectionHeader;
  461.     for (DWORD i = 0;i<pPEHeader->NumberOfSections;i++,pTempSectionHeader++)
  462.     {
  463.         memcpy((PVOID)((DWORD)pTempNewImageBuffer+pTempSectionHeader->VirtualAddress),\
  464.             (void*)((DWORD)pFileBuffer+pTempSectionHeader->PointerToRawData),pTempSectionHeader->SizeOfRawData);
  465.     }
  467.     *pNewImageBuffer = pTempNewImageBuffer;
  468.     pTempNewImageBuffer = NULL;
  469.     return *pSizeOfImage;
  470. }
  472. //ImageBuffer ---> NewBuffer
  473. //将拉伸后加载到内存的ImageBuffer存入到NewBuffer里面，然后准备存盘；
  474. DWORD CopyImageBufferToNewBuffer(IN LPVOID pImageBuffer,OUT LPVOID* pNewBuffer)
  475. {
  476.     //下面大部分操作都是跟上面一样的，这里就不再赘述了
  477.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  478.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  479.     PIMAGE_FILE_HEADER pPEHeader = NULL;
  480.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  481.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  482.     LPVOID pTempNewBuffer = NULL;
  483.     DWORD sizeOfFile = 0;
  484.     DWORD numberOfSection = 0;
  486.     if (pImageBuffer == NULL)
  487.     {
  488.         printf("缓冲区指针无效\r\n");
  489.     }
  490.     //判断是否是有效的MZ标志
  491.     if (*((PWORD)pImageBuffer) != IMAGE_DOS_SIGNATURE)
  492.     {
  493.         printf("不是有效的MZ头\r\n");
  494.         return 0;
  495.     }
  496.     pDosHeader = (PIMAGE_DOS_HEADER)pImageBuffer;
  497.     //判断是否是有效的PE标志
  498.     if (*((PDWORD)((DWORD)pImageBuffer+pDosHeader->e_lfanew)) != IMAGE_NT_SIGNATURE)
  499.     {
  500.         printf("不是有效的PE标志\r\n");
  501.         return 0;
  502.     }
  503.     //NT头地址
  504.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pImageBuffer + pDosHeader->e_lfanew);
  505.     //标准PE文件头
  506.     pPEHeader = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader) + 4);
  507.     //可选PE头
  508.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader+IMAGE_SIZEOF_FILE_HEADER);
  509.     //第一个节表地址
  510.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader);
  512.     //计算文件需要的空间--最后一个节的文件偏移+节对齐后的长度
  513.     /*
  514.     numberOfSection = pPEHeader->NumberOfSections;
  515.     pSectionHeader = pSectionHeader[numberOfSection-1];
  516.     sizeOfFile = (pSectionHeader->PointerToRawData + pSectionHeader->Misc.VirtualSize + pOptionHeader->FileAlignment);
  517.     printf("sizeOfFile %X \r\n",sizeOfFile);
  519.     for (DWORD i=0;i<=numberOfSection;i++)
  520.     {
  521.         sizeOfFile += sizeOfFile[i];
  522.     }
  523.     */
  525.     sizeOfFile = pOptionHeader->SizeOfHeaders;
  526.     //使用winhex打开notepad.exe 是0x00000400，这是第一个节之前的所有大小
  527.     for(DWORD i = 0;i<pPEHeader->NumberOfSections;i++)
  528.     {
  529.         sizeOfFile += pSectionHeader[i].SizeOfRawData;  // pSectionHeader[i]另一种加法
  530.     }
  532.     /*
  533.     上面的for循环大概意思就是基于几个节的数量依次循环叠加sizeOfFile的值；因为SizeOfRawData是文件中对齐后的大小；
  534.     所以循环计算如下：
  535.     sizeOfFile = 0x00000400 + 0x00007800 = 0x00007C00
  536.     sizeOfFile = 0x00007C00 + 0x00000800 = 0x00008400
  537.     sizeOfFile = 0x00008400 + 0x00008000 = 0x00010400
  539.     */
  541.     //根据SizeOfImage申请新的空间
  542.     pTempNewBuffer = malloc(sizeOfFile);
  544.     if (!pTempNewBuffer)
  545.     {
  546.         printf("申请内存空间失败\r\n");
  547.         return 0;
  548.     }
  549.     //初始化新的缓冲区
  550.     memset(pTempNewBuffer,0,sizeOfFile);
  551.     //根据SizeOfHeaders 先copy头
  552.     memcpy(pTempNewBuffer,pDosHeader,pOptionHeader->SizeOfHeaders);
  553.     //根据节表循环复制节
  554.     //PIMAGE_SECTION_HEADER pTempSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader);
  555.     PIMAGE_SECTION_HEADER pTempSectionHeader = pSectionHeader;
  556.     for (int j=0;j<pPEHeader->NumberOfSections;j++,pTempSectionHeader++)
  557.     {
  558.         /*memcpy((LPVOID)((DWORD)pTempNewBuffer + pTempSectionHeader->PointerToRawData),
  559.         (LPVOID)((DWORD)pImageBuffer + pTempSectionHeader->VirtualAddress),
  560.         pTempSectionHeader->SizeOfRawData);*/
  561.         //PointerToRawData节区在文件中的偏移,VirtualAddress节区在内存中的偏移地址,SizeOfRawData节在文件中对齐后的尺寸
  562.         memcpy((PDWORD)((DWORD)pTempNewBuffer+pTempSectionHeader->PointerToRawData),
  563.         (PDWORD)((DWORD)pImageBuffer+pTempSectionHeader->VirtualAddress),
  564.         pTempSectionHeader->SizeOfRawData);
  565.         //printf("%X  --> PoniterToRadata\r\n",pTempSectionHeader->PointerToRawData);
  566.         //printf("%X  --> VirtualAddress\r\n",pTempSectionHeader->VirtualAddress);
  567.         //printf("%X  --> VirtualSize\r\n",pTempSectionHeader->Misc.VirtualSize);
  568.     }
  570.     //返回数据
  571.     *pNewBuffer = pTempNewBuffer;
  572.     pTempNewBuffer = NULL;
  573.     return sizeOfFile;
  574.   }
  576. //将上面得到的MemBuffer存盘到本地；
  577. BOOL MemeryTOFile(IN LPVOID pMemBuffer,IN size_t size,OUT LPSTR lpszFile)
  578. {
  579.     FILE* fp = NULL;
  580.     fp = fopen(lpszFile, "wb+");
  581.     if (!fp)  //  这里我刚开始写漏了一个等于号，变成复制NULL了，导致错误
  582. //  if(fp == NULL)  可以这么写，没问题
  583.     {
  584.         fclose(fp);
  585.         return FALSE;
  586.     }
  587.     fwrite(pMemBuffer,size,1,fp);
  588.     fclose(fp);
  589.     fp = NULL;
  590.     return TRUE;
  591. }
  593. /*
  594. DWORD RvaToFileOffset(IN LPVOID pFileBuffer,IN DWORD dwRva)
  595. {
  596.     DWORD dwFOAValue = 0;
  597.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  598.     PIMAGE_NT_HEADERS pNTHeader = NULL;
  599.     PIMAGE_FILE_HEADER pPEHeader = NULL;
  600.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  601.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  602.     pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionHeader + pPEHeader->SizeOfOptionalHeader);
  604.     //判断指针是否有效
  605.     if (!pFileBuffer)
  606.     {
  607.         printf("FileBuffer 指针无效\r\n");
  608.         return dwFOAValue;
  609.     }
  610.     //判断是否是有效的MZ标志
  611.     if (*((PWORD)pFileBuffer) != IMAGE_DOS_SIGNATURE)
  612.     {
  613.         printf("不是有效的MZ标志\r\n");
  614.         return dwFOAValue;
  615.     }
  616.     //为需要用到的指针赋值
  617.     pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
  618.     pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pFileBuffer+pDosHeader->e_lfanew);
  619.     pPEHeader = (PIMAGE_FILE_HEADER)(((DWORD)pNTHeader) + 4);
  620.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader+IMAGE_SIZEOF_FILE_HEADER);
  622.     //判断dwRva所处的节
  624.     //计算与节开始位置的差
  626.     //该节文件中的偏移+差 == 该值在文件中的偏移
  627.     return 0;
  628. }
  629. */
  631. //在原有的exe文件中开始操作添加ShellCode代码；
  633. VOID AddCodeInCodeSec()
  634. {
  635.     LPVOID pFileBuffer = NULL;
  636.     LPVOID pImageBuffer = NULL;
  637.     LPVOID pNewBuffer = NULL;
  638.     PIMAGE_DOS_HEADER pDosHeader = NULL;
  639.     PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
  640.     PIMAGE_SECTION_HEADER pSectionHeader = NULL;
  641.     PBYTE codeBegin = NULL;
  642.     BOOL isOK = FALSE;
  643.     DWORD size = 0;
  645.     //File-->FileBuffer
  646.     ReadPEFile(FilePath_In,&amp;pFileBuffer);
  647.     if (!pFileBuffer)
  648.     {
  649.         printf("文件-->缓冲区失败\r\n");
  650.         return ;
  651.     }
  653.     //FileBuffer-->ImageBuffer
  654.     CopyFileBufferToImageBuffer(pFileBuffer,&amp;pImageBuffer);
  655.     if (!pImageBuffer)
  656.     {
  657.         printf("FileBuffer-->ImageBuffer失败\r\n");
  658.         free(pFileBuffer);
  659.         return ;
  660.     }
  662.     //判断代码段空闲区域是否能够足够存储ShellCode代码
  663.     pDosHeader = (PIMAGE_DOS_HEADER)pImageBuffer;
  664.     pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)(((DWORD)pImageBuffer + pDosHeader->e_lfanew) + 4 + IMAGE_SIZEOF_FILE_HEADER);
  665.     pSectionHeader = (PIMAGE_SECTION_HEADER)(((DWORD)pImageBuffer + pDosHeader->e_lfanew) + 4 + IMAGE_SIZEOF_FILE_HEADER + IMAGE_SIZEOF_NT_OPTIONAL32_HEADER);
  666.     if (((pSectionHeader->SizeOfRawData) - (pSectionHeader->Misc.VirtualSize)) < SHELLCODELENGTH)
  667.     {
  668.         printf("代码区域空闲空间不够\r\n");
  669.         free(pFileBuffer);
  670.         free(pImageBuffer);
  671.     }
  673.     //将代码复制到空闲区域
  674.     codeBegin = (PBYTE)((DWORD)pImageBuffer + pSectionHeader->VirtualAddress + pSectionHeader->Misc.VirtualSize);
  675.     printf("pSectionHeader->VirtualAddress: %#010X\r\n", pSectionHeader->VirtualAddress);
  676.     printf("pSectionHeader->Misc.VirtualSize: %#010X\r\n", pSectionHeader->Misc.VirtualSize);
  677.     printf("codeBegin: %#010X\r\n", codeBegin);
  679.     memcpy(codeBegin,ShellCode,SHELLCODELENGTH);
  681.     //修正E8-->call后面的代码区域
  682.     DWORD callAddr = (MESSAGEBOXADDR - (pOptionHeader->ImageBase + ((DWORD)(codeBegin + 0xD) - (DWORD)pImageBuffer)));
  683.     printf("callAddr ---> %#010X \r\n",callAddr);
  684.     *(PDWORD)(codeBegin + 0x09) = callAddr;
  685.     printf("*(PWORD)(codeBegin + 0x09) ---> %#010X \r\n",*(PDWORD)(codeBegin + 0x09));
  687.     //修正E9-->jmp后面的代码区域
  688.     DWORD jmpAddr = ((pOptionHeader->ImageBase + pOptionHeader->AddressOfEntryPoint) - (pOptionHeader->ImageBase + ((DWORD)(codeBegin + SHELLCODELENGTH) - (DWORD)pImageBuffer)));
  689.     printf("jmpAddr ---> %#010X \r\n",jmpAddr);
  690.     *(PDWORD)(codeBegin + 0x0E) = jmpAddr;
  691.     printf("*(PWORD)(codeBegin + 0x0E) ---> %#010X \r\n",*(PDWORD)(codeBegin + 0x0E));
  693.     //修正OEP
  694.     printf("pOptionHeader->AddressOfEntryPoint ---> %#010X \r\n",pOptionHeader->AddressOfEntryPoint);
  695.     printf("(DWORD)codeBegin ---> %#010X \r\n",((DWORD)codeBegin - (DWORD)pImageBuffer));
  696.     pOptionHeader->AddressOfEntryPoint = (DWORD)codeBegin - (DWORD)pImageBuffer;
  697.     printf("pOptionHeader->AddressOfEntryPoint ---> %#010X \r\n",pOptionHeader->AddressOfEntryPoint);
  698.     //修正OEP好理解，就是定位到OEP地址，然后直接通过codeBegin地址减去pImageBuffer的首地址即可；
  700.     //ImageBuffer-->NewBuffer
  701.     size = CopyImageBufferToNewBuffer(pImageBuffer,&amp;pNewBuffer);
  702.     if (size == 0 || !pNewBuffer)
  703.     {
  704.         printf("ImageBuffer-->NewBuffer失败\r\n");
  705.         free(pFileBuffer);
  706.         free(pImageBuffer);
  707.         return ;
  708.     }
  710.     //NewBuffer-->文件
  711.     isOK = MemeryTOFile(pNewBuffer,size,FilePath_Out);
  712.     if (isOK)
  713.     {
  714.         printf("修改代码添加SHELLCODE 存盘成功\r\n");
  715.         return ;
  716.     }
  718.     //释放内存
  719.     free(pFileBuffer);
  720.     free(pImageBuffer);
  721.     free(pNewBuffer);
  722. }
  724. //调用函数新增节表和节操作，成功之后并存盘到本地；
  725. VOID NewSectionsInCodeSec()
  726. {
  727.     LPVOID pFileBuffer = NULL;
  728.     LPVOID pNewImageBuffer = NULL;
  729.     BOOL isOK = FALSE;
  730.     DWORD size1 = 0;
  731.     DWORD size2 = 0;
  733.     //File-->FileBuffer
  734.     size1 = ReadPEFile(FilePath_In,&amp;pFileBuffer);
  735.     if (size1 == 0 || !pFileBuffer)
  736.     {
  737.         printf("文件-->缓冲区失败\r\n");
  738.         return ;
  739.     }
  740.     printf("fileSize - Final: %#X \r\n",size1);
  742.     //FileBuffer-->NewImageBuffer
  743.     size2 = CopyFileBufferToNewImageBuffer(pFileBuffer,size1,&amp;pNewImageBuffer);
  744.     if (size2 == 0 || !pFileBuffer)
  745.     {
  746.         printf("FileBuffer-->NewImageBuffer失败\r\n");
  747.         free(pFileBuffer);
  748.         return ;
  749.     }
  750.     printf("sizeOfFile - Final: %#X \r\n",size2);
  751.     //NewImageBuffer-->文件
  752.     isOK = MemeryTOFile(pNewImageBuffer,size2,FilePath_Out);
  753.     if (isOK)
  754.     {
  755.         printf("新增节表和节存盘成功\r\n");
  756.        return ;
  757.     }
  759.     //释放内存
  760.     free(pFileBuffer);
  761.     free(pNewImageBuffer);
  762. }
  764. VOID ExtendLastSectionsInCodeSec()
  765. {
  766.     //ReadPEFile CopyFileBufferToImageBuffer CopyImageBufferToNewImageBuffer
  768.     LPVOID pFileBuffer = NULL;
  769.     LPVOID pImageBuffer = NULL;
  770.     LPVOID pNewImageBuffer = NULL;
  771.     BOOL isOK = FALSE;
  772.     DWORD FileBufferSize = 0;
  773.     DWORD ImageBufferSize = 0;
  774.     DWORD size = 0;
  776.     //File-->FileBuffer
  777.     FileBufferSize = ReadPEFile(FilePath_In,&amp;pFileBuffer);
  778.     if (FileBufferSize == 0 || !pFileBuffer)
  779.     {
  780.         printf("文件-->缓冲区失败\r\n");
  781.         return ;
  782.     }
  783.     printf("FileBufferSize - Final: %#X \r\n",FileBufferSize);
  785.     //FileBuffer-->ImageBuffer
  786.     ImageBufferSize = FileBufferToModifyImageBuffer(pFileBuffer,&amp;pImageBuffer);
  787.     if (ImageBufferSize == 0 || !pFileBuffer)
  788.     {
  789.         printf("FileBuffer-->ImageBuffer失败\r\n");
  790.         free(pFileBuffer);
  791.         return ;
  792.     }
  793.     printf("ImageBufferSize - Final: %#X \r\n",ImageBufferSize);
  795.     size = CopyImageBufferToNewBuffer(pImageBuffer,&amp;pNewImageBuffer);
  796.     if (size == 0 || !pImageBuffer)
  797.     {
  798.         printf("pImageBuffer-->pNewImageBuffer失败\r\n");
  799.         free(pFileBuffer);
  800.         return ;
  801.     }
  802.     //pNewImageBuffer-->文件
  803.     isOK = MemeryTOFile(pNewImageBuffer,size,FilePath_Out);
  804.     if (isOK)
  805.     {
  806.         printf("扩大一个节成功，并存盘\r\n");
  807.         return ;
  808.     }
  810.     //释放内存
  811.     free(pFileBuffer);
  812.     free(pImageBuffer);
  813.     free(pNewImageBuffer);
  814. }
  1. // test2.cpp:程序入口
  2. //
  4. #include "stdafx.h"
  5. #include "test.h"
  7. int main(int argc, char* argv[])
  8. {
  9.     //Fun();
  10.     //AddCodeInCodeSec();
  11.     //NewSectionsInCodeSec();
  12.     ExtendLastSectionsInCodeSec();
  13.     printf("Hello World! Cntf\r\n");
  14.     return 0;
  15. }
  • 发表于 2022-02-18 09:37:41
  • 阅读 ( 6600 )
  • 分类：渗透测试

0 条评论

略略略
略略略

36 篇文章

略略略

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！

站长统计