PE目录项之导出表（解析、移动）

最新推荐文章于 2024-07-15 21:01:41 发布
最新推荐文章于 2024-07-15 21:01:41 发布
阅读量1.5k 收藏 10
点赞数 4
分类专栏： PE文件结构 文章标签： c语言 exe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35289660/article/details/106932627
版权

PE目录项之导出表（解析、移动）

文章目录

0.说明

观看滴水逆向视频总结（部分截图来自于滴水课件）

编译器：vc++6.0

编写语言：c

欢迎大家留言交流或询问😃^ __ ^

有不懂的直接留言，我必回！😄🤣

1.简述导出表

导出表，顾名思义就是要导出的函数的表。为别人提供函数，供别人调用。就要根据这种表，将函数导出。

所以这张表，就是提供一个要导出的函数的清单，方便导出。

一般是dll为exe提供函数，dll有导出表，但是exe自身也可以为别人提供函数，也是通过导出表。

a.位置

目录项的第一个结构就是导出表

在这里插入图片描述

IMAGE_DIRECTORY_ENTRy_EXPORt意思
VirtualAddress这个表结构的RVA
Size这个表结构的大小

我们根据他给的VirtualAddress找到对应的表结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KZ1SV13t-1592919607115)(E:%5CTypora%5Cimage%5Cimage-20200622140942338.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L7DLcGhK-1592919607116)(E:\Typora\image\image-20200622173546610.png)]

b.导出表的结构

struct_IMAGE_EXPORT_DIRECTORY作用
Characteristics（未使用）
TimeDateStamp时间戳
MajorVersion（未使用）
MinorVersion（未使用）
Name指向该导出表文件名字符串
Base导出函数起始序号（基值）
NumberOfFuctions所有导出函数的个数
NumberOfNames以函数名字导出的函数个数
AddressOfFunctions所有导出函数的地址表的RVA
AddressOfNames导出函数名称表的RVA
AddressOfNameOrdinals导出函数序号表的RVA

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fg6u8dyv-1592919607119)(E:\Typora\image\image-20200622141132071.png)]

前面四个不用怎么管，后面红色的要全部记熟，结构中最后面的三个RVA分别指向三个表结构。根据箭头指向，表结构大概如图所示。

注意：AddressOfNameOrdinals指向的表结构，宽度为2个字节，也就是每个序号站2个字节。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kq2y4eoM-1592919607121)(E:\Typora\image\image-20200622144150278.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qqCcVJXN-1592919607122)(E:\Typora\image\image-20200622144239851.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mNSuPLl3-1592919607123)(E:\Typora\image\image-20200622144258392.png)]

c.导出表的工作方式

导出表的意义是为别人 提供一个要导出的函数的清单，方便别人调用。一般有两种方式。

① 根据函数名导出

  1. 一般用调用者提供一个函数名，根据这个函数名，

  2. 挨个遍历AddressOfName里面的RVA指向的字符串，去对比这个函数名

  3. 若相等，再根据这个RVA在AddressOfNames表中的排序序号，对照获得AddressOfNameOrdinals表中相同排序序号的值，

  4. 再根据这个值作为排序序号查找AddressOfFunctions表中相同排序序号的值， 这个值是RVA，指向这个函数的真正地址。

注意这里的排序序号都是从0开始的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ny3QY7QZ-1592919607124)(E:\Typora\image\image-20200622145330767.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3WjiY2la-1592919607125)(E:\Typora\image\image-20200622145425550.png)]

② 根据序号导出函数

  1. 调用者提供一个序号
  2. 用这个序号值减去base值得到一个新值
  3. 根据这个新值作为AddressOfFuctions表中的排序序号，直接查找函数RVA，即指向这个函数的真正地址。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NX4Bp9UC-1592919607126)(E:\Typora\image\image-20200622150338229.png)]

③ 总结

  1. 我们发现，虽然导出表最后有三张表，但是，如果按照序号导出函数的话，只需要一张表AddressOfFuctions，而另外两张表，我完全是为了方便通过函数名导出函数而建造的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wd3TnOqX-1592919607127)(E:\Typora\image\image-20200622150702059.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kzj1NheK-1592919607128)(E:\Typora\image\image-20200622150719742.png)]

2.解析导出表

a.注意要点

  1. 导出表的结构比较复杂，整个结构是牵连在一起的，要自己去画图或者自己去解析依次后才能有一个抽象到具体的认识。
  2. 导出表中涉及到的VirtualAddress全是RVA，在内存中寻址时，要注意先把RVA转换成FOA，在通过FOA这个偏移去寻址。所以自己编写一个独立的函数ConvertRvaToFoa将RVA转换为FOA。（具体见源代码中）
  3. 对指针的运用要求比较高
  4. 函数中会涉及到很多结构体的定义，均来自头文件windows.h。（准确的来说是winnt.h）。

b.源代码

编写语言：C

编译环境：VC++6.0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xYmMBr2H-1592919607129)(E:\Typora\image\image-20200622192154553.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LzdTDqWC-1592919607130)(E:\Typora\image\image-20200622194155681.png)]

