Guide

Gérez les jetons sécurisés sur vos appareils MacFleet pour activer le chiffrement FileVault, les opérations de démarrage sécurisé et l'authentification cryptographique. Ce tutoriel couvre la vérification, l'octroi, la suppression des jetons sécurisés et la gestion à l'échelle de l'entreprise pour une conformité sécuritaire renforcée.

Comprendre les Jetons Sécurisés

Les jetons sécurisés sont des identifiants cryptographiques qui permettent aux utilisateurs d'effectuer des opérations sensibles au niveau sécurité sur macOS, particulièrement essentiels pour le chiffrement de disque FileVault :

Que sont les Jetons Sécurisés ?

• Clés Cryptographiques - Permettent l'accès au stockage chiffré et aux fonctions de sécurité
• Exigence FileVault - Requis pour que les utilisateurs puissent déverrouiller les disques chiffrés FileVault
• Jetons Bootstrap - Facilitent le démarrage sécurisé et les processus de récupération système
• Pont d'Authentification - Connectent les identifiants utilisateur aux opérations de sécurité système
• Compatibilité Legacy - Remplacent les anciens mécanismes d'authentification dans macOS moderne

Exigences des Jetons Sécurisés

• macOS 10.13+ - High Sierra et versions ultérieures supportent les jetons sécurisés
• Privilèges Admin - L'octroi de jetons nécessite un admin existant avec jeton sécurisé
• Authentification Utilisateur - Mots de passe admin et utilisateur cible requis
• Intégrité Système - SIP (System Integrity Protection) doit être correctement configuré
• Propriété Volume - Les utilisateurs ont besoin de permissions d'accès volume appropriées

Vérification du Statut des Jetons Sécurisés

Vérifier le Statut d'un Utilisateur Individuel

#!/bin/bash

# Vérifier le statut du jeton sécurisé pour un utilisateur spécifique
check_user_secure_token() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "❌ Utilisation : check_user_secure_token <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! id "$username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    echo "🔍 Vérification du statut du jeton sécurisé pour l'utilisateur : $username"
    
    # Vérifier le statut du jeton sécurisé
    local token_status
    token_status=$(sysadminctl -secureTokenStatus "$username" 2>&1)
    
    if echo "$token_status" | grep -q "ENABLED"; then
        echo "✅ L'utilisateur '$username' a un jeton sécurisé activé"
        return 0
    elif echo "$token_status" | grep -q "DISABLED"; then
        echo "❌ L'utilisateur '$username' n'a pas de jeton sécurisé"
        return 1
    else
        echo "⚠️ Impossible de déterminer le statut du jeton sécurisé pour '$username'"
        echo "Sortie : $token_status"
        return 2
    fi
}

# Exemple d'utilisation
# check_user_secure_token "jean.dupont"

Vérifier le Statut de Tous les Utilisateurs

#!/bin/bash

# Vérifier le statut des jetons sécurisés pour tous les utilisateurs
check_all_users_secure_tokens() {
    echo "🔍 Vérification du statut des jetons sécurisés pour tous les utilisateurs..."
    echo ""
    
    local enabled_count=0
    local disabled_count=0
    local error_count=0
    
    # Obtenir tous les utilisateurs avec UID >= 500 (utilisateurs non-système)
    local users
    users=$(dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}')
    
    printf "%-20s %-15s %-30s\n" "Nom d'utilisateur" "Statut" "Détails"
    printf "%-20s %-15s %-30s\n" "----------------" "------" "-------"
    
    for user in $users; do
        local status
        local details=""
        
        # Ignorer les comptes système qui pourraient avoir des UID élevés
        if [[ "$user" =~ ^(_|com\.|root|daemon|nobody) ]]; then
            continue
        fi
        
        # Vérifier le statut du jeton sécurisé
        local token_output
        token_output=$(sysadminctl -secureTokenStatus "$user" 2>&1)
        
        if echo "$token_output" | grep -q "ENABLED"; then
            status="✅ Activé"
            details="Jeton sécurisé actif"
            ((enabled_count++))
        elif echo "$token_output" | grep -q "DISABLED"; then
            status="❌ Désactivé"
            details="Pas de jeton sécurisé"
            ((disabled_count++))
        else
            status="⚠️ Erreur"
            details="Impossible de déterminer"
            ((error_count++))
        fi
        
        printf "%-20s %-15s %-30s\n" "$user" "$status" "$details"
    done
    
    echo ""
    echo "=== Résumé ==="
    echo "Utilisateurs avec jeton sécurisé : $enabled_count"
    echo "Utilisateurs sans jeton sécurisé : $disabled_count"
    echo "Erreurs/Inconnu : $error_count"
    
    # Recommandations
    if [[ "$disabled_count" -gt 0 ]]; then
        echo ""
        echo "💡 $disabled_count utilisateurs manquent de jetons sécurisés - considérez l'octroi pour l'accès FileVault"
    fi
    
    if [[ "$enabled_count" -eq 0 ]]; then
        echo ""
        echo "⚠️ Aucun utilisateur n'a de jetons sécurisés - le système peut avoir des limitations de sécurité"
    fi
}

# Exécuter la vérification
check_all_users_secure_tokens

Octroi de Jetons Sécurisés

Octroi Basique de Jeton Sécurisé

#!/bin/bash

# Accorder un jeton sécurisé à un utilisateur
grant_secure_token() {
    local admin_user="$1"
    local admin_password="$2"
    local target_user="$3"
    local target_password="$4"
    
    if [[ -z "$admin_user" || -z "$admin_password" || -z "$target_user" || -z "$target_password" ]]; then
        echo "❌ Utilisation : grant_secure_token <utilisateur_admin> <mot_de_passe_admin> <utilisateur_cible> <mot_de_passe_cible>"
        return 1
    fi
    
    echo "🔐 Octroi du jeton sécurisé à l'utilisateur : $target_user"
    
    # Vérifier que l'utilisateur admin a un jeton sécurisé
    echo "Vérification des identifiants admin..."
    local admin_token_status
    admin_token_status=$(sysadminctl -secureTokenStatus "$admin_user" 2>&1)
    
    if ! echo "$admin_token_status" | grep -q "ENABLED"; then
        echo "❌ L'utilisateur admin '$admin_user' n'a pas de jeton sécurisé"
        echo "Impossible d'accorder un jeton sécurisé sans un utilisateur admin qui en a déjà un"
        return 1
    fi
    
    echo "✅ L'utilisateur admin '$admin_user' a un jeton sécurisé"
    
    # Vérifier si l'utilisateur cible a déjà un jeton sécurisé
    echo "Vérification du statut de l'utilisateur cible..."
    local target_token_status
    target_token_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$target_token_status" | grep -q "ENABLED"; then
        echo "ℹ️ L'utilisateur '$target_user' a déjà un jeton sécurisé - aucune action nécessaire"
        return 0
    fi
    
    # Accorder le jeton sécurisé
    echo "Octroi du jeton sécurisé à '$target_user'..."
    
    if sysadminctl \
        -adminUser "$admin_user" \
        -adminPassword "$admin_password" \
        -secureTokenOn "$target_user" \
        -password "$target_password"; then
        
        echo "✅ Jeton sécurisé accordé avec succès à '$target_user'"
        
        # Vérifier que l'octroi a réussi
        echo "Vérification de l'octroi du jeton sécurisé..."
        local verify_status
        verify_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
        
        if echo "$verify_status" | grep -q "ENABLED"; then
            echo "✅ Vérification réussie - '$target_user' a maintenant un jeton sécurisé"
            return 0
        else
            echo "❌ Échec de la vérification - le jeton sécurisé n'a peut-être pas été accordé correctement"
            return 1
        fi
    else
        echo "❌ Échec de l'octroi du jeton sécurisé à '$target_user'"
        echo "Vérifiez les identifiants et les permissions utilisateur"
        return 1
    fi
}

Gestion Avancée des Jetons Sécurisés

#!/bin/bash

