Inhaltsverzeichnis

Scenarij 1.3: Izgradnja višerazinske CA hijerarhije

Scenarij 1.3: Izgradnja višerazinske CA hijerarhije

Kategorija: PKI infrastruktura
Složenost: ⭐⭐⭐⭐ (Visoka)
Preduvjeti: 1.1 Root-CA, 1.2 Intermediate-CA
Procijenjeno vrijeme: 1-2 sata

Opis

Ovaj scenarij opisuje izgradnju višerazinske PKI hijerarhije sa specijaliziranim Intermediate-CA za različite namjene. Dobro strukturirana CA hijerarhija omogućuje fleksibilno upravljanje certifikatima, granularne sigurnosne kontrole i jednostavan opoziv.

Što se kreira:

Root-CA (Offline, sidrište povjerenja)
Policy-CA (opcijski, za velike organizacije)
Više specijaliziranih Issuing-CA:
- Server-CA: TLS server certifikati
- Client-CA: mTLS klijentski certifikati
- User-CA: S/MIME i korisnička autentifikacija
- CodeSign-CA: Code-Signing certifikati
- Device-CA: IoT/uređajni certifikati

Prednosti strukturirane hijerarhije:

Razdvajanje odgovornosti: Različiti timovi upravljaju različitim CA-ovima
Granularni opoziv: Kompromitiran CA utječe samo na jedno područje
Usklađenost: Različite politike po namjeni
Skalabilnost: Novi CA-ovi se mogu jednostavno dodati
Revizija: Jasna dodjela certifikata izdavajućem CA

Modeli hijerarhije

Model A: 2-razinska hijerarhija (Standard)

                         ┌─────────────────────┐
                         │      Root-CA        │
                         │    (ML-DSA-87)      │
                         │    20 godina        │
                         │    pathLen=4        │
                         │    [OFFLINE]        │
                         └──────────┬──────────┘
                                    │
           ┌────────────────────────┼────────────────────────┐
           │                        │                        │
           ▼                        ▼                        ▼
┌─────────────────────┐  ┌─────────────────────┐  ┌─────────────────────┐
│    Server-CA        │  │    Client-CA        │  │   CodeSign-CA       │
│   (ML-DSA-65)       │  │   (ML-DSA-65)       │  │   (ML-DSA-65)       │
│   10 godina         │  │   10 godina         │  │   10 godina         │
│   pathLen=0         │  │   pathLen=0         │  │   pathLen=0         │
│   [ONLINE]          │  │   [ONLINE]          │  │   [HSM]             │
└──────────┬──────────┘  └──────────┬──────────┘  └──────────┬──────────┘
           │                        │                        │
           ▼                        ▼                        ▼
    ┌──────────────┐        ┌──────────────┐        ┌──────────────┐
    │ Server-Certs │        │ Client-Certs │        │ CodeSign-    │
    │ (TLS)        │        │ (mTLS)       │        │ Certifikati  │
    └──────────────┘        └──────────────┘        └──────────────┘

Karakteristike:

Jednostavno upravljanje
Root-CA izravno potpisuje sve Issuing-CA
Pogodno za male do srednje organizacije

Model B: 3-razinska hijerarhija (Enterprise)

                              ┌─────────────────────┐
                              │      Root-CA        │
                              │    (ML-DSA-87)      │
                              │    25 godina        │
                              │    pathLen=3        │
                              │    [OFFLINE/HSM]    │
                              └──────────┬──────────┘
                                         │
                    ┌────────────────────┴────────────────────┐
                    │                                         │
                    ▼                                         ▼
         ┌─────────────────────┐               ┌─────────────────────┐
         │    Policy-CA        │               │    Policy-CA        │
         │   (Produkcija)      │               │   (Razvoj)          │
         │   (ML-DSA-65)       │               │   (ML-DSA-65)       │
         │   15 godina         │               │   10 godina         │
         │   pathLen=1         │               │   pathLen=1         │
         │   [ONLINE/HSM]      │               │   [ONLINE]          │
         └──────────┬──────────┘               └──────────┬──────────┘
                    │                                     │
      ┌─────────────┼─────────────┐           ┌──────────┴──────────┐
      │             │             │           │                     │
      ▼             ▼             ▼           ▼                     ▼
┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐      ┌───────────┐
│ Server-CA │ │ Client-CA │ │ CodeSign  │ │ Dev-CA    │      │ Test-CA   │
│ (Prod)    │ │ (Prod)    │ │ -CA       │ │           │      │           │
│ pathLen=0 │ │ pathLen=0 │ │ pathLen=0 │ │ pathLen=0 │      │ pathLen=0 │
└─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘      └─────┬─────┘
      │             │             │             │                  │
      ▼             ▼             ▼             ▼                  ▼
   Server        Client        Code         Dev-Certs          Test-Certs
   Certs         Certs         Signing

Karakteristike:

Viša sigurnost kroz dodatnu razinu
Razdvajanje produkcije i razvoja
Policy-CA mogu imati različite Certificate Policies
Pogodno za velike organizacije s compliance zahtjevima

Model C: Cross-certifikacija (Multi-Root)

┌─────────────────────┐                    ┌─────────────────────┐
│   Root-CA (Stari)   │◄──────────────────►│   Root-CA (Novi/PQ) │
│   (RSA/ECDSA)       │  Cross-certifikat  │   (ML-DSA-87)       │
│   [Legacy]          │                    │   [Post-Quantum]    │
└──────────┬──────────┘                    └──────────┬──────────┘
           │                                          │
           ▼                                          ▼
    Legacy hijerarhija                         PQ hijerarhija

Karakteristike:

Omogućuje migraciju s klasične na PQ kriptografiju
Oba Root-CA su međusobno pouzdana
Klijenti mogu vjerovati objema hijerarhijama

Dijagram tijeka

┌─────────────────────────────────────────────────────────────────────────────┐
│                    IZGRADNJA CA HIJERARHIJE                                 │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 1: Kreiranje Root-CA (Air-Gapped sustav)                              │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Generiranje ML-DSA-87 para ključeva                                      │
│  • pathLength = broj planiranih razina                                      │
│  • Valjanost: 20-25 godina                                                  │
│  • Offline osiguranje ključa                                                │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 2: Planiranje CA strukture                                            │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Definiranje broja i tipova Intermediate-CA                               │
│  • Definiranje konvencije imenovanja (DN struktura)                         │
│  • Definiranje Certificate Policies po tipu CA                              │
│  • Planiranje strategije opoziva (CRL/OCSP po CA)                           │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 3: Kreiranje Policy-CA (opcijski, za 3-razinsku hijerarhiju)          │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Kreiranje CSR-a s pathLength=1                                           │
│  • Potpisivanje od Root-CA                                                  │
│  • Dodjela Certificate Policy OID-a                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 4: Kreiranje Issuing-CA                                               │
├─────────────────────────────────────────────────────────────────────────────┤
│  Za svaki planirani Issuing-CA:                                             │
│    a) Generiranje para ključeva (ML-DSA-65)                                 │
│    b) Kreiranje CSR-a sa specifičnim ekstenzijama                           │
│    c) Potpisivanje od nadređenog CA (Root ili Policy-CA)                    │
│    d) Postavljanje EKU (Extended Key Usage) prema namjeni                   │
│    e) pathLength=0 (bez daljnje Sub-CA)                                     │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 5: Konfiguracija Trust Store-a i lanaca                               │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Kreiranje Trust Store-a s Root-CA                                        │
│  • Kreiranje CA lanaca za svaki Issuing-CA                                  │
│  • Distribucija lanaca klijentima/serverima                                 │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 6: Infrastruktura opoziva                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Postavljanje CRL Distribution Points za svaki CA                         │
│  • Konfiguracija OCSP Respondera                                            │
│  • Objava prvih (praznih) CRL-ova                                           │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ KORAK 7: Dokumentacija i politike                                           │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Dokumentiranje Certificate Policy (CP)                                   │
│  • Kreiranje Certification Practice Statement (CPS)                         │
│  • Dokumentacija Key Ceremony                                               │
│  • Operativni priručnik za CA administratore                                │
└─────────────────────────────────────────────────────────────────────────────┘

Uključene funkcije

Područje	FFI funkcija	Opis
Ključevi	`wvds_sec_crypto_x509_keypair_generate_mldsa()`	ML-DSA ključevi za CA
DN	`wvds_sec_crypto_x509_dn_create()`	Distinguished Names
DN	`wvds_sec_crypto_x509_dn_add_component()`	Dodavanje CN, O, OU
CSR	`wvds_sec_crypto_x509_csr_create()`	Kreiranje CSR-a
CSR	`wvds_sec_crypto_x509_csr_sign()`	Potpisivanje CSR-a
Ekstenzije	`wvds_sec_crypto_x509_ext_set_basic_constraints()`	CA + pathLength
Ekstenzije	`wvds_sec_crypto_x509_ext_set_key_usage()`	keyCertSign, cRLSign
Ekstenzije	`wvds_sec_crypto_x509_ext_set_extended_key_usage()`	EKU za specijalizaciju
Ekstenzije	`wvds_sec_crypto_x509_ext_set_certificate_policies()`	Policy OID-ovi
Ekstenzije	`wvds_sec_crypto_x509_ext_set_name_constraints()`	Namespace ograničenja
Ekstenzije	`wvds_sec_crypto_x509_ext_set_policy_constraints()`	Policy zahtjevi
Certifikat	`wvds_sec_crypto_x509_cert_create_from_csr()`	Izdavanje CA certifikata
Lanac	`wvds_sec_crypto_x509_chain_create()`	Chain handle
Lanac	`wvds_sec_crypto_x509_chain_add_cert()`	Dodavanje certifikata
Trust Store	`wvds_sec_crypto_x509_trust_store_create()`	Kreiranje Trust Store-a
Validacija	`wvds_sec_crypto_x509_validate_chain()`	Validacija lanca

Primjer koda: Potpuna 2-razinska hijerarhija

C# (.NET Wrapper)

using System;
using System.IO;
using System.Collections.Generic;
using WvdS.Security.Cryptography.X509Certificates.Extensions.PQ;
 
namespace CaHierarchyExample
{
    /// <summary>
    /// Kreira potpunu 2-razinsku CA hijerarhiju sa specijaliziranim Issuing-CA
    /// </summary>
    class Program
    {
        // Lozinke (u produkciji: sigurno unijeti ili iz HSM-a!)
        static readonly Dictionary<string, string> Passwords = new()
        {
            ["root"]     = "R00t#CA!V3ryStr0ng#2024",
            ["server"]   = "S3rv3r#CA!Str0ng#2024",
            ["client"]   = "Cl13nt#CA!Str0ng#2024",
            ["codesign"] = "C0d3S1gn#CA!Str0ng#2024",
            ["device"]   = "D3v1c3#CA!Str0ng#2024"
        };
 
        // Bazni URL-ovi za opoziv
        const string CRL_BASE_URL = "http://crl.datecpro.de";
        const string OCSP_URL = "http://ocsp.datecpro.de";
        const string CA_ISSUERS_URL = "http://ca.datecpro.de";
 
        static void Main(string[] args)
        {
            using var context = PqCryptoContext.Initialize();
 
            Console.WriteLine("╔══════════════════════════════════════════════════════════╗");
            Console.WriteLine("║     WvdS PQ-Crypto: Izgradnja CA hijerarhije             ║");
            Console.WriteLine("╚══════════════════════════════════════════════════════════╝\n");
 
            // ══════════════════════════════════════════════════════════════════════
            // KORAK 1: Kreiranje Root-CA
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ KORAK 1: Kreiranje Root-CA                              │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            var (rootCert, rootKey) = CreateRootCA(context);
 
            // ══════════════════════════════════════════════════════════════════════
            // KORAK 2: Kreiranje Issuing-CA
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ KORAK 2: Kreiranje Issuing-CA                           │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            var issuingCAs = new List<(PqCertificate cert, string name)>();
 
            // 2.1 Server-CA (za TLS server certifikate)
            var serverCA = CreateIssuingCA(context, rootCert, rootKey, new IssuingCAConfig
            {
                Name = "server",
                CommonName = "WvdS Server CA",
                OrganizationalUnit = "TLS Services",
                ExtendedKeyUsage = new[] { ExtendedKeyUsage.ServerAuth },
                ValidYears = 10
            });
            issuingCAs.Add((serverCA, "server"));
 
            // 2.2 Client-CA (za mTLS klijentske certifikate)
            var clientCA = CreateIssuingCA(context, rootCert, rootKey, new IssuingCAConfig
            {
                Name = "client",
                CommonName = "WvdS Client CA",
                OrganizationalUnit = "Client Authentication",
                ExtendedKeyUsage = new[] { ExtendedKeyUsage.ClientAuth },
                ValidYears = 10
            });
            issuingCAs.Add((clientCA, "client"));
 
            // 2.3 CodeSign-CA (za Code-Signing)
            var codeSignCA = CreateIssuingCA(context, rootCert, rootKey, new IssuingCAConfig
            {
                Name = "codesign",
                CommonName = "WvdS CodeSign CA",
                OrganizationalUnit = "Code Signing Services",
                ExtendedKeyUsage = new[] { ExtendedKeyUsage.CodeSigning },
                ValidYears = 8  // Kraće za Code-Signing
            });
            issuingCAs.Add((codeSignCA, "codesign"));
 
            // 2.4 Device-CA (za IoT/uređaje)
            var deviceCA = CreateIssuingCA(context, rootCert, rootKey, new IssuingCAConfig
            {
                Name = "device",
                CommonName = "WvdS Device CA",
                OrganizationalUnit = "IoT and Device Authentication",
                ExtendedKeyUsage = new[] { ExtendedKeyUsage.ClientAuth, ExtendedKeyUsage.ServerAuth },
                ValidYears = 10
            });
            issuingCAs.Add((deviceCA, "device"));
 
            // ══════════════════════════════════════════════════════════════════════
            // KORAK 3: Kreiranje CA lanaca
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ KORAK 3: Kreiranje CA lanaca                            │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            foreach (var (cert, name) in issuingCAs)
            {
                using var chain = context.CreateCertificateChain();
                chain.Add(cert);
                chain.Add(rootCert);
 
                string chainPath = $"{name}-ca-chain.pem";
                File.WriteAllText(chainPath, chain.ExportToPem());
                Console.WriteLine($"  ✓ {chainPath}");
            }
 
            // Potpuni lanac sa svim CA
            using var fullChain = context.CreateCertificateChain();
            foreach (var (cert, _) in issuingCAs)
                fullChain.Add(cert);
            fullChain.Add(rootCert);
 
            File.WriteAllText("full-ca-chain.pem", fullChain.ExportToPem());
            Console.WriteLine($"  ✓ full-ca-chain.pem (svi CA)");
 
            // ══════════════════════════════════════════════════════════════════════
            // KORAK 4: Kreiranje Trust Store-a
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ KORAK 4: Kreiranje Trust Store-a                        │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            using var trustStore = context.CreateTrustStore();
            trustStore.AddCertificate(rootCert);
 
            File.WriteAllText("trust-store.pem", rootCert.ExportToPem());
            Console.WriteLine("  ✓ trust-store.pem (Root-CA)");
 
            // ══════════════════════════════════════════════════════════════════════
            // KORAK 5: Validacija
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ KORAK 5: Validacija hijerarhije                         │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            foreach (var (cert, name) in issuingCAs)
            {
                // Provjera potpisa od Root
                bool sigValid = cert.VerifySignature(rootCert);
 
                // Validacija lanca
                using var testChain = context.CreateCertificateChain();
                testChain.Add(cert);
                testChain.Add(rootCert);
                var result = context.ValidateChain(testChain, trustStore);
 
                Console.WriteLine($"  {name.ToUpper()}-CA:");
                Console.WriteLine($"    Potpis:            {(sigValid ? "✓ OK" : "✗ GREŠKA")}");
                Console.WriteLine($"    Validacija lanca:  {(result.IsValid ? "✓ OK" : "✗ GREŠKA")}");
            }
 
            // ══════════════════════════════════════════════════════════════════════
            // Sažetak
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n╔══════════════════════════════════════════════════════════╗");
            Console.WriteLine("║                    SAŽETAK                               ║");
            Console.WriteLine("╠══════════════════════════════════════════════════════════╣");
            Console.WriteLine("║ Kreirani CA:                                             ║");
            Console.WriteLine("║   • Root-CA        (ML-DSA-87, 20 godina, pathLen=4)     ║");
            Console.WriteLine("║   • Server-CA      (ML-DSA-65, 10 godina, pathLen=0)     ║");
            Console.WriteLine("║   • Client-CA      (ML-DSA-65, 10 godina, pathLen=0)     ║");
            Console.WriteLine("║   • CodeSign-CA    (ML-DSA-65,  8 godina, pathLen=0)     ║");
            Console.WriteLine("║   • Device-CA      (ML-DSA-65, 10 godina, pathLen=0)     ║");
            Console.WriteLine("╠══════════════════════════════════════════════════════════╣");
            Console.WriteLine("║ Kreirane datoteke:                                       ║");
            Console.WriteLine("║   • root-ca.crt.pem / .key.pem                           ║");
            Console.WriteLine("║   • server-ca.crt.pem / .key.pem / -chain.pem            ║");
            Console.WriteLine("║   • client-ca.crt.pem / .key.pem / -chain.pem            ║");
            Console.WriteLine("║   • codesign-ca.crt.pem / .key.pem / -chain.pem          ║");
            Console.WriteLine("║   • device-ca.crt.pem / .key.pem / -chain.pem            ║");
            Console.WriteLine("║   • full-ca-chain.pem / trust-store.pem                  ║");
            Console.WriteLine("╚══════════════════════════════════════════════════════════╝");
 
            // Čišćenje
            rootCert.Dispose();
            rootKey.Dispose();
            foreach (var (cert, _) in issuingCAs)
                cert.Dispose();
        }
 
