滴水三期：day30.1-FileBuffer-ImageBuffer

原创 已于 2023-04-22 03:30:08 修改 · 1.5k 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
逆向

当前文章被收录于：

逆向
69 篇文章 103 人学习

以初学者的视角跟着海东老师学习逆向，笔者是一个热爱逆向的大学生，希望志同道合的同学可以一起相互学习，笔记只是个人学习上的理解和总结，如果有错还望指出，共同进步

订阅专栏 查看详情
于 2022-05-02 13:49:32 首次发布
本文详细介绍了PE文件的结构，包括DOS头、PE头、可选头和节表等，并探讨了从FileBuffer到ImageBuffer再到NewBuffer的过程，以及内存偏移地址与文件偏移地址的转换。此外，提供了C语言实现的相关函数，用于模拟PE文件在内存中的转换和计算内存地址对应的文件偏移地址。

一、FileBuffer到ImageBuffer常见的误区

1.文件执行的总过程

  • 一个硬盘上的文件读入到虚拟内存中（FileBuffer），是原封不动的将硬盘上的文件数据复制一份放到虚拟内存中
  • 接着如果文件要运行，需要先将FileBuffer中的文件数据"拉伸"，重载到每一个可执行文件的4GB虚拟内存中！此时称文件印象或者内存印象，即ImageBuffer
  • 但是ImageBuffer就是文件运行时真正在内存中状态吗？或者说文件在ImageBuffer中就是表示文件被执行了吗？不！！！！！！
  • 在ImageBuffer中的文件数据由于按照一定的规则被"拉伸"，只是已经无线接近于可被windows执行的文件格式了！但是此时还不代表文件已经被执行了，因为此时文件也只是处在4GB的虚拟内存中，如果文件被执行操作系统还需要做一些事情，将文件真正的装入内存中，等待CPU的分配执行
  • 所以不要理解为ImageBuffer中的状态就是文件正在被执行，后面操作系统还要做很多事情才能让ImageBuffer中的文件真正执行起来的

2.SizeOfRawData一定大于Misc.VirtualSize？

  • SizeOfRawData表示此节在硬盘上经过文件对齐后的大小；Misc.VirtualSize表示此节在内存中没有对齐的大小。那么是不是说SizeOfRawData一定大于等于Misc.VirtualSize呢？不一定！！！！！！！

  • 我们写C语言的时候知道如果你定义一个数组已经初始化，比如int arr[1000] = {0};，此时编译成.exe文件存放在硬盘上时，这1000个int类型的0肯定会存放在某一个节中，并且分配1000个0的空间，这个空间大小是多少，最后重载到ImageBuffer时还是多少，即Misc.VirtualSize不管文件在硬盘上还是内存中的值都是一致的。所以，SizeOfRawData一般都是大于等于Misc.VirtualSize的

  • 但是如果我们定义成int arr[1000];，表示数据还未初始化，并且如果程序中没有使用过或初始化过这块内存空间，那么我们平时看汇编会发现其实编译器还没有做任何事情，这就只是告诉编译器需要预留出1000个int宽度大小的内存空间。所以如果某一个节中存在已经被定义过但还未初始化的数据，那么文件在硬盘上不会显式的留出空间，即SizeOfRawData中不会算上未初始化数据的空间；但是此节的Misc.VirtualSize为加载到内存中时节的未对齐的大小，那么这个值就需要算上给未初始化留出来空间后的整个节的大小，故在内存中的节本身的总大小可能会大于硬盘中的此节文件对齐后的大小。

