Procedure per il backup e il ripristino delle chiavi e dei certificati CA.

#!/bin/bash
# ca-backup.sh - Creazione backup CA
 
BACKUP_DIR="/backup/pki/$(date +%Y%m%d)"
ENCRYPTION_KEY="/etc/pki/backup-key.pem"  # Chiave pubblica RSA per cifratura
 
mkdir -p "$BACKUP_DIR"
 
# 1. Chiavi private (cifrate)
echo "Backup chiavi private..."
for key in /etc/pki/CA/*.key; do
    keyname=$(basename "$key" .key)
 
    # Cifratura con AES-256
    openssl enc -aes-256-cbc -salt -pbkdf2 \
        -in "$key" \
        -out "$BACKUP_DIR/${keyname}.key.enc" \
        -pass file:/etc/pki/backup-passphrase.txt
 
    # Oppure con chiave pubblica RSA (asimmetrico)
    openssl pkeyutl -encrypt \
        -pubin -inkey "$ENCRYPTION_KEY" \
        -in "$key" \
        -out "$BACKUP_DIR/${keyname}.key.rsa-enc"
done
 
# 2. Certificati
echo "Backup certificati..."
cp /etc/pki/CA/*.pem "$BACKUP_DIR/"
 
# 3. Database CA
echo "Backup database CA..."
cp /etc/pki/CA/index.txt "$BACKUP_DIR/"
cp /etc/pki/CA/serial "$BACKUP_DIR/"
cp /etc/pki/CA/crlnumber "$BACKUP_DIR/"
 
# 4. Configurazione
cp /etc/pki/CA/openssl.cnf "$BACKUP_DIR/"
 
# 5. Certificati emessi
tar czf "$BACKUP_DIR/issued-certs.tar.gz" /etc/pki/CA/newcerts/
 
# 6. Checksum
cd "$BACKUP_DIR"
sha256sum * > SHA256SUMS
 
# 7. Archivio completo (opzionale)
cd /backup/pki
tar czf "ca-backup-$(date +%Y%m%d).tar.gz" "$(date +%Y%m%d)/"
 
echo "Backup completato: $BACKUP_DIR"

#!/bin/bash
# hsm-backup.sh - Backup chiavi HSM
 
# Luna HSM
/usr/safenet/lunaclient/bin/lunacm << EOF
partition backup
    partition name = ca-partition
    backup file = /backup/hsm/ca-partition-$(date +%Y%m%d).bak
EOF
 
# Thales HSM
nShield-cknfastrc backup --slotlist=0 --output=/backup/hsm/nshield-$(date +%Y%m%d).bak
 
# AWS CloudHSM
aws cloudhsmv2 create-cluster-backup --cluster-id <cluster-id>

#!/bin/bash
# shamir-split.sh - Distribuzione chiave ai depositari
 
KEY_FILE="/etc/pki/CA/root-ca.key"
SHARES=5
THRESHOLD=3
 
# Con ssss-split (Shamir's Secret Sharing Scheme)
cat "$KEY_FILE" | ssss-split -t $THRESHOLD -n $SHARES -w root-ca
 
# Risultato: 5 file (root-ca-1 a root-ca-5)
# Minimo 3 necessari per il ripristino
 
# Distribuzione ai depositari
echo "Distribuzione share ai depositari:"
echo "  Share 1 → Depositario A"
echo "  Share 2 → Depositario B"
echo "  Share 3 → Depositario C"
echo "  Share 4 → Cassaforte Off-Site"
echo "  Share 5 → HSM Escrow"

#!/bin/bash
# ca-restore.sh - Ripristino CA da backup
 
BACKUP_FILE="$1"
RESTORE_DIR="/etc/pki/CA"
 
if [ -z "$BACKUP_FILE" ]; then
    echo "Utilizzo: $0 <backup-file.tar.gz>"
    exit 1
fi
 
echo "=== RIPRISTINO CA ==="
echo "Backup: $BACKUP_FILE"
read -p "Continuare? (yes/no): " confirm
[ "$confirm" != "yes" ] && exit 1
 
# 1. Backup stato attuale
echo "Backup stato attuale..."
mv "$RESTORE_DIR" "${RESTORE_DIR}.pre-restore-$(date +%Y%m%d%H%M%S)"
 
# 2. Estrazione backup
echo "Estrazione backup..."
mkdir -p "$RESTORE_DIR"
tar xzf "$BACKUP_FILE" -C "$RESTORE_DIR" --strip-components=1
 
# 3. Decifratura chiavi private
echo "Decifratura chiavi private..."
for enc_key in "$RESTORE_DIR"/*.key.enc; do
    keyname=$(basename "$enc_key" .key.enc)
    openssl enc -aes-256-cbc -d -pbkdf2 \
        -in "$enc_key" \
        -out "$RESTORE_DIR/${keyname}.key" \
        -pass file:/etc/pki/backup-passphrase.txt
    rm "$enc_key"
done
 
# 4. Impostazione permessi
chmod 600 "$RESTORE_DIR"/*.key
chmod 644 "$RESTORE_DIR"/*.pem
chown -R root:root "$RESTORE_DIR"
 
# 5. Verifica
echo "Verifica ripristino..."
for key in "$RESTORE_DIR"/*.key; do
    cert="${key%.key}.pem"
    if [ -f "$cert" ]; then
        key_mod=$(openssl rsa -in "$key" -noout -modulus 2>/dev/null | md5sum)
        cert_mod=$(openssl x509 -in "$cert" -noout -modulus 2>/dev/null | md5sum)
        if [ "$key_mod" = "$cert_mod" ]; then
            echo "✓ $(basename "$key"): Corrispondenza Key/Cert"
        else
            echo "✗ $(basename "$key"): NON CORRISPONDONO!"
        fi
    fi
done
 
# 6. Avvio servizi CA
echo "Avvio servizi CA..."
systemctl start pki-ca
systemctl start ocsp-responder
 
echo "=== RIPRISTINO COMPLETATO ==="

#!/bin/bash
# shamir-combine.sh - Ripristino chiave da share
 
echo "Ripristino Shamir Share"
echo "Necessari minimo 3 di 5 share"
 
# Raccolta share (dai depositari)
ssss-combine -t 3 > /tmp/restored-key.tmp << EOF
<Share-1-da-Depositario-A>
<Share-2-da-Depositario-B>
<Share-3-da-Depositario-C>
EOF
 
# Verifica
openssl rsa -in /tmp/restored-key.tmp -check -noout
if [ $? -eq 0 ]; then
    echo "Chiave ripristinata con successo"
    mv /tmp/restored-key.tmp /etc/pki/CA/root-ca.key
    chmod 600 /etc/pki/CA/root-ca.key
else
    echo "ERRORE: Chiave non valida!"
    rm /tmp/restored-key.tmp
fi

#!/bin/bash
# verify-backup.sh - Verifica integrità backup
 
BACKUP_DIR="$1"
 
echo "=== Verifica backup ==="
 
# Verifica checksum
cd "$BACKUP_DIR"
sha256sum -c SHA256SUMS
if [ $? -ne 0 ]; then
    echo "ERRORE: Mismatch checksum!"
    exit 1
fi
 
# Verifica coppie chiave/certificato
for enc_key in *.key.enc; do
    keyname=$(basename "$enc_key" .key.enc)
    cert="${keyname}.pem"
 
    if [ ! -f "$cert" ]; then
        echo "ATTENZIONE: Nessun certificato per $keyname"
        continue
    fi
 
    # Decifratura e verifica (temporanea)
    openssl enc -aes-256-cbc -d -pbkdf2 \
        -in "$enc_key" \
        -out /tmp/verify.key \
        -pass file:/etc/pki/backup-passphrase.txt
 
    key_mod=$(openssl rsa -in /tmp/verify.key -noout -modulus 2>/dev/null | md5sum)
    cert_mod=$(openssl x509 -in "$cert" -noout -modulus 2>/dev/null | md5sum)
 
    if [ "$key_mod" = "$cert_mod" ]; then
        echo "✓ $keyname: OK"
    else
        echo "✗ $keyname: NON CORRISPONDONO!"
    fi
 
    rm /tmp/verify.key
done
 
echo "=== Verifica completata ==="

• Cerimonia delle chiavi – Generazione sicura chiavi
• Revoca di emergenza – In caso di compromissione
• Operatività – Manutenzione giornaliera

« ← Disaster Recovery | → Cerimonia delle chiavi »

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