pe重定位及修正

最新推荐文章于 2022-10-27 14:56:33 发布
最新推荐文章于 2022-10-27 14:56:33 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： window
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_bcb/article/details/79371975
版权 
#include "stdafx.h"


#include <windows.h>  
#include <iostream>  
  
class MemBlock {  
public:  
    MemBlock() : m_buff(NULL) {}  
  
    bool alloc(size_t size) {  
        m_buff = VirtualAlloc(m_buff, size,  MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);   
        if(m_buff == NULL)   {    
            printf("VirtualAlloc error: %d\n",GetLastError());    
            return false;  
        }    
        return true;  
    }  
  
    ~MemBlock() {  
        if (!m_buff) {  
            return;  
        }  
        if(!VirtualFree(m_buff, 0, MEM_RELEASE))  {    
            printf("VirutalFree error: %d",GetLastError());    
        }   
    }  
  
    void load(size_t offset, void const* buff, size_t size) {  
        memcpy((char*)m_buff + offset, buff, size);  
    }  
  
    void* get() { return m_buff; }  
  
private:  
    void* m_buff;  
};  
  
class PEFile {  
public:  
    PEFile(char const* path) {  
        HANDLE fileHandle= CreateFile(path,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);  
        if(INVALID_HANDLE_VALUE == fileHandle){  
            std::cout << "打开文件映射对象失败！" << std::endl;  
            return;  
        }  
        HANDLE mapHandle=    CreateFileMapping(fileHandle,NULL,PAGE_READONLY,0,0,NULL);  
        if(mapHandle==NULL){  
            std::cout << "打开文件映射对象失败！" << std::endl;;  
            return;  
        }  
        m_BaseAddress =(LPBYTE)MapViewOfFile(mapHandle,FILE_MAP_READ,0,0,0);  
  
        m_dosHead=(PIMAGE_DOS_HEADER)m_BaseAddress;  
  
        m_ntHead=(PIMAGE_NT_HEADERS)(m_BaseAddress+m_dosHead->e_lfanew);  
  
        if(m_dosHead->e_magic==IMAGE_DOS_SIGNATURE&&m_ntHead->Signature != IMAGE_NT_SIGNATURE){  
            std::cout << "打开文件映射对象失败！" << std::endl;;  
            return;  
        }  
  
        m_sectionBase = IMAGE_FIRST_SECTION(m_ntHead);


        m_imgSize = 0;
        m_codeVA = 0;
        PIMAGE_SECTION_HEADER sectAddr = m_sectionBase;  
        for (WORD n = m_ntHead->FileHeader.NumberOfSections; n  > 0; --n) {  
            //模拟内存对齐机制    
            DWORD dwBlockCount  = (sectAddr->SizeOfRawData + m_ntHead->OptionalHeader.SectionAlignment - 1) /  
                m_ntHead->OptionalHeader.SectionAlignment;    
  
            DWORD dwBeginVA = sectAddr->VirtualAddress;    
            DWORD dwEndVA = dwBeginVA + dwBlockCount * m_ntHead->OptionalHeader.SectionAlignment;   
            if (m_imgSize < dwEndVA) {  
                m_imgSize = dwEndVA;
            }
            if (strcmp((char*)sectAddr->Name, ".text") == 0) {  
                m_codeVA = sectAddr->VirtualAddress;  
            }
            sectAddr++;
        }
    }
    void loadImage() {  
        m_image.alloc(m_imgSize);  


        loadSection(m_image);


        importFun((DWORD)m_image.get());


        relocAddr((DWORD)m_image.get());


        printf("image base address %p\n", m_image.get());


        void (*main_fun)();
        main_fun = (void (*)())((DWORD)m_image.get() + m_ntHead->OptionalHeader.AddressOfEntryPoint);
        main_fun();  
    }


    void loadSection(MemBlock& image) {
        PIMAGE_SECTION_HEADER sectAddr = m_sectionBase;  
        WORD n = m_ntHead->FileHeader.NumberOfSections;  
        while  (n  > 0) {  
            //模拟内存对齐机制    
            DWORD dwBlockCount  = (sectAddr->SizeOfRawData + m_ntHead->OptionalHeader.SectionAlignment - 1) /  
                m_ntHead->OptionalHeader.SectionAlignment;    
  
            DWORD dwBeginVA = sectAddr->VirtualAddress;    
            DWORD dwEndVA = sectAddr->VirtualAddress + dwBlockCount * m_ntHead->OptionalHeader.SectionAlignment;   
  
            image.load(sectAddr->VirtualAddress, (void*)(m_BaseAddress + sectAddr->PointerToRawData), sectAddr->SizeOfRawData);


            sectAddr++;  
            n--;  
        }
    }