二、手动模拟FileBuffer到ImageBuffer过程

  1. 先在硬盘上找一个可执行文件，将文件的数据复制到内存中，即FileBuffer中（前面的练习做过很多次了）

  2. 根据SizeOfImage的大小，再使用malloc开辟一块ImageBuffer，用0x00初始化ImageBuffer（SizeOfImage即为文件加载到4GB虚拟内存的大小）

  3. 因为所有头和节表经过文件对齐后的这段数据经过PE loader加载到ImageBuffer是不会变的，所以直接可以将所有头和节表经过文件对齐后的这块数据从FileBuffer中复制到ImageBuffer中

  4. 接着就是复制所有节的数据：需要使用循环，先复制第一个节的内容。通过第一个节对应节表中的PointerToRawData的值确定第一个节的起始地址；再通过SizeOfRawData的值得到从起始地址开始需要复制多少字节的数据到ImageBuffer中；再接着将这些数据复制到ImageBuffer中的哪个位置呢？就需要通过此节对应的节表中的VirtualAddress决定将数据从ImageBuffer中的哪个地址开始赋值，由于是相对地址，所以还需要知道ImageBase，但是！！我们是用C语言模拟PE的加载过程，此时ImageBuffer的首地址是由malloc申请的，不是真正的ImageBase！（只有当文件真正执行时，操作系统把文件拉伸装入虚拟内存时，才是ImageBase）所以malloc申请的首地址 + VirtualAddress就是最终将第一节数据复制到ImageBuffer中的起始地址。后面的节的数据以此类推从FileBuffer复制到ImageBuffer中

    为什么选择SizeOfRawData，不选择Misc.VirtualSize来确定需要复制的节的大小？因为上面说过，Misc.VirtualSize的值由于节中有未初始化的数据且未使用而计算出预留的空间装入内存后的总大小的值可能会很大，如果这个值大到已经包含了后面一个节的数据，那么按照这个值将FileBuffer中的数据复制到ImageBuffer中很可能会把下一个节的数据也复制过去，所以直接用SizeOfRawData就可以了。但是如果节中包含未初始化数据，这样做其实就不太准确了，但是可以大致模拟这个过程即可。（更好一点的做法是比较SizeOfRawData和VirtualSize，选择较小值）

    image-20211223163538138

三、内存偏移地址与文件偏移地址换算

  • 比如一个文件加载到4GB内存中的某一个数据地址为0x501234，那么怎么算出这个内存地址对应到文件在硬盘上时的地址是多少，即算出文件偏移地址？

    1. 先算出此内存地址相对于文件在内存中的起始地址的偏移量
    2. 接着通过这个偏移量循环和每一个节的VirtualAddress做比较，当此偏移量大于某一个节的VirtualAddress并且小于此VirtualAddress + Misc.VirtualSize，就说明这个内存地址就在这个节中
    3. 再用此偏移量 - 此节的VirtualAddress得到这个内存地址相对于所在节的偏移量
    4. 接着找内存地址所在节的PointerToRawData，通过PointerToRawData + 内存地址相对于所在节的偏移量来得到此内存地址在硬盘上时相对于文件的偏移量

  • 举例：现在我们要找0x501234对应的文件偏移是多少？

    • 0x501234 - 0x500000 = 0x1234
    • 因为0x1000 < 0x1234 < 0x1000 + Misc.VirtualSize，所以0x501234在可执行文件的第一个节中
    • 0x1234 - 0x1000 = 0x234
    • 由于第一个节的PointerToRawData为0x400，且假设FileBuffer的起始地址为0（相对的），则0x501234对应的文件偏移地址为0x400 + 0x234 = 0x634
    image-20211223170518081

四、作业

1.C语言实现如下功能

  • 如图：

    image-20211223170629821

  • 代码如下：

    #include "stdafx.h"
#include <stdlib.h>
#include <string.h>

typedef unsigned short WORD;
typedef unsigned int DWORD;
typedef unsigned char BYTE;

//宏定义MZ标记和PE标记，方便后面判断
#define MZ 0x5A4D
#define PE 0x4550
#define IMAGE_SIZEOF_SHORT_NAME 8

//DOS头
struct _IMAGE_DOS_HEADER {
	WORD e_magic;  //MZ标记
	WORD e_cblp;
	WORD e_cp;
	WORD e_crlc;
	WORD e_cparhdr;
	WORD e_minalloc;
	WORD e_maxalloc;
	WORD e_ss;
	WORD e_sp;
	WORD e_csum;
	WORD e_ip;
	WORD e_cs;
	WORD e_lfarlc;
	WORD e_ovno;
	WORD e_res[4];
	WORD e_oemid;
	WORD e_oeminfo;
	WORD e_res2[10];
	DWORD e_lfanew;  //PE文件真正开始的偏移地址
};

//标准PE头
struct _IMAGE_FILE_HEADER {
	WORD Machine;  //文件运行平台
	WORD NumberOfSections;  //节数量
	DWORD TimeDateStamp;  //时间戳
	DWORD PointerToSymbolTable;
	DWORD NumberOfSymbols;
	WORD SizeOfOptionalHeader;  //可选PE头大小
	WORD Characteristics;  //特征值
};