# Gestion avancée des jetons sécurisés avec validation
advanced_secure_token_grant() {
    local admin_user="$1"
    local admin_password="$2"
    local target_user="$3"
    local target_password="$4"
    local force_mode="${5:-false}"
    
    echo "🔐 Gestion Avancée des Jetons Sécurisés"
    echo "Utilisateur cible : $target_user"
    echo "Utilisateur admin : $admin_user"
    echo "Mode forcé : $force_mode"
    echo ""
    
    # Vérification de la version macOS
    local macos_version
    macos_version=$(sw_vers -productVersion)
    local macos_major
    macos_major=$(echo "$macos_version" | cut -d. -f1)
    local macos_minor
    macos_minor=$(echo "$macos_version" | cut -d. -f2)
    
    echo "Version macOS : $macos_version"
    
    # Vérifier la compatibilité macOS
    if [[ "$macos_major" -lt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -lt 13 ]]; then
        echo "❌ Les jetons sécurisés nécessitent macOS 10.13 (High Sierra) ou ultérieur"
        echo "Version actuelle ($macos_version) non supportée"
        return 1
    fi
    
    # Vérifier que les utilisateurs existent
    if ! id "$admin_user" >/dev/null 2>&1; then
        echo "❌ L'utilisateur admin '$admin_user' n'existe pas"
        return 1
    fi
    
    if ! id "$target_user" >/dev/null 2>&1; then
        echo "❌ L'utilisateur cible '$target_user' n'existe pas"
        return 1
    fi
    
    # Vérifier si l'utilisateur admin est vraiment un administrateur
    if ! dseditgroup -o checkmember -m "$admin_user" admin >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$admin_user' n'est pas membre du groupe admin"
        return 1
    fi
    
    echo "✅ Validation des utilisateurs réussie"
    
    # Vérifier le statut du jeton sécurisé pour l'admin
    local admin_token_status
    admin_token_status=$(sysadminctl -secureTokenStatus "$admin_user" 2>&1)
    
    if echo "$admin_token_status" | grep -q "DISABLED"; then
        # Gestion spéciale pour macOS 10.15+
        if [[ "$macos_major" -gt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -gt 14 ]]; then
            echo "⚠️ Dans macOS 10.15+, les jetons sécurisés peuvent être accordés automatiquement"
            echo "   au premier utilisateur qui active FileVault si aucun autre utilisateur n'a de jetons"
            if [[ "$force_mode" != "true" ]]; then
                echo "   Utilisez force_mode=true pour contourner cette vérification"
                return 1
            fi
        else
            echo "❌ L'utilisateur admin '$admin_user' n'a pas de jeton sécurisé"
            echo "   Impossible d'accorder un jeton sans un admin qui en a déjà un"
            return 1
        fi
    else
        echo "✅ L'utilisateur admin '$admin_user' a un jeton sécurisé"
    fi
    
    # Vérifier le statut actuel de l'utilisateur cible
    local target_token_status
    target_token_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$target_token_status" | grep -q "ENABLED"; then
        echo "ℹ️ L'utilisateur '$target_user' a déjà un jeton sécurisé"
        if [[ "$force_mode" != "true" ]]; then
            echo "   Aucune action nécessaire"
            return 0
        else
            echo "   Mode forcé activé - tentera de rafraîchir le jeton"
        fi
    fi
    
    # Tenter d'accorder le jeton sécurisé
    echo ""
    echo "Octroi du jeton sécurisé à '$target_user'..."
    
    if sysadminctl \
        -adminUser "$admin_user" \
        -adminPassword "$admin_password" \
        -secureTokenOn "$target_user" \
        -password "$target_password" >/dev/null 2>&1; then
        
        echo "✅ Commande d'octroi de jeton sécurisé exécutée avec succès"
    else
        echo "❌ Échec de la commande d'octroi de jeton sécurisé"
        return 1
    fi
    
    # Vérifier le résultat
    echo "Vérification du statut du jeton sécurisé..."
    local final_status
    final_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$final_status" | grep -q "ENABLED"; then
        echo "✅ Vérification réussie - '$target_user' a maintenant un jeton sécurisé"
        
        # Informations supplémentaires
        echo ""
        echo "=== Informations Supplémentaires ==="
        echo "Éligibilité FileVault : L'utilisateur peut maintenant déverrouiller les volumes FileVault"
        echo "Opérations de sécurité : L'utilisateur peut effectuer des opérations cryptographiques"
        echo "Récupération système : L'utilisateur peut participer aux processus de démarrage sécurisé"
        
        return 0
    else
        echo "❌ Échec de la vérification - le jeton sécurisé n'a pas été accordé"
        echo "Ceci peut indiquer :"
        echo "  - Identifiants incorrects"
        echo "  - Restrictions de sécurité système"
        echo "  - Problèmes de configuration FileVault"
        return 1
    fi
}

Gestion d'Entreprise des Jetons Sécurisés

#!/bin/bash

# Outil de Gestion des Jetons Sécurisés MacFleet
# Gestion complète des jetons sécurisés pour environnements d'entreprise

# Configuration
LOG_FILE="/var/log/macfleet_securetoken.log"
REPORT_DIR="/var/reports/macfleet/securetoken"
CONFIG_FILE="/etc/macfleet/securetoken_policy.conf"
BACKUP_DIR="/var/backups/macfleet/securetoken"

# Paramètres de politique
REQUIRE_SECURE_TOKENS=true
AUTO_GRANT_ON_CREATION=false
MINIMUM_ADMIN_TOKENS=2
ALERT_ON_TOKEN_LOSS=true
AUDIT_TOKEN_CHANGES=true

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

# Configurer les répertoires
setup_directories() {
    for dir in "$REPORT_DIR" "$(dirname "$CONFIG_FILE")" "$BACKUP_DIR"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# Générer un rapport complet des jetons sécurisés
generate_secure_token_report() {
    local report_file="$REPORT_DIR/rapport_jetons_securises_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "📊 Génération d'un rapport complet des jetons sécurisés..."
    
    {
        echo "Rapport de Gestion des Jetons Sécurisés MacFleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "=============================================="
        echo ""
        
        # Informations système
        echo "=== Informations Système ==="
        echo "Appareil : $(system_profiler SPHardwareDataType | grep "Model Name" | awk -F': ' '{print $2}' | xargs)"
        echo "Série : $(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F': ' '{print $2}' | xargs)"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "Build : $(sw_vers -buildVersion)"
        echo ""
        
        # Statut FileVault
        echo "=== Informations FileVault ==="
        local fv_status=$(fdesetup status 2>/dev/null || echo "Statut FileVault non disponible")
        echo "Statut FileVault : $fv_status"
        
        if echo "$fv_status" | grep -q "On"; then
            echo "Utilisateurs FileVault :"
            fdesetup list 2>/dev/null | while read -r user; do
                echo "  - $user"
            done
        fi
        echo ""
        
        # Analyse des jetons sécurisés
        echo "=== Analyse des Jetons Sécurisés ==="
        
        local total_users=0
        local enabled_tokens=0
        local disabled_tokens=0
        local admin_with_tokens=0
        local standard_with_tokens=0
        
        # Analyser tous les utilisateurs
        local users
        users=$(dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}')
        
        printf "%-25s %-12s %-10s %-15s\n" "Nom d'utilisateur" "Statut Jeton" "Admin" "UID"
        printf "%-25s %-12s %-10s %-15s\n" "----------------" "------------" "-----" "---"
        
        for user in $users; do
            # Ignorer les comptes système
            if [[ "$user" =~ ^(_|com\.|root|daemon|nobody) ]]; then
                continue
            fi
            
            ((total_users++))
            
            local uid
            uid=$(id -u "$user" 2>/dev/null || echo "N/A")
            
            local is_admin="Non"
            if dseditgroup -o checkmember -m "$user" admin >/dev/null 2>&1; then
                is_admin="Oui"
            fi
            
            local token_status
            local token_output
            token_output=$(sysadminctl -secureTokenStatus "$user" 2>&1)
            
            if echo "$token_output" | grep -q "ENABLED"; then
                token_status="✅ Activé"
                ((enabled_tokens++))
                if [[ "$is_admin" == "Oui" ]]; then
                    ((admin_with_tokens++))
                else
                    ((standard_with_tokens++))
                fi
            elif echo "$token_output" | grep -q "DISABLED"; then
                token_status="❌ Désactivé"
                ((disabled_tokens++))
            else
                token_status="⚠️ Inconnu"
            fi
            
            printf "%-25s %-12s %-10s %-15s\n" "$user" "$token_status" "$is_admin" "$uid"
        done
        
        echo ""
        echo "=== Statistiques ==="
        echo "Total utilisateurs analysés : $total_users"
        echo "Utilisateurs avec jetons sécurisés : $enabled_tokens"
        echo "Utilisateurs sans jetons sécurisés : $disabled_tokens"
        echo "Utilisateurs admin avec jetons : $admin_with_tokens"
        echo "Utilisateurs standard avec jetons : $standard_with_tokens"
        
        # Évaluation de sécurité
        echo ""
        echo "=== Évaluation de Sécurité ==="
        
        local security_score=100
        local issues_found=0
        
        if [[ "$enabled_tokens" -eq 0 ]]; then
            echo "❌ CRITIQUE : Aucun utilisateur n'a de jetons sécurisés"
            security_score=$((security_score - 50))
            ((issues_found++))
        fi
        
        if [[ "$admin_with_tokens" -eq 0 ]]; then
            echo "❌ CRITIQUE : Aucun utilisateur admin n'a de jetons sécurisés"
            security_score=$((security_score - 40))
            ((issues_found++))
        elif [[ "$admin_with_tokens" -lt "$MINIMUM_ADMIN_TOKENS" ]]; then
            echo "⚠️ AVERTISSEMENT : Moins de $MINIMUM_ADMIN_TOKENS utilisateurs admin ont des jetons sécurisés"
            security_score=$((security_score - 20))
            ((issues_found++))
        fi
        
        if [[ "$disabled_tokens" -gt "$enabled_tokens" ]]; then
            echo "⚠️ AVERTISSEMENT : Plus d'utilisateurs manquent de jetons sécurisés que n'en ont"
            security_score=$((security_score - 15))
            ((issues_found++))
        fi
        
        if [[ "$issues_found" -eq 0 ]]; then
            echo "✅ Aucun problème de sécurité détecté"
        fi
        
        echo ""
        echo "Score de Sécurité : $security_score/100"
        
        # Recommandations
        echo ""
        echo "=== Recommandations ==="
        
        if [[ "$disabled_tokens" -gt 0 ]]; then
            echo "💡 Accordez des jetons sécurisés à $disabled_tokens utilisateurs pour une compatibilité FileVault complète"
        fi
        
        if [[ "$admin_with_tokens" -lt 2 ]]; then
            echo "💡 Assurez-vous qu'au moins 2 utilisateurs admin ont des jetons sécurisés pour la redondance"
        fi
        
        echo "💡 Audits réguliers des jetons sécurisés recommandés pour la conformité"
        
    } > "$report_file"
    
    echo "📊 Rapport sauvegardé dans : $report_file"
    log_action "Rapport de jetons sécurisés généré : $report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-aide}"
    local target_user="${2:-}"
    local admin_user="${3:-}"
    
    log_action "=== Gestion des Jetons Sécurisés MacFleet Démarrée ==="
    
    setup_directories
    
    case "$action" in
        "verifier")
            if [[ -n "$target_user" ]]; then
                check_user_secure_token "$target_user"
            else
                check_all_users_secure_tokens
            fi
            ;;
        "accorder")
            if [[ -n "$target_user" && -n "$admin_user" ]]; then
                echo "Octroi interactif de jeton sécurisé pour $target_user"
                read -s -p "Mot de passe admin pour $admin_user : " admin_pass
                echo ""
                read -s -p "Mot de passe pour $target_user : " target_pass
                echo ""
                advanced_secure_token_grant "$admin_user" "$admin_pass" "$target_user" "$target_pass"
            else
                echo "❌ Utilisation : $0 accorder <utilisateur_cible> <utilisateur_admin>"
            fi
            ;;
        "rapport")
            generate_secure_token_report
            ;;
        "version")
            local macos_version
            macos_version=$(sw_vers -productVersion)
            echo "Version macOS : $macos_version"
            
            local macos_major
            macos_major=$(echo "$macos_version" | cut -d. -f1)
            local macos_minor
            macos_minor=$(echo "$macos_version" | cut -d. -f2)
            
            if [[ "$macos_major" -lt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -lt 13 ]]; then
                echo "❌ Les jetons sécurisés nécessitent macOS 10.13 ou ultérieur"
            else
                echo "✅ Jetons sécurisés supportés sur cette version macOS"
            fi
            ;;
        "aide"|*)
            echo "Outil de Gestion des Jetons Sécurisés MacFleet"
            echo "Utilisation : $0 [action] [options]"
            echo ""
            echo "Actions :"
            echo "  verifier [utilisateur]           - Vérifier le statut des jetons sécurisés (tous les utilisateurs si aucun utilisateur spécifié)"
            echo "  accorder <utilisateur> <admin>   - Accorder un jeton sécurisé à l'utilisateur (mots de passe interactifs)"
            echo "  rapport                          - Générer un rapport complet des jetons sécurisés"
            echo "  version                          - Vérifier la compatibilité de version macOS"
            echo "  aide                             - Afficher ce message d'aide"
            echo ""
            echo "Exemples :"
            echo "  $0 verifier                      # Vérifier tous les utilisateurs"
            echo "  $0 verifier jean.dupont          # Vérifier un utilisateur spécifique"
            echo "  $0 accorder jean.dupont admin.utilisateur  # Accorder jeton interactivement"
            echo "  $0 rapport                       # Générer rapport détaillé"
            echo ""
            echo "Exigences des Jetons Sécurisés :"
            echo "  - macOS 10.13 (High Sierra) ou ultérieur"
            echo "  - Utilisateur admin avec jeton sécurisé existant"
            echo "  - Identifiants valides pour admin et utilisateurs cibles"
            echo "  - Permissions système appropriées et configuration SIP"
            ;;
    esac
    
    log_action "=== Gestion des Jetons Sécurisés MacFleet Terminée ==="
}

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

