windowsPE加载器，替换进程内存，

最新推荐文章于 2023-05-25 18:39:14 发布
最新推荐文章于 2023-05-25 18:39:14 发布
阅读量960 收藏
点赞数
分类专栏： 计算机安全 编程杂烩 加壳 文章标签： image alignment null header dos exe

http://topic.csdn.net/u/20091103/11/c38fd755-6ff6-4b8b-a7bc-9aa1c94774c4.html

http://bbs.eyuyan.com/read.php?tid=150015&page=2

 Windows的PE加载器在启动程序的时候，会将磁盘上的文件加载到内存，然后做很多操作，如函数导入表重定位，变量预处理之类的。这位仁兄等于是自己写了一个PE加载器。直接将内存中的程序启动。记得以前的“红色代码”病毒也有相同的特性。
    直接启动内存中的程序相当于加了一个壳，可以把程序加密保存，运行时解密到内存，然后启动，不过对于增加破解难度还要稍微复杂点。否则人家把内存中的进程DUMP出来然后修复导入表就被拖出来了。


#include "stdafx.h" 
 
 
typedef IMAGE_SECTION_HEADER (*PIMAGE_SECTION_HEADERS)[1];  
 
// 计算对齐后的大小  
unsigned long GetAlignedSize(unsigned long Origin, unsigned long Alignment)  
{  
    return (Origin + Alignment - 1) / Alignment * Alignment;  
}  
 
