Ovaj scenarij opisuje redovitu rotaciju kriptografskih ključeva. Rotacija ključeva je kritična sigurnosna mjera koja ograničava rizik kompromitacije.

Razlozi za rotaciju:

• Vremenski - Dosegnuta maksimalna životna dob ključa
• Količinski - Maksimalan broj operacija/volumen podataka
• Sigurnosni incident - Sumnja na kompromitaciju
• Usklađenost - Regulatorni zahtjevi
• Nadogradnja algoritma - Migracija na jače algoritme

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);
 
        // Provjera uvjeta za rotaciju
        var needsRotation = ShouldRotate(metadata);
 
        if (!needsRotation.Required)
        {
            return new RotationResult
            {
                KeyId = keyId,
                Rotated = false,
                Reason = "Rotacija nije potrebna"
            };
        }
 
        return await PerformRotationAsync(keyId, metadata, needsRotation.Reason);
    }
 
    private RotationCheck ShouldRotate(KeyMetadata metadata)
    {
        // 1. Vremenska rotacija
        if (DateTime.UtcNow - metadata.CreatedAt > _maxKeyAge)
        {
            return new RotationCheck(true, "Dosegnuta maksimalna starost");
        }
 
        // 2. Količinska rotacija
        if (metadata.OperationCount > _maxOperations)
        {
            return new RotationCheck(true, "Dosegnut maksimalni broj operacija");
        }
 
        // 3. Nadogradnja algoritma (RSA → ML-DSA)
        if (metadata.Algorithm.StartsWith("RSA") && !metadata.Algorithm.Contains("ML-DSA"))
        {
            return new RotationCheck(true, "Potrebna PQ-migracija");
        }
 
        return new RotationCheck(false, null);
    }
 
    private async Task<RotationResult> PerformRotationAsync(
        string keyId,
        KeyMetadata oldMetadata,
        string reason)
    {
        using var ctx = PqCryptoContext.Initialize();
 
        // 1. Sigurnosna kopija starog ključa
        await _keyStore.BackupAsync(keyId);
 
        // 2. Generiranje novog ključa
        var newKeyId = $"{keyId}-{DateTime.UtcNow:yyyyMMdd}";
        using var newKey = ctx.GenerateKeyPair(PqAlgorithm.MlDsa65);
 
        // 3. Pohrana novog ključa
        await _keyStore.StoreAsync(newKeyId, newKey, new KeyMetadata
        {
            Algorithm = "ML-DSA-65",
            CreatedAt = DateTime.UtcNow,
            PreviousKeyId = keyId,
            RotationReason = reason
        });
 
        // 4. Označavanje starog ključa kao "u rotaciji"
        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();
 
        // Učitavanje trenutnog ključa
        var currentKey = await keyStore.GetCurrentKeyAsync(keyId);
 
        // Potpisivanje s trenutnim ključem
        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();
 
        // Dohvaćanje svih valjanih verzija ključa
        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)
            {
                // Pogrešan ključ, pokušaj sljedeći
                continue;
            }
        }
 
        return false;
    }
}

public class VaultKeyRotation
{
    private readonly IVaultClient _vault;
 
    public async Task RotateKeyInVault(string keyPath)
    {
        // 1. Dohvaćanje trenutne verzije
        var current = await _vault.V1.Secrets.KeyValue.V2.ReadSecretAsync(
            path: keyPath,
            mountPoint: "secret"
        );
 
        var currentVersion = current.Data.Metadata.Version;
 
        // 2. Generiranje novog ključa
        using var ctx = PqCryptoContext.Initialize();
        using var newKey = ctx.GenerateKeyPair(PqAlgorithm.MlDsa65);
 
        // 3. Spremanje kao nova verzija (stara ostaje sačuvana)
        var secretData = new Dictionary<string, object>
        {
            ["privateKey"] = Convert.ToBase64String(newKey.ExportPkcs8()),
            ["publicKey"] = Convert.ToBase64String(newKey.PublicKey.Export()),
            ["algorithm"] = "ML-DSA-65",
            ["rotatedAt"] = DateTime.UtcNow.ToString("O"),
            ["previousVersion"] = currentVersion
        };
 
        await _vault.V1.Secrets.KeyValue.V2.WriteSecretAsync(
            path: keyPath,
            data: secretData,
            mountPoint: "secret"
        );
 
        Console.WriteLine($"Ključ rotiran: {keyPath} v{currentVersion} → v{currentVersion + 1}");
    }
 
    public async Task DestroyOldVersions(string keyPath, int keepVersions = 3)
    {
        // Brisanje starih verzija (Vault zadržava metapodatke)
        var metadata = await _vault.V1.Secrets.KeyValue.V2.ReadSecretMetadataAsync(
            path: keyPath,
            mountPoint: "secret"
        );
 
        var currentVersion = metadata.Data.CurrentVersion;
        var versionsToDestroy = new List<int>();
 
        for (int v = 1; v < currentVersion - keepVersions; v++)
        {
            versionsToDestroy.Add(v);
        }
 
        if (versionsToDestroy.Any())
        {
            await _vault.V1.Secrets.KeyValue.V2.DestroySecretVersionsAsync(
                path: keyPath,
                versions: versionsToDestroy,
                mountPoint: "secret"
            );
 
            Console.WriteLine($"Stare verzije izbrisane: {string.Join(", ", versionsToDestroy)}");
        }
    }
}

« ← 11.2 Pohrana ključeva | ↑ Pregled ključeva | 11.4 Sigurnosna kopija ključeva → »

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