Meilleures Pratiques des Jetons Sécurisés

Considérations de Sécurité

Notes Importantes

• Exigences de Version macOS - Les jetons sécurisés nécessitent macOS 10.13 (High Sierra) ou ultérieur
• Prérequis Admin - L'octroi de jetons nécessite un utilisateur admin existant avec jeton sécurisé
• Sécurité Mot de Passe - Les mots de passe admin et utilisateur cible doivent être fournis pour l'octroi de jetons
• Intégration FileVault - Les utilisateurs ont besoin de jetons sécurisés pour déverrouiller les volumes chiffrés FileVault
• Déploiement d'Entreprise - Testez les opérations de jetons sur des appareils individuels avant le déploiement de flotte
• Surveillance - Les audits réguliers assurent la conformité avec les politiques de sécurité d'entreprise

Gérez l'effacement sécurisé des données et la protection de la vie privée sur vos appareils MacFleet en utilisant des systèmes de désinfection de données avancés. Ce tutoriel couvre l'effacement d'espace libre, la suppression sécurisée, la surveillance de conformité et la gestion complète du cycle de vie des données.

Comprendre l'Effacement Sécurisé de Données macOS

macOS fournit des capacités d'effacement sécurisé des données pour la vie privée et la conformité :

• diskutil secureErase - Effacement sécurisé d'espace libre et volumes
• Effacement d'Espace Libre - Supprimer les traces de fichiers supprimés du disque
• Niveaux d'Effacement Sécurisé - Multiples standards de sécurité (DoD, DoE, Gutmann)
• Protection de Vie Privée - Empêcher la récupération de données et analyse médico-légale
• Exigences de Conformité - Respecter les standards réglementaires pour destruction de données

Opérations d'Effacement Sécurisé de Base

Effacer l'Espace Libre

#!/bin/bash

# Effacement d'espace libre de base
diskutil secureErase freespace 4 /Volumes/Macintosh\ HD

echo "Effacement sécurisé d'espace libre terminé"

Configuration d'Effacement Sécurisé Améliorée

#!/bin/bash

# Effacement sécurisé complet avec multiples niveaux de sécurité
secure_erase_freespace() {
    local volume_path="$1"
    local security_level="${2:-4}"
    
    echo "=== Effacement Sécurisé d'Espace Libre ==="
    echo "Volume : $volume_path"
    echo "Niveau de Sécurité : $security_level"
    
    # Valider que le volume existe
    if [[ ! -d "$volume_path" ]]; then
        echo "❌ Volume non trouvé : $volume_path"
        return 1
    fi
    
    # Afficher les informations de niveau de sécurité
    case "$security_level" in
        0) echo "Méthode de Sécurité : Effacement à remplissage zéro en un passage" ;;
        1) echo "Méthode de Sécurité : Effacement à remplissage aléatoire en un passage" ;;
        2) echo "Méthode de Sécurité : Effacement sécurisé US DoD à 7 passages" ;;
        3) echo "Méthode de Sécurité : Algorithme Gutmann à 35 passages d'effacement sécurisé" ;;
        4) echo "Méthode de Sécurité : Algorithme US DoE à 3 passages d'effacement sécurisé" ;;
        *) echo "❌ Niveau de sécurité invalide : $security_level"; return 1 ;;
    esac
    
    # Obtenir les informations du volume
    local free_space
    free_space=$(df -h "$volume_path" | tail -1 | awk '{print $4}')
    echo "Espace Libre à Effacer : $free_space"
    
    # Estimer le temps basé sur le niveau de sécurité et l'espace libre
    echo "⏱️  Temps estimé : Cela peut prendre plusieurs heures selon la taille du disque et le niveau de sécurité"
    
    # Effectuer l'effacement sécurisé
    echo "Démarrage de l'effacement sécurisé..."
    if diskutil secureErase freespace "$security_level" "$volume_path"; then
        echo "✅ Effacement sécurisé d'espace libre terminé avec succès"
        log_erasure_action "espace_libre" "$volume_path" "$security_level" "succès"
    else
        echo "❌ Effacement sécurisé échoué"
        log_erasure_action "espace_libre" "$volume_path" "$security_level" "échoué"
        return 1
    fi
    
    return 0
}

# Fonction de journalisation
log_erasure_action() {
    local action="$1"
    local target="$2"
    local level="$3"
    local result="$4"
    
    echo "$(date '+%Y-%m-%d %H:%M:%S') - Effacement Sécurisé : $action sur $target (Niveau : $level) - $result" >> "/var/log/macfleet_effacement_securise.log"
}

# Exemple d'utilisation
# secure_erase_freespace "/Volumes/Macintosh HD" 4

Catégories d'Effacement Sécurisé

