滴水PE作业2

最新推荐文章于 2025-12-28 09:18:17 发布
原创 最新推荐文章于 2025-12-28 09:18:17 发布 · 147 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#学习

这段代码主要实现了对PE文件的解析，包括打开文件、读取内存、释放内存等操作。它详细处理了PE文件的DOS头、NT头、可选头、节表，以及重定位表、导出表和导入表的信息。通过对内存地址的转换，代码能够打印出各种表的详细内容，如节名、虚拟地址、文件偏移等，并能将导出表的内容写入新的文件。

 打印上图所示的导出表, 导入表, 重定位表以及所有的头部的信息

代码如下

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<Windows.h>
FILE* OpenFile(char path[]);
char* GetMemory(FILE* file_point);
void FreeMemory(FILE* file_point, char* memory_point[], int memory_size);
void conversion(PIMAGE_SECTION_HEADER section);
PIMAGE_DOS_HEADER dos_ptr(char* memory);
PIMAGE_NT_HEADERS nt_ptr(char* memory);
PIMAGE_FILE_HEADER file_ptr(char* memory);
PIMAGE_OPTIONAL_HEADER optional_ptr(char* memory);
PIMAGE_SECTION_HEADER section_ptr(char* memory);
PIMAGE_SECTION_HEADER last_section_ptr(char* memory);
void export_file(char* memory);
char* transform_to_file(char* memory, char* first);
char* transform_to_memory(char* memory, char* first);
DWORD get_largest_size(DWORD virtual_size, DWORD file_size);
DWORD* data_directory(char* memory);

void analysize(char path[]);
void print(char* memory);
void print_reloc(char* memory);
void print_export(char* memory);
void print_import(char* memory);
void conversion2(PIMAGE_SECTION_HEADER section);

FILE* OpenFile(char path[]) {
	//打开文件
	FILE* file_point;
	int return1 = fopen_s(&file_point, path, "rb");
	if (return1 != 0) {
		printf("获取文件指针错误\n");
	}
	return file_point;
}
char* GetMemory(FILE* file_point) {
	//开辟空间
	fseek(file_point, 0, SEEK_END);
	int file_size = ftell(file_point);
	fseek(file_point, 0, SEEK_SET);
	DWORD needed_size = sizeof(char) * file_size;
	char* enter_memory = (char*)malloc(needed_size);
	memset(enter_memory, 0, needed_size);
	fread(enter_memory, file_size, 1, file_point);
	return enter_memory;
}

void FreeMemory(FILE* file_point, char* memory_point[], int memory_size) {
	for (int i = 0; i < memory_size; i++) {
		free(memory_point[i]);
	}
	fclose(file_point);
}

void conversion(PIMAGE_SECTION_HEADER section) {
	char* point = (char*)section;
	printf("节表: ");
	for (int i = 0; i < 8; i++) {
		printf("%c", *point);
		point++;
	}
}

PIMAGE_DOS_HEADER dos_ptr(char* memory) {
	return (PIMAGE_DOS_HEADER)(memory);
}
PIMAGE_NT_HEADERS nt_ptr(char* memory) {
	return (PIMAGE_NT_HEADERS)((DWORD)dos_ptr(memory) + dos_ptr(memory)->e_lfanew);
}
PIMAGE_FILE_HEADER file_ptr(char* memory) {
	return (PIMAGE_FILE_HEADER)((DWORD)nt_ptr(memory) + 4);
}
PIMAGE_OPTIONAL_HEADER optional_ptr(char* memory) {
	return (PIMAGE_OPTIONAL_HEADER)((DWORD)file_ptr(memory) + 20);
}
PIMAGE_SECTION_HEADER section_ptr(char* memory) {
	return (PIMAGE_SECTION_HEADER)(optional_ptr(memory) + 1);
}
PIMAGE_SECTION_HEADER last_section_ptr(char* memory) {
	PIMAGE_SECTION_HEADER section = section_ptr(memory);
	PIMAGE_FILE_HEADER file = file_ptr(memory);
	int circle_num = file->NumberOfSections;
	for (int i = 0; i < circle_num - 1; i++) {
		section++;
	}
	return section;
}