    void importFun(DWORD imageLoadAddr) {
        PIMAGE_IMPORT_DESCRIPTOR impTable = (PIMAGE_IMPORT_DESCRIPTOR)(imageLoadAddr + m_ntHead->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);  
        while ( impTable->TimeDateStamp != 0 || impTable->Name != 0) {  
            PCHAR ptr = (PCHAR)((DWORD)m_image.get()+ impTable->Name); 
            std::cout << "handle import dll " << ptr << std::endl;
            HMODULE handle = GetModuleHandle(ptr);  
            if (handle == NULL)  
                handle = LoadLibrary(ptr);  
            if (handle == NULL) {  
                std::cout << "A required .DLL file, " << ptr << ", was not found.\n";
                return;
            }  
            if (impTable->TimeDateStamp != -1)  
            {  
                impTable->ForwarderChain  = (DWORD)handle;  
                impTable->TimeDateStamp = 0xCDC31337;  


                PIMAGE_THUNK_DATA funAddr = (PIMAGE_THUNK_DATA)(imageLoadAddr + (DWORD)impTable->FirstThunk);
                PIMAGE_THUNK_DATA impFunThunk    ;
                if (impTable->Characteristics == 0)  
                    impFunThunk  = (PIMAGE_THUNK_DATA)(imageLoadAddr + (DWORD)impTable->FirstThunk);
                else   
                    impFunThunk = (PIMAGE_THUNK_DATA)(imageLoadAddr + impTable->OriginalFirstThunk);  
  
                while ( impFunThunk->u1.AddressOfData != NULL) {  
                    DWORD dw = 0;
                    if (IMAGE_SNAP_BY_ORDINAL(impFunThunk    ->u1.Ordinal)) {  
                        LPCSTR fnAddr = (LPCSTR)IMAGE_ORDINAL(impFunThunk->u1.Ordinal);
                        dw = (DWORD)GetProcAddress(handle, fnAddr); 
                        printf("\t[0x%p] %d => 0x%08x\n", &(funAddr->u1.Function), IMAGE_ORDINAL(impFunThunk->u1.Ordinal), dw);
                    } else {  
                        PIMAGE_IMPORT_BY_NAME pName = (PIMAGE_IMPORT_BY_NAME)(impFunThunk->u1.AddressOfData + imageLoadAddr);  
                        dw = (DWORD)GetProcAddress(handle, pName->Name);
                        printf("\t[0x%p] %s => 0x%08x\n", &(funAddr->u1.Function), pName->Name, dw);
                    }  
                    if (dw == 0) {
                        std::cout << "not find import fun";
                        return;
                    }  
  
                    funAddr->u1.Function = dw;  
                    funAddr++;


                    impFunThunk ++;
                }  
         
            } else { // -1 = new style bound import   
                printf("New style bound import: %s\n", ptr);  
            }  
            impTable++;          
        } 
    }


    void relocAddr(DWORD imageLoadAddr) {
        IMAGE_DATA_DIRECTORY* pDataDir = &(m_ntHead->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC]);  
        if (pDataDir->VirtualAddress == 0) {  
            std::cout << "not exist data directory IMAGE_DIRECTORY_ENTRY_BASERELOC" << std::endl;;  
        }  
        printf("reloc entry va: %08x  size: %d\n",  pDataDir->VirtualAddress, pDataDir->Size);  
        DWORD va = pDataDir->VirtualAddress;  
        while (va < pDataDir->VirtualAddress + pDataDir->Size) {  
            PIMAGE_BASE_RELOCATION relocBase = (PIMAGE_BASE_RELOCATION)(m_BaseAddress + rva2foa(va));  
            PWORD   typeBase = (PWORD)(relocBase + 1);  
            int typeCount = (relocBase->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);  
            printf("reloc block va: %08x   size: %d  count: %d\n", pDataDir->VirtualAddress,  relocBase->SizeOfBlock, typeCount);  
            for (int i = 0; i < typeCount; ++i)  
            {  
                DWORD offset = typeBase[i] & 0x0fff;  
                WORD flag = (typeBase[i] >> 12) & 0x000f;  
                /* 
                IMAGE_REL_BASED_ABSOLUTE (0) 使块按照32位对齐，位置为0。 
                IMAGE_REL_BASED_HIGH (1) 高16位必须应用于偏移量所指高字16位。 
                IMAGE_REL_BASED_LOW (2) 低16位必须应用于偏移量所指低字16位。 
                IMAGE_REL_BASED_HIGHLOW (3) 全部32位应用于所有32位。. 
                IMAGE_REL_BASED_HIGHADJ (4) 需要32位，高16位位于偏移量，低16位位于下一个偏移量数组元素，组合为一个带符号数，加上32位的一个数，然后加上8000然后把高16位保存在偏移量的16位域内。 
                IMAGE_REL_BASED_MIPS_JMPADDR (5)        Unknown 
                IMAGE_REL_BASED_SECTION (6)        Unknown 
                IMAGE_REL_BASED_REL32 (7)        Unknown 
                */  
                if (flag == IMAGE_REL_BASED_HIGHLOW) {  
                    // 对需要重定位的数据进行修正  
                    // 需要进行重定位的地址 =  模块基址+重定位基址+每个数据表示偏移量  
                    PDWORD relocAddress = (PDWORD)(imageLoadAddr + relocBase->VirtualAddress + offset);  
                    DWORD oldAddr = *relocAddress;  
                    // 修正方法: 重定位之后的值 = 需要进行重定位的地址值 - IMAGE_OPTINAL_HEADER中的基址 + 实际基址  
                    *relocAddress = oldAddr - m_ntHead->OptionalHeader.ImageBase + imageLoadAddr;  
  
                    printf("\tadress: 0x%p   value: 0x%p => 0x%p \n", relocAddress,  oldAddr, *relocAddress);  
                }  
            }  
            va += relocBase->SizeOfBlock;  
        } 
    }


    size_t rva2foa(size_t rva)    
    {    
        PIMAGE_SECTION_HEADER sectAddr = m_sectionBase;  
        WORD n = m_ntHead->FileHeader.NumberOfSections;  
        while  (n  > 0) {  
            //模拟内存对齐机制    
            DWORD dwBlockCount  = (sectAddr->SizeOfRawData + m_ntHead->OptionalHeader.SectionAlignment - 1) /  
                m_ntHead->OptionalHeader.SectionAlignment;    
  
            DWORD dwBeginVA = sectAddr->VirtualAddress;    
            DWORD dwEndVA = sectAddr->VirtualAddress + dwBlockCount * m_ntHead->OptionalHeader.SectionAlignment;    
            //如果stRVA在某个区段中    
            if (rva >= dwBeginVA && rva < dwEndVA)   {    
                return rva - dwBeginVA + sectAddr->PointerToRawData;    
            }    
            else if (rva < dwBeginVA) {//在文件头中直接返回    
                return rva;    
            }   
            sectAddr++;  
            n--;  
        }   
        std::cout << "not find rva " <<  rva << std::endl;;  
        return 0;    
    } 






    void analyseReloc() {  
        IMAGE_DATA_DIRECTORY* pDataDir = &(m_ntHead->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC]);  
        if (pDataDir->VirtualAddress == 0) {  
            std::cout << "not exist data directory IMAGE_DIRECTORY_ENTRY_BASERELOC" << std::endl;;  
        }  
        printf("reloc entry va: %08x  size: %d\n",  pDataDir->VirtualAddress, pDataDir->Size);  
        DWORD va = pDataDir->VirtualAddress;  
        while (va < pDataDir->VirtualAddress + pDataDir->Size) {  
            PIMAGE_BASE_RELOCATION relocBase = (PIMAGE_BASE_RELOCATION)(m_BaseAddress + rva2foa(va));  
            PWORD   typeBase = (PWORD)(relocBase + 1);  
            int typeCount = (relocBase->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);  
            printf("reloc block va: %08x   size: %d  count: %d\n", pDataDir->VirtualAddress,  relocBase->SizeOfBlock, typeCount);  
            for (int i = 0; i < typeCount; ++i)  
            {  
                DWORD offset = typeBase[i] & 0x0fff;  
                offset += rva2foa(relocBase->VirtualAddress);  
                WORD flag = (typeBase[i] >> 12) & 0x000f;  
                static char* flag_str[] = {  
                    "REL_BASED_ABSOLUTE",  
                    "REL_BASED_HIGH",  
                    "REL_BASED_LOW",  
                    "REL_BASED_HIGHLOW",  
                    "REL_BASED_HIGHADJ",  
                    "REL_BASED_MACHINE_SPECIFIC_5",  
                    "REL_BASED_RESERVED",  
                    "REL_BASED_MACHINE_SPECIFIC_7",  
                    "REL_BASED_MACHINE_SPECIFIC_8",  
                    "REL_BASED_MACHINE_SPECIFIC_9",  
                    "REL_BASED_DIR64",  
                    "UNKOWN",  
                    "UNKOWN",  
                    "UNKOWN",  
                    "UNKOWN",  
                    "UNKOWN"  
                };  
                PDWORD addr = (PDWORD)(m_BaseAddress + offset);  
                printf("\trva: %08x   foa: %08x  addr: %08x  %s\n", offset,  rva2foa(offset), *addr, flag_str[flag]);  
            }  
            va += relocBase->SizeOfBlock;  
        }  
    }  
  
    void analyseImport() {  
        IMAGE_DATA_DIRECTORY* pDataDir = m_ntHead->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_IMPORT;  
        if (pDataDir->VirtualAddress == 0) {  
            std::cout << "not exist data directory IMAGE_DIRECTORY_ENTRY_IMPORT";  
        }  
    }  
  
private:  
    LPBYTE m_BaseAddress;  
    PIMAGE_DOS_HEADER m_dosHead;  
    PIMAGE_NT_HEADERS m_ntHead;  
    PIMAGE_SECTION_HEADER m_sectionBase;  
    MemBlock m_image;  


    size_t m_imgSize;
    size_t m_codeVA;
};  






int _tmain(int argc, _TCHAR* argv[])
{
    PEFile pe(argv[1]);    
    pe.loadImage() ;
	return 0;
}
过期码农
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PE文件：重定位表（为什么需要重定位和如何重定位）
weixin_43742894的博客
03-31 1240
**为什么重定位？** 重定位就是修正PE文件的地址。 PE文件有着默认的基址(ImageBase默认为0x40000000)，理论上当PE要加载的时候，就会占据这个地址，但是当这个地址因为一些原因，被占用而不能被加载时，PE文件就被加载到其他地方了，这时候就需要基址重定位了。
PE_修正重定位表
qq_42363151的博客
09-25 299
PE
PE 重定位
加号减减号的博客
05-04 1318
PE 重定位简述 基址重定位表 IMAGE_BASE_RELOCATION TypeOffset 重定位地址计算 重定位过程总结 参考资料 PE 重定位简述 当 PE 文件被加载进虚拟内存却并非加载到 PE 头所指定的 ImageBase 处时（如 ASLR 机制），我们就说发生了 PE 重定位。比如说我们某一个 PE 文件的 ImageBase 为 0x400000，然...
滴水逆向三期实践15：根据重定位表修正地址
Rivival_S 的博客
10-28 2351
占坑
PE重定位
fa1c4的blog
03-04 303
PE重定位基本原理(很简洁 找到所有硬编码的地址 每个地址减去ImageBase 加上装载的实际地址 主要是查找硬编码地址, 是由重定位表relocation table提供每个硬编码的偏移. 也就是基址重定位表. Base_Relocation_Table 记录在PE头的DataDirectory数组的第六个元素. 该表是由IMAGE_BASE_RELOCATION结构体组成的, 结构体记录了硬编码地址的偏移. IMAGE_BASE_RELOCATION结构体 结构体由VirtualAddress,
PE重定位练习
10-07
该文件包含一个dll和PEview，和文章中的截图对应，方便大家更好的理解PE重定位原理
pe 文件编程：清除文件头中的重定位表.rar_pe_清楚重定位表
09-21
重定位表包含了所有需要修正的地址信息，确保程序能够正确运行。 重定位表主要包含两部分：节重定位表和图像重定位表。节重定位表记录了文件内部不同节之间的相对地址调整；图像重定位表则处理文件与进程地址空间的...
重定位表1
08-03
总之，重定位表是PE文件适应不同加载地址的关键机制，它通过维护一系列的重定位项来修正程序内部的相对地址，确保程序在运行时的正确性。理解并能正确处理重定位表对于PE文件分析、调试和逆向工程来说至关重要。
甲壳重定位信息查看器
03-28
PE文件格式中，重定位信息存储在文件头的“重定位节”（Relocation Table）中，包含了需要修正的地址和修正方法。EXE文件通常只有一个映像，而DLL文件可能被多个进程共享，因此它们的重定位处理更为复杂。"甲壳重...
易语言源码易语言PE校验修正源码.rar
03-30
3. **修正技术**：源码可能包括了对PE文件的修正功能，如修复节区的大小、地址、重定位信息，或者更新导入导出表等。这些修正通常需要对PE文件结构有深入了解，以及掌握如何在内存中操作这些结构。 4. **易语言编程...
PE-64位-重定位表-读取解析-保存修改-代码
插件开发
03-14 1758
重定位表（Relocation Table）用于在程序加载到内存中时，进行内存地址的修正。一个简单程序test.exe需要三个动态链接库dll（a.dll，b.dll，c.dll），假设test.exe的ImageBase为400000H，而a.dll、b.dll、c.dll的基址ImageBase均为1000000H。
PE手动重定位
Starr
11-15 576
文章目录源码运行添加重定位信息 工具：RadAsm，010 Editor，LordPE。 源码 .386 .model flat,stdcall option casemap:none include msvcrt.inc includelib msvcrt.lib .data szText db 'welcome', 0ah, 00h szPause db 'pause', 00h ...
PE重定位表
跃然实验室
06-11 372
重定位表解决Pe文件实际加载基址与PE文件中所指定的加载基址不同时带来的问题。 保存有待修正数据的地址 EXE文件不存在重定位表：对于EXE文件来说，每个文件总是使用独立的虚拟地址空间，所以EXE总是能够按照这个地址装入，这意味着EXE 文件不再需要重定位信息。 　　DLL文件需要重定位表：对于DLL文件来说，由于多个DLL文件全部使用宿主EXE文件的地址空间，...
PE文件重定位
lookerson的专栏
09-12 4249
PE格式是Windows环境下可执行文件（如：exe，dll）的格式，而Windows下面的程序，例如动态链接库无法加载到它本身期望加载的地址的时候，便会发生重定位。那么，重定位是如何实现的呢？   一．PE文件格式的结构 PE文件主要是由PE头和PE体组成的，其中，PE头主要由DOS头， DOS存根，NT头：签名，NT头：文件头，NT头：可选头，节头组成， 而剩下的各节区组成PE体。其
用x32/x64dbg脱DLL壳(IAT表修复和重定位表修复)
qq_41866334的博客
05-06 4914
一直搜到的都是看雪论坛上用的lordPE和ImportREC进行脱壳和修复,感觉有点过时了. 记录一下x32/x64dbg的脱壳和IAT修复方法. 首先用esp定律等方法找到程序的入口点, 然后使用Scylla插件并填写其中的OEP地址. 然后用IAT Autosearch去找可能的IAT表,dump并fix pe文件即可. ...
PE-重定位表
最新发布
qq_51600802的博客
10-27 926
按照上述思路，可写代码打印重定位表的信息（不打印具体项，但按照上面公式打印具体项的数量）但这里注意一个问题，就是遍历这个重定位表，是根据这一块的 VirtualAddress 和 SizeOfBlock 结束后，下一块 VirtualAddress 和 SizeOfBlock 是否全0 来判断重定位表是否结束的。1、每个程序都有一个独立的4G内存空间，当你双击一个程序时，操作系统就为你开辟一个虚拟的4g内存空间，然后就开始贴图，将各个PE文件贴到内存空间，当贴完之后，eip指向程序入口点就开始跑了。
LordPE关闭重定位 alsr
lhk124的博客
07-23 506
前言：alsr多多少少影响逆向时对程序的分析。关闭它。 两种情况： 1.操作系统开启了alsr。关闭方法文章如下： win10参考文章：https://www.52pojie.cn/thread-1099755-1-1.html win7参考文章：https://bbs.pediy.com/thread-258653.htm2 2.程序保护关闭方法 爱盘下载LordPE 重新用OD载入程序后，可以看见不会再变化了。 ...
也谈PE重定位表
weixin_30734435的博客
01-17 117
最近研究脱壳，遇到了dll，所以不可避免的需要修复重定位表。以前研究过也脱过不少壳，但都是exe从来没有手工修过重定位表，于是搜索之，恩有这么一篇：《PE重定位表学习手记》，有刚巧手上有看雪段钢等编著的《加密与解密》，一并阅读。 《PE重定位表学习手记》中说到： 每个块的首部是如下定义： typedef struct _IMAGE_BASE_RELOCATION { DWORD ...
滴水逆向三期 PE基础 移动重定位表与修改IMAGEBASE
四位的博客
05-16 1863
分析 一 移动重定位 直接把整张表复制后修改目录表的RVA即可 二 修改ImageBase ①首先当然是修改ImageBase ②遍历重定位表中的数据加上新旧ImageBase的差值, 就是在打印的基础上加上修改数据 重定位表的结构 SECTION为所属区段, RVA为大表, items为有多少数据(SizeofBlock-8)/2 因为小表为word RVA为要修改数据的地址(非真实地址) offset为文件偏移 type为数据属性 FarAddress为真正的地址也是修改imagebase后应该修改
代码重定位与虚拟内存：原理与Linux实例解析
本讲解由国创中心的张雪凯于2021年8月3日提供，主要内容分为两个部分：代码重定位和虚拟内存的必要性及实现。 1. **代码重定位** - 在编程中，由于可执行文件通常需要存储在只读存储器（如ROM或FLASH）中以保持其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值