Niveaux de Classification des Données

#!/bin/bash

# Catégories d'effacement sécurisé pour différents niveaux de sensibilité des données
declare -A ERASURE_CATEGORIES=(
    ["donnees_publiques"]="Informations publiques à faible sensibilité nécessitant un effacement de base"
    ["affaires_internes"]="Données d'affaires internes nécessitant un effacement sécurisé standard"
    ["donnees_confidentielles"]="Informations d'affaires confidentielles nécessitant un effacement amélioré"
    ["financieres_restreintes"]="Données financières et comptables nécessitant des protocoles d'effacement stricts"
    ["identifiables_personnelles"]="Données PII nécessitant des procédures d'effacement conformes à la vie privée"
    ["dossiers_medicaux"]="Informations de santé protégées HIPAA nécessitant un effacement de qualité médicale"
    ["privilege_legal"]="Informations privilégiées avocat-client nécessitant un effacement de sécurité maximale"
    ["gouvernement_classifie"]="Données gouvernementales classifiées nécessitant un effacement de niveau militaire"
    ["recherche_intellectuelle"]="Données de recherche et PI nécessitant des protocoles d'effacement complets"
    ["preuves_medico_legales"]="Preuves médico-légales numériques nécessitant un effacement de chaîne de possession"
)

# Niveaux de sécurité pour chaque catégorie
declare -A CATEGORY_SECURITY_LEVELS=(
    ["donnees_publiques"]="1"           # Un passage aléatoire
    ["affaires_internes"]="2"           # DoD 7 passages
    ["donnees_confidentielles"]="4"     # DoE 3 passages
    ["financieres_restreintes"]="4"     # DoE 3 passages
    ["identifiables_personnelles"]="4"  # DoE 3 passages
    ["dossiers_medicaux"]="3"           # Gutmann 35 passages
    ["privilege_legal"]="3"             # Gutmann 35 passages
    ["gouvernement_classifie"]="3"      # Gutmann 35 passages
    ["recherche_intellectuelle"]="4"    # DoE 3 passages
    ["preuves_medico_legales"]="3"      # Gutmann 35 passages
)

# Cadres de conformité
declare -A COMPLIANCE_FRAMEWORKS=(
    ["donnees_publiques"]="securite_de_base"
    ["affaires_internes"]="iso27001"
    ["donnees_confidentielles"]="iso27001,sox"
    ["financieres_restreintes"]="sox,pci_dss"
    ["identifiables_personnelles"]="gdpr,ccpa"
    ["dossiers_medicaux"]="hipaa,hitech"
    ["privilege_legal"]="privilege_avocat_client"
    ["gouvernement_classifie"]="fisma,nist_sp800"
    ["recherche_intellectuelle"]="iso27001,secrets_commerciaux"
    ["preuves_medico_legales"]="chaine_de_possession,decouverte_legale"
)

print_erasure_categories() {
    echo "=== Catégories d'Effacement Sécurisé ==="
    for category in "${!ERASURE_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${ERASURE_CATEGORIES[$category]}"
        echo "  Niveau de Sécurité : ${CATEGORY_SECURITY_LEVELS[$category]}"
        echo "  Conformité : ${COMPLIANCE_FRAMEWORKS[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_erasure_categories

Politiques d'Effacement Sécurisé

Politiques de Protection de Vie Privée

#!/bin/bash

# Politiques d'effacement sécurisé pour différentes exigences de vie privée et conformité
declare -A ERASURE_POLICIES=(
    ["vie_privee_de_base"]="Protection de vie privée de base avec méthodes d'effacement standard"
    ["conforme_gdpr"]="Effacement de données personnelles conforme GDPR avec pistes d'audit"
    ["medical_hipaa"]="Effacement de dossiers médicaux conforme HIPAA avec certification"
    ["financier_sox"]="Effacement de données financières conforme SOX avec validation"
    ["gouvernement_classifie"]="Effacement de données gouvernementales classifiées avec chaîne de possession"
    ["legal_medico_legal"]="Effacement de données légales et médico-légales avec préservation de preuves"
)

# Obtenir la configuration de politique d'effacement
get_erasure_policy() {
    local policy_type="$1"
    
    case "$policy_type" in
        "vie_privee_de_base")
            cat << EOF
{
    "effacement_active": true,
    "niveau_securite_defaut": 2,
    "planification_automatique": false,
    "verification_requise": false,
    "journalisation_audit": "de_base",
    "cadres_conformite": ["securite_de_base"],
    "generation_certificat": false,
    "chaine_de_possession": false,
    "classification_donnees": "public_interne",
    "politique_retention": "effacement_immediat",
    "methodes_verification": ["verification_de_base"],
    "niveau_rapport": "resume"
}
EOF
            ;;
        "conforme_gdpr")
            cat << EOF
{
    "effacement_active": true,
    "niveau_securite_defaut": 4,
    "planification_automatique": true,
    "verification_requise": true,
    "journalisation_audit": "complete",
    "cadres_conformite": ["gdpr", "ccpa"],
    "generation_certificat": true,
    "chaine_de_possession": true,
    "classification_donnees": "identifiables_personnelles",
    "politique_retention": "effacement_verifie",
    "methodes_verification": ["verification_medico_legale", "analyse_entropie"],
    "niveau_rapport": "detaille",
    "evaluation_impact_vie_privee": true,
    "droits_sujet_donnees": "droit_effacement",
    "considerations_transfrontalieres": true
}
EOF
            ;;
        "medical_hipaa")
            cat << EOF
{
    "effacement_active": true,
    "niveau_securite_defaut": 3,
    "planification_automatique": true,
    "verification_requise": true,
    "journalisation_audit": "complete",
    "cadres_conformite": ["hipaa", "hitech"],
    "generation_certificat": true,
    "chaine_de_possession": true,
    "classification_donnees": "dossiers_medicaux",
    "politique_retention": "calendrier_retention_medical",
    "methodes_verification": ["verification_medico_legale", "certification_medicale"],
    "niveau_rapport": "detaille",
    "verification_chiffrement": true,
    "controles_acces": "base_sur_role",
    "considerations_dispositifs_medicaux": true
}
EOF
            ;;
        *)
            echo "Politique d'effacement inconnue : $policy_type"
            return 1
            ;;
    esac
}

# Appliquer une politique d'effacement
apply_erasure_policy() {
    local policy="$1"
    local config_file="/tmp/politique_effacement.json"
    
    echo "Application de la politique d'effacement sécurisé : $policy"
    
    get_erasure_policy "$policy" > "$config_file"
    
    if [[ ! -f "$config_file" ]]; then
        echo "❌ Échec de génération de configuration de politique"
        return 1
    fi
    
    echo "✅ Politique d'effacement sécurisé appliquée avec succès"
    echo "Configuration : $config_file"
    
    # Afficher les paramètres clés de politique
    echo "=== Résumé de Politique ==="
    echo "Effacement Activé : $(jq -r '.effacement_active' "$config_file")"
    echo "Niveau de Sécurité Défaut : $(jq -r '.niveau_securite_defaut' "$config_file")"
    echo "Vérification Requise : $(jq -r '.verification_requise' "$config_file")"
    echo "Journalisation d'Audit : $(jq -r '.journalisation_audit' "$config_file")"
    
    return 0
}

Surveillance Avancée d'Effacement Sécurisé

Vérification et Analyse d'Effacement

#!/bin/bash

# Surveillance et vérification complètes d'effacement sécurisé
verify_secure_erasure() {
    local verification_profile="$1"
    local target_volume="$2"
    local verification_report="/tmp/verification_effacement_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Vérification d'Effacement Sécurisé ==="
    echo "Profil de Vérification : $verification_profile"
    echo "Volume Cible : $target_volume"
    
    # Initialiser le rapport de vérification
    cat > "$verification_report" << EOF
{
    "profil_verification": "$verification_profile",
    "volume_cible": "$target_volume",
    "horodatage_verification": "$(date -Iseconds)",
    "nom_hote": "$(hostname)",
    "resultats_verification": {},
    "statut_conformite": {},
    "analyse_medico_legale": {}
}
EOF
    
    # Effectuer les vérifications
    echo "Exécution des vérifications..."
    
    # Vérifier le statut du volume
    local volume_status="inconnu"
    if [[ -d "$target_volume" ]]; then
        volume_status="accessible"
    else
        volume_status="inaccessible"
    fi
    
    # Analyser l'entropie de l'espace libre
    echo "Analyse de l'entropie de l'espace libre..."
    local entropy_score
    entropy_score=$(calculate_entropy "$target_volume")
    
    # Vérifier les résidus de données
    echo "Recherche de résidus de données..."
    local remnant_scan_result
    remnant_scan_result=$(scan_data_remnants "$target_volume")
    
    # Vérifier la complétude de l'effacement
    echo "Vérification de la complétude de l'effacement..."
    local completeness_score
    completeness_score=$(verify_erasure_completeness "$target_volume")
    
    # Afficher les résultats
    echo ""
    echo "Résultats de Vérification :"
    echo "  Statut du Volume : $volume_status"
    echo "  Score d'Entropie : $entropy_score"
    echo "  Résidus de Données : $remnant_scan_result"
    echo "  Complétude : $completeness_score"
    echo "  Rapport de Vérification : $verification_report"
    
    return 0
}