        /// <summary>
        /// Kreira Root-CA s ML-DSA-87
        /// </summary>
        static (PqCertificate cert, PqKeyPair key) CreateRootCA(PqCryptoContext context)
        {
            Console.WriteLine("Generiram Root-CA (ML-DSA-87)...");
 
            // ML-DSA-87 za najvišu sigurnost kod Root-CA
            var keyPair = context.GenerateKeyPair(PqAlgorithm.MlDsa87);
            keyPair.SelfTest();
 
            var dn = new DistinguishedNameBuilder()
                .AddCommonName("WvdS Root CA")
                .AddOrganization("DATECpro GmbH")
                .AddOrganizationalUnit("PKI Services")
                .AddCountry("DE")
                .AddLocality("München")
                .Build();
 
            var extensions = new X509ExtensionsBuilder()
                .AddBasicConstraints(isCa: true, pathLengthConstraint: 4, critical: true)
                .AddKeyUsage(KeyUsageFlags.KeyCertSign | KeyUsageFlags.CrlSign, critical: true)
                .AddSubjectKeyIdentifier(keyPair)
                .Build();
 
            var validity = new CertificateValidity(
                DateTime.UtcNow,
                DateTime.UtcNow.AddYears(20)
            );
 
            var cert = context.CreateRootCertificate(keyPair, dn, validity, extensions);
 
            // Spremanje
            File.WriteAllText("root-ca.crt.pem", cert.ExportToPem());
            File.WriteAllText("root-ca.key.pem", keyPair.ExportToEncryptedPem(Passwords["root"]));
 
            Console.WriteLine($"  Subject:    {cert.Subject}");
            Console.WriteLine($"  Serial:     {cert.SerialNumber}");
            Console.WriteLine($"  Algoritam:  ML-DSA-87");
            Console.WriteLine($"  Valjanost:  {cert.NotBefore:yyyy-MM-dd} - {cert.NotAfter:yyyy-MM-dd}");
            Console.WriteLine($"  pathLength: 4");
            Console.WriteLine($"  ✓ root-ca.crt.pem / root-ca.key.pem spremljeno");
 
            return (cert, keyPair);
        }
 
