程序博客网 > 和讯网数据爬虫

（未完待续）Windows PE 文件加壳学习笔记

来源：互联网 发布：和讯网数据爬虫 编辑：程序博客网 时间：2024/05/14 19:56
要想给PE文件加壳，搞清楚PE文件的格式是前提。
以可执行程序EXE文件为例， 由描述程序信息的文件头和记录代码数据的节组成。
文件头包括DOS文件头， PE文件头， PE可选信息头组成
下面给出个结构的C定义（在windos开发包 winnt.h 文件中可以找到）

typedef struct _PE_IMAGE_DOS_HEADER {   // DOS .EXE header
    WORD   e_magic;                     // Magic number
    WORD   e_cblp;                      // Bytes on last page of file
    WORD   e_cp;                        // Pages in file
    WORD   e_crlc;                      // Relocations
    WORD   e_cparhdr;                   // Size of header in paragraphs
    WORD   e_minalloc;                  // Minimum extra paragraphs needed
    WORD   e_maxalloc;                  // Maximum extra paragraphs needed
    WORD   e_ss;                        // Initial (relative) SS value
    WORD   e_sp;                        // Initial SP value
    WORD   e_csum;                      // Checksum
    WORD   e_ip;                        // Initial IP value
    WORD   e_cs;                        // Initial (relative) CS value
    WORD   e_lfarlc;                    // File address of relocation table
    WORD   e_ovno;                      // Overlay number
    WORD   e_res[4];                    // Reserved words
    WORD   e_oemid;                     // OEM identifier (for e_oeminfo)
    WORD   e_oeminfo;                   // OEM information; e_oemid specific
    WORD   e_res2[10];                  // Reserved words
    LONG   e_lfanew;                    // File address of new exe header
} PE_IMAGE_DOS_HEADER;

typedef struct _PE_IMAGE_FILE_HEADER {
    WORD    Machine;
    WORD    NumberOfSections;
    DWORD   TimeDateStamp;
    DWORD   PointerToSymbolTable;
    DWORD   NumberOfSymbols;
    WORD    SizeOfOptionalHeader;
    WORD    Characteristics;
} PE_IMAGE_FILE_HEADER;

typedef struct _PE_IMAGE_OPTIONAL_HEADER32 {
    //
    // Standard fields.
    //

    WORD    Magic;
    BYTE    MajorLinkerVersion;
    BYTE    MinorLinkerVersion;
    DWORD   SizeOfCode;
    DWORD   SizeOfInitializedData;
    DWORD   SizeOfUninitializedData;
    DWORD   AddressOfEntryPoint;
    DWORD   BaseOfCode;
    DWORD   BaseOfData;

    //
    // NT additional fields.
    //

    DWORD   ImageBase;
    DWORD   SectionAlignment;
    DWORD   FileAlignment;
    WORD    MajorOperatingSystemVersion;
    WORD    MinorOperatingSystemVersion;
    WORD    MajorImageVersion;
    WORD    MinorImageVersion;
    WORD    MajorSubsystemVersion;
    WORD    MinorSubsystemVersion;
    DWORD   Win32VersionValue;
    DWORD   SizeOfImage;
    DWORD   SizeOfHeaders;
    DWORD   CheckSum;
    WORD    Subsystem;
    WORD    DllCharacteristics;
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    DWORD   SizeOfHeapReserve;
    DWORD   SizeOfHeapCommit;
    DWORD   LoaderFlags;
    DWORD   NumberOfRvaAndSizes;
    PE_IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} PE_IMAGE_OPTIONAL_HEADER32;

typedef struct _PE_IMAGE_NT_HEADERS32 {
    DWORD Signature;
    PE_IMAGE_FILE_HEADER FileHeader;
    PE_IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} PE_IMAGE_NT_HEADERS32;



结构好像很复杂，其实很多部分的定义已经弃用了。 这是因为这个结构兼容 DOS， Win16， Win32以及Win64系统。 而前二者已经成为历史了，所以不少和它们相关的定义已经失效了。

文件信息头之后就是节（SECTION）信息了。 先是节头，让后才是节的数据。
给出节头的定义：
typedef struct _PE_IMAGE_SECTION_HEADER {
    BYTE    Name[IMAGE_SIZEOF_SHORT_NAME];
    union {
            DWORD   PhysicalAddress;
            DWORD   VirtualSize;
    } Misc;
    DWORD   VirtualAddress;
    DWORD   SizeOfRawData;
    DWORD   PointerToRawData;
    DWORD   PointerToRelocations;
    DWORD   PointerToLinenumbers;
    WORD    NumberOfRelocations;
    WORD    NumberOfLinenumbers;
    DWORD   Characteristics;
} PE_IMAGE_SECTION_HEADER;

这个节头把文件空间与程序运行的虚拟空间联系起来， Windos PE 加载器正是根据这个节头还有上面提到的文件头中的数据把文件映像加载到内存中。

