~~NOTOC~~
====== Scenarij 10.4: Hibridni TLS ======

<WRAP round info>
**Kategorija:** [[.:start|TLS/mTLS]] \\
**Kompleksnost:** ⭐⭐⭐⭐⭐ (Zelo visoka) \\
**Predpogoji:** OpenSSL 3.6+, PQ certifikati \\
**Predviden čas:** 45-60 minut
</WRAP>

----

===== Opis =====

Ta scenarij opisuje **hibridni TLS** - kombinacijo klasičnih in postkvantnih algoritmov v TLS rokovanju za maksimalno varnost v prehodnem obdobju.

**Hibridni pristopi:**
  * **Hibridna izmenjava ključev** - X25519 + ML-KEM-768
  * **Hibridni podpis** - ECDSA + ML-DSA-65
  * **Dvojni certifikati** - Klasični + PQ certifikat

<WRAP round tip>
**Zakaj hibridno?** Če je en algoritem prelomljen (klasični s kvantnim računalnikom, PQ z novimi napadi), povezava ostane varna prek drugega.
</WRAP>

----

===== TLS 1.3 hibridna izmenjava ključev =====

<mermaid>
sequenceDiagram
    participant Client as Odjemalec
    participant Server as Strežnik

    Client->>Server: ClientHello + key_share(X25519 + ML-KEM-768)
    Server->>Client: ServerHello + key_share(X25519 + ML-KEM-768)
    Note over Client,Server: Kombinacija obeh deljenih skrivnosti
    Client->>Server: Finished
    Server->>Client: Finished
    Note over Client,Server: Hibridno zavarovana povezava
</mermaid>

----

===== Primer kode: Hibridni TLS z OpenSSL 3.6 =====

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

// OpenSSL 3.6 hibridne skupine za izmenjavo ključev
public static class HybridTlsConfig
{
    // Hibridne skupine za izmenjavo ključev (OpenSSL 3.6+)
    public const string HYBRID_X25519_MLKEM768 = "x25519_mlkem768";
    public const string HYBRID_SECP384R1_MLKEM768 = "secp384r1_mlkem768";
    public const string HYBRID_SECP256R1_MLKEM512 = "secp256r1_mlkem512";

    [DllImport("libssl")]
    private static extern int SSL_CTX_set1_groups_list(IntPtr ctx, string groups);

    public static void ConfigureHybridKeyExchange(IntPtr sslContext)
    {
        // Konfiguracija hibridnih skupin (vrstni red prednosti)
        var groups = $"{HYBRID_X25519_MLKEM768}:{HYBRID_SECP384R1_MLKEM768}:X25519:secp384r1";

        int result = SSL_CTX_set1_groups_list(sslContext, groups);
        if (result != 1)
        {
            throw new CryptographicException("Konfiguracija hibridne izmenjave ključev ni uspela");
        }
    }
}
</code>

----

===== ASP.NET Core hibridni TLS strežnik =====

<code csharp>
using Microsoft.AspNetCore.Server.Kestrel.Core;
using System.Security.Authentication;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenAnyIP(443, listenOptions =>
    {
        listenOptions.UseHttps(httpsOptions =>
        {
            // Hibridni certifikat (ML-DSA + ECDSA)
            httpsOptions.ServerCertificate = LoadHybridCertificate();

            // Zahtevanje TLS 1.3 (predpogoj za hibridno)
            httpsOptions.SslProtocols = SslProtocols.Tls13;

            // OpenSSL konfiguracija za hibridno izmenjavo ključev
            httpsOptions.OnAuthenticate = (context, sslOptions) =>
            {
                // Šifrirni nabori za TLS 1.3
                sslOptions.CipherSuitesPolicy = new CipherSuitesPolicy(new[]
                {
                    TlsCipherSuite.TLS_AES_256_GCM_SHA384,
                    TlsCipherSuite.TLS_CHACHA20_POLY1305_SHA256
                });

                // Pogajanje o protokolu aplikacijske plasti
                sslOptions.ApplicationProtocols = new List<SslApplicationProtocol>
                {
                    SslApplicationProtocol.Http2,
                    SslApplicationProtocol.Http11
                };
            };
        });

        listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
    });
});