void export_file(char* memory) {
	FILE* win_file = NULL;
	fopen_s(&win_file, "D:\\Ddisk\\last_memory.exe", "wb");
	fseek(win_file, 0, SEEK_SET);
	PIMAGE_OPTIONAL_HEADER optional = optional_ptr(memory);
	//先导出头部数据
	int sizeofHeaders = optional->SizeOfHeaders;
	int fileAlignment = optional->FileAlignment;
	if ((sizeofHeaders % fileAlignment) > 0) {
		DWORD header_data = fileAlignment * ((sizeofHeaders / fileAlignment) + 1);
		fwrite(memory, 1, header_data, win_file);
	}
	else if ((sizeofHeaders % fileAlignment) == 0) {
		DWORD header_data2 = fileAlignment * (sizeofHeaders / fileAlignment);
		fwrite(memory, 1, header_data2, win_file);
	}
	//导出各个
	int section_num = file_ptr(memory)->NumberOfSections;
	PIMAGE_SECTION_HEADER section = section_ptr(memory);
	for (int i = 0; i < section_num; i++) {
		fseek(win_file, section->PointerToRawData, SEEK_SET);
		fwrite((char*)(section->PointerToRawData + (DWORD)memory), 1, section->SizeOfRawData, win_file);
		section++;
	}
	fclose(win_file);
}
//转换rva到foa
//first代表文件开始地址, 根据开始地址找到内存基址和alignment, 节表个数
// if(memory-first>=内存基址){memory=memory-内存基址}
// if(memory<alignment){memory存在于header中, return memory}
// 定位到节表
//遍历节表信息, 依次比较if(VirtualAddress+VirtualSize>=memory>=VirtualAddress){
//	锁定节表序号, offset: memory-virtualAddress;
// 根据节表序号找到文件中的偏移, 文件偏移加offset为foa
char* transform_to_file(char* memory, char* first) {
	//定位file并获取节表数量
	PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)first;
	PIMAGE_FILE_HEADER file = (PIMAGE_FILE_HEADER)((DWORD)dos + dos->e_lfanew + 4);
	int table_num = file->NumberOfSections;
	//定位optional并获取内存基址与对齐
	PIMAGE_OPTIONAL_HEADER optional = (PIMAGE_OPTIONAL_HEADER)(DWORD(file) + 20);
	DWORD image_base = optional->ImageBase;
	DWORD align = optional->SectionAlignment;
	if ((int)(memory - first) >= (int)image_base) { memory = memory - image_base; }
	if ((int)memory < (int)align) { return memory; }
	PIMAGE_SECTION_HEADER section = NULL;
	section = (PIMAGE_SECTION_HEADER)(optional + 1);
	for (int i = 0; i < table_num; i++) {
		if ((section->VirtualAddress + get_largest_size(section->Misc.VirtualSize, section->SizeOfRawData)) >= (DWORD)memory && (DWORD)memory >= section->VirtualAddress) {
			return (char*)((DWORD)section->PointerToRawData + ((DWORD)memory - (DWORD)section->VirtualAddress));
			break;
		}
		section++;
	}
	return (char*)-1;
}
char* transform_to_memory(char* memory, char* first) {
	//定位file并获取节表数量
	PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)first;
	PIMAGE_FILE_HEADER file = (PIMAGE_FILE_HEADER)((DWORD)dos + dos->e_lfanew + 4);
	int table_num = file->NumberOfSections;
	//定位optional并获取内存基址与对齐
	PIMAGE_OPTIONAL_HEADER optional = (PIMAGE_OPTIONAL_HEADER)(DWORD(file) + 20);
	DWORD image_base = optional->ImageBase;
	DWORD align = optional->SectionAlignment;
	if ((int)(memory - first) >= (int)image_base) { memory = memory - image_base; }
	if ((int)memory < (int)align) { return memory; }
	PIMAGE_SECTION_HEADER section = NULL;
	section = (PIMAGE_SECTION_HEADER)(optional + 1);
	for (int i = 0; i < table_num; i++) {
		if (section->PointerToRawData + get_largest_size(section->Misc.VirtualSize, section->SizeOfRawData) >= (DWORD)memory && (DWORD)memory >= section->PointerToRawData) {
			return (char*)((DWORD)section->VirtualAddress + ((DWORD)memory - (DWORD)section->PointerToRawData));
			break;
		}
		section++;
	}
	return (char*)-1;
}
DWORD get_largest_size(DWORD virtual_size, DWORD file_size) {
	if (virtual_size > file_size) {
		return virtual_size;
	}
	else {
		return file_size;
	}
	return 0;
}
//得到数据目录表存储的各个表的数据
DWORD* data_directory(char* memory) {
	PIMAGE_OPTIONAL_HEADER optional = optional_ptr(memory);
	DWORD* data_directory = (DWORD*)&optional->DataDirectory;
	int directory_circle = optional->NumberOfRvaAndSizes;
	DWORD sum_arr[32] = { 0 };
	for (int i = 0; i < directory_circle; i++) {
		sum_arr[i + 16] = *data_directory;
		sum_arr[i] = (DWORD)(transform_to_file((char*)*data_directory, memory));
		data_directory = data_directory + 2;
	}
	return sum_arr;
}
//翻译字符串
void conversion2(PIMAGE_SECTION_HEADER section) {
	char* point = (char*)section;
	printf("===================开始查找节表");
	for (int i = 0; i < 8; i++) {
		printf("%c", *point);
		point++;
	}printf("中信息=========================\n");
}
//打印重定位表
void print_reloc(char* memory) {
	//打印重定位表
	// 1.根据table_address[5]的的地址找到重定位表
	DWORD* first_data = data_directory(memory);
	DWORD table_address[32] = { 0 };
	for (int i = 0; i < 32; i++) {
		table_address[i] = *first_data;
		first_data++;
	}
	printf("===================开始查找数据目录->重定位表中信息=========================\n");
	if (table_address[5] == 0) { printf("不存在重定位表\n"); }
	else {
		printf("%x\n", table_address[5]);
		printf("%x\n", memory);
		printf("%x\n", (DWORD)memory + table_address[5]);
		PIMAGE_BASE_RELOCATION reloc = (PIMAGE_BASE_RELOCATION)((DWORD)memory + table_address[5]);
		int sign = 1;
		WORD shift_pos = 0;
		WORD judge = 0;
		while (reloc->VirtualAddress != 0 && reloc->SizeOfBlock != 0) {
			printf("%-2d: VirtualAddress:%-8x", sign, reloc->VirtualAddress);
			printf("FOA:%-8x", ((DWORD)(reloc)-(DWORD)(memory)));
			printf("SizeOfBlock:%x\n", reloc->SizeOfBlock);
			printf("具体项数据为: \n");
			DWORD times = (reloc->SizeOfBlock - 8) / 2;
			short* position = (short*)((DWORD)reloc + 8);
			for (int i = 1; i <= times; i++) {
				shift_pos = *position;
				judge = shift_pos;
				shift_pos = shift_pos << 4;
				shift_pos = shift_pos >> 4;
				judge = judge >> 12;
				if (judge == 3) {
					printf("(%-3d)%-6x ", i, reloc->VirtualAddress + shift_pos);
				}
				position++;
			}
			printf("\n");
			printf("废弃项数据为: \n");
			short* position2 = (short*)((DWORD)reloc + 8);
			for (int i = 1; i <= times; i++) {
				shift_pos = *position2;
				judge = shift_pos;
				shift_pos = shift_pos << 4;
				shift_pos = shift_pos >> 4;
				judge = judge >> 12;
				if (judge != 3) {
					printf("(%-3d)%x ", i, reloc->VirtualAddress + shift_pos);
				}
				position2++;
			}
			printf("\n");
			reloc = (PIMAGE_BASE_RELOCATION)((DWORD)reloc + reloc->SizeOfBlock);
			sign++;
		}
	}
}
//打印导出表
void print_export(char* memory) {
	// 1.根据table_address中的地址找到导出表的地址
	// 2. 打印导出表的信息
	DWORD* first_data = data_directory(memory);
	DWORD table_address[32] = { 0 };
	for (int i = 0; i < 32; i++) {
		table_address[i] = *first_data;
		first_data++;
	}
	printf("===================开始查找数据目录->导出表中信息=========================\n");
	if (table_address[0] == 0) { printf("不存在导出表\n"); }
	else {
		PIMAGE_EXPORT_DIRECTORY export_table = (PIMAGE_EXPORT_DIRECTORY)((DWORD)table_address[0] + (DWORD)memory);
		printf("Name(存储导出表文件名字符串的地址): %x\n", (DWORD)transform_to_file((char*)(export_table->Name), memory));
		printf("Base(导出函数起始序号): %x\n", export_table->Base);
		printf("NumberOfFunction(所有导出函数个数): %x\n", export_table->NumberOfFunctions);
		printf("NumberOfNames(以函数名字导出的函数的个数): %x\n", export_table->NumberOfNames); printf("\n");
		//打印导出表->地址表
		printf("AddressOfFunction(导出函数地址表(FOA))地址: %x\n", (DWORD)transform_to_file((char*)(export_table->AddressOfFunctions), memory));
		printf("AddressOfFunction(导出函数地址表(FOA))数据\n");
		DWORD* export_address_data = (DWORD*)((DWORD)memory + (DWORD)transform_to_file((char*)export_table->AddressOfFunctions, memory));
		int num = export_table->NumberOfFunctions;
		for (int i = 0; i < num; i++) {
			printf("RVA: %-8x", *export_address_data);
			printf("FOA: %x\n", (DWORD)transform_to_file((char*)*export_address_data, memory));
			export_address_data++;
		}
		printf("\n");
		//打印导出表->名称表
		printf("AddressOfNames(导出函数名称表(FOA)): %x\n", (DWORD)transform_to_file((char*)(export_table->AddressOfNames), memory));
		printf("AddressOfFunction(导出函数名称表(FOA))数据\n");
		DWORD* export_name_data = (DWORD*)((DWORD)memory + (DWORD)transform_to_file((char*)export_table->AddressOfNames, memory));
		int num2 = export_table->NumberOfNames;
		for (int i = 0; i < num2; i++) {
			printf("RVA: %-8x", *export_name_data);
			DWORD name_foa = (DWORD)transform_to_file((char*)*export_name_data, memory);
			printf("FOA: %-8x", name_foa);
			printf("FOA对应函数名称:");
			char* new_name_foa = (memory + name_foa);
			while (*new_name_foa != 0) {
				printf("%c", *new_name_foa);
				new_name_foa++;
			}
			export_name_data++;
			printf("\n");
		}
		printf("\n");
		//打印导出表->序号表
		printf("AddressOfNameOrdinals(导出函数序号表RVA: %x, FOA: %x\n", export_table->AddressOfNameOrdinals, (DWORD)transform_to_file((char*)(export_table->AddressOfNameOrdinals), memory));
		printf("AddressOfFunction(导出函数序号数据\n");
		WORD* export_order_data = (WORD*)((DWORD)memory + (DWORD)transform_to_file((char*)export_table->AddressOfNameOrdinals, memory));
		int num3 = export_table->NumberOfNames;
		for (int i = 0; i < num3; i++) {
			printf("%d: ", i);
			printf("序号: %d ", *export_order_data);
			printf("导出序号=序号+Base=%d+%d=%d\n", *export_order_data, export_table->Base, *export_order_data + export_table->Base);
			printf("\n");
			export_order_data++;
		}
	}
}
void print_import(char* memory) {
	DWORD* first_data = data_directory(memory);
	DWORD table_address[32] = { 0 };
	for (int i = 0; i < 32; i++) {
		table_address[i] = *first_data;
		first_data++;
	}
	//打印导入表
	printf("===================开始查找数据目录->导入表中信息=========================\n");
	if (table_address[1] == 0) {
		printf("不存在导入表\n");
	}
	else {
		PIMAGE_IMPORT_DESCRIPTOR pimport = (PIMAGE_IMPORT_DESCRIPTOR)(table_address[1] + (DWORD)memory);
		int i = 1;
		while (pimport->Name != 0) {
			//打印dll名字
			printf("导入表%d所在FOA:%x\n", i, ((DWORD)pimport - (DWORD)memory));
			printf("%-2d:", i);
			char* name = (char*)(transform_to_file((char*)pimport->Name, memory) + (DWORD)memory);
			printf("----------------------");
			while (*name != 0) {
				printf("%c", *name);
				name++;
			}
			printf("---");
			printf("TimeDateStamp: %x ", pimport->TimeDateStamp);
			printf("----------------------");
			printf("\n");

			//打印OriginalFirstThunk
			DWORD* oring_thunk = (DWORD*)transform_to_file((char*)pimport->OriginalFirstThunk, memory);
			printf("OriginalFirstThunk所在: RVA:%-8xRVA->FOA:%-8x\n", pimport->OriginalFirstThunk, oring_thunk);
			int j = 1;
			printf("OrinGinalFirstThunk→ INT(导入名称表)\n");
			DWORD* file_oring_thunk = (DWORD*)((DWORD)oring_thunk + (DWORD)memory);
			while (*file_oring_thunk != 0) {
				if ((*file_oring_thunk & 0x80000000) == 0x80000000) {
					printf("(%-2d):%-4x\n", j, 0x7FFFFFFF & *file_oring_thunk);
				}
				else {
					char* real_file_oring_thunk = (char*)((DWORD)(transform_to_file((char*)*file_oring_thunk, memory) + (DWORD)memory));
					printf("(%-2d):RVA:%x, FOA:%x: ", j, *file_oring_thunk, transform_to_file((char*)*file_oring_thunk, memory));
					PIMAGE_IMPORT_BY_NAME import_byname = (PIMAGE_IMPORT_BY_NAME)(real_file_oring_thunk);
					printf("%x,%s\n", import_byname->Hint, import_byname->Name);
				}
				j++;
				file_oring_thunk++;
			}
			printf("\n");
			//打印FirstThunk
			DWORD* firstThunk = (DWORD*)transform_to_file((char*)pimport->FirstThunk, memory);
			printf("FirstThunk: RVA:%-8xRVA->FOA:%-8x\n", pimport->FirstThunk, firstThunk);
			DWORD* file_firstThunk = (DWORD*)((DWORD)firstThunk + (DWORD)memory);
			int k = 1;
			printf("FirstThunk→ IAT(导入地址表)\n");
			while (*file_firstThunk != 0) {
				if ((*file_firstThunk & 0x80000000) == 0x80000000) {
					printf("(%-2d):%-4x ", k, 0x7FFFFFFF & *file_firstThunk);
				}
				else {
					printf("(%-2d):%x: ", k, transform_to_file((char*)*file_firstThunk, memory));
					PIMAGE_IMPORT_BY_NAME import_byname = (PIMAGE_IMPORT_BY_NAME)(file_firstThunk);
					printf("%x,%s\n", import_byname->Hint, import_byname->Name);
				}
				k++;
				file_firstThunk++;
			}
			printf("\n");
			printf("\n");
			pimport++;
			i++;
		}
	}
}
void print(char* memory) {
	//打印dos头
	PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)memory;
	printf("===================开始查找DOS头中信息=========================\n");
	printf("Dos->e_magic: %x\n", dos->e_magic);
	printf("Dos->e_lfanew: %x\n", dos->e_lfanew);
	printf("\n");
	//打印NT->PE标记头
	PIMAGE_NT_HEADERS nt = (PIMAGE_NT_HEADERS)((DWORD)dos + dos->e_lfanew);
	printf("===================开始查找NT->PE标记头中信息=========================\n");
	printf("NT->PE标记: %x\n", *nt);
	//打印NT->标准PE头
	PIMAGE_FILE_HEADER file = (PIMAGE_FILE_HEADER)((DWORD)(nt)+4);
	printf("\n");
	printf("===================开始查找NT->标准PE头中信息=========================\n");
	printf("Machine: %x\n", file->Machine);
	printf("NumberOfSections(节表个数): %x\n", file->NumberOfSections);
	printf("SizeOfOptionalHeader(可选PE头大小): %x\n", file->SizeOfOptionalHeader);
	printf("\n");
	//打印NT->可选PE头
	PIMAGE_OPTIONAL_HEADER optional = (PIMAGE_OPTIONAL_HEADER)(DWORD(file) + 20);
	printf("===================开始查找NT->可选PE头中信息=========================\n");
	printf("PE->magic: %x\n", optional->Magic);
	printf("Address Of EntryPoint(程序入口地址偏移): %x\n", optional->AddressOfEntryPoint);
	printf("Image Base(内存基址): %x\n", optional->ImageBase);
	printf("Section Alighment(内存对齐): %x\n", optional->SectionAlignment);
	printf("File Alignment(文件对齐): %x\n", optional->FileAlignment);
	printf("Size Of Image(内存大小): %x\n", optional->SizeOfImage);
	printf("Size Of Headers(头文件大小): %x\n", optional->SizeOfHeaders);
	printf("Number Of Rva And Sizes: %x\n", optional->NumberOfRvaAndSizes);
	printf("\n");
	//打印数据目录的偏移
	DWORD* directory = (DWORD*)&optional->DataDirectory;
	printf("===================开始查找NT->数据目录中信息=========================\n");
	//打印各个数据目录的信息,创建table_address=table_p存储各个数据目录的地址(foa), table_before=table_p2存储rva
	DWORD table_address[16] = { 0 };
	DWORD table_before[16] = { 0 };
	DWORD* table_p = table_address;
	DWORD* table_p2 = table_before;
	//数据目录终1
	for (int i = 0; i < 16; i++) {
		printf("内存偏移: %-8x ", *directory);
		*table_p2 = (DWORD)*directory;
		*table_p = (DWORD)transform_to_file((char*)*directory, memory);
		printf("RVA->FOA: %-12x", *table_p);
		table_p++;
		table_p2++;
		directory++;
		printf("大小: %x\n", *directory++);
	}printf("\n");
	
	//打印节表
	printf("\n");
	PIMAGE_SECTION_HEADER section = (PIMAGE_SECTION_HEADER)(DWORD(optional) + file->SizeOfOptionalHeader);
	for (int i = 0; i < file->NumberOfSections; i++) {
		conversion(section);
		printf("VirtualSize(对齐前所占大小(内存)): %x\n", section->Misc.VirtualSize);
		printf("SizeOfRawData(对齐后所占大小(文件)): %x\n", section->SizeOfRawData);
		printf("VirtualAddress(在内存中偏移(RVA)): %x\n", section->VirtualAddress);
		printf("PointerToRawData(在文件中偏移(FOA)): %x\n", section->PointerToRawData);
		printf("Characteristics(标志(块属性)): %x\n", section->Characteristics);
		section++;
		printf("\n");
	}
}


