偶然翻了一下手机日历,原来今天是夏至啊,时间过的真快。ISCC的比赛已经持续了2个多月了,我也跟着比赛的那些题目学了2个月.......虽然过程很辛苦,但感觉还是很幸运的,能在大三的时候遇到ISCC,不管怎样,对我来说都会是一个很好的锻炼机会。

在做综合关的逆向破解的题目,遇到了很多蛋疼的问题,磕磕碰碰把《加密与解密》看完了。还是老习惯,把这1个多星期以后学到的,想到的做一个总结,希望能有一个思想上的提高,也希望能对其他人有一个借鉴的效果吧。这里想起lenus大神的一句话:

Hacker的精神里面除了学习(learn)的第一精神以外,还应该是共享(share)的精神。

好,废话不多说,开始吧。

1. 逆向?破解?

一开始接触逆向,我直接是使用的一些加壳脱壳工具,都是鼠标点一下就出来了,这段时间深入了解了逆向的原理之后,我感觉逆向是一个综合性很强的技术,中间还需要windows编程,PE结果,汇编等知识。

对于脱壳,我的理解是:脱壳不意味着它字面上的意思,把外壳直接拿掉,然后就扔掉(像吃水果一样),脱壳本质上是一个高级的crack技术,也就是绕过破解。

这是一张关于壳的图示:

而我们不管用lordPE, procDump, 还是手工脱壳也好,其实本质上就是要改变程序的执行流,让程序跳过头部(实际中不一定是头部,这里只是逻辑上的)的一段壳代码,而直接来到原程序的入口代码处,也就是常说的OEP,那问题就来了,那脱壳就这么简单?

当然不是,我个人感觉,脱壳并不仅仅是改变程序执行流这么简单,因为被加过壳的程序往往IAT,重定位表,节区都被加密,压缩处理过了。如果你直接强行跳转过来,程序也是不能执行的。所以,网上常说的找OEP的原理就在这里。为什么要找OEP呢?其实本质上来说,这并不是最重要的,不要被这些形式上的东西框住了思维,我们从原理上思考,一个程序要运行,无非需要几种东西:

1. 可以执行的机器码

2. IAT

3. 重定位表(DLL)

4. 资源代码(不太重要就是了,因为并不影响逆向的结果)

转换了思维之后,我就豁然开朗了,我们要做的就是找到代码中的某一行,恰好已经全部完成了代码的解压缩和解密,IAT的重写,重定位表的重写,做好这些事后,我们就可以dump下来了,至于是不是OEP其实不是很重要,所谓的找OEP是因为,一般情况下在OEP的时候恰好都满足了上面的条件,而且也比较好找到,所以,OEP是dump的首选,如果你理解了原理,这么做也没有错。

第二点就是:为什么要用ImportREC来重建IAT表呢?它的原理又是什么呢?

这里首先要从加壳的原理说起,不管你是UPX压缩壳,ASProtect,穿山甲加密壳,还是VMP虚拟机壳...基本上来说都会破坏原本的IAT,将原本的IAT移到一个新的节区里面并加密等处理,然后构建自己的IAT表,并修改PE头。为什么要这么做呢?

因为壳必须保证它能调用到自己需要的函数,但是原程序并不能保证这点,所以壳必须自己构造自己的IAT三剑客:

调用LoadLibrary将dll文件映射到调用进程的地址空间中
调用GetModualHandle获得dll模块句柄
调用GetProcAddress获取输入函数的地址

一般壳程序都会构造这三个API,然后重建自己的IAT表,这样壳程序就能保证调用到自己需要的所有winAPI了。

而我们脱壳的是内存中的映像,即使这时候原程序的IAT已经恢复过来了(解压缩,解密),但是位置已经变了,原程序无法直接调用了。而ImportREC的作用就是找到这里API对用RVA,然后在一段空的地方重建这些结构,逆向构造出一个IAT出来,然后修改PE头,完成IAT的修复。明白了原理,自己手工修复IAT也是一样的。

修复重定位表和资源表的原理也是一样的,就不在详述了。

下面,我们通过一个dump实例的编程过程来深刻的理解一个dump的思想。

接下来的程序是我们对看雪上的一篇帖子的学习笔记,是lenus大神的脱壳教程,我这里就当是做一个学习笔记。

一:dump小程序的目标

对于dump来说,他的英文翻译就是“转存”。也就是说把内存中或者其他的输入转存到另一个位置,当然对于我们现在说的dump就是把内存中运行的PE进程的数据,从内存中抓取出来,然后在用文件的形式保存下来。

根据上面的分析我们基本上得到了一个这样的思维。Dump程序要做的事分几个基本的步骤:

1.  在系统中找到目标进程
2.  在进程中确定进程的大小imagesize
3.  把进程中的数据保存到文件

Code:

resource.h

#define ID_FLESH                        2
#define IDD_DIALOG1                     101
#define ICO_MAIN                        103
#define IDC_PROCESS                     1028
#define IDC_CORRECT                     1033

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        105
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1034
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

#include <windows.h>
#include <tlhelp32.h>
#include "resource.h"

