Rollback-Strategie

Notfall-Pläne und Verfahren für die Rückkehr zur klassischen PKI bei Hybrid-Problemen.

Trigger: Ein Server funktioniert nicht mit Hybrid-Zertifikat.

#!/bin/bash
# rollback-single.sh - Einzelnes Zertifikat zurücksetzen
 
SERVER="$1"
CERT_NAME="$2"
 
if [ -z "$SERVER" ] || [ -z "$CERT_NAME" ]; then
    echo "Usage: $0 <server> <cert-name>"
    exit 1
fi
 
echo "Rollback für $SERVER/$CERT_NAME"
 
# 1. Backup des Hybrid-Zertifikats
ssh "$SERVER" "cp /etc/ssl/certs/${CERT_NAME}.pem /etc/ssl/certs/${CERT_NAME}.pem.hybrid-backup"
 
# 2. Classic-Zertifikat wiederherstellen (falls vorhanden)
if [ -f "/backup/certs/${SERVER}/${CERT_NAME}-classic.pem" ]; then
    scp "/backup/certs/${SERVER}/${CERT_NAME}-classic.pem" "$SERVER:/etc/ssl/certs/${CERT_NAME}.pem"
else
    # Neu ausstellen mit Classic-CA
    echo "Stelle Classic-Zertifikat neu aus..."
    ssh "$SERVER" "openssl req -new -key /etc/ssl/private/${CERT_NAME}.key -out /tmp/rollback.csr -subj \"/CN=$SERVER\""
    scp "$SERVER:/tmp/rollback.csr" "/tmp/rollback-$SERVER.csr"
 
    openssl ca -config /etc/pki/classic/openssl.cnf \
        -in "/tmp/rollback-$SERVER.csr" \
        -out "/tmp/rollback-$SERVER.pem" \
        -days 365 -batch
 
    scp "/tmp/rollback-$SERVER.pem" "$SERVER:/etc/ssl/certs/${CERT_NAME}.pem"
fi
 
# 3. Service neuladen
ssh "$SERVER" "systemctl reload nginx || systemctl reload apache2"
 
# 4. Verifizieren
ssh "$SERVER" "openssl s_client -connect localhost:443 -brief" 2>/dev/null | head -5
 
echo "Rollback abgeschlossen für $SERVER"

Trigger: Mehrere Server eines Services betroffen.

#!/bin/bash
# rollback-service.sh - Alle Server eines Services zurücksetzen
 
SERVICE="$1"
SERVERS_FILE="/etc/pki/inventory/${SERVICE}-servers.txt"
 
if [ ! -f "$SERVERS_FILE" ]; then
    echo "Server-Liste nicht gefunden: $SERVERS_FILE"
    exit 1
fi
 
echo "=== Service-Rollback für $SERVICE ==="
echo "Server: $(wc -l < "$SERVERS_FILE")"
 
# Parallel auf allen Servern
cat "$SERVERS_FILE" | parallel -j 10 '
    echo "Rollback: {}"
    ./rollback-single.sh {} server-cert
'
 
echo "=== Verifizierung ==="
cat "$SERVERS_FILE" | while read server; do
    status=$(curl -sk "https://$server/health" 2>/dev/null && echo "OK" || echo "FAIL")
    echo "$server: $status"
done

Trigger: Hybrid-CA-Zertifikat hat Problem.

#!/bin/bash
# rollback-ca.sh - Auf Classic-CA zurückwechseln
 
echo "=== CA-ROLLBACK ==="
echo "WARNUNG: Dies wechselt die Signing-CA für alle neuen Zertifikate!"
read -p "Fortfahren? (yes/no): " confirm
[ "$confirm" != "yes" ] && exit 1
 
# 1. Backup aktuelle Konfiguration
cp /etc/pki/CA/openssl.cnf /etc/pki/CA/openssl.cnf.hybrid-backup
cp -r /etc/pki/CA/issued /etc/pki/CA/issued-hybrid-backup
 
# 2. Classic-CA aktivieren
ln -sf /etc/pki/classic/openssl.cnf /etc/pki/CA/openssl.cnf
export CA_CERT=/etc/pki/classic/intermediate-ca.pem
export CA_KEY=/etc/pki/classic/intermediate-ca.key
 
# 3. Neue CRL mit Classic-CA generieren
openssl ca -config /etc/pki/CA/openssl.cnf -gencrl -out /var/www/pki/crl.pem
 
