~~NOTOC~~
====== Scenarij 7.1: Hibridno šifriranje ======

<WRAP round info>
**Kategorija:** [[.:start|Šifriranje]] \\
**Kompleksnost:** Visoka \\
**Predpogoji:** Par ključev ML-KEM, klasični par ključev \\
**Ocenjeni čas:** 20-30 minut
</WRAP>

----

===== Opis =====

Ta scenarij opisuje **hibridno šifriranje** s klasičnimi (RSA/ECDH) in post-kvantnimi (ML-KEM) algoritmi. Hibridno šifriranje združuje oba postopka za zaščito tako pred klasičnimi kot pred kvantnimi napadi.

**Koncept:**
  * **Klasični ključ** - Zaščita pred današnjimi grožnjami
  * **PQ ključ** - Zaščita pred prihodnjimi kvantnimi računalniki
  * **Kombinirani ključ** - Varnost dokler je eden od obeh varen

----

===== Potek dela =====

<mermaid>
flowchart LR
    subgraph Posiljatelj
        DATA[Podatki] --> SYM[AES-256-GCM]
        KEY1[RSA/ECDH izmenjava ključev] --> KDF
        KEY2[ML-KEM enkapsulacija ključa] --> KDF
        KDF[HKDF kombinacija] --> SYM
    end

    subgraph Prejemnik
        SYM2[AES-256-GCM dešifriranje]
        KDF2[HKDF kombinacija] --> SYM2
        DEC1[RSA/ECDH dešifriranje] --> KDF2
        DEC2[ML-KEM dekapsulacija] --> KDF2
    end

    SYM --> |Šifriran tekst| SYM2

    style KDF fill:#e8f5e9
    style KDF2 fill:#e8f5e9
</mermaid>

----

===== Primer kode (C#) =====

<code csharp>
using WvdS.Security.Cryptography.X509Certificates.Extensions.PQ;
using System.Security.Cryptography;

using var ctx = PqCryptoContext.Initialize();

// Ključi prejemnika (oba algoritma)
var recipientEcdh = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP384);
var recipientMlKem = ctx.GenerateKeyPair(PqAlgorithm.MlKem768);

// === ŠIFRIRANJE ===

// 1. Klasična izmenjava ključev (ECDH)
using var senderEcdh = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP384);
var ecdhSharedSecret = senderEcdh.DeriveKeyMaterial(recipientEcdh.PublicKey);

// 2. PQ enkapsulacija ključa (ML-KEM)
var (mlKemCiphertext, mlKemSharedSecret) = ctx.Encapsulate(recipientMlKem.PublicKey);

// 3. Kombinacija ključev preko HKDF
var combinedSecret = CombineSecrets(ecdhSharedSecret, mlKemSharedSecret);
var encryptionKey = ctx.DeriveKey(
    combinedSecret,
    outputLength: 32,
    salt: null,
    info: Encoding.UTF8.GetBytes("hybrid-encryption-v1")
);

// 4. Šifriranje podatkov
var plaintext = Encoding.UTF8.GetBytes("Skrivno sporočilo");
var nonce = RandomNumberGenerator.GetBytes(12);
var ciphertext = new byte[plaintext.Length];
var tag = new byte[16];

using var aes = new OpenSslAesGcm(encryptionKey);
aes.Encrypt(nonce, plaintext, ciphertext, tag);

// 5. Sestavitev šifriranega sporočila
var encryptedMessage = new HybridEncryptedMessage
{
    EcdhPublicKey = senderEcdh.PublicKey.ExportSubjectPublicKeyInfo(),
    MlKemCiphertext = mlKemCiphertext,
    Nonce = nonce,
    Ciphertext = ciphertext,
    Tag = tag
};

Console.WriteLine($"Šifrirano: {encryptedMessage.Ciphertext.Length} bajtov");
</code>

----

===== Dešifriranje =====

<code csharp>
// === DEŠIFRIRANJE ===

using var ctx = PqCryptoContext.Initialize();

// Nalaganje zasebnih ključev prejemnika
var recipientEcdh = ctx.LoadEcdhPrivateKey("recipient-ecdh.key.pem", "Password!");
var recipientMlKem = ctx.LoadPrivateKey("recipient-mlkem.key.pem", "Password!");

// 1. Klasična izmenjava ključev
var senderEcdhPubKey = ECDiffieHellman.Create();
senderEcdhPubKey.ImportSubjectPublicKeyInfo(encryptedMessage.EcdhPublicKey, out _);
var ecdhSharedSecret = recipientEcdh.DeriveKeyMaterial(senderEcdhPubKey.PublicKey);

// 2. PQ dekapsulacija ključa
var mlKemSharedSecret = ctx.Decapsulate(recipientMlKem, encryptedMessage.MlKemCiphertext);