当加载器把数据读到内存后，还要做一些初始化工作。 这有牵涉到上面提到的PE可选信息头PE_IMAGE_OPTIONAL_HEADER32里面的最后一个数据项DataDirectory了。
DataDirectory这个数组有16个元素，各含义如下：
#define IMAGE_DIRECTORY_ENTRY_EXPORT          0   // Export Directory
#define IMAGE_DIRECTORY_ENTRY_IMPORT          1   // Import Directory
#define IMAGE_DIRECTORY_ENTRY_RESOURCE        2   // Resource Directory
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION       3   // Exception Directory
#define IMAGE_DIRECTORY_ENTRY_SECURITY        4   // Security Directory
#define IMAGE_DIRECTORY_ENTRY_BASERELOC       5   // Base Relocation Table
#define IMAGE_DIRECTORY_ENTRY_DEBUG           6   // Debug Directory
//      IMAGE_DIRECTORY_ENTRY_COPYRIGHT       7   // (X86 usage)
#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE    7   // Architecture Specific Data
#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR       8   // RVA of GP
#define IMAGE_DIRECTORY_ENTRY_TLS             9   // TLS Directory
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG    10   // Load Configuration Directory
#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT   11   // Bound Import Directory in headers
#define IMAGE_DIRECTORY_ENTRY_IAT            12   // Import Address Table
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT   13   // Delay Load Import Descriptors
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14   // COM Runtime descriptor
#define IMAGE_DIRECTORY_ENTRY_RESERVED         15

其中比较重要的是
导出符号表 IMAGE_DIRECTORY_ENTRY_EXPORT；
导入符号表 IMAGE_DIRECTORY_ENTRY_IMPORT；
资源 IMAGE_DIRECTORY_ENTRY_RESOURCE；
导入地址表 IMAGE_DIRECTORY_ENTRY_IAT；

导出符号表作用是记录该程序导出的符号，通常是DLL文件的符号，可由其他进程调用。
导入符号表示记录该程序需要调用的外部程序。
资源的作用是记录程序资源的结构信息。
导入地址表是改程序用到的外部程序的地址。

这些数据存在于文件中的某一个节。