// 计算加载pe并对齐需要占用多少内存  
// 未直接使用OptionalHeader.SizeOfImage作为结果是因为据说有的编译器生成的exe这个值会填0  
unsigned long CalcTotalImageSize(PIMAGE_DOS_HEADER MzH  
                                 , unsigned long FileLen  
                                 , IMAGE_NT_HEADERS peH  
                                 , IMAGE_SECTION_HEADERS peSecH)  
{  
    unsigned long res;  
    // 计算pe头的大小  
    res = GetAlignedSize( peH->OptionalHeader.SizeOfHeaders  
        , peH->OptionalHeader.SectionAlignment  
        );  
 
    // 计算所有节的大小  
    for( int i = 0; i < peH->FileHeader.NumberOfSections; ++i)  
    {  
        // 超出文件范围  
        if(peSecH->ointerToRawData + peSecH->SizeOfRawData > FileLen)  
            return 0;  
        else if(peSecH->VirtualAddress)//计算对齐后某节的大小  
        {  
            if(peSecH->Misc.VirtualSize)  
            {  
                res = GetAlignedSize( peSecH->VirtualAddress + peSecH->Misc.VirtualSize  
                    , peH->OptionalHeader.SectionAlignment  
                    );  
            }  
            else 
            {  
                res = GetAlignedSize( peSecH->VirtualAddress + peSecH->SizeOfRawData  
                    , peH->OptionalHeader.SectionAlignment  
                    );  
            }  
        }  
        else if( peSecH->Misc.VirtualSize < peSecH->SizeOfRawData )  
        {  
            res += GetAlignedSize( peSecH->SizeOfRawData  
                , peH->OptionalHeader.SectionAlignment  
                );  
        }  
        else 
        {  
            res += GetAlignedSize( peSecH->Misc.VirtualSize  
                , peH->OptionalHeader.SectionAlignment  
                );  
        }// if_else  
    }// for  
      
    return res;  
}  
// 加载pe到内存并对齐所有节  
BOOL AlignPEToMem( void *Buf  
                  , long Len  
                  , IMAGE_NT_HEADERS &peH  
                  , IMAGE_SECTION_HEADERS &peSecH  
                  , void *&Mem  
                  , unsigned long &ImageSize)  
{  
    IMAGE_DOS_HEADER SrcMz;// DOS头  
    IMAGE_NT_HEADERS SrcPeH;// E头  
    IMAGE_SECTION_HEADERS SrcPeSecH;// 节表  
      
    SrcMz = (PIMAGE_DOS_HEADER)Buf;  
 
    if( Len < sizeof(IMAGE_DOS_HEADER) )   
        return FALSE;  
      
    if( SrcMz->e_magic != IMAGE_DOS_SIGNATURE )  
        return FALSE;  
      
    if( Len < SrcMz->e_lfanew + (long)sizeof(IMAGE_NT_HEADERS) )  
        return FALSE;  
 
    SrcPeH = (PIMAGE_NT_HEADERS)((int)SrcMz + SrcMz->e_lfanew);  
    if( SrcPeH->Signature != IMAGE_NT_SIGNATURE )  
        return FALSE;  
 
    if( (SrcPeH->FileHeader.Characteristics & IMAGE_FILE_DLL) ||  
        (SrcPeH->FileHeader.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE == 0) ||  
        (SrcPeH->FileHeader.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER)) )  
    {  
        return FALSE;  
    }  
 
 
    SrcPeSecH = (PIMAGE_SECTION_HEADERS)((int)SrcPeH + sizeof(IMAGE_NT_HEADERS));  
    ImageSize = CalcTotalImageSize( SrcMz, Len, SrcPeH, SrcPeSecH);  
 
    if( ImageSize == 0 )  
        return FALSE;  
      
    Mem = VirtualAlloc( NULL, ImageSize, MEM_COMMIT, AGE_EXECUTE_READWRITE); // 分配内存  
    if( Mem != NULL )  
    {  
        // 计算需要复制的PE头字节数  
        unsigned long l = SrcPeH->OptionalHeader.SizeOfHeaders;  
        for( int i = 0; i < SrcPeH->FileHeader.NumberOfSections; ++i)  
        {  
            if( (SrcPeSecH->ointerToRawData) &&  
                (SrcPeSecH->ointerToRawData < l) )  
            {  
                l = SrcPeSecH->ointerToRawData;  
            }  
        }  
        memmove( Mem, SrcMz, l);  
        peH = (PIMAGE_NT_HEADERS)((int)Mem + ((PIMAGE_DOS_HEADER)Mem)->e_lfanew);  
        peSecH = (PIMAGE_SECTION_HEADERS)((int)peH + sizeof(IMAGE_NT_HEADERS));  
 
        void *Pt = (void *)((unsigned long)Mem   
            + GetAlignedSize( peH->OptionalHeader.SizeOfHeaders  
            , peH->OptionalHeader.SectionAlignment)  
            );  
 
        for( i = 0; i < peH->FileHeader.NumberOfSections; ++i)  
        {  
            // 定位该节在内存中的位置  
            if(peSecH->VirtualAddress)  
                t = (void *)((unsigned long)Mem + peSecH->VirtualAddress);  
 
            if(peSecH->SizeOfRawData)  
            {  
                // 复制数据到内存  
                memmove(Pt, (const void *)((unsigned long)(SrcMz) + peSecH->ointerToRawData), peSecH->SizeOfRawData);  
                if(peSecH->Misc.VirtualSize < peSecH->SizeOfRawData)  
                    t = (void *)((unsigned long)Pt + GetAlignedSize(peSecH->SizeOfRawData, peH->OptionalHeader.SectionAlignment));  
                else // pt 定位到下一节开始位置  
                    t = (void *)((unsigned long)Pt + GetAlignedSize(peSecH->Misc.VirtualSize, peH->OptionalHeader.SectionAlignment));  
            }  
            else 
            {  
                t = (void *)((unsigned long)Pt + GetAlignedSize(peSecH->Misc.VirtualSize, peH->OptionalHeader.SectionAlignment));  
            }  
        }  
    }  
    return TRUE;  
}  
 
 
 
typedef void *(__stdcall *pfVirtualAllocEx)(unsigned long, void *, unsigned long, unsigned long, unsigned long);  
pfVirtualAllocEx MyVirtualAllocEx = NULL;  
 
BOOL IsNT()  
{  
    return MyVirtualAllocEx!=NULL;  
}  
 
// 生成外壳程序命令行  
char *PrepareShellExe(char *CmdParam, unsigned long BaseAddr, unsigned long ImageSize)  
{  
    if(IsNT())  
    {  
        char *Buf = new char[256];  
        memset(Buf, 0, 256);  
        GetModuleFileName(0, Buf, 256);  
        strcat(Buf, CmdParam);  
        return Buf; // 请记得释放内存;-)  
    }  
    else 
    {  
        // Win98下的处理请参考原文;-)  
        // http://community.csdn.net/Expert/topic/4416/4416252.xml?temp=8.709133E-03  
        return NULL;  
    }  
}  
 