// 3. Kombinacija ključev
var combinedSecret = CombineSecrets(ecdhSharedSecret, mlKemSharedSecret);
var decryptionKey = ctx.DeriveKey(
    combinedSecret,
    outputLength: 32,
    salt: null,
    info: Encoding.UTF8.GetBytes("hybrid-encryption-v1")
);

// 4. Dešifriranje podatkov
var decrypted = new byte[encryptedMessage.Ciphertext.Length];

using var aes = new OpenSslAesGcm(decryptionKey);
aes.Decrypt(
    encryptedMessage.Nonce,
    encryptedMessage.Ciphertext,
    encryptedMessage.Tag,
    decrypted
);

var message = Encoding.UTF8.GetString(decrypted);
Console.WriteLine($"Dešifrirano: {message}");
</code>

----

===== Kombinacija skrivnosti (HKDF) =====

<code csharp>
private static byte[] CombineSecrets(byte[] secret1, byte[] secret2)
{
    // Združi in zgoščeni - preprosta ampak varna metoda
    // Alternativno: Vzporedni HKDF in XOR
    var combined = new byte[secret1.Length + secret2.Length];
    Buffer.BlockCopy(secret1, 0, combined, 0, secret1.Length);
    Buffer.BlockCopy(secret2, 0, combined, secret1.Length, secret2.Length);

    // HKDF Extract
    return HKDF.Extract(HashAlgorithmName.SHA256, combined);
}
</code>

----

===== Oblika sporočila =====

<code csharp>
public class HybridEncryptedMessage
{
    // Glava
    public string Version { get; set; } = "1.0";
    public string Algorithm { get; set; } = "ECDH-P384+ML-KEM-768/AES-256-GCM";

    // Enkapsulacija ključa
    public byte[] EcdhPublicKey { get; set; }   // ECDH efemerni javni ključ
    public byte[] MlKemCiphertext { get; set; } // ML-KEM šifriran tekst

    // Šifrirana vsebina
    public byte[] Nonce { get; set; }           // 12 bajtov
    public byte[] Ciphertext { get; set; }      // Spremenljivo
    public byte[] Tag { get; set; }             // 16 bajtov

    // Serializacija
    public byte[] Serialize()
    {
        using var ms = new MemoryStream();
        using var writer = new BinaryWriter(ms);

        writer.Write(Version);
        writer.Write(Algorithm);
        writer.Write(EcdhPublicKey.Length);
        writer.Write(EcdhPublicKey);
        writer.Write(MlKemCiphertext.Length);
        writer.Write(MlKemCiphertext);
        writer.Write(Nonce.Length);
        writer.Write(Nonce);
        writer.Write(Ciphertext.Length);
        writer.Write(Ciphertext);
        writer.Write(Tag.Length);
        writer.Write(Tag);

        return ms.ToArray();
    }
}
</code>

----

===== Kombinacije algoritmov =====

^  Kombinacija  ^  Klasično  ^  PQ  ^  Varnostni nivo  ^
| Standardno | ECDH P-384 | ML-KEM-768 | 192-bitov hibridno |
| Visoka varnost | ECDH P-521 | ML-KEM-1024 | 256-bitov hibridno |
| Podpora za podedovano | RSA-4096 + ECDH P-256 | ML-KEM-512 | 128-bitov hibridno |
| Minimalno | X25519 | ML-KEM-512 | 128-bitov hibridno |

----

===== Panožne zahteve =====

^  Panoga  ^  Min. varnost  ^  Priporočena kombinacija  ^
| **Finančni sektor** | 192-bitov | ECDH P-384 + ML-KEM-768 |
| **Zdravstvo** | 128-bitov | ECDH P-256 + ML-KEM-512 |
| **Vlada** | 256-bitov | ECDH P-521 + ML-KEM-1024 |
| **Energetika** | 192-bitov | ECDH P-384 + ML-KEM-768 |

----

===== Povezani scenariji =====

^  Povezava  ^  Scenarij  ^  Opis  ^
| **Komponenta** | [[.:key_encapsulation|7.2 Enkapsulacija ključev]] | Podrobnosti ML-KEM |
| **Aplikacija** | [[.:file_encryption|7.3 Šifriranje datotek]] | Praktična uporaba |
| **Povezano** | [[sl:int:pqcrypt:szenarien:schluessel:generierung|11.1 Generiranje ključev]] | Ustvarjanje ključev |

----

<< [[.:start|← Pregled šifriranja]] | [[sl:int:pqcrypt:szenarien:start|↑ Scenariji]] | [[.:key_encapsulation|7.2 Enkapsulacija ključev →]] >>

{{tag>szenario verschluesselung hybrid ml-kem ecdh}}

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