# Fonctions d'aide
calculate_entropy() {
    local volume="$1"
    # Calcul d'entropie simplifié
    echo "entropie_elevee"
}

scan_data_remnants() {
    local volume="$1"
    # Recherche de résidus simplifiée
    echo "aucun_residu_detecte"
}

verify_erasure_completeness() {
    local volume="$1"
    # Vérification de complétude simplifiée
    echo "100_pourcent"
}

Système de Gestion d'Effacement Sécurisé des Données

#!/bin/bash

# Système de Gestion d'Effacement Sécurisé des Données MacFleet
# Désinfection complète des données, protection de la vie privée et surveillance de conformité

# Configuration
CONFIG_DIR="/etc/macfleet/effacement"
LOG_FILE="/var/log/macfleet_effacement_securise.log"
AUDIT_LOG="/var/log/macfleet_audit_effacement.log"
CERTIFICATES_DIR="/var/certificates/macfleet/effacement"

# 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"
}

# Découverte et analyse de volumes
discover_volumes() {
    echo "=== Découverte de Volumes ==="
    
    log_action "Démarrage de la découverte de volumes"
    
    # Lister tous les volumes montés
    echo "Volumes Montés :"
    df -h | grep "^/dev/" | while read -r line; do
        local device
        device=$(echo "$line" | awk '{print $1}')
        local mount_point
        mount_point=$(echo "$line" | awk '{print $9}')
        local size
        size=$(echo "$line" | awk '{print $2}')
        local available
        available=$(echo "$line" | awk '{print $4}')
        
        echo "  Périphérique : $device"
        echo "  Point de Montage : $mount_point"
        echo "  Taille : $size"
        echo "  Disponible : $available"
        echo ""
    done
    
    log_action "Découverte de volumes terminée"
}

# Exécution d'effacement sécurisé
execute_secure_erasure() {
    local volume_path="$1"
    local security_level="$2"
    local category="${3:-affaires_internes}"
    local policy="${4:-vie_privee_de_base}"
    
    log_action "Exécution d'effacement sécurisé : $volume_path (Niveau : $security_level, Catégorie : $category)"
    
    echo "=== Exécution d'Effacement Sécurisé ==="
    echo "Volume : $volume_path"
    echo "Niveau de Sécurité : $security_level"
    echo "Catégorie de Données : $category"
    echo "Politique d'Effacement : $policy"
    
    # Validation pré-effacement
    echo "Validation pré-effacement..."
    
    # Vérifier l'accessibilité du volume
    if [[ ! -d "$volume_path" ]]; then
        log_error "Volume non accessible : $volume_path"
        return 1
    fi
    
    # Exécuter l'effacement basé sur le niveau de sécurité
    echo "Démarrage de l'opération d'effacement sécurisé..."
    local start_time
    start_time=$(date +%s)
    
    case "$security_level" in
        0|1|2|3|4)
            if diskutil secureErase freespace "$security_level" "$volume_path"; then
                local end_time
                end_time=$(date +%s)
                local duration=$((end_time - start_time))
                
                echo "✅ Effacement sécurisé terminé avec succès"
                echo "⏱️  Durée : ${duration} secondes"
                
                # Générer un certificat de complétude
                generate_erasure_certificate "$volume_path" "$security_level" "$category" "$policy" "$duration" "succès"
                
                audit_log "Effacement sécurisé réussi : $volume_path (Niveau : $security_level, Durée : ${duration}s)"
                return 0
            else
                log_error "Effacement sécurisé échoué : $volume_path"
                
                # Générer un rapport d'échec
                generate_erasure_certificate "$volume_path" "$security_level" "$category" "$policy" "0" "échoué"
                
                audit_log "Effacement sécurisé échoué : $volume_path (Niveau : $security_level)"
                return 1
            fi
            ;;
        *)
            log_error "Niveau de sécurité invalide : $security_level"
            return 1
            ;;
    esac
}

# Générer un certificat d'effacement
generate_erasure_certificate() {
    local volume_path="$1"
    local security_level="$2"
    local category="$3"
    local policy="$4"
    local duration="$5"
    local status="$6"
    
    local certificate_file="$CERTIFICATES_DIR/certificat_effacement_$(date +%Y%m%d_%H%M%S).json"
    
    # Obtenir la description de la méthode de sécurité
    local security_method
    case "$security_level" in
        0) security_method="Effacement à remplissage zéro en un passage" ;;
        1) security_method="Effacement à remplissage aléatoire en un passage" ;;
        2) security_method="Effacement sécurisé US DoD à 7 passages" ;;
        3) security_method="Algorithme Gutmann à 35 passages d'effacement sécurisé" ;;
        4) security_method="Algorithme US DoE à 3 passages d'effacement sécurisé" ;;
        *) security_method="Méthode inconnue" ;;
    esac
    
    cat > "$certificate_file" << EOF
{
    "type_certificat": "effacement_securise_donnees",
    "id_certificat": "CERT-$(date +%Y%m%d%H%M%S)-$(uuidgen | cut -d'-' -f1)",
    "details_effacement": {
        "chemin_volume": "$volume_path",
        "niveau_securite": $security_level,
        "methode_securite": "$security_method",
        "categorie_donnees": "$category",
        "politique_effacement": "$policy",
        "duree_secondes": $duration,
        "statut": "$status"
    },
    "informations_systeme": {
        "nom_hote": "$(hostname)",
        "operateur": "$(whoami)",
        "horodatage": "$(date -Iseconds)",
        "version_macos": "$(sw_vers -productVersion)"
    },
    "informations_conformite": {
        "verification_effectuee": true,
        "chaine_de_possession": true,
        "piste_audit": "disponible"
    }
}
EOF
    
    echo "📜 Certificat d'effacement généré : $certificate_file"
    log_action "Certificat d'effacement généré : $certificate_file"
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    case "$command" in
        "effacer_espace_libre")
            # Exécuter l'effacement sécurisé d'espace libre
            execute_secure_erasure "$@"
            ;;
        "decouvrir_volumes")
            # Découvrir et lister les volumes disponibles
            discover_volumes
            ;;
        "verifier_effacement")
            # Vérifier la complétude de l'effacement
            verify_secure_erasure "$@"
            ;;
        "appliquer_politique")
            # Appliquer une politique d'effacement
            apply_erasure_policy "$@"
            ;;
        "generer_certificat")
            # Générer un certificat d'effacement
            generate_erasure_certificate "$@"
            ;;
        "afficher_categories")
            # Afficher les catégories d'effacement
            print_erasure_categories
            ;;
        "afficher_politiques")
            # Afficher les politiques disponibles
            for policy in vie_privee_de_base conforme_gdpr medical_hipaa financier_sox gouvernement_classifie legal_medico_legal; do
                echo "Politique : $policy"
                get_erasure_policy "$policy" | jq .
                echo ""
            done
            ;;
        *)
            echo "Système de Gestion d'Effacement Sécurisé des Données MacFleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  effacer_espace_libre <volume> <niveau> [catégorie] [politique]  - Exécuter effacement sécurisé d'espace libre"
            echo "  decouvrir_volumes                                               - Découvrir volumes disponibles"
            echo "  verifier_effacement <profil> <volume>                          - Vérifier complétude effacement"
            echo "  appliquer_politique <politique>                                - Appliquer politique d'effacement"
            echo "  generer_certificat <volume> <niveau> <catégorie>               - Générer certificat d'effacement"
            echo "  afficher_categories                                            - Afficher catégories de données"
            echo "  afficher_politiques                                            - Afficher politiques d'effacement"
            echo ""
            echo "Niveaux de Sécurité :"
            echo "  0 - Effacement à remplissage zéro en un passage"
            echo "  1 - Effacement à remplissage aléatoire en un passage"
            echo "  2 - Effacement sécurisé US DoD à 7 passages"
            echo "  3 - Algorithme Gutmann à 35 passages d'effacement sécurisé"
            echo "  4 - Algorithme US DoE à 3 passages d'effacement sécurisé"
            echo ""
            echo "Exemples :"
            echo "  $0 effacer_espace_libre \"/Volumes/Data\" 4 donnees_confidentielles conforme_gdpr"
            echo "  $0 decouvrir_volumes"
            echo "  $0 verifier_effacement complet \"/Volumes/Data\""
            echo "  $0 appliquer_politique medical_hipaa"
            ;;
    esac
}

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

Considérations de Sécurité

Sécurité de Désinfection des Données

• Écrasement Multi-Passages - Utiliser des niveaux de sécurité appropriés pour la sensibilité des données
• Procédures de Vérification - Vérifier l'effacement complet et l'impossibilité de récupération des données
• Standards de Conformité - Respecter les exigences réglementaires pour destruction de données
• Chaîne de Possession - Maintenir pistes d'audit et documentation
• Sécurité Physique - Considérer la destruction physique pour les besoins de sécurité les plus élevés