// 是否包含可重定向列表  
BOOL HasRelocationTable(PIMAGE_NT_HEADERS peH)  
{  
    return (peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress)  
        && (peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size);  
}  
#pragma pack(push, 1)  
typedef struct{  
    unsigned long VirtualAddress;  
    unsigned long SizeOfBlock;  
} *PImageBaseRelocation;  
#pragma pack(pop)  
 
// 重定向PE用到的地址  
void DoRelocation(PIMAGE_NT_HEADERS peH, void *OldBase, void *NewBase)  
{  
    unsigned long Delta = (unsigned long)NewBase - peH->OptionalHeader.ImageBase;  
    ImageBaseRelocation p = (PImageBaseRelocation)((unsigned long)OldBase   
        + peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);  
    while(p->VirtualAddress + p->SizeOfBlock)  
    {  
        unsigned short *pw = (unsigned short *)((int)p + sizeof(*p));  
        for(unsigned int i=1; i <= (p->SizeOfBlock - sizeof(*p)) / 2; ++i)  
        {  
            if((*pw) & 0xF000 == 0x3000){  
                unsigned long *t = (unsigned long *)((unsigned long)(OldBase) + p->VirtualAddress + ((*pw) & 0x0FFF));  
                *t += Delta;  
            }  
            ++pw;  
        }  
        p = (PImageBaseRelocation)pw;  
    }  
}  
 
// 卸载原外壳占用内存  
BOOL UnloadShell(HANDLE rocHnd, unsigned long BaseAddr)  
{  
    typedef unsigned long (__stdcall *pfZwUnmapViewOfSection)(unsigned long, unsigned long);  
    pfZwUnmapViewOfSection ZwUnmapViewOfSection = NULL;  
    BOOL res = FALSE;  
    HMODULE m = LoadLibrary("ntdll.dll");  
    if(m){  
        ZwUnmapViewOfSection = (pfZwUnmapViewOfSection)GetProcAddress(m, "ZwUnmapViewOfSection");  
        if(ZwUnmapViewOfSection)  
            res = (ZwUnmapViewOfSection((unsigned long)ProcHnd, BaseAddr) == 0);  
        FreeLibrary(m);  
    }  
    return res;  
}  
 
// 创建外壳进程并获取其基址、大小和当前运行状态  
BOOL CreateChild(char *Cmd, CONTEXT &Ctx, HANDLE &rocHnd, HANDLE &ThrdHnd,   
                 unsigned long &rocId, unsigned long &BaseAddr, unsigned long &ImageSize)  
{  
    STARTUPINFOA si;  
    ROCESS_INFORMATION pi;  
    unsigned long old;  
    MEMORY_BASIC_INFORMATION MemInfo;  
    memset(&si, 0, sizeof(si));  
    memset(&pi, 0, sizeof(pi));  
    si.cb = sizeof(si);  
      
    BOOL res = CreateProcess(NULL, Cmd, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi); // 以挂起方式运行进程;  
    if(res){  
        rocHnd = pi.hProcess;  
        ThrdHnd = pi.hThread;  
        rocId = pi.dwProcessId;  
        // 获取外壳进程运行状态，[ctx.Ebx+8]内存处存的是外壳进程的加载基址，ctx.Eax存放有外壳进程的入口地址  
        Ctx.ContextFlags = CONTEXT_FULL;  
        GetThreadContext(ThrdHnd, &Ctx);  
        ReadProcessMemory(ProcHnd, (void *)(Ctx.Ebx+8), &BaseAddr, sizeof(unsigned long), &old); // 读取加载基址  
        void *p = (void *)BaseAddr;  
        // 计算外壳进程占有的内存  
        while(VirtualQueryEx(ProcHnd, p, &MemInfo, sizeof(MemInfo)))  
        {  
            if(MemInfo.State = MEM_FREE) break;  
            p = (void *)((unsigned long)p + MemInfo.RegionSize);  
        }  
        ImageSize = (unsigned long)p - (unsigned long)BaseAddr;  
    }  
    return res;  
}  
 
