数据结构

Redis 8.10.3 源码研读报告

从 ae 事件循环、SDS 动态字符串、dict 渐进式 rehash 到 zskiplist 跳表:逐个核心结构对照 Redis 8.10.3 源码逐行讲解,把内存数据库的设计细节一次讲透。

Redis 8.10.3 源码研读报告

读写速度快的根本原因 · 源码级逐层定位 · 安全漏洞全景分析

研读对象:redis/redis 官方仓库 tag 8.10.3(2026-10-26 发布,最新稳定版)[1]

一、总体结论(先看这里)

Redis 读写快的根本原因是七个设计决策的叠加,缺一不可:①数据全内存、操作纯 CPU;②ae 事件循环 + epoll 多路复用,单线程监听上万连接;③命令执行始终在主线程串行,无锁、无上下文切换、天然原子;④8.10 起网络读写由「每线程独立事件循环」的 IO 线程并行处理,读写 syscall 不再挤占命令执行;⑤一整套为内存场景定制的数据结构(SDS、dict 渐进式 rehash、跳表、listpack、intset),操作复杂度 O(1)/O(log N) 且内存紧凑;⑥分配与协议层的微观优化(jemalloc、共享对象、零拷贝、lookahead 批量解析);⑦把一切慢操作(RDB/AOF/惰性删除)移出主线程或切成时间片。

安全结论:有漏洞,且处于高发期。8.10.3 本身就是一次安全修复版本(修复集群总线传播超 4GB 消息的堆溢出)[1];2025 至 2026 年官方连续披露多批「认证后远程代码执行(RCE)」级漏洞(Lua 引擎 UAF、Stream NACK 双重释放、TLS 待处理链表、blocked-client 重执行等)[2][4]。绝大多数利用需要先通过认证,但现实中弱口令、空口令实例泛滥,实际门槛远低于纸面值。升级到 8.10.3 + 收口网络访问 + ACL 最小权限是当前最有效的组合防护。

支柱一句话本质核心源码入口操作代价
纯内存键空间读写不碰磁盘,查找即哈希定位db.c#lookupKey(L279)O(1) 哈希定位
ae 事件循环 + epoll单线程 epoll_wait 监听海量 fd,就绪才处理ae.c#aeProcessEvents(L365)O(就绪事件数)
命令串行执行全部命令在主线程顺序执行,无锁无竞争server.c#call(L3992)无锁开销
IO 多线程(8.10 新架构)每 IO 线程独立事件循环,读写与命令执行真正并行iothread.c#IOThreadMain(L975)读写并行化
专用数据结构SDS/dict/跳表/listpack 为内存定制,紧凑且省拷贝dict.c / sds.c / t_zset.cO(1)/O(log N)
分配与对象池jemalloc + 共享对象 + 单写者内存计数zmalloc.c(L136)少分配少原子
协议与网络优化lookahead 批量解析 + 大参数零拷贝 + 前置同步写networking.c(L3690/L3278)少 syscall 少拷贝

二、性能根因逐层拆解(附源码定位)

2.1 纯内存操作:一切快的前提

Redis 把全部键值放在进程内存中,命令执行的路径上没有任何磁盘 I/O——这是数量级层面的根本优势(内存访问约 100ns 级,磁盘随机访问约 10ms 级,相差五个数量级)。持久化(RDB/AOF)被刻意移出命令路径:RDB 由 fork 出的子进程生成,AOF 写盘由后台线程 fsync,主线程只把数据追加进内存缓冲区。

读写命令的统一入口:lookupKey

db.c L279 lookupKey / L349 lookupKeyReadWithFlags / L366 lookupKeyWriteWithFlags

所有读写命令最终都经由 lookupKey 拿到值对象(8.10.3 中值类型已从 robj 演进为 kvobj):先 dbFindByLink 定位哈希桶链,再做过期判断(expireIfNeeded)与 LRU/LFU 时钟更新。命中路径完全在用户态内存中完成,无 syscall、无磁盘等待。

2.2 ae 事件循环与 epoll 多路复用:单线程管住上万连接