//可选PE头
struct _IMAGE_OPTIONAL_HEADER {
	WORD Magic;  //文件类型
	BYTE MajorLinkerVersion;
	BYTE MinorLinkerVersion;
	DWORD SizeOfCode;   //代码节文件对齐后的大小
	DWORD SizeOfInitializedData;  //初始化数据文件对齐后的大小
	DWORD SizeOfUninitializedData;  //未初始化数据文件对齐后大小
	DWORD AddressOfEntryPoint;  //程序入口点（偏移量）
	DWORD BaseOfCode;  //代码基址
	DWORD BaseOfData;  //数据基址
	DWORD ImageBase;   //内存镜像基址
	DWORD SectionAlignment;  //内存对齐粒度
	DWORD FileAlignment;  //文件对齐粒度
	WORD MajorOperatingSystemVersion;
	WORD MinorOperatingSystemVersion;
	WORD MajorImageVersion;
	WORD MinorImageVersion;
	WORD MajorSubsystemVersion;
	WORD MinorSubsystemVersion;
	DWORD Win32VersionValue;
	DWORD SizeOfImage;  //文件装入虚拟内存后大小
	DWORD SizeOfHeaders;  //DOS、NT头和节表大小
	DWORD CheckSum;  //校验和
	WORD Subsystem;
	WORD DllCharacteristics;
	DWORD SizeOfStackReserve;  //预留堆栈大小
	DWORD SizeOfStackCommit;  //实际分配堆栈大小
	DWORD SizeOfHeapReserve;  //预留堆大小
	DWORD SizeOfHeapCommit;  //实际分配堆大小
	DWORD LoaderFlags;
	DWORD NumberOfRvaAndSizes;  //目录项数目
	//_IMAGE_DATA_DIRECTORY DataDirectory[16];  //这个先不管
};

//NT头
struct _IMAGE_NT_HEADERS {
	DWORD Signature;  //PE签名
	_IMAGE_FILE_HEADER FileHeader;
	_IMAGE_OPTIONAL_HEADER OptionalHeader;
};

//节表
struct _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;  //该节特征属性
};

/*计算文件大小函数
参数：文件绝对路径
返回值：返回文件大小（单位字节）
*/
int compute_file_size(char* filePath){
	FILE* fp = fopen(filePath,"rb");
    if(!fp){
		printf("打开文件失败");
		exit(0);
	}
    fseek(fp,0,2);
	int size = ftell(fp);
	//fseek(fp,0,0); 单纯计算文件大小，就不需要还原指针了
	fclose(fp);
	return size;
}

/*将文件读入FileBuffer函数
参数：文件绝对路径
返回值：FileBuffer起始地址
*/
char* to_FileBuffer(char* filePath){
    FILE* fp = fopen(filePath,"rb");
    if(!fp){
		printf("打开文件失败");
		exit(0);
	}
    int size = compute_file_size(filePath);
    
	char* mp = (char*)malloc(sizeof(char) * size);  //分配内存空间
    if(!mp){
        printf("分配空间失败");
        fclose(fp);
        exit(0);
    }
    
    int isSucceed = fread(mp,size,1,fp);
    if(!isSucceed){
        printf("读取数据失败");
        free(mp);
        fclose(fp);
        exit(0);
    }
    
    fclose(fp);
    return mp;
}

/*FileBuffer到ImageBuffer函数
参数：FileBuffer起始地址
返回值：ImageBuffer起始地址
*/
char* fileBuffer_to_ImageBuffer(char* fileBufferp){

	_IMAGE_DOS_HEADER* _image_dos_header = NULL;
	_IMAGE_FILE_HEADER* _image_file_header = NULL;
	_IMAGE_OPTIONAL_HEADER* _image_optional_header = NULL;
	_IMAGE_SECTION_HEADER* _image_section_header = NULL;

	_image_dos_header = (_IMAGE_DOS_HEADER*)fileBufferp;
	_image_file_header = (_IMAGE_FILE_HEADER*)(fileBufferp + _image_dos_header->e_lfanew + 4);
	_image_optional_header = (_IMAGE_OPTIONAL_HEADER*)((char*)_image_file_header + 20);
	_image_section_header = (_IMAGE_SECTION_HEADER*)((char*)_image_optional_header + _image_file_header->SizeOfOptionalHeader);

	DWORD sizeofImage = _image_optional_header->SizeOfImage;
	char* imageBufferp = (char*)malloc(sizeofImage);
	if(NULL == imageBufferp){
        printf("动态申请ImageBuffer内存失败\n");
        exit(0);
    }
	for(DWORD i = 0;i < sizeofImage;i++){
		*(imageBufferp + i) = 0x00;
	}

	//strncpy(imageBufferp,fileBufferp,_image_optional_header->SizeOfHeaders); imageBufferp,fileBufferp值不会变
	for(i = 0;i < _image_optional_header->SizeOfHeaders;i++){
		*(imageBufferp + i) = *(fileBufferp + i);
	}
	

	for(i = 0;i < _image_file_header->NumberOfSections;i++){
		for(DWORD j = 0;j < _image_section_header->SizeOfRawData;j++){
			*(imageBufferp + _image_section_header->VirtualAddress + j) = *(fileBufferp + 
				_image_section_header->PointerToRawData + j);
		}
		_image_section_header++;
	}

	return imageBufferp;
}