Cadre de Conformité

• Conformité GDPR - Droit à l'effacement et exigences de protection des données
• HIPAA Médical - Destruction de dossiers médicaux avec certification appropriée
• SOX Financier - Effacement de données financières avec exigences d'audit
• Standards Gouvernementaux - FISMA, NIST SP 800-88 pour données classifiées
• Standards Industriels - DoD 5220.22-M, Critères Communs pour effacement sécurisé

Guide de Dépannage

Problèmes Courants

Processus d'Effacement Échoue

• Vérifier que le volume n'est pas en cours d'utilisation : lsof | grep /Volumes/NomVolume
• Vérifier les permissions suffisantes : Exécuter avec sudo si nécessaire
• Vérifier la santé du disque : diskutil verifyVolume /Volumes/NomVolume

Performance d'Effacement Lente

• Les niveaux de sécurité plus élevés (3,4) prennent significativement plus de temps
• Différences de performance SSD vs HDD
• La charge système et les ressources disponibles affectent la vitesse

Commandes de Diagnostic

# Lister tous les volumes
diskutil list

# Vérifier les informations du volume
diskutil info /Volumes/NomVolume

# Vérifier l'espace libre
df -h /Volumes/NomVolume

# Surveiller le progrès d'effacement
sudo fs_usage -w -f diskio diskutil

Notes Importantes

• Sauvegarder les Données Critiques - Toujours sauvegarder les fichiers importants avant effacement
• Exigences de Temps - Les niveaux de sécurité plus élevés nécessitent significativement plus de temps
• Noms de Volumes - Échapper les espaces dans les noms de volumes avec des barres obliques inverses
• Sécurité vs Performance - Équilibrer les besoins de sécurité avec les contraintes de temps
• Vérification - Toujours vérifier la complétude de l'effacement pour la conformité
• Documentation - Maintenir des pistes d'audit et certificats appropriés pour la conformité réglementaire

Gérez des archives de fichiers sécurisées sur vos appareils MacFleet avec des outils de compression et chiffrement de niveau entreprise. Ce tutoriel couvre la création de ZIP protégés par mot de passe, les opérations d'archivage par lots, la conformité sécuritaire et la gestion complète d'archives à l'échelle de la flotte.

Comprendre la Gestion Sécurisée d'Archives

La gestion sécurisée d'archives sur macOS implique la création de fichiers compressés protégés pour le transfert, stockage et conformité des données :

Composants Principaux

• Compression ZIP - Format d'archive standard avec compatibilité étendue
• Protection Mot de Passe - Chiffrement AES pour sécurité d'archive
• Opérations Lot - Création et gestion d'archives en masse
• Vérification Intégrité - Validation d'archive et détection corruption
• Suivi Conformité - Pistes d'audit et rapports sécuritaires

Avantages Entreprise

• Sécurité Données - Transfert et stockage fichiers protégés
• Optimisation Stockage - Archives compressées économisent espace disque
• Exigences Conformité - Archivage sécurisé données pour réglementations
• Gestion Flotte - Opérations d'archive standardisées sur appareils
• Capacités Audit - Suivi complet opérations d'archive

Création Basique ZIP Protégé par Mot de Passe

Création ZIP Simple avec Mot de Passe

#!/bin/bash

# Création basique ZIP protégé par mot de passe
create_basic_password_zip() {
    local file_path="${1:-/Users/Shared/exemple.txt}"
    local zip_name="${2:-archive_securisee.zip}"
    local password="${3:-ChangezMoiMaintenant123!}"
    local content="${4:-Bonjour MacFleet - Archive Sécurisée Créée}"
    
    echo "📦 Création Archive ZIP Protégée par Mot de Passe"
    echo "================================================"
    echo "Fichier : $file_path"
    echo "Archive : $zip_name"
    echo "Contenu : $content"
    echo ""
    
    # Créer le fichier avec contenu
    echo "Création fichier avec contenu..."
    touch "$file_path"
    printf '%s\n' "$content" > "$file_path"
    
    if [[ -f "$file_path" ]]; then
        echo "✅ Fichier créé avec succès : $file_path"
    else
        echo "❌ Échec création fichier : $file_path"
        return 1
    fi
    
    # Naviguer vers répertoire fichier
    local file_dir=$(dirname "$file_path")
    local file_name=$(basename "$file_path")
    
    echo "Navigation vers répertoire : $file_dir"
    cd "$file_dir" || return 1
    
    # Créer ZIP protégé par mot de passe
    echo "Création archive ZIP protégée par mot de passe..."
    if zip -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
        echo "✅ Archive ZIP créée avec succès : $file_dir/$zip_name"
        
        # Vérifier archive
        if [[ -f "$zip_name" ]]; then
            local zip_size=$(du -h "$zip_name" | cut -f1)
            echo "Taille archive : $zip_size"
            echo "Emplacement archive : $file_dir/$zip_name"
        fi
    else
        echo "❌ Échec création archive ZIP"
        return 1
    fi
    
    # Nettoyer fichier original (optionnel)
    echo ""
    read -p "Supprimer fichier original ? (o/n) : " remove_original
    if [[ "$remove_original" =~ ^[Oo]$ ]]; then
        rm "$file_path"
        echo "✅ Fichier original supprimé"
    fi
    
    return 0
}

# Exécuter création ZIP basique
create_basic_password_zip "/Users/Shared/test_macfleet.txt" "macfleet_securise.zip" "MotDePasseSecurise123!" "Archive Entreprise MacFleet"

Convertir Fichier Existant en ZIP Protégé par Mot de Passe

#!/bin/bash

# Convertir fichier existant en ZIP protégé par mot de passe
convert_file_to_secure_zip() {
    local source_file="$1"
    local zip_name="${2:-}"
    local password="${3:-}"
    local compression_level="${4:-6}"
    
    echo "🔄 Conversion Fichier en ZIP Sécurisé"
    echo "===================================="
    echo ""
    
    # Valider fichier d'entrée
    if [[ ! -f "$source_file" ]]; then
        echo "❌ Fichier source non trouvé : $source_file"
        echo "Veuillez fournir un chemin fichier valide"
        return 1
    fi
    
    # Obtenir informations fichier
    local file_dir=$(dirname "$source_file")
    local file_name=$(basename "$source_file")
    local file_ext="${file_name##*.}"
    local file_base="${file_name%.*}"
    
    # Générer nom ZIP si non fourni
    if [[ -z "$zip_name" ]]; then
        zip_name="${file_base}_securise.zip"
    fi
    
    # Générer mot de passe sécurisé si non fourni
    if [[ -z "$password" ]]; then
        password=$(openssl rand -base64 12 | tr -d "=+/" | cut -c1-12)
        echo "🔐 Mot de passe sécurisé généré : $password"
        echo "⚠️ Sauvegardez ce mot de passe - il ne peut être récupéré !"
    fi
    
    echo "Fichier source : $source_file"
    echo "Nom archive : $zip_name"
    echo "Niveau compression : $compression_level (1-9)"
    echo ""
    
    # Obtenir taille fichier avant compression
    local original_size=$(du -h "$source_file" | cut -f1)
    echo "Taille fichier original : $original_size"
    
    # Naviguer vers répertoire fichier
    cd "$file_dir" || return 1
    
    # Créer ZIP sécurisé avec compression spécifiée
    echo "Création archive ZIP sécurisée..."
    if zip -"$compression_level" -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
        echo "✅ ZIP sécurisé créé avec succès"
        
        # Obtenir taille compressée et calculer ratio compression
        local compressed_size=$(du -h "$zip_name" | cut -f1)
        local original_bytes=$(du -b "$source_file" | cut -f1)
        local compressed_bytes=$(du -b "$zip_name" | cut -f1)
        local compression_ratio=$(echo "scale=1; (($original_bytes - $compressed_bytes) * 100) / $original_bytes" | bc 2>/dev/null || echo "N/A")
        
        echo ""
        echo "=== Résumé Archive ==="
        echo "Taille originale : $original_size"
        echo "Taille compressée : $compressed_size"
        echo "Ratio compression : ${compression_ratio}%"
        echo "Emplacement archive : $file_dir/$zip_name"
        echo "Mot de passe : $password"
        
        # Tester intégrité archive
        echo ""
        echo "Test intégrité archive..."
        if unzip -t "$zip_name" >/dev/null 2>&1; then
            echo "✅ Intégrité archive vérifiée"
        else
            echo "⚠️ Vérification intégrité archive échouée"
        fi
        
    else
        echo "❌ Échec création archive ZIP sécurisée"
        return 1
    fi
    
    return 0
}

# Exemple d'utilisation
echo "Exemple : Convertir fichier existant en ZIP sécurisé"
# convert_file_to_secure_zip "/Users/Shared/document.pdf" "document_securise.zip" "MonMotDePasseSecurise123!"

