Salt 加密热路径优化:libcrypto RSAX931 签名/验证器缓存与 mtime 键控密钥缓存解析

原创2026-09-21 14:51:281,706 阅读
文章标签:运维配置管理DevOpsIaC任务调度工作流自动化后端

Salt 加密热路径优化:libcrypto RSAX931 签名/验证器缓存与 mtime 键控密钥缓存解析

本篇文章围绕 Salt(GitHub 加速计划 / sa / salt 仓库)中 changelog/69940.fixed.md 记录的修复展开,深入讲解 Salt 在 master 的 MWorker 进程中对 RSA 密钥加载与签名验证路径所做的一次关键性能优化:将 libcrypto 底层的 RSAX931 签名器 / 验证器对象缓存在 salt.crypt.PublicKey 与 PrivateKey 实例上,同时为 PublicKey.from_file 引入以文件 mtime 为键的路径级缓存。读完本文,你将理解 Salt 认证模块中 PEM 解析与 BIO/RSA 分配为何会成为热点、缓存失效与密钥轮换是如何被安全处理的,以及对应的单元测试如何保证优化不改变原有行为。

一、问题背景:繁忙 master 的 MWorker 为什么每分钟产生数千次冗余解析

Salt 的 master 进程会派生多个 MWorker 工作进程来处理 minion 的上线(sign_in)与各类消息。每次身份认证与消息签名验证,都会反复加载 master 自己的 RSA 密钥对,并使用对端公钥做签名校验。在修复之前,每次调用都会发生:

  1. 重新打开密钥文件、读取 PEM 字节;
  2. 交给 cryptography 库做完整的 PEM 解析,构造出 RSAPrivateKey / RSAPublicKey 对象;
  3. 在需要 X9.31(RSAX931)签名或验证时,把密钥再次序列化为 PEM,然后通过 ctypes 调用 OpenSSL libcrypto,为每个操作分配一个新的 BIO 与 RSA 结构体。

在活跃 master 的多个 MWorker 进程里,这类重复工作每分钟可达数千次,成为显著的 CPU 与内存分配开销。这正是 changelog/69940.fixed.md 要解决的问题:Eliminates thousands of redundant PEM parses and libcrypto BIO/RSA allocations per minute in a busy master's MWorker processes.

二、优化方案总览:实例级懒缓存 + 路径级 mtime 键控缓存

本次修复在 salt/crypt.py 中构建了两层互补的缓存机制:

层级 缓存对象 缓存键 实现位置
实例级懒缓存 libcrypto 的 RSAX931Signer / RSAX931Verifier 每个 PrivateKey / PublicKey 实例一份,首次使用时构造 PrivateKey.init 与 PublicKey.init
路径级 mtime 键控缓存 PublicKey 实例本身 (path, mtime_str) 二元组 _get_pub_key_with_evict 与 _pub_key_cache / _pub_key_cache_path_index 两个模块级字典

加上私钥侧早已存在的 @memoize 路径缓存(见下文第三节),三层配合让“同一个密钥文件被反复加载”的开销趋近于零。

1. 实例级懒缓存:一个实例只构造一次 libcrypto 对象