/*计算NewBuffer大小函数
参数：NewBuffer起始地址
返回值：unsigned int类型（单位：字节）
*/
DWORD compute_NewBuffer_size(char* newBufferp){
	_IMAGE_DOS_HEADER* _image_dos_header = NULL;
	_IMAGE_FILE_HEADER* _image_file_header = NULL;
	_IMAGE_OPTIONAL_HEADER* _image_optional_header = NULL;
	_IMAGE_SECTION_HEADER* _image_section_header = NULL;

	_image_dos_header = (_IMAGE_DOS_HEADER*)newBufferp;
	_image_file_header = (_IMAGE_FILE_HEADER*)(newBufferp + _image_dos_header->e_lfanew + 4);
	_image_optional_header = (_IMAGE_OPTIONAL_HEADER*)((char*)_image_file_header + 20);
	_image_section_header = (_IMAGE_SECTION_HEADER*)((char*)_image_optional_header + _image_file_header->SizeOfOptionalHeader);
	
	_IMAGE_SECTION_HEADER* last_image_section_header = _image_section_header + _image_file_header->NumberOfSections - 1;
	DWORD sizeofNewBuffer = last_image_section_header->PointerToRawData + last_image_section_header->SizeOfRawData;
	return sizeofNewBuffer;
}

/*ImageBuffer到NewBuffer函数
参数：ImageBuffer起始地址
返回值：NewBuffer起始地址
*/
char* imageBuffer_to_NewBuffer(char* imageBufferp){
	
	_IMAGE_DOS_HEADER* _image_dos_header = NULL;
	_IMAGE_FILE_HEADER* _image_file_header = NULL;
	_IMAGE_OPTIONAL_HEADER* _image_optional_header = NULL;
	_IMAGE_SECTION_HEADER* _image_section_header = NULL;

	_image_dos_header = (_IMAGE_DOS_HEADER*)imageBufferp;
	_image_file_header = (_IMAGE_FILE_HEADER*)(imageBufferp + _image_dos_header->e_lfanew + 4);
	_image_optional_header = (_IMAGE_OPTIONAL_HEADER*)((char*)_image_file_header + 20);
	_image_section_header = (_IMAGE_SECTION_HEADER*)((char*)_image_optional_header + _image_file_header->SizeOfOptionalHeader);

	//重新计算newBuffer需要大小
	/*方法一:SizeOfHEADER + 所有节的SizeOfRawData之和
	int sizeofSections = 0;  
	_IMAGE_SECTION_HEADER* _image_section_header_temp = _image_section_header;
	for(DWORD i = 0;i < _image_file_header->NumberOfSections;i++){
		sizeofSections += _image_section_header_temp->SizeOfRawData;
		_image_section_header_temp++;
	}
	char* newBufferp = (char*)malloc(_image_optional_header->SizeOfHeaders + sizeofSections);
	*/
	
	//方法二:使用最后一个节的文件偏移地址 + 最后一个节对齐后的大小
	DWORD size = compute_NewBuffer_size(imageBufferp);
	char* newBufferp = (char*)malloc(size);
	if(NULL == newBufferp){
        printf("NewBuffer内存分配失败\n");
        exit(0);
    }
	for(DWORD i = 0;i < size;i++){
		*(newBufferp + i) = 0x00;
	}
	
	
	for(i = 0;i < _image_optional_header->SizeOfHeaders;i++){
		*(newBufferp + i) = *(imageBufferp + i);
	}
	
	for(i = 0;i < _image_file_header->NumberOfSections;i++){
		for(DWORD j = 0;j < _image_section_header->SizeOfRawData;j++){ //不用VirtualSize因为害怕会多复制覆盖下一个节
			*(newBufferp + _image_section_header->PointerToRawData + j) = *(imageBufferp + 
				_image_section_header->VirtualAddress + j);
		}
		_image_section_header++;
	}

	return newBufferp;
}	