BOOL CALLBACK DlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
BOOL GetProcessListFunc(HWND hDlg,HWND hWindList); // 列出各个进程的函数,刷新时也用到
LPCTSTR SaveAsFunc(HWND hDlg);                     //通用对话框函数
BOOL DumpFunc(HWND hDlg,HWND hWindList);           // 主要的dump函数,调用其他的小功能函数实现其功能
BOOL CreateDumpFile(HWND hDlg,LPCTSTR Dump_Name,HGLOBAL hMem);    //生成dump文件函数,把dump的东西写到磁盘上
HGLOBAL ReadProcess(HWND hDlg,DWORD IDProcess);      //读取目标进程空间,放置到本空间申请的堆中
int GetSizeOfImage(HWND hDlg,DWORD IDProcess);       // 获取pe文件的SizeOfImage
BOOL CheckPEFunc(HWND hDlg,HANDLE hProcess);        //检查pe文件的完整性
BOOL CorrectSizeFunc(HWND hDlg,HWND hWindList);                   //纠正文件的大小
LPCTSTR GetFilePath(HWND hDlg,DWORD IDProcess);//获取目标exe的绝对路径
BOOL ModifySectionFunc(HWND hDlg,LPCTSTR Dump_Name);//修改文件的节表使其RA=RVA ,RS=RVS
BOOL CopyThePEHead(HWND hDlg,LPCTSTR Dump_Name);   //把原来PE文件的头部复制到dump文件中

////////////////全局变量/////////////////////
int sizeoffile=0;
int sizeofimage=0;              //当使用了CorrectSizeFunc后这个有了具体数值,就不需要再次获取了
int BaseAddress=0x400000;      
DWORD ID=0;                   //这个是用来控制进程的切换的
///////////////////////////////

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                                            PSTR szCmdLine, int iCmdShow)
{
    DialogBoxParam (hInstance,MAKEINTRESOURCE(IDD_DIALOG1),NULL,DlgProc,(LPARAM)hInstance);
    return TRUE;
}

BOOL CALLBACK DlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{
        static HINSTANCE hInstance;
        static HWND hWindList;

switch (message)
         {
        case    WM_CLOSE:
                EndDialog (hDlg, 0) ;
                   return TRUE ;
         case     WM_INITDIALOG :
                hInstance = (HINSTANCE) lParam;
                SendMessage(hDlg,WM_SETICON,ICON_BIG,(LPARAM)LoadIcon(hInstance,MAKEINTRESOURCE(ICO_MAIN)));
                hWindList = GetDlgItem(hDlg,IDC_PROCESS);
                if(!GetProcessListFunc(hDlg,hWindList))
                {
                    MessageBox(hDlg,TEXT("Fail to get the process"),TEXT("Sorry"),MB_OK | MB_ICONSTOP);
                    EndDialog(hDlg,0);            
                }
                return TRUE ;
                
         case     WM_COMMAND :
                  switch (LOWORD (wParam))
                  {
                      case     IDOK :
                                   DumpFunc(hDlg,hWindList);
                                   return TRUE ;
                    case    ID_FLESH:
                                if(!GetProcessListFunc(hDlg,hWindList))
                                {
                                    MessageBox(hDlg,TEXT("Fail to get the process"),TEXT("Sorry"),MB_OK | MB_ICONSTOP);
                                    EndDialog(hDlg,0);            
                                }
                                return TRUE;

case    IDC_CORRECT:
                                if(!CorrectSizeFunc(hDlg,hWindList))
                                    MessageBox(hDlg,TEXT("The correct size function is faile..."),TEXT("Fail..."),MB_OK | MB_ICONWARNING);
                                return TRUE;

}

break ;
     }
     return FALSE ;
}

BOOL GetProcessListFunc(HWND hDlg,HWND hWindList)
{
    //此函数是进程列表的作用,在此不作过多介绍
    HANDLE hProcessSnap = NULL;
    PROCESSENTRY32 pe32   = {0};
    SendMessage(hWindList,LB_RESETCONTENT,0,0);
    pe32.dwSize = sizeof(PROCESSENTRY32);

hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)  
    return FALSE;

if (!Process32First(hProcessSnap, &pe32))
    {
       CloseHandle (hProcessSnap);
       return FALSE;
    }
    do
    {
        WPARAM tmp=(WPARAM)SendMessage(hWindList,LB_ADDSTRING,0,(LPARAM)pe32.szExeFile);
        SendMessage(hWindList,LB_SETITEMDATA,tmp,(LPARAM)pe32.th32ProcessID);
    }
    while (Process32Next(hProcessSnap, &pe32));
    CloseHandle (hProcessSnap);
    
    return TRUE;

}

