ShellCode瘦身的艺术0_HASH

写在前面的话：

前面几篇文章，我们介绍了如何获取kernerl32.dll导出函数地址的方法；

并在此基础上，编写了ShellCode，实现了动态加载DLL以及解析API地址；

但是，似乎还称不上Perfect，我们能够获取到LoadLibrary和GetProcAddress，事情就结束了吗？

我们仍然需要给他们push一些个参数，那些API的名字，占用了我们ShellCode的大部分空间；(如果API较多的话)

这使得我们的ShellCode看上去不那么美妙，因此，对API做HASH势在必行；

那也许有朋友会问：做了HASH，总有一处还原的地方吧，如果不还原，那程序里就一定有字符串存在；否则，GetProcAddress怎么玩呢？

也因此，我们对Kernel32.dll导出表的解析，就需要一般化一下了；让它不止适应于kernel32.dll，而是windows下的任何32位的PE文件；

(64位类似，解析PE，都一样，笔者就拿32位举例了，有兴趣的朋友也可以自行解析)

如果能够做到，那我们的HASH才会有意义，因为，ENT里就有API名字了；

因此，在开始HASH运算前，我们先来搞一下之前的那部分程序；

零：导出表一般化解析

0. 先来看下PE的DOS头结构

typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header
    WORD   e_magic;                     // Magic number
    WORD   e_cblp;                      // Bytes on last page of file
    WORD   e_cp;                        // Pages in file
    WORD   e_crlc;                      // Relocations
    WORD   e_cparhdr;                   // Size of header in paragraphs
    WORD   e_minalloc;                  // Minimum extra paragraphs needed
    WORD   e_maxalloc;                  // Maximum extra paragraphs needed
    WORD   e_ss;                        // Initial (relative) SS value
    WORD   e_sp;                        // Initial SP value
    WORD   e_csum;                      // Checksum
    WORD   e_ip;                        // Initial IP value
    WORD   e_cs;                        // Initial (relative) CS value
    WORD   e_lfarlc;                    // File address of relocation table
    WORD   e_ovno;                      // Overlay number
    WORD   e_res[];                    // Reserved words
    WORD   e_oemid;                     // OEM identifier (for e_oeminfo)
    WORD   e_oeminfo;                   // OEM information; e_oemid specific
    WORD   e_res2[];                  // Reserved words
    LONG   e_lfanew;                    // File address of new exe header
  } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;

我们需要关注的是最后一个字段，这个里的内容是NT头的偏移，首先，看下，这个字段在本结构体的偏移60(0x3C)

也就是说，[BaseAddr+0x3C]就是e_lfanew的值，因此，NT头的首地址BaseAddr+e_lfanew;

那再看下NT头的结构：