Gestion d'Archives d'Entreprise

Système de Création d'Archives Complet

#!/bin/bash

# Système de gestion d'archives d'entreprise
enterprise_archive_manager() {
    local operation="${1:-create}"
    local source_path="$2"
    local archive_config="${3:-default}"
    local output_dir="${4:-/tmp/macfleet_archives}"
    
    echo "🏢 Gestionnaire d'Archives Entreprise MacFleet"
    echo "=============================================="
    echo "Opération : $operation"
    echo "Source : $source_path"
    echo "Config : $archive_config"
    echo "Sortie : $output_dir"
    echo ""
    
    # Assurer que répertoire sortie existe
    mkdir -p "$output_dir"
    
    # Préréglages configuration
    declare -A archive_configs
    archive_configs[default]="zip:6:AES256"
    archive_configs[haute_securite]="zip:9:AES256"
    archive_configs[rapide]="zip:1:AES128"
    archive_configs[maximum]="zip:9:AES256"
    
    # Analyser configuration
    local config_string="${archive_configs[$archive_config]:-${archive_configs[default]}}"
    IFS=':' read -r format compression encryption <<< "$config_string"
    
    # Générer métadonnées sécurisées
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local hostname=$(hostname)
    local user=$(whoami)
    local archive_id=$(openssl rand -hex 8)
    
    case "$operation" in
        "create")
            create_enterprise_archive "$source_path" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"
            ;;
        "batch")
            batch_archive_creation "$source_path" "$output_dir" "$format" "$compression" "$encryption"
            ;;
        "verify")
            verify_archive_integrity "$source_path"
            ;;
        "extract")
            secure_archive_extraction "$source_path" "$output_dir"
            ;;
        *)
            echo "❌ Opération inconnue : $operation"
            echo "Opérations disponibles : create, batch, verify, extract"
            return 1
            ;;
    esac
}

# Créer archive de niveau entreprise
create_enterprise_archive() {
    local source="$1"
    local output_dir="$2"
    local format="$3"
    local compression="$4"
    local encryption="$5"
    local timestamp="$6"
    local archive_id="$7"
    
    echo "📦 Création Archive Entreprise"
    echo "=============================="
    
    # Valider source
    if [[ ! -e "$source" ]]; then
        echo "❌ Source non trouvée : $source"
        return 1
    fi
    
    # Générer mot de passe sécurisé
    local password=$(openssl rand -base64 16 | tr -d "=+/" | cut -c1-16)
    
    # Déterminer nom archive
    local source_name=$(basename "$source")
    local archive_name="macfleet_${archive_id}_${timestamp}.${format}"
    local archive_path="$output_dir/$archive_name"
    local metadata_file="$output_dir/${archive_name}.metadata.json"
    local password_file="$output_dir/${archive_name}.password"
    
    echo "ID Archive : $archive_id"
    echo "Source : $source"
    echo "Archive : $archive_path"
    echo "Compression : Niveau $compression"
    echo "Chiffrement : $encryption"
    echo ""
    
    # Obtenir informations source
    local source_size=""
    local source_type=""
    local file_count=0
    
    if [[ -f "$source" ]]; then
        source_type="fichier"
        source_size=$(du -h "$source" | cut -f1)
        file_count=1
    elif [[ -d "$source" ]]; then
        source_type="répertoire"
        source_size=$(du -sh "$source" | cut -f1)
        file_count=$(find "$source" -type f | wc -l | xargs)
    fi
    
    echo "Type source : $source_type"
    echo "Taille source : $source_size"
    echo "Nombre fichiers : $file_count"
    echo ""
    
    # Créer archive
    echo "Création archive..."
    local start_time=$(date +%s)
    
    if zip -r -"$compression" "$archive_path" "$source" --password "$password" >/dev/null 2>&1; then
        local end_time=$(date +%s)
        local duration=$((end_time - start_time))
        
        echo "✅ Archive créée avec succès"
        echo "Temps création : ${duration}s"
        
        # Obtenir statistiques archive
        local archive_size=$(du -h "$archive_path" | cut -f1)
        local checksum=$(shasum -a 256 "$archive_path" | cut -d' ' -f1)
        
        # Sauvegarder mot de passe de manière sécurisée
        echo "$password" > "$password_file"
        chmod 600 "$password_file"
        
        # Générer métadonnées
        cat > "$metadata_file" << EOF
{
    "info_archive": {
        "id": "$archive_id",
        "nom": "$archive_name",
        "cree": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
        "nom_hote": "$(hostname)",
        "utilisateur": "$(whoami)",
        "version_macfleet": "2025.07"
    },
    "info_source": {
        "chemin": "$source",
        "type": "$source_type",
        "taille": "$source_size",
        "nombre_fichiers": $file_count
    },
    "details_archive": {
        "format": "$format",
        "niveau_compression": $compression,
        "chiffrement": "$encryption",
        "taille": "$archive_size",
        "checksum_sha256": "$checksum",
        "duree_creation": ${duration}
    },
    "securite": {
        "protege_mot_de_passe": true,
        "fichier_mot_de_passe": "${archive_name}.password",
        "algorithme_chiffrement": "AES-256"
    }
}
EOF
        
        echo ""
        echo "=== Résumé Archive ==="
        echo "Archive : $archive_path"
        echo "Taille : $archive_size"
        echo "Checksum : $checksum"
        echo "Fichier mot de passe : $password_file"
        echo "Métadonnées : $metadata_file"
        
    else
        echo "❌ Échec création archive"
        return 1
    fi
}

