Sie befinden sich hier: start » it » Documentazione interna » Libreria WvdS Crypto » 6. Scenari » 1. Costruzione dell'infrastruttura PKI » Scenario 1.3: Costruire gerarchia CA multilivello

Inhaltsverzeichnis

Scenario 1.3: Costruire gerarchia CA multilivello

Categoria: Infrastruttura PKI
Complessità: Alta
Prerequisiti: 1.1 Root-CA, 1.2 Intermediate-CA
Tempo stimato: 1-2 ore

Descrizione

Questo scenario descrive la costruzione di una gerarchia PKI multilivello con Intermediate-CA specializzate per diversi scopi d'uso. Una gerarchia CA ben strutturata consente gestione flessibile dei certificati, controlli di sicurezza granulari e revoca semplificata.

Cosa viene creato:

  • Root-CA (Offline, Trust Anchor)
  • Policy-CA (opzionale, per grandi organizzazioni)
  • Più Issuing-CA specializzate:
    • Server-CA: Certificati TLS server
    • Client-CA: Certificati mTLS client
    • User-CA: S/MIME e autenticazione utente
    • CodeSign-CA: Certificati code-signing
    • Device-CA: Certificati IoT/dispositivi

Vantaggi di una gerarchia strutturata:

  • Separazione delle responsabilità: Team diversi gestiscono CA diverse
  • Revoca granulare: Una CA compromessa riguarda solo un'area
  • Conformità: Policy diverse per ogni scopo d'uso
  • Scalabilità: Nuove CA possono essere aggiunte facilmente
  • Audit: Chiara assegnazione dei certificati alla CA emittente

Modelli di gerarchia

Modello A: Gerarchia a 2 livelli (Standard)

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

Caratteristiche:

  • Semplice da gestire
  • Root-CA firma direttamente tutte le Issuing-CA
  • Adatta per organizzazioni piccole e medie

Modello B: Gerarchia a 3 livelli (Enterprise)

                              ┌─────────────────────┐
                              │      Root-CA        │
                              │    (ML-DSA-87)      │
                              │    25 anni          │
                              │    pathLen=3        │
                              │    [OFFLINE/HSM]    │
                              └──────────┬──────────┘
                                         │
                    ┌────────────────────┴────────────────────┐
                    │                                         │
                    ▼                                         ▼
         ┌─────────────────────┐               ┌─────────────────────┐
         │    Policy-CA        │               │    Policy-CA        │
         │   (Produzione)      │               │   (Sviluppo)        │
         │   (ML-DSA-65)       │               │   (ML-DSA-65)       │
         │   15 anni           │               │   10 anni           │
         │   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 │
└─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘      └─────┬─────┘
      │             │             │             │                  │
      ▼             ▼             ▼             ▼                  ▼
   Cert.        Cert.          Code         Cert.Dev           Cert.Test
   Server       Client        Signing

Caratteristiche:

  • Maggiore sicurezza grazie a livello aggiuntivo
  • Separazione tra Produzione e Sviluppo
  • Policy-CA possono avere Certificate Policies diverse
  • Adatta per grandi organizzazioni con requisiti di conformità

Modello C: Cross-Certificazione (Multi-Root)

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

Caratteristiche:

  • Consente migrazione da crittografia classica a PQ
  • Entrambe le Root-CA sono mutuamente affidabili
  • I client possono fidarsi di entrambe le gerarchie

Diagramma di flusso