BOOL DumpFunc(HWND hDlg,HWND hWindList)
{
    HGLOBAL hMem;
    LPCTSTR Dump_Name=NULL;                    //感觉有点问题,这个只是指针没有开辟足够的空间。
                                              //从数组(规定好的)到指针(未规定好的)就可以,
                                              //从指针到数组就不可以
    WPARAM tmp=(WPARAM)SendMessage(hWindList,LB_GETCURSEL,0,0);
    if (tmp==LB_ERR)
    {
        MessageBox(hDlg,TEXT("Please choose a process..."),TEXT("oh...no,no,no..."),MB_OK);
        return FALSE;
    }
    DWORD IDProcess=SendMessage(hWindList,LB_GETITEMDATA,tmp,0); //获得此列单里面的进程ID
    ID=IDProcess;
    hMem=ReadProcess(hDlg,IDProcess);
    if(hMem)                                   //如果返回的hMen不正确说明没有正确的申请到空间
    {
        if(sizeoffile!=0)                     //没有大小的dump 是没有意义的
        {
            Dump_Name=SaveAsFunc(hDlg);       //要保存的文件名
            if(Dump_Name)                     //如果得到的文件名是空就不继续执行
            {
                CreateDumpFile(hDlg,Dump_Name,hMem); //把数据写入文件中
                GlobalFree(hMem);                    //资源是可贵的,释放空间
            }
        }
    }
        
        return TRUE;
}

LPCTSTR SaveAsFunc(HWND hDlg)
{
    //获取你要保存的文件名,默认为dumped.exe
    HANDLE hFile;
    static    char szFileName[MAX_PATH]="dumped";
    OPENFILENAME stOF={0};
    stOF.hwndOwner=hDlg;
    stOF.lStructSize=sizeof(stOF);
    stOF.lpstrFilter="*.*";
    stOF.lpstrDefExt="exe";
    stOF.nMaxFile=MAX_PATH;    
    stOF.lpstrFile=szFileName;
    if(!GetSaveFileName(&stOF))
            return FALSE;
    char szBuffer[100];
    char szMsg[]="%s 已存在。要替换它吗?";
    wsprintf(szBuffer,szMsg,szFileName);
    hFile=CreateFile(szFileName,GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile != INVALID_HANDLE_VALUE)
    {
       if(IDNO==MessageBox(hDlg,szBuffer,TEXT("另存为"),MB_YESNO | MB_ICONWARNING))
       {
           CloseHandle(hFile);
           return FALSE;
       }
    }

CloseHandle(hFile);
    return szFileName;
}

BOOL CreateDumpFile(HWND hDlg,LPCTSTR Dump_Name,HGLOBAL hMem)
{
    //创建一个新的dump文件
    HANDLE hFile=CreateFile(Dump_Name,GENERIC_WRITE | GENERIC_READ,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile==INVALID_HANDLE_VALUE)
    {

MessageBox(hDlg,TEXT("Maybe you have alreadly had a this name file:("),
                   TEXT("Can't create a file"),MB_OK | MB_ICONWARNING);
        GlobalFree(hMem);
        return FALSE;
    }
    int NumberOfBytesWritten;
    WriteFile(hFile,hMem,sizeoffile,(LPDWORD)&NumberOfBytesWritten,NULL);    //注意这个函数第三个参数是必要的!
    CloseHandle(hFile);
    if(!CopyThePEHead(hDlg,Dump_Name))
    {
        //复制PE头
        MessageBox(hDlg,TEXT("复制PE头失败了"),TEXT("失败了"),MB_OK | MB_ICONWARNING);
    }    
    if(!ModifySectionFunc(hDlg,Dump_Name))
    {
        //节表对齐
        MessageBox(hDlg,TEXT("修改节表失败了"),TEXT("失败了"),MB_OK | MB_ICONWARNING);
    }
    MessageBox(hDlg,TEXT("文件已经dump成功"),TEXT("Lenus'ExeDump"),MB_OK | MB_ICONINFORMATION);//胜利的号角!    
    return TRUE;
}

HGLOBAL ReadProcess(HWND hDlg,DWORD IDProcess)
{
    //此函数是读取目标进程的空间,并把他写入到自己内存空间里面的一个内存块中
    
    HANDLE hProcess=OpenProcess(PROCESS_ALL_ACCESS,0,IDProcess);//使用上面获得的进程id
    if(!hProcess)
    {
        MessageBox(hDlg,TEXT("I can't open the process:("),TEXT("oh my god.."),MB_OK);
        return FALSE;
    }
    if(sizeofimage==0 || ID!=IDProcess)                 
    //当更换当前的进程或者没有使用修正的功能的时候需要重新的获取
    //由于不知道在更换选项的时候会发出什么消息,所以只能这么干 so foolish!!
    {
            sizeofimage=GetSizeOfImage(hDlg,IDProcess);
    }
    
    if(!sizeofimage)
    {
        return FALSE;
    }
    //为了以防万一,让sizeofimage增加一个文件对齐度。

if(!(sizeofimage%0x1000))                          //如果是文件对齐度的整数倍的时候就不处理
        sizeoffile=sizeofimage;
    else
        sizeoffile=(sizeofimage/0x1000+1)*0x1000;     //如果不是就增加一个文件对齐度
    
    //申请一个文件空间的内存块
    static HGLOBAL hMem=0;
    hMem=GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,sizeoffile);
    if(!hMem)
    {
        MessageBox(hDlg,TEXT("I think i have enough space to get!:("),TEXT("Wrong!!!"),MB_OK | MB_ICONSTOP);
        return FALSE;
    }
    //将这个pe文件在内存中的大小全部读到申请的块中
    
    DWORD NumberOfBytesReadorWrite;
    if(!ReadProcessMemory(hProcess,(LPCVOID)BaseAddress,hMem,sizeofimage,&NumberOfBytesReadorWrite))
    {
        MessageBox(hDlg,TEXT("I can't read the process:("),TEXT("oh my god.."),MB_OK);
        return FALSE;
    }

