AES加密中密钥轮换的高效重加密问题（ASP.NET场景）

核心思路 #

密钥轮换的关键是双密钥共存过渡，先让系统兼容新旧密钥，再通过后台异步任务完成批量重加密，最后安全淘汰旧密钥，全程不阻塞正常业务。

分步实现方案 #

1. 密钥仓库改造 #

给每个加密密钥添加唯一KeyId版本标识，同时在存储机密数据时，必须记录该数据对应的加密KeyId（可以把KeyId拼接在加密数据前，格式如{KeyId}:{Base64加密内容}，或者单独用字段存储）。

密钥实体示例：

public class AesEncryptionKey
{
    public string KeyId { get; set; } // 如"AES-202405"
    public byte[] Key { get; set; }
    public byte[] IV { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedTime { get; set; }
}

2. 加密解密逻辑适配 #

• 加密：默认使用最新版本的活跃密钥，加密后带上对应KeyId。
• 解密：先解析出数据关联的KeyId，用对应密钥解密，不管密钥新旧（只要标记为活跃）。

解密逻辑片段：

public async Task<string> DecryptAsync(string encryptedDataWithKeyId)
{
    var splitResult = encryptedDataWithKeyId.Split(':', 2);
    var targetKeyId = splitResult[0];
    var rawEncryptedData = splitResult[1];

    var key = await _keyStore.GetActiveKeyByIdAsync(targetKeyId);
    if (key == null)
        throw new InvalidOperationException("无法找到匹配的加密密钥");

    // AES解密实现
    using var aes = Aes.Create();
    aes.Key = key.Key;
    aes.IV = key.IV;
    var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
    
    var encryptedBytes = Convert.FromBase64String(rawEncryptedData);
    var decryptedBytes = decryptor.TransformFinalBlock(encryptedBytes, 0, encryptedBytes.Length);
    return Encoding.UTF8.GetString(decryptedBytes);
}

3. 异步批量重加密 #

用后台任务（ASP.NET Core BackgroundService、Hangfire 或 Quartz 均可）分批处理数据，避免一次性拉取大量数据导致系统压力：

• 按KeyId筛选出用旧密钥加密的数据，每次拉取100-500条（根据系统性能调整）。
• 对单条数据：用旧密钥解密 → 用新密钥加密 → 更新存储的加密内容和KeyId。
• 添加重试机制和错误日志，避免个别数据处理失败中断全局任务。

后台任务示例：

public class KeyRotationReencryptionService : BackgroundService
{
    private readonly IKeyStore _keyStore;
    private readonly ISecretRepository _secretRepo;
    private readonly IEncryptionService _encryptionService;
    private readonly ILogger<KeyRotationReencryptionService> _logger;

    public KeyRotationReencryptionService(IKeyStore keyStore, ISecretRepository secretRepo, IEncryptionService encryptionService, ILogger<KeyRotationReencryptionService> logger)
    {
        _keyStore = keyStore;
        _secretRepo = secretRepo;
        _encryptionService = encryptionService;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // 获取待淘汰的旧密钥和新密钥
        var oldKey = await _keyStore.GetOldestActiveKeyAsync();
        var newKey = await _keyStore.GetLatestActiveKeyAsync();
        if (oldKey.KeyId == newKey.KeyId) return;

        const int batchSize = 200;
        int offset = 0;

        while (!stoppingToken.IsCancellationRequested)
        {
            var secrets = await _secretRepo.GetSecretsByKeyIdAsync(oldKey.KeyId, batchSize, offset);
            if (!secrets.Any()) break;

            foreach (var secret in secrets)
            {
                try
                {
                    var plainText = await _encryptionService.DecryptAsync(secret.EncryptedContent);
                    secret.EncryptedContent = await _encryptionService.EncryptAsync(plainText, newKey.KeyId);
                    secret.KeyId = newKey.KeyId;
                    
                    await _secretRepo.UpdateSecretAsync(secret);
                    offset++;
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "重加密机密数据失败，ID: {SecretId}", secret.Id);
                }
            }

            // 每批处理后短暂休眠，降低系统负载
            await Task.Delay(800, stoppingToken);
        }

        // 所有数据处理完成，标记旧密钥为非活跃
        oldKey.IsActive = false;
        await _keyStore.UpdateKeyAsync(oldKey);
        _logger.LogInformation("密钥轮换完成，旧密钥 {KeyId} 已停用", oldKey.KeyId);
    }
}

4. 收尾与验证 #

• 重加密完成后，先通过查询确认所有数据都已切换到新KeyId，再彻底删除旧密钥（也可保留1-2周作为兜底）。
• 验证业务系统的加密解密功能完全正常，没有出现数据无法解密的情况。

高效优化点 #

• 增量处理：如果机密数据有更新时间字段，重加密时只处理密钥轮换前的数据，后续新数据自动用新密钥。
• 数据库优化：给KeyId字段加索引，加快旧密钥数据的筛选速度。
• 并行处理：单批次内可并行处理数据（注意控制数据库连接数和线程数，避免过载）。

内容的提问来源于stack exchange，提问作者xxxyyy