首页
论坛
课程
招聘
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝

[调试逆向] [原创]《32位PE解析、PE修改、导入表注入》(上传打印资源表代码)

2020-3-21 20:13 4587

[调试逆向] [原创]《32位PE解析、PE修改、导入表注入》(上传打印资源表代码)

2020-3-21 20:13
4587

混子目录



                                                 

0x0 PE概述

PE文件的全称是Portable Executable,意为可移植的可执行的文件,常见的EXE、DLL、OCX、SYS、COM都是PE文件,我们比较熟悉的DLL和exe文件都是PE文件。了解PE文件格式有助于加深对操作系统的理解,掌握可执行文件的数据结构机器运行机制,对于逆向破解,加壳等安全方面方面的同学极其重要。

PE在二进制文件中就是一堆0和1,但是它是按一定的格式来存储的,下面我先从宏观上来给大家介绍。

PE分dos头、NT头(包含标准PE头和可选PE头(包含数据目录))、节表。

下面我上一张图给大家看一下:


dos头(方块1第一块),NT头(方块1第二块),标准PE头(方块2),可选PE头(方块3),数据目录(方块5)、节表(方块4)。

下面我按着这个编号来介绍。


0x1解析PE

首先我讲一下dos头,如图



微软定义如下:


typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header 

   WORD   e_magic;          +0           // Magic number  DOS签名 4D5A "MZ"

   WORD   e_cblp;           +2           // Bytes on last page of file 

   WORD   e_cp;             +4           // Pages in file 

   WORD   e_crlc;           +6           // Relocations 

   WORD   e_cparhdr;        +8           // Size of header in paragraphs 

   WORD   e_minalloc;       +10           // Minimum extra paragraphs needed 

   WORD   e_maxalloc;       +12           // Maximum extra paragraphs needed 

   WORD   e_ss;             +14           // Initial (relative) SS value 

   WORD   e_sp;             +16           // Initial SP value 

   WORD   e_csum;           +18           // Checksum 

   WORD   e_ip;             +20           // Initial IP value 

   WORD   e_cs;             +22           // Initial (relative) CS value 

   WORD   e_lfarlc;         +24           // File address of relocation table 

   WORD   e_ovno;           +26           // Overlay number 

   WORD   e_res[4];         +28 +32 +34 +36           // Reserved words 

   WORD   e_oemid;          +38           // OEM identifier (for e_oeminfo) 

   WORD   e_oeminfo;        +40           // OEM information; e_oemid specific 

   WORD   e_res2[10];                 // Reserved words 

   LONG   e_lfanew;         +60     // File address of new exe header  指向PE头 3Ch

      } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;



虽然字段比较多,但是我们初学只要知道2个字段就ok了——   WORD   e_magic和LONG   e_lfanew;    e_magic字段是标记,用途就是标记这个文件是什么类型的文件,比如:exe,dll,sys文件都是4D5A开头的。


MZ是一个大佬名字的简称,不过他貌似已经挂了???xxxx 反正知道mz标记就是代表可执行文件就ok了。

lfanew字段就是标记NT头在文件里的偏移,文件头+lfanew就是NT头的位置(中间有一段没用的数据叫 dos  sub 下文增加节会讲)。


0x50 0x45是PE的标志 ,因为“PE”的ascll码就是0x50 0x45。

NT头

NT头包含标准PE头和可选PE头,文件的很多信息都在这里面。


Signature字段里存的就是pe标记,注意宽度是4,然后就是标准PE头。


标准PE头

标准PE头一共是20个字节,下面我讲一下字段的用处。


typedef struct _IMAGE_FILE_HEADER { 

       * WORD   [60]+4 Machine; 运行平台

       * WORD    NumberOfSections; [60]+6 文件的节数目

       * DWORD   TimeDateStamp;   [60]+8 文件创建日期和时间

        DWORD   PointerToSymbolTable;   [60]+12  指向符号表(用于调试)

        DWORD   NumberOfSymbols;  [60]+16 符号表中的符号数量(用于调试)

       * WORD    SizeOfOptionalHeader;[60]+20  可选头的长度

       * WORD    Characteristics; [60]+22  文件属性

} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER



1.Machine字段,表示目标CPU 的类型。

几个常见的及其标识如下:

机器              标识     

Intel I386          14ch

MIPS R3000        162h

Alpha AXP          184h

Power PC           1F0h

MIPS R4000         184h

2.NumberOfSection,标识节的数目,关于节后面会详细讲。

3.TimeDateStamp

PE文件创建的时间,这个时间是指从1970年1月1日到创建该文件的所有的秒数。

4)PointerToSymbolTable。略

5)NumberOfSymbol。略

6)SizeOfOptionalHeader:紧跟着标准PE头后面的数据大小,这也是一个数据结构,它叫做可选PE头,其大小依赖于是64位还是32位文件。32位文件值通常是00E0h,对于64位值通常为00F0h。

7)Characteristics:文件属性,普通EXE文件这个字段值为010fh,DLL文件这个字段一般是0210h。


(标准pe头)

可选PE头

可选PE头,其大小依赖于是64位还是32位文件。32位文件值通常是00E0h,对于64位值通常为00F0h。



可选PE头字段多,但是重要的不多(加*的都很重要,不要慌,*是我加的)。


typedef struct _IMAGE_OPTIONAL_HEADER { 

       * WORD    Magic;  10B 32位PE 20B 64位PE 107 ROM映像[60]+24

        BYTE    MajorLinkerVersion;  链接器版本号   [60]+26                 

        BYTE    MinorLinkerVersion;  链接器副版本号  [60]+27

       * DWORD   SizeOfCode;  所有代码节的总和  该大小是基于文件对齐后的大小[60]+28

       * DWORD   SizeOfInitializedData;  所有含已初始化数据的节的总大小  [60]+32

       * DWORD   SizeOfUninitializedData;  所有含未初始化数据的节的大小    [60]+36

       * DWORD   AddressOfEntryPoint;  程序执行入口RVA     [60]+40

       * DWORD   BaseOfCode;  代码节的起始RVA              [60]+44

       * DWORD   BaseOfData;  数据节的起始RVA               [60]+48

       * DWORD   ImageBase;  程序的优先装载地址              [60]+52

       * DWORD   SectionAlignment;  内存中节的对齐粒度                 [60]+56                               

       * DWORD   FileAlignment;  文件中节的对齐粒度           [60]+60

        WORD    MajorOperatingSystemVersion;  操作系统主版本号 [60]+64

        WORD    MinorOperatingSystemVersion;  操作系统副版本号   [60]+66

        WORD    MajorImageVersion;  PE文件映像的版本号     [60]+68

        WORD    MinorImageVersion;                          [60]+70

        WORD    MajorSubsystemVersion;  子系统的版本号       [60]+72

        WORD    MinorSubsystemVersion;                     [60]+74

        DWORD   Win32VersionValue;  未用 必须设置0          [60]+76

        DWORD   SizeOfImage;  内存中整个PE文件的映像尺寸       [60]+80

        DWORD   SizeOfHeaders;  所有节表按照文件对齐粒度后的大小   [60]+84

        DWORD   CheckSum;  校验和                    [60]+88

        WORD    Subsystem;  指定使用界面的子系统       [60]+92

        WORD    DllCharacteristics;  DALL文件属性        [60]+94

      *  DWORD   SizeOfStackReserve;  初始化时保留的栈的大小  [60]+96

      *  DWORD   SizeOfStackCommit;  初始化时实际提交的栈的大小   [60]+100

      *  DWORD   SizeOfHeapReserve;  初始化时保留的堆的大小   [60]+104

      *  DWORD   SizeOfHeapCommit;  初始化时实际提交的堆的大小 [60]+108

        DWORD   LoaderFlags;  加载标志  未用      [60]+112

        DWORD   NumberOfRvaAndSizes;  下面的数据目录结构的数量  +116

        IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];+120 

} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;




额,重要的也蛮多。。。

详细字段的用处我会在下面代码里会详细说明,数据目录。。。。好吧,现在讲。


数据目录

在PE结构中最重要的就是节表和数据目录表,数据目录一共指向16张表,分别是:导出表、导入表、资源表、异常信息表、安全证书表、重定位表、调试信息表、版权所以表、全局指针表                           