关于这些表的结构不是三言两语可以解释的了的，分析EXE文件的数据或者看代码吧 ,嘿嘿
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include "./bst/bst_stdafx.h"
  6. #include "./bst/bst_blob.h"
  7. #include "./bst/bst_pack.h"
  10. #define XPAKER_FILE_ALIGNMENT   0x1000
  11. #define XPAKER_SECTION_ALIGNMENT 0X200
  14. int main(int argc, char** argv)
  15. {
  16.     //必须先做节的内存映射，否则PE文件中的虚地址不能用
  17.     char szInputFile[0x100];
  18.     char szOutputFile[0x100];
  20.     if(argc<2) return 0;
  21.     strcpy(szInputFile, argv[1]);
  22.     sprintf(szOutputFile, "_%s",szInputFile);
  24.     memptr_t pRead, pWrite;
  25.     PE_IMAGE_DOS_HEADER* pDosHeader;
  26.     PE_IMAGE_NT_HEADERS32* pPEHeaders;
  27.     PE_IMAGE_SECTION_HEADER* pSecHeader;
  28.     uint_t nSecNum;
  29.     PE_IMAGE_IMPORT_DESCRIPTOR* pImportDesc;
  30.     uint_t nImportDescNum;
  31.     PE_IMAGE_IMPORT_BY_NAME* pImportName;
  32.     uint_t i,j;
  34.     
  35.     blob_c PERawImage;
  36.     PERawImage.bload(szInputFile);
  37.     
  38.     pRead=PERawImage.begin();
  39.     pDosHeader=(PE_IMAGE_DOS_HEADER*)pRead; //得到原始镜像dos头的地址
  40.     
  41.     pRead+=pDosHeader->e_lfanew;
  42.     pPEHeaders = (PE_IMAGE_NT_HEADERS32*)pRead; //得到原始镜像PE头的地址
  43.     
  44.     pRead+=sizeof(PE_IMAGE_NT_HEADERS32);
  45.     pSecHeader=(PE_IMAGE_SECTION_HEADER*)pRead; //得到原始镜像节表的地址
  46.     nSecNum = pPEHeaders->FileHeader.NumberOfSections;
  47.     
  48.     //------------------------------------------------------------------------------------
  49.     //------------------------------------------------------------------------------------
  50.     blob_c PEImage(pPEHeaders->OptionalHeader.SizeOfImage);
  51.     
  52.     //映射后的内存映像
  53.     memcpy(PEImage.begin(), PERawImage.begin(), pPEHeaders->OptionalHeader.SizeOfHeaders);
  54.     for(i=0;i<=nSecNum-1;i++)
  55.     {
  56.         memset(PEImage.begin()+pSecHeader[i].VirtualAddress, 0, pSecHeader[i].Misc.VirtualSize);
  57.         memcpy(PEImage.begin()+pSecHeader[i].VirtualAddress, PERawImage.begin()+pSecHeader[i].PointerToRawData, pSecHeader[i].SizeOfRawData);
  58.     }
  60.     pRead=PEImage.begin();
  61.     pDosHeader=(PE_IMAGE_DOS_HEADER*)pRead; //得到虚拟镜像dos头的地址
  62.     
  63.     pRead+=pDosHeader->e_lfanew;
  64.     pPEHeaders = (PE_IMAGE_NT_HEADERS32*)pRead; //得到虚拟镜像PE头的地址
  65.     
  66.     pRead+=sizeof(PE_IMAGE_NT_HEADERS32);
  67.     pSecHeader=(PE_IMAGE_SECTION_HEADER*)pRead; //得到虚拟镜像节表的地址
  68.     nSecNum = pPEHeaders->FileHeader.NumberOfSections;
  69.     
  70.     
  71.     pRead = PEImage.begin() + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
  72.     pImportDesc = (PE_IMAGE_IMPORT_DESCRIPTOR*)pRead; //得到虚拟镜像导入表的地址
  73.     
  74.     
  75.     //得到导入表的模块数目
  76.     for(i=0;TRUE;i++)
  77.     {
  78.         if(pImportDesc[i].Characteristics==0 && pImportDesc[i].FirstThunk==0)
  79.             break;
  80.     }
  81.     nImportDescNum = i;
  82.     
  83.     
  84.     //"winnt.h"
  85. /*  
  86.     //打印输入表
  87.     if(nImportDescNum!=0)
  88.     {
  89.         FILE* f_out;
  90.         f_out=fopen("debug.txt","wt");
  91.         
  92.         for(i=0;i<=nImportDescNum-1;i++)
  93.         {
  94.             fprintf(f_out, "%s/n", PEImage.begin()+pImportDesc[i].Name);//打印模块名
  95.             
  96.             if(pImportDesc[i].OriginalFirstThunk!=0)
  97.                 pRead = PEImage.begin() + pImportDesc[i].OriginalFirstThunk;
  98.             else
  99.                 pRead = PEImage.begin() + pImportDesc[i].FirstThunk;
  100.             
  101.             for(j=0;TRUE;j++)
  102.             {           
  103.                 if(((DWORD*)pRead)[j]==0)
  104.                     break;
  105.                 if(((DWORD*)pRead)[j]&IMAGE_ORDINAL_FLAG32)
  106.                 {
  107.                     fprintf(f_out, "  *%08X/n", ((DWORD*)pRead)[j]&0x7FFFFFFF);//打印无符号函数
  108.                 }
  109.                 else
  110.                 {
  111.                     pImportName = (PE_IMAGE_IMPORT_BY_NAME*)(PEImage.begin() + ((DWORD*)pRead)[j]);
  112.                     fprintf(f_out, "  %04X %s/n", pImportName->Hint, pImportName->Name);//打印函数
  113.                 }
  114.                 
  115.                 
  116.             }
  117.             fprintf(f_out, "/n");
  118.         }       
  119.         fclose(f_out);
  120.     }
  121. //*/
  122. /*
  123.     //重定位导入表内函数
  124.     HMODULE hModule;
  125.     FARPROC pProc;
  126.     //hModule = LoadLibrary();
  127.     //pProc = GetProcAddress(hModule, MAKEINTRESOURCE());
  129.     if(nImportDescNum!=0)
  130.     {
  131.         for(i=0;i<=nImportDescNum-1;i++)
  132.         {
  133.             hModule = LoadLibrary((LPCSTR)(PEImage.begin()+pImportDesc[i].Name));//fprintf(f_out, "%s/n", PEImage.begin()+pImportDesc[i].Name);//打印模块名
  134.             
  135.             if(pImportDesc[i].OriginalFirstThunk!=0)
  136.                 pRead = PEImage.begin() + pImportDesc[i].OriginalFirstThunk;
  137.             else
  138.                 pRead = PEImage.begin() + pImportDesc[i].FirstThunk;
  139.             
  140.             for(j=0;TRUE;j++)
  141.             {           
  142.                 if(((DWORD*)pRead)[j]==0)
  143.                     break;
  144.                 if(((DWORD*)pRead)[j]&IMAGE_ORDINAL_FLAG32)
  145.                 {
  146.                     pProc = GetProcAddress(hModule, MAKEINTRESOURCE(((DWORD*)pRead)[j]&0x7FFFFFFF));//fprintf(f_out, "  *%08X/n", ((DWORD*)pRead)[j]&0x7FFFFFFF);//打印无符号函数
  147.                 }
  148.                 else
  149.                 {
  150.                     pImportName = (PE_IMAGE_IMPORT_BY_NAME*)(PEImage.begin() + ((DWORD*)pRead)[j]);
  151.                     pProc = GetProcAddress(hModule, (LPCSTR)(pImportName->Name));//fprintf(f_out, "  %04X %s/n", pImportName->Hint, pImportName->Name);//打印函数
  152.                 }
  153.                 pRead = PEImage.begin() + pImportDesc[i].FirstThunk;
  154.                 ((DWORD*)pRead)[j] = (DWORD)pProc;
  156.             }
  158.         }
  159.     }//if
  163.     //输出IAT 重定位外部符号的地址
  164.     if(pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress!=0)
  165.     {
  166.         FILE* f_out;
  167.         f_out=fopen("debug1.txt","wt");
  168.         j = pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size / 4;
  169.         pRead = PEImage.begin() + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress;
  170.         for(i=0;i<=j-1;i++)
  171.         {
  172.             fprintf(f_out, "%08X/n", ((DWORD*)pRead)[i]);
  173.         }
  175.         fclose(f_out);
  176.     }
  177. //*/
  179. //------------------------------------------------------------
  180.     //加壳，组装PE
  182.     uint_t PackerCodeRelocateOffset[0x10]={0x000B, 0x0013, 0x001B, 0x0023, 0x002B, 0x0033, 0x003B, };
  183.     blob_c PEReleaseBuf(pPEHeaders->OptionalHeader.SizeOfImage*3);
  184.     memset(PEReleaseBuf.begin(),0,PEReleaseBuf.size());
  185.     blob_c PELoaderData;
  186.     PELoaderData.bload(".//PackLoader//loader.dat");
  188.     ///*写映像
  189.     blob_c tmpSectionBuf_text(pPEHeaders->OptionalHeader.SizeOfImage*4);
  190.     memset(tmpSectionBuf_text.begin(),0,tmpSectionBuf_text.size());
  193.     //编码
  194.     BYTE nPeek;
  195.     BYTE byCurByte, nRptCnt;
  196.     uint_t nOldImageSize = pPEHeaders->OptionalHeader.SizeOfImage;
  197.     uint_t nOldHeaderSize = pPEHeaders->OptionalHeader.SizeOfHeaders;
  198.     pRead = PEImage.begin()+pPEHeaders->OptionalHeader.SizeOfHeaders;
  199.     pWrite = tmpSectionBuf_text.begin();
  201.     nPeek = 0;
  203.     nRptCnt = 0;
  204.     byCurByte = *((BYTE*)pRead);
  205.     for(i=0;i<=nOldImageSize-nOldHeaderSize-1;i++)
  206.     {
  207.         if(byCurByte == *((BYTE*)pRead) && nRptCnt<=(0x3F-1))   //最长的重复记录 63 个
  208.         {
  209.             nRptCnt++;
  210.         }
  211.         else
  212.         {
  213.             if(nRptCnt==1)
  214.             {
  215.                 if(byCurByte>=0xC0)
  216.                 {
  217.                     *((BYTE*)pWrite++) = 0xC1;  //没有重复，但是值大于C0
  218.                     *((BYTE*)pWrite++) = byCurByte;
  219.                 }
  220.                 else
  221.                 {
  222.                     *((BYTE*)pWrite++) = byCurByte;
  223.                 }
  224.             }
  225.             else
  226.             {
  227.                 *((BYTE*)pWrite++) = 0xC0+nRptCnt;  //重复，输出重复的代码
  228.                 *((BYTE*)pWrite++) = byCurByte;
  229.                 nRptCnt = 1;    //重新开始计数
  230.             }
  231.             byCurByte = *((BYTE*)pRead); //重复判定的字符更新
  232.         }
  233.         pRead++;
  234.     }
  235.     *((BYTE*)pWrite++) = 0xC0;  //结束符
  238.     //写壳代码
  239.     uint_t nPackerCodeEntryOffset;
  240.     nPackerCodeEntryOffset = pWrite-tmpSectionBuf_text.begin(); 
  242.     pRead = PELoaderData.begin();
  243.     memcpy(pWrite, pRead, PELoaderData.size());
  245.     //重建导入表
  246.     uint_t nOriginalFirstThunkOfImportDataOffset, nFirstThunkOfImportDataOffset, nImportTableOfImportDataOffset, nStrOfImportDataOffset;
  247.     uint_t nOriginalFirstThunkOfImportDataPtr, nFirstThunkOfImportDataPtr, nImportTableOfImportDataPtr, nStrOfImportDataPtr;
  248.     nFirstThunkOfImportDataOffset = 0;
  249.     nOriginalFirstThunkOfImportDataOffset = nFirstThunkOfImportDataOffset + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  250.     nImportTableOfImportDataOffset = nOriginalFirstThunkOfImportDataOffset + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  251.     nStrOfImportDataOffset = nImportTableOfImportDataOffset + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;
  253.     nOriginalFirstThunkOfImportDataPtr = nOriginalFirstThunkOfImportDataOffset;
  254.     nFirstThunkOfImportDataPtr = nFirstThunkOfImportDataOffset;
  255.     nImportTableOfImportDataPtr = nImportTableOfImportDataOffset;
  256.     nStrOfImportDataPtr = nStrOfImportDataOffset;
  258.     uint_t nPackerImportDataOffset = nPackerCodeEntryOffset + PELoaderData.size();
  259.     uint_t nPackerIATOffset = nPackerCodeEntryOffset + PELoaderData.size();
  260.     uint_t nImortDataVirtualOffset = 0x1000 + (pPEHeaders->OptionalHeader.SizeOfImage - pPEHeaders->OptionalHeader.SizeOfHeaders) +nPackerIATOffset;
  261.     uint_t nPackerImportOffset = nPackerIATOffset + pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  262.     blob_c tmpImportTableBuf(pPEHeaders->OptionalHeader.SizeOfImage*2);
  263.     memcpy(tmpImportTableBuf.begin()+nImportTableOfImportDataOffset, pImportDesc, pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size);
  264.     memcpy(tmpImportTableBuf.begin()+nFirstThunkOfImportDataOffset, PEImage.begin()+pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress, pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size);
  265.     PE_IMAGE_IMPORT_DESCRIPTOR* ptmpImportDesc = (PE_IMAGE_IMPORT_DESCRIPTOR*)(tmpImportTableBuf.begin()+nImportTableOfImportDataOffset);
  268.     if(nImportDescNum!=0)
  269.     {
  270.         for(i=0;i<=nImportDescNum-1;i++)
  271.         {
  272.             //fprintf(f_out, "%s/n", PEImage.begin()+pImportDesc[i].Name);//打印模块名
  273.             strcpy((char*)tmpImportTableBuf.begin()+nStrOfImportDataPtr, (char*)PEImage.begin()+pImportDesc[i].Name);
  274.             ptmpImportDesc[i].Name = nStrOfImportDataPtr + nImortDataVirtualOffset;
  275.             nStrOfImportDataPtr += strlen((char*)PEImage.begin()+pImportDesc[i].Name)+1;
  276.             
  278.             ptmpImportDesc[i].OriginalFirstThunk = 0;
  279.             pRead = PEImage.begin() + pImportDesc[i].FirstThunk;
  280.             ptmpImportDesc[i].FirstThunk = ptmpImportDesc[i].FirstThunk - pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress + nImortDataVirtualOffset;
  281.             nFirstThunkOfImportDataPtr = pImportDesc[i].FirstThunk - pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress;
  283.             for(j=0;TRUE;j++)
  284.             {           
  285.                 if(((DWORD*)pRead)[j]==0)
  286.                     break;
  287.                 if(!(((DWORD*)pRead)[j]&IMAGE_ORDINAL_FLAG32))
  288.                 {
  289.                     pImportName = (PE_IMAGE_IMPORT_BY_NAME*)(PEImage.begin() + ((DWORD*)pRead)[j]);
  290.                     //fprintf(f_out, "  %04X %s/n", pImportName->Hint, pImportName->Name);//打印函数
  291.                     *(BYTE*)(tmpImportTableBuf.begin()+nStrOfImportDataPtr+0) = 0;
  292.                     *(BYTE*)(tmpImportTableBuf.begin()+nStrOfImportDataPtr+1) = 0;  //Hint
  293.                     strcpy((char*)tmpImportTableBuf.begin()+nStrOfImportDataPtr+2, (char*)pImportName->Name);
  295.                     *((DWORD*)(tmpImportTableBuf.begin() + nFirstThunkOfImportDataPtr)) = nStrOfImportDataPtr + nImortDataVirtualOffset;nFirstThunkOfImportDataPtr+=4;
  296.                     nStrOfImportDataPtr += strlen((char*)pImportName->Name)+2+1; //2位Hint的长度，1为字符串结束符
  297.                 }
  298.                 else
  299.                 {
  300.                     nFirstThunkOfImportDataPtr+=4;
  301.                 }
  302.             
  303.             }
  304.             nFirstThunkOfImportDataPtr+=4;  //跳过0
  305.         }
  306.     }//if
  309.     uint_t ntmpImportTableBufSize;
  310.     ntmpImportTableBufSize = nStrOfImportDataPtr;
  313.     //写导入数据
  314.     pRead = tmpImportTableBuf.begin();
  315.     pWrite = tmpSectionBuf_text.begin() + nPackerImportDataOffset;
  316.     memcpy(pWrite, pRead, ntmpImportTableBufSize);
  318.     uint_t nSecTextImageSize;
  319.     nSecTextImageSize = nPackerImportDataOffset + ntmpImportTableBufSize;
  320.     nSecTextImageSize = (nSecTextImageSize+0x0FFF)&0xFFFFF000;
  323.     //重定位壳代码的地址
  324.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[0])) = pPEHeaders->OptionalHeader.ImageBase+pPEHeaders->OptionalHeader.SizeOfImage;
  325.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[1])) = pPEHeaders->OptionalHeader.ImageBase+pPEHeaders->OptionalHeader.SizeOfHeaders;
  326.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[2])) = nPackerCodeEntryOffset;
  327.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[3])) = pPEHeaders->OptionalHeader.ImageBase+pPEHeaders->OptionalHeader.AddressOfEntryPoint;
  328.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[4])) = pPEHeaders->OptionalHeader.ImageBase+pPEHeaders->OptionalHeader.SizeOfImage+nPackerIATOffset;
  329.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[5])) = pPEHeaders->OptionalHeader.ImageBase+pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress;
  330.     *((DWORD*)(tmpSectionBuf_text.begin()+nPackerCodeEntryOffset+PackerCodeRelocateOffset[6])) = pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  331.     
  334.     //*/
  335.     //填表头
  336.     PE_IMAGE_SECTION_HEADER tmpSecHeader_data, tmpSecHeader_text;
  337.     
  338.     memcpy(tmpSecHeader_data.Name, ".data", IMAGE_SIZEOF_SHORT_NAME);
  339.     tmpSecHeader_data.Misc.VirtualSize = pPEHeaders->OptionalHeader.SizeOfImage - pPEHeaders->OptionalHeader.SizeOfHeaders;
  340.     tmpSecHeader_data.VirtualAddress = pPEHeaders->OptionalHeader.SizeOfHeaders;
  341.     tmpSecHeader_data.SizeOfRawData = 0;//暂时
  342.     tmpSecHeader_data.PointerToRawData = pPEHeaders->OptionalHeader.SizeOfHeaders;//暂时
  343.     tmpSecHeader_data.PointerToRelocations = 0x00000000;
  344.     tmpSecHeader_data.PointerToLinenumbers = 0x00000000;
  345.     tmpSecHeader_data.NumberOfRelocations = 0x0000;
  346.     tmpSecHeader_data.NumberOfLinenumbers = 0x0000;
  347.     tmpSecHeader_data.Characteristics = 0xE0000080;
  348.     
  349.     memcpy(tmpSecHeader_text.Name, ".text", IMAGE_SIZEOF_SHORT_NAME);
  350.     tmpSecHeader_text.Misc.VirtualSize = nSecTextImageSize;//暂时
  351.     tmpSecHeader_text.VirtualAddress = pPEHeaders->OptionalHeader.SizeOfImage;
  352.     tmpSecHeader_text.SizeOfRawData = tmpSecHeader_text.Misc.VirtualSize;//暂时
  353.     tmpSecHeader_text.PointerToRawData = pPEHeaders->OptionalHeader.SizeOfHeaders;//暂时
  354.     tmpSecHeader_text.PointerToRelocations = 0x00000000;
  355.     tmpSecHeader_text.PointerToLinenumbers = 0x00000000;
  356.     tmpSecHeader_text.NumberOfRelocations = 0x0000;
  357.     tmpSecHeader_text.NumberOfLinenumbers = 0x0000;
  358.     tmpSecHeader_text.Characteristics = 0xE0000040;
  364.     PE_IMAGE_DOS_HEADER tmpDosHeader;
  365.     tmpDosHeader.e_magic = IMAGE_DOS_SIGNATURE;        // Magic number
  366.     tmpDosHeader.e_cblp = 0x0090;                      // Bytes on last page of file
  367.     tmpDosHeader.e_cp = 0x0003;                        // Pages in file
  368.     tmpDosHeader.e_crlc = 0x0000;                      // Relocations
  369.     tmpDosHeader.e_cparhdr = 0x0004;                   // Size of header in paragraphs
  370.     tmpDosHeader.e_minalloc = 0x0000;                  // Minimum extra paragraphs needed
  371.     tmpDosHeader.e_maxalloc = 0xFFFF;                  // Maximum extra paragraphs needed
  372.     tmpDosHeader.e_ss = 0x0000;                        // Initial (relative) SS value
  373.     tmpDosHeader.e_sp = 0x00B8;                        // Initial SP value
  374.     tmpDosHeader.e_csum = 0x0000;                      // Checksum
  375.     tmpDosHeader.e_ip = 0x0000;                        // Initial IP value
  376.     tmpDosHeader.e_cs = 0x0000;                        // Initial (relative) CS value
  377.     tmpDosHeader.e_lfarlc = 0x0040;                    // File address of relocation table
  378.     tmpDosHeader.e_ovno = 0x0000;                      // Overlay number
  379.     memset(tmpDosHeader.e_res, 0, sizeof(WORD)*4);                    // Reserved words
  380.     tmpDosHeader.e_oemid = 0x0000;                     // OEM identifier (for e_oeminfo)
  381.     tmpDosHeader.e_oeminfo = 0x0000;                   // OEM information; e_oemid specific
  382.     memset(tmpDosHeader.e_res2, 0, sizeof(WORD)*10);        // Reserved words
  383.     tmpDosHeader.e_lfanew = 0x00C0;                    // File address of new exe header
  388.     PE_IMAGE_NT_HEADERS32 tmpPEHeaders;
  389.     tmpPEHeaders.Signature = IMAGE_NT_SIGNATURE;
  391.     tmpPEHeaders.FileHeader.Machine = 0x014C;
  392.     tmpPEHeaders.FileHeader.NumberOfSections = 0x0002;  //就两个节
  393.     tmpPEHeaders.FileHeader.TimeDateStamp = 0x00000000;
  394.     tmpPEHeaders.FileHeader.PointerToSymbolTable = 0;
  395.     tmpPEHeaders.FileHeader.NumberOfSymbols = 0;
  396.     tmpPEHeaders.FileHeader.SizeOfOptionalHeader = 0x00E0;
  397.     tmpPEHeaders.FileHeader.Characteristics = 0x010F;
  399.     tmpPEHeaders.OptionalHeader.Magic = 0x010B;
  400.     tmpPEHeaders.OptionalHeader.MajorLinkerVersion = 0x06;
  401.     tmpPEHeaders.OptionalHeader.MinorLinkerVersion = 0x00;
  402.     tmpPEHeaders.OptionalHeader.SizeOfCode = 0x00000000;
  403.     tmpPEHeaders.OptionalHeader.SizeOfInitializedData = 0x00000000;
  404.     tmpPEHeaders.OptionalHeader.SizeOfUninitializedData = 0x00000000;
  405.     tmpPEHeaders.OptionalHeader.AddressOfEntryPoint = pPEHeaders->OptionalHeader.SizeOfImage+nPackerCodeEntryOffset;
  406.     tmpPEHeaders.OptionalHeader.BaseOfCode = 0; //没用
  407.     tmpPEHeaders.OptionalHeader.BaseOfData = 0; //没用
  408.     
  409.     tmpPEHeaders.OptionalHeader.ImageBase = pPEHeaders->OptionalHeader.ImageBase;
  410.     tmpPEHeaders.OptionalHeader.SectionAlignment = 0x00001000;
  411.     tmpPEHeaders.OptionalHeader.FileAlignment = 0x000001000;
  412.     tmpPEHeaders.OptionalHeader.MajorOperatingSystemVersion = 0x0004;
  413.     tmpPEHeaders.OptionalHeader.MinorOperatingSystemVersion = 0x0000;
  414.     tmpPEHeaders.OptionalHeader.MajorImageVersion = 0x0000;
  415.     tmpPEHeaders.OptionalHeader.MinorImageVersion = 0x0000;
  416.     tmpPEHeaders.OptionalHeader.MajorSubsystemVersion = 0x0004;
  417.     tmpPEHeaders.OptionalHeader.MinorSubsystemVersion = 0x0000;
  418.     tmpPEHeaders.OptionalHeader.Win32VersionValue = 0;
  419.     tmpPEHeaders.OptionalHeader.SizeOfImage = pPEHeaders->OptionalHeader.SizeOfHeaders + tmpSecHeader_data.Misc.VirtualSize + tmpSecHeader_text.Misc.VirtualSize;
  420.     tmpPEHeaders.OptionalHeader.SizeOfHeaders = 0x00001000;
  421.     tmpPEHeaders.OptionalHeader.CheckSum = 0x00000000;
  422.     tmpPEHeaders.OptionalHeader.Subsystem = pPEHeaders->OptionalHeader.Subsystem;
  423.     tmpPEHeaders.OptionalHeader.DllCharacteristics = 0;
  424.     tmpPEHeaders.OptionalHeader.SizeOfStackReserve = 0x00100000;
  425.     tmpPEHeaders.OptionalHeader.SizeOfStackCommit = 0x00001000;
  426.     tmpPEHeaders.OptionalHeader.SizeOfHeapReserve = 0x00100000;
  427.     tmpPEHeaders.OptionalHeader.SizeOfHeapCommit = 0x00001000;
  428.     tmpPEHeaders.OptionalHeader.LoaderFlags = 0;
  429.     tmpPEHeaders.OptionalHeader.NumberOfRvaAndSizes = 0x00000010;
  430.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress = 0x00000000;
  431.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size = 0x00000000;
  432.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress = pPEHeaders->OptionalHeader.SizeOfImage+nPackerImportDataOffset+nImportTableOfImportDataOffset;
  433.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size = pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;
  434.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = 0x00000000;
  435.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = 0x00000000;
  436.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0x00000000;
  437.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = 0x00000000;
  438.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress = 0x00000000;
  439.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size = 0x00000000;
  440.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0x00000000;
  441.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = 0x00000000;
  442.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = 0x00000000;
  443.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size = 0x00000000;
  444.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_ARCHITECTURE].VirtualAddress = 0x00000000;
  445.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_ARCHITECTURE].Size = 0x00000000;
  446.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].VirtualAddress = 0x00000000;
  447.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].Size = 0x00000000;
  448.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress = 0x00000000;
  449.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size = 0x00000000;
  450.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress = 0x00000000;
  451.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].Size = 0x00000000;
  452.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0x00000000;
  453.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0x00000000;
  454.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress = pPEHeaders->OptionalHeader.SizeOfImage+nPackerImportDataOffset+nFirstThunkOfImportDataOffset;
  455.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size = pPEHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  456.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress = 0x00000000;
  457.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].Size = 0x00000000;
  458.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress = 0x00000000;
  459.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].Size = 0x00000000;
  460.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESERVED].VirtualAddress = 0;
  461.     tmpPEHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESERVED].Size = 0;
  467.     //写文件头
  468.     pWrite = PEReleaseBuf.begin();
  469.     memcpy(pWrite, &tmpDosHeader, sizeof(PE_IMAGE_DOS_HEADER)); 
  470.     pWrite = PEReleaseBuf.begin() + tmpDosHeader.e_lfarlc;
  471.     memcpy(pWrite, PERawImage.begin()+pDosHeader->e_lfarlc, 0x40); //0x40 dos stub 代码长度     
  472.     pWrite = PEReleaseBuf.begin() + tmpDosHeader.e_lfanew;
  473.     memcpy(pWrite, &tmpPEHeaders, sizeof(PE_IMAGE_NT_HEADERS32));
  474.     
  475.     //写2个节头
  476.     pWrite+=sizeof(PE_IMAGE_NT_HEADERS32);
  477.     memcpy(pWrite, &tmpSecHeader_data, sizeof(PE_IMAGE_SECTION_HEADER));
  478.     pWrite+=sizeof(PE_IMAGE_SECTION_HEADER);
  479.     memcpy(pWrite, &tmpSecHeader_text, sizeof(PE_IMAGE_SECTION_HEADER));
  482.     //写节数据
  483.     pWrite = PEReleaseBuf.begin() + tmpSecHeader_text.PointerToRawData;
  484.     memcpy(pWrite, tmpSectionBuf_text.begin(), tmpSecHeader_text.SizeOfRawData);
  487.     //dump成文件
  488.     FILE* f_rl;
  489.     f_rl = fopen(szOutputFile,"wb");
  490.     fwrite(PEReleaseBuf.begin(), tmpPEHeaders.OptionalHeader.SizeOfImage, 1, f_rl);
  491.     fclose(f_rl);
  493.     //...
  496.     return 0;   
  497. }