        /// <summary>
        /// Kreira Issuing-CA sa specifičnom konfiguracijom
        /// </summary>
        static PqCertificate CreateIssuingCA(
            PqCryptoContext context,
            PqCertificate issuerCert,
            PqKeyPair issuerKey,
            IssuingCAConfig config)
        {
            Console.WriteLine($"\nKreiram {config.CommonName}...");
 
            // ML-DSA-65 za Issuing-CA
            var keyPair = context.GenerateKeyPair(PqAlgorithm.MlDsa65);
            keyPair.SelfTest();
 
            var dn = new DistinguishedNameBuilder()
                .AddCommonName(config.CommonName)
                .AddOrganization("DATECpro GmbH")
                .AddOrganizationalUnit(config.OrganizationalUnit)
                .AddCountry("DE")
                .Build();
 
            // Extensions Builder
            var extBuilder = new X509ExtensionsBuilder()
                .AddBasicConstraints(isCa: true, pathLengthConstraint: 0, critical: true)
                .AddKeyUsage(KeyUsageFlags.KeyCertSign | KeyUsageFlags.CrlSign, critical: true)
                .AddSubjectKeyIdentifier(keyPair)
                .AddAuthorityKeyIdentifier(issuerCert)
                .AddCrlDistributionPoint($"{CRL_BASE_URL}/root-ca.crl")
                .AddAuthorityInfoAccess(OCSP_URL, $"{CA_ISSUERS_URL}/root-ca.crt");
 
            // Extended Key Usage (opcijski, ograničava uporabu)
            if (config.ExtendedKeyUsage?.Length > 0)
            {
                extBuilder.AddExtendedKeyUsage(config.ExtendedKeyUsage, critical: false);
            }
 
            var extensions = extBuilder.Build();
 
            var validity = new CertificateValidity(
                DateTime.UtcNow,
                DateTime.UtcNow.AddYears(config.ValidYears)
            );
 
            // Kreiranje CSR-a
            var csr = context.CreateCertificateRequest(dn, keyPair, extensions);
 
            // Potpisivanje od Root-CA
            var cert = context.IssueCertificateFromRequest(
                csr, issuerCert, issuerKey, validity, extensions
            );
 
            // Spremanje
            string baseName = config.Name;
            File.WriteAllText($"{baseName}-ca.crt.pem", cert.ExportToPem());
            File.WriteAllText($"{baseName}-ca.key.pem", keyPair.ExportToEncryptedPem(Passwords[baseName]));
 
            Console.WriteLine($"  Subject:    {cert.Subject}");
            Console.WriteLine($"  Issuer:     {cert.Issuer}");
            Console.WriteLine($"  Serial:     {cert.SerialNumber}");
            Console.WriteLine($"  Algoritam:  ML-DSA-65");
            Console.WriteLine($"  Valjanost:  {cert.NotBefore:yyyy-MM-dd} - {cert.NotAfter:yyyy-MM-dd}");
            Console.WriteLine($"  EKU:        {string.Join(", ", config.ExtendedKeyUsage ?? Array.Empty<ExtendedKeyUsage>())}");
            Console.WriteLine($"  ✓ {baseName}-ca.crt.pem / {baseName}-ca.key.pem spremljeno");
 
            // Čišćenje ključa (certifikat drži javni ključ)
            keyPair.Dispose();
            csr.Dispose();
 
            return cert;
        }
    }
 
