如何从零开始写一个加壳器

本篇内容介绍了“如何从零开始写一个加壳器”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

加壳原理

手工加壳

即我们向PE文件添加一个区段并将其设置为入口点，这样PE文件最开始执行的命令就是我们添加的区段也就是壳的指令，壳对加密区进行解密，对压缩区进行解压，将原本的EXE文件还原出来，然后跳转至原程序入口，程序照常运行。

首先生成一个打印hello的exe文件。

#include <stdio.h>

int main() {
printf("hello");
}

我们目前要干的事情是:以手动的形式向PE文件添加一个壳部分并设为程序入口，并使其能跳转回原入口。 那就来吧

用010editor打开我们的exe文件，启用exe模板分析。 我们首先修改其文件头numverofsection属性，这个属性用来定义当前PE文件存在多少个区段,因为我们要添加一个壳区段，所以我们将其加1变成6

在我们重载模板后我们就会在区段表发现多出来一个空的区段表

从上到下各个比较重要字段的意思是 \1. Name 表示该区段的名字 2.VirtualSize 表示在内存中的大小(一般内存对齐为0x1000) 3.virtualaddress 虚拟地址 即上一个区段的VirtualAddress + 上一个区段经内存对齐粒度对齐后的大小 4.sizeofdata 表示在文件中的大小（一般文件对齐为0x200) 5.pointertorawdata 文件的偏移 即 上一个区段的PointerToRawData + 上一个区段的SizeOfRawData

然后我们通过修改以上各值来定义一个新区段（壳区段)的属性

这里的virtualsize看着填一个就行了。 此时我们只是定义了区段表，但文件中并没有该区段存在，所以我们得创建该区段。 然后还要让区段可编辑，把下列值改为1即可

ctrl+shift+i 向目标文件偏移处插入0x200大小的空间。 这样一来，壳区段就创建好了。 然后我们还要修改 扩展头的SizeofImage 。将他改为最后一个区段的内存地址+内存大小

然后去掉随机基址选项。

找到扩展头的DLL属性字段，去掉随机基址，把40 81改为 00 81

接下来我们把程序入口点设置给壳区段。 使用LORDPE把入口点设为壳区块的虚拟地址

然后我们用OD打开这个文件

真正的加壳流程

刚刚提到的手工加壳，不过是最最基础的加壳原型而已，真正的加壳还涉及了代码加解密等操作.

真正写壳时一般写两个东西，加壳器和stub 所谓加壳器，就是给被加壳文件创造出一个新的区段， 在此同时将程序以某种方式加密，然后把stub放入新区段，并将程序入口点设为新区段的地址，然后在新区段结束后跳转回原程序入口。这个新区段我们叫做壳区段. 那么这个stub就是加壳后程序最先执行的命令了，它执行解密算法，将原程序释放出来。

基于c++的壳编写

https://github.com/ConsT27/PackingEXE/tree/master项目地址

Stub

stub是被植入到PE文件中的代码，它一般会干下面这些事情。

流程如下

0.合并data，rdata到text 1.PEB动态寻址，遍历导出表找到GetProcAddress函数 2.解密 3.修改入口点到原入口点

同时stub一般以dll的形式存在。原因是DLL通常自带重定位表，这在我们的移植过程中的重定位操作中提供了巨大的便利。

合并数据段

我们要移植stub过去，肯定需要移植代码段，也需要移植数据段。不如我们干脆把数据段合并到代码段，一块移植过去。

PEB动态寻址&导出表遍历找函数

为什么会用到这个技术编写stub？ 因为我们的stub.dll植入到宿主程序时，只有.text植入过去，没有对应的导入表，所以我们的stub无法直接调用一些API。所以我们需要动态获取各种API。 其中我采用的是PEB动态查询得到GetProcAddress函数，然后用GetProcAddress函数去获取各个API。

那么，什么是PEB？ PEB是一个微软还未完全公开作用的一个结构，它叫做 进程环境信息块 ，包含了进程的信息。其结构如下

typedef struct _PEB {
BYTE                          Reserved1[2];
BYTE                          BeingDebugged; //被调试状态
BYTE                          Reserved2[1];
PVOID                         Reserved3[2];
PPEB_LDR_DATA                 Ldr;
PRTL_USER_PROCESS_PARAMETERS  ProcessParameters;
BYTE                          Reserved4[104];
PVOID                         Reserved5[52];
PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
BYTE                          Reserved6[128];
PVOID                         Reserved7[1];
ULONG                         SessionId;
} PEB, *PPEB;
复制代码