Redis 自带一个极简事件循环库 ae(约 500 行),把「监听大量 socket」这件事交给内核 epoll,自己只处理就绪事件。编译期按性能优先级自动选择后端:evport > epoll > kqueue > select(Linux 上即 epoll)。

文件函数行号关键逻辑
ae.caeMainL497主循环:aeProcessEvents(AE_ALL_EVENTS|AE_CALL_BEFORE_SLEEP|AE_CALL_AFTER_SLEEP) 死循环
ae.caeProcessEventsL365计算最近定时器→调 aeApiPoll 阻塞等待→遍历 fired[] 依次回调读/写处理器→处理时间事件
ae.caeCreateFileEventL145按 fd 索引注册读写回调(events[] 数组直接以 fd 为下标,O(1) 定位)
ae_epoll.caeApiPollL89核心一行:epoll_wait(epfd, events, setsize, timeout),就绪 fd 直接映射进 fired[]
ae_epoll.caeApiCreateL19epoll_create(1024)(内核 2.6+ 用红黑树 + 就绪链表,回调式 O(1) 取就绪)
server.cmain → aeMainL8051 / L8410初始化完成后进入 aeMain(server.el),此后服务器的一切都发生在这个循环里
深挖:一次请求在事件循环中的完整路径
/* ae.c L365 起(节选并注释) */
int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
    /* 1. 睡眠前钩子:写 AOF 缓冲、直接同步写回客户端等 */
    if (eventLoop->beforesleep != NULL && (flags & AE_CALL_BEFORE_SLEEP))
        eventLoop->beforesleep(eventLoop);          /* server.c#beforeSleep L1947 */
    /* 2. 内核等待:有 fd 就绪或定时器到期才返回 */
    numevents = aeApiPoll(eventLoop, tvp);          /* ae_epoll.c L93: epoll_wait */
    /* 3. 唤醒后钩子:获取模块 GIL、刷新时间缓存 */
    if (eventLoop->aftersleep != NULL && flags & AE_CALL_AFTER_SLEEP)
        eventLoop->aftersleep(eventLoop);           /* server.c#afterSleep L2162 */
    /* 4. 逐个触发就绪 fd 的读/写回调(客户端连接对应 */
    /*    readQueryFromClient / sendReplyToClient)       */
    for (j = 0; j < numevents; j++) { ... }
}

整条路径只有一个线程在跑:一个客户端的 SET 命令从内核网卡中断 → epoll 就绪队列 → 回调读数据 → 解析 → 执行 → 写回,全部串行在同一核上完成,数据始终热在 CPU cache 里。这是「单线程反而快」的微观基础。

2.3 单线程命令执行模型:用串行换掉锁和切换

所有命令的执行(对数据结构的增删改查)永远发生在主线程,一个时刻只有一条命令在跑。收益是三重的:无锁——dict、跳表、SDS 等全部数据结构不需要任何互斥保护;无上下文切换——不存在线程间抢核、缓存失效;天然原子——INCR、MULTI/EXEC、Lua 脚本的原子性无需额外机制。多线程难以做对的「正确性」,Redis 用「根本不并发」直接消解。

命令执行的唯一通道:call()

server.c L3992 call(L4058 执行)· L4467 processCommand

processCommand 完成权限、OOM、集群重定向等检查后,一切命令最终走到 call() 中这行:

    c->cmd->proc(c);   /* server.c L4058:函数指针直调,零间接开销 */