# 4. OCSP-Responder neustarten (falls vorhanden)
systemctl restart ocsp-responder
 
# 5. Dokumentation
echo "$(date -Iseconds) CA-ROLLBACK: Wechsel zu Classic-CA" >> /var/log/pki-rollback.log
 
echo "CA-Rollback abgeschlossen."
echo "Neue Zertifikate werden jetzt mit Classic-CA signiert."

Trigger: Katastrophale Probleme mit Hybrid-PKI.

#!/bin/bash
# rollback-complete.sh - Komplettes Rollback zur Classic-PKI
 
echo "========================================"
echo "     KOMPLETTES PKI-ROLLBACK"
echo "========================================"
echo ""
echo "WARNUNG: Dies wird:"
echo "  1. Alle Hybrid-Zertifikate widerrufen"
echo "  2. Alle Server auf Classic umstellen"
echo "  3. Die Hybrid-CA deaktivieren"
echo ""
read -p "Geben Sie 'ROLLBACK' ein um fortzufahren: " confirm
[ "$confirm" != "ROLLBACK" ] && exit 1
 
LOG="/var/log/pki-complete-rollback-$(date +%Y%m%d-%H%M%S).log"
exec > >(tee -a "$LOG") 2>&1
 
echo "Start: $(date -Iseconds)"
 
# 1. Alle Hybrid-Zertifikate identifizieren
echo "=== Phase 1: Inventur ==="
find /etc/pki/hybrid/issued -name "*.pem" > /tmp/hybrid-certs.txt
echo "Hybrid-Zertifikate: $(wc -l < /tmp/hybrid-certs.txt)"
 
# 2. Server-Liste erstellen
echo "=== Phase 2: Server-Mapping ==="
# (Server → Zertifikat Mapping aus CMDB oder Inventory)
 
# 3. Classic-Zertifikate für alle ausstellen
echo "=== Phase 3: Classic Re-Issue ==="
while read cert; do
    serial=$(openssl x509 -in "$cert" -serial -noout | cut -d= -f2)
    subject=$(openssl x509 -in "$cert" -subject -noout | sed 's/subject=//')
 
    echo "Re-Issue: $subject"
    # Hier: Classic-Zertifikat ausstellen
done < /tmp/hybrid-certs.txt
 
# 4. Server aktualisieren
echo "=== Phase 4: Deployment ==="
# (Parallel auf allen Servern Classic-Certs deployen)
 
# 5. Hybrid-Zertifikate widerrufen
echo "=== Phase 5: Revocation ==="
while read cert; do
    openssl ca -config /etc/pki/hybrid/openssl.cnf -revoke "$cert" -crl_reason superseded
done < /tmp/hybrid-certs.txt
 
# 6. Finale CRL
openssl ca -config /etc/pki/hybrid/openssl.cnf -gencrl -out /var/www/pki/hybrid-final.crl
 
# 7. Hybrid-CA offline nehmen
echo "=== Phase 6: Hybrid-CA Deaktivierung ==="
mv /etc/pki/hybrid /etc/pki/hybrid-DISABLED-$(date +%Y%m%d)
 
echo "=== ROLLBACK ABGESCHLOSSEN ==="
echo "Ende: $(date -Iseconds)"
echo "Log: $LOG"

# Rollback-Test Script
#!/bin/bash
TEST_SERVER="test-server.example.com"
 
echo "=== Rollback-Test $(date) ==="
 
# Aktuellen Status speichern
openssl s_client -connect "$TEST_SERVER:443" -brief 2>/dev/null > /tmp/before.txt
 
# Rollback ausführen
./rollback-single.sh "$TEST_SERVER" server-cert
 
# Neuen Status prüfen
openssl s_client -connect "$TEST_SERVER:443" -brief 2>/dev/null > /tmp/after.txt
 
# Vergleich
echo "Vorher:"
grep "Signature" /tmp/before.txt
echo "Nachher:"
grep "Signature" /tmp/after.txt
 
# Wiederherstellen
echo "Stelle Hybrid wieder her..."
# ...

Bei jedem Rollback dokumentieren:

• Classic → Hybrid – Migration
• Disaster Recovery – Größere Ausfälle
• Zertifikat widerrufen – Einzelne Revocation

« ← Parallel-Betrieb | → Inventur »

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