我们关心的是PEB偏移0c得到的 PPEB_LDR_DATA Ldr; 它是一个指针，指向一个 PPEB_LDR_DATA 结构， 存放着已经被进程装在的动态链接库的信息

typedef struct _PEB_LDR_DATA
{
ULONG Length; // +0x00
BOOLEAN Initialized; // +0x04
PVOID SsHandle; // +0x08
LIST_ENTRY InLoadOrderModuleList; // +0x0c
LIST_ENTRY InMemoryOrderModuleList; // +0x14
LIST_ENTRY InInitializationOrderModuleList;// +0x1c
} PEB_LDR_DATA,*PPEB_LDR_DATA; // +0x24

PPEB_LDR_DATA 偏移1c是一个指向LIST_ENTRY InInitializationOrderModuleList结构的指针，这个结构 存放着指向模块初始化链表的头 ， 按顺序存放着PE装入运行时初始化模块信息，一般来说第一个链表结点是ntdll.dll,第二个链表结点就是kernel32.dll 。我们就在其中找到kernel32.dll的信息，获取其PE信息，得到导出表，循环遍历得到GetProcAddress函数。 另外，PEB地址再TEB偏移0x30处。用汇编语言表示就是 fs:[0x30]。

以上是PEB寻址的大致流程，另外还有一个比较关键的点是遍历kernel32.dll导出表获得GetProcAddress函数信息。 关于导出表可以看看这个文章https://blog.csdn.net/evileagle/article/details/12176797

首先一个导出表结构体如下

typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD   Characteristics;  //一般为0，没啥用
DWORD   TimeDateStamp;  //导出表生成的时间
WORD    MajorVersion;  //版本，也是0没啥用
WORD    MinorVersion;  //也是没啥用的版本信息一般为0
DWORD   Name;  //当前导出表的模块名字
DWORD   Base;  //序号表中序号的基数
DWORD   NumberOfFunctions;  //导出函数数量
DWORD   NumberOfNames;  //按名字导出函数的数量
DWORD   AddressOfFunctions;     // 序号表
DWORD   AddressOfNames;         // 名称表
DWORD   AddressOfNameOrdinals;  // 地址表
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;

其中序号表的起始序号是Base属性定义的值。以下是导出表的序号名称地址表的关系

我们的遍历流程是，先遍历名称表找到GetProcAddress在名称数组中的下标，然后根据这个下标去序号数组中找相同下标的序号值，然后以这个序号值为下标去找地址数组中的对应值。我们找到的地址表中的值就是函数入口

下面我把这段程序的汇编代码放出来。我是用内联汇编把这段代码塞进C++的