X509Certificate2 LoadHybridCertificate()
{
    using var ctx = PqCryptoContext.Initialize();

    // Dvojni certifikat z obema algoritmoma
    var cert = ctx.LoadCertificateWithPrivateKey(
        "server-hybrid.crt.pem",
        "server-hybrid.key.pem",
        "Password!"
    );

    return cert;
}
</code>

----

===== Ustvarjanje hibridnega certifikata =====

<code csharp>
public class HybridCertificateBuilder
{
    public X509Certificate2 CreateHybridServerCertificate(
        X509Certificate2 caCert,
        AsymmetricAlgorithm caKey,
        string[] dnsNames)
    {
        using var ctx = PqCryptoContext.Initialize();

        // Dvojni ključ: ECDSA + ML-DSA
        using var ecdsaKey = ECDsa.Create(ECCurve.NamedCurves.nistP384);
        using var mlDsaKey = ctx.GenerateKeyPair(PqAlgorithm.MlDsa65);

        var dn = new DnBuilder()
            .AddCN(dnsNames[0])
            .AddO("Example GmbH")
            .Build();

        // CSR z obema ključema
        var csr = ctx.CreateHybridCertificateRequest(
            classicalKey: ecdsaKey,
            pqKey: mlDsaKey,
            subject: dn,
            extensions: new ExtBuilder()
                .SubjectAlternativeName(dnsNames.Select(d => $"dns:{d}").ToArray())
                .Build()
        );

        // Izdaja hibridnega certifikata
        var cert = ctx.IssueHybridCertificate(
            csr,
            issuerCert: caCert,
            issuerKey: caKey,
            validDays: 365,
            extensions: new ExtBuilder()
                .BasicConstraints(ca: false, critical: true)
                .KeyUsage(KeyUsageFlags.DigitalSignature | KeyUsageFlags.KeyEncipherment)
                .ExtendedKeyUsage(ExtKeyUsage.ServerAuth)
                .SubjectKeyIdentifier(mlDsaKey.PublicKey)
                .AuthorityKeyIdentifier(caCert)
                // Hibridno specifična razširitev
                .AddCustomExtension(
                    oid: "1.3.6.1.4.1.99999.1.1",  // Primer OID
                    critical: false,
                    value: "hybrid:ecdsa-p384+ml-dsa-65"
                )
                .Build()
        );

        return cert;
    }
}
</code>

----

===== Nginx z OpenSSL 3.6 hibridno =====

<code nginx>
server {
    listen 443 ssl http2;
    server_name www.example.com;

    # Hibridni certifikat
    ssl_certificate     /etc/nginx/ssl/server-hybrid-chain.pem;
    ssl_certificate_key /etc/nginx/ssl/server-hybrid.key.pem;

    # Samo TLS 1.3
    ssl_protocols TLSv1.3;

    # Hibridne skupine za izmenjavo ključev (OpenSSL 3.6+)
    ssl_ecdh_curve x25519_mlkem768:secp384r1_mlkem768:X25519:secp384r1;

    # Podpisni algoritmi (hibridni)
    ssl_conf_command SignatureAlgorithms ed25519:ecdsa_secp384r1_sha384:mldsa65:hybrid_mldsa65_ecdsa_p384;

    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;

    location / {
        proxy_pass http://backend:8080;
    }
}
</code>

----

===== Konfiguracija hibridnega odjemalca =====