CloseHandle(hProcess);   //有开始就,有关闭
    Sleep(200);               //等待一会
    return hMem;

}

int GetSizeOfImage(HWND hDlg,DWORD IDProcess)
{
    //这个函数的作用是获取SizeOfImage的数值
    //当函数执行失败返回的是0
    //成功返回的是非0
    HANDLE hModuleSnap = NULL;
    MODULEENTRY32 stModE  = {0};
    stModE.dwSize = sizeof(MODULEENTRY32);
    hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,IDProcess);  //快照,对本进程中所有的模块进行snap

if (hModuleSnap == INVALID_HANDLE_VALUE)
    {
        MessageBox(hDlg,TEXT("The Module snapshot can't get!"),TEXT("Error!"),MB_OK | MB_ICONSTOP);
        return FALSE;    //返回0
    }
    if (!Module32First(hModuleSnap, &stModE))
    {
       MessageBox(hDlg,TEXT("The Module32First can't work!"),TEXT("Error!"),MB_OK | MB_ICONSTOP);
       CloseHandle (hModuleSnap);
       return FALSE;
    }
    CloseHandle (hModuleSnap);
    return stModE.modBaseSize;//初始化为0
}

BOOL CheckPEFunc(HWND hDlg,HANDLE hProcess)
{
    //检查pe文件,检查两个标志
    //如果不是pe文件那么会迫使GetSizeOfImage直接返回
    //下面不是重点,所以不介绍了
    int BaseAddress=0x400000;
    IMAGE_DOS_HEADER DosHead;
    _IMAGE_NT_HEADERS NtHead;

if(!ReadProcessMemory(hProcess,(LPCVOID)BaseAddress,&DosHead.e_magic,2,NULL))
    {
        MessageBox(hDlg,TEXT("I can't read the IMAGE_DOS_SIGNATURE:("),TEXT("oh my god.."),MB_OK);
        return FALSE;
    }

if(DosHead.e_magic != IMAGE_DOS_SIGNATURE)
    {
        return FALSE;
    }

if(!ReadProcessMemory(hProcess,(LPCVOID)(BaseAddress+0x3c),&DosHead.e_lfanew,4,NULL))
    {
        MessageBox(hDlg,TEXT("I can't read the e_lfanew:("),TEXT("oh my god.."),MB_OK);
        return FALSE;
    }

if(!ReadProcessMemory(hProcess,(LPCVOID)(BaseAddress+DosHead.e_lfanew),&NtHead.Signature,4,NULL))
    {
        MessageBox(hDlg,TEXT("I can't read the e_lfanew:("),TEXT("oh my god.."),MB_OK);
        return FALSE;
    }

if(NtHead.Signature != IMAGE_NT_SIGNATURE)
    {
        return FALSE;
    }
    return TRUE;

}

BOOL CorrectSizeFunc(HWND hDlg,HWND hWindList)
{
    //函数能获取文件的PE头部的SizeOfImage,作为正确的SizeOfImage
    LPCTSTR File_Name=NULL;                   
    WPARAM tmp=(WPARAM)SendMessage(hWindList,LB_GETCURSEL,0,0);
    if (tmp==LB_ERR)
    {
        MessageBox(hDlg,TEXT("Please choose a process..."),TEXT("oh...no,no,no..."),MB_OK);
        return FALSE;
    }
    DWORD IDProcess=SendMessage(hWindList,LB_GETITEMDATA,tmp,0); //获得此列单里面的进程ID
    ID=IDProcess;//全局变量ID的作用是控制在不同的进程的切换
    File_Name=GetFilePath(hDlg,IDProcess);
    if(!File_Name)
        return FALSE;
    //打开文件
    HANDLE  hFile;
    hFile=CreateFile(File_Name,GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);

if (hFile == INVALID_HANDLE_VALUE )
    {
        return FALSE ;
    }

//创建文件映射内核对象
    HANDLE hMapping;
    hMapping =    CreateFileMapping (hFile, NULL, PAGE_READONLY,0,0,NULL);
    if (hMapping == NULL )
    {
        CloseHandle (hFile ) ;
        return FALSE;
    }
    //创建文件视图
    LPVOID ImageBase ;
    ImageBase =MapViewOfFile(hMapping,FILE_MAP_READ,0,0,0) ;
    if (ImageBase == NULL)
    {
        CloseHandle (hMapping) ;
        return FALSE;
    }
    //下面的代码就是从文件的PE头找到SizeOfImage的
    PIMAGE_DOS_HEADER DosHead = NULL ;
    PIMAGE_NT_HEADERS32 pNtHeader = NULL ;
    PIMAGE_FILE_HEADER pFileHeader = NULL ;
    PIMAGE_OPTIONAL_HEADER pOptionalHeader = NULL ;
    PIMAGE_SECTION_HEADER pSectionHeader = NULL ;
    DosHead=(PIMAGE_DOS_HEADER)ImageBase;
    pNtHeader = ( PIMAGE_NT_HEADERS32 ) ((DWORD)ImageBase + DosHead->e_lfanew ) ;
    pOptionalHeader = &pNtHeader->OptionalHeader;    
    sizeofimage=(int)pOptionalHeader->SizeOfImage;
    //找到了以后,输出结果
    char szBuffer[100];
    char szMsg[]="原来的image size是:%08X\n修整的image size是:%08X";
    wsprintf(szBuffer,szMsg,GetSizeOfImage(hDlg,IDProcess),sizeofimage);
    MessageBox(hDlg,szBuffer,TEXT("纠正结果"),MB_OK );
    CloseHandle (hMapping);
    CloseHandle (hFile) ;
    Sleep(200);
    return TRUE;
}

