密钥轮换时避免并发请求读到旧密钥:分布式锁与双Buffer模式

文章导读
密钥轮换时最典型的并发风险不在写入端,而在读取端:一个请求已经在本地缓存中持有旧密钥,轮换操作此时把远端密钥更新为新值,后续该请求继续用旧密钥处理数据,遇到使用不同密钥签发的数据就会失败。判断是否需要额外同步措施,可以看请求持有密钥的时间跨度:如果从取密钥到加解密完成都在一次调用内、且密钥对象不可变,那么多数情况下不需要锁;但如果密钥被存入长生命周期缓存、或者请求会跨线程共享,就必须处理读取与更新
📋 目录
  1. A 双Buffer模式解决“短暂持有”型竞争
  2. B 多节点场景用分布式锁,锁粒度要精确
  3. C 版本号校验兜底:保留一小段历史密钥表
  4. D 容易忽略的检查点
A A

密钥轮换时最典型的并发风险不在写入端,而在读取端:一个请求已经在本地缓存中持有旧密钥,轮换操作此时把远端密钥更新为新值,后续该请求继续用旧密钥处理数据,遇到使用不同密钥签发的数据就会失败。判断是否需要额外同步措施,可以看请求持有密钥的时间跨度:如果从取密钥到加解密完成都在一次调用内、且密钥对象不可变,那么多数情况下不需要锁;但如果密钥被存入长生命周期缓存、或者请求会跨线程共享,就必须处理读取与更新之间的竞争。

我一般先看两个问题:旧密钥在代码里存活多久?拿到密钥后是被直接使用,还是放进了成员变量或异步任务的对象里?如果只是在一个方法内取出来用完就丢,通常不用加锁;如果会跨线程共享,就需要处理读取与更新之间的竞争。

双Buffer模式解决“短暂持有”型竞争

双Buffer模式适合解决“短暂持有”型竞争:在内存中为密钥保留两个槽位,当前生效的称为active,另一个是standby。轮换时先把新密钥写入standby,并通过一次原子指针切换把active指向standby,之后旧密钥所在的槽位就没有新读者。这里的关键操作是切换前要确保新密钥已完全初始化,切换后要等待已知读者释放才回收旧槽位;如果切换前后没有等待,读者可能仍使用旧槽位的引用,所以需要在代码里显式维护读者计数或使用读写锁来界定安全回收时机。

下面的代码用AtomicReference保存当前密钥,用读写锁保证切换时没有读者卡在旧密钥上。注意读锁必须覆盖“取密钥”和“使用密钥”这一段完整操作,不能只在取的时候加锁、用完就释放,否则轮换仍然可能在加解密中间发生。

密钥轮换时避免并发请求读到旧密钥:分布式锁与双Buffer模式
class KeyBuffer {
    private final AtomicReference<byte[]> active;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public <T> T readWithActive(Function<byte[], T> action) {
        lock.readLock().lock();
        try {
            return action.apply(active.get());
        } finally {
            lock.readLock().unlock();
        }
    }

    public void rotate(byte[] newKey) {
        lock.writeLock().lock();
        try {
            active.set(newKey);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

这里 readWithActive 的 action 就是加解密操作,rotate 在配置中心回调里调用。验证时可以同时在 rotate 前后打印版本号,并观察 action 是否出现解密失败;失败时优先检查读锁是不是在 action 外面就被释放了。

多节点场景用分布式锁,锁粒度要精确

使用分布式锁防止并发轮换时,锁的粒度要精确到“单个密钥资源”,而不是所有密钥共用一个锁。拿到锁后必须先检查当前密钥版本是否已经是最新的,避免两个节点先后执行轮换、第二个节点覆盖第一个节点的结果。同时要设置合理的锁超时,超时时间要大于轮换操作加上等待读者释放所需的时间,否则锁提前失效会造成多个轮换同时进行。释放锁必须放在finally块里,并且最好使用带lease的锁实现,防止持有锁的进程崩溃后死锁。

以 Redis 锁为例,拿到锁之后必须做版本检查,否则即使加了锁,也可能发生第二个节点把已经轮换过的结果再覆盖一次:

密钥轮换时避免并发请求读到旧密钥:分布式锁与双Buffer模式
String token = UUID.randomUUID().toString();
boolean locked = redis.setIfAbsent("key:rotate:" + keyName, token, Duration.ofSeconds(30));
if (!locked) {
    return;
}
try {
    String currentVersion = redis.get("key:version:" + keyName);
    if (newVersion.equals(currentVersion)) {
        return;
    }
    redis.set("key:version:" + keyName, newVersion);
    // 执行真正的密钥替换和本地缓存刷新
} finally {
    if (token.equals(redis.get("key:rotate:" + keyName))) {
        redis.delete("key:rotate:" + keyName);
    }
}

keyName 是当前轮换的资源名,token 是本次持有者标识,newVersion 是目标版本号。执行位置放在真正写密钥之前。验证时可以让两个节点同时发起轮换,看最终版本号是否只写入一次。失败时优先检查锁超时时间和轮换操作的耗时。

版本号校验兜底:保留一小段历史密钥表

如果不想让所有读者都参与分布式锁,可以给密钥加版本号或密钥ID,并且在密文里保存这个ID。解密时先用ID查历史密钥表,查不到就说明轮换已经发生,这时可以触发重试或丢弃密文。要注意这里不能只存“当前密钥”,必须保留一个短期的历史密钥表,窗口外再统一清理,否则还在链路上的旧报文会批量解密失败。

密钥轮换时避免并发请求读到旧密钥:分布式锁与双Buffer模式
byte[] keyId = Arrays.copyOfRange(encryptedData, 0, 16);
SecretKey key = keyHistory.get(keyId);
if (key == null) {
    throw new RetryableKeyRotationException("key not found: " + keyId);
}
byte[] plain = decrypt(encryptedData, 16, key);

这个代码放在解密函数最前面,keyId 从密文前 16 字节读取。验证方式是留一条旧密钥加密的报文,等历史表清理后解密,预期得到 key not found。失败时优先检查 keyHistory 的 TTL 和清理线程是否误删了仍在窗口内的密钥。

容易忽略的检查点

前面几个方案合起来看,真正容易漏掉的一是读者与轮换者的竞争,二是锁超时后旧持有者还在执行。分布式锁只解决写者之间的互斥,不解决读者已经取走旧密钥的问题;如果读者持有密钥的时间长,最好在读取入口加读写锁,或者直接用版本号兜底。另一个检查点是轮换操作的幂等性:锁内要校验版本号,否则异常重试会造成二次覆盖。

上线前可以盯着这几类日志:轮换入口需要打印 oldVersion -> newVersion;解密失败时需要打印丢的是哪个 keyId;锁获取失败时要区分“没抢到锁”和“抢到锁但锁已超时”。如果发现轮换期间日志里出现“key not found”,先看历史密钥表的保留时间,不要把清理逻辑当成性能优化。