<code csharp>
public HttpClient CreateHybridTlsClient()
{
    var handler = new SocketsHttpHandler
    {
        SslOptions = new SslClientAuthenticationOptions
        {
            EnabledSslProtocols = SslProtocols.Tls13,

            // Šifrirni nabori (TLS 1.3 privzeti dobri)
            CipherSuitesPolicy = new CipherSuitesPolicy(new[]
            {
                TlsCipherSuite.TLS_AES_256_GCM_SHA384,
                TlsCipherSuite.TLS_CHACHA20_POLY1305_SHA256
            }),

            RemoteCertificateValidationCallback = (sender, certificate, chain, errors) =>
            {
                if (errors != SslPolicyErrors.None)
                {
                    Console.WriteLine($"TLS napaka: {errors}");
                    return false;
                }

                // Preverjanje hibridnega podpisa
                if (certificate is X509Certificate2 cert2)
                {
                    var algorithm = cert2.SignatureAlgorithm.FriendlyName;
                    Console.WriteLine($"Podpisni algoritem strežnika: {algorithm}");

                    // Preverjanje ali se uporablja PQ algoritem
                    if (!algorithm.Contains("ML-DSA") && !algorithm.Contains("hybrid"))
                    {
                        Console.WriteLine("OPOZORILO: Strežnik ne uporablja PQ certifikata");
                    }
                }

                return true;
            }
        }
    };

    return new HttpClient(handler);
}
</code>

----

===== Strategija nadomestka =====

<code csharp>
public class HybridTlsClientWithFallback
{
    public async Task<HttpResponseMessage> GetWithFallback(string url)
    {
        // Poskus 1: Hibridni TLS
        try
        {
            using var hybridClient = CreateHybridTlsClient();
            return await hybridClient.GetAsync(url);
        }
        catch (AuthenticationException ex) when (IsHybridNotSupported(ex))
        {
            Console.WriteLine("Hibridni TLS ni podprt, nadomestek na klasični...");
        }

        // Nadomestek: Klasični TLS 1.3
        using var classicClient = CreateClassicTlsClient();
        return await classicClient.GetAsync(url);
    }

    private bool IsHybridNotSupported(Exception ex)
    {
        return ex.Message.Contains("no common signature algorithm") ||
               ex.Message.Contains("unsupported group");
    }

    private HttpClient CreateClassicTlsClient()
    {
        var handler = new HttpClientHandler
        {
            SslProtocols = SslProtocols.Tls13
        };
        return new HttpClient(handler);
    }
}
</code>

----

===== Matrika združljivosti =====

^  Komponenta  ^  Hibridna izmenjava ključev  ^  Hibridni podpis  ^
| OpenSSL 3.6+ | Da | Da |
| BoringSSL | Da (eksperimentalno) | Ne |
| Windows SChannel | Ne (še ne) | Ne |
| NSS (Firefox) | Da (ML-KEM) | Ne |
| .NET 9+ | Da (z OpenSSL) | Da |

----

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

^  Panoga  ^  Časovnica  ^  Zahteva  ^
| **BSI TR-02102** | Od 2025 | Hibridno priporočeno |
| **NIST** | Od 2024 | ML-KEM za izmenjavo ključev |
| **Finance (PCI)** | 2025-2027 | Načrt migracije na PQ |
| **Vlada** | Od 2025 | Hibridno obvezno (US NSA CNSA 2.0) |

----

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

^  Povezava  ^  Scenarij  ^  Opis  ^
| **Predpogoj** | [[.:server_setup|10.1 TLS strežnik]] | Osnovna nastavitev |
| **Predpogoj** | [[.:mtls_deployment|10.3 Uvajanje mTLS]] | mTLS infrastruktura |
| **Povezano** | [[sl:int:pqcrypt:szenarien:verschluesselung:key_encapsulation|7.2 Enkapsulacija ključev]] | ML-KEM |
| **Povezano** | [[sl:int:pqcrypt:konzepte:algorithmen|Algoritmi]] | PQ osnove |

----

<< [[.:mtls_deployment|← 10.3 Uvajanje mTLS]] | [[.:start|↑ Pregled TLS]] | [[sl:int:pqcrypt:szenarien:start|→ Vsi scenariji]] >>

{{tag>scenarij tls hibridni post-quantum ml-kem ml-dsa openssl}}

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