TLS表、加载配置表、绑定导入表、IAT表、延迟导入表、COM信息表 最后一个保留未使用。                     

这么多表中我们只要注重导出表、导入表、重定位表、IAT表就可以了。他们直接影响程序运行。 注意:数据目录只是各种表的地址(rva)。需要寻址才能找到他们。


(数据目录,太长了没有截完)

每张记录宽度8字节 然后*16=128字节


经过解析就变成




代码实现解析PE头(PE头和标准PE头是两个东西)

代码实现思路就是按照字段宽度偏移来遍历dos头、NT头。(这里rva和foa都一样)


__int64 flen = 0;

//int arr_dos[30];

char* word_dos[] =

{

         "e_magic",  "e_cblp",  "e_cp",  "e_crlc",  "e_cparhdr",  "e_minalloc", "e_maxalloc",   "e_ss",  "e_sp",
         "e_csum",  "e_ip",  "e_cs", "e_lfarlc","e_ovno",   "e_res[4]",  "e_res[4]",  "e_res[4]", "e_res[4]",  "e_oemid",

         "e_oeminfo",   "e_res2[10]",  "e_res2[10]",    "e_res2[10]",  "e_res2[10]",     "e_res2[10]",   "e_res2[10]",
        "e_res2[10]",    "e_res2[10]",    "e_res2[10]",      "e_res2[10]",     "e_lfanew"

};

/////////////////////////////////////////////////////////////////char* NT_word[]

int arr_pe[8] = { 4,2,2,4,4,4,2,2 }; //标准pe每个字段的宽度

int pe_s = 0;//没用 凑数的

int arr_o_pe[] = { 2,1,1,4,4,4,4,4,4,4,4,4,2,2,2,2,2,2,4

,4,4,4,2,2,4

,4,4,4 ,4,4 };//取字段字节数

int arr_sch[10] = { 8,4,4,4,4,4,4,2,2,4 };

//char*// file_ser(char*, unsigned __int64);

char* file_open(char* fstr)//打开文件并保存文件流

{

         FILE* pf = fopen(fstr, "rb");

         if (pf == NULL)

         {

                   perror("The following error occurred");

                   return 0;

         }

         fseek(pf, 0, 2);

         unsigned __int64 fsize = ftell(pf);

         flen = fsize;

         rewind(pf);

         char* fbuff = (char*)malloc(fsize);

         if (fbuff == NULL)

         {

                   perror("The following error occurred");

                   return 0;

         }

         memset(fbuff, 0, fsize);

         unsigned __int64 r = fread(fbuff, 1, fsize, pf);

         if (r == 0)

         {

                   perror("The following error occurred");

                   return 0;

         }

         //fclose(pf);

         //free(pf);

         //pf = 0;

         //print_pe(fbuff);

         //ftoi_32(fbuff);

         return fbuff;

}

先打开文件,然后调用打印函数。

void print_pe(char* ppe)//打印pe字段

{

         char* flag = ppe;//flag是游标

         for (int j = 0; j <= 58; j += 2)//dos头除了最后一个字段都是2个字节

         {

                   printf("%s   %X\n", word_dos[j / 2], *(short*)flag);

                   flag += 2;

         }

         printf("%s %X\n", word_dos[30], *(int*)flag);//e_lfanew字段

         int pe_offsets = *(int*)flag;

         flag = (char*)((int)ppe + pe_offsets);   //游标跳NT头

         printf("*************pe******************\n");

         for (int i = 0; i < 8; i++)//处理标准pe

         {

                   if (arr_pe[i] == 4)

                   {

                            printf("%X\n", *(int*)flag);

                            flag += 4;

                   }

                   else if (arr_pe[i] == 2)

                   {

                            printf("%X\n", *(short*)flag);

                            flag += 2;

                   }

         }

         printf("*************option pe******************\n");

         for (int i1 = 0; i1 < sizeof(arr_o_pe) / sizeof(arr_o_pe[0]); i1++)//处理可选pe

         {

                   if (arr_o_pe[i1] == 4)

                   {

                            printf("%X\n", *(int*)flag);

                            flag += 4;

                   }

                   else if (arr_o_pe[i1] == 2)

                   {

                            printf("%X\n", *(short*)flag);

                            flag += 2;

                   }

                   else if (arr_o_pe[i1] == 1)

                   {

                            printf("%X\n", *(char*)flag);

                            flag += 1;

                   }

         }
        		printf("*************data dir******************\n");

		for (int i1 = 0; i1 < 16; i1++)
		{
		
		
			printf("%X   %X\n", *(int*)flag, *(int*)(flag+4));
				flag += 8;

			}

         return;

}



0x2 PE节表

PE文件中所有节的属性都被定义在节表中,节表由一系列的IMAGE_SECTION_HEADER结构排列而成,每个结构用来描述一个节,结构的排列顺序和它们描述的节在文件中的排列顺序是一致的。全部有效结构的最后以一个空的IMAGE_SECTION_HEADER结构作为结束,所以节表中总的IMAGE_SECTION_HEADER结构数量等于节的数量加一。节表总是被存放在紧接在PE文件头的地方。

另外,节表中 IMAGE_SECTION_HEADER 结构的总数总是由PE文件头 IMAGE_NT_HEADERS 结构中的 FileHeader.NumberOfSections 字段来指定的。

一个节表的宽度是40个字节,最后一个节表后面要跟上40个字节的0,也就是结束标志。(也可以没有结束标志,不过可能会炸。。。)


(节表)

一个文件至少由1个节表组成,每个节表记录了节的地址(rva和foa),大小,权限等,每节表占40个字节。

下面来说说每一个字段和作用。


typedef struct _IMAGE_SECTION_HEADER {                                                                           

    BYTE    Name[IMAGE_SIZEOF_SHORT_NAME]; +0                                                                     

    union {                                                                                

            DWORD   PhysicalAddress;                                                                                   

            DWORD   VirtualSize;                                                                            

    } Misc;                                  +8   双字 是该节在没有对齐前的真实尺寸,该值可以不准确。

    DWORD   VirtualAddress;             +12 节区在内存中的偏移地址。加上ImageBase才是在内存中的真正地址址.                                                 

    DWORD   SizeOfRawData;           +16 节在文件中对齐后的尺寸.                                                 

    DWORD   PointerToRawData;               +20 节区在文件中的偏移.     raw地址+偏移=下一节的地址                                     

    DWORD   PointerToRelocations; +24 在obj文件中使用 对exe无意义                                              

    DWORD   PointerToLinenumbers;        +28 行号表的位置 调试的时候使用                                       

    WORD    NumberOfRelocations;          +32 在obj文件中使用  对exe无意义                                           

    WORD    NumberOfLinenumbers;       +34 行号表中行号的数量 调试的时候使用                                           

    DWORD   Characteristics;             +36 节的属性                                              

} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;



联合体就当成一个变量来用就可以了,宽度是最大的那一个变量。



1、Name          8个字节 一般情况下是以"\0"结尾的ASCII吗字符串来标识的名称,内容可以自定义.                                                            

注意:该名称并不遵守必须以"\0"结尾的规律,如果不是以"\0"结尾,系统会截取8个字节的长度进行处理.                                                             

2、Misc  双字 是该节在没有对齐前的真实尺寸,该值可以不准确。                                        

3、VirtualAddress 节区在内存中的偏移地址。加上ImageBase才是在内存中的真正地址.

4、SizeOfRawData  节在文件中对齐后的尺寸.                                                                

5、PointerToRawData 节区在文件中的偏移.                                                            

6、PointerToRelocations 在obj文件中使用 对exe无意义                                                              

7、PointerToLinenumbers 行号表的位置 调试的时候使用                                                              

8、NumberOfRelocations 在obj文件中使用  对exe无意义                                                          

9、NumberOfLinenumbers 行号表中行号的数量 调试的时候使用                                              

10、Characteristics 节的属性                                                             

节的属性:

[值:00000020h] [IMAGE_SCN_CNT_CODE                // Section contains code.(包含可执行代码)]

[值:00000040h] [IMAGE_SCN_CNT_INITIALIZED_DATA    // Section contains initialized data.(该块包含已初始化的数据)]

[值:00000080h] [IMAGE_SCN_CNT_UNINITIALIZED_DATA  // Section contains uninitialized data.(该块包含未初始化的数据)]

[值:00000200h] [IMAGE_SCN_LNK_INFO                // Section contains comments or some other type of information.]

[值:00000800h] [IMAGE_SCN_LNK_REMOVE              // Section contents will not become part of image.]

[值:00001000h] [IMAGE_SCN_LNK_COMDAT              // Section contents comdat.]

[值:00004000h] [IMAGE_SCN_NO_DEFER_SPEC_EXC       // Reset speculative exceptions handling bits in the TLB entries for this section.]

[值:00008000h] [IMAGE_SCN_GPREL                   // Section content can be accessed relative to GP.]

[值:00500000h] [IMAGE_SCN_ALIGN_16BYTES           // Default alignment if no others are specified.]

[值:01000000h] [IMAGE_SCN_LNK_NRELOC_OVFL         // Section contains extended relocations.]

[值:02000000h] [IMAGE_SCN_MEM_DISCARDABLE         // Section can be discarded.]

[值:04000000h] [IMAGE_SCN_MEM_NOT_CACHED          // Section is not cachable.]

[值:08000000h] [IMAGE_SCN_MEM_NOT_PAGED           // Section is not pageable.]

[值:10000000h] [IMAGE_SCN_MEM_SHARED              // Section is shareable(该块为共享块).]

[值:20000000h] [IMAGE_SCN_MEM_EXECUTE             // Section is executable.(该块可执行)]

[值:40000000h] [IMAGE_SCN_MEM_READ                // Section is readable.(该块可读)]

[值:80000000h] [IMAGE_SCN_MEM_WRITE               // Section is writeable.(该块可写)]

可选PE头下面就是节表,所以我们可以用dos头+lfanew+NT头的宽度来定位,注意可选pe头宽度不确定,所以只能一步一步偏移过来,下面代码我会讲。



这个文件一共有6张表,而且在标准pe头里已经记录了


 

PE加载过程

当你打开一个exe时,操作系统首先会读取PE的数据,然后再把节给加载到内存里,

但是加载的时候有可能会拉升节,因为内存对齐是0x1000也就是一个页。但是老的编译器生成的PE文件的文件对齐是0x200,所以这种文件会被拉升。

PE加载的过程:                                                                    

1、根据SizeOfImage的大小,开辟一块缓冲区(ImageBuffer).                                                                 

2、根据SizeOfHeader的大小,将头信息从FileBuffer拷贝到ImageBuffer                                

3、根据节表中的信息循环讲FileBuffer中的节拷贝到ImageBuffer中.                                                                  

                                                                                    

代码练习

练习1 打印节表


void print_section(char* ppe)

{

         int arr_sch[10] = { 8,4,4,4,4,4,4,2,2,4 };

char* sch = (char*)((int)ppe + (*(int*)((int)ppe + 60))/*dos+*/ + 24);/*pe头*/

                                                                                                                                                                  //printf("%x..\n", *(short*)sch);

sch += *(short*)((int)ppe + (*(int*)((int)ppe + 60))/*dos+*/ + 20);

//printf("%x...", *(short*)((int)ppe + (*(int*)((int)ppe + 60))/*dos+*/ + 20));

//printf("%x..\n", *(short*)sch);

char str[9] = { 0 };

printf("**********section*************\n");

for (int i = 0; i < *(short*)((int)ppe + (*(int*)((int)ppe + 60))/*dos+*/ + 6/*节表个数*/); i++)

{

           for (int j = 0; j < 10; j++)//处理

           {

                    if (arr_sch[j] == 4)

                    {

                             printf("%X\n", *(int*)sch);

                             sch += 4;

                    }

                    else if (arr_sch[j] == 2)

                    {

                             printf("%X\n", *(short*)sch);

                             sch += 2;

                    }

                    else if (arr_sch[j] == 8)

                    {

                             //sch += 8;

                             memset(str, 0, 9);

                             for (int k = 0; k < 8; k++)

                             {

                                       str[k] = *(sch++);

                             }

                             printf("%s \n", str);

                    }

           }

}

}




练习2文件流转映像


char* ftoi_32(char* fp)

{

    if (*(short*)fp != 0x5a4d)

    {

        cout << "错误 不是mz";

        return 0;

    }

    char* pfbuff = fp;

    char* buff = pfbuff;

    char* soi = (char*)((int)fp + (*(int*)((int)fp + 60))/*dos+*/ + 80);/*sizeofimage*/

                                                                        /*if (*(int*)(soi-24) == 0x1000)

                                                                        {

                                                                        return fp;

                                                                        }*/

    printf("%x..", *(unsigned int*)soi);

    char* imbuff = (char*)malloc(*(unsigned int*)soi);

    char* imagebuff = imbuff;

    memset(imagebuff, 0, *(unsigned int*)soi);

    printf("%x soh ", *((int*)(soi + 4)));

    //if (*((int*)(soi + 4))<= 0x1000)// 拷贝头+拉升

    //{

    int i = 0;

    while (i++ <= *(unsigned int*)(soi + 4))

    {

        *(char*)imagebuff++ = *(char*)pfbuff++;

    }

    int sct_sum = *(short*)((int)fp + (*(int*)((int)fp + 60))/*dos+*/ + 6);//numberofsection

    char* sord = (char*)((int)fp + (*(int*)((int)fp + 60))/*dos+*/ + 24);/*pe头*/

    sord += *(short*)((int)fp + (*(int*)((int)fp + 60))/*dos+*/ + 20);

    //pe头末尾+可选pe头的宽度=节表

    sord += 16;//sizeofrawdata

    imagebuff = (imbuff + *(int*)(sord - 4));

    pfbuff = (fp + *(int*)(sord + 4));

    printf("%x  ", *(int*)sord);

    printf("\n%x  ", *(int*)(sord - 4));

    for (int s = 0; s < sct_sum; s++)

    {

        //pfbuff = (fp + *(int*)(sord -4));

        printf("节大小%x  ", *(int*)sord);

        //cout << sct_sum << endl;

        for (int s1 = 0; s1 < *(int*)sord; s1++)

        {

            *(char*)imagebuff++ = *(char*)pfbuff++;

        }

        sord += 40;//下一个节表的sizeofrawdata

        imagebuff = imbuff + (*(int*)(sord - 4));

        pfbuff = (fp + *(int*)(sord + 4));

    }

    FILE* fp1 = NULL;

    fp1 = fopen("copyi3.exe", "wb");

    fwrite((char*)imbuff, 1, *(int*)(soi), fp1);

    //cout << u;

    fclose(fp1);

    fp = NULL;

    //free(imagebuff);

    //free(pfbuff);

    //  free(imbuff);

    //itof_32(imbuff);

    return imbuff;

}




练习3映像转文件流


char* itof_32(char* imbuff,char* name)//filebuffer to imagebuffer

{

if (*(short*)imbuff != 0x5a4d)

{

           cout << "错误 不是mz";

           return 0;

}

char* imgb = imbuff;

unsigned int fbuff_size = 0;

int sct_cnt = *(short*)((int)imbuff + (*(int*)((int)imbuff + 60))/*dos+*/ + 6/*节表个数*/);

char* sord = (char*)((int)imbuff + (*(int*)((int)imbuff + 60))/*dos+*/ + 24);/*pe头*/

sord += *(short*)((int)imbuff + (*(int*)((int)imbuff + 60))/*dos+*/ + 20);

//pe头末尾+可选pe头的宽度=节表

sord += 16;//sizeofrawdata

printf("    %x  ", *((int*)sord));

int si = 0;

while (si++ < sct_cnt)

{

           fbuff_size += (*(int*)sord);

           sord += 40;

}

fbuff_size += *(int*)((int)imbuff + (*(int*)((int)imbuff + 60))/*dos+*/ + 84);/*sizeofheaders*/

////**************************************缩短头

char* fbuff = (char*)malloc(flen);

memset(fbuff, 0, flen);

if (!fbuff)

{

           perror("The following error occurred");

           getchar();

           return 0;

}

char* buff = fbuff;

memset(buff, 0, flen);

char* soh = (char*)((int)imbuff + (*(int*)((int)imbuff + 60))/*dos+*/ + 84);/*sizeofheaders*/

                                                                                                                                                                                   //int fa = *(int*)(soh - 24);//FileAlignment;

                                                                                                                                                                                   //if (*(int*)soh < fa)// 拷贝头+缩短

                                                                                                                                                                                   //{

int i = 0;

while (i++ <= *(int*)(soh))

{

           *(char*)fbuff++ = *(char*)imbuff++;

}

//************************************缩短节

sord -= 40 * sct_cnt;//第一个节表的SizeOfRawData;

printf("    %x  ", *(int*)(sord - 4));

imbuff = (imgb + *(int*)(sord - 4));

fbuff = (buff + *(int*)(sord + 4));

int s = 0;

while (s++ < sct_cnt)//节缩短

{

//                 cout << sct_cnt << endl;

           int s1 = 0;

           while (s1++ < *(int*)sord)

           {

                    *(char*)fbuff++ = *(char*)imbuff++;

           }

           sord = (char*)(((int)sord) + 40);//下一个节表的sizeofrawdata

           fbuff = (buff + *(int*)(sord + 4));

           imbuff = imgb + *(int*)(sord - 4);

}

//file_ser(buff, fbuff_size);

FILE* fp1 = fopen(name, "wb");

fwrite((char*)buff, 1, flen, fp1);

fclose(fp1);

fp1 = NULL;

return buff;

}



0x3 代码节空白区添加代码

通常每个节都会遗留一些0,这和对齐有关系,比如说文件对齐是200h,存储的数据只有10h,那么这个节里还会有190h的空间给我们随便搞。如果想在别人程序里加一段自己的程序,就可以在代码节或其他节的空隙里添加硬编码,然后修改OEP让程序一开始先执行你的程序,然后再跳到原来的OEP上。


放代码前,先来了解2个硬编码,E8,E9。

E8对应的汇编语句就是call,E9就是jmp。

E8后面跟地址(4个字节)E9也是。不过跳转的地址不能写死,有一个公式就是:

真正要跳转的地址 = E8这条指令的下一行地址 + X

X = 真正要跳转的地址 -   E8这条指令的下一行地址

写代码的时候只要计算一下x,然后把x填到E8/E9后面就可以了。

代码练习

练习1 内存偏移转文件偏移


int rva_to_foa(char* i,int n)

{

         Int  rva = 0;

         Int  rva_offset = 0;

         rva_offset = n;

         int sct_cnt = *(short*)((int)i + (*(int*)((int)i + 60))/*dos+*/ + 6/*节表个数*/);

         char* sord = (char*)((int)i + (*(int*)((int)i + 60))/*dos+*/ + 24);/*pe头*/

         sord += *(short*)( (int)i + (*(short*)((int)i + 60))/*可选头大小*/ + 20);

         sord += 12;//VirtualAddress;

         sord += 40 * (sct_cnt - 1);//最后一个节表的virtusladdress

         int s = sct_cnt;

         while (s > 0)

         {

                   if (rva_offset >= *(int*)sord)

                   {

                            break;

                   }

                   sord -= 40;

                   s--;

         }

         if (s == 0)//偏移在头部

         {

                   //printf("foa%x\n", rva_offset);

                   return rva_offset;

         }

         rva_offset -= *(int*)(sord);//减fva+foa

         rva_offset += *(int*)(sord + 8);

         //printf("foa%x\n", rva_offset);

         return rva_offset;

}



练习2文件偏移转内存偏移


int foa_to_rva(char* i, int n)

{

         Int  rva = 0;

         Int  rva_offset = 0;

         rva_offset = n;

         int sct_cnt = *(short*)((int)i + (*(int*)((int)i + 60))/*dos+*/ + 6/*节表个数*/);

         char* sord = (char*)((int)i + (*(int*)((int)i + 60))/*dos+*/ + 24);/*pe头*/

         sord += *(short*)((int)i + (*(short*)((int)i + 60))/*可选头大小*/ + 20);

         sord += 20;//foa;

         sord += 40 * (sct_cnt - 1);//最后一个节表的virtusladdress

         int s = sct_cnt;

         while (s > 0)

         {

                   if (rva_offset >= *(int*)sord)

                   {

                            break;

                   }

                   sord -= 40;

                   s--;

         }

         if (s == 0)//偏移在头部

         {

                   //printf("foa%x\n", rva_offset);

                   return rva_offset;

         }

         rva_offset -= *(int*)(sord);//减foa+rva

         rva_offset += *(int*)(sord-8 );

         //printf("rva%x\n", rva_offset);

         return rva_offset;

}



 

练习3 在代码节空白区添加代码

//先调用文件打开函数-》文件buffer转映像buff-》添加代码函数(也就是这个)-》映像buff

//转文件buff函数存盘


char* inseart_code(char* imbuff)

{

         char* buff = imbuff;

         char* sod = (imbuff + (*(int*)(imbuff + 60) + 24));//pe头尾

         sod += *(short*)(imbuff + (*(int*)(imbuff + 60) + 20));

         while (strcmp(sod, ".text") != 0)

         {

                   sod += 40;

         }

         buff = (imbuff + (*(int*)(sod + 12))) + (*(int*)(sod + 8));//节的空白区

         char* oep = (imbuff + (*(int*)(imbuff + 60) + 40));

         //      oep += *(short*)(imbuff + (*(int*)(imbuff + 60) + 20));

         int roep = *(int*)oep;

         *(int*)oep = buff - imbuff;//代码入口

         char a[] = { 0x6A,0,0x6A,0,0x6A,0,0x6A,0,0xE8,0,0,0,0,0xE9,0,0,0,0 };

         int dest_addr = 0x75fc0047;//messageBox 的地址  这个地址会改变

         int x = dest_addr - (((int)(buff - imbuff) + 13) + 0x400000);

         int y = 0x400000 + roep - (((int)(buff - imbuff) + 18) + 0x400000);

         *(int*)(a + 9) = x;

         *(int*)(a + 14) = y;

         int s = 0;

         //75FC0026    8BEC            mov ebp, esp

         while (s <= (sizeof(a) / sizeof(a[0])))

         {

                   (*(char*)buff++) = a[s];

                   s++;

         }

         return imbuff;

}



0x4 新增节


这个比较简单,多余文字我不写了。直接上代码。。

代码练习

练习1 新增节


char* inseart_jb(char* imbuff,int size)

{

         char* buff = imbuff;

         char* sh = (char*)((imbuff + (*(int*)(imbuff + 60))) + 24)/*pe*/;

         int sh_cnt = *(short*)(sh - 18);//节表个数

         int old_size = *(int*)(sh + 56);

         *(int*)(sh + 56) += size;//sizeofimg扩大

         flen += size;

         unsigned int nl = *(int*)(sh + 56);

         (*(short*)(sh - 18))++;//节表数+1

         sh += *(short*)(sh - 4);//节表

         int s = 0;

         while (s++ < sh_cnt)

         {

                   sh += 40;

         }

         char code[] = {

                   0x2E, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x40, 0xE9, 0x01,

                   0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x10,

                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

                   0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0xf0

         };//节表

         strcpy(code, "tttt");

         unsigned int va = 0;

         int vs_rs = size;//尺寸

         if (*(int*)(sh - 32) >= *(int*)(sh - 24))

         {

                   va = (*(int*)(sh - 32)) + (*(int*)(sh - 28));

         }

         else

         {

                   va = (*(int*)(sh - 24)) + (*(int*)(sh - 28));

         }

         unsigned int ra = (*(int*)(sh - 20)) + (*(int*)(sh - 24));

         *(int*)(code + 8) = vs_rs;

         *(int*)(code + 12) = va;//p偏移

         *(int*)(code + 16) = vs_rs;

         *(int*)(code + 20) = ra;

         s = 0;

         while (s<40)

         {

                   *sh = code[s];

                   sh++;

                   s++;

         }

         //****************************新增节

         char* buff1 = (char*)realloc(imbuff,nl);

         memset((char*)(buff1 + old_size), 0, size);

          imbuff=buff1 ;

         return buff1;

}



0x5扩大最后节和合并节

由于有的时候节表剩余空间不够80个字节,所以就不能增加节(当然可以也可以把dos sub给覆盖掉)但可以用扩大最后节/合并节 

         扩大最后节:                                                       

         1、拉伸到内存                                                     

         2、分配一块新的空间:SizeOfImage + Ex                                                

         3、将最后一个节的SizeOfRawData和VirtualSize改成N                                               

            SizeOfRawData = VirtualSize = N                                                    

            N = (SizeOfRawData或者VirtualSize 内存对齐后的值) + Ex                                                       

         4、修改SizeOfImage大小                                                  

            SizeOfImage = SizeOfImage + Ex                

  

         合并节


(字有点丑。。。)  最后把节的属性改到最大就ok。

代码练习

练习1扩大最后节


char* expand_lastjb(char* imgbuff)

{

         char* si = (imgbuff + (*(unsigned int*)(imgbuff + 60)) + 80);

         (*(int*)si) += 0x1000;//扩大映像尺寸

         unsigned sl = (*(unsigned int*)si);

         char* buff = (char*)realloc(imgbuff,sl);

         if (buff==0)

         {

                   printf("内存分配失败--expand——lastjb");

                   getchar();

                   return 0;

         }

         memset(buff, 0, sl);

         imgbuff = buff;

         char* sh = (imgbuff + (*(unsigned int*)(imgbuff + 60)));//pe

         int sh_cnt = *(short*)(sh + 6);

         sh += ((*(short*)(sh + 20)) +24);//节表头

         int s = 0;

         while (s++ < (sh_cnt-1))

         {

                   sh += 40;

         }

         *(int*)(sh + 36) |= 0x60000020; //加上代码节的权限

         *(int*)(sh + 8) += 0x1000;

         *(int*)(sh + 16) += 0x1000;

         return imgbuff;

}



练习2合并节


char* merge_jb(char* imbuff)

{

         char* buff = imbuff;

         int all_jb_char = 0;//保存所有节表的属性;

         char* pe = (imbuff + (*(int*)(imbuff + 60)));//pe头

         char* sh = (pe + 24 + (*(short*)(pe + 20)) );//节表

         int code_size = 0;

         int s = 0;

         while (s <(*(short*)(pe+6)))  //得到节表的大小和权限

         {

                   if(s == (*(short*)(pe + 6))-1)

                   if (*(int*)(sh + 8 + 40 * s) >= *(int*)(sh + 16 + 40 * s))//virtualsize和sizeofrawdata做比较

                   {

                            code_size += *(int*)(sh + 8 + 40 * s) + *(int*)(sh + 12 + 40 * s) - (*(int*)(pe + 84));

                   }

                   else

                   {

                            code_size += *(int*)(sh + 16 + 40 * s)+ (*(int*)(sh + 12 + 40 * s) - (*(int*)(pe + 84)));

                   }

                   all_jb_char |= *(int*)(sh + 36 + 40 * s);

                   for (int i = 0; i < 40 && s!=0; i++)//除第一个节表外都置位0

                   {

                            *(sh+i+40*s) = 0;

                   }

                   s++;

         }

         *(int*)(sh + 8) = code_size;

         *(int*)(sh + 16) = code_size;

         *(int*)(sh + 36) = all_jb_char;

         *(short*)(pe + 6) = 1;//numberofsection置位1;

         return imbuff;

}



0x6 导出表

1、如何定位导出表:                                       

数据目录项的第一个结构,就是导出表.                                        

typedef struct _IMAGE_DATA_DIRECTORY {                                      

    DWORD   VirtualAddress;                                        

    DWORD   Size;                                          

} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;


                     


VirtualAddress  导出表的RVA                                          

Size 导出表大小                                               



字段说明

         


工作原理

1.按名称导出


2.按序号导出


代码练习

练习1 按序号导出函数地址


int GetFunctionAddrByOrdinals(char* fbuff, int ord)

{

         char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

         char* data_dir = pe + 120;//数据目录

         char* exportt = fbuff + rva_to_foa(fbuff, *(int*)data_dir);//导出表头

         if (*(int*)data_dir == 0)

         {

                   printf("此文件没有导出表");

                   getchar();

                   return 0;

         }

         int* aof = (int*)(fbuff + rva_to_foa(fbuff, *(int*)(exportt + 28)));//地址表头

         int nof = *(int*)(exportt + 20);// 所有导出函数的个数

         int* arr_fun = (int*)malloc(sizeof(int)*nof);

         int base = *(int*)(exportt + 16);

         int s = 0;

         while (s<nof)

         {

                   arr_fun[s] = *(int*)(aof + s);//函数表

                   //printf("rav:%x ", arr_fun[s]);

                   if (ord - base == s)

                   {

                            printf("rav:%x ", arr_fun[s]);

                            return arr_fun[s];

                   }

                   s++;

         }

         printf("无此函数");

         getchar();

         return 0;

}



练习2 按名字导出函数地址


int GetFunctionAddrByName(char* fbuff, char* name)//导出表:按名字导出+显示导出函数信息

{

         char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

         char* data_dir = pe + 120;//数据目录

         char* export1 = fbuff+ rva_to_foa(fbuff, *(int*)data_dir);//回来发现export是关键字 不能拖内存 所以又定义了一个

         char* export=export1;//导出表头  

         if (*(int*)data_dir == 0)

         {

                   printf("此文件没有导出表");

                   getchar();

                   return 0;

         }

         int NumberOfNames= *(int*)(export+24);

         int* aon = (int*)(fbuff + rva_to_foa(fbuff, *(int*)(export+32)));//名称地址表头

         //aon = (int*)(fbuff + rva_to_foa(fbuff, *(int*)(aon)));

         int* arr_name = (int*)malloc(sizeof(int)*NumberOfNames);

         int base = *(int*)(export+16);

         int flag = -1;//索引

         int s = 0;

         while (s<NumberOfNames)

         {

                   arr_name[s]=(int)(fbuff + rva_to_foa(fbuff, *(int*)(aon+s)));//函数名地址

                   //printf("%s\n", arr_name[s]);

                   if (strcmp((char*)arr_name[s],name) == 0)

                   {

                            flag = s;

                   }

                   s++;

         }

         if (flag == -1)//判断有没有这个函数

         {

                   printf("没有此函数");

                   getchar();

                   return 0;

         }

         short* aono = (short*)(fbuff + rva_to_foa(fbuff, *(int*)(export + 36)));//序号表

         short* arr_name_ord = (short*)malloc(sizeof(short)*NumberOfNames);

          s = 0;

         while (s<NumberOfNames)

         {

                   arr_name_ord[s] = *(short*)(aono+s)+base;//函数序号表

                   //printf("%d\n", arr_name_ord[s]);

                   s++;

         }

         int* aof = (int*)(fbuff + rva_to_foa(fbuff, *(int*)(export + 28)));//地址表头

         int nof = *(int*)(export + 20);// 所有导出函数的个数

         int* arr_fun= (int*)malloc(sizeof(int)*nof);

         s = 0;

         while (s<nof)

         {

                   arr_fun[s] = *(int*)(aof + s);//函数表

                   printf("rav:%x ", arr_fun[s]);

                   printf("%x ", arr_name_ord[s]);

                   printf("%s\n",arr_name[s]);

                   s++;

         }

         printf("%x", arr_fun[arr_name_ord[flag]-base]);

         return arr_fun[arr_name_ord[flag]];//返回地址

}



练习3 移动导出表到新增节

//此文件已经新增节处理过了。


char* move_export(char* fbuff)

{

    char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

    char* data_dir = pe + 120;//数据目录

    char* exportt = fbuff + rva_to_foa(fbuff, *(int*)data_dir);//导出表头

    if (*(int*)data_dir == 0)

    {

        printf("此文件没有导出表");

        getchar();

        return 0;

    }

    char* nexport=  fbuff + rva_to_foa(fbuff, getlastjb_rva_add(fbuff));//定位到最后一个节的开始地址

    char* nexporth = nexport;

    *(int*)data_dir = foa_to_rva(fbuff,nexport-fbuff);

    int s = 0;

    while (s<40)

    {

        *(char*)(nexport + s) = *(char*)(exportt + s);

        s++;

    }

    int nf = *(int*)(exportt + 20);//numberoffunction

    int nn = *(int*)(exportt + 24);//numberofnames

    char* name = fbuff + rva_to_foa(fbuff, *(int*)(exportt+12));//dll名字的地址

    char* paddr = fbuff + rva_to_foa(fbuff, *(int*)(exportt + 28));

    char* pnaddr = nexport + 40;

    s = 0;

    *(int*)(nexporth + 28) = foa_to_rva(fbuff,pnaddr-fbuff);//复原AddressOfFunctions;

    while (s<nf)//拷贝函数表

    {

        *(int*)(pnaddr)= *(int*)(paddr+4*s) ;

        /*

        pnaddr= (char*)((int*)pnaddr+1);

        paddr = (char*)((int*)paddr + 1);

        */   //这个表达式比较麻烦所以用下面的+4

        pnaddr += 4;      //函数地址!

        s++;

    }

    paddr = fbuff + rva_to_foa(fbuff, *(int*)(exportt + 36));

    s = 0;

    *(int*)(nexporth + 36) = foa_to_rva(fbuff, pnaddr - fbuff);// AddressOfNameOrdinals

    while (s<nn)//拷贝函数序号表

    {

        *(short*)(pnaddr) = *(short*)(paddr+2*s);

        pnaddr += 2;

        s++;

    }

    paddr = fbuff +rva_to_foa(fbuff, *(int*)(exportt + 32));

    s = 0;

    int strl = strlen(name);//两个地址转换偏移

    char* straddr =name;//存储字符串的地方;

    char* nstradd = pnaddr + 4 * nn; //地址表后

    *(int*)(nexporth + 32) = foa_to_rva(fbuff, pnaddr - fbuff);//AddressOfNames;

    while (s<nn+1)//拷贝函名称数表

    {

        if (s!=0)//s=0时复制dll的NAME

        {

        *(int*)(pnaddr) =(foa_to_rva(fbuff,nstradd-fbuff));

        *(int*)(nexporth + 12) = (int)foa_to_rva(fbuff,pnaddr-fbuff);//定位name

        pnaddr += 4;//表指针后移

        paddr += 4;

        }

        for (int i = 0; i < strl; i++)

        {

            *nstradd++= *straddr++;

        }

        *nstradd=0;// 少0

        nstradd++;

        strl = strlen(fbuff + rva_to_foa(fbuff, *(int*)paddr));

        straddr = fbuff + rva_to_foa(fbuff, *(int*)(paddr));

        s++;

    }

    return fbuff;

}



0x7重定位表

重定位就是你本来这个程序理论上要占据这个地址,但是由于某种原因,这个地址现在不能让你占用,你必须转移到别的地址,这就需要基址重定位。你可能会问,不是说过每个进程都有自己独立的虚拟地址空间吗?既然都是自己的,怎么会被占据呢?对于EXE应用程序来说,是这样的。但是动态链接库就不一样了,我们说过动态链接库都是寄居在别的应用程序的空间的,所以出现要载入的基地址被应用程序占据了或者被其它的DLL占据了,也是很正常的,这时它就不得不进行重定位了。

1.重定位表定位


2.重定位表解析


代码练习

练习1打印重定位表


void print_relocation(char* fbuff)

{

         char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

         char* data_dir = pe + 120;//数据目录

         if (*(int*)(data_dir+8*5) == 0)

         {

                   printf("文件没有重定位表");

                   getchar();

                   return;

         }

         char* relocation = fbuff + rva_to_foa(fbuff, *(int*)(data_dir + 8 * 5));//重定位表头

         char* flag = relocation;

         int s = 0;

         int s1 = 0;

         int rva = 0;//记录偏移

         int b = 0;

         printf("%x\n", 12 & 0x3);

         while (*(int*)flag != 0 && *(int*)(flag+4) != 0)

         {

                   rva = *(int*)flag;

                   printf("*************%x\n", rva);

                   flag += 8;//    DWORD   SizeOfBlock

                   s = 0;

                   s1 = (*(int*)(flag - 4)-8) / 2;

                   while (s++ < s1)//当前页有多少个地址

                   {

                            b = *(short*)flag;

                            //if (b & 0x3000 == 0x3000)

                            printf("%x\n",rva+(b & 0xfff));

                            flag += 2;

                   }

         }

}



练习2移动重定位表

char* move_relocation(char* fbuff,int offset)//移动重定位表到新增节 偏移可以为0 也可以修改重定位数据

{

    char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

    char* data_dir = pe + 120;//数据目录

    if (*(int*)(data_dir + 8 * 5) == 0)

    {

        printf("文件没有重定位表");

        getchar();

        return 0;

    }

    char* relocation = fbuff + rva_to_foa(fbuff, *(int*)(data_dir + 8 * 5));//重定位表头

    char* flag = relocation;

    int s = 0;

    int s1 = 0;

    int rva = 0;//记录偏移

    short b = 0;

    char*  nrelocation = fbuff + rva_to_foa(fbuff, (getlastjb_rva_add(fbuff)));//移动的目的地foa

    *(int*)(data_dir + 8 * 5) = foa_to_rva(fbuff, nrelocation - fbuff);//改变数据目录的偏移;

    while (*(int*)flag != 0 && *(int*)(flag + 4) != 0)

    {

        rva = *(int*)flag;

        *(int*)nrelocation = (*(int*)flag);

        nrelocation += 4;

        *(int*)nrelocation = *(int*)(flag+4);

        nrelocation += 4;

        //这里可以用别的库函数代替

        printf("*************%x\n", rva);

        flag += 8;//    DWORD   SizeOfBlock

        s = 0;

        s1 = (*(int*)(flag - 4) - 8) / 2;

        while (s++ < s1)//当前页有多少个地址

        {

            b = *(short*)flag;

            //if (b & 0x3000 == 0x3000)

            *(int*)(fbuff + rva_to_foa(fbuff,rva + (b & 0x0fff))) += offset;

        //  else

            *(short*)nrelocation = (*(short*)flag);

            //*(short*)nrelocation = (*(short*)flag);

            nrelocation += 2;

            printf("%x\n", rva + (b & 0xfff));

            flag += 2;

        }

    }

        s = 0;

        while (s++<2)//为了避免意外情况,后面补8个0 表示结束

        {

            *(int*)nrelocation=0;

            nrelocation += 4;

        }

    return fbuff;

}


0x8导入表

在编程中常常用到“导入函数”(Import functions),导入函数就是被程序调用但其执行代码又不在程序中的函数,这些函数的代码位于一个或者多个DLL中,在调用者程序中只保留一些函数信息,包括函数名及其驻留的DLL名等。

于磁盘上的PE 文件来说,它无法得知这些输入函数在内存中的地址,只有当PE 文件被装入内存后,Windows 加载器才将相关DLL 装入,并将调用输入函数的指令和函数实际所处的地址联系起来。这就是“动态链接”的概念。动态链接是通过PE 文件中定义的“导入表”来完成的,导入表中保存的正是函数名和其驻留的DLL 名等。

导入表结构:                                                                                            

typedef struct _IMAGE_IMPORT_DESCRIPTOR {                                                                                      

    union {                                                                                         

        DWORD   Characteristics;                                                                                                         DWORD   OriginalFirstThunk;   //RVA 指向IMAGE_THUNK_DATA结构数组               };                                                                                            

    DWORD   TimeDateStamp;         //时间戳                                     

    DWORD   ForwarderChain;                                                                                                       

    DWORD   Name;                                                 //RVA,指向dll名字,该名字已0结尾                                     

    DWORD   FirstThunk;             //RVA,指向IMAGE_THUNK_DATA结构数组                                    

} IMAGE_IMPORT_DESCRIPTOR;                                                                                       

typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;


                                                                         


OriginalFirstThunk字段就是指向INT表,FirstThunk字段指向IAT表。通常情况下程序加载前这个两个表的内容是一样的,如果TimeDateStamp;字段为-1的话,IAT表存的就是地址。这是绑定导入表的内容,本文不做阐述。

程序加载前和加载后IAT表的值可能不一样。在时间戳为-1、dll时间戳没有变化、dll没有发生重定位的情况下,IAT表的值都是函数的绝对地址。一般情况下程序加载前IAT表的值和INT表的值是一样的,程序加载后IAT表的内容变成了函数的地址,INT则不变。


                                                                                                                                             

    

     typedef struct _IMAGE_THUNK_DATA32 {                                          

             union {                                          

                 PBYTE  ForwarderString;                                            

                 PDWORD Function;                                     

                 DWORD Ordinal;                                          

                 PIMAGE_IMPORT_BY_NAME  AddressOfData;                                       

             } u1;                                     

         } IMAGE_THUNK_DATA32;                                          

         typedef IMAGE_THUNK_DATA32 * PIMAGE_THUNK_DATA32;


                                 


这个就是INT表的结构,当成一个4字节的容器就ok。。它通常指向留一个表,也就是函数名结构数组。


  也就是这个东西。。


typedef struct _IMAGE_IMPORT_BY_NAME {                                                                                                              

    WORD    Hint;                                                     //可能为空,编译器决定 如果不为空 是函数在导出表中的索引                                               

    BYTE    Name[1];                                               //函数名称,以0结尾                                               

} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;




代码练习    

练习1 输出导入表


void print_import(char* fbuff)

{

    char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

    char* data_dir = pe + 120;//数据目录

    if (*(int*)(data_dir + 8) == 0)

    {

        printf("文件没有导入表");

        getchar();

        return ;

    }

    char* importt = fbuff + rva_to_foa(fbuff, *(int*)(data_dir + 8));//导入表第一张表的表头

    char* pimportt = importt;

    char* poft=0;

    char* pft = 0;

    char* str=0;

//  int b = 0xffffffff >> 31;

    //printf("%d",b );

    while (*(int*)pimportt != 0 && *(int*)(pimportt + 16) != 0)

    {

        char* name =fbuff + rva_to_foa(fbuff, *(int*)(pimportt + 12));

        printf("*******************%s\n",name);

        poft = fbuff+rva_to_foa(fbuff,*(int*)(pimportt));//poft是  FirstThunk;  指向的地址;        

        pft = fbuff + rva_to_foa(fbuff, *(int*)(pimportt + 16));//pft是  OriginalFirstThunk指向的地址;        

        while (*(int*)(poft) != 0)

        {

            if (*(unsigned int*)(poft) >> 31 == 1)//算术右移和逻辑右移不一样

            {

                printf("int:%0x ", (*(int*)(poft) << 1) / 2);//位运算把第一位去掉 再/2 =取低31位

                poft += 4;

                if (*(int*)(pimportt + 4) == -1)//时间戳

                {

                    printf("iat: %x\n", *(int*)(pft));

                }

                else

                    printf("iat:%0x \n", (*(int*)(pft) << 1) / 2); //位运算把第一位去掉 再/2 =取低31位

                pft += 4;

                continue;

            }

            str = fbuff + 2 + rva_to_foa(fbuff, *(int*)(poft));

            printf("int:%s  ", str);

            poft += 4;

            if (*(int*)(pimportt + 4) == -1)//时间戳

            {

                printf("iat: %x\n", *(int*)(pft));

            }

            else

            {

                str = fbuff + 2 + rva_to_foa(fbuff, *(int*)(pft));

                printf("iat: %s\n", str);

            }

                pft += 4;

        }

        pimportt += 20;

    }

}



0x9 导入表注入

      导入表注入原理:                                                

     当Exe被加载时,系统会根据Exe导入表信息来加载需要用到的DLL,导入表注入的原理就是修改exe导入表,将自己的DLL添加到exe的导入表中,这样exe运行时可以将自己的DLL加载到exe的进程空间.                                                                          

                  


注意事项:移动导入表时,最好不要移动IAT表,因为它里面存的有可能是函数的绝对地址,移动的话可能会需要重定位,否则程序会崩溃。我当时移动导入表然后注入的时候,程序不能运行,找bug找了好久,最后打开od调试时发现IAT表出问题了,它载入内存时没有变成函数地址(有可能改一下时间戳就ok,但最后我放弃移动IAT表了。。。)


左图是我手动移动导入表后的IAT表,右图是用工具注入dll后的IAT表。


下面来说说我导入表注入的思路(因为我比较懒,所以直接选择把导入表移动到新增节里了。。。):

1. 找到原表,2.找到新增节的rva,3. 先把自己构造的导入表放进去,然后一边遍历原表一边复制(我把新增节分成4块,导入表块,INT表块,dll名称块,函数名结构数组块)IAT表不动。

效果:

原文件



注入后的文件



代码实现导入表注入


void inject_dll(char* fbuff, char* fun_name,char* dll_name)

{

         char* pe = (fbuff + (*(int*)(fbuff + 60)));//pe头

         char* data_dir = pe + 120;//数据目录

         if (*(int*)(data_dir + 8) == 0)

         {

                   printf("文件没有导入表");

                   getchar();

                  return;

         }

         char* importt = fbuff + rva_to_foa(fbuff, *(int*)(data_dir + 8));//导入表第一张表的表头

         char* pimportt = importt;

         char* poft = 0;

         char* pft = 0;

         char* str = 0;

         char* pdest = fbuff + rva_to_foa(fbuff, getlastjb_rva_add(fbuff));//新导出表的位置

         char* niat = pdest + 0x500;//新iat表位置

         char* nint = pdest + 0x800;//新int表位置

         char* ndllname = pdest + 0x1100;//新dll名

         char* nstr = pdest + 0x1800;//新dll名数组

         //构建导入表  注入的dll

         *(int*)pdest = foa_to_rva(fbuff,nint - fbuff);

         *(int*)(pdest + 4) = 0;

         *(int*)(pdest + 8) = 0;

         *(int*)(pdest + 12) = foa_to_rva(fbuff, ndllname - fbuff);

         *(int*)(pdest + 16) = foa_to_rva(fbuff, niat - fbuff);

         pdest += 20;

         strcpy(ndllname, dll_name);

         //*(short*)ndllname = 0;

         ndllname += strlen(dll_name)+1;

         *(int*)nint = foa_to_rva(fbuff,nstr-fbuff);

         *(int*)niat = *(int*)nint;

         *(int*)(nint+4) = 0;

         *(int*)(niat +4) = 0;

         nint += 8;

         niat += 8;

         *(short*)nstr = 0;//函数名结构数组

         nstr += 2;

         strcpy(nstr, fun_name);

         nstr += strlen(fun_name) + 1;

         while (*(int*)pimportt != 0 && *(int*)(pimportt + 16) != 0)

         {//iat表没有复制

                   char* name = fbuff + rva_to_foa(fbuff, *(int*)(pimportt + 12));

                   printf("*******************%s\n", name);

                   *(int*)pdest = 0;//foa_to_rva(fbuff, nina - fbuff);

                   *(int*)(pdest + 4) = -0;

                   *(int*)(pdest + 8) = 0;

                  *(int*)(pdest + 12) = foa_to_rva(fbuff, ndllname - fbuff);

                   *(int*)(pdest + 16) = *(int*)(pimportt + 16);//foa_to_rva(fbuff, nita - fbuff);

                   pdest += 20;

                   /*for (int i = 0; i < 20; i++)

                   {

                            *(pdest + i) = *(pimportt + i);

                   }*/

                   strcpy(ndllname,name);//拷贝dll名字

                   //*(short*)ndllname = 0;

                   ndllname += strlen(name) + 1;

                   poft = fbuff + rva_to_foa(fbuff, *(int*)(pimportt));//poft是 OriginalFirstThunk  指向的地址;        

                   pft = fbuff + rva_to_foa(fbuff, *(int*)(pimportt + 16));//pft是  FirstThunk指向的地址;        

                   while (*(int*)(poft) != 0)

                   {

                            /*if (*(unsigned int*)(poft) >> 31 == 1)//当ina里存的是序号 ,算术右移和逻辑右移不一样

                            {

                                     printf("int:%0x ", (*(int*)(poft) << 1) / 2);//位运算把第一位去掉 再/2 =取低31位

                                     *(int*)nina = 0;//*(int*)(poft);//复制ina

                                     if (*(int*)(pimportt + 4) == -1)//时间戳 当ita是函数地址

                                     {

                                               printf("iat: %x\n", *(int*)(pft));

                                               *(int*)nita = *(int*)(pft);//复制ina

                                     }

                                     else

                                     {

                                               printf("iat:%x \n", (*(int*)(pft) << 1) / 2);//位运算把第一位去掉 再/2 =取低31位

                                               *(int*)nita = *(int*)(pft);//复制ina

                                     }       

                                     nina += 4;

                                     nita += 4;

                                     pft += 4;

                                     poft += 4;

                                     continue;

                            }*/

                            str = fbuff + 2 + rva_to_foa(fbuff, *(int*)(poft));

                            printf("int:%s  ", str);

                            *(int*)niat = foa_to_rva(fbuff,nstr-fbuff);//复制ina 指向字符串

                            *(short*)nstr = *(short*)(str-2);//函数名结构数组

                            nstr += 2;

                            strcpy(nstr, str);

                            nstr += strlen(str) + 1;

                            //nina += 4;

                   /*     if (*(int*)(pimportt + 4) == -1)//时间戳 当ita是函数地址

                            {

                                     printf("iat: %x\n", *(int*)(pft));

                                     *(int*)nita = *(int*)(pft);//复制ina

                                     //nita += 4;

                            }

                            else

                            {

                                     str = fbuff + 2 + rva_to_foa(fbuff, *(int*)(pft));

                                     printf("iat: %s\n", str);

                                     *(int*)nita = *(int*)nina;//指向同一个地方

                                     //nita += 4;

                            }*/

                            //*(int*)nina = 0;

                            //nita += 4;

                            nint += 4;

                            poft += 4;

                            pft += 4;

                   }

                   for (int i = 0; i < 2; i++)//补0

                   {

                            *(int*)nint = 0;

                            nint += 4;

                            //*(int*)nitt = 0;

                            //nita += 4;

                   }

                   pimportt += 20;

         }

                   for (int i = 0; i < 4; i++)//补0

                   {

                            *(int*)pdest = 0;

                            pdest += 4;

                   }

         *(int*)(data_dir + 8) = getlastjb_rva_add(fbuff);//修改数据目录

}



Ok,我讲完了,完整代码我一会发到下面。我要去肝win32了,下次见,886+。






















哦哦,我这篇文章主要发的代码比较多,理论少了点。所以我放几个参考资源来了解、掌握PE。

书籍:《PE权威指南》

视频:https://ke.qq.com/course/179553?taid=1062952866332001&tuin=437f9e13

帖子:

1.   https://www.cnblogs.com/You0/p/4229529.html

2.       https://www.cnblogs.com/You0/p/4238829.html

3.       https://www.cnblogs.com/You0/p/4238954.html

4.       https://www.cnblogs.com/You0/p/4239024.html


最后于 2020-6-1 14:51 被AMask编辑 ,原因:
上传的附件:
最新回复 (35)
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-21 21:45
2
0
我去封装一下代码 一会发上来 ,这篇文章我晚上再优化下。有啥建议说一下,我改
感谢大家支持
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-21 21:49
3
0
代码有点多。。。晚上我再加注释
雪    币: 5
活跃值: 活跃值 (10)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
wx_无酒无茶 活跃值 2020-3-21 21:49
4
1
留名
雪    币: 1885
活跃值: 活跃值 (17)
能力值: (RANK:210 )
在线值:
发帖
回帖
粉丝
china 活跃值 5 2020-3-21 21:52
5
0
WORD版有的话,建议上传方便下载收藏,谢谢。
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-21 22:14
6
1
china WORD版有的话,建议上传方便下载收藏,谢谢。
有的,一会传过来
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-22 01:41
7
0
不好意思各位,我封装的时候发现部分函数有bug,正在找。。。。  不过这个帖子我一定会写好!
最后于 2020-3-22 02:34 被AMask编辑 ,原因:
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-22 10:29
8
0
代码均为原创,所以昨天封装时突然发现了bug。。。而且有的模块没有了????  我要重新修改、封装源码,然后上传我的源码,我再修改内容
最后于 2020-3-22 10:32 被AMask编辑 ,原因:
雪    币: 265
活跃值: 活跃值 (19)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
niuzuoquan 活跃值 2020-3-22 18:34
9
1
mark
雪    币: 1004
活跃值: 活跃值 (10)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
gaveu屯烫烫 活跃值 2020-3-22 19:58
10
1
mark~
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-22 23:03
11
0
源码已上传
雪    币: 5636
活跃值: 活跃值 (22)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
Elice 活跃值 2020-3-23 01:46
12
1
mark一下
雪    币: 85
活跃值: 活跃值 (10)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
wodexinren 活跃值 2020-3-23 19:51
13
1
好久没来,论坛里这么详细的帖子越来越少了,支持一下
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-23 20:35
14
0
wodexinren 好久没来,论坛里这么详细的帖子越来越少了,支持一下
感谢支持
雪    币: 4719
活跃值: 活跃值 (924)
能力值: (RANK:40 )
在线值:
发帖
回帖
粉丝
Editor 活跃值 2020-3-24 10:56
15
1
感谢分享!
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-24 12:47
16
0
Editor 感谢分享!
雪    币: 2492
活跃值: 活跃值 (19)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
airbar 活跃值 2020-3-24 14:27
17
1
非常有营养的帖子
雪    币: 199
活跃值: 活跃值 (22)
能力值: ( LV2,RANK:50 )
在线值:
发帖
回帖
粉丝
Lthis 活跃值 1 2020-3-25 10:35
18
1
楼主这个帖子是滴水培训视频PE章节的笔记~~
很多截图是视频里边的,也推荐大家去看看~~
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-25 12:25
19
1
Lthis 楼主这个帖子是滴水培训视频PE章节的笔记~~ 很多截图是视频里边的,也推荐大家去看看~~
恩,我主要写的是如何用代码实现
最后于 2020-3-25 12:27 被AMask编辑 ,原因:
雪    币: 199
活跃值: 活跃值 (22)
能力值: ( LV2,RANK:50 )
在线值:
发帖
回帖
粉丝
Lthis 活跃值 1 2020-3-25 14:45
20
0
AMask Lthis 楼主这个帖子是滴水培训视频PE章节的笔记~~ 很多截图是视频里边的,也推荐大家去看看~~ 恩,我主要写的是如何用代码实现
赞楼主的分享精神~~
雪    币: 62
活跃值: 活跃值 (20)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
crczh 活跃值 2020-3-26 10:15
21
0
mark!
雪    币: 257
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
Seduction-ch 活跃值 2020-3-26 10:55
22
1
感谢
雪    币: 4823
活跃值: 活跃值 (23)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
tomtory 活跃值 2020-3-26 11:29
23
1
感谢!!
雪    币: 5
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
小笑糊涂仙 活跃值 2020-3-26 14:17
24
1
非常感谢。。。。
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-3-26 15:42
25
0
感谢大家支持
雪    币: 725
活跃值: 活跃值 (23)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
dz默契 活跃值 2020-3-26 18:24
26
1
已经肝到挪动导出表和重定位表了,回头来参考下表哥的代码。找下思路
雪    币: 40
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
git_31645BaoTony 活跃值 2020-3-26 19:29
27
1
学习了,讲的很详细!
雪    币: 11
活跃值: 活跃值 (17)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
落叶的忧伤 活跃值 2020-3-27 13:21
28
1
学习了! 牛逼!
雪    币: 243
活跃值: 活跃值 (11)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
Besttwuya 活跃值 2020-3-29 16:50
29
1
讲的很详细,感谢分享!
雪    币: 166
活跃值: 活跃值 (30)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
cxbcxb 活跃值 2020-3-29 22:04
30
1
写的好详细,作者用心了
雪    币: 1482
活跃值: 活跃值 (36)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
Rookietp 活跃值 2020-4-10 17:33
31
1
啥都好,但是为啥代码都是 以+结构大小的方式去取值- -。
雪    币: 205
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
橄榄绿o 活跃值 2020-4-10 18:37
32
1
滴水原味,mark
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-4-10 18:42
33
0
Rookietp [em_78]啥都好,但是为啥代码都是 以+结构大小的方式去取值- -。
因为它本身结构就是那么大呀
雪    币: 1482
活跃值: 活跃值 (36)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
Rookietp 活跃值 2020-4-10 23:42
34
0
AMask 因为它本身结构就是那么大呀
用结构体去写可读性比较高呢~
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-4-10 23:53
35
0
Rookietp 用结构体去写可读性比较高呢~
好吧,其实我这样写可以顺便练练指针
雪    币: 168
活跃值: 活跃值 (21)
能力值: ( LV2,RANK:20 )
在线值:
发帖
回帖
粉丝
AMask 活跃值 2020-6-1 14:54
36
0
补一下打印资源表的代码,已上传文件
游客
登录 | 注册 方可回帖
返回