Classic → Hybrid Migration

Schrittweise Migration von klassischer PKI (RSA/ECDSA) zu Hybrid-Modus (Klassisch + ML-DSA).

#!/bin/bash
# inventory-certs.sh - Zertifikats-Inventur
 
echo "=== Zertifikats-Inventur $(date) ===" > inventory.csv
echo "Pfad,Subject,Algorithmus,Schlüsselgröße,Ablauf,Tage" >> inventory.csv
 
# Lokale Zertifikate
for cert in /etc/ssl/certs/*.pem /etc/pki/tls/certs/*.pem; do
    [ -f "$cert" ] || continue
 
    subject=$(openssl x509 -in "$cert" -subject -noout 2>/dev/null | sed 's/subject=//')
    algo=$(openssl x509 -in "$cert" -text -noout 2>/dev/null | grep "Public Key Algorithm" | awk '{print $4}')
    keysize=$(openssl x509 -in "$cert" -text -noout 2>/dev/null | grep "Public-Key:" | grep -oP '\d+')
    expiry=$(openssl x509 -in "$cert" -enddate -noout 2>/dev/null | cut -d= -f2)
    days=$(( ($(date -d "$expiry" +%s) - $(date +%s)) / 86400 ))
 
    echo "\"$cert\",\"$subject\",\"$algo\",\"$keysize\",\"$expiry\",\"$days\"" >> inventory.csv
done
 
# Remote Endpoints
ENDPOINTS=(
    "api.example.com:443"
    "web.example.com:443"
    "mail.example.com:465"
)
 
for endpoint in "${ENDPOINTS[@]}"; do
    host=${endpoint%:*}
    port=${endpoint#*:}
 
    cert_info=$(echo | openssl s_client -connect "$endpoint" -servername "$host" 2>/dev/null | openssl x509 -text -noout 2>/dev/null)
    # ... analog auswerten
done
 
echo "Inventur abgeschlossen: inventory.csv"

→ Details: Zertifikats-Inventur

# Docker-basierte Test-PKI
docker run -d --name test-ca \
    -v /test-pki:/pki \
    -e OPENSSL_CONF=/pki/openssl.cnf \
    alpine/openssl
 
# OpenSSL 3.6 für PQ
docker exec test-ca openssl version
# OpenSSL 3.6.0 ...
 
# Test: Hybrid-Zertifikat erstellen
docker exec test-ca openssl genpkey -algorithm ML-DSA-65 -out /pki/test-mldsa.key

Option A: Neue Hybrid Root-CA (empfohlen)

// Neue Hybrid Root-CA erstellen
using var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP384);
var request = new CertificateRequest(
    "CN=My Organization Root CA - Hybrid, O=My Organization",
    ecdsa,
    HashAlgorithmName.SHA384);
 
// CA Extensions
request.CertificateExtensions.Add(
    new X509BasicConstraintsExtension(true, true, 2, true));
request.CertificateExtensions.Add(
    new X509KeyUsageExtension(
        X509KeyUsageFlags.KeyCertSign | X509KeyUsageFlags.CrlSign,
        true));
 
// Hybrid Self-Signed (ECDSA + ML-DSA)
var hybridRoot = request.CreateSelfSigned(
    DateTimeOffset.UtcNow,
    DateTimeOffset.UtcNow.AddYears(25),
    CryptoMode.Hybrid);
 
// Export
File.WriteAllBytes("hybrid-root-ca.pfx",
    hybridRoot.Export(X509ContentType.Pfx, "secure-password"));

Option B: Cross-Certification (Übergang)

// Alte Root-CA cross-zertifiziert neue Hybrid-CA
using var oldRoot = new X509Certificate2("old-root.pfx", "password");
using var newHybridRoot = new X509Certificate2("hybrid-root.pfx", "password");
 
// Cross-Zertifikat erstellen
var crossCertRequest = new CertificateRequest(
    newHybridRoot.SubjectName,
    newHybridRoot.GetECDsaPublicKey()!,
    HashAlgorithmName.SHA384);
 
// Signiert von alter Root
var crossCert = crossCertRequest.Create(
    oldRoot,
    newHybridRoot.NotBefore,
    newHybridRoot.NotAfter,
    newHybridRoot.SerialNumberBytes.ToArray());

# Neue Hybrid Intermediate-CA
# 1. Schlüssel generieren
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-384 -out intermediate.key
 
# 2. CSR erstellen
openssl req -new -key intermediate.key \
    -out intermediate.csr \
    -subj "/CN=My Organization Intermediate CA - Hybrid/O=My Organization"
 
# 3. Von Hybrid-Root signieren (mit WvdS)

// Intermediate mit Hybrid-Root signieren
using var hybridRoot = new X509Certificate2("hybrid-root.pfx", "password");
 
var intermediateCsr = CertificateRequest.LoadSigningRequest(
    File.ReadAllBytes("intermediate.csr"),
    HashAlgorithmName.SHA384);
 
// CA Extensions hinzufügen
intermediateCsr.CertificateExtensions.Add(
    new X509BasicConstraintsExtension(true, true, 1, true));
 
var intermediate = intermediateCsr.Create(
    hybridRoot,
    DateTimeOffset.UtcNow,
    DateTimeOffset.UtcNow.AddYears(10),
    Guid.NewGuid().ToByteArray(),
    CryptoMode.Hybrid);

// Hybrid-signierte CRL erstellen
var crlBuilder = new CertificateRevocationListBuilder();
 
// Alte CRL-Einträge übernehmen
foreach (var entry in existingCrlEntries)
{
    crlBuilder.AddEntry(entry.SerialNumber, entry.RevocationDate, entry.Reason);
}
 
// Mit Hybrid-CA signieren
byte[] newCrl = crlBuilder.Build(
    hybridIntermediate,
    newCrlNumber,
    DateTimeOffset.UtcNow.AddDays(7),
    HashAlgorithmName.SHA384,
    CryptoMode.Hybrid);

Priorität-Matrix:

# Batch-Erneuerung mit Hybrid
for server in $(cat servers.txt); do
    # CSR erstellen
    ssh "$server" "openssl req -new -key /etc/ssl/private/server.key \
        -out /tmp/renew.csr -subj \"/CN=$server\""
 
    # CSR abholen
    scp "$server:/tmp/renew.csr" "./csrs/$server.csr"
 
    # Hybrid-Zertifikat ausstellen (via API oder Script)
    ./sign-hybrid.sh "./csrs/$server.csr" "./certs/$server.pem"
 
    # Zertifikat deployen
    scp "./certs/$server.pem" "$server:/etc/ssl/certs/server.pem"
    ssh "$server" "systemctl reload nginx"
done

// Client-Zertifikat mit Hybrid ausstellen
var clientCsr = CertificateRequest.LoadSigningRequest(csrBytes, HashAlgorithmName.SHA384);
 
clientCsr.CertificateExtensions.Add(
    new X509EnhancedKeyUsageExtension(
        new OidCollection { new Oid("1.3.6.1.5.5.7.3.2") }, // Client Auth
        false));
 
var clientCert = clientCsr.Create(
    intermediate,
    DateTimeOffset.UtcNow,
    DateTimeOffset.UtcNow.AddYears(1),
    Guid.NewGuid().ToByteArray(),
    CryptoMode.Hybrid);

→ Siehe CI/CD Code-Signing für Pipeline-Integration

# Prometheus Alert für Hybrid-Status
- alert: NonHybridCertificateInProduction
  expr: x509_cert_algorithm{env="production"} !~ ".*ML-DSA.*|.*Hybrid.*"
  for: 24h
  labels:
    severity: warning
  annotations:
    summary: "Nicht-Hybrid-Zertifikat in Produktion: {{ $labels.filepath }}"

# 1. Zur klassischen CA zurückwechseln
export CA_CERT=/etc/pki/CA/classic-intermediate.pem
export CA_KEY=/etc/pki/CA/classic-intermediate.key
 
# 2. Zertifikate mit klassischer CA neu ausstellen
./issue-classic.sh
 
# 3. Hybrid-CA-Zertifikate widerrufen (falls nötig)
./revoke-hybrid-certs.sh

→ Details: Rollback-Strategie

• Parallel-Betrieb – Alternative Strategie
• Inventur – Detaillierte Bestandsaufnahme
• Krypto-Modi – Hybrid erklärt

« ← Migration | → Parallel-Betrieb »

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