LPCTSTR GetFilePath(HWND hDlg,DWORD IDProcess)
{
    //此函数获得目标进程的绝对路径
    //如果获取失败返回NULL
    HANDLE hModuleSnap = NULL;
    MODULEENTRY32 a   = {0};
    a.dwSize = sizeof(MODULEENTRY32);
    hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,IDProcess);  //快照,对本进程中所有的模块进行snap

if (hModuleSnap == INVALID_HANDLE_VALUE)
    {
        MessageBox(hDlg,TEXT("The Module snapshot can't get!"),TEXT("Error!"),MB_OK | MB_ICONSTOP);
        return FALSE;    //返回0
    }
    if (!Module32First(hModuleSnap, &a))
    {
       MessageBox(hDlg,TEXT("The Module32First can't work!"),TEXT("Error!"),MB_OK | MB_ICONSTOP);
       CloseHandle (hModuleSnap);
       return FALSE;
    }
    CloseHandle (hModuleSnap);
    return a.szExePath;

}

BOOL ModifySectionFunc(HWND hDlg,LPCTSTR Dump_Name)
{
    //此函数的将修改dump下来的exe,使其RA=RVA ,RS=RVS
    //首先是打开dump文件
    HANDLE hFile=CreateFile(Dump_Name,GENERIC_WRITE | GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile==INVALID_HANDLE_VALUE)
    {

MessageBox(hDlg,TEXT("I can open the dump file..."),TEXT("Error!!"),MB_OK | MB_ICONWARNING);
        return FALSE;
    }
    //下面移动到节表前面
    IMAGE_DOS_HEADER myDosHeader;
    DWORD NumberOfBytesReadorWrite;    
    ReadFile(hFile,(LPVOID)&myDosHeader,sizeof(IMAGE_DOS_HEADER),&NumberOfBytesReadorWrite,NULL);
    SetFilePointer(hFile,myDosHeader.e_lfanew+sizeof(DWORD),NULL,FILE_BEGIN);
    IMAGE_FILE_HEADER myNtHeader;
    ReadFile(hFile,(LPVOID)&myNtHeader,sizeof(IMAGE_FILE_HEADER),&NumberOfBytesReadorWrite,NULL);
    int nSectionCount;
    nSectionCount = myNtHeader.NumberOfSections;             // 保存Section个数
    // 过了IMAGE_NT_HEADERS结构就是IMAGE_SECTION_HEADER结构数组了,注意是结构数组,有几个Section该结构就有几个元素
    // 这里动态开辟NumberOfSections个内存来存储不同的Section信息
    IMAGE_SECTION_HEADER *pmySectionHeader = (IMAGE_SECTION_HEADER *)calloc(nSectionCount, sizeof(IMAGE_SECTION_HEADER));
    SetFilePointer(hFile,myDosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS),NULL,FILE_BEGIN);
    ReadFile(hFile,(LPVOID)pmySectionHeader,sizeof(IMAGE_SECTION_HEADER)*nSectionCount,
             &NumberOfBytesReadorWrite,NULL);
    //移动回到节表的开始,准备写入
    SetFilePointer(hFile,myDosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS),NULL,FILE_BEGIN);
    for (int i = 0; i < nSectionCount; i++, pmySectionHeader++)
    {
        //将RA=RVA ,RS=RVS
        pmySectionHeader->SizeOfRawData=pmySectionHeader->Misc.VirtualSize;
        pmySectionHeader->PointerToRawData=pmySectionHeader->VirtualAddress;
        //将修改好的数值写回
        WriteFile(hFile,(LPVOID)pmySectionHeader,sizeof(IMAGE_SECTION_HEADER),&NumberOfBytesReadorWrite,NULL);
    }
    // 恢复指针
    pmySectionHeader -=nSectionCount;

if (pmySectionHeader != NULL)          // 释放内存
    {
      free(pmySectionHeader);
      pmySectionHeader = NULL;
    }

// 最后不要忘记关闭文件
    CloseHandle(hFile);
    return TRUE;
}