/*NewBuffer存盘函数
参数：需要写出数据的内存首地址，保存绝对路径，写出的数据大小（单位：字节）
返回值：成功返回1，失败返回0
*/
int save_to_disk(char* newBufferp,char* storagePath,DWORD size){
	FILE* fp = fopen(storagePath,"wb");
	if(!fp){
		printf("打开文件失败");
		return 0;
	}
	int isSucceed = fwrite(newBufferp,size,1,fp);
	if(!isSucceed){
        free(newBufferp);
        fclose(fp);
        return 0;
    }
	fclose(fp);
	return 1;
}


int main(int argc,char* argv[]){
    char* filePath = "D:/C-language/file/notepad.exe";  //你要打开的PE文件绝对路径
    char* storagePath = "D:/C-language/file/notepad_copy.exe"; //保存路径

	char* fileBufferp = to_FileBuffer(filePath);
	char* imageBufferp = fileBuffer_to_ImageBuffer(fileBufferp);
	char* newBufferp = imageBuffer_to_NewBuffer(imageBufferp);
	int isSucceed = save_to_disk(newBufferp,storagePath,compute_NewBuffer_size(newBufferp)); 
	if(isSucceed){
		printf("存盘成功");
	}else{
		printf("存盘失败");
	}

	free(fileBufferp);
	free(imageBufferp);
	free(newBufferp);
	return 0;
}

2.编写一个函数，将RVA的值转换成FOA

就是将文件加载到内存时，已知一个数据在内存中的地址，将此地址转化成如果文件在硬盘上时的相对于文件起始地址的文件偏移地址。即将虚拟内存偏移地址转换成文件偏移地址。

说明：这里只考虑RVA在节中，不包含在节的空白区中！而且由于FileBuffer到ImageBuffer中，节中会有数据被初始化，这里目前来说无法解决，所以就假设节中没有未被初始化的数据，或者拉伸后未被初始化数据不影响地址转化

  • 代码如下：

    #include "stdafx.h"
#include <stdlib.h>
#include <string.h>

typedef unsigned short WORD;
typedef unsigned int DWORD;
typedef unsigned char BYTE;

//宏定义MZ标记和PE标记，方便后面判断
#define MZ 0x5A4D
#define PE 0x4550
#define IMAGE_SIZEOF_SHORT_NAME 8

//DOS头
struct _IMAGE_DOS_HEADER {
	WORD e_magic;  //MZ标记
	WORD e_cblp;
	WORD e_cp;
	WORD e_crlc;
	WORD e_cparhdr;
	WORD e_minalloc;
	WORD e_maxalloc;
	WORD e_ss;
	WORD e_sp;
	WORD e_csum;
	WORD e_ip;
	WORD e_cs;
	WORD e_lfarlc;
	WORD e_ovno;
	WORD e_res[4];
	WORD e_oemid;
	WORD e_oeminfo;
	WORD e_res2[10];
	DWORD e_lfanew;  //PE文件真正开始的偏移地址
};

//标准PE头
struct _IMAGE_FILE_HEADER {
	WORD Machine;  //文件运行平台
	WORD NumberOfSections;  //节数量
	DWORD TimeDateStamp;  //时间戳
	DWORD PointerToSymbolTable;
	DWORD NumberOfSymbols;
	WORD SizeOfOptionalHeader;  //可选PE头大小
	WORD Characteristics;  //特征值
};

//可选PE头
struct _IMAGE_OPTIONAL_HEADER {
	WORD Magic;  //文件类型
	BYTE MajorLinkerVersion;
	BYTE MinorLinkerVersion;
	DWORD SizeOfCode;   //代码节文件对齐后的大小
	DWORD SizeOfInitializedData;  //初始化数据文件对齐后的大小
	DWORD SizeOfUninitializedData;  //未初始化数据文件对齐后大小
	DWORD AddressOfEntryPoint;  //程序入口点（偏移量）
	DWORD BaseOfCode;  //代码基址
	DWORD BaseOfData;  //数据基址
	DWORD ImageBase;   //内存镜像基址
	DWORD SectionAlignment;  //内存对齐粒度
	DWORD FileAlignment;  //文件对齐粒度
	WORD MajorOperatingSystemVersion;
	WORD MinorOperatingSystemVersion;
	WORD MajorImageVersion;
	WORD MinorImageVersion;
	WORD MajorSubsystemVersion;
	WORD MinorSubsystemVersion;
	DWORD Win32VersionValue;
	DWORD SizeOfImage;  //文件装入虚拟内存后大小
	DWORD SizeOfHeaders;  //DOS、NT头和节表大小
	DWORD CheckSum;  //校验和
	WORD Subsystem;
	WORD DllCharacteristics;
	DWORD SizeOfStackReserve;  //预留堆栈大小
	DWORD SizeOfStackCommit;  //实际分配堆栈大小
	DWORD SizeOfHeapReserve;  //预留堆大小
	DWORD SizeOfHeapCommit;  //实际分配堆大小
	DWORD LoaderFlags;
	DWORD NumberOfRvaAndSizes;  //目录项数目
	//_IMAGE_DATA_DIRECTORY DataDirectory[16];  //这个先不管
};