    /// <summary>
    /// Konfiguracija za Issuing-CA
    /// </summary>
    class IssuingCAConfig
    {
        public string Name { get; set; }
        public string CommonName { get; set; }
        public string OrganizationalUnit { get; set; }
        public ExtendedKeyUsage[] ExtendedKeyUsage { get; set; }
        public int ValidYears { get; set; } = 10;
    }
}

Preporučena konfiguracija po tipu CA

Root-CA

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-87	Najviša sigurnost za dugotrajno sidrište povjerenja
Valjanost	20-25 godina	Dugotrajno, jer je promjena zahtjevna
pathLength	Broj razina	npr. 4 za fleksibilnost
Key Usage	keyCertSign, cRLSign	Samo CA operacije
Pohrana	Offline/HSM	Potrebna najviša zaštita

Policy-CA (opcijski)

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-65	Dobar omjer sigurnosti i performansi
Valjanost	12-15 godina	Kraće od Root
pathLength	1	Dopušta jednu razinu ispod
Certificate Policies	Policy OID	Definira pravila izdavanja
Pohrana	Online/HSM	Rijetka uporaba, visoka zaštita

Server-CA

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-65	Ravnoteža sigurnosti i performansi
Valjanost	8-10 godina	Kraća rotacija od Root
pathLength	0	Bez Sub-CA
Key Usage	keyCertSign, cRLSign	CA operacije
Extended Key Usage	serverAuth (opcijski)	Ograničenje na TLS servere
Pohrana	Online (zaštićeno)	Česta uporaba za izdavanje

Client-CA

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-65	Ravnoteža sigurnosti i performansi
Valjanost	8-10 godina	Standardni životni vijek
pathLength	0	Bez Sub-CA
Extended Key Usage	clientAuth	Samo klijentska autentifikacija
Name Constraints	Opcijski	DNS/Email namespace ograničenja

CodeSign-CA

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-65 ili ML-DSA-87	Visoka sigurnost za potpisivanje koda
Valjanost	6-8 godina	Preporučena kraća rotacija
pathLength	0	Bez Sub-CA
Extended Key Usage	codeSigning	Samo potpisivanje koda
Pohrana	HSM	Povećana zaštita za potpisivanje koda

Device-CA

Svojstvo	Preporuka	Obrazloženje
Algoritam	ML-DSA-44 ili ML-DSA-65	Performanse važne za IoT
Valjanost	8-10 godina	Uzeti u obzir životni vijek uređaja
pathLength	0	Bez Sub-CA
Extended Key Usage	clientAuth, serverAuth	Dvosmjerna komunikacija
Name Constraints	Preporučeno	Ograničenje na namespace uređaja

Extended Key Usage (EKU) OID-ovi

Namjena	OID	Tip CA
TLS Server Authentication	1.3.6.1.5.5.7.3.1	Server-CA
TLS Client Authentication	1.3.6.1.5.5.7.3.2	Client-CA, Device-CA
Code Signing	1.3.6.1.5.5.7.3.3	CodeSign-CA
Email Protection (S/MIME)	1.3.6.1.5.5.7.3.4	User-CA
Time Stamping	1.3.6.1.5.5.7.3.8	TSA-CA
OCSP Signing	1.3.6.1.5.5.7.3.9	OCSP Responder

EKU nasljeđivanje: Ako CA ima EKU, izdani certifikati smiju imati samo EKU koji su podskup CA EKU-a. Server-CA sa samo serverAuth ne može izdavati certifikate s clientAuth.

Name Constraints

Name Constraints ograničavaju namespace u kojem CA smije izdavati certifikate.

wvds_sec_crypto_x509_ext_set_name_constraints(
    ext,
    permitted_dns: ["datecpro.de", ".datecpro.de"],
    permitted_email: ["@datecpro.de"],
    excluded_dns: ["external.datecpro.de"],
    critical: true
)

scenarij, pki, hijerarhija, root-ca, intermediate-ca, policy-ca, eku, name-constraints

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