// 创建外壳进程并用目标进程替换它然后执行  
HANDLE AttachPE(char *CmdParam, IMAGE_NT_HEADERS peH, IMAGE_SECTION_HEADERS peSecH,   
                void *Ptr, unsigned long ImageSize, unsigned long &rocId)  
{  
    HANDLE res = INVALID_HANDLE_VALUE;  
    CONTEXT Ctx;  
    HANDLE Thrd;  
    unsigned long Addr, Size;  
    char *s = repareShellExe(CmdParam, peH->OptionalHeader.ImageBase, ImageSize);  
    if(s==NULL) return res;  
    if(CreateChild(s, Ctx, res, Thrd, rocId, Addr, Size)){  
        void *p = NULL;  
        unsigned long old;  
        if((peH->OptionalHeader.ImageBase == Addr) && (Size >= ImageSize)){// 外壳进程可以容纳目标进程并且加载地址一致  
            p = (void *)Addr;  
            VirtualProtectEx(res, p, Size, AGE_EXECUTE_READWRITE, &old);  
        }  
        else if(IsNT()){  
            if(UnloadShell(res, Addr)){// 卸载外壳进程占有内存  
                p = MyVirtualAllocEx((unsigned long)res, (void *)peH->OptionalHeader.ImageBase, ImageSize, MEM_RESERVE | MEM_COMMIT, AGE_EXECUTE_READWRITE);  
            }  
            if((p == NULL) && HasRelocationTable(peH)){// 分配内存失败并且目标进程支持重定向  
                p = MyVirtualAllocEx((unsigned long)res, NULL, ImageSize, MEM_RESERVE | MEM_COMMIT, AGE_EXECUTE_READWRITE);  
                if(p) DoRelocation(peH, tr, p); // 重定向  
            }  
        }  
        if(p){  
            WriteProcessMemory(res, (void *)(Ctx.Ebx+8), &p, sizeof(DWORD), &old); // 重置目标进程运行环境中的基址  
            peH->OptionalHeader.ImageBase = (unsigned long)p;  
            if(WriteProcessMemory(res, p, tr, ImageSize, &old)){// 复制PE数据到目标进程  
                Ctx.ContextFlags = CONTEXT_FULL;  
                if((unsigned long)p == Addr)  
                    Ctx.Eax = peH->OptionalHeader.ImageBase + peH->OptionalHeader.AddressOfEntryPoint; // 重置运行环境中的入口地址  
                else 
                    Ctx.Eax = (unsigned long)p + peH->OptionalHeader.AddressOfEntryPoint;  
                SetThreadContext(Thrd, &Ctx);// 更新运行环境  
                ResumeThread(Thrd);// 执行  
                CloseHandle(Thrd);  
            }  
            else{// 加载失败,杀掉外壳进程  
                TerminateProcess(res, 0);  
                CloseHandle(Thrd);  
                CloseHandle(res);  
                res = INVALID_HANDLE_VALUE;  
            }  
        }  
        else{// 加载失败,杀掉外壳进程  
            TerminateProcess(res, 0);  
            CloseHandle(Thrd);  
            CloseHandle(res);  
            res = INVALID_HANDLE_VALUE;  
        }  
    }  
    delete[] s;  
    return res;  
}  
/**//*******************************************************/ 
{ ******************************************************* } 
{ *                 从内存中加载并运行exe               * } 
{ ******************************************************* } 
{ * 参数：                                                } 
{ * Buffer: 内存中的exe地址                               } 
{ * Len: 内存中exe占用长度                                } 
{ * CmdParam: 命令行参数(不包含exe文件名的剩余命令行参数）} 
{ * rocessId: 返回的进程Id                               } 
{ * 返回值： 如果成功则返回进程的Handle(ProcessHandle),   } 
{            如果失败则返回INVALID_HANDLE_VALUE           } 
{ ******************************************************* } 
 /*******************************************************/ 
HANDLE MemExecute(void *ABuffer, long Len, char *CmdParam, unsigned long *ProcessId)  
{  
    HANDLE res = INVALID_HANDLE_VALUE;  
    IMAGE_NT_HEADERS peH;  
    IMAGE_SECTION_HEADERS peSecH;  
    void *Ptr;  
    unsigned long peSz;  
    if(AlignPEToMem(ABuffer, Len, peH, peSecH, tr, peSz))  
    {  
        res = AttachPE(CmdParam, peH, peSecH, tr, peSz, *ProcessId);  
        VirtualFree(Ptr, peSz, MEM_DECOMMIT);  
    }  
    return res;  
}  
 
// 初始化  
class CInit  
{  
public:  
    CInit()  
    {  
        MyVirtualAllocEx = (pfVirtualAllocEx)GetProcAddress(GetModuleHandle("Kernel32.dll"), "VirtualAllocEx");  
    }  
}Init;  
 
 
 
 
int APIENTRY WinMain(HINSTANCE hInstance,  
                     HINSTANCE hPrevInstance,  
                     LPSTR     lpCmdLine,  
                     int       nCmdShow)  
{  
    HANDLE hFile = NULL;  
    hFile = ::CreateFile( "f://SourceFromCsdn2.exe" 
        , FILE_ALL_ACCESS  
        , 0  
        , NULL  
        , OPEN_EXISTING  
        , FILE_ATTRIBUTE_NORMAL  
        , NULL  
        );  
    if( hFile == INVALID_HANDLE_VALUE )  
        return -1;  
 
    ::SetFilePointer( hFile, 0, NULL, FILE_BEGIN);  
    DWORD dwFileSize = ::GetFileSize( hFile, NULL);  
 
    LPBYTE pBuf = new BYTE[dwFileSize];  
    memset( pBuf, 0, dwFileSize);  
 
    DWORD dwNumberOfBytesRead = 0;  
    ::ReadFile( hFile  
        , pBuf  
        , dwFileSize  
        , &dwNumberOfBytesRead  
        , NULL  
        );  
 
    ::CloseHandle(hFile);  
      
    unsigned long ulProcessId = 0;  
    MemExecute( pBuf, dwFileSize, "", &ulProcessId);  
    delete[] pBuf;  
 
      
    return 0;  
}

lionzl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PE 文件加载器实现
pureman_mega的博客
08-12 786
/** * peLoader.cpp * Windows APT Warfare * by aaaddress1@chroot.org */ #include <stdio.h> #include <windows.h> #pragma warning(disable : 4996) #define getNtHdr(buf) ((IMAGE_NT_HEADERS *)((size_t)buf + ((IMAGE_DOS_HEADER *)buf)->e_lfanew.
探索 PE 文件内存加载器：PEMemoryLoader
最新发布
gitblog_00068的博客
04-23 347
探索 PE 文件内存加载器：PEMemoryLoader 项目地址:https://gitcode.com/aplyc1a/PEMemoryLoader 在软件开发和逆向工程的世界中，PEMemoryLoader 是一个值得探索的开源工具。它允许你在不依赖于传统的文件系统加载方式的情况下，动态地在内存中加载PE（Portable Executable）文件。对于那些想要进行二进制分析、安全研究或者...
PE加载器——你爱的很沉重，可还是得看她想不想要
sxr__nc的博客
04-20 1130
构造PE加载器，简而言之就是手动把PE文件在内存中展开，并且如果有重定位表的话手动修复重定位表，以及修复IAT表等一些重要数据。 源码： #include<stdio.h> #include<windows.h> #include<winnt.h> int main() { HANDLE hFile = CreateFileA("你的测试程序的绝对地址", G...
【滴水逆向P77】加载进程（PE查看器）应用程序源码解析
WdIg-2023的博客
05-25 1450
在上一篇文章中讲解了通用控件，做了一个基本的加载进程（PE查看器）的应用程序项目，，大家如果有不懂的可以去看看，由于不是很了解Win32编程，所以有很多东西写出来了，但是不是很理解，所以今天专门来写一篇文章来详细了解一下其中使用到的API，函数，宏和结构体。
Windows加载器与模块初始化
lionzl的专栏
08-29 746
在最近的MSJ专栏中，我讨论了COM类型库和数据库访问层，例如ActiveX®数据对象（ADO）和OLE DB。MSJ专栏的长期读者可能认为我已经不行了（写不出技术层次比较高的文章了）。为了重振雄风，这个月我要讲解一部分Windows NT®加载器代码，它是操作系统和你的代码接合的地方。同时我也会向你演示一些获取加载器状态信息的高超技巧，以及可以用在Developer Studio®调试器中的相关...
32机器pe hook以及进程调试工具源代码
09-03
5. **进程attach**：调试器附着到一个正在运行的进程，以便观察和控制它的执行。在Windows中，`DebugActiveProcess`函数用于实现这一点，这对于调试工具的开发是必不可少的。 6. **进程字符串枚举**：遍历进程的...
pe读取器 读取各项文件可以修改成pe注入器
05-06
标题 "pe读取器 读取各项文件可以修改成pe注入器" 暗示了这个工具或技术涉及的是Windows操作系统中的Portable Executable (PE) 文件格式，以及如何将其读取器转换为PE注入器。PE文件格式是Windows平台上的可执行文件...
LordPE - 查看PE文件的强大工具 Win10系统可用
11-20
4. **附加功能**：除了核心功能，LordPE还包含了其他实用工具，如16Edit.DLL（16位编辑器）、procs.DLL和PROCS2.DLL（进程管理工具），以及REALIGN.DLL（内存对齐工具）等，满足不同场景下的需求。 5. **LordPlug....
DLL 加载的详细解析，
10-28
- **映像加载**：系统找到DLL后，将其映射到调用进程的虚拟地址空间，分配内存并加载DLL的PE（Portable Executable）头。 - **初始化过程**：DLL中的`.dllmain`入口点被调用，执行`DllMain`函数。此函数可以进行...
EXE连接和加载.rar
06-30
加载器会寻找合适的内存区域来放置PE文件，并进行相应的调整。 4. **重定位**：由于内存地址的变化，加载器需要对PE文件中的代码和数据进行重定位，以确保程序的正确执行。这涉及到处理重定位表，修正指令指针和...
windows在内存启动exe程序
02-23
无需windows的PE加载器，可将exe数据读入内存，直接在内存中启动。可启动任意后缀的exe程序。
win10可用x64进程替换代码
05-17
大多数windows病毒使用的进程替换技术都是32位进程替换，此代码为x64进程替换。 可将win10x64系统64位记事本进程替换为任意自写x64程序进程。
windows PE文件结构及其加载机制
热门推荐
liuyez123的博客
04-29 2万+
1. 概述PE文件的全称是Portable Executable，意为可移植的可执行的文件，常见的EXE、DLL、OCX、SYS、COM都是PE文件，PE文件是微软Windows操作系统上的程序文件（可能是间接被执行，如DLL）。它是1993年Windows NT系统引入的新可执行文件格式，到现在已经经过20多年了。虽然使用PE作为可执行文件格式的Windows操作系统已经更换了很多版本，其结构的变
Pe研究之：从内存中加载Pe文件(代码重定位，进程隐藏，代码注入)
mergerly的专栏
01-19 4995
<br />Pe研究之：<br /> <br />从内存中加载Pe文件<br /> <br />作者：Sunline              lisunlin0@yahoo.com.cn 日期：2007年7月<br />关键字：代码重定位，代码注入，远程代码, 加载exe文件, 加载dll文件<br />Remotthread, injectcode, relocation code, load dll from memory, load pe from memory load pe from memor
Win加载exe
weixin_30853329的博客
06-24 57
1、OD 加载exe --> 运行到用户代码，断下之后 --> 堆栈窗口 ESP 右击 数据窗口中跟随 --> 将数据窗口的下拉框拉到最下面 　　(或者直接看堆栈窗口) 　　如下图： 　　ZC: 此图效果为 XPsp3中的效果，有如下信息： 　　　　(1)、此时的 ESP值为 0012FFC4，其值 正好就是 调用kernel32.7C817067 (也就是即将调用 ...
反向进程注入及隐藏--动手做一个最简单的PELoader
08-16 1516
文章属性：原创文章提交：Luke0314 (msfocus_at_hotmail.com)动手做一个最简单的PELoaderLuke msfocus@hotmail.com一．废话最近因为公司的项目需要，顺带的学习了一点和PELoader相关的东西，恰见网上正在沸沸扬扬的谈论虚拟脱壳。本人不才，实在是没能力也没精力去写一个真正意义上的虚拟机，因此尝试做了一个简单而偷懒的PE加载器。这个PE加载器也
傀儡进程 插入
tony的专栏
10-25 1260
BOOL InjectProcess(LPTSTR VictimFile,LPTSTR InjectExe) { HANDLE hFile; DWORD dwFileSize; //文件大小 IMAGE_DOS_HEADER DosHeader; IMAGE_NT_HEADERS NtHeader; PROCESS_INFORMATION pi; STARTUPINFO si;
pe加载器加载mfc
08-27
然后，加载器会遍历PE文件的节表，加载每个节到内存中，并按照特定的顺序将节中的代码和数据复制到进程的地址空间中。 对于使用MFC开发的可执行文件，加载器会识别并加载与MFC相关的节。这些节包含MFC框架所需的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值