Guide

Sécurisez les données sensibles sur vos appareils MacFleet 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 MacFleet
# Gestion complète de chiffrement/déchiffrement pour environnements d'entreprise

# Configuration
LOG_FILE="/var/log/macfleet_encryption.log"
CONFIG_FILE="/etc/macfleet/encryption_policy.conf"
KEY_STORE="/var/lib/macfleet/keys"
AUDIT_LOG="/var/log/macfleet_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/macfleet_encryption_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de Gestion de Chiffrement MacFleet"
        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 MacFleet :"
            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

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

1. 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

2. 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

3. 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 :

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

Découvrez et gérez les fichiers sur vos appareils MacFleet en utilisant des systèmes de recherche et découverte de fichiers avancés. Ce tutoriel couvre la recherche de chemins de fichiers, les recherches basées sur les extensions, l'analyse de contenu et la gestion complète du cycle de vie des fichiers.

Comprendre la Découverte de Fichiers macOS

macOS fournit plusieurs capacités de découverte et recherche de fichiers :

• find - Utilitaire de recherche de fichiers et répertoires en ligne de commande
• Résolution de Chemin de Fichier - Localiser des fichiers spécifiques par nom et extension
• Filtrage par Extension - Rechercher des fichiers par type et format de fichier
• Recherche de Contenu - Trouver des fichiers basés sur le contenu et les métadonnées
• Intégration Spotlight - Exploiter l'indexation macOS pour des recherches rapides

Opérations de Découverte de Fichiers de Base

Trouver un Chemin de Fichier

#!/bin/bash

# Recherche de chemin de fichier de base
find / -name 'nom de fichier avec extension' -print 2>/dev/null

echo "Recherche de chemin de fichier terminée"

Découverte de Fichiers Améliorée

#!/bin/bash

# Découverte de fichiers complète avec multiples méthodes de recherche
discover_file_paths() {
    local file_pattern="$1"
    local search_scope="${2:-/}"
    local search_type="${3:-name}"
    
    echo "=== Découverte de Fichiers et Résolution de Chemin ==="
    echo "Motif de Recherche : $file_pattern"
    echo "Portée de Recherche : $search_scope"
    echo "Type de Recherche : $search_type"
    
    # Valider les paramètres de recherche
    if [[ -z "$file_pattern" ]]; then
        echo "❌ Le motif de fichier est requis"
        return 1
    fi
    
    if [[ ! -d "$search_scope" ]]; then
        echo "❌ Répertoire de portée de recherche non trouvé : $search_scope"
        return 1
    fi
    
    # Effectuer la recherche basée sur le type
    echo "Démarrage de la découverte de fichiers..."
    local results_count=0
    
    case "$search_type" in
        "name")
            echo "Recherche par nom de fichier..."
            find "$search_scope" -name "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "iname")
            echo "Recherche par nom de fichier (insensible à la casse)..."
            find "$search_scope" -iname "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "type")
            echo "Recherche par type de fichier..."
            find "$search_scope" -type f -name "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "content")
            echo "Recherche par contenu..."
            grep -r "$file_pattern" "$search_scope" 2>/dev/null | while read -r match; do
                echo "Correspondance de contenu : $match"
                ((results_count++))
            done
            ;;
        *)
            echo "❌ Type de recherche inconnu : $search_type"
            return 1
            ;;
    esac
    
    echo "✅ Découverte de fichiers terminée"
    log_discovery_action "$file_pattern" "$search_scope" "$search_type" "succès"
    
    return 0
}

# Exemple d'utilisation
# discover_file_paths "document.txt" "/" "name"

Lister les Fichiers par Extension

#!/bin/bash

# Recherche d'extension de fichier améliorée
find_files_by_extension() {
    local extension="$1"
    local count="${2:-10}"
    local search_path="${3:-/}"
    
    echo "=== Recherche de Fichiers par Extension ==="
    echo "Extension : .$extension"
    echo "Limite de Résultats : $count"
    echo "Chemin de Recherche : $search_path"
    
    # Recherche d'extension de base
    echo "Recherche de fichiers .$extension..."
    find "$search_path" -name "*.$extension" -print 2>/dev/null | head -n "$count"
    
    echo "✅ Recherche d'extension terminée"
}

# Exemple d'utilisation
# find_files_by_extension "txt" 10 "/"

Catégories de Découverte de Fichiers

Classifications de Types de Fichiers

#!/bin/bash

# Catégories de découverte de fichiers pour différents types de fichiers et objectifs
declare -A FILE_CATEGORIES=(
    ["config_systeme"]="Fichiers de configuration système et préférences"
    ["donnees_application"]="Fichiers de données d'application et préférences utilisateur"
    ["contenu_media"]="Images, vidéos, fichiers audio et contenu multimédia"
    ["fichiers_document"]="Documents texte, feuilles de calcul, présentations"
    ["code_developpement"]="Code source, scripts, projets de développement"
    ["archive_compresse"]="Archives compressées et fichiers de sauvegarde"
    ["certificats_securite"]="Certificats de sécurité, clés et identifiants"
    ["log_diagnostic"]="Journaux système, fichiers de diagnostic et données de dépannage"
    ["cache_temporaire"]="Fichiers cache, données temporaires et contenu jetable"
    ["base_donnees_structuree"]="Fichiers de base de données et stockage de données structurées"
)

# Extensions de fichiers pour chaque catégorie
declare -A CATEGORY_EXTENSIONS=(
    ["config_systeme"]="plist,conf,cfg,ini,settings,preferences"
    ["donnees_application"]="app,dmg,pkg,bundle,framework"
    ["contenu_media"]="jpg,jpeg,png,gif,mp4,mov,mp3,wav,m4a"
    ["fichiers_document"]="pdf,doc,docx,xls,xlsx,ppt,pptx,txt,rtf"
    ["code_developpement"]="swift,m,h,py,js,ts,php,java,cpp,c"
    ["archive_compresse"]="zip,tar,gz,bz2,rar,7z,dmg"
    ["certificats_securite"]="p12,pem,crt,key,keychain,cer"
    ["log_diagnostic"]="log,crash,diag,report,trace"
    ["cache_temporaire"]="cache,tmp,temp,bak,swp"
    ["base_donnees_structuree"]="db,sqlite,sql,json,xml,csv"
)

# Priorités de recherche pour différentes catégories
declare -A SEARCH_PRIORITIES=(
    ["config_systeme"]="haute"
    ["donnees_application"]="moyenne"
    ["contenu_media"]="faible"
    ["fichiers_document"]="haute"
    ["code_developpement"]="moyenne"
    ["archive_compresse"]="faible"
    ["certificats_securite"]="critique"
    ["log_diagnostic"]="moyenne"
    ["cache_temporaire"]="faible"
    ["base_donnees_structuree"]="haute"
)

print_file_categories() {
    echo "=== Catégories de Découverte de Fichiers ==="
    for category in "${!FILE_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${FILE_CATEGORIES[$category]}"
        echo "  Extensions : ${CATEGORY_EXTENSIONS[$category]}"
        echo "  Priorité : ${SEARCH_PRIORITIES[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_file_categories

Politiques de Découverte de Fichiers

Politiques de Recherche et Découverte

#!/bin/bash

# Politiques de découverte de fichiers pour différentes exigences organisationnelles
declare -A DISCOVERY_POLICIES=(
    ["audit_securite"]="Découverte de fichiers axée sécurité avec numérisation complète"
    ["conformite_gdpr"]="Découverte de fichiers conforme GDPR pour identification de données personnelles"
    ["inventaire_actifs"]="Inventaire complet d'actifs et catalogage de fichiers"
    ["nettoyage_performance"]="Optimisation de performance par identification de nettoyage de fichiers"
    ["verification_sauvegarde"]="Vérification de sauvegarde et contrôle d'intégrité de données"
    ["enquete_medico_legale"]="Découverte de fichiers médico-légaux pour enquête d'incident"
)

# Obtenir la configuration de politique de découverte
get_discovery_policy() {
    local policy_type="$1"
    
    case "$policy_type" in
        "audit_securite")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "complete",
    "types_fichiers_priorite": ["certificats_securite", "config_systeme", "log_diagnostic"],
    "analyse_contenu": true,
    "collecte_metadonnees": true,
    "analyse_permissions": true,
    "verification_hash": true,
    "suivi_acces": true,
    "detection_chiffrement": true,
    "motifs_suspects": ["password", "key", "token", "secret"],
    "niveau_rapport": "detaille",
    "journalisation_audit": "complete",
    "surveillance_temps_reel": true
}
EOF
            ;;
        "conformite_gdpr")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "donnees_utilisateur_focus",
    "types_fichiers_priorite": ["fichiers_document", "base_donnees_structuree", "donnees_application"],
    "analyse_contenu": true,
    "collecte_metadonnees": true,
    "detection_donnees_personnelles": true,
    "classification_donnees": true,
    "analyse_retention": true,
    "suivi_consentement": false,
    "identification_sujet_donnees": true,
    "analyse_transfrontaliere": true,
    "motifs_vie_privee": ["email", "phone", "ssn", "passport", "address"],
    "niveau_rapport": "conforme_vie_privee",
    "journalisation_audit": "conforme_gdpr",
    "cartographie_donnees": true
}
EOF
            ;;
        "inventaire_actifs")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "systeme_complet",
    "types_fichiers_priorite": ["donnees_application", "config_systeme", "fichiers_document"],
    "analyse_contenu": false,
    "collecte_metadonnees": true,
    "analyse_taille": true,
    "suivi_modification": true,
    "analyse_propriete": true,
    "detection_version": true,
    "conformite_licence": true,
    "detection_doublons": true,
    "optimisation_stockage": true,
    "niveau_rapport": "focus_inventaire",
    "journalisation_audit": "standard",
    "catalogage": true
}
EOF
            ;;
        *)
            echo "Politique de découverte inconnue : $policy_type"
            return 1
            ;;
    esac
}

# Appliquer une politique de découverte
apply_discovery_policy() {
    local policy="$1"
    local config_file="/tmp/politique_decouverte.json"
    
    echo "Application de la politique de découverte de fichiers : $policy"
    
    get_discovery_policy "$policy" > "$config_file"
    
    if [[ ! -f "$config_file" ]]; then
        echo "❌ Échec de génération de configuration de politique"
        return 1
    fi
    
    echo "✅ Politique de découverte de fichiers appliquée avec succès"
    echo "Configuration : $config_file"
    
    # Afficher les paramètres clés de politique
    echo "=== Résumé de Politique ==="
    echo "Découverte Activée : $(jq -r '.decouverte_activee' "$config_file")"
    echo "Portée de Recherche : $(jq -r '.portee_recherche' "$config_file")"
    echo "Analyse de Contenu : $(jq -r '.analyse_contenu' "$config_file")"
    echo "Collecte de Métadonnées : $(jq -r '.collecte_metadonnees' "$config_file")"
    echo "Niveau de Rapport : $(jq -r '.niveau_rapport' "$config_file")"
    
    return 0
}

Découverte et Analyse Avancées de Fichiers

Système de Découverte de Fichiers Complet

#!/bin/bash

# Découverte de fichiers avancée avec analyse de contenu et extraction de métadonnées
advanced_file_discovery() {
    local search_criteria="$1"
    local analysis_level="${2:-standard}"
    local output_format="${3:-text}"
    
    echo "=== Système de Découverte de Fichiers Avancé ==="
    echo "Critères de Recherche : $search_criteria"
    echo "Niveau d'Analyse : $analysis_level"
    echo "Format de Sortie : $output_format"
    
    local discovery_report="/tmp/decouverte_fichiers_$(date +%Y%m%d_%H%M%S).json"
    
    # Initialiser le rapport de découverte
    cat > "$discovery_report" << EOF
{
    "session_decouverte": {
        "criteres_recherche": "$search_criteria",
        "niveau_analyse": "$analysis_level",
        "horodatage": "$(date -Iseconds)",
        "nom_hote": "$(hostname)",
        "operateur": "$(whoami)"
    },
    "fichiers_decouverts": [],
    "statistiques_fichiers": {},
    "analyse_contenu": {},
    "resultats_securite": {}
}
EOF
    
    # Effectuer une découverte de fichiers complète
    echo "Exécution de recherche de fichiers complète..."
    
    # Recherche par multiples critères
    local files_found=0
    
    # Recherche de nom de fichier de base
    echo "  - Recherche par motifs de nom de fichier..."
    find / -name "*$search_criteria*" -type f -print 2>/dev/null | while read -r file_path; do
        analyze_discovered_file "$file_path" "$analysis_level" "$discovery_report"
        ((files_found++))
    done
    
    # Recherche basée sur le contenu
    if [[ "$analysis_level" == "complet" ]]; then
        echo "  - Exécution d'analyse de contenu..."
        grep -r "$search_criteria" / 2>/dev/null | head -100 | while read -r match; do
            local file_path
            file_path=$(echo "$match" | cut -d':' -f1)
            analyze_discovered_file "$file_path" "$analysis_level" "$discovery_report"
        done
    fi
    
    # Générer des statistiques de fichiers
    generate_file_statistics "$discovery_report"
    
    # Afficher les résultats
    echo ""
    echo "Résultats de Découverte :"
    echo "  Fichiers Trouvés : $files_found"
    echo "  Rapport de Découverte : $discovery_report"
    
    # Formater la sortie
    case "$output_format" in
        "json")
            cat "$discovery_report"
            ;;
        "resume")
            jq -r '.session_decouverte, .statistiques_fichiers' "$discovery_report"
            ;;
        *)
            echo "Découverte terminée - voir le fichier de rapport pour détails"
            ;;
    esac
    
    return 0
}

# Analyser un fichier découvert
analyze_discovered_file() {
    local file_path="$1"
    local analysis_level="$2"
    local report_file="$3"
    
    if [[ ! -f "$file_path" ]]; then
        return 1
    fi
    
    # Informations de fichier de base
    local file_size
    file_size=$(stat -f%z "$file_path" 2>/dev/null || echo "0")
    local file_permissions
    file_permissions=$(stat -f%A "$file_path" 2>/dev/null || echo "inconnu")
    local file_owner
    file_owner=$(stat -f%Su "$file_path" 2>/dev/null || echo "inconnu")
    local modification_time
    modification_time=$(stat -f%Sm "$file_path" 2>/dev/null || echo "inconnu")
    
    # Analyse améliorée pour niveau complet
    local file_type="inconnu"
    local content_preview=""
    local security_flags=""
    
    if [[ "$analysis_level" == "complet" ]]; then
        file_type=$(file -b "$file_path" 2>/dev/null || echo "inconnu")
        
        # Aperçu de contenu sécurisé pour fichiers texte
        if file "$file_path" | grep -q "text"; then
            content_preview=$(head -c 200 "$file_path" 2>/dev/null | tr '\n' ' ')
        fi
        
        # Analyse de sécurité
        if [[ "$file_permissions" =~ 7.* ]]; then
            security_flags="executable_par_proprietaire"
        fi
        
        if [[ "$file_path" =~ \.key$|\.pem$|\.p12$ ]]; then
            security_flags="${security_flags},potentiel_identifiant_securite"
        fi
    fi
    
    # Journaliser la découverte de fichier
    log_discovered_file "$file_path" "$file_size" "$file_type" "$security_flags"
}

# Journaliser un fichier découvert
log_discovered_file() {
    local file_path="$1"
    local file_size="$2"
    local file_type="$3"
    local security_flags="$4"
    
    echo "$(date '+%Y-%m-%d %H:%M:%S') - Fichier Découvert : $file_path (Taille : $file_size, Type : $file_type, Sécurité : $security_flags)" >> "/var/log/macfleet_decouverte_fichiers.log"
}

Système de Gestion de Découverte de Fichiers

#!/bin/bash

# Système de Gestion de Découverte et Recherche de Fichiers MacFleet
# Découverte, catalogage et gestion complètes de fichiers

# Configuration
CONFIG_DIR="/etc/macfleet/decouverte"
LOG_FILE="/var/log/macfleet_decouverte_fichiers.log"
AUDIT_LOG="/var/log/macfleet_audit_decouverte.log"
INDEX_DIR="/var/index/macfleet/decouverte"

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

audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}

# Indexation du système de fichiers
create_file_index() {
    local index_scope="${1:-/Users}"
    local index_level="${2:-standard}"
    
    log_action "Création d'index du système de fichiers : $index_scope (Niveau : $index_level)"
    
    echo "=== Indexation du Système de Fichiers ==="
    echo "Portée d'Index : $index_scope"
    echo "Niveau d'Index : $index_level"
    
    local index_file="$INDEX_DIR/index_fichiers_$(date +%Y%m%d_%H%M%S).json"
    
    # Initialiser l'index
    cat > "$index_file" << EOF
{
    "metadonnees_index": {
        "portee": "$index_scope",
        "niveau": "$index_level",
        "cree": "$(date -Iseconds)",
        "nom_hote": "$(hostname)",
        "total_fichiers": 0,
        "taille_totale": 0
    },
    "entrees_fichiers": []
}
EOF
    
    echo "Démarrage de l'indexation du système de fichiers..."
    local file_count=0
    
    # Indexer les fichiers basé sur le niveau
    case "$index_level" in
        "de_base")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_basic "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 1000)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        "standard")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_standard "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 500)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        "complet")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_comprehensive "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 100)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        *)
            echo "❌ Niveau d'index inconnu : $index_level"
            return 1
            ;;
    esac
    
    echo "✅ Indexation du système de fichiers terminée"
    echo "  Fichiers Indexés : $file_count"
    echo "  Fichier d'Index : $index_file"
    
    audit_log "Index du système de fichiers créé : $index_scope ($file_count fichiers)"
    
    return 0
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    case "$command" in
        "trouver_fichier")
            # Trouver un fichier spécifique par nom
            discover_file_paths "$@"
            ;;
        "trouver_extension")
            # Trouver des fichiers par extension
            find_files_by_extension "$@"
            ;;
        "recherche_avancee")
            # Découverte de fichiers avancée
            advanced_file_discovery "$@"
            ;;
        "creer_index")
            # Créer un index du système de fichiers
            create_file_index "$@"
            ;;
        "appliquer_politique")
            # Appliquer une politique de découverte
            apply_discovery_policy "$@"
            ;;
        "afficher_categories")
            # Afficher les catégories de fichiers
            print_file_categories
            ;;
        "afficher_politiques")
            # Afficher les politiques disponibles
            for policy in audit_securite conformite_gdpr inventaire_actifs nettoyage_performance verification_sauvegarde enquete_medico_legale; do
                echo "Politique : $policy"
                get_discovery_policy "$policy" | jq .
                echo ""
            done
            ;;
        *)
            echo "Système de Gestion de Découverte et Recherche de Fichiers MacFleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  trouver_fichier <motif> [portée] [type]               - Trouver fichiers spécifiques par motif"
            echo "  trouver_extension <ext> [nombre] [chemin]             - Trouver fichiers par extension"
            echo "  recherche_avancee <critères> [niveau] [format]       - Découverte de fichiers avancée"
            echo "  creer_index [portée] [niveau]                        - Créer index du système de fichiers"
            echo "  appliquer_politique <politique>                      - Appliquer politique de découverte"
            echo "  afficher_categories                                  - Afficher catégories de fichiers"
            echo "  afficher_politiques                                  - Afficher politiques de découverte"
            echo ""
            echo "Exemples :"
            echo "  $0 trouver_fichier \"document.txt\" \"/Users\" \"name\""
            echo "  $0 trouver_extension \"pdf\" 20 \"/Users\""
            echo "  $0 recherche_avancee \"config\" \"complet\" \"json\""
            echo "  $0 creer_index \"/Users\" \"standard\""
            echo "  $0 appliquer_politique \"audit_securite\""
            ;;
    esac
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Considérations de Sécurité

Sécurité de Découverte de Fichiers

• Contrôles d'Accès - Respecter les permissions de fichiers et restrictions d'accès
• Protection de Données Sensibles - Éviter d'exposer le contenu de fichiers sensibles dans les journaux
• Impact sur les Performances - Surveiller les performances système pendant la découverte à grande échelle
• Conformité de Vie Privée - S'assurer que les pratiques de découverte respectent les réglementations de vie privée
• Pistes d'Audit - Maintenir des journaux complets des activités de découverte

Cadre de Conformité

• Classification de Données - Classifier correctement les fichiers découverts basé sur la sensibilité
• Politiques de Rétention - Implémenter la rétention et élimination appropriées de données
• Journalisation d'Accès - Journaliser tous les accès aux fichiers et activités de découverte
• Protection de Vie Privée - Protéger les informations personnelles et sensibles pendant la découverte
• Conformité Réglementaire - Respecter les exigences de découverte et catalogage spécifiques à l'industrie

Guide de Dépannage

Problèmes Courants

Erreurs de Permission Refusée

• Exécuter la découverte avec privilèges appropriés : sudo pour recherches système
• Vérifier les permissions de fichiers et répertoires : ls -la
• Vérifier l'accessibilité de la portée de recherche

Performance de Recherche Lente

• Limiter la portée de recherche à des répertoires spécifiques
• Utiliser des recherches indexées pour données fréquemment consultées
• Considérer la spécificité des critères de recherche

Commandes de Diagnostic

# Tester la fonctionnalité find de base
find /Users -name "*.txt" -print 2>/dev/null | head -5

# Vérifier les permissions du système de fichiers
ls -la /chemin/vers/repertoire/recherche

# Surveiller les performances de recherche
time find /Users -name "motif" -print 2>/dev/null

# Vérifier l'espace disque disponible pour l'indexation
df -h

Notes Importantes

• Échappement de Chemin de Fichier - Utiliser des guillemets ou barres obliques inverses pour chemins avec espaces : "Nouveau Dossier/fichier.txt" ou Nouveau\ Dossier/fichier.txt
• Portée de Recherche - Les recherches plus larges prennent plus de temps mais fournissent des résultats plus complets
• Impact Système - La découverte de fichiers à grande échelle peut impacter les performances système
• Limites de Résultats - Utiliser des limites appropriées pour éviter une sortie écrasante
• Maintenance d'Index - Mettre régulièrement à jour les index de fichiers pour précision
• Sensibilisation à la Sécurité - Être prudent lors de la recherche de fichiers et identifiants sensibles

Implémentez une gestion de suppression de fichiers et dossiers de niveau entreprise sur votre déploiement MacFleet avec la suppression sécurisée de données, les pistes d'audit, la protection par sauvegarde, la gestion de conformité et les opérations de nettoyage automatisées. Ce tutoriel fournit des solutions pour maintenir l'hygiène des données tout en assurant la sécurité, la conformité et la protection des données.

Comprendre la Gestion de Suppression de Fichiers macOS

macOS fournit plusieurs méthodes pour la suppression de fichiers et dossiers :

• rm - Supprimer fichiers et répertoires depuis la ligne de commande
• rm -r - Suppression récursive pour répertoires avec contenu
• rm -f - Suppression forcée sans invites de confirmation
• Finder - Opérations de suppression/corbeille basées sur GUI
• srm - Suppression sécurisée avec écrasement de données (legacy)

Opérations de Suppression de Fichiers de Base

Suppression Simple de Fichier/Dossier

#!/bin/bash

# Suppression de fichier de base
rm '/chemin vers le fichier ou dossier'

Suppression de Répertoire Récursive

#!/bin/bash

# Suppression de dossier récursive
rm -rf /Users/nomutilisateur/Desktop/Mes\ Fichiers

Supprimer Seulement le Contenu du Dossier

#!/bin/bash

# Supprimer le contenu du dossier
rm '/chemin vers le dossier/*'

Suppression de Fichiers Multiples

#!/bin/bash

# Supprimer des fichiers spécifiques multiples
rm Desktop/1.png Desktop/2.png

# Supprimer des fichiers par motif
rm Desktop/{1,2}.png

# Supprimer tous les fichiers d'un type
rm Desktop/*.png

Système de Gestion de Suppression de Fichiers Entreprise

#!/bin/bash

# Outil de Gestion de Suppression de Fichiers et Dossiers Entreprise MacFleet
# Suppression sécurisée de données avec capacités de conformité et d'audit

# Configuration
CONFIG_FILE="/etc/macfleet/file_deletion_policy.conf"
LOG_FILE="/var/log/macfleet_file_deletion.log"
BACKUP_DIR="/Library/MacFleet/DeletedFiles"
AUDIT_LOG="/var/log/macfleet_deletion_audit.log"
QUARANTINE_DIR="/Library/MacFleet/QuarantinedFiles"

# Créer les répertoires
mkdir -p "$(dirname "$CONFIG_FILE")" "$(dirname "$LOG_FILE")" "$BACKUP_DIR" "$(dirname "$AUDIT_LOG")" "$QUARANTINE_DIR"

# Politique de gestion de suppression de fichiers par défaut
cat > "$CONFIG_FILE" 2>/dev/null << 'EOF' || true
# Politique de Gestion de Suppression de Fichiers Entreprise MacFleet
# Version : 2.0

# Application des Politiques de Suppression
ENFORCE_DELETION_POLICIES=true
REQUIRE_BACKUP_BEFORE_DELETE=true
SECURE_DELETION_ENABLED=true
PREVENT_SYSTEM_FILE_DELETION=true
BUSINESS_HOURS_PROTECTION=true

# Sécurité et Protection des Données
REQUIRE_ADMIN_APPROVAL=false
VALIDATE_FILE_PERMISSIONS=true
PROTECTED_DIRECTORIES_ENFORCEMENT=true
MALWARE_QUARANTINE_CHECK=true
SENSITIVE_DATA_DETECTION=true

# Sauvegarde et Récupération
AUTOMATIC_BACKUP_ENABLED=true
BACKUP_RETENTION_DAYS=30
COMPRESSED_BACKUPS=true
ENCRYPTED_BACKUPS=true
RECOVERY_VALIDATION=true

# Conformité et Audit
AUDIT_ALL_DELETIONS=true
COMPLIANCE_REPORTING=true
INCIDENT_DOCUMENTATION=true
GDPR_COMPLIANCE=true
DATA_CLASSIFICATION_AWARE=true

# Expérience Utilisateur
USER_NOTIFICATION_ENABLED=true
DELETION_CONFIRMATION=true
PROGRESS_MONITORING=true
BATCH_OPERATION_SUPPORT=true
ROLLBACK_CAPABILITY=true

# Performance et Sécurité
DELETION_TIMEOUT=300
MAX_CONCURRENT_DELETIONS=5
SIZE_LIMIT_CHECK=true
FREE_SPACE_MONITORING=true
SYSTEM_LOAD_MONITORING=true
EOF

# Charger la configuration
source "$CONFIG_FILE" 2>/dev/null || true

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

# Fonction de journalisation d'audit
audit_log() {
    local action="$1"
    local file_path="$2"
    local result="$3"
    local details="$4"
    echo "$(date '+%Y-%m-%d %H:%M:%S') - ACTION:$action FILE:$file_path RESULT:$result DETAILS:$details USER:$(whoami) SIZE:$(get_file_size "$file_path")" >> "$AUDIT_LOG"
}

# Obtenir la taille de fichier pour audit
get_file_size() {
    local file_path="$1"
    if [[ -e "$file_path" ]]; then
        du -sh "$file_path" 2>/dev/null | awk '{print $1}' || echo "inconnu"
    else
        echo "0"
    fi
}

# Valider la sécurité de suppression de fichier
validate_deletion_safety() {
    local file_path="$1"
    local force="${2:-false}"
    
    echo "=== Validation de Sécurité de Suppression de Fichier ==="
    
    # Vérifier si le fichier/répertoire existe
    if [[ ! -e "$file_path" ]]; then
        echo "❌ Fichier ou répertoire introuvable : $file_path"
        audit_log "VALIDATION" "$file_path" "NOT_FOUND" "Fichier ou répertoire n'existe pas"
        return 1
    fi
    
    echo "✅ Fichier/répertoire trouvé : $file_path"
    
    # Empêcher la suppression de fichiers système
    if [[ "$PREVENT_SYSTEM_FILE_DELETION" == "true" ]]; then
        local protected_paths=(
            "/System"
            "/Library/System"
            "/usr/bin"
            "/usr/sbin"
            "/bin"
            "/sbin"
            "/var/db"
            "/private/var/db"
            "/Applications/Utilities"
        )
        
        for protected_path in "${protected_paths[@]}"; do
            if [[ "$file_path" == "$protected_path"* ]]; then
                echo "❌ Impossible de supprimer le chemin système protégé : $file_path"
                audit_log "VALIDATION" "$file_path" "PROTECTED_PATH" "Suppression de fichier système bloquée"
                return 1
            fi
        done
    fi
    
    # Vérifier les répertoires protégés
    if [[ "$PROTECTED_DIRECTORIES_ENFORCEMENT" == "true" && "$force" != "true" ]]; then
        local protected_dirs=(
            "/Users/*/Documents/Important"
            "/Users/*/Desktop/Critique"
            "/Library/MacFleet/Config"
            "/etc"
            "/Applications"
        )
        
        for protected_dir in "${protected_dirs[@]}"; do
            if [[ "$file_path" == $protected_dir* ]]; then
                echo "❌ Fichier dans répertoire protégé : $file_path"
                audit_log "VALIDATION" "$file_path" "PROTECTED_DIR" "Accès répertoire protégé bloqué"
                return 1
            fi
        done
    fi
    
    # Protection des heures de bureau pour données utilisateur
    if [[ "$BUSINESS_HOURS_PROTECTION" == "true" && "$force" != "true" ]]; then
        local current_hour
        current_hour=$(date +%H)
        local current_day
        current_day=$(date +%u)  # 1=Lundi, 7=Dimanche
        
        if [[ $current_day -ge 1 && $current_day -le 5 && $current_hour -ge 9 && $current_hour -lt 18 ]]; then
            if [[ "$file_path" == "/Users/"* ]]; then
                echo "⚠️  Protection heures de bureau : Suppression données utilisateur restreinte"
                audit_log "VALIDATION" "$file_path" "BUSINESS_HOURS" "Suppression données utilisateur bloquée pendant heures de bureau"
                return 1
            fi
        fi
    fi
    
    # Vérifier les permissions de fichier
    if [[ "$VALIDATE_FILE_PERMISSIONS" == "true" ]]; then
        if [[ ! -w "$file_path" && ! -w "$(dirname "$file_path")" ]]; then
            echo "❌ Permissions insuffisantes pour supprimer : $file_path"
            audit_log "VALIDATION" "$file_path" "NO_PERMISSION" "Permissions insuffisantes pour suppression"
            return 1
        fi
    fi
    
    # Détection de données sensibles
    if [[ "$SENSITIVE_DATA_DETECTION" == "true" ]]; then
        if detect_sensitive_data "$file_path"; then
            echo "⚠️  Données sensibles détectées dans : $file_path"
            if [[ "$force" != "true" ]]; then
                audit_log "VALIDATION" "$file_path" "SENSITIVE_DATA" "Suppression données sensibles nécessite flag force"
                return 1
            fi
        fi
    fi
    
    audit_log "VALIDATION" "$file_path" "PASSED" "Toutes les vérifications de sécurité réussies"
    return 0
}

# Détecter les données sensibles dans les fichiers
detect_sensitive_data() {
    local file_path="$1"
    
    if [[ -f "$file_path" ]]; then
        # Vérifier les motifs de données sensibles courants
        local sensitive_patterns=(
            "\b\d{3}-\d{2}-\d{4}\b"  # Motif SSN
            "\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b"  # Motif carte de crédit
            "password"
            "secret"
            "private.*key"
            "confidential"
        )
        
        for pattern in "${sensitive_patterns[@]}"; do
            if grep -qi "$pattern" "$file_path" 2>/dev/null; then
                return 0  # Données sensibles trouvées
            fi
        done
    fi
    
    return 1  # Aucune donnée sensible trouvée
}

# Créer une sauvegarde avant suppression
create_backup() {
    local file_path="$1"
    local backup_reason="${2:-deletion}"
    
    if [[ "$AUTOMATIC_BACKUP_ENABLED" != "true" ]]; then
        return 0
    fi
    
    echo "=== Création de Sauvegarde ==="
    
    local backup_timestamp
    backup_timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_name
    backup_name="$(basename "$file_path")_${backup_timestamp}_${backup_reason}"
    local backup_path="$BACKUP_DIR/$backup_name"
    
    # Créer la structure de répertoire de sauvegarde
    mkdir -p "$BACKUP_DIR"
    
    # Copier fichier/répertoire vers l'emplacement de sauvegarde
    if [[ -d "$file_path" ]]; then
        # Sauvegarde de répertoire
        if [[ "$COMPRESSED_BACKUPS" == "true" ]]; then
            tar -czf "${backup_path}.tar.gz" -C "$(dirname "$file_path")" "$(basename "$file_path")" 2>/dev/null
            backup_path="${backup_path}.tar.gz"
        else
            cp -R "$file_path" "$backup_path" 2>/dev/null
        fi
    else
        # Sauvegarde de fichier
        if [[ "$COMPRESSED_BACKUPS" == "true" && $(stat -f%z "$file_path" 2>/dev/null || echo 0) -gt 1048576 ]]; then
            gzip -c "$file_path" > "${backup_path}.gz" 2>/dev/null
            backup_path="${backup_path}.gz"
        else
            cp "$file_path" "$backup_path" 2>/dev/null
        fi
    fi
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Sauvegarde créée : $backup_path"
        
        # Chiffrer la sauvegarde si activé
        if [[ "$ENCRYPTED_BACKUPS" == "true" ]]; then
            encrypt_backup "$backup_path"
        fi
        
        # Enregistrer la sauvegarde dans les métadonnées
        echo "$(date -u +%Y-%m-%dT%H:%M:%SZ)|$file_path|$backup_path|$backup_reason" >> "$BACKUP_DIR/backup_manifest.log"
        
        log_action "Sauvegarde créée pour $file_path à $backup_path"
        audit_log "BACKUP" "$file_path" "CREATED" "Chemin sauvegarde : $backup_path"
        
        return 0
    else
        echo "❌ Échec de création de sauvegarde pour : $file_path"
        log_action "ÉCHEC : Création de sauvegarde échouée pour $file_path"
        audit_log "BACKUP" "$file_path" "FAILED" "Erreur création sauvegarde"
        return 1
    fi
}

# Chiffrer le fichier de sauvegarde
encrypt_backup() {
    local backup_path="$1"
    
    # Chiffrement simple utilisant les outils intégrés (en production, utiliser chiffrement entreprise approprié)
    if command -v openssl >/dev/null 2>&1; then
        openssl enc -aes-256-cbc -salt -in "$backup_path" -out "${backup_path}.enc" -k "MacFleet_Backup_Key_$(date +%Y)" 2>/dev/null
        if [[ $? -eq 0 ]]; then
            rm "$backup_path"
            echo "🔐 Sauvegarde chiffrée : ${backup_path}.enc"
            log_action "Sauvegarde chiffrée : ${backup_path}.enc"
        fi
    fi
}

# Suppression sécurisée de fichier
secure_delete() {
    local file_path="$1"
    local secure_passes="${2:-3}"
    
    echo "=== Processus de Suppression Sécurisée ==="
    
    if [[ ! -e "$file_path" ]]; then
        echo "❌ Fichier introuvable pour suppression sécurisée : $file_path"
        return 1
    fi
    
    local file_size
    file_size=$(get_file_size "$file_path")
    
    # Pour les fichiers, effectuer écrasement sécurisé avant suppression
    if [[ -f "$file_path" && "$SECURE_DELETION_ENABLED" == "true" ]]; then
        echo "🔐 Effectuant suppression sécurisée avec $secure_passes passes..."
        
        # Écrasement multiple passes
        for ((pass=1; pass<=secure_passes; pass++)); do
            echo "Passe $pass/$secure_passes : Écrasement avec données aléatoires..."
            dd if=/dev/urandom of="$file_path" bs=1024 count=$(du -k "$file_path" 2>/dev/null | cut -f1) 2>/dev/null || true
            sync
        done
        
        # Passe finale zéros
        dd if=/dev/zero of="$file_path" bs=1024 count=$(du -k "$file_path" 2>/dev/null | cut -f1) 2>/dev/null || true
        sync
        
        echo "🔐 Écrasement sécurisé terminé"
        audit_log "SECURE_DELETE" "$file_path" "OVERWRITTEN" "Écrasement sécurisé avec $secure_passes passes"
    fi
    
    # Effectuer suppression finale
    if [[ -d "$file_path" ]]; then
        # Suppression de répertoire
        rm -rf "$file_path" 2>/dev/null
    else
        # Suppression de fichier
        rm -f "$file_path" 2>/dev/null
    fi
    
    local deletion_result=$?
    
    if [[ $deletion_result -eq 0 ]]; then
        echo "✅ Fichier supprimé de manière sécurisée : $file_path (Taille : $file_size)"
        audit_log "SECURE_DELETE" "$file_path" "SUCCESS" "Suppression sécurisée terminée (Taille : $file_size)"
        return 0
    else
        echo "❌ Échec de suppression : $file_path"
        audit_log "SECURE_DELETE" "$file_path" "FAILED" "Suppression échouée"
        return 1
    fi
}

# Suppression de fichier entreprise avec gestion complète
enterprise_file_delete() {
    local file_path="$1"
    local force="${2:-false}"
    local secure="${3:-true}"
    local backup="${4:-true}"
    
    echo "=== Suppression de Fichier Entreprise ==="
    
    if [[ -z "$file_path" ]]; then
        echo "❌ Chemin de fichier requis"
        return 1
    fi
    
    log_action "SUPPRESSION FICHIER ENTREPRISE : Début suppression de $file_path"
    
    # Validation pré-suppression
    if ! validate_deletion_safety "$file_path" "$force"; then
        log_action "ÉCHEC : Validation sécurité suppression fichier échouée pour $file_path"
        return 1
    fi
    
    # Créer sauvegarde si requis
    if [[ "$backup" == "true" || "$REQUIRE_BACKUP_BEFORE_DELETE" == "true" ]]; then
        if ! create_backup "$file_path" "pre_deletion"; then
            if [[ "$force" != "true" ]]; then
                echo "❌ Sauvegarde échouée et mode force non activé"
                return 1
            else
                echo "⚠️  Procédure sans sauvegarde (mode force)"
            fi
        fi
    fi
    
    # Vérifier les ressources système
    check_system_resources
    
    # Confirmation utilisateur si activée
    if [[ "$DELETION_CONFIRMATION" == "true" && "$force" != "true" ]]; then
        echo "⚠️  Confirmation suppression requise pour : $file_path"
        # Dans les scripts automatisés, ceci s'intégrerait avec les flux d'approbation
        log_action "Confirmation suppression requise pour $file_path"
    fi
    
    # Effectuer la suppression
    local start_time
    start_time=$(date +%s)
    
    if [[ "$secure" == "true" ]]; then
        secure_delete "$file_path"
    else
        # Suppression standard
        if [[ -d "$file_path" ]]; then
            rm -rf "$file_path" 2>/dev/null
        else
            rm -f "$file_path" 2>/dev/null
        fi
    fi
    
    local deletion_result=$?
    local end_time
    end_time=$(date +%s)
    local duration=$((end_time - start_time))
    
    # Envoyer des notifications
    send_deletion_notification "$file_path" "$deletion_result" "$duration"
    
    # Nettoyage et vérification
    if [[ $deletion_result -eq 0 ]]; then
        echo "✅ Suppression de fichier terminée avec succès : $file_path"
        log_action "SUCCÈS : Fichier supprimé avec succès : $file_path (Durée : ${duration}s)"
        
        # Mettre à jour les statistiques d'utilisation
        update_deletion_stats "$file_path"
        
        # Nettoyer les fichiers liés
        cleanup_related_files "$file_path"
        
        return 0
    else
        echo "❌ Suppression de fichier échouée : $file_path"
        log_action "ÉCHEC : Impossible de supprimer le fichier : $file_path"
        return 1
    fi
}

# Envoyer une notification de suppression
send_deletion_notification() {
    local file_path="$1"
    local result="$2"
    local duration="$3"
    
    if [[ "$USER_NOTIFICATION_ENABLED" != "true" ]]; then
        return 0
    fi
    
    echo "=== Envoi des Notifications de Suppression ==="
    
    local notification_title="Gestion de Fichiers MacFleet"
    local result_text="succès"
    if [[ $result -ne 0 ]]; then
        result_text="échec"
    fi
    
    local notification_message="Suppression de fichier $result_text : $(basename "$file_path") (${duration}s)"
    
    # Afficher notification aux utilisateurs connectés
    local logged_users
    logged_users=$(who | awk '{print $1}' | sort -u)
    
    for user in $logged_users; do
        if [[ -n "$user" ]]; then
            sudo -u "$user" osascript -e "display notification \"$notification_message\" with title \"$notification_title\"" 2>/dev/null || true
            echo "📱 Notification envoyée à l'utilisateur : $user"
        fi
    done
    
    log_action "Notifications de suppression envoyées pour $file_path ($result_text)"
}

# Opérations de suppression de fichiers en masse
bulk_file_deletion() {
    local file_list="$1"
    local force="${2:-false}"
    local secure="${3:-true}"
    
    echo "=== Opérations de Suppression de Fichiers en Masse ==="
    
    local success_count=0
    local failure_count=0
    local total_count=0
    
    # Gérer différents types d'entrée
    if [[ -f "$file_list" ]]; then
        # Liste de fichiers depuis fichier
        while IFS= read -r file_path; do
            # Ignorer lignes vides et commentaires
            if [[ -z "$file_path" || "$file_path" == \#* ]]; then
                continue
            fi
            
            ((total_count++))
            echo "Traitement ($total_count) : $file_path"
            
            if enterprise_file_delete "$file_path" "$force" "$secure"; then
                ((success_count++))
            else
                ((failure_count++))
            fi
            
            echo "---"
            sleep 1  # Brève pause entre opérations
        done < "$file_list"
    else
        # Suppression basée sur motif
        echo "Suppression basée sur motif : $file_list"
        
        # Étendre le motif et traiter chaque fichier
        for file_path in $file_list; do
            if [[ -e "$file_path" ]]; then
                ((total_count++))
                echo "Traitement ($total_count) : $file_path"
                
                if enterprise_file_delete "$file_path" "$force" "$secure"; then
                    ((success_count++))
                else
                    ((failure_count++))
                fi
            fi
        done
    fi
    
    echo "=== Résumé de Suppression en Masse ==="
    echo "Total fichiers traités : $total_count"
    echo "Suppressions réussies : $success_count"
    echo "Suppressions échouées : $failure_count"
    
    log_action "Suppression en masse terminée : $success_count/$total_count réussies"
    audit_log "BULK_DELETE" "MULTIPLE" "COMPLETED" "Succès : $success_count Échecs : $failure_count Total : $total_count"
}

# Nettoyer les anciennes sauvegardes selon la politique de rétention
cleanup_old_backups() {
    echo "=== Nettoyage de Rétention de Sauvegarde ==="
    
    if [[ ! -d "$BACKUP_DIR" ]]; then
        echo "Aucun répertoire de sauvegarde trouvé"
        return 0
    fi
    
    local retention_days="${BACKUP_RETENTION_DAYS:-30}"
    local cleanup_count=0
    
    # Trouver et supprimer les anciennes sauvegardes
    while IFS= read -r old_backup; do
        if [[ -n "$old_backup" ]]; then
            rm -f "$old_backup"
            ((cleanup_count++))
            echo "Ancienne sauvegarde supprimée : $old_backup"
        fi
    done < <(find "$BACKUP_DIR" -type f -mtime +$retention_days 2>/dev/null)
    
    echo "Nettoyage de $cleanup_count anciennes sauvegardes (plus de $retention_days jours)"
    log_action "Nettoyage sauvegarde : $cleanup_count anciennes sauvegardes supprimées"
}

# Vérifier les ressources système avant suppression
check_system_resources() {
    echo "=== Vérification des Ressources Système ==="
    
    # Vérifier l'espace disque disponible
    local available_space
    available_space=$(df -h / | tail -1 | awk '{print $4}' | sed 's/G//')
    
    echo "Espace Disponible : ${available_space}GB"
    
    if [[ "$FREE_SPACE_MONITORING" == "true" ]] && (( $(echo "$available_space < 5" | bc -l) )); then
        echo "⚠️  Avertissement espace disque faible : ${available_space}GB disponible"
        log_action "Espace disque faible pendant opération suppression : ${available_space}GB"
    fi
    
    # Vérifier la charge système
    local load_average
    load_average=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | tr -d ',')
    
    echo "Charge Système : $load_average"
    
    if [[ "$SYSTEM_LOAD_MONITORING" == "true" ]] && (( $(echo "$load_average > 5.0" | bc -l) )); then
        echo "⚠️  Charge système élevée : $load_average"
        log_action "Charge système élevée pendant opération suppression : $load_average"
    fi
}

# Générer un rapport de suppression de fichiers
generate_deletion_report() {
    local report_file="/Library/MacFleet/Reports/file_deletion_report_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Génération du Rapport de Suppression de Fichiers ==="
    
    mkdir -p "$(dirname "$report_file")"
    
    # Compter les opérations récentes du journal d'audit
    local recent_deletions=0
    local successful_deletions=0
    local failed_deletions=0
    local total_backup_size=0
    
    if [[ -f "$AUDIT_LOG" ]]; then
        recent_deletions=$(grep -c "ACTION:SECURE_DELETE\|ACTION:BULK_DELETE" "$AUDIT_LOG" 2>/dev/null || echo 0)
        successful_deletions=$(grep -c "RESULT:SUCCESS" "$AUDIT_LOG" 2>/dev/null || echo 0)
        failed_deletions=$(grep -c "RESULT:FAILED" "$AUDIT_LOG" 2>/dev/null || echo 0)
    fi
    
    if [[ -d "$BACKUP_DIR" ]]; then
        total_backup_size=$(du -sh "$BACKUP_DIR" 2>/dev/null | awk '{print $1}' || echo "0")
    fi
    
    cat > "$report_file" << EOF
{
  "report_type": "file_deletion_management",
  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "device_info": {
    "hostname": "$(hostname)",
    "os_version": "$(sw_vers -productVersion)",
    "available_space": "$(df -h / | tail -1 | awk '{print $4}')"
  },
  "deletion_statistics": {
    "recent_deletions": $recent_deletions,
    "successful_deletions": $successful_deletions,
    "failed_deletions": $failed_deletions,
    "success_rate": "$(echo "scale=2; $successful_deletions * 100 / ($successful_deletions + $failed_deletions + 1)" | bc)%"
  },
  "backup_statistics": {
    "total_backup_size": "$total_backup_size",
    "backup_retention_days": $BACKUP_RETENTION_DAYS,
    "encrypted_backups": $ENCRYPTED_BACKUPS
  },
  "policy_configuration": {
    "secure_deletion": $SECURE_DELETION_ENABLED,
    "automatic_backup": $AUTOMATIC_BACKUP_ENABLED,
    "business_hours_protection": $BUSINESS_HOURS_PROTECTION,
    "sensitive_data_detection": $SENSITIVE_DATA_DETECTION
  },
  "security_status": {
    "system_file_protection": $PREVENT_SYSTEM_FILE_DELETION,
    "protected_directories": $PROTECTED_DIRECTORIES_ENFORCEMENT,
    "audit_enabled": $AUDIT_ALL_DELETIONS
  }
}
EOF
    
    echo "Rapport de suppression de fichiers sauvegardé dans : $report_file"
    log_action "Rapport de suppression généré : $report_file"
}

# Fonction principale avec gestion d'arguments
main() {
    log_action "=== Outil de Gestion de Suppression de Fichiers MacFleet Démarré ==="
    
    case "${1:-help}" in
        "delete"|"supprimer")
            enterprise_file_delete "$2" "$3" "$4" "$5"
            ;;
        "bulk"|"masse")
            bulk_file_deletion "$2" "$3" "$4"
            ;;
        "cleanup-backups"|"nettoyer-sauvegardes")
            cleanup_old_backups
            ;;
        "report"|"rapport")
            generate_deletion_report
            ;;
        *)
            echo "Outil de Gestion de Suppression de Fichiers et Dossiers Entreprise MacFleet"
            echo "Usage : $0 [commande] [options]"
            echo ""
            echo "Commandes :"
            echo "  delete [chemin_fichier] [force] [secure] [backup]  - Supprimer fichier avec contrôles entreprise"
            echo "  bulk [fichier_liste/motif] [force] [secure]       - Suppression en masse depuis liste ou motif"
            echo "  cleanup-backups                                   - Supprimer anciennes sauvegardes selon politique rétention"
            echo "  report                                            - Générer rapport gestion suppression"
            echo ""
            echo "Options :"
            echo "  force    - true/false (contourner vérifications sécurité)"
            echo "  secure   - true/false (activer suppression sécurisée)"
            echo "  backup   - true/false (créer sauvegarde avant suppression)"
            echo ""
            echo "Exemples :"
            echo "  $0 delete \"/Users/user/temp.txt\"            - Suppression sécurisée avec sauvegarde"
            echo "  $0 delete \"/tmp/folder\" true true false     - Suppression sécurisée forcée sans sauvegarde"
            echo "  $0 bulk \"*.log\" false true                 - Suppression sécurisée en masse fichiers log"
            echo "  $0 bulk file_list.txt true                   - Suppression forcée en masse depuis liste"
            echo "  $0 cleanup-backups                           - Nettoyer anciennes sauvegardes"
            ;;
    esac
    
    log_action "=== Opération de gestion de suppression de fichiers terminée ==="
}

# Exécuter la fonction principale
main "$@"

## Notes de Configuration Importantes

### Commandes de Suppression de Fichiers macOS

- **`rm`** - Suppression de fichier de base
- **`rm -r`** - Suppression de répertoire récursive
- **`rm -f`** - Suppression forcée sans invites
- **`rm -rf`** - Suppression récursive forcée
- **Correspondance de motifs** - `*.txt`, `{1,2}.png` pour opérations en masse

### Points d'Intégration Entreprise

- **Prévention de Perte de Données (DLP)** - Intégration avec systèmes DLP
- **Systèmes de Sauvegarde et Récupération** - Intégration sauvegarde automatisée
- **Plateformes de Conformité** - Rapports de conformité GDPR, HIPAA
- **Gestion d'Information et d'Événements de Sécurité (SIEM)** - Journalisation audit suppression

### Bonnes Pratiques pour Suppression de Fichiers Entreprise

1. **Sécurité et Protection des Données**
   - Toujours créer des sauvegardes avant suppression
   - Utiliser suppression sécurisée pour données sensibles
   - Valider les permissions de fichier avant suppression
   - Implémenter protection heures de bureau

2. **Conformité et Gouvernance**
   - Maintenir pistes d'audit complètes
   - Implémenter conscience classification données
   - Supporter exigences conformité réglementaires
   - Documenter toutes opérations suppression

3. **Sécurité et Récupération**
   - Empêcher suppression fichiers système
   - Implémenter capacités de retour arrière
   - Surveiller ressources système pendant opérations
   - Fournir systèmes notification clairs

N'oubliez pas de tester minutieusement les procédures de suppression de fichiers dans un environnement contrôlé avant l'implémentation sur l'ensemble de votre MacFleet pour assurer la sécurité des données et la conformité avec les politiques organisationnelles.