typedef struct _IMAGE_NT_HEADERS {
    DWORD Signature;
    IMAGE_FILE_HEADER FileHeader;
    IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;

// NT头中的文件头20Byte
typedef struct _IMAGE_FILE_HEADER {
    WORD    Machine;
    WORD    NumberOfSections;
    DWORD   TimeDateStamp;
    DWORD   PointerToSymbolTable;
    DWORD   NumberOfSymbols;
    WORD    SizeOfOptionalHeader;
    WORD    Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;

// NT头中的扩展头
typedef struct _IMAGE_OPTIONAL_HEADER {
    //
    // Standard fields.
    //

    WORD    Magic;
    BYTE    MajorLinkerVersion;
    BYTE    MinorLinkerVersion;
    DWORD   SizeOfCode;
    DWORD   SizeOfInitializedData;
    DWORD   SizeOfUninitializedData;
    DWORD   AddressOfEntryPoint;
    DWORD   BaseOfCode;
    DWORD   BaseOfData;

    //
    // NT additional fields.
    //

    DWORD   ImageBase;
    DWORD   SectionAlignment;
    DWORD   FileAlignment;
    WORD    MajorOperatingSystemVersion;
    WORD    MinorOperatingSystemVersion;
    WORD    MajorImageVersion;
    WORD    MinorImageVersion;
    WORD    MajorSubsystemVersion;
    WORD    MinorSubsystemVersion;
    DWORD   Win32VersionValue;
    DWORD   SizeOfImage;
    DWORD   SizeOfHeaders;
    DWORD   CheckSum;
    WORD    Subsystem;
    WORD    DllCharacteristics;
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    DWORD   SizeOfHeapReserve;
    DWORD   SizeOfHeapCommit;
    DWORD   LoaderFlags;
    DWORD   NumberOfRvaAndSizes;
    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;

typedef struct _IMAGE_DATA_DIRECTORY {
    DWORD   VirtualAddress;
    DWORD   Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;

#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16

我们要找什么呢，导出表的RVA，导出表是扩展头里的第0号元素；因此，计算出的数据目录表[导出表]相对NT头的偏移，就是0x78;

至此，我们通过分析DOS头和NT头结构，得到了下面的信息：

0、e_lfanew = [BaseAddr+0x3C]

1、NTStartVA：BaseAddr + e_lfnew

2、ExportStartRVA：[NTStartVA + 0x78]

3、ExportStartVA：BaseAddr + ExportStartRVA

到这一步，接下来就需要看下导出表的结构了

typedef struct _IMAGE_EXPORT_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   Name;
    DWORD   Base;
    DWORD   NumberOfFunctions;
    DWORD   NumberOfNames;
    DWORD   AddressOfFunctions;     // RVA from base of image
    DWORD   AddressOfNames;         // RVA from base of image
    DWORD   AddressOfNameOrdinals;  // RVA from base of image
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;

需要的字段，EAT/ENT/EOT，我们在上边的分析中，其实已经得到了这个导出表结构体的首地址了，就是ExportStartVA，那就简单了

4、EATRVA = [ExportStartVA + 0x1C]  -> EAT = BaseAddr + EATRVA

5、ENTRVA = [ExportStartVA + 0x20]  -> ENT = BaseAddr + ENTRVA

6、EOTRVA = [ExportStartVA + 0x24]  -> EOT = BaseAddr + EOTRVA

至此，分析结束，开始编写代码；

一、代码(为了便于理解，咱们封装成一些裸函数)

0、获取基址

void __declspec(naked) GetKernelBase() {
    _asm {
        push ebp;
        mov ebp, esp;
        sub esp, 0x0C;
        mov eax, fs:[0x30]; // PEB
        mov eax, [eax + 0xC]; // LDR
        mov eax, [eax + 0xC]; // InLoadOrderModuleList, exe
        mov eax, [eax]; // nt.dll
        mov eax, [eax]; // kernel32.dll
        mov eax, dword ptr ds : [eax + 0x18]; // BaseAddr;
        mov esp, ebp;
        pop ebp;
        ret;
    }
}

1、解析导出表，部分关键代码(全部代码，考虑下，还是在我们写完HASH算法后贴出来)

_asm{
        push ebp;
        mov ebp, esp;
        sub esp, 0x10;
        push ebx;
        push ecx;
        push esi;
        push edi;

        ...

        mov [ebp - 0x4], eax; // [ebp - 0x4] -> BaseAddr
        mov eax, [eax + 0x3C]; // e_lfanew
        add eax, [ebp - 0x4]; // NTStartVA
        mov eax, [eax + 0x78]; // ExportStartRVA
        add eax, [ebp - 0x4]; // ExportStart_VA
        mov ebx, [eax + 0x1C]; // EATRVA
        add ebx, [ebp - 0x4]; // EAT
        mov [ebp - 0x8], ebx; // [ebp - 0x8] -> EAT
        mov ebx, [eax + 0x20]; // ENTRVA
        add ebx, [ebp - 0x4]; // ENT
        mov [ebp - 0xC], ebx; // [ebp - 0xC] -> ENT
        mov ebx, [eax + 0x24]; // EOTRVA
        add ebx, [ebp - 0x4]; // EOT
        mov [ebp - 0x10], ebx; // [ebp - 0x10] -> EOT

        ...

        pop edi;
        pop esi;
        pop ecx;
        pop ebx;
        mov esp, ebp;
        pop ebp;
        ret;
}

2、接下来就要考虑如何实现HASH算法了

要求：尽量简单，又不失功能；(不同的API的HASH碰撞几率越小越好，同时ShellCode里，要兼顾体积)

/*
* @1 API
* @2 Length
*/
void __declspec(naked) ApiHash() {
    _asm {
        push ebp;
        mov ebp, esp;
        sub esp, 0x8;
        mov dword ptr[ebp - 0x4], 0x6B821B17; // Init Hash Value
        mov dword ptr[ebp - 0x8], ; // Init Local Var
        jmp short _begin;

    _loop:
        mov eax, [ebp + 0x8]; // eax = srcApi
        add eax, 0x1; // eax = srcApi + 1
        mov[ebp + 0x8], eax; // srcApi++
        mov ecx, [ebp - 0x8]; // ecx = i
        add ecx, 0x1; // ecx += 1
        mov[ebp - 0x8], ecx; // i++

    _begin:
        mov edx, [ebp - 0x8]; // edx = i
        cmp edx, [ebp + 0xC]; // edx vs len
        jnb short _end; // if (edx >= len) exit;
        mov eax, [ebp - 0x4]; // eax = Hash
        shl eax, 0x5; // eax = Hash << 5
        mov ecx, [ebp + ]; // ecx = srcApi
        movsx edx, byte ptr[ecx]; // edx = *srcApi
        add eax, edx; // eax = Hash << 5 + *srcApi
        mov ecx, [ebp - 0x4]; // ecx = Hash
        shr ecx, 0x2; // ecx = Hash >> 2
        add eax, ecx; // eax = Hash << 5 + *srcApi + Hash >> 2
        xor eax, [ebp - 0x4];
        mov[ebp - 0x4], eax; // Hash ^= (Hash << 5 + *srcApi + Hash >> 2);
        jmp short _loop;

    _end:
        mov eax, [ebp - 0x4]; // eax = Hash
        mov esp, ebp;
        pop ebp;
        ret 0x8;
    }
}

3、既然HASH算法也有了，在开始编写获取API的函数之前，先实现一个获取字符串长度的函数；

/*
 * @ String
 */
void __declspec(naked) asmstrlen() {
    _asm {
        push ebp;
        mov ebp, esp;
        sub esp, 0x4;
        mov dword ptr [ebp - 0x4], ;
        jmp short _begin;

    _loop:
        mov eax, [ebp + 0x8]; // eax = String
        add eax, 0x1; // eax = String + 1
        mov [ebp + 0x8], eax; // String++
        mov ecx, [ebp - 0x4]; // ecx = i
        add ecx, 0x1; // ecx += 1
        mov [ebp - 0x4], ecx; // i++

    _begin:
        mov ecx, [ebp + ]; // ecx = String
        movsx edx, byte ptr [ecx]; // edx = *String
        cmp edx, ;
        je _end;
        jmp _loop;

    _end:
        mov eax, [ebp - 0x4]; // eax = len
        mov esp, ebp;
        pop ebp;
        ret 0x4;
    }
}

4、接下来，就要编写通过HASH获取API地址的函数了

/*
 * @1 BaseAddr
 * @2 HASH
 */
void __declspec(naked) GetHASHAPIAddr() {
    _asm {
        push ebp;
        mov ebp, esp;
        sub esp, 0x14;
        push esi;
        push edi;

        mov eax, [ebp + ]; // BaseAddr
        mov [ebp - 0x4], eax;
        mov eax, [eax + 0x3C]; // e_lfanew
        add eax, [ebp - 0x4]; // NTStartVA
        mov eax, [eax + 0x78]; // ExportStartRVA
        add eax, [ebp - 0x4]; // ExportStart_VA
        mov ebx, [eax + 0x1C]; // EATRVA
        add ebx, [ebp - 0x4]; // EAT
        mov [ebp - 0x8], ebx; // [ebp - 0x8] -> EAT
        mov ebx, [eax + 0x20]; // ENTRVA
        add ebx, [ebp - 0x4]; // ENT
        mov [ebp - 0xC], ebx; // [ebp - 0xC] -> ENT
        mov ebx, [eax + 0x24]; // EOTRVA
        add ebx, [ebp - 0x4]; // EOT
        mov [ebp - 0x10], ebx; // [ebp - 0x10] -> EOT

        xor ebx, ebx;
        mov eax, [eax + 0x18]; // NumOfNames
        mov [ebp - 0x14], eax;
        cld;

    _ENT_FIND:
        mov esi, [ebp - 0xC]; // ENTStartVA
        mov esi, [esi +  * ebx]; // ENTContentRVA
        add esi, [ebp - 0x4]; // ENTContentVA
        push esi;
        push esi;
        call asmstrlen;
        pop esi;
        push eax;
        push esi;
        call ApiHash;
        mov edi, [ebp + 0xC]; // HASH
        cmp eax, edi;
        je _ENT_OK;
        inc ebx;
        mov eax, [ebp - 0x14];
        dec eax;
        mov [ebp - 0x14], eax;
        cmp eax, ;
        jg _ENT_FIND;
        jmp _ENT_END;

    _ENT_OK:
        mov ecx, [ebp - 0x10]; // EOTStartVA
        mov ecx, [ecx +  * ebx];
        and ecx, 0xFFFF;
        mov esi, [ebp - 0x8]; // EATStartVA
        mov eax, [esi +  * ecx]; // EAT Address RVA
        add eax, [ebp - 0x4]; // EAT Address VA

    _ENT_END:
        pop edi;
        pop esi;
        mov esp, ebp;
        pop ebp;
        ret 0x8;
    }
}

我们只需要事先准备好需要的API的HASH值，就可以了，下面让我们来测试下；

5、测试

int main(int argc, char** argv) {
    DWORD LoadLibAddr = ;
    _asm {
        call GetKernelBase;
        push 0x28182EF6; // LoadLibrayA HASH
        push eax;
        call GetHASHAPIAddr;
        mov LoadLibAddr, eax;
    }

    printf("LoadLibrary[0x%X]\n", LoadLibAddr);

    getchar();

    return ;
}

我们在调试器中输入这个地址：

可以看到，获取到了这个函数的地址；

获取有同学会说，这个是在kernel32.dll里的，其他dll里的函数也可以吗；当然了，看我们的GetHashAPIAddr参数就知道了；

来代码吧，搞一个MessageBox的函数，这个是在user32.dll里的，见代码，运行后会弹框，证明就成功了；

int main(int argc, char** argv) {
    char srcDll[] = "user32.dll";
    DWORD LoadLibAddr = ;

    _asm {
        call GetKernelBase;
        push 0x28182EF6; // LoadLibrayA HASH
        push eax;
        call GetHASHAPIAddr;
        mov LoadLibAddr, eax;

        push esi;
        mov esi, eax;
        lea eax, srcDll;
        push eax;
        call esi;
        push 0x564B6854; // MessageBoxA HASH
        push eax;
        call GetHASHAPIAddr;

        push ;
        push ;
        push ;
        push ;
        call eax;
    }

    printf("LoadLibraryA[0x%X]\n", LoadLibAddr);

    getchar();

    return ;
}

至此，我们的API算是都准备好了，通过实现HASH算法，我们去掉了占用体积过大的API字符串，瘦身的目的达到了；

在后续的文章中，笔者将带领大家一起分析ShellCode中的截断问题，敬请期待；