//NT头
struct _IMAGE_NT_HEADERS {
	DWORD Signature;  //PE签名
	_IMAGE_FILE_HEADER FileHeader;
	_IMAGE_OPTIONAL_HEADER OptionalHeader;
};

//节表
struct _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;  //该节特征属性
};

/*计算文件大小函数
参数：文件绝对路径
返回值：返回文件大小（单位字节）
*/
int compute_file_size(char* filePath){
	FILE* fp = fopen(filePath,"rb");
    if(!fp){
		printf("打开文件失败");
		exit(0);
	}
    fseek(fp,0,2);
	int size = ftell(fp);
	//fseek(fp,0,0); 单纯计算文件大小，就不需要还原指针了
	fclose(fp);
	return size;
}

/*将文件读入FileBuffer函数
参数：文件绝对路径
返回值：FileBuffer起始地址
*/
char* to_FileBuffer(char* filePath){
    FILE* fp = fopen(filePath,"rb");
    if(!fp){
		printf("打开文件失败");
		exit(0);
	}
    int size = compute_file_size(filePath);
    
	char* mp = (char*)malloc(sizeof(char) * size);  //分配内存空间
    if(!mp){
        printf("分配空间失败");
        fclose(fp);
        exit(0);
    }
    
    int isSucceed = fread(mp,size,1,fp);
    if(!isSucceed){
        printf("读取数据失败");
        free(mp);
        fclose(fp);
        exit(0);
    }
    
    fclose(fp);
    return mp;
}
	
/*虚拟内存偏移地址->文件偏移地址函数
参数：FileBuffer起始地址,RVA地址值
返回值：RVA对应的FOA，返回0则表示非法RVA
*/
DWORD RVA_to_FOA(char* fileBufferp,DWORD RVA){
	_IMAGE_DOS_HEADER* _image_dos_header = NULL;
	_IMAGE_FILE_HEADER* _image_file_header = NULL;
	_IMAGE_OPTIONAL_HEADER* _image_optional_header = NULL;
	_IMAGE_SECTION_HEADER* _image_section_header = NULL;

	_image_dos_header = (_IMAGE_DOS_HEADER*)fileBufferp;
	_image_file_header = (_IMAGE_FILE_HEADER*)(fileBufferp + _image_dos_header->e_lfanew + 4);
	_image_optional_header = (_IMAGE_OPTIONAL_HEADER*)((char*)_image_file_header + 20);
	_image_section_header = (_IMAGE_SECTION_HEADER*)((char*)_image_optional_header + 
		_image_file_header->SizeOfOptionalHeader);

	bool flag = 0; //用来判断最终RVA值是否在节中的非空白区
	if(RVA < _image_section_header->VirtualAddress)
		return RVA;
	for(int i = 0;i < _image_file_header->NumberOfSections;i++){
		if(RVA >= _image_section_header->VirtualAddress 
			&& RVA < _image_section_header->VirtualAddress + _image_section_header->Misc.VirtualSize){
			flag = 1;
			break;
		}else{
			_image_section_header++;
		}
	}
	if(!flag)
		return 0;
	DWORD mem_offset_from_section = RVA - _image_section_header->VirtualAddress;
	return _image_section_header->PointerToRawData + mem_offset_from_section;	
}

int main(int argc,char* argv[]){
    char* filePath = "D:/C-language/file/notepad.exe";  //你要打开的PE文件绝对路径
	char* fileBufferp = to_FileBuffer(filePath);
	unsigned int FOA = RVA_to_FOA(fileBufferp,0x00008008);
	printf("0x%08X\n",FOA); //0x00007208
	return 0;
}

    • 注：这种方法可以应对绝大部分转换了，但是如果此时的内存偏移RVA所在的节含有未初始化数据，那么由于在虚拟内存拉伸后这部分数据进行初始化了，用RVA - 此节的起始地址，这个值会大于文件在硬盘上没有给未初始化数据分空间的大小，那么最后再用FileBuffer中此节的起始地址 + 此偏移，就会出现偏差。（目前还不知道怎么解决）

    • 简单验证一下：

      1