命令表本身也是 dict(server.c#lookupCommandLogic L3633):命令名哈希查找 O(1) 后拿函数指针执行。L4026-L4049 还能看到配套的时钟缓存优化——只在单调时钟漂移超 10µs 或累计 25 条命令后才刷新缓存时间,避免每条命令都做取时钟 syscall。

2.4 IO 多线程:8.10 全新架构(与 6.0 旧模型的本质区别)

网上大量文章仍在描述 6.0/7.x 的旧模型(主线程 epoll 收集就绪 fd → 派发给 IO 线程做 read/write → 自旋等全部完成后回来)。8.10 已经彻底重构:新增 iothread.c(约 1080 行,2024 年起的全新文件),每个 IO 线程拥有自己独立的 ae 事件循环和自己的 fd 集合,客户端连接按「最少客户端数」策略整个生命周期常驻某一线程[10]。

函数行号职责
IOThreadMainL975IO 线程入口:注册 beforesleep/aftersleep 后 aeMain(t->el)——每个 IO 线程就是一个完整的独立事件循环
initThreadedIOL991为每个线程建独立 eventLoop、互斥队列、eventNotifier 并 pthread_create;上限 IO_THREADS_MAX_NUM=128(server.h L226)
assignClientToIOThreadL334新连接按各线程当前客户端数最少者分配(负载均衡 + 连接亲和)
processClientsFromIOThreadL603主线程侧:接收 IO 线程移交的客户端——IO 线程已读完整命令,主线程在此执行命令(L664-L674 CLIENT_IO_PENDING_COMMAND 路径)
isClientMustHandledByMainThreadL292安全边界:阻塞/PubSub/Monitor/tracking/主从同步中 等客户端强制留在主线程,杜绝数据竞争
pauseIOThread / resumeIOThreadL482/L487协作式暂停:主线程要动 IO 线程数据时先暂停对方(原子状态 + 忙等确认),保证共享上下文安全
prefetchIOThreadCommandsL524两阶段 prefetch:先把待处理 client 结构体拉进 cache,再访问数据建命令批——8.x 的 CPU cache 优化代表作

分工原则一句话:IO 线程只碰网络(读、解析、写回),凡是动服务器数据的(执行命令、释放客户端)一律移交主线程。iothread.c L594-L597 的注释原话:"IO threads never free client since this operation access much server data"。因此命令执行依旧串行无锁,而 socket read/write 在多线程里并行——两全。配置项 io-threads(config.c L3507)默认仍为 1,范围 1~128;默认即纯单线程模式。

深挖:新架构为什么比旧模型快
  • 消灭了「barrier 等待」:旧模型每轮 epoll_wait 后要把就绪 fd 分发下去、等全部 IO 线程干完才能继续,主线程空转;新模型 IO 线程常驻运行,主线程只在 beforeSleep 里收发客户端(L2076-L2111),真正并行。
  • 连接-线程亲和:一条连接固定属于一个线程,其 client 结构体、querybuf、回复缓冲区始终热在同一线程的 CPU cache 中(配合 L524 prefetch 进一步强化)。
  • 低成本的线程间通知:不走锁竞争的共享队列,而是 eventNotifier(pipe/eventfd)唤醒 + 互斥链表搬运(sendPendingClientsToIOThreads L503),且带批量阈值(IO_THREAD_MAX_PENDING_CLIENTS)摊薄唤醒成本。
  • 内存计数也随之重构:见 2.6 节 zmalloc 单写者槽位——每线程一个专用 used_memory 计数槽,加法是无锁前缀的单写者普通写。

2.5 专用数据结构:为内存场景从头定制

2.5.1 SDS:五档头部的二进制安全字符串

Redis 不用 C 字符串,自研 SDS(Simple Dynamic String):头部内嵌长度字段,sdslen O(1) 返回(C 字符串 strlen 是 O(N) 扫描);按字符串长度自适应 5 档头部(1~8 字节头部),配合 __attribute__((__packed__)) 零对齐浪费——短字符串(绝大多数键名)只付 1 字节管理成本;二进制安全可存任意字节;预分配 + 惰性释放让 append 类操作摊还 O(1)。

/* sds.h L28-55(节选):五档头部,越短越省 */
struct __attribute__ ((__packed__)) sdshdr5  { unsigned char flags; char buf[]; };
struct __attribute__ ((__packed__)) sdshdr8  {
    uint8_t  len;      /* 已用长度——sdslen() O(1) 的来源 */
    uint8_t  alloc;    /* 已分配长度——惰性释放的依据 */
    unsigned char flags; char buf[];
};
/* sdshdr16 / 32 / 64 同构,uint16/32/64 按需扩档 */
文件函数行号关键逻辑
sds.c_sdsMakeRoomForL341增长策略:<1MB 时翻倍预留(贪心版 sdsMakeRoomFor),避免反复 realloc
sds.csdsResizeL369jemalloc 下先查 je_nallocx(L403-L410):新大小对应同一分配块时直接跳过 realloc 调用
sds.hsdslenL98读头部 len 字段,O(1) 取长度

2.5.2 dict 渐进式 rehash:扩缩容不卡顿

键空间与各种 Hash/Set 底层都是 dict。扩容不一次搬完,而是把迁移「摊」进每次增删改查:_dictRehashStep(dict.c L471)在每次查找顺带搬 1 个桶;后台任务用 dictRehashMicroseconds(L449)按微秒预算批量搬。查找要同时看新旧两张表(dictFind L805),但单步代价恒定,百万级键扩容时延迟曲线是平滑的而非悬崖。

/* dict.c L406(节选):一次最多搬 n 个桶,且空桶访问上限 n*10 */
int dictRehash(dict *d, int n) {
    int empty_visits = n*10;   /* 防止连续空桶把一次迁移变成全表扫描 */
    while(n-- && d->ht_used[0] != 0) {
        while(d->ht_table[0][d->rehashidx] == NULL) {
            d->rehashidx++;
            if (--empty_visits == 0) return 1;  /* 到量即停 */
        }
        rehashEntriesInBucketAtIndex(d, d->rehashidx);  /* 搬一整个桶 */
        d->rehashidx++;
    }
    return !dictCheckRehashingCompleted(d);
}

配套设计:哈希种子启动时随机化(main 中 dictSetHashFunctionSeed,server.c L8128-L8130),防碰撞攻击;8.x 引入 kvstore.c 把键空间按哈希槽分成多个 dict(集群模式下按 slot 分片,热点 dict 更小、遍历分摊)。

2.5.3 zskiplist:8.0 起的紧凑压缩布局

ZSet 的核心是「dict + 跳表」双索引(server.h L1816-1819):dict 负责 member→score 的 O(1) 查找,跳表负责按 score 的 O(log N) 范围操作。8.x 对跳表节点做了一次显著内存压缩:SDS 元素直接内嵌在节点 level[] 数组之后(L1806 注释明确 "sds ele is embedded after level[] array"),连 level[0] 的 span 字段都被复用来存节点信息(L1790-L1795 zskiplistNodeInfo)——节点一整块内存分配,缓存行友好。

/* server.h L1797-1814(节选)*/
typedef struct zskiplistNode {
    double score;
    struct zskiplistNode *backward;          /* 双向:倒序遍历 O(1) 步进 */
    struct zskiplistLevel {
        struct zskiplistNode *forward;
        unsigned long span;                  /* 跨度:ZRANK 类操作 O(log N) 的关键 */
    } level[];                               /* 柔性数组:层数 1~32 按需分配 */
} zskiplistNode;                             /* SDS member 紧随其后内嵌(零额外指针) */
函数行号关键逻辑
zslInsertL326zslRandomLevel 概率分层(每层 1/4 概率晋升),插入 O(log N);8.x 已把逐层定位拆出 zslInsertNode
zslUpdateScoreL396快路径(L400-L405):新分数不改变排序位置时原地改写,省去删除+重插——ZINCRBY 的高频路径
zslGetRankL645沿 forward 累加 span 得名次,O(log N)

其余同理:小 Hash 用 listpack(连续内存、无指针)、小 Set 用 intset(有序整型数组,二分查找)、List 用 quicklist(ziplist/listpack 双端链)。共同点是小数据量下极致省内存、零指针追逐,cache 局部性远好于教科书结构。

2.6 分配器与对象层:少分配、少原子、少拷贝

文件函数/结构行号关键逻辑
zmalloc.czmalloc_reserve_thread_slots / zmalloc_register_reserved_slotL136 / L1518.10 新增:主线程与每个 IO 线程各占一个专用 used_memory 计数槽(main L8288 调用)
zmalloc.cupdate_used_memory_entryL168专用槽走「单写者」普通 load+store(L171-L174 注释:no lock prefix);只有共享池才用原子 RMW——把每笔分配的原子开销从常态变为例外
MakefileUSE_JEMALLOCL101/L320Linux 默认链接自带 jemalloc:按 size-class 分配抗碎片,多线程 arena 隔离竞争
server.ccreateSharedObjectsL2204启动时预创建 +OK、:0、:1、+PONG 等常用回复对象,0~9999 共享整数(OBJ_SHARED_INTEGERS,server.h L127)——高频回复零分配零拷贝
keymeta.h / entry.hKeyMeta / Entry头文件8.x 新框架:TTL 等元数据以 8 字节内联挂在 kvobj 上(无 TTL 键零元数据成本);Hash 的 field-value 打包进单块 Entry(三种布局按需选最省的)
lazyfree.c / bio.clazy free—DEL 大集合时不同步释放,丢给后台线程——慢操作移出主线程的典型代表

2.7 协议与网络层:把每条命令的 syscall 和拷贝压到最少

函数行号关键逻辑
processInputBufferL3690lookahead 批量解析(默认 16,server.h L212):一次事件循环把缓冲区里最多 16 条命令全部解析进 pending_cmds 队列再逐条执行——pipeline 的吞吐放大器
processMultibulkBufferL3278大参数零拷贝(L3442-L3452):≥32KB(PROTO_MBULK_BIG_ARG,L193)的 bulk 且恰好独占缓冲区时,createObject 直接引用 querybuf,全程零 memcpy;读入前还会先对齐缓冲区起点(L3398-L3423)+ sdsMakeRoomForNonGreedy 精确预留
handleClientsWithPendingWritesL2958beforeSleep 里(server.c L2104 调用)先把回复直接 write 回 socket——多数小回复根本无需注册可写事件、无需二次进事件循环,一次 syscall 完成读+算+写
writeToClientL2847单事件写量上限 NET_MAX_WRITES_PER_EVENT=64KB(L2874-L2890)防大回复饿死其他客户端;replica 通道不设限(L2855-L2864)保主从不积压
readQueryFromClientL3893单次读 16KB(PROTO_IOBUF_LEN,L1918);IO 线程模式下解析完成后挂 CLIENT_IO_PENDING_COMMAND 移交主线程(L3843-L3847)

协议本身也「为快而生」:RESP 文本协议可 memchr/strchr 直扫、string2ll 手写转换,解析即指针游走(新解析器见 networking.c 与 resp_parser.c 的回调式实现);回复小对象直接共享池引用(2.6 节)。合起来的效果:一条 GET 的端到端路径上,用户态 CPU 指令数被压到两位数级别。

2.8 微观优化合集:慢操作全部切片或外移

  • 主动过期限时限 CPU:expire.c#activeExpireCycle(L287)快速循环预算仅 1000µs(L97),过期清理永不霸占主线程。
  • 时间缓存:server.c#call L4026-L4049,25 条命令或 10µs 漂移才刷新缓存时钟,替代每命令 gettimeofday。
  • 集群总线、定时器、惰性释放、AOF fsync:分别由 cluster 线程、时间事件、bio 后台线程承担,主线程只做内存中的数据结构操作。
  • prefetch:memory_prefetch.c + iothread.c L524,把「即将被主线程执行的命令的 client 结构」提前拉入 cache,两阶段流水。
  • 渐进式 rehash / 渐进式 backlog 裁剪:一切 O(大) 操作都拆成常数步长,循环里逐步消化。

三、安全漏洞分析(以官方公告与 CVE 记录为准)

3.1 结论

Redis 存在安全漏洞,且 2025-2026 年处于集中高发期。最新稳定版 8.10.3 本身即是一个安全修复版本:修复了集群模式下经集群总线传播超 4GB 的 PUBLISH/SPUBLISH 消息时触发的堆缓冲区溢出[1]。更值得注意的是趋势:2026 年 6 月至 8 月,官方连续紧急修复多枚「认证后 RCE」漏洞,其中 stream NACK 双重释放漏洞(CVE-2026-25243)的补丁还被绕过过一次,绕过变体的 PoC 已公开、影响几乎所有在用旧版本[4]。

3.2 漏洞全景表(近年代表性漏洞)

编号类型与根因利用前置条件影响 / 修复版本严重度
CVE-2024-31227 / 31228[3] Lua 栈配置错误导致崩溃;未知 slot 导致集群崩溃(DoS 类) 需认证,可执行脚本/集群命令 修复于 2024-10 批次(详见官方公告) 中
CVE-2024-31449[3] Lua 库栈溢出,潜在 RCE 需认证,可执行 EVAL 官方 2024-10 公告批次修复 高危
CVE-2024-46981[5] 特制 Lua 脚本操纵垃圾回收器,UAF → 潜在 RCE(NVD 收录) 需认证,可执行 Lua 7.4.0 等版本线修复 高危
CVE-2025-32023[7] HyperLogLog 特制字符串触发堆栈溢出 → RCE 需认证 6.2.19 / 7.4.5 等起修复 高危
CVE-2025-46817 / 46818[6] Lua 整数溢出→潜在 RCE;Lua 脚本跨用户数据访问类问题 需认证,可执行脚本 8.2.2 起修复(同批含 49844) 高危
CVE-2025-49844[2] Lua UAF:操纵 GC 触发释放后使用 → RCE 需认证,可执行 Lua 脚本 OSS/CE 8.2.2+、8.0.4+、7.4.6+、7.2.11+ Critical
CVE-2026-23631[4] 主从同步 Lua 引擎释放后使用(UAF) 需认证 + 特定配置 2026-06 批次修复 高危(8.1)
CVE-2026-25243(含补丁绕过变体)[4] stream 消费组共享 NACK 对象引用计数缺陷 → 双重释放 → 堆上任意读写 → RCE;首个补丁未修干净,绕过变体以 RESTORE+XGROUP+EVAL 序列再次触发,PoC 公开 需认证,可执行 RESTORE/XGROUP/EVAL 影响 ≤6.2.22、≤7.4.9、≤8.6.4;修复 8.8.0+ 高危(8.8)
RedisBloom TDigest 堆溢出[4] RedisBloom 模块 TDigest 模块堆溢出 → RCE(已在 8.8.0 复现) 需认证 + 加载 RedisBloom 模块 8.8.0 受影响,升级模块/版本解决 高危
AVD-2026-1911719[9] blocked-client:重执行阻塞客户端命令时链表迭代器遍历同一键的阻塞等待列表,触发客户端内存破坏 → RCE,PoC 已公开 需普通权限(无认证部署无需权限) 2026-08 披露,官方补丁已发布 高危
QVD-2026-55651 / 58458[4] 2026 年 8 月连发两枚 RCE;后者为 TLS 待处理链表漏洞,细节与 PoC 公开 需认证(TLS 场景) 官方 2026-08 紧急修复版本 高危
CVE-2026-62356[8] CMSketch RDB 加载时缓冲区大小计算错误(堆溢出类) 加载恶意 RDB 文件 8.2.9(2026-08)修复 高
8.10.3 本版修复[1] 集群总线传播 >4GB PUBLISH/SPUBLISH 消息时堆缓冲区溢出 集群模式 + 特大消息传播 8.10.3 已修复(本报告研读版本) 高

另有 CVE-2025-21605(官方 2025-04 公告修复[6])、8.0.2(2025-05)与 8.6.3(2026-05)等 SECURITY 级版本更新[6],细节以官方发布说明为准,此处不展开。

3.3 重点漏洞深挖

CVE-2025-49844:Lua 垃圾回收器 UAF → RCE(CVSS 10.0 满分)

官方公告原文:经认证的用户可用特制 Lua 脚本操纵垃圾回收器,触发释放后使用并可能导致远程代码执行[2]。由 Wiz 研究员(Benny Isaacs、Nir Brakha、Sagi Tzadik)经 Trend Micro/ZDI 报告。这是 Redis 评分最高的漏洞之一,也暴露了一个结构性事实:Lua 解释器是 Redis 内嵌的完整图灵机,其沙箱的任何内存安全缺口都直接等价于宿主机代码执行。

8.10.3 源码中的对应防线:script_lua.c 的 luaSetAllowListProtection(L1348,全局表 __newindex 白名单)、luaSetTableProtectionRecursively(L1358,递归只读表)与 Lua 库裁剪(L80 起的 deprecated 清单、L1236 起「不加载」的库)。但此类防护管住的是「Lua 语言层」的越权,管不住 Lua VM 自身实现层的内存错误——后者正是 2024-2026 年一连串 CVE 的共同根源。

修复版本:OSS/CE 8.2.2+、8.0.4+、7.4.6+、7.2.11+(8.10.3 已含修复)[2]。

CVE-2026-25243 及其补丁绕过:Stream NACK 双重释放利用链

根因在 stream 消费组(consumer group)的共享 NACK(Pending Entries List 中已投递未确认条目)对象引用计数缺陷。官方首发补丁后未修干净,绕过变体用 RESTORE + XGROUP + EVAL 三条命令构造特定流操作序列,重新触发共享 NACK 的双重释放,把内存破坏原语升级为堆上任意读写,最终劫持函数指针执行任意命令——完整利用链分析已有公开逆向文章[4]。

影响范围几乎覆盖当时全部在用版本:Redis ≤6.2.22、≤7.4.9、≤8.6.4;修复版本 8.8.0 及以上(8.10.3 已含修复)。利用前提是「已认证且具备 RESTORE/XGROUP/EVAL 权限」。

教训(对运维侧):打了补丁 ≠ 安全——补丁绕过类漏洞专杀「台账上标了已修复」的实例,Redis 处于漏洞高发期时应直接跟进最新稳定版而非停在「打过某个 CVE 补丁」的版本[4]。

8.10.3 本版修复:集群总线超 4GB 消息堆溢出

GitHub 官方 8.10.3 发布说明原文(Update urgency: SECURITY):"Heap buffer overflow when propagating a PUBLISH/SPUBLISH message larger than 4GB over the cluster bus in cluster mode"[1]。即集群模式下,超过 4GB 的发布消息沿集群总线(cluster bus)传播时缓冲区尺寸计算溢出导致堆溢出。

这正是本报告选择 8.10.3 作为研读版本的原因:它是当前同时含「全部历史漏洞修复 + 本枚新漏洞修复」的最新稳定版。若生产集群启用 PUBLISH 广播超大消息,务必在 8.10.3 及以上版本运行。

3.4 8.10.3 内建防护机制现状(源码实测)

机制源码位置现状与局限
protected-modeconfig.c L3403默认开启:无 bind/密码时仅回环可连,可挡「裸奔公网」的第一层;但显式 bind 公网 + 设弱密码时无能为力
ACL 权限体系acl.c(main 中 L8136 即初始化)支持按用户限定命令与 key 模式(可禁 EVAL/RESTORE 等高危命令);默认用户为 nopass 全权限——不配置等于没设防
Lua 沙箱script_lua.c L1348 / L1358全局表白名单 + 递归只读表 + 库裁剪;但拦不住 Lua VM 实现层内存错误(见 3.3 第一条)
输入尺寸限制config.c L3581(proto-max-bulk-len 默认 512MB);networking.c L3309/L3392 未认证多命令/bulk 限制;L3699-L3704 未认证 lookahead 收敛为 1挡住超大参数内存攻击与未认证阶段的解析滥用
TLStls.c / socket.c传输加密可选;但 2026-08 的 TLS 待处理链表 RCE(QVD-2026-58458)说明 TLS 栈自身也曾是攻击面[4]

3.5 剩余风险面与加固建议

当前(8.10.3 时点)的风险面不在「有没有洞」——一定还会有新洞,而在两个结构性事实:①几乎所有高危 CVE 的前置条件都是「先认证」,而现实中的弱口令、空口令、默认端口实例使这个门槛形同虚设[4];②模块生态(如 RedisBloom TDigest 堆溢出)在主进程内运行,把第三方 C 代码的内存安全直接并入 Redis 的信任边界[4]。对应的加固动作:

  1. 版本策略

    生产实例统一升级到 8.10.3 及以上;把官方安全公告与 release notes 的 SECURITY 标记纳入例行监控;补丁打完仍要跟进——2026 年已出现补丁绕过案例[4]。

  2. 网络收口

    禁止任何公网暴露,内网白名单;bind 明确指定;容器环境同步更新基础镜像版本。

  3. 认证与最小权限

    强制 requirepass/ACL 强口令;按用户裁剪命令权限,非必要禁用 EVAL、RESTORE、XGROUP、DEBUG、CONFIG 等高危命令——2025-2026 年的 RCE 利用链几乎全部经由此类命令触发[2][4]。

  4. 模块审计

    卸载不使用的 module(尤其 RedisBloom 类概率结构模块);加载的模块跟进其独立安全更新。

  5. 行为监控

    审计异常连接与非常规命令序列(重点 EVAL/RESTORE/XGROUP/PUBLISH 超大消息);关注源自 Lua 引擎栈的崩溃堆栈——官方列为疑似利用的典型痕迹[2]。

四、总结

以 8.10.3 源码为准:Redis 的读写速度来自一条自洽的工程主线——内存数据结构 + 无锁串行命令执行 + epoll 事件循环,8.10 再叠加「每线程独立事件循环」的 IO 并行,配合 SDS/dict/跳表等专用结构与分配、协议层的成体系微观优化。所有机制的源码位置在本报告第二章均给出了 8.10.3 实测的文件、函数与行号,可直接对源验证。

安全上:有漏洞、曾经高危、未来还会有。8.10.3 修复了包括集群总线堆溢出与全部历史 RCE 在内的已知问题,但 2025-2026 年的漏洞节奏(Lua 引擎、Stream、TLS、blocked-client、第三方模块多个方向连发 RCE,含补丁绕过与公开 PoC)说明:版本跟进速度 + 网络收口 + 强认证与命令最小权限,比任何单点防护都重要。

主要来源

  1. [1] GitHub redis/redis Releases — 8.10.3:官方发布说明(2026-10-26,SECURITY 级,含集群总线 >4GB PUBLISH 堆溢出修复原文)
  2. [2] Redis 官方安全公告:CVE-2025-49844:Lua UAF → RCE,CVSS 10.0;含受影响/修复版本表与疑似利用痕迹清单
  3. [3] Redis 官方安全公告:CVE-2024-31449 / 31227 / 31228(2024-10)
  4. [4] 安全客(360):《Redis 补丁被绕过了:最新 RCE 的 PoC 已全网公开》(2026-08-27):CVE-2026-25243 补丁绕过、QVD-2026-55651/58458、CVE-2026-23631、RedisBloom TDigest 及加固清单
  5. [5] NVD — CVE-2024-46981:Lua GC 操纵 UAF → RCE
  6. [6] Redis 官方安全公告:CVE-2025-21605;及 腾讯云开发者社区:Redis 8.2.2 发布解读(CVE-2025-46817/46818/49844 批次细节)、Redis 8.0.2 解读、Redis 8.6.3 解读
  7. [7] 高校信息化部门漏洞预警:CVE-2025-32023(HyperLogLog 堆栈溢出 → RCE)
  8. [8] Redis Open Source 8.2 Release Notes:8.2.9(2026-08)CVE-2026-62356 CMSketch RDB 加载缓冲区计算错误
  9. [9] 阿里云漏洞库 AVD-2026-1911719:blocked-client 重执行命令 RCE(2026-08 披露,PoC 已公开)
  10. [10] GitHub redis/redis 源码 tag 8.10.3:本报告全部行号与代码片段的直接研读对象(本地解压研读)

报告完

Redis 8.10.3 源码研读报告 · 性能根因 + 源码定位 + 安全漏洞全景

文中行号以官方 tag 8.10.3 为准;后续版本变动时建议按函数名重新定位。