BOOL CopyThePEHead(HWND hDlg,LPCTSTR Dump_Name)
{
    //此函数的作用是将原来PE文件的PE头部完整的copy到dump文件中
    HANDLE hFile=CreateFile(GetFilePath(hDlg,ID),GENERIC_READ,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile==INVALID_HANDLE_VALUE)
    {

MessageBox(hDlg,TEXT("I can open the object file..."),TEXT("Error!!"),MB_OK | MB_ICONWARNING);
        return FALSE;
    }
    //下面移动到节表前面
    IMAGE_DOS_HEADER myDosHeader;
    DWORD NumberOfBytesReadorWrite;    
    ReadFile(hFile,(LPVOID)&myDosHeader,sizeof(IMAGE_DOS_HEADER),&NumberOfBytesReadorWrite,NULL);
    SetFilePointer(hFile,myDosHeader.e_lfanew+sizeof(DWORD),NULL,FILE_BEGIN);
    IMAGE_FILE_HEADER myNtHeader;
    ReadFile(hFile,(LPVOID)&myNtHeader,sizeof(IMAGE_FILE_HEADER),&NumberOfBytesReadorWrite,NULL);
    IMAGE_SECTION_HEADER mySectionHeader;
    SetFilePointer(hFile,myDosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS),NULL,FILE_BEGIN);
    ReadFile(hFile,(LPVOID)&mySectionHeader,sizeof(IMAGE_SECTION_HEADER),&NumberOfBytesReadorWrite,NULL);
    SetFilePointer(hFile,NULL,NULL,FILE_BEGIN);
    HGLOBAL hMem=0;
    //读出节表的第一个文件位置,以确PE头的大小
    //申请同样大小的空间
    hMem=GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,mySectionHeader.PointerToRawData);
    if(!hMem)
    {
        MessageBox(hDlg,TEXT("I can't get the Memory space!"),TEXT("Error!!!"),MB_OK | MB_ICONSTOP);
        return FALSE;
    }
    //将文件中的PE头部读取到申请的空间中
    ReadFile(hFile,hMem,mySectionHeader.PointerToRawData,&NumberOfBytesReadorWrite,NULL);
    CloseHandle(hFile);
    //////////////////上面是读///////////////////////
    //////////////////下面是写///////////////////////
    hFile=CreateFile(Dump_Name,GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile==INVALID_HANDLE_VALUE)
    {
        MessageBox(hDlg,TEXT("I can open the dump file..."),TEXT("Error!!"),MB_OK | MB_ICONWARNING);
        return FALSE;
    }
    //下面是将空间中的数据写到dump文件的头部
    WriteFile(hFile,hMem,mySectionHeader.PointerToRawData,&NumberOfBytesReadorWrite,NULL);
    CloseHandle(hFile);
    GlobalFree(hMem);
    return TRUE;
}

这里:

1. 获取当前进程列表使用的是:CreateToolhelp32Snapshot,Process32First, Process32Next 这三个函数,即创建一个进程快照,然后遍历它,之前做ring3的进程注入的时候用的也是这个技术,原理不是很难理解,本质上就是一个链表的操作。

2. 在进程中确定进程的大小imagesize 使用的是从磁盘的文件PE头中读取SizeOfImage这个字段来获取。这里就有一个很有趣的知识点了,我们先从原始的方法开始讲。

2.1 用ReadProcessMemory函数从从当前内存的进程映像工具PE格式的偏移获取到SizeOfImage的值的,这种方法不太可靠,要是加壳程序修改了映像中的PE头信息,就要出错了。

2.2 LordPE使用的方法,采用了对Module32Next来获取dump的进程的基本信息的。

BOOL WINAPI Module32First( 
HANDLE hSnapshot, //这是先前的CreateToolhelp32Snapshot函数返回的快照
  LPMODULEENTRY32 lpme //这个是指向MODULEENTRY32结构的指针
);

下面是MUDULEENTRY32结构:
typedef struct tagMODULEENTRY32 { 
  DWORD dwSize; 
  DWORD th32ModuleID; 
  DWORD th32ProcessID; 
  DWORD GlblcntUsage; 
  DWORD ProccntUsage; 
  BYTE *modBaseAddr; 
  DWORD modBaseSize;    //这个是是我们要获取的关键 
  HMODULE hModule; 
  TCHAR szModule[MAX_PATH]; 
  TCHAR szExePath[MAX_PATH]; 
  DWORD dwFlags;
} MODULEENTRY32, *PMODULEENTRY32, *LPMODULEENTRY32;

这种方法会受到anti-dump技术的影响。

因为MUDULEENTRY32是从内核中PEB(进程环境块)获取的数据。