PrivateKey 在 __init__ 末尾把 self._signer 初始化为 None(salt/crypt.py#L355),PublicKey 同样把 self._verifier 初始化为 None(salt/crypt.py#L433):

# salt/crypt.py — PrivateKey.__init__ 尾部
# Lazy cache of the libcrypto-backed X9.31 signer.  ``self.key`` is
# immutable after __init__ so the derived signer can be reused for the
# lifetime of this instance.
self._signer = None

随后 PrivateKey.encrypt() 在首次调用时,将 self.key 序列化为传统 OpenSSL PEM 格式,构造 salt.utils.rsax931.RSAX931Signer 并缓存在 self._signer 上(salt/crypt.py#L357-L365):

def encrypt(self, data):
    if self._signer is None:
        pem = self.key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.TraditionalOpenSSL,
            encryption_algorithm=serialization.NoEncryption(),
        )
        self._signer = salt.utils.rsax931.RSAX931Signer(pem)
    return self._signer.sign(data)

PublicKey._decrypt() 采用完全对称的模式,首次调用时把 self.key 以 SubjectPublicKeyInfo 格式序列化并构造 RSAX931Verifier(salt/crypt.py#L491-L498):

def _decrypt(self, data):
    if self._verifier is None:
        pem = self.key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo,
        )
        self._verifier = salt.utils.rsax931.RSAX931Verifier(pem)
    return self._verifier.verify(data)

由于 self.key 在 __init__ 之后不可变,派生的签名器 / 验证器可以安全复用于整个实例生命周期;代码注释明确说明:当实例通过路径级缓存被复用后,decrypt()/encrypt() 便不再重复做 PEM 序列化与 libcrypto 的 BIO/RSA 分配。

2. 路径级 mtime 键控缓存:PublicKey.from_file 的入口改造

PublicKey.from_file 不再直接读文件构造对象,而是先取文件 mtime,路由到 _get_pub_key_with_evict(salt/crypt.py#L408-L418):

@classmethod
def from_file(cls, path, *args, **kwargs):
    return _get_pub_key_with_evict(path, str(os.path.getmtime(path)))

模块级缓存由两个字典构成(salt/crypt.py#L564-L571):

  • _pub_key_cache:以 (path, mtime_str) 为键,存放 PublicKey 实例;
  • _pub_key_cache_path_index:以 path 为键,指向当前缓存键,用于支持“验证失败后的按路径驱逐重载”路径。

_get_pub_key_with_evict 的命中与回填逻辑如下(salt/crypt.py#L574-L590):

def _get_pub_key_with_evict(path, timestamp):
    cache_key = (path, timestamp)
    cached = _pub_key_cache.get(cache_key)
    if cached is not None:
        return cached
    with salt.utils.files.fopen(path, "rb") as fp:
        pub = PublicKey(fp.read())
    _pub_key_cache[cache_key] = pub
    _pub_key_cache_path_index[path] = cache_key
    return pub

关键设计:磁盘上密钥轮换会 bump mtime,从而使 (path, mtime) 缓存键变化,透明地强制加载新实例,无需任何显式清理调用。

三、私钥侧的对等优化:memoize 装饰器与时间戳参数

公钥侧新增了模块级路径缓存,而私钥侧复用了一直存在的“穷人的缓存”模式。get_rsa_key(path, passphrase) 调用被 @salt.utils.decorators.memoize 装饰的 _get_key_with_evict(path, timestamp, passphrase)(salt/crypt.py#L537-L561):

@salt.utils.decorators.memoize
def _get_key_with_evict(path, timestamp, passphrase):
    return PrivateKey.from_file(path, passphrase).key

def get_rsa_key(path, passphrase):
    return _get_key_with_evict(path, str(os.path.getmtime(path)), passphrase)

memoize 装饰器(salt/utils/decorators/init.py#L274-L299)把参数序列化为字符串作为字典键缓存返回值。因为 timestamp(即 mtime)被编码进参数,当私钥文件在磁盘上被替换时,mtime 变化导致缓存键变化,下一次调用会完整地从磁盘重新加载密钥。这与公钥侧 (path, mtime_str) 的缓存键设计完全同构,两套机制互相印证。

四、底层支撑:rsax931 模块如何构造并复用 libcrypto 对象

签名器 / 验证器的实际构造位于 salt/utils/rsax931.py,它通过 ctypes 直接绑定 OpenSSL libcrypto:

  • 模块初始化时设置 RSA_private_encrypt、RSA_public_decrypt 等函数原型,并定义 RSA_X931_PADDING = 5(对应 openssl/rsa.h 中 RSA_X931_PADDING 宏,salt/utils/rsax931.py#L172-L175)。
  • RSAX931Signer.__init__(salt/utils/rsax931.py#L178-L195):把 PEM 私钥放入内存 BIO(BIO_new_mem_buf),RSA_new() 分配 RSA 结构体,再用 PEM_read_bio_RSAPrivateKey 解析。
  • RSAX931Signer.sign()(salt/utils/rsax931.py#L204-L220):按 RSA_size 分配输出缓冲,调用 RSA_private_encrypt(..., RSA_X931_PADDING) 产出签名。
  • RSAX931Verifier.__init__(salt/utils/rsax931.py#L223-L241):用 PEM_read_bio_RSA_PUBKEY 解析公钥(注意它会把 b"RSA " 前缀替换掉以兼容不同格式的公钥头)。
  • RSAX931Verifier.verify()(salt/utils/rsax931.py#L250-L267):通过 RSA_public_decrypt 从签名恢复摘要,失败时返回 ValueError。
  • 两个类都在 __del__ 中调用 BIO_free 与 RSA_free 释放底层资源。

由此可见,每次构造 RSAX931Signer/RSAX931Verifier 都意味着一次 PEM 解析加上一对 BIO/RSA 分配。修复前这些对象在每次 encrypt()/decrypt() 时被重新创建;修复后它们被缓存到实例上,这正是 changelog 中所说“eliminates thousands of redundant PEM parses and libcrypto BIO/RSA allocations per minute”的实现根基。

五、安全兜底:验证/解密失败时的单次重载重试

缓存最怕的场景是“密钥已轮换但 mtime 没变”。现实中确实存在不更新 mtime 的轮换方式:cp -p 保留时间戳、NFS 的 mtime 缓存、以及保留时间戳的原子重命名。为了保持缓存前“每次读取都是最新”的行为,PublicKey.verify 与 PublicKey.decrypt 都实现了失败后驱逐并重试一次的回退逻辑。

verify() 的流程(salt/crypt.py#L476-L489):

def verify(self, data, signature, algorithm=PKCS1v15_SHA1):
    result = self._verify(data, signature, algorithm)
    if result:
        return True
    # 密钥可能在磁盘上轮换但未 bump mtime(cp -p、NFS mtime 缓存、
    # 保留时间戳的原子重命名)——驱逐缓存条目并重试一次。
    fresh = _reload_evicted_pub_key(self)
    if fresh is None or fresh is self:
        return False
    return fresh._verify(data, signature, algorithm)

decrypt() 则捕获 RSAX931Verifier.verify() 抛出的 ValueError 后走同样的重载路径(salt/crypt.py#L500-L510):

def decrypt(self, data):
    try:
        return self._decrypt(data)
    except ValueError:
        fresh = _reload_evicted_pub_key(self)
        if fresh is None or fresh is self:
            raise
        return fresh._decrypt(data)

驱逐与重载由 _reload_evicted_pub_key 完成(salt/crypt.py#L593-L611):它通过 _pub_key_cache_path_index 找到该实例对应的缓存键,从两个字典中移除,然后以当前磁盘 mtime 重新调用 _get_pub_key_with_evict 加载新实例;若文件已不可读(OSError)则返回 None。

这套设计保证了三点:

  1. mtime 正常变化的轮换:缓存键自动失效,无需重试;
  2. mtime 未变的轮换:首次校验失败触发一次驱逐重载,随后命中新密钥;
  3. 真正的坏签名 / 坏载荷:重试仍然失败,verify 返回 False、decrypt 重新抛出异常,且每个伪造尝试至多付出一次额外文件读取 + PEM 解析的代价,不会无限重试。

六、单元测试如何验证缓存语义与轮换安全

tests/pytests/unit/test_crypt.py 为这套机制提供了完整的测试覆盖,可以作为理解缓存行为的“可执行文档”:

  • 实例复用:test_pubkey_from_file_returns_cached_instance(tests/pytests/unit/test_crypt.py#L755-L763)断言对同一文件连续两次 PublicKey.from_file 返回同一个对象(first is second),证明下游 libcrypto 状态(验证器)在整个进程内被复用。
  • mtime 驱逐:test_pubkey_from_file_mtime_evicts(tests/pytests/unit/test_crypt.py#L766-L784)用 os.utime 把 mtime 显式拨快 5 秒(避免依赖文件系统时间戳分辨率),断言返回新实例,且底层 RSAPublicKey.public_numbers() 与旧实例一致。
  • mtime 未变时的验证重试:test_verify_retries_after_rotation_without_mtime_bump(tests/pytests/unit/test_crypt.py#L787-L823)先用旧密钥预热缓存,再原地写入新公钥并 os.utime 恢复原 mtime,验证缓存中的旧实例调用 verify 仍能返回 True,且 _pub_key_cache 中同一 (path, mtime) 键已被替换为新实例。
  • mtime 未变时的解密重试:test_decrypt_retries_after_rotation_without_mtime_bump(tests/pytests/unit/test_crypt.py#L826-L850)覆盖 AsyncAuth 使用的 X9.31 解密路径,新私钥签名后的载荷用缓存的旧公钥实例仍能解密成功。
  • 失败不被掩盖:test_verify_genuine_bad_sig_returns_false_after_retry(tests/pytests/unit/test_crypt.py#L853-L863)与 test_decrypt_genuine_bad_payload_raises_after_retry(tests/pytests/unit/test_crypt.py#L866-L869)证明重试是有界的一次性重载,真实的坏签名 / 坏载荷仍按原有语义返回 False 或抛异常。
  • 签名器构造计数:测试还统计了 PrivateKey.encrypt 路径中 RSAX931Signer 的构造次数,验证同一实例多次加密只构造一次签名器(见 tests/pytests/unit/test_crypt.py#L750-L752 附近的断言),直接对应 changelog 中“缓存 libcrypto-backed RSAX931 signer / verifier”的目标。

此外,测试文件中的 _clear_pub_key_cache fixture(tests/pytests/unit/test_crypt.py#L659-L668)在用例之间清空 crypt._pub_key_cache 与 crypt._pub_key_cache_path_index,防止模块级缓存跨用例污染,这也侧面说明了缓存是进程级的全局状态。

七、适用前提与运维影响

从实现与测试可以看出,本次优化对部署和使用是完全透明的:

  • PublicKey.from_file、PrivateKey.from_file、get_rsa_key、get_rsa_pub_key、sign_message、verify_signature(见 salt/crypt.py#L621-L634)等公开入口的调用签名未变,上层调用方无需修改;
  • 密钥轮换的两种常见方式(正常覆盖写导致 mtime 变化、cp -p 等保留 mtime 的方式)都被覆盖:前者靠缓存键自动失效,后者靠失败重试兜底;
  • 缓存只针对按路径加载的场景;使用 from_str / from_bytes 构造的 PrivateKeyString / PublicKeyString(salt/crypt.py#L513-L534)不进入路径缓存,但同样享有实例级签名器 / 验证器懒缓存带来的单次构造收益。

需要说明的是,本修复针对的是 master 侧 MWorker 进程中的重复 PEM 解析与 libcrypto 对象分配开销,其收益在拥有大量 minion、认证与消息验证频繁的繁忙 master 上最为明显;同时,FIPS 模式下的 SHA1 算法拦截逻辑(_enforce_fips、_verify 中的 FIPS 分支,见 salt/crypt.py#L326-L334 与 salt/crypt.py#L458-L462)不受缓存影响,安全边界保持不变。

八、总结

changelog/69940.fixed.md 记录的这次修复,用两层正交的缓存策略解决了 Salt 认证路径上的真实性能热点:实例级懒缓存让每个密钥对象生命周期内只构造一次 libcrypto 的 RSAX931Signer/RSAX931Verifier;路径级 mtime 键控缓存让同一个公钥文件在进程内共享同一个 PublicKey 实例,密钥轮换通过 mtime 自动失效。而 verify/decrypt 的失败重试逻辑,则在缓存与磁盘状态出现分歧(mtime 未变的轮换)时优雅回退到“重新加载并重试一次”,既保证了性能优化,又完整保留了缓存前的行为契约。整套机制在 salt/crypt.py、salt/utils/rsax931.py 与 tests/pytests/unit/test_crypt.py 中均有完整实现与测试印证,是理解 Salt 密钥缓存设计与 libcrypto 集成方式的绝佳入口。

登录后查看全文
salt