void analysize(char path[]) {
	FILE* file_point = OpenFile(path);
	char* memory_point = GetMemory(file_point);
	print(memory_point);
	print_export(memory_point);
	print_import(memory_point);
	print_reloc(memory_point);
	char* memory[] = { memory_point };
	int num = (sizeof(memory)) / 4;
	FreeMemory(file_point, memory, num);
}
int main() {
    char dll[] = "D:\\Ddisk\\逆向\\AutoUpdateUtil.dll";
    char last_memory[] = "D:\\Ddisk\\last_memory.exe";
    char notepad[] = "C:\\Windows\\System32\\notepad.exe";
    char crack[] = "D:\\Ddisk\\逆向\\CrackMe.exe";
    analysize(notepad);
}

部分运行结果如下

wave_sky
关注
PE文件复看：打印PE头信息
KKMI的博客
05-31 942
PE文件解析打印头部信息1.把文件读取到堆空间 1.把文件读取到堆空间 以后对PE文件进行频繁的操作总是绕不开第一步，就是把PE文件的信息读取到自己申请的堆空间中，所以先实现这个函数，以便于以后频繁使用。 函数： ReadPEfile_TO_FileBuffer 功能说明： 把PE文件以二进制的读方式读取到FileBuffer堆空间 DWORD ReadPEfile_TO_FileBuffer(IN char* filepath, OUT void** FileBuffer) { //打开文件，读
PE头打印
qq_41232519的博客
09-22 616
文章目录 一、GetLogicalDrives() #include <windows.h> DWOR dwtLogicalDrives = GetLogicalDrives(); //返回一个数字 13 1101 1为存在，0为不存在，从右到左 ，A存在，B不存在，C存在，D存在
PE导出表，C语言打印导出表信息【滴水逆向三期49笔记＋作业】
WdIg-2023的博客
03-22 1123
我们前面在学习PE文件结构的时候，在可选PE头里跳过了最后一项，为一个有16个元素结构体数组，我们称它为数据目录。 今天我们来学习数据目录的第一个结构：导出表。
PE文件的输出
weixin_58628068的博客
12-04 555
编写应用程序，打印PE文件头中的各项字段、区块表和区块信息、输出表导出的函数，以及输入表中导入的函数 输入：PE文件 输出：txt文件，内容为上述各项信息
C++打印PE文件头信息Demo
ahch8077的博客
06-09 273
PE文件格式被组织为一个线性的数据流，它由一个MS-DOS头部开始，接着是一个是模式的程序残余以及一个PE文件标志，这之后紧接着PE文件头和可选头部。这些之后是所有的段头部，段头部之后跟随着所有的段实体。文件的结束处是一些其它的区域，其中是一些混杂的信息，包括重分配信息、符号表信息、行号信息以及字串表数据。 PE文件主要信息按顺序 IMAGE_DOS_HEADER MS-DO...
滴水课程作业（手动+代码解析pe）
weixin_52437902的博客
07-27 547
滴水逆向课后作业
滴水PE部分作业
qq_52442096的博客
11-21 239
【代码】滴水PE部分作业。
滴水PE作业(3月16日)
bruce_devil的博客
03-17 209
滴水逆向作业(3月16日)
精选资源
滴水三期 win32作业项目 PE查看器源码
05-16
滴水三期 win32作业项目 PE查看器源码
滴水逆向3期作业Filebuffer->Imagebuffer->Newbuffer->存盘功能C++源码
06-23
"滴水逆向3期作业"是一个关于逆向工程的学习项目，重点在于理解C++源码中如何处理文件，特别是与PE（Portable Executable）文件格式相关的操作。PE文件格式是Windows操作系统中用于可执行程序、动态链接库（DLL）和...
滴水三期PE文件格式个人笔记
weixin_73368512的博客
11-30 322
【代码】滴水三期PE文件格式个人笔记。
【滴水三期】32/64位——PE文件头字段打印与解析
sunqingyu888的博客
08-03 1066
【滴水三期】32/64位——PE文件头字段打印与解析
[滴水逆向]03-12 pe头字段说明课后作业，输出pe结构
fzucaicai的博客
09-21 1147
所以重点来了：用完ftell（）这个函数，就会将文件内部指针的位置移动到最末尾（如果设置的是SEEK_END），所以需要重新使用一下fseek重新设置文件内部指针的一个位置。有个问题，因为我认为前面一个已经判断指针移动失败了，于是我把第二个注释了，发现少了第二个fseek就会输出错误的答案。如果执行成功 , 则返回 0 , 失败返回非 0 , 并设置 error 错误代码;偏移量参数 , 可以为正数 , 也可以为负数;设置的指针的位置是 起始位置 + 偏移量;
打印导出表
qq_41232519的博客
10-05 785
文章目录一、流程二、演示三、完整代码 一、流程 1、创建一个RVA转FOA的函数 2、创建一个打印导出表的函数 3、File-> FileBuffer 4、获取头信息 5、获取结构体数组的信息 6、获取导出表的地址Rva 7、获取导出表的地址Foa 8、导出表在文件中的地址 9、打印导出表的成员属性 10、将导出表Name、AddressOfNames、AddressOfFunctions、AddressOfNameOrdinals的Rva转换成Foa 11、 打印导出表文件名 12、获取导出函数地址
构建个人学习与工作LLM应用系统的核心运行机制：一种人机协同系统“认知引擎”的架构原理
weixin_41939376的博客
12-28 375
摘要：本文提出构建"人机协同认知引擎"的方法论，旨在将临时性对话升级为可持续复利的认知生产力系统。核心架构包含六层功能：情境层（明确任务背景）、世界模型层（构建个人知识体系）、证据与记忆层（确保可追溯性）、推理与规划层（生成可执行计划）、行动与外部化层（输出实际成果）以及评估与学习层（持续优化）。
PySide6从0开始学习的笔记（十八） MVC（Model-View-Controller）模式的图形渲染体系
xulibo5828的博客
12-26 840
MVC 的核心是数据（Model）- 视图（View）- 控制器（Controller）QGraphicsItem（图元）= Model（模型）：图元是显示的基本单元，它可以是一个圆、一个多边形、一条直线，或者是一个图片，它承载着图形的核心数据与状态（比如坐标、形状、颜色、是否可交互、像素数据等），是 “要渲染的内容本身”，不关心自己如何被显示、在哪显示。QGraphicsView（视图）= View（视图）
【AI学习-comfyUI学习-第二十三-法线贴图工作流-depth 结构+MiDaS 法线-各个部分学习】
qq_22146161的博客
12-25 1361
最近，学习comfyUI，这也是AI的一部分，想将相关学习到的东西尽可能记录下来。不断学习摸索中。
个人用云计算学习笔记 --24 虚拟化、KVM 基础使用与热迁移实验、VMware ESXi笔记
iconball的博客
12-26 911
本文系统介绍了虚拟化技术基础概念、发展历程和主流方案，重点分析了KVM虚拟化的使用方法和热迁移实验。主要内容包括：虚拟化定义及组件（物理机、虚拟机、Hypervisor）；技术演进时间线（1964年IBM大型机到2014年容器技术）；虚拟化类型比较（全/半/硬件辅助）；KVM图形界面和命令行操作指南；以及基于NFS共享存储的热迁移实验环境搭建与实施步骤。文章为读者提供了从虚拟化原理到实践操作的完整知识框架。
学习C#调用OpenXml操作word文档的基本用法（14：学习文档编号定义类）
最新发布
gc_2299的博客
12-28 410
学习文档编号定义类NumberingDefinitionsPart的主要属性
PE查看器源码分析：滴水三期win32项目解析
滴水三期win32作业项目PE查看器是一个针对Windows操作系统的编程作业项目，旨在通过Win32 API（Windows 32位应用程序接口）实现一个PE（Portable Executable，可移植执行体）文件查看器。PE文件是Windows操作系统中...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值