Gestion du Chiffrement de Fichiers sur macOS

Sécurisez les données sensibles sur vos appareils Roundfleet en utilisant des techniques avancées de chiffrement et déchiffrement de fichiers. Ce tutoriel couvre les méthodes de chiffrement OpenSSL, la gestion des clés d'entreprise, les politiques de sécurité, et la surveillance de conformité pour une protection complète des données.

Comprendre le Chiffrement de Fichiers sur macOS

Le chiffrement de fichiers protège les données sensibles en les convertissant en un format illisible qui ne peut être accessible qu'avec la clé de déchiffrement correcte. Bien que macOS offre FileVault pour le chiffrement complet du disque, le chiffrement sélectif de fichiers fournit un contrôle granulaire sur des documents et fichiers de données spécifiques.

Méthodes de Chiffrement Clés

DES (Data Encryption Standard) - Chiffrement hérité pour protection basique
AES-256-CBC - Standard de Chiffrement Avancé avec clés 256-bit
AES-256-GCM - AES avec Mode Galois/Counter pour chiffrement authentifié
ChaCha20-Poly1305 - Chiffrement de flux moderne avec authentification
RSA - Chiffrement à clé publique pour échange de clés et signatures numériques

Chiffrement de Fichier Basique

Chiffrement de Fichier Simple

#!/bin/bash

# Chiffrement de fichier basique utilisant OpenSSL
INPUT_FILE="/chemin/vers/original.txt"
OUTPUT_FILE="/chemin/vers/chiffre.txt"
PASSWORD="votre_mot_de_passe_securise"

openssl des -in "$INPUT_FILE" -out "$OUTPUT_FILE" -k "$PASSWORD"

echo "Fichier chiffré avec succès : $OUTPUT_FILE"

Chiffrement de Fichier Amélioré

#!/bin/bash

# Chiffrement de fichier amélioré avec validation
encrypt_file() {
    local input_file="$1"
    local output_file="$2"
    local password="$3"
    local algorithm="${4:-aes-256-cbc}"
    
    # Valider les paramètres d'entrée
    if [[ -z "$input_file" ]] || [[ -z "$output_file" ]] || [[ -z "$password" ]]; then
        echo "❌ Erreur : Paramètres requis manquants"
        echo "Usage : encrypt_file <fichier_entree> <fichier_sortie> <mot_de_passe> [algorithme]"
        return 1
    fi
    
    # Vérifier si le fichier d'entrée existe
    if [[ ! -f "$input_file" ]]; then
        echo "❌ Erreur : Le fichier d'entrée n'existe pas : $input_file"
        return 1
    fi
    
    # Créer le répertoire de sortie s'il n'existe pas
    local output_dir
    output_dir=$(dirname "$output_file")
    mkdir -p "$output_dir"
    
    echo "🔒 Chiffrement du fichier avec $algorithm..."
    echo "  Entrée : $input_file"
    echo "  Sortie : $output_file"
    
    # Effectuer le chiffrement
    if openssl "$algorithm" -in "$input_file" -out "$output_file" -k "$password" 2>/dev/null; then
        echo "✅ Fichier chiffré avec succès"
        
        # Vérifier que le fichier chiffré a été créé
        if [[ -f "$output_file" ]]; then
            local file_size
            file_size=$(stat -f%z "$output_file" 2>/dev/null || echo "0")
            echo "  Taille du fichier chiffré : ${file_size} octets"
        fi
        
        return 0
    else
        echo "❌ Échec du chiffrement"
        return 1
    fi
}

# Exemples d'usage
encrypt_file "/Users/jean/Documents/sensible.txt" "/Users/jean/Chiffre/sensible.enc" "monmotdepasse123" "aes-256-cbc"

Chiffrement AES-256 Fort

#!/bin/bash

# Chiffrement AES-256-CBC avancé avec sel
encrypt_file_aes256() {
    local input_file="$1"
    local output_file="$2"
    local password="$3"
    
    echo "🔐 Exécution du chiffrement AES-256-CBC..."
    
    # Utiliser AES-256-CBC avec sel pour sécurité renforcée
    if openssl aes-256-cbc -salt -in "$input_file" -out "$output_file" -k "$password"; then
        echo "✅ Chiffrement AES-256 terminé"
        
        # Générer le hachage du fichier pour vérification d'intégrité
        local hash
        hash=$(shasum -a 256 "$output_file" | cut -d' ' -f1)
        echo "  Hachage du fichier (SHA-256) : $hash"
        
        # Sauvegarder le hachage pour vérification
        echo "$hash" > "${output_file}.sha256"
        echo "  Hachage sauvegardé dans : ${output_file}.sha256"
        
        return 0
    else
        echo "❌ Échec du chiffrement AES-256"
        return 1
    fi
}

# Exemple d'usage
encrypt_file_aes256 "/chemin/vers/document.pdf" "/chemin/vers/document.pdf.enc" "mot_de_passe_fort_123!"

Déchiffrement de Fichier

Déchiffrement de Fichier Basique

#!/bin/bash

# Déchiffrement de fichier basique utilisant OpenSSL
INPUT_FILE="/chemin/vers/chiffre.txt"
OUTPUT_FILE="/chemin/vers/dechiffre.txt"
PASSWORD="votre_mot_de_passe_securise"

openssl des -d -in "$INPUT_FILE" -out "$OUTPUT_FILE" -k "$PASSWORD"

echo "Fichier déchiffré avec succès : $OUTPUT_FILE"

Déchiffrement de Fichier Avancé

#!/bin/bash

# Déchiffrement de fichier avancé avec vérification
decrypt_file() {
    local input_file="$1"
    local output_file="$2"
    local password="$3"
    local algorithm="${4:-aes-256-cbc}"
    
    # Valider les paramètres
    if [[ -z "$input_file" ]] || [[ -z "$output_file" ]] || [[ -z "$password" ]]; then
        echo "❌ Erreur : Paramètres requis manquants"
        echo "Usage : decrypt_file <fichier_entree> <fichier_sortie> <mot_de_passe> [algorithme]"
        return 1
    fi
    
    # Vérifier si le fichier chiffré existe
    if [[ ! -f "$input_file" ]]; then
        echo "❌ Erreur : Le fichier chiffré n'existe pas : $input_file"
        return 1
    fi
    
    echo "🔓 Déchiffrement du fichier avec $algorithm..."
    echo "  Entrée : $input_file"
    echo "  Sortie : $output_file"
    
    # Créer le répertoire de sortie
    local output_dir
    output_dir=$(dirname "$output_file")
    mkdir -p "$output_dir"
    
    # Effectuer le déchiffrement
    if openssl "$algorithm" -d -in "$input_file" -out "$output_file" -k "$password" 2>/dev/null; then
        echo "✅ Fichier déchiffré avec succès"
        
        # Vérifier le hachage si disponible
        verify_file_integrity "$input_file" "$output_file"
        
        return 0
    else
        echo "❌ Échec du déchiffrement - mot de passe incorrect ou fichier corrompu"
        return 1
    fi
}

# Vérifier l'intégrité du fichier
verify_file_integrity() {
    local encrypted_file="$1"
    local decrypted_file="$2"
    local hash_file="${encrypted_file}.sha256"
    
    if [[ -f "$hash_file" ]]; then
        echo "🔍 Vérification de l'intégrité du fichier..."
        local stored_hash expected_hash
        stored_hash=$(cat "$hash_file")
        
        # Pour la vérification, nous avons besoin du hachage du fichier original (ceci est un exemple simplifié)
        if [[ -f "$decrypted_file" ]]; then
            echo "  Vérification d'intégrité du fichier terminée"
        fi
    fi
}

# Exemple d'usage
decrypt_file "/chemin/vers/document.pdf.enc" "/chemin/vers/document_recupere.pdf" "mot_de_passe_fort_123!" "aes-256-cbc"

Opérations de Fichiers par Lots

Chiffrer Plusieurs Fichiers

#!/bin/bash

# Chiffrement par lots de plusieurs fichiers
batch_encrypt() {
    local source_dir="$1"
    local encrypted_dir="$2"
    local password="$3"
    local file_pattern="${4:-*}"
    
    echo "📁 Démarrage du chiffrement par lots..."
    echo "  Source : $source_dir"
    echo "  Cible : $encrypted_dir"
    echo "  Motif : $file_pattern"
    
    # Créer le répertoire chiffré
    mkdir -p "$encrypted_dir"
    
    local count=0
    local success=0
    
    # Traiter les fichiers correspondant au motif
    while IFS= read -r -d '' file; do
        if [[ -f "$file" ]]; then
            local relative_path
            relative_path=$(realpath --relative-to="$source_dir" "$file")
            local encrypted_file="$encrypted_dir/${relative_path}.enc"
            
            # Créer les sous-répertoires si nécessaire
            mkdir -p "$(dirname "$encrypted_file")"
            
            echo "  Traitement : $relative_path"
            
            if openssl aes-256-cbc -salt -in "$file" -out "$encrypted_file" -k "$password" 2>/dev/null; then
                ((success++))
                echo "    ✅ Chiffré"
            else
                echo "    ❌ Échec"
            fi
            
            ((count++))
        fi
    done < <(find "$source_dir" -name "$file_pattern" -type f -print0)
    
    echo "🎉 Chiffrement par lots terminé : $success/$count fichiers chiffrés"
}

# Exemple d'usage
batch_encrypt "/Users/jean/Documents" "/Users/jean/Chiffre" "mot_de_passe_lot123" "*.txt"

Déchiffrer Plusieurs Fichiers

#!/bin/bash

# Déchiffrement par lots de plusieurs fichiers
batch_decrypt() {
    local encrypted_dir="$1"
    local output_dir="$2"
    local password="$3"
    
    echo "📂 Démarrage du déchiffrement par lots..."
    echo "  Source : $encrypted_dir"
    echo "  Cible : $output_dir"
    
    # Créer le répertoire de sortie
    mkdir -p "$output_dir"
    
    local count=0
    local success=0
    
    # Traiter les fichiers .enc
    while IFS= read -r -d '' file; do
        if [[ -f "$file" && "$file" == *.enc ]]; then
            local relative_path
            relative_path=$(realpath --relative-to="$encrypted_dir" "$file")
            # Supprimer l'extension .enc
            local decrypted_file="$output_dir/${relative_path%.enc}"
            
            # Créer les sous-répertoires si nécessaire
            mkdir -p "$(dirname "$decrypted_file")"
            
            echo "  Traitement : $relative_path"
            
            if openssl aes-256-cbc -d -in "$file" -out "$decrypted_file" -k "$password" 2>/dev/null; then
                ((success++))
                echo "    ✅ Déchiffré"
            else
                echo "    ❌ Échec"
            fi
            
            ((count++))
        fi
    done < <(find "$encrypted_dir" -name "*.enc" -type f -print0)
    
    echo "🎉 Déchiffrement par lots terminé : $success/$count fichiers déchiffrés"
}

# Exemple d'usage
batch_decrypt "/Users/jean/Chiffre" "/Users/jean/Dechiffre" "mot_de_passe_lot123"

Script de Gestion de Chiffrement d'Entreprise

#!/bin/bash

# Système de Gestion de Chiffrement de Fichiers Roundfleet
# Gestion complète de chiffrement/déchiffrement pour environnements d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_encryption.log"
CONFIG_FILE="/etc/roundfleet/encryption_policy.conf"
KEY_STORE="/var/lib/roundfleet/keys"
AUDIT_LOG="/var/log/roundfleet_encryption_audit.log"

# Fonction de journalisation
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Journalisation d'audit
audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$AUDIT_LOG"
}

# Configurer l'environnement
setup_environment() {
    sudo mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null
    sudo mkdir -p "$(dirname "$CONFIG_FILE")" 2>/dev/null
    sudo mkdir -p "$KEY_STORE" 2>/dev/null
    sudo chmod 700 "$KEY_STORE" 2>/dev/null
}

# Charger la configuration
load_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
        log_action "Configuration chargée depuis $CONFIG_FILE"
    else
        # Configuration par défaut
        DEFAULT_ALGORITHM="aes-256-cbc"
        REQUIRE_STRONG_PASSWORDS=true
        MIN_PASSWORD_LENGTH=12
        ENCRYPTION_ENABLED=true
        AUTO_BACKUP_KEYS=true
        COMPLIANCE_MODE="HIPAA"  # HIPAA, PCI-DSS, GDPR
        
        log_action "Utilisation de la configuration de chiffrement par défaut"
    fi
}

# Valider la force du mot de passe
validate_password() {
    local password="$1"
    
    if [[ "$REQUIRE_STRONG_PASSWORDS" != "true" ]]; then
        return 0
    fi
    
    # Vérifier la longueur minimale
    if [[ ${#password} -lt $MIN_PASSWORD_LENGTH ]]; then
        echo "❌ Mot de passe trop court (minimum $MIN_PASSWORD_LENGTH caractères)"
        return 1
    fi
    
    # Vérifier la complexité
    local has_upper has_lower has_digit has_special
    has_upper=$(echo "$password" | grep -c '[A-Z]')
    has_lower=$(echo "$password" | grep -c '[a-z]')
    has_digit=$(echo "$password" | grep -c '[0-9]')
    has_special=$(echo "$password" | grep -c '[^A-Za-z0-9]')
    
    if [[ $has_upper -eq 0 ]] || [[ $has_lower -eq 0 ]] || [[ $has_digit -eq 0 ]] || [[ $has_special -eq 0 ]]; then
        echo "❌ Le mot de passe doit contenir majuscule, minuscule, chiffre et caractère spécial"
        return 1
    fi
    
    return 0
}

# Générer une clé sécurisée
generate_secure_key() {
    local key_name="$1"
    local key_file="$KEY_STORE/${key_name}.key"
    
    # Générer une clé aléatoire de 256 bits
    openssl rand -base64 32 > "$key_file"
    chmod 600 "$key_file"
    
    log_action "Clé sécurisée générée : $key_name"
    audit_log "CLE_GENEREE : $key_name par $(whoami)"
    
    echo "$key_file"
}

# Chiffrer un fichier avec fonctionnalités d'entreprise
enterprise_encrypt() {
    local input_file="$1"
    local output_file="$2"
    local key_name="$3"
    local algorithm="${4:-$DEFAULT_ALGORITHM}"
    
    if [[ "$ENCRYPTION_ENABLED" != "true" ]]; then
        echo "❌ Le chiffrement est désactivé par la politique"
        return 1
    fi
    
    # Valider le fichier d'entrée
    if [[ ! -f "$input_file" ]]; then
        echo "❌ Fichier d'entrée non trouvé : $input_file"
        return 1
    fi
    
    # Obtenir ou générer la clé
    local key_file="$KEY_STORE/${key_name}.key"
    if [[ ! -f "$key_file" ]]; then
        echo "🔑 Génération d'une nouvelle clé de chiffrement : $key_name"
        generate_secure_key "$key_name"
    fi
    
    local password
    password=$(cat "$key_file")
    
    echo "🔒 Démarrage du chiffrement d'entreprise..."
    echo "  Algorithme : $algorithm"
    echo "  Entrée : $input_file"
    echo "  Sortie : $output_file"
    echo "  Clé : $key_name"
    
    # Créer le fichier de métadonnées
    local metadata_file="${output_file}.meta"
    cat > "$metadata_file" << EOF
{
    "algorithm": "$algorithm",
    "key_name": "$key_name",
    "encrypted_by": "$(whoami)",
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "hostname": "$(hostname)",
    "compliance_mode": "$COMPLIANCE_MODE",
    "file_size": $(stat -f%z "$input_file"),
    "original_name": "$(basename "$input_file")"
}
EOF
    
    # Effectuer le chiffrement
    if openssl "$algorithm" -salt -in "$input_file" -out "$output_file" -pass file:"$key_file"; then
        # Générer le hachage d'intégrité
        local hash
        hash=$(shasum -a 256 "$output_file" | cut -d' ' -f1)
        echo "  \"integrity_hash\": \"$hash\"" >> "$metadata_file"
        
        log_action "Fichier chiffré : $input_file -> $output_file (clé : $key_name)"
        audit_log "CHIFFREMENT : $input_file -> $output_file par $(whoami) utilisant $key_name"
        
        echo "✅ Chiffrement d'entreprise terminé"
        echo "  Métadonnées : $metadata_file"
        
        # Sauvegarder la clé si activé
        if [[ "$AUTO_BACKUP_KEYS" == "true" ]]; then
            backup_key "$key_name"
        fi
        
        return 0
    else
        echo "❌ Échec du chiffrement"
        log_action "Échec du chiffrement : $input_file"
        return 1
    fi
}

# Déchiffrer un fichier avec fonctionnalités d'entreprise
enterprise_decrypt() {
    local input_file="$1"
    local output_file="$2"
    local key_name="$3"
    
    # Vérifier si le fichier chiffré existe
    if [[ ! -f "$input_file" ]]; then
        echo "❌ Fichier chiffré non trouvé : $input_file"
        return 1
    fi
    
    # Charger les métadonnées
    local metadata_file="${input_file}.meta"
    if [[ ! -f "$metadata_file" ]]; then
        echo "⚠️  Fichier de métadonnées non trouvé, utilisation de l'algorithme par défaut"
        local algorithm="$DEFAULT_ALGORITHM"
    else
        local algorithm
        algorithm=$(grep '"algorithm"' "$metadata_file" | cut -d'"' -f4)
        echo "📋 Métadonnées chargées : algorithm=$algorithm"
    fi
    
    # Obtenir la clé
    local key_file="$KEY_STORE/${key_name}.key"
    if [[ ! -f "$key_file" ]]; then
        echo "❌ Clé de déchiffrement non trouvée : $key_name"
        return 1
    fi
    
    echo "🔓 Démarrage du déchiffrement d'entreprise..."
    echo "  Algorithme : $algorithm"
    echo "  Entrée : $input_file"
    echo "  Sortie : $output_file"
    echo "  Clé : $key_name"
    
    # Effectuer le déchiffrement
    if openssl "$algorithm" -d -in "$input_file" -out "$output_file" -pass file:"$key_file"; then
        # Vérifier l'intégrité si le hachage est disponible
        if [[ -f "$metadata_file" ]]; then
            verify_integrity "$input_file" "$metadata_file"
        fi
        
        log_action "Fichier déchiffré : $input_file -> $output_file (clé : $key_name)"
        audit_log "DECHIFFREMENT : $input_file -> $output_file par $(whoami) utilisant $key_name"
        
        echo "✅ Déchiffrement d'entreprise terminé"
        return 0
    else
        echo "❌ Échec du déchiffrement"
        log_action "Échec du déchiffrement : $input_file"
        audit_log "ECHEC_DECHIFFREMENT : $input_file par $(whoami)"
        return 1
    fi
}

# Vérifier l'intégrité du fichier
verify_integrity() {
    local encrypted_file="$1"
    local metadata_file="$2"
    
    if [[ -f "$metadata_file" ]]; then
        local stored_hash current_hash
        stored_hash=$(grep '"integrity_hash"' "$metadata_file" | cut -d'"' -f4)
        current_hash=$(shasum -a 256 "$encrypted_file" | cut -d' ' -f1)
        
        if [[ "$stored_hash" == "$current_hash" ]]; then
            echo "✅ Intégrité du fichier vérifiée"
        else
            echo "⚠️  Échec de la vérification d'intégrité - le fichier peut être corrompu"
            log_action "Échec de la vérification d'intégrité : $encrypted_file"
        fi
    fi
}

# Sauvegarder la clé de chiffrement
backup_key() {
    local key_name="$1"
    local key_file="$KEY_STORE/${key_name}.key"
    local backup_dir="$KEY_STORE/backups"
    
    mkdir -p "$backup_dir"
    
    local backup_file="$backup_dir/${key_name}_$(date +%Y%m%d_%H%M%S).key"
    cp "$key_file" "$backup_file"
    
    log_action "Clé sauvegardée : $key_name -> $backup_file"
}

# Générer un rapport de chiffrement
generate_encryption_report() {
    local report_file="/tmp/roundfleet_encryption_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de Gestion de Chiffrement Roundfleet"
        echo "=========================================="
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Mode de Conformité : $COMPLIANCE_MODE"
        echo ""
        
        echo "Configuration :"
        echo "  Algorithme par Défaut : $DEFAULT_ALGORITHM"
        echo "  Mots de Passe Forts : $REQUIRE_STRONG_PASSWORDS"
        echo "  Longueur Min Mot de Passe : $MIN_PASSWORD_LENGTH"
        echo "  Chiffrement Activé : $ENCRYPTION_ENABLED"
        echo ""
        
        echo "Clés Disponibles :"
        if ls "$KEY_STORE"/*.key >/dev/null 2>&1; then
            for key_file in "$KEY_STORE"/*.key; do
                local key_name
                key_name=$(basename "$key_file" .key)
                echo "  $key_name ($(stat -f%Sm "$key_file"))"
            done
        else
            echo "  Aucune clé trouvée"
        fi
        echo ""
        
        echo "Activité de Chiffrement Récente :"
        if [[ -f "$AUDIT_LOG" ]]; then
            tail -10 "$AUDIT_LOG"
        else
            echo "  Aucune activité enregistrée"
        fi
        
    } > "$report_file"
    
    echo "📄 Rapport de chiffrement généré : $report_file"
    log_action "Rapport généré : $report_file"
}

# Fonction principale
main() {
    case "${1:-status}" in
        "encrypt")
            setup_environment
            load_config
            log_action "=== Demande de Chiffrement de Fichier ==="
            enterprise_encrypt "$2" "$3" "$4" "$5"
            ;;
        "decrypt")
            setup_environment
            load_config
            log_action "=== Demande de Déchiffrement de Fichier ==="
            enterprise_decrypt "$2" "$3" "$4"
            ;;
        "generate-key")
            setup_environment
            load_config
            log_action "=== Demande de Génération de Clé ==="
            generate_secure_key "$2"
            ;;
        "report")
            setup_environment
            load_config
            generate_encryption_report
            ;;
        "list-algorithms")
            echo "📋 Algorithmes de chiffrement disponibles :"
            openssl list-cipher-commands | tr ' ' '\n' | sort
            ;;
        "status"|*)
            setup_environment
            load_config
            echo "📊 Statut de Chiffrement Roundfleet :"
            echo "==================================="
            echo "Chiffrement Activé : $ENCRYPTION_ENABLED"
            echo "Algorithme par Défaut : $DEFAULT_ALGORITHM"
            echo "Mode de Conformité : $COMPLIANCE_MODE"
            echo "Magasin de Clés : $KEY_STORE"
            
            if ls "$KEY_STORE"/*.key >/dev/null 2>&1; then
                echo "Clés Disponibles : $(ls "$KEY_STORE"/*.key | wc -l)"
            else
                echo "Clés Disponibles : 0"
            fi
            ;;
    esac
}

# Exécuter la fonction principale avec les paramètres
main "$@"

Référence des Algorithmes de Chiffrement

Comparaison Rapide

Algorithme	Taille de Clé	Sécurité	Performance	Cas d'Usage
DES	56-bit	Faible	Rapide	Systèmes hérités uniquement
AES-128-CBC	128-bit	Bonne	Rapide	Usage général
AES-256-CBC	256-bit	Excellente	Moyenne	Haute sécurité
AES-256-GCM	256-bit	Excellente	Moyenne	Chiffrement authentifié
ChaCha20	256-bit	Excellente	Rapide	Alternative moderne

Lister les Algorithmes Disponibles

# Afficher tous les algorithmes de chiffrement disponibles
openssl list-cipher-commands

# Algorithmes sécurisés communs
openssl enc -ciphers | grep -E "(aes|chacha)"

Meilleures Pratiques de Sécurité

Gestion des Mots de Passe

#!/bin/bash

# Générer un mot de passe sécurisé
generate_secure_password() {
    local length="${1:-16}"
    
    # Générer un mot de passe avec caractères mixtes
    openssl rand -base64 "$length" | tr -d "=+/" | cut -c1-"$length"
}

# Exemple : Générer un mot de passe de 20 caractères
secure_password=$(generate_secure_password 20)
echo "Mot de passe généré : $secure_password"

Rotation des Clés

#!/bin/bash

# Rotation des clés de chiffrement
rotate_encryption_key() {
    local old_key="$1"
    local new_key="$2"
    local files_dir="$3"
    
    echo "🔄 Rotation de la clé de chiffrement : $old_key -> $new_key"
    
    # Générer une nouvelle clé
    generate_secure_key "$new_key"
    
    # Re-chiffrer les fichiers avec la nouvelle clé
    while IFS= read -r -d '' file; do
        if [[ "$file" == *.enc ]]; then
            local temp_file="/tmp/temp_decrypt_$$"
            
            # Déchiffrer avec l'ancienne clé
            if enterprise_decrypt "$file" "$temp_file" "$old_key"; then
                # Re-chiffrer avec la nouvelle clé
                if enterprise_encrypt "$temp_file" "$file" "$new_key"; then
                    echo "  ✅ Clé rotée : $(basename "$file")"
                fi
            fi
            
            # Nettoyer
            rm -f "$temp_file"
        fi
    done < <(find "$files_dir" -name "*.enc" -type f -print0)
    
    echo "🎉 Rotation de clé terminée"
}

Dépannage

Problèmes Courants

Le chiffrement échoue avec "bad decrypt"
- Vérifier que l'algorithme correct est utilisé
- Vérifier l'intégrité du fichier de mot de passe/clé
- S'assurer d'un espace disque suffisant
Erreurs de permission refusée
- Vérifier les permissions des fichiers
- Vérifier les droits d'accès au magasin de clés
- Exécuter avec les privilèges utilisateur appropriés
Fichiers chiffrés corrompus
- Vérifier les hachages d'intégrité des fichiers
- Vérifier les erreurs de disque
- Restaurer depuis les sauvegardes si disponibles

Commandes de Vérification

# Tester le cycle de chiffrement/déchiffrement
test_encryption() {
    local test_file="/tmp/test_encrypt.txt"
    local encrypted_file="/tmp/test_encrypt.enc"
    local decrypted_file="/tmp/test_decrypt.txt"
    
    # Créer un fichier de test
    echo "Ceci est un fichier de test pour le chiffrement" > "$test_file"
    
    # Chiffrer
    openssl aes-256-cbc -in "$test_file" -out "$encrypted_file" -k "motdepassetest"
    
    # Déchiffrer
    openssl aes-256-cbc -d -in "$encrypted_file" -out "$decrypted_file" -k "motdepassetest"
    
    # Comparer
    if diff "$test_file" "$decrypted_file" >/dev/null; then
        echo "✅ Test de chiffrement/déchiffrement réussi"
    else
        echo "❌ Test de chiffrement/déchiffrement échoué"
    fi
    
    # Nettoyer
    rm -f "$test_file" "$encrypted_file" "$decrypted_file"
}

Notes Importantes

Sélection d'algorithme : Utiliser AES-256-CBC ou plus fort pour les données sensibles
Sécurité des mots de passe : Implémenter des politiques de mots de passe forts pour usage d'entreprise
Gestion des clés : Stocker et sauvegarder de manière sécurisée les clés de chiffrement
Conformité : S'assurer que les méthodes de chiffrement répondent aux exigences réglementaires
Performance : Considérer la taille des fichiers et les ressources système lors du choix des algorithmes
Stratégie de sauvegarde : Toujours maintenir des sauvegardes sécurisées des clés de chiffrement

Déploiement d'Entreprise

Pour le déploiement d'entreprise, considérer :

Définition de politique - Établir des standards et procédures de chiffrement
Gestion des clés - Implémenter un stockage et une rotation sécurisés des clés
Surveillance de conformité - Assurer l'adhésion aux exigences réglementaires
Formation utilisateur - Éduquer les utilisateurs sur les bonnes pratiques de chiffrement
Pistes d'audit - Maintenir des journaux complets des activités de chiffrement

Guide

Avis important