下面是PEB的结构。
struct   _PEB (sizeof=488) 
+000 byte     InheritedAddressSpace 
+001 byte     ReadImageFileExecOptions 
+002 byte     BeingDebugged 
+003 byte     SpareBool 
+004 void     *Mutant 
+008 void     *ImageBaseAddress 
+00c struct   _PEB_LDR_DATA *Ldr 
+010 struct   _RTL_USER_PROCESS_PARAMETERS *ProcessParameters 
+014 void     *SubSystemData 
+018 void     *ProcessHeap 
+01c void     *FastPebLock 
+020 void     *FastPebLockRoutine 
+024 void     *FastPebUnlockRoutine 
+028 uint32   EnvironmentUpdateCount 
+02c void     *KernelCallbackTable 
+030 uint32   SystemReserved[2] 
+038 struct   _PEB_FREE_BLOCK *FreeList 
+03c uint32   TlsExpansionCounter 
+040 void     *TlsBitmap 
+044 uint32   TlsBitmapBits[2] 
+04c void     *ReadOnlySharedMemoryBase 
+050 void     *ReadOnlySharedMemoryHeap 
+054 void     **ReadOnlyStaticServerData 
+058 void     *AnsiCodePageData 
+05c void     *OemCodePageData 
+060 void     *UnicodeCaseTableData
+064 uint32   NumberOfProcessors 
+068 uint32   NtGlobalFlag 
+070 union    _LARGE_INTEGER CriticalSectionTimeout 
+070    uint32   LowPart 
+074    int32    HighPart 
+070    struct   __unnamed3 u 
+070       uint32   LowPart 
+074       int32    HighPart 
+070    int64    QuadPart 
+078 uint32   HeapSegmentReserve 
+07c uint32   HeapSegmentCommit 
+080 uint32   HeapDeCommitTotalFreeThreshold 
+084 uint32   HeapDeCommitFreeBlockThreshold 
+088 uint32   NumberOfHeaps 
+08c uint32   MaximumNumberOfHeaps 
+090 void     **ProcessHeaps 
+094 void     *GdiSharedHandleTable 
+098 void     *ProcessStarterHelper 
+09c uint32   GdiDCAttributeList 
+0a0 void     *LoaderLock 
+0a4 uint32   OSMajorVersion 
+0a8 uint32   OSMinorVersion 
+0ac uint16   OSBuildNumber 
+0ae uint16   OSCSDVersion 
+0b0 uint32   OSPlatformId 
+0b4 uint32   ImageSubsystem 
+0b8 uint32   ImageSubsystemMajorVersion 
+0bc uint32   ImageSubsystemMinorVersion 
+0c0 uint32   ImageProcessAffinityMask 
+0c4 uint32   GdiHandleBuffer[34] 
+14c function *PostProcessInitRoutine 
+150 void     *TlsExpansionBitmap 
+154 uint32   TlsExpansionBitmapBits[32] 
+1d4 uint32   SessionId 
+1d8 void     *AppCompatInfo 
+1dc struct   _UNICODE_STRING CSDVersion 
+1dc    uint16   Length 
+1de    uint16   MaximumLength 
+1e0    uint16   *Buffer

我们从FS:[30]就可以获得这个PEB的首地址。然后在0C处的_PEB_LDR_DATA *Ldr是一个关键通过它,我们能访问到