void GetApis()
{
HMODULE hKernel32;

_asm
{
pushad;
; //获取kernel32.dll的加载基址;
mov eax, fs: [0x30] ;  //得到PEB地址
mov eax, [eax + 0ch];  //获得LDR_PEB_DATA地址
mov eax, [eax + 0ch];  //获得LIST_ENTRY InLoadOrderModuleList;地址
mov eax, [eax];  //获得LIST_ENTRY InLoadOrderModuleList下一项的地址
mov eax, [eax];  /获得LIST_ENTRY InLoadOrderModuleList下下项即我们需要的LIST_ENTRY InInitializationOrderModuleList的地址
mov eax, [eax + 018h]; //获得kernel32.dll地址
mov hKernel32, eax;
mov ebx, [eax + 03ch];//获得kernel32.dll NT头RVA
add ebx, eax; //NT头的VA
add ebx, 078h; //获得区段表
mov ebx, [ebx]; //获得导出表RVA
add ebx, eax;  //导出表VA
lea ecx, [ebx + 020h];  
mov ecx, [ecx]; // ecx => 名称表的首地址(rva);
add ecx, eax; // ecx => 名称表的首地址(va);
xor edx, edx; // 作为索引(index)来使用.
_WHILE:;
mov esi, [ecx + edx * 4];//名称数组入口点rva，名称数组单位大小4字节
lea esi, [esi + eax];  //入口点VA
cmp dword ptr[esi], 050746547h;   //进行名称匹配，050746547h即小端存储的GetP
jne _LOOP;//不相等就跳入_LOOP段
cmp dword ptr[esi + 4], 041636f72h; //名陈匹配，rocA，以下依次为ddre，ss
jne _LOOP;
cmp dword ptr[esi + 8], 065726464h;
jne _LOOP;
cmp word  ptr[esi + 0ch], 07373h;
jne _LOOP;
mov edi, [ebx + 024h]; 
add edi, eax;  //获得序号表VA

mov di, [edi + edx * 2];  //获得序号数组中对应下标的地址，序号数组单位大小2字节
and edi, 0FFFFh;  //给di提位到32位，即给予edi 序号表中对应下标的地址
mov edx, [ebx + 01ch];  
add edx, eax;  //获得地址表
mov edi, [edx + edi * 4];  //获得地址数组中，序号对应的值，地址数组单位大小4字节
add edi, eax;   //获得GetProcAddress的入口地址
mov MyGetProcAddress, edi;  //赋值
jmp _ENDWHILE;  //END
_LOOP:;
inc edx; // ++index;
jmp _WHILE;
_ENDWHILE:;
popad;
}

解密

解密代码段。这段好写。

void Decrypt()
{
unsigned char* pText = (unsigned char*)g_conf.textScnRVA + 0x400000;//锁定到PE文件的text段（因为加壳时去掉了基址随机化，所以自信的把基址填成0x400000

DWORD old = 0;
MyVirtualProtect(pText, g_conf.textScnSize, PAGE_READWRITE, &old);//修改代码段的属性,注意我们这里使用了动态获得的
//解密代码段
for (DWORD i = 0; i < g_conf.textScnSize; i++)
{
pText[i] ^= g_conf.key;
}
//把属性修改回去
MyVirtualProtect(pText, g_conf.textScnSize, old, &old);

}

修改入口点

_asm    
{
mov eax, g_conf.srcOep;  //入口点是g_conf.srcOep
add eax, 0x400000
jmp eax
}

加壳器

加壳器流程如下

1.打开需要被加壳的PE文件 2.加载stub 3.加密代码段 4.添加新区段 5.stub重定位修复 6.stub移植 7.PE文件入口点修改 8.去随机基址 9.保存文件

以下的各个流程描述中会用到诸多自定义函数，我先贴上来吧。

诸多自定函数&结构体

//****************
//对齐处理
//time:2020/11/5
//****************
int AlignMent(_In_ int size, _In_ int alignment) {
return (size) % (alignment)==0 ? (size) : ((size) / alignment+1) * (alignment);
}

//***********************
//PE信息获取函数簇
//time:2020/11/2
//***********************
PIMAGE_DOS_HEADER GetDosHeader(_In_ char* pBase) {
return PIMAGE_DOS_HEADER(pBase);
}

PIMAGE_NT_HEADERS GetNtHeader(_In_ char* pBase) {
return PIMAGE_NT_HEADERS(GetDosHeader(pBase)->e_lfanew+(SIZE_T)pBase);
}

PIMAGE_FILE_HEADER GetFileHeader(_In_ char* pBase) {
return &(GetNtHeader(pBase)->FileHeader);
}

PIMAGE_OPTIONAL_HEADER32 GetOptHeader(_In_ char* pBase) {
return &(GetNtHeader(pBase)->OptionalHeader);
}

PIMAGE_SECTION_HEADER GetLastSec(_In_ char* pBase) {
DWORD SecNum = GetFileHeader(pBase)->NumberOfSections;
PIMAGE_SECTION_HEADER FirstSec = IMAGE_FIRST_SECTION(GetNtHeader(pBase));
PIMAGE_SECTION_HEADER LastSec = FirstSec + SecNum - 1;
return LastSec;
}

PIMAGE_SECTION_HEADER GetSecByName(_In_ char* pBase,_In_ const char* name) {
DWORD Secnum = GetFileHeader(pBase)->NumberOfSections;
PIMAGE_SECTION_HEADER Section = IMAGE_FIRST_SECTION(GetNtHeader(pBase));
char buf[10] = { 0 };
for (DWORD i = 0; i < Secnum; i++) {
memcpy_s(buf, 8, (char*)Section[i].Name, 8);
if (!strcmp(buf, name)) {
return Section + i;
}
}
return nullptr;
}

typedef struct _StubConf
{
DWORD srcOep;       //入口点
DWORD textScnRVA;   //代码段RVA
DWORD textScnSize;  //代码段的大小
DWORD key;          //解密密钥
}StubConf;

struct StubInfo
{
char* dllbase;          //stub.dll的加载基址
DWORD pfnStart;         //stub.dll(start)导出函数的地址
StubConf* pStubConf;    //stub.dll(g_conf)导出全局变量的地址
};

打开PE文件

这里采用的方法是利用CreateFileA函数。同时这个函数还抛出了一个指向PE文件大小的指针

char* GetFileHmoudle(_In_ const char* path,_Out_opt_ DWORD* nFileSize) {
//打开一个文件并获得文件句柄
HANDLE hFile = CreateFileA(path,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
//获得文件大小
DWORD FileSize = GetFileSize(hFile, NULL);
//返回文件大小到变量nFileSize
if(nFileSize)
*nFileSize = FileSize;
//申请一片大小为FileSize的内存并将指针置于首位
char* pFileBuf = new CHAR[FileSize]{ 0 };
//给刚刚申请的内存读入数据
DWORD dwRead;
ReadFile(hFile, pFileBuf, FileSize, &dwRead, NULL);
CloseHandle(hFile);
return pFileBuf;
}

加载STUB

void LoadStub(_In_ StubInfo* pstub) {
pstub->dllbase = (char*)LoadLibraryEx(L"F:\\stubdll.dll", NULL, DONT_RESOLVE_DLL_REFERENCES);
pstub->pfnStart = (DWORD)GetProcAddress((HMODULE)pstub->dllbase, "Start");  //获得stub的入口函数Start(自己定义在stub中的一个函数
pstub->pStubConf = (StubConf*)GetProcAddress((HMODULE)pstub->dllbase, "g_conf");
}
//不仅加载了stub，还获得了stub抛出的用于收集信息的全局结构体（g_conf,是一个stub抛出的结构体，用于获取信息，结构如下）
typedef struct _StubConf
{
DWORD srcOep;       //入口点
DWORD textScnRVA;   //代码段RVA
DWORD textScnSize;  //代码段的大小
DWORD key;          //解密密钥
}StubConf;

加密代码段

DWORD textRVA = GetSecByName(PeHmoudle, ".text")->VirtualAddress;
DWORD textSize = GetSecByName(PeHmoudle, ".text")->Misc.VirtualSize;
Encry(PeHmoudle,pstub);
void Encry(_In_ char* hpe,_In_ StubInfo pstub) {
//获取代码段首地址
BYTE* TargetText = GetSecByName(hpe, ".text")->PointerToRawData + (BYTE*)hpe;
//获取代码段大小
DWORD TargetTextSize = GetSecByName(hpe, ".text")->Misc.VirtualSize;
//加密代码段
for (int i = 0; i < TargetTextSize; i++) {
TargetText[i] ^= 0x15;
}
pstub.pStubConf->textScnRVA = GetSecByName(hpe, ".text")->VirtualAddress;
pstub.pStubConf->textScnSize = TargetTextSize;
pstub.pStubConf->key = 0x15;
}
//加密代码段，并给予了stub一些信息

添加新区段

char* AddSec(_In_ char*& hpe, _In_ DWORD& filesize, _In_ const char* secname, _In_ const int secsize) {
GetFileHeader(hpe)->NumberOfSections++;
PIMAGE_SECTION_HEADER pesec = GetLastSec(hpe);
//设置区段表属性
memcpy(pesec->Name, secname, 8);
pesec->Misc.VirtualSize = secsize;
pesec->VirtualAddress = (pesec - 1)->VirtualAddress + AlignMent((pesec - 1)->SizeOfRawData,GetOptHeader(hpe)->SectionAlignment);
pesec->SizeOfRawData = AlignMent(secsize, GetOptHeader(hpe)->FileAlignment);
pesec->PointerToRawData = AlignMent(filesize,GetOptHeader(hpe)->FileAlignment);
pesec->Characteristics = 0xE00000E0;
//设置OPT头映像大小
GetOptHeader(hpe)->SizeOfImage = pesec->VirtualAddress + pesec->SizeOfRawData;
//扩充文件数据
int newSize = pesec->PointerToRawData + pesec->SizeOfRawData;
char* nhpe = new char [newSize] {0};
//向新缓冲区录入数据
memcpy(nhpe, hpe, filesize);
//缓存区更替
delete hpe;
filesize = newSize;
return nhpe;
}

stub重定位

好家伙，这个东西稍有不慎就会让整个程序拉跨掉（过来人的忠告 为什么需要stub重定位呢？因为我们的stub最开始是加载在内存中的，它的许多指令如跳转到的地址是按内存为基准确定的，但是我们需要把他移植进文件，所以它的代码里许多地址就是错误的，我们需要对这些地址进行处理，即重定位，使其以宿主程序为标准进行地址修复。 可能我表述的不是很清楚

举个例子吧，比如stub在加载进内存时，有一条跳转指令时jmp 12345678, 如果我们不处理就把这条指令移植进PE文件，那么PE文件执行到此处时就会跳转到12345678，此时的12345678地址可能就已经不是PE文件加载的内存区间了，从而程序会崩溃。所以要修复。根据stub的重定位表进行修复。 重定位表就是记录哪些地址的数据需要被修复的，我们遍历这些地址进行修复即可。 如果以下代码看起来吃力，可以先去了解一下重定位表

void FixStub(DWORD targetDllbase, DWORD stubDllbase,DWORD targetNewScnRva,DWORD stubTextRva )
{
//找到stub.dll的重定位表
DWORD dwRelRva = GetOptHeader((char*)stubDllbase)->DataDirectory[5].VirtualAddress;
IMAGE_BASE_RELOCATION* pRel = (IMAGE_BASE_RELOCATION*)(dwRelRva + stubDllbase);

//遍历重定位表
while (pRel->SizeOfBlock)
{
struct TypeOffset
{
WORD offset : 12;
WORD type : 4;

};
TypeOffset* pTypeOffset = (TypeOffset*)(pRel + 1);
DWORD dwCount = (pRel->SizeOfBlock - 8) / 2;    //需要重定位的数量
for (int i = 0; i < dwCount; i++)
{
if (pTypeOffset[i].type != 3)
{
continue;
}
//需要重定位的地址
DWORD* pFixAddr = (DWORD*)(pRel->VirtualAddress + pTypeOffset[i].offset + stubDllbase);

DWORD dwOld;
//修改属性为可写
VirtualProtect(pFixAddr, 4, PAGE_READWRITE, &dwOld);
//去掉dll当前加载基址
*pFixAddr -= stubDllbase;
//去掉默认的段首RVA
*pFixAddr -= stubTextRva;
//换上目标文件的加载基址
*pFixAddr += targetDllbase;
//加上新区段的段首RVA
*pFixAddr += targetNewScnRva;
//把属性修改回去
VirtualProtect(pFixAddr, 4, dwOld, &dwOld);
}
//切换到下一个重定位块
pRel = (IMAGE_BASE_RELOCATION*)((DWORD)pRel + pRel->SizeOfBlock);
}

stub移植

这个简单，没啥说的

memcpy(GetLastSec(PeNewHmoudle)->PointerToRawData+ PeNewHmoudle,
GetSecByName(pstub.dllbase, ".text")->VirtualAddress+pstub.dllbase,
GetSecByName(pstub.dllbase,".text")->Misc.VirtualSize);

入口点修改

GetOptHeader(PeNewHmoudle)->AddressOfEntryPoint =
pstub.pfnStart-(DWORD)pstub.dllbase-GetSecByName(pstub.dllbase,".text")->VirtualAddress+GetLastSec(PeNewHmoudle)->VirtualAddress;

去随机基址

不去掉随机基址，加载基址就是不固定的，不方便操作

GetOptHeader(PeNewHmoudle)->DllCharacteristics &= (~0x40);

保存文件

void SaveFile(_In_ const char* path, _In_ const char* data, _In_ int FileSize) {
HANDLE hFile = CreateFileA(
path,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
DWORD Buf = 0;
WriteFile(hFile, data, FileSize, &Buf,NULL);
CloseHandle(hFile);
}

“如何从零开始写一个加壳器”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！