有点多，抱歉了。
功能不全，只能给不含资源的EXE加壳，比如win32 控制台程序。

搞清楚文件的结构之后，我们就可以开始操刀搞加壳了。

。。。待续



和讯网数据爬虫 和讯网数据爬虫
原创粉丝点击
热门IT博客
淘宝网肚皮舞服装新款淘宝网肚皮舞服装新款
济南市网络举报电话济南市网络举报电话
java 架构视频
阿里云盘免费吗
apk源码编译软件
linux命令详解手册
美国指数型基金数据
mac用户头像更改
大数据总结报告
点金手软件怎么样
瑰柏翠和欧舒丹 知乎
linux下多线程机制
模拟黄金软件下载
人肉搜索网络团队
淘宝达人怎么登录
怎么复制汇总数据
双十一淘宝客服话术
美国陆军3 知乎
arraymap遍历数据
xmind8 mac破解序列号
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 www.55125.cn app.avjj88.com 农肤导航 acfun网 玩雏视频 ppt2010插入动态图 wwwz569com最新网址 人妖99rys在线 火影之纲手性监狱2动漫 陈文媛和张柏芝阿娇钟欣棕咬卵门400张照 www.754ee.com 69乐园真实夫妻照片 换爱视频俱乐部 18acg绅士最新网址 同人工囗囗番全彩漫画 91论坛登录网址 一品堂夜生活论坛 吉尼斯最大的生}器图 www2222xzcom 小明视视频2018 页码从第三页开始 小明视视频播放2018台湾 1996杨思敏经典版 玉浦圃之愉情宝手机在线播放 两男一女具体做法 真人做人视频90分钟 真人做真爰有声音动作视频 wacom50少彐x片 相H近伦 儿子给妈种下情种 子母家庭 军儿 你长大了 会弄娘了 打工期间跟儿子做了 上朋友他妈免费视频中文字慕 儿子你不能这样啊在线播放30分钟 全屏儿子射J去妈怀孕了全彩 108种外阴女人夜毛一 www vr9777 小学女生被扒裤子在线播放 男子扒女子裤子并又扒胸亲的视频 视频 小学生b18十

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里