标签
#c++ #反汇编 #安全 #内存结构 #PE
滴水逆向第三期-fileBuffer_imageBuffer
tscg_的博客
03-20 725
本文详细介绍了一个PE文件从FileBuffer到ImageBuffer的具体过程
PE文件加载流程
dohxxx的博客
03-20 4730
PE加载器流程 1.将PE文件用ReadFile读取数据 char szFileName[] = "1.exe"; //打开文件,设置属性可读可写 HANDLE hFile = CreateFileA(szFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, ...
《Windows PE》2.2 加载PE文件一
最新发布
bcdaren的博客
08-26 1730
如图2-8所示：我们可以通过GDTR寄存器找到GDT全局段描述符表，在GDT全局段描述符表中保存LDT1、LDT2、LDT3三个局部段描述符表的段描述符，对应的局部段描述符表的段选择子分别为Selector1、Selector2、Selector3。G=0表示界限粒度为字节（实模式下内存地址空间以字节为单位，20位段界限域可访问的地址空间就是220个字节，1MB大小），G = 1表示界限粒度是4KB（保护模式下，内存地址空间以页为单位，20位段界限域可访问的地址空间就是220*212个字节，4GB大小）。
滴水逆向三期实践3：FileBuffer-ImageBuffer
Rivival_S 的博客
09-22 1929
书接上回 这张图上回已经有过了，这里加上更详细的说明 设该文件文件对齐FileAlignment为200，内存对齐SectionAlignment为1000，则有如下节： 节1：PointerToRawData 400 VirtualAddress 1000 节2：PointerToRawData 600 VirtualAddress 2000 节3：Poi...
6.PE文件之FileBuffer与ImageBuffer转换
kernelhack
10-27 4185
FileBuffer可以看作是文件在硬盘时的数据,WinHex等工具展示出来就是这种状态. ImageBuffer可以看作是文件按照PE格式拉伸到内存中的状态,可以称为进程,OD等工具查看的就是文件在内存中的数据(已经完成重定位,IAT等修复). FileBuffer <-> ImageBuffer 下述过程不进行重定位,IAT等修复,只是将数据按照PE格式进行拉伸. FileBuffer -> ImageBuffer 1.根据IMAGE_OPTIONAL_HEADER.
手动加载PE文件
gongxie0235的博客
05-13 1383
今天手撸一下加载PE文件，并执行加载的PE文件。看完这一节之后相信大家会对PE文件的结构和在内存中的加载顺序有一个比较深刻的理解。本文中可能对PE文件的基础知识介绍的不是很详细，建议大家先看看PE文件的基础结构，了解了这些基础知识后再看本文会简单许多。废话不多说，下边让我们进入正是环节吧~
PE执行流程
SXXYNHHXX的博客
09-01 883
PE介绍
PE加载过程
qq_58405021的博客
12-05 1637
PE加载过程
滴水逆向 FileBuffer---＞ImageBuffer
clayoa的博客
01-02 1007
上节课说到遍历节表，这节课让我们把FileBuffer-->ImageBuffer 海哥让我们用notepad.exe因为他的文件对齐和内存对齐是不一样的，如果一样的化，FileBuffer和ImageBuffer是一样的，为什么ImageBuffer还是不能执行呢？因为ImageBuffer的地址是我们malloc出来的，首地址不是ImageBase。 写代码之前我们需要掌握几个知识点 1.ImageBuffer的大小是多少？ 我们不能直接把FileBuffer复制过来，因为notepad.
PE文件（四）FileBuffer-ImageBuffer
2301_78838647的博客
05-07 1268
4.复制所有的节：通过第一个节对应节表中的PointerToRawData的值确定该节在FileBuffer的起始地址，然后通过SizeOfRawData的值确定该节在FileBuffer中需要复制的数据的大小，再通过VirtualAddress再加上ImageBase得到此节在ImageBuffer中的起始地址，最后将FileBuffer对应的数据在ImageBuffer中的起始地址位置开始复制，完成第一个节的复制。此时ImageBuffer中的文件的数据满足文件运行的条件，但文件仍然不能真正的运行。
FileBuffer-＞ImageBuffer-＞FileBuffer
qq_42363151的博客
08-28 363
PE
PE文件windows加载执行过程
weixin_41038905的博客
03-21 1495
Windows进程创建过程 第一阶段：打开目标映像文件，创建Section 由CreateProcess函数完成 字符串采用ASCII字符，则使用CreateProcessA函数 字符串采用Unicode字符，则使用CreateProcessW函数 由于windows内部都是Unicode字符，所以CreateProcessA函数只是将ASCII字符转换成Unicode字符后继续调用的CreateProcessW函数 CreateProcess函数步骤： 1.检查PE文件的有效性 2.为PE文件分配Sect
8.PE文件之新增节
kernelhack
10-28 4683
目录 新增节对PE文件中哪些值会有影响? 新增节步骤: 手动新增节 代码新增节 如果需要在PE文件中构建一端SHELLCODE(默认节区剩余空间不足情况下),可以通过新增节来解决此问题.通常大部分加壳软件都会新增节来移动或者备份各种目录项数据. 新增节对PE文件中哪些值会有影响? IMAGE_FILE_HEADER→NumberOfSections(当前PE文件节的数量,如果新增节需要修正此值). IMAGE_OPTIONAL_HEADER → SizeOfImage(新增节后在内存中的大小
【PE结构】PIMAGE_FILE_HEADER中TimeDateStamp的时间戳与标准时间转换
weixin_30666401的博客
02-22 963
计算PE文件创建时间，需要对时间进行转换，也就是将时间戳转换成特定的格式，或者特定的格式转换成时间戳。 pImageFileHeader->TimeDateStamp的值为1487665851 网上找了一下方法，可以用gmtime_s和strftime函数进行转化 gmtime_s函数 gmtime_s可以直接显示文件创建时间，但是年数需要加上1900，月数要加上1，小时要加上8 ...
3.PE文件之标准PE头(IMAGE_FILE_HEADER)
kernelhack
10-25 5560
标准PE头IMAGE_FILE_HEADER紧跟在PE标记后,即IMAGE_NT_HEADERS.Signature + 4的位置.由此位置开始的20个字节为数据结构标准PE头IMAGE_FILE_HEADER的内容. 该结构在微软的官方文档中被称为标准通用对象文件格式(Common Object File Format COFF)头.它记录了PE文件的全局属性,如该PE文件运行的平台、PE文件类型(EXE / DLL)、文件中存在的节的总数等. IMAGE_FILE_HEADER 结构及成员含义如下
程序时如何被链接和加载的？？？
H002399的专栏
06-08 819
运行 PE 可执行文件 启动一个 PE 可执行程序的过程是相对简单的。  读入文件的第一页，其中有 DOS 头部，PE 头部和区段头部等。  确定地址空间的目标区域是否有效，如果不可用则另分配一块区域。  根据各区段头部的信息，将文件中的所有区段映射到地址空间的适当位置上。  如果文件并没有被加载到它的目标地址中，则进行重定位。  遍历导入区段中的 DLL 列表，将任何未加载
病毒实验五
weixin_34417635的博客
03-07 220
title: viruslab5 date: 2016-01-13 15:47:40 categories: virus tags: virus --- PE文件注入 part1 要求:附带程序将一个完整的PE文件(hellow.exe)读到内存中 并将其分解为PE头、节表、以及各个节。 试编写void OutputPEInMem()函数，用其打印下列信息： PE头中的ImageBase...
PE文件结构及其加载机制
vbsourcecode的专栏
11-01 2151
PE文件结构及其加载机制（一） 一、PE文件结构 PE即Portable Executable，是win32环境自身所带的执行体文件格式，其部分特性继承自Unix的COFF（Common Object File Format）文件格式。PE表示该文件格式是跨win32平台的，即使Windows运行在非Intel的CPU上，任何Win32平台的PE装载器也能识别和使用该文
PE格式详细讲解【02】– IMAGE_FILE_HEADER 结构
u011513939的博客
06-20 2937
PE Header 是PE相关结构NT映像头（IMAGE_NT_HEADER）的简称，里边包含着许多PE装载器用到的重要字段。下边将为大家详细讲解哈~ 首先是IMAGE_NT_HEADERS 结构的定义：（啥？结构不会，先看看小甲鱼童鞋的《零基础入门学习C语言》关于结构方面的章节吧~） IMAGE_NT_HEADERS STRUCT { +0h DWORD Signature
滴水逆向三期实践4：节空白区
Rivival_S 的博客
09-22 1273
还记得节与节之间无论是文件中还是内存中都会存在一定的空白区（空隙）。那么可不可以往这里面注入代码呢？ 节表 VirtualSize（Misc）是指节的真实大小，暂且相信这个值的真实性。（后面有更可靠的方法） 那么如果注入代码（硬编码）长度 加上VirtualSize仍然没有超过（覆盖）下一个节在文件中的位置 ， 即 ( VirtualSize + 即注入代码长度 ) <SizeOfRawData 那么就可以往PE文件中注入代码了。在此之前，还需要知道一点其他的知识 为了效果显著...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值