#include<stdio.h>
#include<windows.h>

char FileName[200]={0};//用于存放我们要解析的程序的地址

//功能：将相应程序读取到内存
//参数：指向程序名字（地址）指针
//返回值：指向该程序被读取到内存的指针
LPVOID ReadPeFile( char FileName[]);

//功能：解析、打印导出表
//参数：指向该程序被读取到内存的指针
//返回值：无
void ReadPE( LPVOID pFileBuffer );

//功能：将RVA转化为FOA
//参数：参数1：要转换的RVA的值（size_t）；参数2：指向文件缓冲区的指针(LPVOID)
//返回值：成功则返回对应的FOA，失败则返回0（这个RVA是没有对应的FOA，为内存拉伸后系统填充的地址，或者RVA超出内存范围）。
size_t ConvertRvaToFoa( size_t RVA , LPVOID pFileBuffer );

int main()
{
	LPVOID pFileBuffer = NULL;

	printf("please input:    (for example: D:/user/Desktop/学习笔记/2020.6.22_PE目录项之导出表/myDll.dll  )\n");
	
	gets(FileName);
	
	pFileBuffer = ReadPeFile( FileName );

	if( pFileBuffer )
		ReadPE( pFileBuffer );
	
}

//功能：将相应程序读取到内存
//参数：指向程序名字（地址）指针
//返回值：指向该程序被读取到内存的指针
LPVOID ReadPeFile( char FileName[] )
{
	LPVOID pFileBuffer = NULL;
	FILE* pFile = NULL;
	DWORD FileSize = 0;

	pFile = fopen( FileName , "rb");
	if(!pFile)
	{
		printf("open file failure!\n");
		return NULL;
	}

	fseek(pFile , 0 , SEEK_END);
	FileSize = ftell(pFile);
	fseek(pFile , 0 , SEEK_SET);
	
	pFileBuffer = calloc(1 , FileSize);
	if(!pFileBuffer)
	{
		printf("Failure to allocate memory space!\n");
		fclose(pFile);
		return NULL;
	}

	fread(pFileBuffer , FileSize , 1 ,pFile);

	fclose(pFile);

	return pFileBuffer ;
}


//功能：解析、打印导出表
//参数：指向该程序被读取到内存的指针
//返回值：无
void ReadPE( LPVOID pFileBuffer )
{
	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;
	
	PIMAGE_DATA_DIRECTORY pDataDirectory = NULL;//定义目录项导出表结构的指针
	PIMAGE_EXPORT_DIRECTORY pExportDirectory = NULL;//定义指向真正导出表的指针

	size_t i;
	PDWORD pAddressOfFunctions;//指向函数地址表
	PWORD pAddressOfNameOrdinals;//指向函数序号表
	PDWORD pAddressOfNames;//指向函数名字表

	pDosHeader = (PIMAGE_DOS_HEADER )pFileBuffer ; 
	pNtHeader = (PIMAGE_NT_HEADERS32 )( (DWORD)pFileBuffer + pDosHeader->e_lfanew );
	pFileHeader = (PIMAGE_FILE_HEADER )( (DWORD)pNtHeader + 4 );
	pOptionHeader = (PIMAGE_OPTIONAL_HEADER )( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER );
	
	pDataDirectory = (PIMAGE_DATA_DIRECTORY)pOptionHeader->DataDirectory;//目录项结构


	//注意将RVA转换为FOA
	pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)( (DWORD)pDosHeader+ ConvertRvaToFoa(pDataDirectory->VirtualAddress, pFileBuffer ) );
	
	printf("\n");
	
	//解析导出表的结构
	printf("Name: %X\n",pExportDirectory->Name );
	printf("Base: %X\n",pExportDirectory->Base );
	printf("NumberOfFunctions: %X\n",pExportDirectory->NumberOfFunctions );
	printf("NumberOfNames : %x\n\n",pExportDirectory->NumberOfNames );
	
	//打印AddressOfFunctions这个表结构。
	printf("****** AddressOfFuctions ******\n");
	pAddressOfFunctions = (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfFunctions , pFileBuffer ) ) ;
	for(i=0 ; i < pExportDirectory->NumberOfFunctions ; i++ ,pAddressOfFunctions++ )
		printf("RVA_%d : %x\n",i, *pAddressOfFunctions );
	printf("*******************************\n\n");

	//打印AddressOfNameOrdinals这个表结构
	printf("****** AddressOfNameOrdinals ******\n");
	pAddressOfNameOrdinals = (PWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfNameOrdinals , pFileBuffer ) );
	for(i=0 ; i<pExportDirectory->NumberOfNames ; i++ ,pAddressOfNameOrdinals++ )
		printf("Ordinal_%d : %d\n",i, *pAddressOfNameOrdinals );
	printf("***********************************\n\n");
	
	//打印AddressOfNames这表结构
	printf("****** AddressOfNames ******\n");
	pAddressOfNames = (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfNames , pFileBuffer ) );
	for(i=0 ; i<pExportDirectory->NumberOfNames ; i++ ,pAddressOfNames++)
	{
	//	printf("Name_%d : ",i);
	//	printf("%x ",*pAddressOfNames);
		printf("Name_%d : %-10s ( RVA :%-8x)\n",i ,(PDWORD)( (DWORD)pDosHeader+ ConvertRvaToFoa(*pAddressOfNames ,pFileBuffer) ) , *pAddressOfNames );
	
	}
	printf("****************************\n\n");

	free( pFileBuffer );
}

//功能：将RVA转化为FOA
//参数：参数1：要转换的RVA的值（size_t）；参数2：指向文件缓冲区的指针(LPVOID)
//返回值：成功则返回对应的FOA，失败则返回0（这个RVA是没有对应的FOA，为内存拉伸后系统填充的地址，或者RVA超出内存范围）。
size_t ConvertRvaToFoa( size_t RVA , LPVOID pFileBuffer )
{
	int i ;//用于遍历节表
//	size_t FOA = 0;

	//定义表头指针
	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;
	PIMAGE_SECTION_HEADER pSectionHeader = NULL;	

	//给表头赋初值
	pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
	pNtHeader = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader+4 );
	pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);	
	//第一个节表头
	pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pOptionHeader + pFileHeader->SizeOfOptionalHeader);
	
	if(RVA < pSectionHeader->VirtualAddress)//判断RVA是否在PE头区
	{
		if(RVA < pSectionHeader->PointerToRawData)
			return RVA;//此时FOA == RVA
		else
			return 0;
	}

	for(i=0 ; i<pFileHeader->NumberOfSections ; i++)//循环遍历节表头
	{
		if( i )//遍历节表头，第一次不遍历，
			pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER );
		
		if(RVA >= pSectionHeader->VirtualAddress )//是否大于这个节表的RVA
		{
			if( RVA <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData )//判断是否在这个节区
				return ( RVA - pSectionHeader->VirtualAddress ) + pSectionHeader->PointerToRawData;//确定节区后，计算FOA
		}
		else//RVA不可能此时的pSectionHeader->VirtuallAddress小，除非是返回值为0的情况。
			return 0;		
	}
		
	return 0;
}

3.移动导出表所有结构到新建的节区

a.移动导出表的原因

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1OQrZh2k-1592919607131)(E:\Typora\image\image-20200622231321796.png)]

b.大概流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t42abtKI-1592919607132)(E:\Typora\image\image-20200622230947327.png)]

新增节的部分前面几章讲过，这里就就直接贴代码过来（稍稍修改）IncreaseSection。

c.注意事项

  1. 有很多个地方，寻址的时候要将RVA转换为FOA在转换为现在内存中的真实位置。
  2. 在修正RVA的时候，注意要将此时的FOA转为RVA
  3. 反正有就是FOA和RVA互转，很多。
  4. 表中的地址是个RVA，并且是DWORD类型的，所以要转为指针才能调用，也有很多地方要强转类型，特别繁琐。
  5. 特别注意：在复制字符串的时候，一定要在字符串的末尾加上一个0，代表字符串末尾。

可能刚开始有很多疑问，建议直接动手写。

d.源代码

如何其他数据都移动成功了，但是新的dll还是调用不了，那很有可能是新增节那一块出问题了！

#include<stdio.h>
#include<windows.h>
#include<string.h>

char FileName[200]={0};
DWORD FileSize = 0;
DWORD NewFileSize = 0;

//功能：将相应程序读取到内存
//参数：指向程序名字（地址）指针
//返回值：指向该程序被读取到内存的指针
LPVOID ReadPeFile( char FileName[]);

//功能：移动导出表中所有结构到新建的节区
//参数：指向该程序被读取到内存的指针
//返回值：返回一个新的pNewFileBuffer（重点：末尾节区已经复制的导出表的所有结构），失败则返回NULL。
LPVOID MoveExportDirectory( LPVOID pFileBuffer );

//功能：将RVA转化为FOA
//参数：参数1：要转换的RVA的值（DWORD）；参数2：指向文件缓冲区的指针(LPVOID)
//返回值：成功则返回对应的FOA，失败则返回0（这个RVA是没有对应的FOA，为内存拉伸后系统填充的地址，或者RVA超出内存范围）
DWORD ConvertRvaToFoa( size_t RVA , LPVOID pFileBuffer );

//功能：将FOA转换为RVA
//参数：参数1：要转换的FOA值（DWORD）；参数2：指向文件内存的指针（LPVOID）；
//返回值：成功则返回对应的RVA，失败返回0（此时为FOA越界）。
DWORD ConvertFoaToRva( size_t FOA , LPVOID pFileBuffer );

//功能：添加一个节表和节区
//参数：指向文件读取到内存的指针
//返回值：返回一个新的pNewFileBUffer（重点：末尾有个新增节且空白）,失败则返回NULL
LPVOID IncreaseSection( LPVOID pFileBuffer );

//功能：将内存中的数据写入文件
//参数：指向内存中数据的指针
//返回值：无
void WritePeFile(LPVOID pFileBuffer);


int main()
{
	LPVOID pFileBuffer = NULL;
	
	LPVOID pNewFileBuffer = NULL;

	printf("please input:    (for example: D:/user/Desktop/学习笔记/2020.6.22_PE目录项之导出表/myDll.dll  )\n");
	
	gets(FileName);
	
	pFileBuffer = ReadPeFile( FileName );

	if( pFileBuffer )
		pNewFileBuffer = MoveExportDirectory( pFileBuffer );

	if( pNewFileBuffer )
		WritePeFile( pNewFileBuffer );


}

//功能：将相应程序读取到内存
//参数：指向程序名字（地址）指针
//返回值：指向该程序被读取到内存的指针
LPVOID ReadPeFile( char FileName[] )
{
	LPVOID pFileBuffer = NULL;
	FILE* pFile = NULL;


	pFile = fopen( FileName , "rb");
	if(!pFile)
	{
		printf("open file failure!\n");
		return NULL;
	}

	fseek(pFile , 0 , SEEK_END);
	FileSize = ftell(pFile);
	fseek(pFile , 0 , SEEK_SET);
	
	pFileBuffer = calloc(1 , FileSize);
	if(!pFileBuffer)
	{
		printf("Failure to allocate memory space!\n");
		fclose(pFile);
		return NULL;
	}

	fread(pFileBuffer , FileSize , 1 ,pFile);

	fclose(pFile);

	return pFileBuffer ;
}


//功能：移动导出表中所有结构到新建的节区
//参数：指向该程序被读取到内存的指针
//返回值：返回一个新的pNewFileBuffer（重点：末尾节区已经复制的导出表的所有结构），失败则返回NULL。
LPVOID MoveExportDirectory( LPVOID pFileBuffer )
{
	LPVOID pNewFileBuffer ;

	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER  pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;

	PIMAGE_DATA_DIRECTORY pDataDirectory = NULL;
	PIMAGE_EXPORT_DIRECTORY pExportDirectory =NULL;

	DWORD i;
//	PDWORD pAddressOfFunctions = NULL;//函数地址表指针
//	PWORD pAddressOfNameOrdinals = NULL;//函数序号表指针
	PDWORD pAddressOfNames = NULL;//指向函数名字表指针

	DWORD Offset = 0;//复制导出表结构的位置至DosHeader的偏移，相当于FOA

	//第一步：在dll新增一个节区，并返回新增节区的FOA
	pNewFileBuffer = IncreaseSection( pFileBuffer );
	if(!pNewFileBuffer)
	{
		printf("sorry , increase section failure!\n");
		free( pFileBuffer );
		return NULL;
	}	
	Offset = FileSize ;//偏移至新建的节区。
	

	//读取这个PE结构
	pDosHeader = (PIMAGE_DOS_HEADER)pNewFileBuffer ;
	pNtHeader = (PIMAGE_NT_HEADERS32)( (DWORD)pDosHeader + pDosHeader->e_lfanew );
	pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader + 4);
	pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);

	pDataDirectory = (PIMAGE_DATA_DIRECTORY)pOptionHeader->DataDirectory ;
	pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)( (DWORD)pDosHeader +  ConvertRvaToFoa( pDataDirectory->VirtualAddress , pNewFileBuffer) );//RVA转FOA再转现在内存中的真实地址



	
	//第二步：将导出表那张大的数据表给复制到新增节区
	//同时修正对应目录项中的VirtualAddress
	memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , pExportDirectory , pDataDirectory->Size );
	pDataDirectory->VirtualAddress = ConvertFoaToRva( Offset , pNewFileBuffer );//注意FOA转为RVA


	//修正内存中导出表的位置
	pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)( (DWORD)pDosHeader + Offset) ;

	//修正偏移
	Offset += pDataDirectory->Size ;
	
//第三步：移动导出表所在的文件名到新到新节区
	//同时修正导出表中的Name
	memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->Name ,pNewFileBuffer) ) , strlen( (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->Name ,pNewFileBuffer) ) )  );//注意RVA转FOA再转现在内存中的真实地址
	pExportDirectory->Name = ConvertFoaToRva( Offset , pNewFileBuffer );
	
	//修正偏移
	Offset += strlen( (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->Name , pNewFileBuffer) )  ) + 1;

	//第四步：将函数地址表挨着给复制过去
	//同时修正导出表中的AddressOfFunctions
	memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfFunctions ,pNewFileBuffer) ) , 4 * pExportDirectory->NumberOfFunctions );//注意RVA转FOA再转现在内存中的真实地址
	pExportDirectory->AddressOfFunctions = ConvertFoaToRva( Offset , pNewFileBuffer );//注意FOA转为RVA

	//修正偏移
	Offset += 4 * pExportDirectory->NumberOfFunctions ;

	//第五步：将函数序号表挨着复制过去
	//同时修正导出表中的AddressOfNameOrdinals
	memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfNameOrdinals , pNewFileBuffer ) ) , 2 * pExportDirectory->NumberOfNames );//注意RVA转FOA再转现在内存中的真实地址
	pExportDirectory->AddressOfNameOrdinals = ConvertFoaToRva( Offset , pNewFileBuffer );//注意FOA转RVA

	//修正偏移
	Offset += 2 * pExportDirectory->NumberOfNames ;

	//第六步：将函数名称表挨着复制过去
	//同时修正导出表中的AddressOfNames
	memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfNames ,pNewFileBuffer) ) , 4 * pExportDirectory->NumberOfNames  );//注意RVA转FOA再转现在内存中的真实地址
	pExportDirectory->AddressOfNames = ConvertFoaToRva( Offset , pNewFileBuffer ) ;//注意FOA转RVA

	//修正偏移
	Offset += 4 * pExportDirectory->NumberOfNames ;

	//第七步：将函数名称表中指向的名称也挨着复制过去
	//同时修正函数名称表
	pAddressOfNames = (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( pExportDirectory->AddressOfNames ,pNewFileBuffer) );//注意RVA转FOA再转现在内存中的真实地址
	for( i = pExportDirectory->NumberOfNames ; i>0 ; i--,pAddressOfNames++ )//遍历函数名字表，循环复制函数名过来
	{
		memcpy( (PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( *pAddressOfNames , pNewFileBuffer) ), strlen( (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( *pAddressOfNames ,pNewFileBuffer) ) )    );//注意RVA转FOA再转现在内存中的真实地址
		*pAddressOfNames = ConvertFoaToRva( Offset ,pNewFileBuffer );	//注意FOA转RVA
		//修正偏移
		Offset += strlen( (PDWORD)( (DWORD)pDosHeader + ConvertRvaToFoa( *pAddressOfNames ,pNewFileBuffer) ) ) +1;//偏移多加1，给名字留个末尾0
	}
	
	pDataDirectory->Size = 0x500 ;//NewFileSize - FileSize ;

	return pNewFileBuffer;
}

//功能：将RVA转化为FOA
//参数：参数1：要转换的RVA的值（DWORD）；参数2：指向文件缓冲区的指针(LPVOID)
//返回值：成功则返回对应的FOA，失败则返回0（这个RVA是没有对应的FOA，为内存拉伸后系统填充的地址，或者RVA超出内存范围）。
DWORD ConvertRvaToFoa( size_t RVA , LPVOID pFileBuffer )
{
	int i ;//用于遍历节表
//	size_t FOA = 0;

	//定义表头指针
	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;
	PIMAGE_SECTION_HEADER pSectionHeader = NULL;	

	//给表头赋初值
	pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
	pNtHeader = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);
	pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader+4 );
	pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);	
	//第一个节表头
	pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pOptionHeader + pFileHeader->SizeOfOptionalHeader);
	
	if(RVA < pSectionHeader->VirtualAddress)//判断RVA是否在PE头区
	{
		if(RVA < pSectionHeader->PointerToRawData)
			return RVA;//此时FOA == RVA
		else
			return 0;
	}

	for(i=0 ; i<pFileHeader->NumberOfSections ; i++)//循环遍历节表头
	{
		if( i )//遍历节表头，第一次不遍历，
			pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER );
		
		if(RVA >= pSectionHeader->VirtualAddress )//是否大于这个节表的RVA
		{
			if( RVA <= pSectionHeader->VirtualAddress + pSectionHeader->SizeOfRawData )//判断是否在这个节区
				return ( RVA - pSectionHeader->VirtualAddress ) + pSectionHeader->PointerToRawData;//确定节区后，计算FOA
		}
		else//RVA不可能此时的pSectionHeader->VirtuallAddress小，除非是返回值为0的情况。
			return 0;		
	}
		
	return 0;
}

//功能：将FOA转换为RVA
//参数：参数1：要转换的FOA值（DWORD）；参数2：指向文件内存的指针（LPVOID）；
//返回值：成功则返回对应的RVA，失败返回0（此时为FOA越界）。
DWORD ConvertFoaToRva( size_t FOA , LPVOID pFileBuffer )
{
	int i = 0;//用于遍历节表。
//	size_t RVA = 0;
	
	//定义表头指针
	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;
	PIMAGE_SECTION_HEADER pSectionHeader = NULL;

	//给表头赋初值
	pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
	pNtHeader = (PIMAGE_NT_HEADERS32)( (DWORD)pDosHeader + pDosHeader->e_lfanew  );
	pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader + 4 );
	pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);
	//第一个节表头
	pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pOptionHeader + pFileHeader->SizeOfOptionalHeader );

	if( FOA < pSectionHeader->PointerToRawData )//判断是否位于 头区
		return FOA ; //这是RVA == FOA ;
	
	for(i=0 ; i<pFileHeader->NumberOfSections ; i++)//循环遍历节表头
	{
		if( i )//遍历节表头，第一次不遍历，
			pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER);

		if( FOA >= pSectionHeader->PointerToRawData )//是否大于这个节表的FOA
		{
			if( FOA < pSectionHeader->PointerToRawData + pSectionHeader->SizeOfRawData )//判断是否在这个节表区域
				return (FOA - pSectionHeader->PointerToRawData ) + pSectionHeader->VirtualAddress ;//计算并返回RVA
		}			
	}

	return 0;
}



//功能：添加一个节表和节区
//参数：指向文件读取到内存的指针
//返回值：返回一个新的pNewFileBUffer（重点：末尾有个新增节且空白）,失败则返回NULL
LPVOID IncreaseSection( LPVOID pFileBuffer )
{
	LPVOID pNewFileBuffer = NULL;

	PIMAGE_DOS_HEADER pDosHeader = NULL;
	PIMAGE_NT_HEADERS32 pNtHeader = NULL;
	PIMAGE_FILE_HEADER pFileHeader = NULL;
	PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL; 
	PIMAGE_SECTION_HEADER pSectionHeader = NULL;

	PIMAGE_SECTION_HEADER pSectionHeader_First = NULL;//多增加一个节表指针指向第一个节表首地址，查看PointerToRawData。
	PIMAGE_SECTION_HEADER pSectionHeader_Last = NULL;//定义最后一个节表指针，方便获取VirtualAddress 和 SizeOfRawData

	int i = 0;//循环节

	pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
	
	pNtHeader = (PIMAGE_NT_HEADERS32)( (DWORD)pDosHeader + pDosHeader->e_lfanew );

	pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader + 4 );

	pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER );

	pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pOptionHeader + pFileHeader->SizeOfOptionalHeader );

	pSectionHeader_First = pSectionHeader ;

	//循环遍历，指向倒数第一个节表再往后移,指向我们将要添加节表 头 的位置 ,i>0。
	for(i=pFileHeader->NumberOfSections ; i>0 ; i-- )
		pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER );

	//先判断是否有节表的区域是否还有空间 用于添加节表。确保在SizeOfRawData范围内。
	//这里一般要空出两个节表位置，一个用于我们添加新节表，一个用于空的空间填充0（约定俗成）。
	if(  ((DWORD)pDosHeader + pSectionHeader_First->PointerToRawData) - (DWORD)pSectionHeader < 2*IMAGE_SIZEOF_SECTION_HEADER   )
	{	
		//如果没有足够空间，就考虑缩短 pDosHeader->e_lfanew，有没有足够空间，用于开辟新的空间。0x40为DOS头的大小
		if(  (pDosHeader->e_lfanew - 0x40) +  (  ((DWORD)pDosHeader + pSectionHeader_First->PointerToRawData) - (DWORD)pSectionHeader  ) > 2*IMAGE_SIZEOF_SECTION_HEADER  )
		{
			memcpy( (LPVOID)( (DWORD)pDosHeader+ 0x40) , pNtHeader , ( (DWORD)pSectionHeader- (DWORD)pFileHeader ) ); 
		
			//修改e_lfanew
			pDosHeader->e_lfanew = 0x40;

			//重新计算各头区的偏移
			pNtHeader = (PIMAGE_NT_HEADERS32)( (DWORD)pDosHeader + pDosHeader->e_lfanew );
			pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader + 4 );
			pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER );
			pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pOptionHeader + pFileHeader->SizeOfOptionalHeader );

			pSectionHeader_First = pSectionHeader ;

			//同样  //循环遍历，指向倒数第一个节表再往后移,指向我们将要添加节表的位置 ,i>0。
			for(i=pFileHeader->NumberOfSections ; i>0 ; i-- )
				pSectionHeader = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER );

			//此时已经符合条件，有足够空间用于新增节表头。
			//即退出if语句后。
		}
		else//没有足够空间则不能添加节，flag=0，失败
		{
			free(pFileBuffer);//释放空间
			printf("Sorry,There is not enough space of new section header!\n");
			return NULL; ; 
		}
	}

	//复制一个节表头过来。
	memcpy( pSectionHeader , pSectionHeader_First , IMAGE_SIZEOF_SECTION_HEADER );

	//更改节表名.NewSec
	strcpy( pSectionHeader->Name,".NewSec");

	//Misc.VirtualSize = 0，那下面构造内存3的文件状态时，就不会往节区填充垃圾数据
	pSectionHeader->Misc.VirtualSize = 0;

	//SizeOfRawData = FileAlignment
	pSectionHeader->SizeOfRawData = pOptionHeader->FileAlignment ;
	
	//RVA
	pSectionHeader_Last = (PIMAGE_SECTION_HEADER)( (DWORD)pSectionHeader - IMAGE_SIZEOF_SECTION_HEADER);
	pSectionHeader->VirtualAddress = pSectionHeader_Last->VirtualAddress + ( (pSectionHeader_Last->SizeOfRawData-1)  / pOptionHeader->SectionAlignment + 1 )*pOptionHeader->SectionAlignment ;

	//PointerToRawData
	pSectionHeader->PointerToRawData = pSectionHeader_Last->PointerToRawData + pSectionHeader_Last->SizeOfRawData;

	//Characteristics，权限，相 或 即可，我给他加上数据段的权限0x42000040
	pSectionHeader->Characteristics = 0x40000040;

	//SizeOfImage 
	pOptionHeader->SizeOfImage += ( (pSectionHeader->SizeOfRawData-1) / pOptionHeader->FileAlignment +1 ) * pOptionHeader->SectionAlignment ;

	//NumberOfSection
	pFileHeader->NumberOfSections += 1;


//*********************************************************
//注意：下面的代码是调整后，新加的，需要特别注意。

	//更改文件大小，方便开辟新的空间 和 存盘。
	NewFileSize = FileSize + pSectionHeader->SizeOfRawData ;

	pNewFileBuffer = calloc( 1 , NewFileSize );
	if(!pNewFileBuffer)
	{
		printf("Sorry , Allocte space failed!\n");
		return NULL;
	}
	
	memcpy( pNewFileBuffer , pFileBuffer , FileSize);
	
	//释放原来的文件缓冲区。
	free(pFileBuffer);

	return pNewFileBuffer;
}


//功能：将内存中的数据写入文件
//参数：指向内存中数据的指针
//返回值：无
void WritePeFile(LPVOID pNewFileBuffer)
{
	FILE* pNewFile = NULL;

	char NewFileName[10]="_New";
	int len = 0;//文件名长度

	//更改新的文件名
	len = strlen( FileName );
	strcat(NewFileName , FileName + len - 4 );//构造一个文件尾
	strcpy(FileName + len - 4 , NewFileName );

	pNewFile = fopen( FileName , "wb");
	if(!pNewFile)
	{
		printf("file creation failed!\n");
		return ;
	}

	fwrite(pNewFileBuffer , NewFileSize , 1 , pNewFile);
	
	fclose(pNewFile);

	free(pNewFileBuffer);

}

欢迎大家留言交流^ _ ^

C4cke
关注
专栏目录
移动导出表
weixin_43990313的博客
07-16 280
移动导出表： 思路： 添加节之后新建一个句柄用来重新安排结构情况，然后将的句柄的内容写入读入的数据流中。 前期知识： fopen()和 fclose() 两个函数都是文件操作函数，对数据流进行操作 fopen将文件读入一个文件流，文件流就是文件原本的形式。 fclose()将文件流关闭。 fwrite()：fwrite(NewBuffer,pOptionalHeader->SizeOfImage,1,fp); 可以直接将内存写入数据流中 RVA 和 FOA的转化： FOA->RVA：修改新的导出
PE文件结构-目录项结构
阿Q在行走
03-09 1000
目录项结构 数据目录项位于可选PE头的最后一部分，向前四个字节说明了数据目录项的数量，而每个数据目录项的结构一致，分别包含RVA地址和数据项的大小。 IMAGE_DATA_DIRECTORY STRUCT { DWORD VirtualAddress ;数据的起始RVA DWORD isize ;数据块的长度 } 数据目录项通常共有16项，它们的详细说明如下： 英文描述 中文描述 ...
PE文件（十一）移动导出表和重定位表
最新发布
2301_78838647的博客
07-15 869
默认情况下.DLL的ImageBase为0x10000000，所以如果一个程序要用的DLL没有合理的修改分配装载起始地址，就可能出现多个DLL的ImageBase都是同一个地址，造成装载冲突。如果只移动函数名称表的话，对剩下的数据加密后，当需要根据函数名去调用导出函数时，由于字符串被加密，只能根据函数名称表查到名称字符串所在地址，但是无法匹配字符串。6.修改导出表中的成员值，指向三个子表在新节中的位置，由于各个子表在导出表的地址数据是RVA，因此需要将FOA转成RVA。
PE之移动导出表
windows小菜鸡的博客
08-18 624
1、移动各种表的目的 （1）在程序启动时，系统会根据导入导出表等进行初始化工作。为了保护程序，一般会对exe程序的二进制进行加密等工作，但是一旦将这些表也进行了加密，那么系统在初始化的时候没办法找到这些表，也无法启动程序。 （2）在对程序加密之前，需要对一些关键的表进行移动后，再对原来的数据进行加密，这样才不能破坏原来的程序。 （3）学会移动各种表，是对程序加密/破解的基础。 2、如何移动导出表 上一篇文章，提到了如何对导出表进行解析，导出表的结构如图下。 导出表的位置是在可选PE头的第一项，如图，我们可
PE格式----目录----导出表
一个热爱逆向，喜爱学习、分享的猿。
05-03 505
PE 文件被执行时，Windows 加载器将文件装入内存并将导入表(Export Table) 登记的动态链接库(一般是DLL 格式)文件一并装入地址空间，再根据DLL 文件中的函数导出信息对被执行文件的IAT 进行修正。 数据目录表的第一个成员指向导出表，是一个IMAGE_EXPORT_DIRECTORY(以后简称IED)结构： IMAGE_EXPORT_DIRECTORY STRUCT【导出表，共40字节】 { +00 h DWORD Characteristics ; 未使用，总是定义为0
PE 之导入表解析和注入
windows小菜鸡的博客
08-19 660
1、导入表 导入表是在可选PE头得数据目录项得第二项 其结构如下 其中name是一个RVA，是DLL的名字 OriginalFirstThunk指向INT表，为 IMAGE_THUNK_DATA32的结构。这个结构的值中如果最高位为1 ，那么除去最高位的值函数的导出序号，否则为指向IMAGE_IMPORT_BY_NAME的RVA 其结构如下 其中Hint值无关紧要。 ** FirstThunk** 指向的是IAT表，其内容结构与OriginalFirstThunk指向的INT表一模一样 2、程序启动
快速查询PE文件知识点和PE文件解析
m0_58089591的博客
05-04 966
快速查询PE文件知识点和PE文件解析
【逆向】【PE入门】使用PEView分析PE文件
热门推荐
lanlanla的成长历程
01-08 1万+
目录 什么是PE？ 什么是PEView? 分析PE文件 什么是DOS头？ IMAGE_DOS_HEADER是干嘛的？ DOS块是干嘛的？ 什么是NT头？ Signatrue？ IMAGE_FILE_HEADER？ IMAGE_OPTIONAL_HEADER? section头？ 1.找到 NT 头的起始偏移地址、结束地址？ 什么是PE？ 参考博客：htt...
【逆向】PE结构分析和关于PE的一些问题及解决
lanlanla的成长历程
01-08 1339
目录 前言： 开始需要大概了解一些名词： 程序的装入（地址的变换） 分页机制： 大概带着这些知识后，再来看PE的结构： 一些结构的定义 关于地址计算的一些问题 经典例题： 例题分析 ☆如何在PE中查找并计算这些地址？ 计算：解决地址转换问题（使用PEView） ①计算每个节区在内存中的位置、大小： ②每个节区在文件中的偏移 ③每个节区在内存中的大小？每个节区在文件中的...
PE目录
qq_41232519的博客
10-20 288
文章目录 什么是可执行文件 PE文件的两种状态 DOS部分 PE头 RVA与FOA的转换 节表 代码空白区添加代码 新增节 导出表 导入表 重定位表 读写文件 PE头打印 读取->拉伸->还原 空白区域添加代码 添加节 扩大节 合并节 动态链接 打印导出表 移动导出表 打印重定位表 移动重定位表 打印导入表 导入表注入 ...
PE文件之移动导出表(自学笔记)
Sanshul的博客
12-22 326
PE文件之移动导出表(自学笔记)
移动导出表和重定位表
qq_41232519的博客
09-06 422
文章目录一、移动导出表二、移动重定位表 一、移动导出表 第一步：在DLL中新增一个节，并返回新增后的FOA 第二步：复制AddressOfFunctions 长度：4*NumberOfFunctions 第三步：复制AddressOfNameOrdinals 长度：NumberOfNames*2 第四步：复制AddressOfNames 长度：NumberOfNames*4 第五步：复制所有的函数名 长度不确定，复制时直接修复AddressOfNames
滴水逆向三期实践13：移动导出表
Rivival_S 的博客
10-28 1115
为什么要移动各种表？ 1、这些表是编译器生成的，里面存储了非常重要的信息。 2、在程序启动的时候，系统会根据这些表做初始化的工作： 比如，将用到的DLL中的函数地址存储到 IAT 表中（IAT表后面会讲） 3、为了保护程序，可以对.exe的二进制代码进行加密操作，但问题是： 我们知道数据目录的各种表是存在各个节里的，而exe的代码的信息也是在节里，表与客户字节的代码和数据都混在一起了，如果进行加密（加壳），那系统在初始化的时候会出问题！ 综上，学会移动各种表，是对程序加密/破解的基础。 移动导
pE文件操作--移动导出表
qq_31125257的博客
12-28 722
一、什么是导出表？ 先回顾一下导出表的结构：相对复杂的是AddressOfFunctions，AddressOfNames和AddressOfNameOrdinals这三个子表；其中地址表存储的是导出的函数地址，名称表存储的是以名字导出的函数的函数名的RVA，序号表存储的是以序号导出的函数的序号（序号+Base才是真正的序号值） 二、为什么要移动各种表？ 这些表是编译器生成的，里面存储了非常重要的信息； 在程序启动的时候，系统会根据这些表做初始化的工作，如将用到的DLL中的函数地址存储到IAT表； 为了
移动导出表到新增节
hambaga的博客
05-20 457
一、为什么要移动导出表 移动导出表是指将导出表以及其内部的三张子表移动到新增节，这个操作是软件加密的第一步。因为软件加密会把节进行加密，而数据目录是在节里的，加密后操作系统不认识了，因此我们要把数据目录里面的东西移动到一个新的节里。 二、怎么移动 上图是导出表的结构，移动导出表的步骤，我个人的做法分为以下几步： 计算新增节的大小，必须能放下导出表，3张子表，所有按名字导出的函数名； 新增一个节，并设置其属性为可读，含已初始化数据； 原封不动地拷贝3张子表到新增节； 遍历 AddressOfNames，计
滴水逆向——PE移动导出表
sunr.
04-13 910
1.为什么要移动各种表？ a.这些表是编译器生成的，里面存储了非常重要的信息。 b.在程序启动的时候，系统会根据这些表做初始化的工作： 比如，将用到的DLL中的函数地址存储到IAT表中. c.为了保护程序，可以对.exe的二进制代码进行加密操作，但问题是： 各种表的信息与客户字节的代码和数据都混在一起了，如果进行加密，那系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值