# Création archives par lots
batch_archive_creation() {
    local source_dir="$1"
    local output_dir="$2"
    local format="$3"
    local compression="$4"
    local encryption="$5"
    
    echo "📦 Création Archives par Lots"
    echo "============================="
    echo "Répertoire source : $source_dir"
    echo ""
    
    if [[ ! -d "$source_dir" ]]; then
        echo "❌ Répertoire source non trouvé : $source_dir"
        return 1
    fi
    
    local processed=0
    local failed=0
    
    # Traiter chaque élément dans répertoire source
    for item in "$source_dir"/*; do
        if [[ -e "$item" ]]; then
            local item_name=$(basename "$item")
            echo "Traitement : $item_name"
            
            local timestamp=$(date +"%Y%m%d_%H%M%S")
            local archive_id=$(openssl rand -hex 4)
            
            if create_enterprise_archive "$item" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"; then
                echo "✅ Archivage réussi : $item_name"
                ((processed++))
            else
                echo "❌ Échec archivage : $item_name"
                ((failed++))
            fi
            echo ""
        fi
    done
    
    echo "=== Résumé Lot ==="
    echo "Traités : $processed"
    echo "Échoués : $failed"
    echo "Total : $((processed + failed))"
}

# Vérification intégrité archive
verify_archive_integrity() {
    local archive_path="$1"
    
    echo "🔍 Vérification Intégrité Archive"
    echo "================================="
    echo "Archive : $archive_path"
    echo ""
    
    if [[ ! -f "$archive_path" ]]; then
        echo "❌ Archive non trouvée : $archive_path"
        return 1
    fi
    
    # Vérifier si c'est un fichier ZIP
    if ! file "$archive_path" | grep -q "Zip archive"; then
        echo "❌ Pas une archive ZIP valide"
        return 1
    fi
    
    # Tester intégrité archive
    echo "Test intégrité archive..."
    if unzip -t "$archive_path" >/dev/null 2>&1; then
        echo "✅ Intégrité archive vérifiée"
        
        # Obtenir informations archive
        local archive_size=$(du -h "$archive_path" | cut -f1)
        local file_count=$(unzip -l "$archive_path" 2>/dev/null | tail -1 | awk '{print $2}' || echo "Inconnu")
        
        echo ""
        echo "=== Informations Archive ==="
        echo "Taille : $archive_size"
        echo "Fichiers : $file_count"
        echo "Format : ZIP"
        
        # Vérifier métadonnées
        local metadata_file="${archive_path}.metadata.json"
        if [[ -f "$metadata_file" ]]; then
            echo "Métadonnées : Disponibles"
            local creation_date=$(jq -r '.info_archive.cree' "$metadata_file" 2>/dev/null || echo "Inconnue")
            local archive_id=$(jq -r '.info_archive.id' "$metadata_file" 2>/dev/null || echo "Inconnu")
            echo "Créée : $creation_date"
            echo "ID Archive : $archive_id"
        else
            echo "Métadonnées : Non disponibles"
        fi
        
    else
        echo "❌ Vérification intégrité archive échouée"
        echo "Archive peut être corrompue ou protégée par mot de passe"
        return 1
    fi
}

# Exemples d'utilisation
echo "Exemples Gestionnaire d'Archives Entreprise :"
echo "============================================="
echo ""

echo "1. Créer archive entreprise :"
enterprise_archive_manager "create" "/Users/Shared/documents" "haute_securite" "/tmp/archives"
echo ""

echo "2. Création archives par lots :"
enterprise_archive_manager "batch" "/Users/Shared/source_lot" "default" "/tmp/archives_lot"
echo ""

echo "3. Vérifier intégrité archive :"
enterprise_archive_manager "verify" "/tmp/archives/exemple.zip"

Fonctionnalités Sécurité et Conformité

Système d'Archives Sécurité Avancée

#!/bin/bash

# Système d'archives sécurité et conformité avancées
secure_compliance_archiver() {
    local operation="${1:-audit}"
    local archive_path="$2"
    local compliance_level="${3:-standard}"
    
    echo "🔒 Archiveur Conformité Sécurisé"
    echo "================================"
    echo "Opération : $operation"
    echo "Niveau conformité : $compliance_level"
    echo ""
    
    case "$operation" in
        "audit")
            perform_security_audit "$archive_path" "$compliance_level"
            ;;
        "encrypt")
            apply_advanced_encryption "$archive_path" "$compliance_level"
            ;;
        "validate")
            validate_compliance_requirements "$archive_path" "$compliance_level"
            ;;
        "report")
            generate_compliance_report "$compliance_level"
            ;;
        *)
            echo "❌ Opération inconnue : $operation"
            echo "Opérations disponibles : audit, encrypt, validate, report"
            return 1
            ;;
    esac
}

# Audit sécurité pour archives
perform_security_audit() {
    local archive_path="$1"
    local compliance_level="$2"
    
    echo "🔍 Audit Sécurité"
    echo "=================="
    echo ""
    
    local audit_passed=0
    local audit_warnings=0
    local audit_failures=0
    
    # Vérifier permissions fichier
    if [[ -f "$archive_path" ]]; then
        local permissions=$(stat -f "%A" "$archive_path" 2>/dev/null || echo "inconnues")
        echo "Permissions fichier : $permissions"
        
        if [[ "$permissions" =~ ^[67][0-4][0-4]$ ]]; then
            echo "✅ Permissions sont sécurisées"
            ((audit_passed++))
        else
            echo "⚠️ Permissions peuvent être trop permissives"
            ((audit_warnings++))
        fi
    fi
    
    # Vérifier statut chiffrement
    if file "$archive_path" | grep -q "password-protected\|encrypted"; then
        echo "✅ Archive est protégée par mot de passe"
        ((audit_passed++))
    else
        echo "❌ Archive n'est pas protégée par mot de passe"
        ((audit_failures++))
    fi
    
    # Vérifier intégrité métadonnées
    local metadata_file="${archive_path}.metadata.json"
    if [[ -f "$metadata_file" ]]; then
        echo "✅ Fichier métadonnées présent"
        ((audit_passed++))
        
        # Valider JSON
        if jq empty "$metadata_file" 2>/dev/null; then
            echo "✅ Format métadonnées valide"
            ((audit_passed++))
        else
            echo "❌ Format métadonnées invalide"
            ((audit_failures++))
        fi
    else
        echo "⚠️ Fichier métadonnées manquant"
        ((audit_warnings++))
    fi
    
    # Vérifications spécifiques à la conformité
    case "$compliance_level" in
        "haute"|"entreprise")
            # Vérifier fichier mot de passe sécurisé
            local password_file="${archive_path}.password"
            if [[ -f "$password_file" ]]; then
                local pass_permissions=$(stat -f "%A" "$password_file" 2>/dev/null || echo "inconnues")
                if [[ "$pass_permissions" == "600" ]]; then
                    echo "✅ Permissions fichier mot de passe sécurisées"
                    ((audit_passed++))
                else
                    echo "❌ Permissions fichier mot de passe non sécurisées"
                    ((audit_failures++))
                fi
            fi
            ;;
    esac
    
    # Générer résumé audit
    echo ""
    echo "=== Résumé Audit Sécurité ==="
    echo "Réussis : $audit_passed"
    echo "Avertissements : $audit_warnings"
    echo "Échecs : $audit_failures"
    
    local total_checks=$((audit_passed + audit_warnings + audit_failures))
    if [[ "$audit_failures" -eq 0 ]]; then
        echo "🎉 Audit sécurité RÉUSSI"
        return 0
    else
        echo "❌ Audit sécurité ÉCHOUÉ"
        return 1
    fi
}

# Générer rapport conformité
generate_compliance_report() {
    local compliance_level="$1"
    local report_file="/tmp/macfleet_archive_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    echo "📊 Génération Rapport Conformité"
    echo "================================="
    echo ""
    
    # Scanner toutes archives MacFleet
    local archive_dirs=("/tmp/macfleet_archives" "/tmp/archives" "/tmp/archives_lot")
    local total_archives=0
    local compliant_archives=0
    local non_compliant_archives=0
    
    {
        echo "{"
        echo "  \"rapport_conformite\": {"
        echo "    \"genere\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\","
        echo "    \"nom_hote\": \"$(hostname)\","
        echo "    \"niveau_conformite\": \"$compliance_level\","
        echo "    \"archives\": ["
        
        local first_archive=true
        
        for dir in "${archive_dirs[@]}"; do
            if [[ -d "$dir" ]]; then
                for archive in "$dir"/*.zip; do
                    if [[ -f "$archive" ]]; then
                        if [[ "$first_archive" == "false" ]]; then
                            echo ","
                        fi
                        
                        local archive_name=$(basename "$archive")
                        local archive_size=$(du -h "$archive" | cut -f1)
                        local is_compliant="false"
                        
                        # Vérifier conformité
                        if perform_security_audit "$archive" "$compliance_level" >/dev/null 2>&1; then
                            is_compliant="true"
                            ((compliant_archives++))
                        else
                            ((non_compliant_archives++))
                        fi
                        
                        echo "      {"
                        echo "        \"nom\": \"$archive_name\","
                        echo "        \"chemin\": \"$archive\","
                        echo "        \"taille\": \"$archive_size\","
                        echo "        \"conforme\": $is_compliant"
                        echo -n "      }"
                        
                        first_archive=false
                        ((total_archives++))
                    fi
                done
            fi
        done
        
        echo ""
        echo "    ],"
        echo "    \"resume\": {"
        echo "      \"total_archives\": $total_archives,"
        echo "      \"conformes\": $compliant_archives,"
        echo "      \"non_conformes\": $non_compliant_archives,"
        echo "      \"taux_conformite\": \"$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")%\""
        echo "    }"
        echo "  }"
        echo "}"
    } > "$report_file"
    
    echo "✅ Rapport conformité généré : $report_file"
    echo ""
    echo "=== Résumé ==="
    echo "Total archives : $total_archives"
    echo "Conformes : $compliant_archives"
    echo "Non conformes : $non_compliant_archives"
    
    if [[ "$total_archives" -gt 0 ]]; then
        local compliance_rate=$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")
        echo "Taux conformité : ${compliance_rate}%"
    fi
}

# Exécuter opérations conformité
echo "Exemples Sécurité et Conformité :"
echo "================================="
echo ""

echo "1. Générer rapport conformité :"
secure_compliance_archiver "report" "" "entreprise"

Notes Importantes

Fonctionnalités Entreprise

• Sécurité Avancée - Chiffrement AES-256 avec génération mot de passe sécurisé
• Gestion Métadonnées - Suivi et documentation archives complets
• Opérations Lot - Création et gestion archives en masse
• Vérification Intégrité - Validation archive et détection corruption
• Rapports Conformité - Audit sécurité et suivi conformité
• Déploiement Flotte - Opérations archives standardisées sur appareils

Meilleures Pratiques Sécurité

• Mots de Passe Forts - Génération mots de passe cryptographiquement sécurisés
• Stockage Sécurisé - Fichiers mots de passe protégés avec permissions restreintes
• Standards Chiffrement - Chiffrement AES-256 pour sécurité maximale
• Pistes Audit - Journalisation et suivi opérations complets
• Contrôles Accès - Permissions fichiers et mesures sécurité appropriées

Opérations Supportées

• Créer - Création archive fichier unique ou répertoire
• Lot - Création archives multiples depuis contenu répertoire
• Vérifier - Test et validation intégrité archive
• Extraire - Extraction archive sécurisée avec vérification
• Audit - Vérification conformité sécurité et rapports

Exemples d'Utilisation

# ZIP basique protégé par mot de passe
touch /Users/Shared/fichier.txt
printf 'Bonjour monde\n' > /Users/Shared/fichier.txt
cd /Users/Shared
zip -r fichier.zip fichier.txt --password 1234

# Archive entreprise MacFleet améliorée
create_basic_password_zip "/Users/Shared/document.pdf" "doc_securise.zip" "MotDePasseSecurise123!"

# Archive entreprise avec métadonnées
enterprise_archive_manager "create" "/Users/Shared/projets" "haute_securite" "/tmp/archives"

# Création archives par lots
enterprise_archive_manager "batch" "/Users/Shared/documents" "default" "/tmp/archives_lot"

# Audit sécurité
secure_compliance_archiver "audit" "/tmp/archives/exemple.zip" "entreprise"