typedef struct _PEB_LDR_DATA {
ULONG Length;
BOOLEAN Initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;

该结构的后三个成员是指向LDR_MODULE链表结构中相应三条双向链表头的指针,分别是按照加载顺序、在内存中的地址顺序和初始化顺序排列的模块信息结构的指针。于是通过它,我们能访问到_LDR_MODULE结构,而这里面包括了本进程的SizeOfImage。
_LDR_MODULE结构如下:
typedef struct _LDR_MODULE {
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
PVOID BaseAddress;
PVOID EntryPoint;
ULONG SizeOfImage;                   //进程的image size
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
SHORT LoadCount;
SHORT TlsIndex;
LIST_ENTRY HashTableEntry;
ULONG TimeDateStamp;
} LDR_MODULE, *PLDR_MODULE;

所以,我们得到关键的代码就是:
  //这里的几个代码是修改PEB的关键
  __asm
  {
    mov eax,fs:[30h]                //获得PEB地址
    mov eax,[eax+0ch]               // +00c struct   _PEB_LDR_DATA *Ldr 
    mov eax,[eax+0ch]               // _LDR_MODULE的首地址
    mov dword ptr [eax+20h],1000h   //eax+20是保存image size的地方

}
上面的代码的作用就是把image size的大小改为了1000h,这样我们用MODULEENTRY32得到的大小是不准确的。

2.3 针对上面的问题,必须使用LordPE的corect image size 技术了,它的原理很简单,就是从磁盘PE文件头中读取真实的image size来修正获取到的数据,从而避免了anti-dump的影响,当然,anti-dump技术还有很多,不止这一种,我也要慢慢去摸索。

3. 对齐节表问题

学过PE结构的朋友都指导,FileAlignment(磁盘对齐值)和SectionAlignment(内存对齐值)是不一样的。

FileAlignment:0x200h

SectionAlignment:0x1000h

在PE加载器加载文件映像的时候,就会在对齐值之间的差值中填0,当然我们dump的时候连着这些0也一并dump下来了。这也就是为什么脱壳的程序普遍都比源程序大很多的原理(当然实际情况不止这些,IAT重建也会造成大小扩大)。

另外,还造成了一个问题,就是 RA!=RVA ,RS!=RVS的问题:

因为我们是从内从中直接dump出来的数据,所以这时正常的情况应该是RA=RVA ,RS=RVS,这里可以手动修改,或者编程实现即可,原理上之前学PE的时候写的PEInfo差不多,主要考察的PE结构的知识。

这是修改后的。

到这里,dump就完成了,还差IAT没修复。

可以采取手工的方法在文件中找一块空位,逆向的重构IAT,在修改PE头。

或者用ImportREC来自动修复。

修复完成后,脱壳成功,至此,一个简单的脱壳工具就出来了。

这个学习笔记就当这段时间学习逆向脱壳的总结了,留下了几个问题没解决:

1. DLL脱壳后的重定位问题

2. VMP虚拟机壳寻找OEP问题。

留待以后解决了.............

信安的路果然还很长,希望以后能继续多多学习,思考,总结,分享,向看雪上那些大神看齐。

下一阶段准备研究一些缓冲区溢出的内核的知识点,继续看《0DAY》。离ISCC结束还有10天,继续加油啦,暑假一定要到北京ISCC决赛去。

-------------------------------分割线-----------------------

不知道怎么结尾,就这样了吧,  跑步去。

关于《加密与解密》的读后感----对dump脱壳的一点思考的更多相关文章

  1. 对dump脱壳的一点思考

    对dump脱壳的一点思考 偶然翻了一下手机日历,原来今天是夏至啊,时间过的真快.ISCC的比赛已经持续了2个多月了,我也跟着比赛的那些题目学了2个月.......虽然过程很辛苦,但感觉还是很幸运的,能 ...

  2. ASP.NET加密和解密数据库连接字符串

    大家知道,在应用程序中进行数据库操作需要连接字符串,而如果没有连接字符串,我们就无法在应用程序中完成检索数据,创建数据等一系列的数据库操作.当有人想要获取你程序中的数据库信息,他首先看到的可能会是We ...

  3. 命令行工具aspnet_regiis.exe实现加密和解密web.config

    命令行工具aspnet_regiis.exe,是一个类似于DOS的命令工具,称之为命令解释器.使用命令行工具加密和解密web.config文件中的数据库连接字符串时,只需要简单的语法命令即可. 加密语 ...

  4. 使用EncryptByPassPhrase和DecryptByPassPhrase对MS SQLServer某一字段时行加密和解密

    在数据库实现加密与解密的文章,Insus.NET较早前也有写过,可以在本博客中可以搜索得到. 今天使用EncryptByPassPhrase和DecryptByPassPhrase来简单实现. 在数据 ...

  5. AES —— JAVA中对称加密和解密

    package demo.security; import java.io.IOException; import java.io.UnsupportedEncodingException; impo ...

  6. 通过ios实现RSA加密和解密

    在加密和解密中,我们需要了解的知识有什么事openssl:RSA加密算法的基本原理:如何通过openssl生成最后我们需要的der和p12文件. 废话不多说,直接写步骤: 第一步:openssl来生成 ...

  7. PHP 使用 mcrypt 扩展中的 mcrypt_encrypt() 和 mcrypt_decrypt() 对数据进行加密和解密

    <?php /* 使用 mcrypt 扩展中的 mcrypt_encrypt() 和 mcrypt_decrypt() 对数据进行加密和解密 */ // 加密 $algorithm = MCRY ...

  8. iOS,一行代码进行RSA、DES 、AES、MD5加密、解密

    本文为投稿文章,作者:Flying_Einstein(简书) 加密的Demo,欢迎下载 JAVA端的加密解密,读者可以看我同事的这篇文章:http://www.jianshu.com/p/98569e ...

  9. C# 利用SQLite对.DB和.logdb加密和解密和SQLite创建数据库

    1.最近研究了下利用SQLite为db文件简单的加密和解密 private static SQLiteConnection GetConnection() { SQLiteConnection con ...

随机推荐

  1. 注册URL模式与HttpHandler的映射关系

    注册URL模式与HttpHandler的映射关系 ASP.NET Core的路由是通过一个类型为RouterMiddleware的中间件来实现的.如果我们将最终处理HTTP请求的组件称为HttpHan ...

  2. NFine的后台源码

    Chloe官网及基于NFine的后台源码毫无保留开放   扯淡 经过不少日夜的赶工,Chloe 的官网于上周正式上线.上篇博客中LZ说过要将官网以及后台源码都会开放出来,为了尽快兑现我说过的话,趁周末 ...

  3. 用TypeScript开发Vue——如何通过vue实例化对象访问实际ViewModel对象

    用TypeScript开发Vue--如何通过vue实例化对象访问实际ViewModel对象 背景 我个人很喜欢TypeScript也很喜欢Vue,但在两者共同使用的时候遇到一个问题. Vue的实例化对 ...

  4. 自己存档:ajax 动态提交form

    $.ajax({                    cache: true,                    type: "POST",                  ...

  5. SQL Server使用游标或临时表遍历数据

    方法一:使用游标(此方法适用所有情况,对标结构没有特殊要求.) declare @ProductName nvarchar() declare pcurr cursor for select Prod ...

  6. (404) 未找到 获取StatusCode状态码

    异常代码: (HttpWebResponse)req.GetResponse(); 当执行这段代码出现异常 解决问题 那如果我们想获得错误发生时候服务器段错误页面的源代码该如何做呢? 其实非常非常简单 ...

  7. SQL复杂查询和视图

    子查询 现实中,很多情况下需要进行下述条件判断 某一元素是否是某一集合成员 某一集合是否包含另一集合 测试集合是否为空 测试集合是否存在另一元组 子查询是出现在WHERE子句中的SELECT语句被称为 ...

  8. android之自定义广播

    布局文件 点击按钮发送广播 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmln ...

  9. mybatis generator使用总结

    一.mybatis项目的体系结构 百度mybaits,可以进入mybatis的github:https://github.com/mybatis. mybatis是一个大大的体系,它不是孤立的,它可以 ...

  10. -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match.

    一, eclipse中使用maven插件的时候,运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery ...