Questo scenario descrive la rotazione regolare delle chiavi crittografiche. La rotazione delle chiavi è una misura di sicurezza critica che limita il rischio di compromissione.

Motivi di rotazione:

• Basata sul tempo - Raggiunta durata massima della chiave
• Basata sull'utilizzo - Massime operazioni/volume dati
• Incidente di sicurezza - Sospetto di compromissione
• Conformità - Requisiti normativi
• Upgrade algoritmo - Migrazione ad algoritmi più forti

using WvdS.Security.Cryptography.X509Certificates.Extensions.PQ;
 
public class KeyRotationService
{
    private readonly IKeyStore _keyStore;
    private readonly TimeSpan _maxKeyAge = TimeSpan.FromDays(365);
    private readonly long _maxOperations = 1_000_000;
 
    public KeyRotationService(IKeyStore keyStore)
    {
        _keyStore = keyStore;
    }
 
    public async Task<RotationResult> CheckAndRotateAsync(string keyId)
    {
        var metadata = await _keyStore.GetMetadataAsync(keyId);
 
        // Verificare condizioni di rotazione
        var needsRotation = ShouldRotate(metadata);
 
        if (!needsRotation.Required)
        {
            return new RotationResult
            {
                KeyId = keyId,
                Rotated = false,
                Reason = "Nessuna rotazione necessaria"
            };
        }
 
        return await PerformRotationAsync(keyId, metadata, needsRotation.Reason);
    }
 
    private RotationCheck ShouldRotate(KeyMetadata metadata)
    {
        // 1. Rotazione basata sul tempo
        if (DateTime.UtcNow - metadata.CreatedAt > _maxKeyAge)
        {
            return new RotationCheck(true, "Età massima raggiunta");
        }
 
        // 2. Rotazione basata sull'utilizzo
        if (metadata.OperationCount > _maxOperations)
        {
            return new RotationCheck(true, "Operazioni massime raggiunte");
        }
 
        // 3. Upgrade algoritmo (RSA → ML-DSA)
        if (metadata.Algorithm.StartsWith("RSA") && !metadata.Algorithm.Contains("ML-DSA"))
        {
            return new RotationCheck(true, "Migrazione PQ necessaria");
        }
 
        return new RotationCheck(false, null);
    }
 
    private async Task<RotationResult> PerformRotationAsync(
        string keyId,
        KeyMetadata oldMetadata,
        string reason)
    {
        using var ctx = PqCryptoContext.Initialize();
 
        // 1. Backup chiave vecchia
        await _keyStore.BackupAsync(keyId);
 
        // 2. Generare nuova chiave
        var newKeyId = $"{keyId}-{DateTime.UtcNow:yyyyMMdd}";
        using var newKey = ctx.GenerateKeyPair(PqAlgorithm.MlDsa65);
 
        // 3. Salvare nuova chiave
        await _keyStore.StoreAsync(newKeyId, newKey, new KeyMetadata
        {
            Algorithm = "ML-DSA-65",
            CreatedAt = DateTime.UtcNow,
            PreviousKeyId = keyId,
            RotationReason = reason
        });
 
        // 4. Contrassegnare vecchia chiave come "in rotazione"
        await _keyStore.SetStatusAsync(keyId, KeyStatus.Rotating);
 
        return new RotationResult
        {
            KeyId = keyId,
            NewKeyId = newKeyId,
            Rotated = true,
            Reason = reason
        };
    }
}

public class OverlappingKeyManager
{
    public async Task<byte[]> SignWithOverlap(
        byte[] data,
        string keyId,
        IKeyStore keyStore)
    {
        using var ctx = PqCryptoContext.Initialize();
 
        // Caricare chiave corrente
        var currentKey = await keyStore.GetCurrentKeyAsync(keyId);
 
        // Firmare con chiave corrente
        var signature = ctx.SignData(
            data,
            currentKey,
            HashAlgorithmName.SHA256
        );
 
        return signature;
    }
 
    public async Task<bool> VerifyWithOverlap(
        byte[] data,
        byte[] signature,
        string keyId,
        IKeyStore keyStore)
    {
        using var ctx = PqCryptoContext.Initialize();
 
        // Ottenere tutte le versioni valide della chiave
        var validKeys = await keyStore.GetValidKeysAsync(keyId);
 
        foreach (var key in validKeys)
        {
            try
            {
                if (ctx.VerifyData(data, signature, key.PublicKey, HashAlgorithmName.SHA256))
                {
                    return true;
                }
            }
            catch (CryptographicException)
            {
                // Chiave sbagliata, provare la prossima
                continue;
            }
        }
 
        return false;
    }
}

« 11.2 Archiviazione chiavi | Panoramica chiavi | 11.4 Backup chiavi »

Wolfgang van der Stille @ EMSR DATA d.o.o. - Post-Quantum Cryptography Professional