┌─────────────────────────────────────────────────────────────────────────────┐
│                    COSTRUZIONE GERARCHIA CA                                 │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 1: Creare Root-CA (Sistema Air-Gapped)                                │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Generare coppia chiavi ML-DSA-87                                         │
│  • pathLength = Numero di livelli pianificati                               │
│  • Validità: 20-25 anni                                                     │
│  • Salvare chiave offline                                                   │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 2: Pianificare struttura CA                                           │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Definire numero e tipi di Intermediate-CA                                │
│  • Definire convenzione di denominazione (struttura DN)                     │
│  • Definire Certificate Policies per tipo CA                                │
│  • Pianificare strategia di revoca (CRL/OCSP per CA)                        │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 3: Creare Policy-CA (opzionale, per gerarchia a 3 livelli)            │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Creare CSR con pathLength=1                                              │
│  • Far firmare da Root-CA                                                   │
│  • Assegnare OID Certificate Policy                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 4: Creare Issuing-CA                                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│  Per ogni Issuing-CA pianificata:                                           │
│    a) Generare coppia chiavi (ML-DSA-65)                                    │
│    b) Creare CSR con extensions specifiche                                  │
│    c) Far firmare dalla CA superiore (Root o Policy-CA)                     │
│    d) Impostare EKU (Extended Key Usage) secondo scopo d'uso                │
│    e) pathLength=0 (nessuna ulteriore Sub-CA)                               │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 5: Configurare Trust Store e Chain                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Creare Trust Store con Root-CA                                           │
│  • Creare CA-Chain per ogni Issuing-CA                                      │
│  • Distribuire Chain a client/server                                        │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 6: Infrastruttura di revoca                                           │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Configurare CRL Distribution Points per ogni CA                          │
│  • Configurare OCSP-Responder                                               │
│  • Pubblicare prime CRL (vuote)                                             │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ PASSO 7: Documentazione e Policy                                            │
├─────────────────────────────────────────────────────────────────────────────┤
│  • Documentare Certificate Policy (CP)                                      │
│  • Creare Certification Practice Statement (CPS)                            │
│  • Documentazione Key Ceremony                                              │
│  • Manuale operativo per amministratori CA                                  │
└─────────────────────────────────────────────────────────────────────────────┘

Funzioni coinvolte

Area Funzione FFI Descrizione
Chiavi wvds_sec_crypto_x509_keypair_generate_mldsa() Chiavi ML-DSA per CA
DN wvds_sec_crypto_x509_dn_create() Distinguished Names
DN wvds_sec_crypto_x509_dn_add_component() Aggiungere CN, O, OU
CSR wvds_sec_crypto_x509_csr_create() Creare CSR
CSR wvds_sec_crypto_x509_csr_sign() Firmare CSR
Extensions wvds_sec_crypto_x509_ext_set_basic_constraints() CA + pathLength
Extensions wvds_sec_crypto_x509_ext_set_key_usage() keyCertSign, cRLSign
Extensions wvds_sec_crypto_x509_ext_set_extended_key_usage() EKU per specializzazione
Extensions wvds_sec_crypto_x509_ext_set_certificate_policies() OID Policy
Extensions wvds_sec_crypto_x509_ext_set_name_constraints() Limitazioni namespace
Extensions wvds_sec_crypto_x509_ext_set_policy_constraints() Requisiti policy
Certificato wvds_sec_crypto_x509_cert_create_from_csr() Emettere certificato CA
Chain wvds_sec_crypto_x509_chain_create() Handle Chain
Chain wvds_sec_crypto_x509_chain_add_cert() Aggiungere certificato
Trust Store wvds_sec_crypto_x509_trust_store_create() Creare Trust Store
Validazione wvds_sec_crypto_x509_validate_chain() Validare Chain

Esempio codice: Gerarchia a 2 livelli completa

C# (.NET Wrapper)

using System;
using System.IO;
using System.Collections.Generic;
using WvdS.Security.Cryptography.X509Certificates.Extensions.PQ;
 
namespace CaHierarchyExample
{
    /// <summary>
    /// Crea una gerarchia CA a 2 livelli completa con Issuing-CA specializzate
    /// </summary>
    class Program
    {
        // Password (in produzione: inserire in modo sicuro o da HSM!)
        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"
        };
 
        // URL base per revoca
        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: Costruzione gerarchia CA             ║");
            Console.WriteLine("╚══════════════════════════════════════════════════════════╝\n");
 
            // ══════════════════════════════════════════════════════════════════════
            // PASSO 1: Creare Root-CA
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ PASSO 1: Creare Root-CA                                 │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            var (rootCert, rootKey) = CreateRootCA(context);
 
            // ══════════════════════════════════════════════════════════════════════
            // PASSO 2: Creare Issuing-CA
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ PASSO 2: Creare Issuing-CA                              │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            var issuingCAs = new List<(PqCertificate cert, string name)>();
 
            // 2.1 Server-CA (per certificati TLS server)
            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 (per certificati mTLS client)
            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 (per 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  // Più breve per Code-Signing
            });
            issuingCAs.Add((codeSignCA, "codesign"));
 
            // 2.4 Device-CA (per IoT/Dispositivi)
            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"));
 
            // ══════════════════════════════════════════════════════════════════════
            // PASSO 3: Creare CA-Chain
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ PASSO 3: Creare CA-Chain                                │");
            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}");
            }
 
            // Chain completa con tutte le 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 (tutte le CA)");
 
            // ══════════════════════════════════════════════════════════════════════
            // PASSO 4: Creare Trust Store
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ PASSO 4: Creare Trust Store                             │");
            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)");
 
            // ══════════════════════════════════════════════════════════════════════
            // PASSO 5: Validazione
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n┌─────────────────────────────────────────────────────────┐");
            Console.WriteLine("│ PASSO 5: Validare gerarchia                             │");
            Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
 
            foreach (var (cert, name) in issuingCAs)
            {
                // Verificare firma da Root
                bool sigValid = cert.VerifySignature(rootCert);
 
                // Validazione Chain
                using var testChain = context.CreateCertificateChain();
                testChain.Add(cert);
                testChain.Add(rootCert);
                var result = context.ValidateChain(testChain, trustStore);
 
                Console.WriteLine($"  {name.ToUpper()}-CA:");
                Console.WriteLine($"    Firma:             {(sigValid ? "✓ OK" : "✗ ERRORE")}");
                Console.WriteLine($"    Validazione Chain: {(result.IsValid ? "✓ OK" : "✗ ERRORE")}");
            }
 
            // ══════════════════════════════════════════════════════════════════════
            // Riepilogo
            // ══════════════════════════════════════════════════════════════════════
            Console.WriteLine("\n╔══════════════════════════════════════════════════════════╗");
            Console.WriteLine("║                    RIEPILOGO                             ║");
            Console.WriteLine("╠══════════════════════════════════════════════════════════╣");
            Console.WriteLine("║ CA create:                                               ║");
            Console.WriteLine("║   • Root-CA        (ML-DSA-87, 20 anni, pathLen=4)       ║");
            Console.WriteLine("║   • Server-CA      (ML-DSA-65, 10 anni, pathLen=0)       ║");
            Console.WriteLine("║   • Client-CA      (ML-DSA-65, 10 anni, pathLen=0)       ║");
            Console.WriteLine("║   • CodeSign-CA    (ML-DSA-65,  8 anni, pathLen=0)       ║");
            Console.WriteLine("║   • Device-CA      (ML-DSA-65, 10 anni, pathLen=0)       ║");
            Console.WriteLine("╠══════════════════════════════════════════════════════════╣");
            Console.WriteLine("║ File creati:                                             ║");
            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("╚══════════════════════════════════════════════════════════╝");
 
            // Cleanup
            rootCert.Dispose();
            rootKey.Dispose();
            foreach (var (cert, _) in issuingCAs)
                cert.Dispose();
        }
 
        /// <summary>
        /// Crea la Root-CA con ML-DSA-87
        /// </summary>
        static (PqCertificate cert, PqKeyPair key) CreateRootCA(PqCryptoContext context)
        {
            Console.WriteLine("Generazione Root-CA (ML-DSA-87)...");
 
            // ML-DSA-87 per massima sicurezza nella 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);
 
            // Salvare
            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($"  Algoritmo:  ML-DSA-87");
            Console.WriteLine($"  Validità:   {cert.NotBefore:yyyy-MM-dd} - {cert.NotAfter:yyyy-MM-dd}");
            Console.WriteLine($"  pathLength: 4");
            Console.WriteLine($"  ✓ root-ca.crt.pem / root-ca.key.pem salvati");
 
            return (cert, keyPair);
        }
 
        /// <summary>
        /// Crea una Issuing-CA con configurazione specifica
        /// </summary>
        static PqCertificate CreateIssuingCA(
            PqCryptoContext context,
            PqCertificate issuerCert,
            PqKeyPair issuerKey,
            IssuingCAConfig config)
        {
            Console.WriteLine($"\nCreazione {config.CommonName}...");
 
            // ML-DSA-65 per 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 (opzionale, limita utilizzo)
            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)
            );
 
            // Creare CSR
            var csr = context.CreateCertificateRequest(dn, keyPair, extensions);
 
            // Firmare da Root-CA
            var cert = context.IssueCertificateFromRequest(
                csr, issuerCert, issuerKey, validity, extensions
            );
 
            // Salvare
            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($"  Algoritmo:  ML-DSA-65");
            Console.WriteLine($"  Validità:   {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 salvati");
 
            // Cleanup chiave (Certificate mantiene chiave pubblica)
            keyPair.Dispose();
            csr.Dispose();
 
            return cert;
        }
    }
 
    /// <summary>
    /// Configurazione per una 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;
    }
}

Configurazione raccomandata per tipo CA

Root-CA

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-87 Massima sicurezza per Trust Anchor longevo
Validità 20-25 anni Longevo, poiché modifica è onerosa
pathLength Numero livelli es. 4 per flessibilità
Key Usage keyCertSign, cRLSign Solo operazioni CA
Ubicazione Offline/HSM Massima protezione richiesta

Policy-CA (opzionale)

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-65 Buon rapporto sicurezza/prestazioni
Validità 12-15 anni Più breve di Root
pathLength 1 Consente un livello sottostante
Certificate Policies OID Policy Definisce policy di emissione
Ubicazione Online/HSM Uso raro, alta protezione

Server-CA

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-65 Bilanciamento sicurezza/prestazioni
Validità 8-10 anni Rotazione più breve di Root
pathLength 0 Nessuna Sub-CA consentita
Key Usage keyCertSign, cRLSign Operazioni CA
Extended Key Usage serverAuth (opzionale) Limitazione a TLS-Server
Ubicazione Online (protetta) Uso frequente per emissione

Client-CA

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-65 Bilanciamento sicurezza/prestazioni
Validità 8-10 anni Durata standard
pathLength 0 Nessuna Sub-CA
Extended Key Usage clientAuth Solo autenticazione client
Name Constraints Opzionale Limitazioni namespace DNS/Email

CodeSign-CA

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-65 o ML-DSA-87 Alta sicurezza per code-signing
Validità 6-8 anni Rotazione più breve raccomandata
pathLength 0 Nessuna Sub-CA
Extended Key Usage codeSigning Solo code-signing
Ubicazione HSM Protezione elevata per code-signing

Device-CA

Proprietà Raccomandazione Motivazione
Algoritmo ML-DSA-44 o ML-DSA-65 Prestazioni importanti per IoT
Validità 8-10 anni Considerare durata vita dispositivi
pathLength 0 Nessuna Sub-CA
Extended Key Usage clientAuth, serverAuth Comunicazione bidirezionale
Name Constraints Raccomandato Limitare a namespace dispositivi

OID Extended Key Usage (EKU)

Scopo d'uso OID Tipo 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

Ereditarietà EKU: Se una CA ha un EKU, i certificati emessi possono avere solo EKU che sono un sottoinsieme degli EKU della CA. Una Server-CA con solo serverAuth non può emettere certificati con clientAuth.

Name Constraints

Name Constraints limita il namespace in cui una CA può emettere certificati. 

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
)
, , , , , , ,

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

Zuletzt geändert: il 30/01/2026 alle 06:51

Seiten-Werkzeuge