Guide

Nouvelles mises à jour et améliorations de Macfleet.

Avis important

Les exemples de code et scripts fournis dans ces tutoriels sont uniquement à des fins éducatives. Macfleet n'est pas responsable des problèmes, dommages ou vulnérabilités de sécurité qui pourraient survenir lors de l'utilisation, modification ou implémentation de ces exemples. Toujours vérifier et tester le code dans un environnement sécurisé avant de l'utiliser dans des systèmes de production.

← Tous les articles

7 juillet 2025

Gestion d'Entreprise de l'Historique de Connexion sur macOS

Surveillez et analysez l'activité de connexion des utilisateurs sur vos appareils MacFleet en utilisant des outils en ligne de commande avancés. Ce tutoriel couvre le suivi de l'historique de connexion, l'analyse des sessions utilisateur, l'audit de sécurité, et la surveillance de conformité de niveau entreprise avec des capacités de rapport complètes.

Comprendre la Gestion de l'Historique de Connexion macOS

macOS fournit plusieurs outils puissants pour traquer l'activité de connexion des utilisateurs :

who - Affiche les utilisateurs actuellement connectés et un bref historique de connexion
last - Affiche l'historique de connexion détaillé avec les informations de session
dscl - Utilitaire en ligne de commande des Services d'Annuaire pour la gestion des utilisateurs
w - Informations étendues d'activité utilisateur avec la charge système
finger - Informations utilisateur et détails de connexion (si disponible)

Ces outils accèdent aux journaux système et aux bases de données utilisateur pour fournir des capacités de suivi de connexion complètes.

Commandes de Base de l'Historique de Connexion

Historique de Connexion Bref avec `who`

#!/bin/bash

# Afficher l'historique de connexion bref
get_brief_login_history() {
    echo "=== Historique de Connexion Bref ==="
    who
    echo ""
    
    # Alternative avec horodatages
    echo "=== Sessions Utilisateur Actuelles ==="
    who -u
}

# Exécuter la vérification de connexion de base
get_brief_login_history

Historique de Connexion Détaillé avec `last`

#!/bin/bash

# Afficher l'historique de connexion détaillé
get_detailed_login_history() {
    echo "=== Historique de Connexion Détaillé ==="
    last
    echo ""
    
    # Afficher les 10 dernières entrées de connexion
    echo "=== 10 Dernières Sessions de Connexion ==="
    last -10
    echo ""
    
    # Afficher l'historique de connexion d'aujourd'hui
    echo "=== Sessions de Connexion d'Aujourd'hui ==="
    last -t "$(date '+%Y%m%d%H%M%S')"
}

# Exécuter la vérification de connexion détaillée
get_detailed_login_history

Vérifier l'Historique de Connexion d'un Utilisateur Spécifique

#!/bin/bash

# Obtenir l'heure de dernière connexion pour un utilisateur spécifique
check_user_login() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "Usage : check_user_login <nom_utilisateur>"
        return 1
    fi
    
    echo "=== Dernière Connexion pour l'Utilisateur : $username ==="
    last -1 "$username"
    echo ""
    
    # Informations utilisateur supplémentaires
    echo "=== Informations du Compte Utilisateur ==="
    dscl . -read "/Users/$username" RealName 2>/dev/null || echo "Utilisateur non trouvé"
    dscl . -read "/Users/$username" UniqueID 2>/dev/null || echo "UID non disponible"
}

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

Analyse Avancée de l'Historique de Connexion

Analyse Complète des Sessions Utilisateur

#!/bin/bash

# Analyse avancée de l'historique de connexion avec insights de sécurité
analyze_login_patterns() {
    echo "=== Analyse Complète de Connexion ==="
    echo "Généré : $(date)"
    echo "Nom d'hôte : $(hostname)"
    echo "=================================="
    echo ""
    
    # Sessions actives actuelles
    echo "1. SESSIONS UTILISATEUR ACTIVES :"
    echo "--------------------------------"
    who -u | while IFS= read -r line; do
        echo "  $line"
    done
    echo ""
    
    # Activité de connexion récente (dernières 24 heures)
    echo "2. ACTIVITÉ DE CONNEXION RÉCENTE (24 heures) :"
    echo "----------------------------------------------"
    local yesterday
    yesterday=$(date -v-1d '+%Y%m%d%H%M%S' 2>/dev/null || date -d 'yesterday' '+%Y%m%d%H%M%S' 2>/dev/null)
    
    if [[ -n "$yesterday" ]]; then
        last -t "$yesterday" | head -20
    else
        last -20
    fi
    echo ""
    
    # Tentatives de connexion échouées (si disponible dans les journaux)
    echo "3. TENTATIVES DE CONNEXION ÉCHOUÉES :"
    echo "------------------------------------"
    grep "authentication failure" /var/log/system.log 2>/dev/null | tail -10 || echo "Aucun échec récent trouvé"
    echo ""
    
    # Analyse de fréquence de connexion
    echo "4. FRÉQUENCE DE CONNEXION PAR UTILISATEUR :"
    echo "------------------------------------------"
    last | grep -v "wtmp begins" | awk '{print $1}' | sort | uniq -c | sort -nr | head -10
    echo ""
    
    # Analyse des connexions distantes vs locales
    echo "5. ANALYSE SOURCE DE CONNEXION :"
    echo "-------------------------------"
    echo "Connexions console :"
    last | grep -c "console" || echo "0"
    echo "Connexions distantes :"
    last | grep -v "console" | grep -v "wtmp begins" | wc -l | tr -d ' '
}

# Exécuter l'analyse complète
analyze_login_patterns

Découverte des Comptes Utilisateur

#!/bin/bash

# Lister tous les utilisateurs et leur statut de connexion
discover_users() {
    echo "=== Découverte des Comptes Utilisateur ==="
    echo ""
    
    # Tous les utilisateurs des services d'annuaire
    echo "1. TOUS LES UTILISATEURS SYSTÈME :"
    echo "---------------------------------"
    dscl . list /Users | grep -v "^_" | grep -v "^root" | grep -v "^daemon" | grep -v "^nobody"
    echo ""
    
    # Utilisateurs avec UID >= 500 (typiquement utilisateurs réguliers)
    echo "2. COMPTES UTILISATEUR RÉGULIERS :"
    echo "---------------------------------"
    dscl . list /Users UniqueID | awk '$2 >= 500 {print $1, "(UID: " $2 ")"}'
    echo ""
    
    # Utilisateurs avec activité de connexion récente
    echo "3. UTILISATEURS AVEC ACTIVITÉ DE CONNEXION RÉCENTE :"
    echo "---------------------------------------------------"
    last | awk '{print $1}' | sort | uniq | grep -v "wtmp" | grep -v "^$" | head -10
    echo ""
    
    # Répertoires personnels
    echo "4. RÉPERTOIRES PERSONNELS UTILISATEUR :"
    echo "---------------------------------------"
    ls -la /Users/ | grep -v "^total" | grep -v "Shared" | awk '{print $9, $3, $4}' | grep -v "^$"
}

# Exécuter la découverte des utilisateurs
discover_users

Système de Gestion de l'Historique de Connexion d'Entreprise

#!/bin/bash

# Système de Gestion de l'Historique de Connexion d'Entreprise MacFleet
# Surveillance complète de l'activité utilisateur et audit de sécurité

# Configuration
LOG_FILE="/var/log/macfleet_login_history.log"
REPORT_DIR="/var/reports/macfleet/login_history"
CONFIG_FILE="/etc/macfleet/login_monitoring.conf"
ALERT_THRESHOLD_FAILED_LOGINS=5
ALERT_THRESHOLD_UNUSUAL_HOURS=22  # Alerte pour connexions après 22h

# Créer la structure des répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$REPORT_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
}

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

# Générer un rapport de connexion complet
generate_login_report() {
    local report_file="$REPORT_DIR/login_report_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Génération du rapport d'historique de connexion complet : $report_file"
    
    {
        echo "{"
        echo "  \"report_type\": \"login_history\","
        echo "  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","
        echo "  \"hostname\": \"$(hostname)\","
        echo "  \"system_info\": {"
        echo "    \"macos_version\": \"$(sw_vers -productVersion)\","
        echo "    \"uptime\": \"$(uptime | awk -F'up ' '{print $2}' | awk -F', ' '{print $1}')\","
        echo "    \"current_users\": $(who | wc -l | tr -d ' ')"
        echo "  },"
        
        # Sessions actives
        echo "  \"active_sessions\": ["
        local first_session=true
        who -u | while IFS= read -r line; do
            if [[ "$first_session" == "false" ]]; then
                echo ","
            fi
            first_session=false
            
            local user terminal login_time pid
            user=$(echo "$line" | awk '{print $1}')
            terminal=$(echo "$line" | awk '{print $2}')
            login_time=$(echo "$line" | awk '{print $3, $4}')
            pid=$(echo "$line" | awk '{print $6}')
            
            echo "    {"
            echo "      \"user\": \"$user\","
            echo "      \"terminal\": \"$terminal\","
            echo "      \"login_time\": \"$login_time\","
            echo "      \"pid\": \"$pid\""
            echo -n "    }"
        done
        echo ""
        echo "  ],"
        
        # Historique de connexion récent
        echo "  \"recent_logins\": ["
        local first_login=true
        last -20 | grep -v "wtmp begins" | while IFS= read -r line; do
            if [[ -n "$line" ]]; then
                if [[ "$first_login" == "false" ]]; then
                    echo ","
                fi
                first_login=false
                
                local user terminal source login_date login_time logout_info
                user=$(echo "$line" | awk '{print $1}')
                terminal=$(echo "$line" | awk '{print $2}')
                source=$(echo "$line" | awk '{print $3}')
                login_date=$(echo "$line" | awk '{print $4, $5, $6}')
                login_time=$(echo "$line" | awk '{print $7}')
                logout_info=$(echo "$line" | awk '{print $9, $10}')
                
                echo "    {"
                echo "      \"user\": \"$user\","
                echo "      \"terminal\": \"$terminal\","
                echo "      \"source\": \"$source\","
                echo "      \"login_date\": \"$login_date\","
                echo "      \"login_time\": \"$login_time\","
                echo "      \"logout_info\": \"$logout_info\""
                echo -n "    }"
            fi
        done
        echo ""
        echo "  ],"
        
        # Statistiques utilisateur
        echo "  \"user_statistics\": {"
        local total_users
        total_users=$(dscl . list /Users | grep -v "^_" | wc -l | tr -d ' ')
        echo "    \"total_system_users\": $total_users,"
        
        local regular_users
        regular_users=$(dscl . list /Users UniqueID | awk '$2 >= 500' | wc -l | tr -d ' ')
        echo "    \"regular_users\": $regular_users,"
        
        local active_login_users
        active_login_users=$(last | awk '{print $1}' | sort | uniq | grep -v "wtmp" | grep -v "^$" | wc -l | tr -d ' ')
        echo "    \"users_with_login_history\": $active_login_users"
        echo "  }"
        echo "}"
    } > "$report_file"
    
    log_action "Rapport d'historique de connexion généré avec succès"
    echo "$report_file"
}

# Surveiller l'activité de connexion suspecte
monitor_suspicious_activity() {
    log_action "Démarrage de la surveillance d'activité de connexion suspecte..."
    
    local alerts=()
    
    # Vérifier les heures de connexion inhabituelles (configurable)
    local current_hour
    current_hour=$(date +%H)
    
    if [[ "$current_hour" -ge "$ALERT_THRESHOLD_UNUSUAL_HOURS" ]]; then
        local late_logins
        late_logins=$(who | wc -l | tr -d ' ')
        
        if [[ "$late_logins" -gt 0 ]]; then
            alerts+=("Activité de connexion nocturne détectée : $late_logins sessions actives après $ALERT_THRESHOLD_UNUSUAL_HOURS:00")
        fi
    fi
    
    # Vérifier les tentatives de connexion échouées multiples
    local failed_logins
    failed_logins=$(grep "authentication failure" /var/log/system.log 2>/dev/null | grep "$(date '+%b %d')" | wc -l | tr -d ' ')
    
    if [[ "$failed_logins" -ge "$ALERT_THRESHOLD_FAILED_LOGINS" ]]; then
        alerts+=("Nombre élevé de tentatives de connexion échouées aujourd'hui : $failed_logins échecs")
    fi
    
    # Vérifier les connexions root
    local root_logins
    root_logins=$(last | grep "^root " | head -5 | wc -l | tr -d ' ')
    
    if [[ "$root_logins" -gt 0 ]]; then
        alerts+=("Activité de connexion root récente détectée : $root_logins sessions")
    fi
    
    # Vérifier les connexions simultanées du même utilisateur
    local duplicate_users
    duplicate_users=$(who | awk '{print $1}' | sort | uniq -d)
    
    if [[ -n "$duplicate_users" ]]; then
        alerts+=("Sessions simultanées multiples détectées pour les utilisateurs : $duplicate_users")
    fi
    
    # Rapporter les alertes
    if [[ ${#alerts[@]} -eq 0 ]]; then
        log_action "✅ Aucune activité de connexion suspecte détectée"
        return 0
    else
        log_action "⚠️  Alertes d'activité de connexion suspecte :"
        for alert in "${alerts[@]}"; do
            log_action "  - $alert"
        done
        return 1
    fi
}

# Analyser les modèles de connexion pour insights de sécurité
analyze_security_patterns() {
    log_action "Analyse des modèles de connexion pour insights de sécurité..."
    
    echo "=== Analyse des Modèles de Sécurité ==="
    echo ""
    
    # Fréquence de connexion par jour de la semaine
    echo "1. FRÉQUENCE DE CONNEXION PAR JOUR :"
    echo "-----------------------------------"
    last | grep -v "wtmp begins" | awk '{print $4}' | sort | uniq -c | sort -nr
    echo ""
    
    # Utilisateurs les plus actifs
    echo "2. UTILISATEURS LES PLUS ACTIFS :"
    echo "--------------------------------"
    last | grep -v "wtmp begins" | awk '{print $1}' | sort | uniq -c | sort -nr | head -10
    echo ""
    
    # Analyse des sources de connexion
    echo "3. SOURCES DE CONNEXION :"
    echo "------------------------"
    echo "Connexions console : $(last | grep -c "console")"
    echo "Connexions distantes : $(last | grep -v "console" | grep -v "wtmp begins" | wc -l | tr -d ' ')"
    echo ""
    
    # Analyse de durée de session
    echo "4. MODÈLES DE SESSION :"
    echo "----------------------"
    local avg_sessions
    avg_sessions=$(last | grep -v "wtmp begins" | grep -v "still logged in" | wc -l | tr -d ' ')
    echo "Total sessions terminées : $avg_sessions"
    
    local active_sessions
    active_sessions=$(who | wc -l | tr -d ' ')
    echo "Sessions actuellement actives : $active_sessions"
    echo ""
    
    # Analyse basée sur l'heure
    echo "5. MODÈLES D'HEURE DE CONNEXION :"
    echo "--------------------------------"
    echo "Heures de bureau (9-17) : $(last | awk '{print $7}' | grep -E '^(09|1[0-7]):' | wc -l | tr -d ' ')"
    echo "Après les heures (18-08) : $(last | awk '{print $7}' | grep -E '^(1[8-9]|2[0-3]|0[0-8]):' | wc -l | tr -d ' ')"
}

# Audit d'accès utilisateur
perform_user_audit() {
    local audit_file="$REPORT_DIR/user_audit_$(date +%Y%m%d_%H%M%S).txt"
    
    log_action "Exécution d'un audit d'accès utilisateur complet : $audit_file"
    
    {
        echo "Rapport d'Audit d'Accès Utilisateur MacFleet"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "============================================="
        echo ""
        
        echo "APERÇU SYSTÈME :"
        echo "----------------"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "Build : $(sw_vers -buildVersion)"
        echo "Temps de fonctionnement système : $(uptime | awk -F'up ' '{print $2}' | awk -F', ' '{print $1}')"
        echo "Date/Heure actuelle : $(date)"
        echo ""
        
        echo "RÉSUMÉ COMPTES UTILISATEUR :"
        echo "---------------------------"
        echo "Total utilisateurs système : $(dscl . list /Users | wc -l | tr -d ' ')"
        echo "Utilisateurs réguliers (UID >= 500) : $(dscl . list /Users UniqueID | awk '$2 >= 500' | wc -l | tr -d ' ')"
        echo "Actuellement connectés : $(who | wc -l | tr -d ' ')"
        echo ""
        
        echo "INFORMATIONS UTILISATEUR DÉTAILLÉES :"
        echo "------------------------------------"
        dscl . list /Users UniqueID | awk '$2 >= 500' | while read -r username uid; do
            echo "Utilisateur : $username (UID : $uid)"
            
            # Nom réel
            local real_name
            real_name=$(dscl . -read "/Users/$username" RealName 2>/dev/null | grep "RealName:" | cut -d' ' -f2-)
            echo "  Nom réel : ${real_name:-"Non défini"}"
            
            # Répertoire personnel
            local home_dir
            home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | grep "NFSHomeDirectory:" | cut -d' ' -f2)
            echo "  Répertoire personnel : ${home_dir:-"Non défini"}"
            
            # Dernière connexion
            local last_login
            last_login=$(last -1 "$username" 2>/dev/null | head -1 | awk '{print $4, $5, $6, $7}')
            echo "  Dernière connexion : ${last_login:-"Jamais"}"
            
            # Statut du compte
            local account_disabled
            account_disabled=$(dscl . -read "/Users/$username" AuthenticationAuthority 2>/dev/null | grep -c "DisabledUser" || echo "0")
            if [[ "$account_disabled" -gt 0 ]]; then
                echo "  Statut : DÉSACTIVÉ"
            else
                echo "  Statut : Actif"
            fi
            
            echo ""
        done
        
        echo "ACTIVITÉ DE CONNEXION RÉCENTE :"
        echo "------------------------------"
        last -50
        
        echo ""
        echo "RECOMMANDATIONS DE SÉCURITÉ :"
        echo "----------------------------"
        
        # Vérifier les utilisateurs sans activité de connexion récente
        local inactive_users
        inactive_users=$(dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}' | while read -r user; do
            if ! last "$user" | grep -q "$(date '+%b')" 2>/dev/null; then
                echo "$user"
            fi
        done)
        
        if [[ -n "$inactive_users" ]]; then
            echo "• Considérer la révision des comptes utilisateur inactifs :"
            echo "$inactive_users" | while read -r user; do
                echo "  - $user"
            done
        else
            echo "• Tous les utilisateurs ont une activité de connexion récente"
        fi
        
        # Vérifier les utilisateurs admin
        local admin_users
        admin_users=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | cut -d' ' -f2-)
        if [[ -n "$admin_users" ]]; then
            echo "• Réviser régulièrement l'accès utilisateur admin :"
            for admin in $admin_users; do
                echo "  - $admin"
            done
        fi
        
    } > "$audit_file"
    
    log_action "Audit d'accès utilisateur terminé avec succès"
    echo "$audit_file"
}

# Exporter les données de connexion pour analyse externe
export_login_data() {
    local export_format="${1:-json}"  # json, csv, xml
    local export_file="$REPORT_DIR/login_export_$(date +%Y%m%d_%H%M%S).$export_format"
    
    log_action "Exportation des données de connexion au format $export_format : $export_file"
    
    case "$export_format" in
        "csv")
            {
                echo "Utilisateur,Terminal,Source,DateConnexion,HeureConnexion,InfoDeconnexion,Duree"
                last -100 | grep -v "wtmp begins" | while IFS= read -r line; do
                    if [[ -n "$line" ]]; then
                        echo "$line" | awk -F' ' '{
                            user=$1; terminal=$2; source=$3; 
                            login_date=$4" "$5" "$6; login_time=$7; 
                            logout_info=$9" "$10; duration=$8;
                            print user","terminal","source","login_date","login_time","logout_info","duration
                        }'
                    fi
                done
            } > "$export_file"
            ;;
        "json")
            generate_login_report > /dev/null
            cp "$REPORT_DIR"/login_report_*.json "$export_file" 2>/dev/null || echo "{\"error\": \"Aucun rapport récent trouvé\"}" > "$export_file"
            ;;
        "xml")
            {
                echo '<?xml version="1.0" encoding="UTF-8"?>'
                echo '<login_history>'
                echo "  <generated>$(date -u +%Y-%m-%dT%H:%M:%SZ)</generated>"
                echo "  <hostname>$(hostname)</hostname>"
                echo "  <sessions>"
                
                last -50 | grep -v "wtmp begins" | while IFS= read -r line; do
                    if [[ -n "$line" ]]; then
                        local user terminal source login_date login_time
                        user=$(echo "$line" | awk '{print $1}')
                        terminal=$(echo "$line" | awk '{print $2}')
                        source=$(echo "$line" | awk '{print $3}')
                        login_date=$(echo "$line" | awk '{print $4, $5, $6}')
                        login_time=$(echo "$line" | awk '{print $7}')
                        
                        echo "    <session>"
                        echo "      <user>$user</user>"
                        echo "      <terminal>$terminal</terminal>"
                        echo "      <source>$source</source>"
                        echo "      <login_date>$login_date</login_date>"
                        echo "      <login_time>$login_time</login_time>"
                        echo "    </session>"
                    fi
                done
                
                echo "  </sessions>"
                echo '</login_history>'
            } > "$export_file"
            ;;
        *)
            log_action "ERREUR : Format d'exportation non supporté : $export_format"
            return 1
            ;;
    esac
    
    log_action "Données de connexion exportées avec succès"
    echo "$export_file"
}

# Fonction de gestion principale
main() {
    local action="${1:-report}"
    local parameter="$2"
    
    setup_directories
    log_action "Gestion Historique de Connexion MacFleet démarrée avec l'action : $action"
    
    case "$action" in
        "brief")
            who
            ;;
        "detailed")
            last
            ;;
        "user")
            if [[ -n "$parameter" ]]; then
                last -1 "$parameter"
            else
                echo "Usage : $0 user <nom_utilisateur>"
                exit 1
            fi
            ;;
        "users")
            dscl . list /Users | grep -v "^_"
            ;;
        "analyze")
            analyze_security_patterns
            ;;
        "monitor")
            monitor_suspicious_activity
            ;;
        "audit")
            perform_user_audit
            ;;
        "export")
            export_login_data "$parameter"
            ;;
        "report"|*)
            generate_login_report
            ;;
    esac
    
    log_action "Gestion Historique de Connexion MacFleet terminée avec l'action : $action"
}

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

Fonctions de Gestion Rapide

Vérification Simple du Statut de Connexion

#!/bin/bash

# Statut de connexion rapide avec sortie améliorée
quick_login_status() {
    echo "📊 Statut de Connexion MacFleet - $(date)"
    echo "=========================================="
    
    # Utilisateurs actuels
    local current_users
    current_users=$(who | wc -l | tr -d ' ')
    echo "👥 Actuellement connectés : $current_users utilisateurs"
    
    if [[ "$current_users" -gt 0 ]]; then
        echo ""
        echo "Sessions Actives :"
        who | while IFS= read -r line; do
            echo "  🔹 $line"
        done
    fi
    
    echo ""
    echo "📈 Activité Récente :"
    echo "  - Dernières 24 heures : $(last -t "$(date -v-1d '+%Y%m%d%H%M%S' 2>/dev/null || date -d 'yesterday' '+%Y%m%d%H%M%S')" | wc -l | tr -d ' ') connexions"
    echo "  - Cette semaine : $(last | grep "$(date '+%b')" | wc -l | tr -d ' ') connexions"
    
    # Temps de fonctionnement système
    echo "  - Temps de fonctionnement système : $(uptime | awk -F'up ' '{print $2}' | awk -F', ' '{print $1}')"
}

quick_login_status

Résumé de Connexion Utilisateur

#!/bin/bash

# Générer un résumé de connexion utilisateur
user_login_summary() {
    echo "🔍 Résumé de Connexion Utilisateur"
    echo "=================================="
    echo ""
    
    echo "Top 10 Utilisateurs les Plus Actifs :"
    echo "-------------------------------------"
    last | grep -v "wtmp begins" | awk '{print $1}' | sort | uniq -c | sort -nr | head -10 | while read -r count user; do
        echo "  $user : $count connexions"
    done
    
    echo ""
    echo "Activité Utilisateur Récente :"
    echo "-----------------------------"
    dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}' | head -10 | while read -r username; do
        local last_login
        last_login=$(last -1 "$username" 2>/dev/null | head -1 | awk '{print $4, $5, $7}' | tr -s ' ')
        echo "  $username : ${last_login:-"Aucune activité récente"}"
    done
}

user_login_summary

Fonctions de Surveillance de Sécurité

Détection de Connexions Échouées

#!/bin/bash

# Surveiller et rapporter les tentatives de connexion échouées
monitor_failed_logins() {
    echo "🔒 Surveillance des Connexions Échouées"
    echo "======================================="
    echo ""
    
    # Vérifier le journal système pour les échecs d'authentification
    echo "Tentatives de Connexion Échouées Récentes :"
    echo "------------------------------------------"
    
    # Dernières 24 heures de tentatives échouées
    grep "authentication failure" /var/log/system.log 2>/dev/null | grep "$(date '+%b %d')" | while IFS= read -r line; do
        echo "  ⚠️  $line"
    done || echo "  ✅ Aucune tentative de connexion échouée trouvée aujourd'hui"
    
    echo ""
    echo "Résumé des Connexions Échouées :"
    echo "-------------------------------"
    
    # Compter les échecs par utilisateur (si disponible)
    local failure_count
    failure_count=$(grep "authentication failure" /var/log/system.log 2>/dev/null | grep "$(date '+%b %d')" | wc -l | tr -d ' ')
    echo "  Total d'échecs aujourd'hui : $failure_count"
    
    # Recommandations
    if [[ "$failure_count" -gt 5 ]]; then
        echo ""
        echo "🚨 Alerte de Sécurité : Nombre élevé de connexions échouées détecté !"
        echo "  - Réviser les comptes utilisateur pour d'éventuelles attaques par force brute"
        echo "  - Considérer l'implémentation de politiques de verrouillage de compte"
        echo "  - Vérifier les adresses IP suspectes dans les journaux"
    fi
}

monitor_failed_logins

Analyse de Durée de Session

#!/bin/bash

# Analyser les durées de session utilisateur
analyze_session_duration() {
    echo "⏱️  Analyse de Durée de Session"
    echo "==============================="
    echo ""
    
    echo "Statistiques de Session :"
    echo "------------------------"
    
    # Sessions actives
    local active_count
    active_count=$(who | wc -l | tr -d ' ')
    echo "  Sessions actives : $active_count"
    
    # Analyse des sessions terminées
    echo "  Sessions terminées récentes :"
    last | grep -v "still logged in" | grep -v "wtmp begins" | head -10 | while IFS= read -r line; do
        local duration
        duration=$(echo "$line" | awk '{print $10}' | tr -d '()')
        if [[ -n "$duration" ]]; then
            echo "    Durée : $duration"
        fi
    done
    
    echo ""
    echo "Sessions de Longue Durée (Actives) :"
    echo "-----------------------------------"
    who -u | while IFS= read -r line; do
        local login_time pid idle
        login_time=$(echo "$line" | awk '{print $3, $4}')
        pid=$(echo "$line" | awk '{print $6}')
        idle=$(echo "$line" | awk '{print $5}')
        
        if [[ "$idle" != "." ]]; then
            echo "  Session démarrée : $login_time (Inactif : $idle)"
        else
            echo "  Session démarrée : $login_time (Actif)"
        fi
    done
}

analyze_session_duration

Configuration et Conformité

Configuration de Politique de Connexion

# /etc/macfleet/login_monitoring.conf
# Configuration de Surveillance d'Historique de Connexion MacFleet

# Seuils d'alerte
ALERT_THRESHOLD_FAILED_LOGINS=5
ALERT_THRESHOLD_UNUSUAL_HOURS=22
ALERT_THRESHOLD_SIMULTANEOUS_SESSIONS=3

# Paramètres de surveillance
MONITOR_INTERVAL_MINUTES=15
LOG_RETENTION_DAYS=90
REPORT_GENERATION_SCHEDULE="daily"

# Politiques de sécurité
REQUIRE_LOGIN_AUDIT_TRAIL=true
ALERT_ON_ROOT_LOGIN=true
ALERT_ON_AFTER_HOURS_LOGIN=true
MONITOR_REMOTE_LOGINS=true

# Paramètres de conformité
GDPR_COMPLIANCE=true
SOX_COMPLIANCE=false
HIPAA_COMPLIANCE=false
EXPORT_FORMAT="json"  # json, csv, xml

Rapport de Conformité

#!/bin/bash

# Générer des rapports de connexion prêts pour la conformité
generate_compliance_report() {
    local compliance_type="${1:-general}"
    local report_file="$REPORT_DIR/compliance_${compliance_type}_$(date +%Y%m%d).txt"
    
    echo "📋 Génération du rapport de conformité $compliance_type..."
    
    {
        echo "RAPPORT DE CONFORMITÉ HISTORIQUE DE CONNEXION"
        echo "============================================="
        echo "Type de rapport : $compliance_type"
        echo "Généré : $(date)"
        echo "Période : $(date -v-30d '+%Y-%m-%d') à $(date '+%Y-%m-%d')"
        echo "Système : $(hostname)"
        echo ""
        
        case "$compliance_type" in
            "gdpr")
                echo "ENREGISTREMENT DE TRAITEMENT DES DONNÉES RGPD :"
                echo "----------------------------------------------"
                echo "• Données de connexion collectées pour surveillance de sécurité"
                echo "• Rétention des données : 90 jours (configurable)"
                echo "• Contrôles d'accès : Utilisateurs admin uniquement"
                echo "• Sujets des données : Tous les utilisateurs système"
                echo ""
                ;;
            "sox")
                echo "CONFORMITÉ CONTRÔLE D'ACCÈS SOX :"
                echo "--------------------------------"
                echo "• Surveillance d'accès utilisateur : Activé"
                echo "• Suivi d'accès privilégié : Activé"
                echo "• Surveillance de connexions échouées : Activé"
                echo "• Complétude piste d'audit : Vérifiée"
                echo ""
                ;;
            "hipaa")
                echo "EXIGENCES D'AUDIT D'ACCÈS HIPAA :"
                echo "--------------------------------"
                echo "• Journalisation d'authentification utilisateur : Active"
                echo "• Surveillance tentatives d'accès : Activé"
                echo "• Accès minimum nécessaire : En cours de révision"
                echo "• Intégrité journal d'audit : Maintenue"
                echo ""
                ;;
        esac
        
        echo "ACTIVITÉ DE CONNEXION DÉTAILLÉE :"
        echo "--------------------------------"
        last -30
        
        echo ""
        echo "RÉSUMÉ D'ACCÈS UTILISATEUR :"
        echo "---------------------------"
        dscl . list /Users UniqueID | awk '$2 >= 500' | while read -r username uid; do
            local login_count
            login_count=$(last "$username" | grep -v "wtmp begins" | wc -l | tr -d ' ')
            echo "$username (UID : $uid) : $login_count sessions de connexion"
        done
        
    } > "$report_file"
    
    echo "✅ Rapport de conformité généré : $report_file"
}

# Générer différents rapports de conformité
# generate_compliance_report "gdpr"
# generate_compliance_report "sox"
# generate_compliance_report "hipaa"

Notes Techniques Importantes

Détails des Commandes

who : Affiche les utilisateurs actuellement connectés avec heures de connexion
last : Affiche l'historique de connexion depuis /var/log/wtmp
dscl : Ligne de commande Services d'Annuaire pour informations utilisateur
w : Version étendue de who avec informations de charge système

Emplacements des Fichiers de Journal

/var/log/wtmp : Base de données binaire d'historique de connexion
/var/log/system.log : Journal système incluant événements d'authentification
/var/log/secure.log : Entrées de journal liées à la sécurité (si activé)

Considérations de Sécurité

Conformité Confidentialité : La surveillance de connexion doit respecter les lois locales de confidentialité
Rétention de Données : Implémenter des politiques de rétention appropriées pour les journaux d'audit
Contrôle d'Accès : Restreindre l'accès aux données d'historique de connexion au personnel autorisé
Surveillance Temps Réel : Considérer l'implémentation d'alertes temps réel pour activité suspecte

Meilleures Pratiques

Audit Régulier : Réviser les modèles de connexion régulièrement pour anomalies
Surveillance Automatisée : Configurer des alertes automatisées pour activité suspecte
Rétention de Données : Maintenir une rétention de journal appropriée pour exigences de conformité
Confidentialité Utilisateur : Équilibrer surveillance de sécurité avec attentes de confidentialité utilisateur
Documentation : Maintenir une documentation claire des procédures de surveillance
Intégration : Considérer l'intégration avec systèmes SIEM pour surveillance centralisée
Impact Performance : Surveiller l'impact sur performance système des activités de journalisation
Stratégie Sauvegarde : Implémenter procédures de sauvegarde pour journaux d'audit critiques

N'oubliez pas de valider tous les scripts sur des appareils de test avant de les déployer sur votre environnement MacFleet, et assurez-vous de la conformité avec les politiques de confidentialité et de sécurité de votre organisation lors de l'implémentation de la surveillance d'historique de connexion.

Guide

Nouvelles mises à jour et améliorations de Macfleet.

Suivez-nous sur X.com

7 juillet 2025

Gestion de Réseau Wi-Fi sur macOS

Déployez et gérez des configurations réseau Wi-Fi complètes sur vos appareils MacFleet. Ce tutoriel couvre la gestion de politiques réseau, configurations de sécurité, paramètres proxy, gestion DNS et stratégies de déploiement de niveau entreprise.

Comprendre la Gestion Réseau macOS

macOS fournit des outils de ligne de commande puissants pour la gestion réseau :

networksetup - Outil principal pour la configuration réseau
airport - Scan et gestion Wi-Fi avancés
scutil - Utilitaire de configuration système pour les paramètres réseau
Profils réseau - Gestion réseau basée sur les politiques d'entreprise

Opérations Wi-Fi Basiques

Activer/Désactiver l'Interface Wi-Fi

#!/bin/bash

# Activer l'interface Wi-Fi
enable_wifi() {
    echo "Activation de l'interface Wi-Fi..."
    networksetup -setairportpower en0 on
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Interface Wi-Fi activée avec succès"
        return 0
    else
        echo "❌ Échec de l'activation de l'interface Wi-Fi"
        return 1
    fi
}

# Désactiver l'interface Wi-Fi
disable_wifi() {
    echo "⚠️  Désactivation de l'interface Wi-Fi..."
    echo "Assurez-vous que l'appareil a une connectivité alternative (Ethernet, etc.)"
    
    networksetup -setairportpower en0 off
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Interface Wi-Fi désactivée avec succès"
        return 0
    else
        echo "❌ Échec de la désactivation de l'interface Wi-Fi"
        return 1
    fi
}

# Utilisation
enable_wifi

Activer/Désactiver le Service Wi-Fi

#!/bin/bash

# Activer le service Wi-Fi
turn_wifi_on() {
    echo "Activation du service Wi-Fi..."
    networksetup -setnetworkserviceenabled Wi-Fi on
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Service Wi-Fi activé"
        return 0
    else
        echo "❌ Échec de l'activation du service Wi-Fi"
        return 1
    fi
}

# Vérifier le statut du service Wi-Fi
check_wifi_service() {
    echo "Vérification du statut du service Wi-Fi..."
    local status
    status=$(networksetup -getnetworkserviceenabled Wi-Fi)
    
    echo "Statut du service Wi-Fi : $status"
    return 0
}

# Utilisation
check_wifi_service
turn_wifi_on

Informations Réseau Wi-Fi

Obtenir les Informations Réseau Actuelles

#!/bin/bash

# Obtenir le SSID du réseau Wi-Fi actuel
get_current_network() {
    echo "=== Réseau Wi-Fi Actuel ==="
    local network_info
    network_info=$(networksetup -getairportnetwork en0)
    
    if [[ "$network_info" == *"not associated"* ]]; then
        echo "❌ Non connecté à un réseau Wi-Fi"
        return 1
    else
        echo "📶 $network_info"
        return 0
    fi
}

# Obtenir des informations Wi-Fi complètes
get_wifi_info() {
    echo "=== Informations Réseau Wi-Fi ==="
    networksetup -getinfo Wi-Fi
    
    echo -e "\n=== Détails de l'Interface Wi-Fi ==="
    ifconfig en0 | grep -E "(inet |ether |status)"
    
    echo -e "\n=== Qualité Wi-Fi ==="
    /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I
}

# Scanner les réseaux disponibles
scan_networks() {
    echo "=== Réseaux Wi-Fi Disponibles ==="
    /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s
}

# Utilisation
get_current_network
echo ""
get_wifi_info

Système de Gestion Wi-Fi d'Entreprise

#!/bin/bash

# Système de Gestion Wi-Fi d'Entreprise MacFleet
# Configuration Wi-Fi centralisée et gestion de politiques pour appareils de flotte

# Configuration
LOG_FILE="/var/log/macfleet_wifi.log"
CONFIG_DIR="/etc/macfleet/wifi"
PROFILES_DIR="$CONFIG_DIR/profiles"
BACKUP_DIR="/var/backups/network_configs"

# Modèles de profils réseau
declare -A NETWORK_PROFILES=(
    ["entreprise"]="security=WPA2Enterprise,proxy=auto,dns=entreprise"
    ["invite"]="security=WPA2Personal,proxy=none,dns=public"
    ["securise"]="security=WPA2Enterprise,proxy=obligatoire,dns=securise"
    ["developpement"]="security=WPA2Personal,proxy=bypass,dns=dev"
    ["public"]="security=none,proxy=auto,dns=public"
)

# Configurations serveurs DNS
declare -A DNS_CONFIGS=(
    ["entreprise"]="10.0.1.1 10.0.1.2"
    ["public"]="8.8.8.8 8.8.4.4"
    ["securise"]="1.1.1.1 1.0.0.1"
    ["dev"]="192.168.1.1 8.8.8.8"
)

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

# Configurer les serveurs DNS
configure_dns() {
    local dns_profile="$1"
    local custom_dns="$2"
    
    log_action "Configuration des serveurs DNS : $dns_profile"
    
    local dns_servers
    if [[ -n "$custom_dns" ]]; then
        dns_servers="$custom_dns"
    else
        dns_servers="${DNS_CONFIGS[$dns_profile]}"
    fi
    
    if [[ -z "$dns_servers" ]]; then
        log_action "❌ Profil DNS inconnu ou configuration vide : $dns_profile"
        return 1
    fi
    
    # Configurer les serveurs DNS
    if networksetup -setdnsservers Wi-Fi $dns_servers; then
        log_action "✅ Serveurs DNS configurés : $dns_servers"
        
        # Vérifier la configuration
        local current_dns
        current_dns=$(networksetup -getdnsservers Wi-Fi)
        log_action "Serveurs DNS actuels : $current_dns"
        
        return 0
    else
        log_action "❌ Échec de la configuration des serveurs DNS"
        return 1
    fi
}

# Configurer les domaines de recherche
configure_search_domains() {
    local domains="$*"
    
    if [[ -z "$domains" ]]; then
        log_action "Effacement des domaines de recherche"
        networksetup -setsearchdomains Wi-Fi "Empty"
    else
        log_action "Configuration des domaines de recherche : $domains"
        networksetup -setsearchdomains Wi-Fi $domains
    fi
    
    if [[ $? -eq 0 ]]; then
        log_action "✅ Domaines de recherche configurés avec succès"
        return 0
    else
        log_action "❌ Échec de la configuration des domaines de recherche"
        return 1
    fi
}

# Configurer le proxy web
configure_web_proxy() {
    local proxy_type="$1"
    local proxy_config="$2"
    
    log_action "Configuration du proxy web : $proxy_type"
    
    case "$proxy_type" in
        "none")
            # Désactiver tous les proxies
            networksetup -setwebproxystate Wi-Fi off
            networksetup -setsecurewebproxystate Wi-Fi off
            networksetup -setautoproxystate Wi-Fi off
            log_action "✅ Tous les proxies désactivés"
            ;;
        "web")
            local proxy_server proxy_port auth_required username password
            IFS=':' read -ra PROXY_PARTS <<< "$proxy_config"
            proxy_server="${PROXY_PARTS[0]}"
            proxy_port="${PROXY_PARTS[1]}"
            auth_required="${PROXY_PARTS[2]}"
            username="${PROXY_PARTS[3]:-}"
            password="${PROXY_PARTS[4]:-}"
            
            if [[ "$auth_required" == "authenticated" && -n "$username" && -n "$password" ]]; then
                networksetup -setwebproxy Wi-Fi "$proxy_server" "$proxy_port" on "$username" "$password"
            else
                networksetup -setwebproxy Wi-Fi "$proxy_server" "$proxy_port" off
            fi
            
            networksetup -setwebproxystate Wi-Fi on
            log_action "✅ Proxy web configuré : $proxy_server:$proxy_port"
            ;;
        "auto")
            networksetup -setautoproxyurl Wi-Fi "$proxy_config"
            networksetup -setautoproxystate Wi-Fi on
            log_action "✅ Proxy automatique configuré : $proxy_config"
            ;;
        *)
            log_action "❌ Type de proxy inconnu : $proxy_type"
            return 1
            ;;
    esac
    
    return 0
}

# Sauvegarder la configuration réseau actuelle
backup_network_config() {
    local backup_timestamp
    backup_timestamp=$(date '+%Y%m%d_%H%M%S')
    local backup_file="$BACKUP_DIR/network_config_$backup_timestamp.tar.gz"
    
    log_action "Création de la sauvegarde de configuration réseau : $backup_file"
    
    # Créer un répertoire de sauvegarde temporaire
    local temp_backup="/tmp/network_backup_$$"
    mkdir -p "$temp_backup"
    
    # Exporter les paramètres actuels
    {
        echo "# Statut du Service Wi-Fi"
        networksetup -getnetworkserviceenabled Wi-Fi
        
        echo -e "\n# Statut d'Alimentation Wi-Fi"
        networksetup -getairportpower en0
        
        echo -e "\n# Réseau Actuel"
        networksetup -getairportnetwork en0
        
        echo -e "\n# Informations Réseau"
        networksetup -getinfo Wi-Fi
        
        echo -e "\n# Serveurs DNS"
        networksetup -getdnsservers Wi-Fi
        
        echo -e "\n# Domaines de Recherche"
        networksetup -getsearchdomains Wi-Fi
        
        echo -e "\n# Proxy Web"
        networksetup -getwebproxy Wi-Fi
        
    } > "$temp_backup/current_config.txt"
    
    # Créer une sauvegarde compressée
    if tar -czf "$backup_file" -C "$(dirname "$temp_backup")" "$(basename "$temp_backup")" 2>/dev/null; then
        log_action "✅ Sauvegarde réseau créée : $backup_file"
        rm -rf "$temp_backup"
        echo "$backup_file"
        return 0
    else
        log_action "❌ Échec de la sauvegarde réseau"
        rm -rf "$temp_backup"
        return 1
    fi
}

# Diagnostics réseau
network_diagnostics() {
    echo "=== Diagnostics Réseau MacFleet ==="
    echo "Horodatage : $(date)"
    echo "Nom d'hôte : $(hostname)"
    echo "======================================="
    
    # Statut de l'interface Wi-Fi
    echo -e "\n🔍 Statut de l'Interface Wi-Fi :"
    local wifi_power
    wifi_power=$(networksetup -getairportpower en0)
    echo "Alimentation : $wifi_power"
    
    local wifi_service
    wifi_service=$(networksetup -getnetworkserviceenabled Wi-Fi)
    echo "Service : $wifi_service"
    
    # Connexion actuelle
    echo -e "\n📶 Connexion Actuelle :"
    networksetup -getairportnetwork en0
    
    # Configuration réseau
    echo -e "\n⚙️  Configuration Réseau :"
    networksetup -getinfo Wi-Fi
    
    # Paramètres DNS
    echo -e "\n🌐 Paramètres DNS :"
    networksetup -getdnsservers Wi-Fi
    
    # Test de connectivité
    echo -e "\n🌍 Test de Connectivité :"
    if ping -c 3 8.8.8.8 >/dev/null 2>&1; then
        echo "✅ Connectivité Internet : Disponible"
    else
        echo "❌ Connectivité Internet : Échec"
    fi
    
    if ping -c 3 apple.com >/dev/null 2>&1; then
        echo "✅ Résolution DNS : Fonctionne"
    else
        echo "❌ Résolution DNS : Échec"
    fi
}

# Fonction d'exécution principale
main() {
    local action="${1:-status}"
    local profile_name="$2"
    local additional_param="$3"
    
    log_action "=== Démarrage de la Gestion Wi-Fi MacFleet ==="
    log_action "Action : $action"
    log_action "Profil : ${profile_name:-N/A}"
    
    case "$action" in
        "status")
            network_diagnostics
            ;;
        "dns")
            if [[ -z "$profile_name" ]]; then
                echo "Profils DNS disponibles : ${!DNS_CONFIGS[*]}"
                echo "Usage : $0 dns <nom_profil|serveurs_personnalisés>"
                exit 1
            fi
            configure_dns "$profile_name" "$additional_param"
            ;;
        "proxy")
            if [[ -z "$profile_name" ]]; then
                echo "Usage : $0 proxy <none|web|auto> [config]"
                exit 1
            fi
            configure_web_proxy "$profile_name" "$additional_param"
            ;;
        "backup")
            backup_network_config
            ;;
        *)
            echo "Usage : $0 {status|dns|proxy|backup}"
            echo "  status  - Afficher le statut et diagnostics réseau"
            echo "  dns     - Configurer les serveurs DNS"
            echo "  proxy   - Configurer les paramètres proxy"
            echo "  backup  - Sauvegarder la configuration réseau actuelle"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion Wi-Fi terminée ==="
}

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

Configuration Réseau Avancée

Gestion de Profils Wi-Fi d'Entreprise

#!/bin/bash

# Créer un profil réseau personnalisé
create_network_profile() {
    local profile_name="$1"
    local ssid="$2"
    local security_type="$3"
    local proxy_config="$4"
    local dns_config="$5"
    
    local profile_file="$PROFILES_DIR/${profile_name}.json"
    
    cat > "$profile_file" << EOF
{
    "profile_name": "$profile_name",
    "created_date": "$(date -Iseconds)",
    "wifi_settings": {
        "ssid": "$ssid",
        "security_type": "$security_type",
        "auto_connect": true,
        "priority": 100
    },
    "proxy_settings": {
        "type": "$proxy_config",
        "bypass_domains": ["*.local", "localhost"]
    },
    "dns_settings": {
        "servers": "$dns_config",
        "search_domains": ["company.com", "local"]
    }
}
EOF

    echo "Profil réseau créé : $profile_file"
}

Surveillance de Qualité Réseau

#!/bin/bash

# Surveiller la qualité et performance réseau
monitor_network_quality() {
    local duration="${1:-60}"  # durée de surveillance en secondes
    local interval="${2:-5}"   # intervalle de vérification en secondes
    
    echo "=== Surveillance de Qualité Réseau ==="
    echo "Durée : ${duration}s, Intervalle : ${interval}s"
    
    local start_time end_time
    start_time=$(date +%s)
    end_time=$((start_time + duration))
    
    while [[ $(date +%s) -lt $end_time ]]; do
        local timestamp signal_strength tx_rate
        timestamp=$(date '+%H:%M:%S')
        
        # Obtenir les métriques Wi-Fi
        local airport_info
        airport_info=$(/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I)
        
        signal_strength=$(echo "$airport_info" | grep 'RSSI:' | awk '{print $2}')
        tx_rate=$(echo "$airport_info" | grep 'lastTxRate:' | awk '{print $2}')
        
        # Tester la vitesse de connectivité
        local ping_time
        ping_time=$(ping -c 1 8.8.8.8 2>/dev/null | grep 'time=' | awk -F'time=' '{print $2}' | awk '{print $1}')
        
        printf "%s | Signal: %sdBm | Vitesse: %sMbps | Ping: %s\n" \
               "$timestamp" "$signal_strength" "$tx_rate" "${ping_time:-timeout}"
        
        sleep "$interval"
    done
}

Sécurité et Conformité

Audit de Sécurité Réseau

#!/bin/bash

# Audit complet de sécurité réseau
network_security_audit() {
    echo "=== Audit de Sécurité Réseau ==="
    log_action "Démarrage de l'audit de sécurité réseau"
    
    # Vérifier le chiffrement Wi-Fi
    local wifi_encryption
    wifi_encryption=$(networksetup -getairportnetwork en0 | grep -o 'WPA\\|WEP\\|None' || echo 'Inconnu')
    echo "Chiffrement Wi-Fi : $wifi_encryption"
    
    # Vérifier le statut du proxy
    local proxy_enabled
    proxy_enabled=$(networksetup -getwebproxystate Wi-Fi)
    echo "Proxy activé : $proxy_enabled"
    
    # Vérifier les serveurs DNS
    local dns_servers
    dns_servers=$(networksetup -getdnsservers Wi-Fi)
    echo "Serveurs DNS : $dns_servers"
    
    # Recommandations de sécurité
    echo -e "\n=== Recommandations de Sécurité ==="
    
    if [[ "$wifi_encryption" == "None" ]]; then
        echo "⚠️  Évitez les réseaux non chiffrés"
    fi
    
    if echo "$dns_servers" | grep -q "There aren't any DNS Servers"; then
        echo "⚠️  Configurez des serveurs DNS sécurisés"
    fi
    
    log_action "✅ Audit de sécurité terminé"
}

Application de Politiques de Conformité

#!/bin/bash

# Appliquer les politiques de conformité d'entreprise
enforce_compliance_policy() {
    local policy_name="$1"
    
    log_action "Application de la politique de conformité : $policy_name"
    
    case "$policy_name" in
        "entreprise")
            # Politique d'entreprise : DNS sécurisé, proxy obligatoire
            configure_dns "entreprise"
            configure_web_proxy "web" "proxy.company.com:8080:authenticated"
            ;;
        "education")
            # Politique éducation : DNS sûr, proxy de filtrage de contenu
            configure_dns "public"
            configure_web_proxy "auto" "http://filter.school.edu/proxy.pac"
            ;;
        "sante")
            # Politique santé : paramètres conformes HIPAA
            configure_dns "securise"
            configure_web_proxy "web" "secure-proxy.hospital.org:8080:authenticated"
            ;;
        *)
            log_action "❌ Politique de conformité inconnue : $policy_name"
            return 1
            ;;
    esac
    
    log_action "✅ Politique de conformité appliquée : $policy_name"
    return 0
}

Dépannage Réseau

Réparation Réseau Automatisée

#!/bin/bash

# Dépannage et réparation réseau automatisés
network_repair() {
    local repair_level="${1:-basic}"
    
    log_action "Démarrage de la réparation réseau : $repair_level"
    
    echo "=== Réparation Réseau MacFleet ==="
    
    # Test de connectivité de base
    echo "🔍 Test de connectivité de base..."
    if ping -c 3 8.8.8.8 >/dev/null 2>&1; then
        echo "✅ Connectivité Internet : OK"
    else
        echo "❌ Connectivité Internet : ÉCHEC"
        
        case "$repair_level" in
            "basic")
                echo "🔧 Tentative de réparation de base..."
                # Redémarrer Wi-Fi
                networksetup -setairportpower en0 off
                sleep 3
                networksetup -setairportpower en0 on
                sleep 5
                ;;
            "avance")
                echo "🔧 Tentative de réparation avancée..."
                # Réinitialisation réseau complète
                configure_dns "public"
                configure_web_proxy "none"
                networksetup -setairportpower en0 off
                sleep 3
                networksetup -setairportpower en0 on
                sleep 10
                ;;
        esac
        
        # Re-tester après réparation
        echo "🔄 Nouveau test de connectivité..."
        if ping -c 3 8.8.8.8 >/dev/null 2>&1; then
            echo "✅ Réparation réussie"
            log_action "Réparation réseau réussie : $repair_level"
        else
            echo "❌ Réparation échouée - escalader vers intervention manuelle"
            log_action "Réparation réseau échouée : $repair_level"
        fi
    fi
}

Meilleures Pratiques

🚀 Optimisation des Performances

Surveillez la qualité réseau régulièrement et basculez vers les réseaux optimaux
Configurez des tailles MTU appropriées pour votre environnement réseau
Utilisez la mise en cache DNS locale pour améliorer les vitesses de résolution
Optimisez les paramètres proxy pour votre cas d'usage spécifique

🔐 Directives de Sécurité

Utilisez toujours des réseaux chiffrés (WPA2/WPA3) dans les environnements d'entreprise
Configurez des serveurs DNS sécurisés pour prévenir l'empoisonnement DNS
Implémentez des politiques proxy pour le filtrage de contenu et la sécurité
Audits de sécurité réguliers pour identifier les vulnérabilités réseau

📋 Meilleures Pratiques de Gestion

Configuration basée sur les profils pour différents groupes d'utilisateurs et emplacements
Application de politiques centralisées sur tous les appareils de flotte
Sauvegarde régulière des configurations réseau avant les changements
Surveillance et alertes automatisées pour les problèmes de connectivité

🔍 Conseils de Dépannage

Utilisez les diagnostics réseau pour identifier les problèmes de configuration
Surveillez la force du signal et les métriques de qualité réseau
Testez la connectivité vers plusieurs points de terminaison pour une validation complète
Documentez les changements réseau pour les pistes d'audit et le dépannage

Notes Importantes

Les changements réseau prennent effet immédiatement mais peuvent nécessiter une reconnexion
Les identifiants d'authentification proxy doivent être gérés de manière sécurisée
Les changements DNS peuvent nécessiter un vidage du cache pour prendre effet
Certains réseaux d'entreprise nécessitent des certificats spécifiques pour l'authentification
Toujours sauvegarder les configurations avant de faire des changements significatifs

7 juillet 2025

Contrôle Wi-Fi d'Entreprise sur macOS

Contrôlez et gérez les paramètres Wi-Fi sur vos appareils MacFleet en utilisant des outils de ligne de commande avancés et des politiques sans fil centralisées. Ce tutoriel couvre la gestion de l'alimentation Wi-Fi, le contrôle des connexions, l'application de la sécurité et la gestion de réseau sans fil de niveau entreprise avec des capacités complètes de surveillance et de conformité.

Comprendre la Gestion Wi-Fi macOS

macOS fournit plusieurs outils de ligne de commande pour la gestion Wi-Fi :

networksetup - Outil principal pour la configuration et le contrôle réseau
airport - Utilitaire de gestion d'interface sans fil de bas niveau
ifconfig - Outil de configuration d'interface réseau
Préférences Système - Équivalent GUI pour les paramètres sans fil

Le contrôle Wi-Fi d'entreprise nécessite une attention particulière aux politiques de sécurité, à la gestion de l'alimentation et aux exigences de conformité.

Commandes de Contrôle Wi-Fi de Base

Désactiver le Wi-Fi

#!/bin/bash

# Commande de base pour désactiver le Wi-Fi
turn_off_wifi_basic() {
    # Obtenir le nom de l'interface airport
    local AIRPORT=$(networksetup -listallhardwareports | grep -A 1 Wi-Fi | grep Device | awk '{print $2}')
    
    if [[ -n "$AIRPORT" ]]; then
        networksetup -setairportpower "$AIRPORT" off
        
        if [[ $? -eq 0 ]]; then
            echo "✅ Wi-Fi désactivé avec succès"
            return 0
        else
            echo "❌ Échec de la désactivation du Wi-Fi"
            return 1
        fi
    else
        echo "❌ Interface Wi-Fi non trouvée"
        return 1
    fi
}

# Exemple d'utilisation
turn_off_wifi_basic

Activer le Wi-Fi

#!/bin/bash

# Activer le Wi-Fi avec vérification
turn_on_wifi() {
    local interface_name="$1"
    
    # Détection automatique de l'interface si non fournie
    if [[ -z "$interface_name" ]]; then
        interface_name=$(networksetup -listallhardwareports | grep -A 1 Wi-Fi | grep Device | awk '{print $2}')
    fi
    
    if [[ -z "$interface_name" ]]; then
        echo "❌ Interface Wi-Fi non trouvée"
        return 1
    fi
    
    echo "Activation de l'interface Wi-Fi : $interface_name"
    networksetup -setairportpower "$interface_name" on
    
    # Attendre que l'interface soit active
    sleep 3
    
    # Vérifier que le Wi-Fi est activé
    local wifi_status
    wifi_status=$(networksetup -getairportpower "$interface_name" | grep "On")
    
    if [[ -n "$wifi_status" ]]; then
        echo "✅ Wi-Fi activé avec succès"
        return 0
    else
        echo "❌ Échec de l'activation du Wi-Fi"
        return 1
    fi
}

# Exemple d'utilisation
# turn_on_wifi "en0"

Vérifier le Statut Wi-Fi

#!/bin/bash

# Vérifier le statut Wi-Fi actuel avec informations détaillées
check_wifi_status() {
    echo "=== Rapport de Statut Wi-Fi ==="
    echo "Généré : $(date)"
    echo "==============================="
    echo ""
    
    # Obtenir toutes les interfaces Wi-Fi
    local wifi_interfaces
    wifi_interfaces=$(networksetup -listallhardwareports | grep -A 1 Wi-Fi | grep Device | awk '{print $2}')
    
    if [[ -z "$wifi_interfaces" ]]; then
        echo "❌ Aucune interface Wi-Fi trouvée"
        return 1
    fi
    
    for interface in $wifi_interfaces; do
        echo "Interface : $interface"
        echo "-----------------"
        
        # Statut d'alimentation
        local power_status
        power_status=$(networksetup -getairportpower "$interface")
        echo "Statut d'Alimentation : $power_status"
        
        # Statut de connexion
        if echo "$power_status" | grep -q "On"; then
            # Obtenir le réseau actuel
            local current_network
            current_network=$(networksetup -getairportnetwork "$interface" | cut -d' ' -f4-)
            echo "Réseau Actuel : $current_network"
            
            # Obtenir l'adresse IP si connecté
            local ip_address
            ip_address=$(ifconfig "$interface" | grep "inet " | awk '{print $2}')
            if [[ -n "$ip_address" ]]; then
                echo "Adresse IP : $ip_address"
            else
                echo "Adresse IP : Non assignée"
            fi
            
            # Force du signal (si disponible)
            if command -v airport >/dev/null 2>&1; then
                local signal_info
                signal_info=$(airport -I | grep "agrCtlRSSI" | awk '{print $2}')
                if [[ -n "$signal_info" ]]; then
                    echo "Force du Signal : $signal_info dBm"
                fi
            fi
        else
            echo "Wi-Fi désactivé"
        fi
        
        echo ""
    done
}

# Exécuter la vérification de statut
check_wifi_status

Système de Contrôle Wi-Fi d'Entreprise

#!/bin/bash

# Système de Contrôle Wi-Fi d'Entreprise MacFleet
# Gestion sans fil complète, application de sécurité et surveillance de conformité

# Configuration
LOG_FILE="/var/log/macfleet_wifi_control.log"
CONFIG_FILE="/etc/macfleet/wifi_config.conf"
BACKUP_DIR="/var/backups/macfleet/wifi"
POLICY_DIR="/etc/macfleet/wifi_policies"

# Créer la structure de répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$BACKUP_DIR" "$POLICY_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
    
    # Définir les permissions appropriées
    chmod 755 "$BACKUP_DIR" "$POLICY_DIR"
}

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

# Application de politique Wi-Fi d'entreprise
enforce_wifi_policy() {
    local policy_name="$1"
    local policy_file="$POLICY_DIR/${policy_name}.policy"
    
    if [[ ! -f "$policy_file" ]]; then
        log_action "ERREUR : Politique Wi-Fi non trouvée : $policy_name"
        return 1
    fi
    
    log_action "Application de la politique Wi-Fi : $policy_name"
    
    # Charger la configuration de politique
    source "$policy_file"
    
    # Obtenir l'interface Wi-Fi
    local wifi_interface
    wifi_interface=$(networksetup -listallhardwareports | grep -A 1 Wi-Fi | grep Device | awk '{print $2}')
    
    if [[ -z "$wifi_interface" ]]; then
        log_action "ERREUR : Aucune interface Wi-Fi trouvée"
        return 1
    fi
    
    # Appliquer les paramètres de politique
    case "${WIFI_POLICY_ACTION:-disable}" in
        "disable")
            networksetup -setairportpower "$wifi_interface" off
            log_action "Wi-Fi désactivé selon la politique : $policy_name"
            ;;
        "enable")
            networksetup -setairportpower "$wifi_interface" on
            log_action "Wi-Fi activé selon la politique : $policy_name"
            ;;
        "scheduled")
            apply_scheduled_wifi_policy "$wifi_interface" "$policy_name"
            ;;
        "conditional")
            apply_conditional_wifi_policy "$wifi_interface" "$policy_name"
            ;;
        *)
            log_action "ERREUR : Action de politique inconnue : ${WIFI_POLICY_ACTION}"
            return 1
            ;;
    esac
    
    return 0
}

# Contrôle Wi-Fi programmé
apply_scheduled_wifi_policy() {
    local interface="$1"
    local policy_name="$2"
    local current_hour=$(date +%H)
    local current_day=$(date +%u)  # 1=Lundi, 7=Dimanche
    
    log_action "Application de la politique Wi-Fi programmée : $policy_name"
    
    # Charger le planning depuis la politique
    local enable_hours="${WIFI_ENABLE_HOURS:-09-17}"
    local enable_days="${WIFI_ENABLE_DAYS:-1-5}"
    
    # Analyser la plage horaire
    local start_hour end_hour
    start_hour=$(echo "$enable_hours" | cut -d'-' -f1)
    end_hour=$(echo "$enable_hours" | cut -d'-' -f2)
    
    # Analyser la plage de jours
    local start_day end_day
    start_day=$(echo "$enable_days" | cut -d'-' -f1)
    end_day=$(echo "$enable_days" | cut -d'-' -f2)
    
    # Vérifier si l'heure actuelle est dans la fenêtre autorisée
    local time_allowed=false
    local day_allowed=false
    
    if [[ "$current_hour" -ge "$start_hour" && "$current_hour" -lt "$end_hour" ]]; then
        time_allowed=true
    fi
    
    if [[ "$current_day" -ge "$start_day" && "$current_day" -le "$end_day" ]]; then
        day_allowed=true
    fi
    
    if [[ "$time_allowed" == "true" && "$day_allowed" == "true" ]]; then
        networksetup -setairportpower "$interface" on
        log_action "Wi-Fi activé - dans les heures programmées"
    else
        networksetup -setairportpower "$interface" off
        log_action "Wi-Fi désactivé - hors des heures programmées"
    fi
}

# Contrôle Wi-Fi conditionnel
apply_conditional_wifi_policy() {
    local interface="$1"
    local policy_name="$2"
    
    log_action "Application de la politique Wi-Fi conditionnelle : $policy_name"
    
    # Vérifier le niveau de batterie
    local battery_level
    battery_level=$(pmset -g batt | grep -o '[0-9]*%' | tr -d '%')
    
    # Vérifier la source d'alimentation
    local power_source
    power_source=$(pmset -g ps | head -1 | grep -o "'.*'" | tr -d "'")
    
    # Vérifier la connexion ethernet
    local ethernet_connected=false
    local ethernet_interfaces
    ethernet_interfaces=$(networksetup -listallhardwareports | grep -A 1 Ethernet | grep Device | awk '{print $2}')
    
    for eth_interface in $ethernet_interfaces; do
        local eth_status
        eth_status=$(ifconfig "$eth_interface" 2>/dev/null | grep "status: active")
        if [[ -n "$eth_status" ]]; then
            ethernet_connected=true
            break
        fi
    done
    
    # Appliquer la logique conditionnelle
    local should_enable_wifi=true
    
    # Désactiver le Wi-Fi si ethernet est connecté et la politique l'exige
    if [[ "$ethernet_connected" == "true" && "${DISABLE_WIFI_WITH_ETHERNET:-false}" == "true" ]]; then
        should_enable_wifi=false
        log_action "Wi-Fi désactivé - Connexion Ethernet détectée"
    fi
    
    # Désactiver le Wi-Fi si la batterie est faible et la politique l'exige
    if [[ -n "$battery_level" && "$battery_level" -lt "${MIN_BATTERY_FOR_WIFI:-20}" ]]; then
        should_enable_wifi=false
        log_action "Wi-Fi désactivé - Niveau de batterie faible : $battery_level%"
    fi
    
    # Activer/désactiver le Wi-Fi selon les conditions
    if [[ "$should_enable_wifi" == "true" ]]; then
        networksetup -setairportpower "$interface" on
        log_action "Wi-Fi activé - Conditions remplies"
    else
        networksetup -setairportpower "$interface" off
        log_action "Wi-Fi désactivé - Conditions non remplies"
    fi
}

# Vérification de conformité de sécurité
check_wifi_security_compliance() {
    log_action "Exécution de la vérification de conformité de sécurité Wi-Fi"
    
    local compliance_issues=()
    local wifi_interface
    wifi_interface=$(networksetup -listallhardwareports | grep -A 1 Wi-Fi | grep Device | awk '{print $2}')
    
    if [[ -z "$wifi_interface" ]]; then
        log_action "ERREUR : Aucune interface Wi-Fi trouvée pour la vérification de conformité"
        return 1
    fi
    
    # Vérifier si le Wi-Fi est activé quand il devrait être désactivé
    local power_status
    power_status=$(networksetup -getairportpower "$wifi_interface")
    
    if echo "$power_status" | grep -q "On"; then
        # Wi-Fi activé, vérifier la sécurité du réseau actuel
        local current_network
        current_network=$(networksetup -getairportnetwork "$wifi_interface" | cut -d' ' -f4-)
        
        if [[ "$current_network" != "You are not associated with an AirPort network." ]]; then
            log_action "Connecté au réseau : $current_network"
            
            # Vérifier si le réseau est dans la liste approuvée
            local approved_networks_file="$POLICY_DIR/approved_networks.list"
            if [[ -f "$approved_networks_file" ]]; then
                if ! grep -q "^$current_network$" "$approved_networks_file"; then
                    compliance_issues+=("Connecté à un réseau non approuvé : $current_network")
                fi
            fi
            
            # Vérifier les réseaux ouverts
            if command -v airport >/dev/null 2>&1; then
                local network_security
                network_security=$(airport -I | grep "Security")
                if echo "$network_security" | grep -q "none"; then
                    compliance_issues+=("Connecté à un réseau ouvert/non sécurisé")
                fi
            fi
        fi
    fi
    
    # Générer le rapport de conformité
    if [[ ${#compliance_issues[@]} -eq 0 ]]; then
        log_action "✅ Vérification de conformité de sécurité Wi-Fi réussie"
        return 0
    else
        log_action "❌ Violations de conformité de sécurité Wi-Fi trouvées :"
        for issue in "${compliance_issues[@]}"; do
            log_action "  - $issue"
        done
        return 1
    fi
}

# Fonction de gestion principale
main() {
    local action="${1:-status}"
    local parameter1="$2"
    local parameter2="$3"
    
    setup_directories
    log_action "Contrôle Wi-Fi MacFleet démarré avec l'action : $action"
    
    case "$action" in
        "disable"|"off")
            turn_off_wifi_basic
            ;;
        "enable"|"on")
            turn_on_wifi "$parameter1"
            ;;
        "status")
            check_wifi_status
            ;;
        "policy")
            enforce_wifi_policy "$parameter1"
            ;;
        "compliance")
            check_wifi_security_compliance
            ;;
        *)
            check_wifi_status
            ;;
    esac
    
    log_action "Contrôle Wi-Fi MacFleet terminé avec l'action : $action"
}

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

Modèles de Politiques Wi-Fi

Configuration de Politique Wi-Fi d'Entreprise

# /etc/macfleet/wifi_policies/corporate_standard.policy
# Politique Wi-Fi d'Entreprise MacFleet

# Action de politique : disable, enable, scheduled, conditional
WIFI_POLICY_ACTION="conditional"

# Paramètres programmés (pour action scheduled)
WIFI_ENABLE_HOURS="08-18"    # 8h à 18h
WIFI_ENABLE_DAYS="1-5"       # Lundi au vendredi

# Paramètres conditionnels
DISABLE_WIFI_WITH_ETHERNET="true"
MIN_BATTERY_FOR_WIFI="15"

# Paramètres de sécurité
REQUIRE_WPA2_MINIMUM="true"
BLOCK_OPEN_NETWORKS="true"
AUTO_CONNECT_CORPORATE_ONLY="true"

# Gestion de l'alimentation
POWER_OPTIMIZATION_LEVEL="balanced"
AUTO_DISABLE_IDLE="true"
IDLE_TIMEOUT_MINUTES="30"

Politique Wi-Fi Axée Sécurité

# /etc/macfleet/wifi_policies/high_security.policy
# Politique Wi-Fi Haute Sécurité MacFleet

WIFI_POLICY_ACTION="conditional"

# Exigences de sécurité
REQUIRE_WPA3_MINIMUM="true"
BLOCK_OPEN_NETWORKS="true"
BLOCK_WEP_NETWORKS="true"
APPROVED_NETWORKS_ONLY="true"

# Désactivation conditionnelle
DISABLE_WIFI_WITH_ETHERNET="true"
DISABLE_WIFI_IN_SECURE_AREAS="true"
MIN_BATTERY_FOR_WIFI="25"

# Surveillance
ENABLE_CONNECTION_LOGGING="true"
ALERT_ON_UNAPPROVED_NETWORKS="true"
SCAN_INTERVAL_MINUTES="5"

Fonctions de Sécurité et Conformité

Gestion de Liste Blanche de Réseaux

#!/bin/bash

# Gérer les réseaux Wi-Fi approuvés
manage_network_whitelist() {
    local action="$1"
    local network_name="$2"
    local whitelist_file="$POLICY_DIR/approved_networks.list"
    
    case "$action" in
        "add")
            if [[ -z "$network_name" ]]; then
                echo "ERREUR : Nom de réseau requis"
                return 1
            fi
            
            # Ajouter le réseau à la liste blanche
            if ! grep -q "^$network_name$" "$whitelist_file" 2>/dev/null; then
                echo "$network_name" >> "$whitelist_file"
                log_action "Réseau ajouté à la liste blanche : $network_name"
            else
                log_action "Réseau déjà dans la liste blanche : $network_name"
            fi
            ;;
        "remove")
            if [[ -z "$network_name" ]]; then
                echo "ERREUR : Nom de réseau requis"
                return 1
            fi
            
            # Supprimer le réseau de la liste blanche
            if [[ -f "$whitelist_file" ]]; then
                grep -v "^$network_name$" "$whitelist_file" > "${whitelist_file}.tmp"
                mv "${whitelist_file}.tmp" "$whitelist_file"
                log_action "Réseau supprimé de la liste blanche : $network_name"
            fi
            ;;
        "list")
            echo "=== Liste Blanche des Réseaux Approuvés ==="
            if [[ -f "$whitelist_file" ]]; then
                cat "$whitelist_file"
            else
                echo "Aucun réseau approuvé configuré"
            fi
            ;;
        *)
            echo "ERREUR : Action de liste blanche invalide : $action"
            return 1
            ;;
    esac
}

# Exemple d'utilisation
# manage_network_whitelist "add" "WiFiEntreprise"
# manage_network_whitelist "list"

Notes Techniques Importantes

Référence des Commandes NetworkSetup

networksetup -setairportpower <device> on|off : Activer/désactiver le Wi-Fi
networksetup -getairportpower <device> : Vérifier le statut d'alimentation Wi-Fi
networksetup -getairportnetwork <device> : Obtenir le réseau Wi-Fi actuel
networksetup -listpreferredwirelessnetworks <device> : Lister les réseaux sauvegardés

Considérations de Sécurité

Privilèges Administrateur : Beaucoup de commandes réseau nécessitent un accès admin
Isolation Réseau : Assurer une segmentation réseau appropriée
Gestion des Profils : Auditer et nettoyer régulièrement les profils réseau sauvegardés
Protection Réseau Ouvert : Bloquer les connexions aux réseaux non sécurisés
Surveillance de Conformité : Implémenter une vérification continue de conformité de sécurité

Meilleures Pratiques de Gestion de l'Alimentation

Optimisation Batterie : Désactiver le Wi-Fi quand la batterie est critique
Priorité Ethernet : Préférer les connexions filaires quand disponibles
Contrôle Programmé : Implémenter des politiques Wi-Fi basées sur l'heure
Gestion Inactivité : Désactiver le Wi-Fi pendant les périodes d'inactivité prolongées
Surveillance des Ressources : Suivre les modèles de consommation d'énergie

Cas d'Usage d'Entreprise

Environnements Sécurisés : Liste blanche stricte des réseaux et conformité
Déploiements Économes en Énergie : Optimisation batterie pour travailleurs mobiles
Opérations Programmées : Contrôle Wi-Fi basé sur l'heure pour différentes équipes
Exigences de Conformité : Pistes d'audit et surveillance de sécurité
Standardisation de Flotte : Politiques Wi-Fi cohérentes sur tous les appareils

N'oubliez pas de tester tous les scripts sur des appareils individuels avant de les déployer sur votre environnement MacFleet, et d'assurer la conformité avec les politiques de sécurité d'entreprise lors de l'implémentation de systèmes de contrôle Wi-Fi d'entreprise.

7 juillet 2025

Contrôle d'Accès aux Sites Web d'Entreprise sur macOS

Contrôlez l'accès aux sites web sur vos appareils MacFleet en utilisant la gestion avancée du fichier hosts, le filtrage DNS et les contrôles de politique d'entreprise. Ce tutoriel fournit des outils complets pour implémenter les politiques d'accès web organisationnelles.

Comprendre les Méthodes de Contrôle d'Accès aux Sites Web

macOS offre plusieurs approches pour contrôler l'accès aux sites web :

Gestion du Fichier Hosts - Redirection DNS locale pour des domaines spécifiques
Configuration DNS - Filtrage au niveau réseau via des serveurs DNS personnalisés
Paramètres Proxy Système - Routage du trafic via des proxys de filtrage
Règles de Pare-feu - Blocage d'adresses IP et de plages de ports spécifiques

Blocage de Sites Web Basique

Bloquer un Site Web Unique

#!/bin/bash

# Bloquer l'accès à un site web spécifique
WEBSITE="www.facebook.com"

# Ajouter une entrée au fichier hosts
echo "127.0.0.1 $WEBSITE" >> /etc/hosts
echo "127.0.0.1 facebook.com" >> /etc/hosts

echo "Accès bloqué à $WEBSITE"

Bloquer Plusieurs Sites Web

#!/bin/bash

# Bloquer plusieurs sites web à la fois
BLOCKED_SITES=(
    "www.facebook.com"
    "facebook.com" 
    "m.facebook.com"
    "www.twitter.com"
    "twitter.com"
    "www.instagram.com"
    "instagram.com"
)

for site in "${BLOCKED_SITES[@]}"; do
    echo "127.0.0.1 $site" >> /etc/hosts
    echo "Bloqué: $site"
done

echo "Blocage de sites web terminé"

Déblocage de Sites Web Basique

Débloquer un Site Web Unique

#!/bin/bash

# Supprimer un site web du fichier hosts
WEBSITE="www.facebook.com"

/usr/bin/sed -i "" "/127.0.0.1 $WEBSITE/d" /etc/hosts
/usr/bin/sed -i "" "/127.0.0.1 facebook.com/d" /etc/hosts

echo "Accès débloqué à $WEBSITE"

Débloquer Tous les Sites Web

#!/bin/bash

# Supprimer toutes les entrées de blocage du fichier hosts
/usr/bin/sed -i "" '/^127.0.0.1.*[^localhost]/d' /etc/hosts

echo "Tous les blocages de sites web supprimés"

Système de Contrôle d'Accès Web d'Entreprise

#!/bin/bash

# Contrôle d'Accès Web d'Entreprise MacFleet
# Système complet de filtrage web et de gestion de politiques

# Configuration
MACFLEET_DIR="/etc/macfleet"
POLICIES_DIR="$MACFLEET_DIR/web_policies"
REPORTS_DIR="$MACFLEET_DIR/reports"
COMPLIANCE_DIR="$MACFLEET_DIR/compliance"
AUDIT_DIR="$MACFLEET_DIR/audit"
LOG_FILE="/var/log/macfleet_web_access.log"
BACKUP_DIR="$MACFLEET_DIR/backups"

# Créer la structure de répertoires
create_directories() {
    local dirs=("$MACFLEET_DIR" "$POLICIES_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR" "$BACKUP_DIR")
    for dir in "${dirs[@]}"; do
        [[ ! -d "$dir" ]] && mkdir -p "$dir"
    done
}

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

# Sauvegarder le fichier hosts
backup_hosts() {
    local backup_file="$BACKUP_DIR/hosts_backup_$(date +%Y%m%d_%H%M%S)"
    cp /etc/hosts "$backup_file"
    log_action "Fichier hosts sauvegardé vers: $backup_file"
}

# Catégories de Sites Web pour le Filtrage d'Entreprise
declare -A WEBSITE_CATEGORIES=(
    ["reseaux_sociaux"]="facebook.com,twitter.com,instagram.com,linkedin.com,snapchat.com,tiktok.com,pinterest.com"
    ["divertissement"]="youtube.com,netflix.com,hulu.com,twitch.tv,spotify.com,reddit.com"
    ["jeux"]="steam.com,epic.com,roblox.com,minecraft.net,ea.com,ubisoft.com"
    ["shopping"]="amazon.com,ebay.com,etsy.com,shopify.com,aliexpress.com"
    ["actualites"]="cnn.com,bbc.com,reuters.com,bloomberg.com,wsj.com"
    ["contenu_adulte"]="example.com"
    ["malveillant"]="malware.com,phishing-site.com,trojan-host.com"
)

# Politiques de Sécurité
declare -A SECURITY_POLICIES=(
    ["securite_elevee"]="reseaux_sociaux,divertissement,jeux,shopping,contenu_adulte,malveillant"
    ["securite_moderee"]="contenu_adulte,malveillant,jeux"
    ["securite_minimale"]="contenu_adulte,malveillant"
    ["equipe_developpement"]="malveillant"
    ["acces_executif"]="malveillant"
)

# Bloquer des sites web par catégorie
block_category() {
    local category="$1"
    local policy="$2"
    
    if [[ -z "${WEBSITE_CATEGORIES[$category]}" ]]; then
        log_action "ERREUR: Catégorie inconnue: $category"
        return 1
    fi
    
    log_action "Blocage de la catégorie: $category (Politique: $policy)"
    
    # Diviser les domaines séparés par des virgules
    IFS=',' read -ra domains <<< "${WEBSITE_CATEGORIES[$category]}"
    
    for domain in "${domains[@]}"; do
        # Ajouter plusieurs variations
        echo "127.0.0.1 $domain" >> /etc/hosts
        echo "127.0.0.1 www.$domain" >> /etc/hosts
        echo "127.0.0.1 m.$domain" >> /etc/hosts
        echo "127.0.0.1 mobile.$domain" >> /etc/hosts
        
        log_action "Domaine bloqué: $domain"
    done
    
    # Sauvegarder les métadonnées de politique
    echo "category=$category,policy=$policy,timestamp=$(date),user=$(whoami)" >> "$POLICIES_DIR/applied_blocks.log"
}

# Appliquer une politique de sécurité
apply_security_policy() {
    local policy="$1"
    
    if [[ -z "${SECURITY_POLICIES[$policy]}" ]]; then
        log_action "ERREUR: Politique de sécurité inconnue: $policy"
        return 1
    fi
    
    log_action "Application de la politique de sécurité: $policy"
    backup_hosts
    
    # Effacer les blocages existants
    /usr/bin/sed -i "" '/^127.0.0.1.*[^localhost]/d' /etc/hosts
    
    # Appliquer les catégories pour cette politique
    IFS=',' read -ra categories <<< "${SECURITY_POLICIES[$policy]}"
    
    for category in "${categories[@]}"; do
        block_category "$category" "$policy"
    done
    
    # Vider le cache DNS
    dscacheutil -flushcache
    killall -HUP mDNSResponder
    
    log_action "Politique de sécurité '$policy' appliquée avec succès"
    
    # Générer un rapport de conformité
    generate_compliance_report "$policy"
}

# Filtrage DNS avancé
configure_dns_filtering() {
    local filter_level="$1"
    
    log_action "Configuration du filtrage DNS: $filter_level"
    
    case "$filter_level" in
        "entreprise")
            # Utiliser des serveurs DNS d'entreprise avec filtrage
            networksetup -setdnsservers "Wi-Fi" 208.67.222.222 208.67.220.220
            networksetup -setdnsservers "Ethernet" 208.67.222.222 208.67.220.220
            ;;
        "securite_familiale")
            # Utiliser un DNS sécurisé pour la famille
            networksetup -setdnsservers "Wi-Fi" 208.67.222.123 208.67.220.123
            networksetup -setdnsservers "Ethernet" 208.67.222.123 208.67.220.123
            ;;
        "securise")
            # Utiliser un DNS axé sur la sécurité
            networksetup -setdnsservers "Wi-Fi" 1.1.1.2 1.0.0.2
            networksetup -setdnsservers "Ethernet" 1.1.1.2 1.0.0.2
            ;;
        "defaut")
            # Réinitialiser au DNS automatique
            networksetup -setdnsservers "Wi-Fi" "Empty"
            networksetup -setdnsservers "Ethernet" "Empty"
            ;;
    esac
    
    log_action "Filtrage DNS configuré: $filter_level"
}

# Gestion de liste blanche pour les sites d'affaires essentiels
manage_whitelist() {
    local action="$1"
    local domain="$2"
    local whitelist_file="$POLICIES_DIR/business_whitelist.txt"
    
    case "$action" in
        "ajouter")
            if ! grep -q "^$domain$" "$whitelist_file" 2>/dev/null; then
                echo "$domain" >> "$whitelist_file"
                # Supprimer du fichier hosts si bloqué
                /usr/bin/sed -i "" "/127.0.0.1.*$domain/d" /etc/hosts
                log_action "Ajouté à la liste blanche: $domain"
            else
                log_action "Domaine déjà en liste blanche: $domain"
            fi
            ;;
        "supprimer")
            if [[ -f "$whitelist_file" ]]; then
                /usr/bin/sed -i "" "/^$domain$/d" "$whitelist_file"
                log_action "Supprimé de la liste blanche: $domain"
            fi
            ;;
        "lister")
            if [[ -f "$whitelist_file" ]]; then
                echo "Liste Blanche d'Affaires:"
                cat "$whitelist_file"
            else
                echo "Aucune liste blanche trouvée"
            fi
            ;;
    esac
}

# Mode d'accès d'urgence
emergency_access() {
    local action="$1"
    local emergency_file="$POLICIES_DIR/emergency_mode.flag"
    
    case "$action" in
        "activer")
            # Sauvegarder les hosts actuels et effacer tous les blocages
            backup_hosts
            cp /etc/hosts "$BACKUP_DIR/hosts_before_emergency"
            /usr/bin/sed -i "" '/^127.0.0.1.*[^localhost]/d' /etc/hosts
            touch "$emergency_file"
            echo "emergency_enabled=$(date)" > "$emergency_file"
            log_action "ACCÈS D'URGENCE ACTIVÉ - Tous les blocages de sites web supprimés"
            ;;
        "desactiver")
            if [[ -f "$emergency_file" ]]; then
                rm "$emergency_file"
                # Restaurer la configuration précédente si disponible
                if [[ -f "$BACKUP_DIR/hosts_before_emergency" ]]; then
                    cp "$BACKUP_DIR/hosts_before_emergency" /etc/hosts
                    log_action "Accès d'urgence désactivé - Configuration précédente restaurée"
                else
                    log_action "Accès d'urgence désactivé - Reconfiguration manuelle requise"
                fi
            else
                log_action "L'accès d'urgence n'est pas actuellement activé"
            fi
            ;;
        "statut")
            if [[ -f "$emergency_file" ]]; then
                echo "Accès d'urgence: ACTIVÉ"
                cat "$emergency_file"
            else
                echo "Accès d'urgence: DÉSACTIVÉ"
            fi
            ;;
    esac
}

# Générer un rapport de conformité complet
generate_compliance_report() {
    local policy="$1"
    local report_file="$REPORTS_DIR/web_access_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    local blocked_domains=$(grep -c "^127.0.0.1" /etc/hosts 2>/dev/null || echo "0")
    local whitelist_count=0
    [[ -f "$POLICIES_DIR/business_whitelist.txt" ]] && whitelist_count=$(wc -l < "$POLICIES_DIR/business_whitelist.txt")
    
    cat > "$report_file" << EOF
{
  "metadonnees_rapport": {
    "horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "nom_hote": "$(hostname)",
    "politique_appliquee": "$policy",
    "version_rapport": "1.0"
  },
  "controle_acces_web": {
    "nombre_domaines_bloques": $blocked_domains,
    "nombre_domaines_liste_blanche": $whitelist_count,
    "filtrage_dns_actif": $(networksetup -getdnsservers Wi-Fi | grep -q "208.67" && echo "true" || echo "false"),
    "mode_urgence": $([ -f "$POLICIES_DIR/emergency_mode.flag" ] && echo "true" || echo "false")
  },
  "politique_securite": {
    "nom": "$policy",
    "categories_bloquees": "$(echo "${SECURITY_POLICIES[$policy]}" | tr ',' ' ')",
    "cadres_conformite": ["SOX", "HIPAA", "NIST", "ISO27001"]
  },
  "statut_systeme": {
    "taille_fichier_hosts": $(wc -l < /etc/hosts),
    "derniere_vidange_dns": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "sauvegarde_disponible": $([ -d "$BACKUP_DIR" ] && [ "$(ls -1 "$BACKUP_DIR"/hosts_backup_* 2>/dev/null | wc -l)" -gt 0 ] && echo "true" || echo "false")
  }
}
EOF
    
    log_action "Rapport de conformité généré: $report_file"
    echo "Rapport sauvegardé vers: $report_file"
}

# Vérification de santé et validation
perform_health_check() {
    echo "=== Vérification de Santé du Contrôle d'Accès Web MacFleet ==="
    
    # Vérifier l'intégrité du fichier hosts
    if [[ -f "/etc/hosts" ]]; then
        echo "✓ Le fichier hosts existe"
        local hosts_size=$(wc -l < /etc/hosts)
        echo "  - Lignes: $hosts_size"
    else
        echo "✗ Fichier hosts manquant"
    fi
    
    # Vérifier les domaines bloqués
    local blocked_count=$(grep -c "^127.0.0.1" /etc/hosts 2>/dev/null || echo "0")
    echo "✓ Domaines bloqués: $blocked_count"
    
    # Vérifier la configuration DNS
    local dns_servers=$(networksetup -getdnsservers Wi-Fi)
    echo "✓ Serveurs DNS: $dns_servers"
    
    # Vérifier la liste blanche
    if [[ -f "$POLICIES_DIR/business_whitelist.txt" ]]; then
        local whitelist_count=$(wc -l < "$POLICIES_DIR/business_whitelist.txt")
        echo "✓ Domaines en liste blanche: $whitelist_count"
    else
        echo "○ Aucune liste blanche configurée"
    fi
    
    # Vérifier le mode d'urgence
    if [[ -f "$POLICIES_DIR/emergency_mode.flag" ]]; then
        echo "⚠️  Mode d'urgence: ACTIF"
    else
        echo "✓ Mode d'urgence: INACTIF"
    fi
    
    # Vérifier l'activité récente
    if [[ -f "$LOG_FILE" ]]; then
        local recent_entries=$(tail -5 "$LOG_FILE" | wc -l)
        echo "✓ Entrées de journal récentes: $recent_entries"
    fi
}

# Fonction de déploiement de flotte
deploy_to_fleet() {
    local policy="$1"
    local fleet_file="$2"
    
    if [[ ! -f "$fleet_file" ]]; then
        log_action "ERREUR: Fichier de flotte non trouvé: $fleet_file"
        return 1
    fi
    
    log_action "Début du déploiement de flotte de la politique: $policy"
    
    while IFS= read -r host; do
        [[ -z "$host" || "$host" =~ ^#.*$ ]] && continue
        
        echo "Déploiement vers: $host"
        
        # Copier ce script vers l'hôte distant et l'exécuter
        ssh "$host" "bash -s" << EOF
#!/bin/bash
# Déploiement distant de la politique d'accès web: $policy

# Créer les répertoires
mkdir -p /etc/macfleet/{web_policies,reports,compliance,audit,backups}

# Appliquer la politique (simplifié pour l'exécution distante)
$(declare -p WEBSITE_CATEGORIES)
$(declare -p SECURITY_POLICIES)
$(type apply_security_policy | sed '1d')

apply_security_policy "$policy"
EOF
        
        if [[ $? -eq 0 ]]; then
            log_action "Déploiement réussi vers: $host"
        else
            log_action "Échec du déploiement vers: $host"
        fi
        
    done < "$fleet_file"
    
    log_action "Déploiement de flotte terminé"
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "appliquer_politique")
            apply_security_policy "$2"
            ;;
        "bloquer_categorie")
            backup_hosts
            block_category "$2" "manuel"
            ;;
        "configurer_dns")
            configure_dns_filtering "$2"
            ;;
        "liste_blanche")
            manage_whitelist "$2" "$3"
            ;;
        "urgence")
            emergency_access "$2"
            ;;
        "verification_sante")
            perform_health_check
            ;;
        "rapport")
            generate_compliance_report "${2:-manuel}"
            ;;
        "deployer")
            deploy_to_fleet "$2" "$3"
            ;;
        "aide"|*)
            echo "Système de Contrôle d'Accès Web MacFleet"
            echo ""
            echo "Usage: $0 <commande> [options]"
            echo ""
            echo "Commandes:"
            echo "  appliquer_politique <politique>     - Appliquer une politique de sécurité (securite_elevee|securite_moderee|securite_minimale|equipe_developpement|acces_executif)"
            echo "  bloquer_categorie <categorie>       - Bloquer une catégorie de sites web (reseaux_sociaux|divertissement|jeux|shopping|actualites|contenu_adulte|malveillant)"
            echo "  configurer_dns <niveau>             - Configurer le filtrage DNS (entreprise|securite_familiale|securise|defaut)"
            echo "  liste_blanche <action> <domaine>    - Gérer la liste blanche (ajouter|supprimer|lister)"
            echo "  urgence <action>                    - Contrôle d'accès d'urgence (activer|desactiver|statut)"
            echo "  verification_sante                  - Effectuer une vérification de santé du système"
            echo "  rapport [politique]                 - Générer un rapport de conformité"
            echo "  deployer <politique> <fichier_flotte> - Déployer une politique vers la flotte"
            echo ""
            echo "Exemples:"
            echo "  $0 appliquer_politique securite_elevee"
            echo "  $0 liste_blanche ajouter salesforce.com"
            echo "  $0 urgence activer"
            echo "  $0 verification_sante"
            ;;
    esac
}

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

## Heures d'Affaires et Contrôles Conviviaux

### Contrôle d'Accès Basé sur l'Heure

```bash
#!/bin/bash

# Appliquer différentes politiques selon les heures d'affaires
apply_time_based_policy() {
    local current_hour=$(date +%H)
    local day_of_week=$(date +%u)
    
    # Heures d'affaires: Lundi-Vendredi 9h - 18h
    if [[ $day_of_week -le 5 ]] && [[ $current_hour -ge 9 ]] && [[ $current_hour -lt 18 ]]; then
        echo "Heures d'affaires détectées - application de la politique stricte"
        apply_security_policy "securite_elevee"
    else
        echo "En dehors des heures d'affaires - application de la politique assouplie"
        apply_security_policy "securite_moderee"
    fi
}

Système de Notification Utilisateur

#!/bin/bash

# Notifier l'utilisateur des changements d'accès aux sites web
notify_user() {
    local message="$1"
    local title="Accès Web MacFleet"
    
    # Utiliser osascript pour la notification utilisateur
    osascript -e "display notification \"$message\" with title \"$title\" sound name \"Glass\""
    
    # Aussi enregistrer dans le système
    log_action "Notification utilisateur: $message"
}

# Exemple d'utilisation
notify_user "Politique d'accès aux sites web mise à jour en mode Haute Sécurité"

Considérations de Sécurité Importantes

Les permissions du fichier hosts doivent être restreintes pour empêcher les modifications non autorisées
Le filtrage DNS fournit une protection au niveau réseau au-delà du fichier hosts local
Les procédures d'accès d'urgence doivent être documentées et testées
Les sauvegardes régulières du fichier hosts et de la configuration sont essentielles
La journalisation d'audit aide à suivre les changements de politique et la conformité

Conformité et Rapports

Le système d'entreprise génère des rapports complets pour :

Conformité SOX - Contrôles d'accès web des services financiers
Exigences HIPAA - Politiques de protection des données de santé
Cadre NIST - Alignement sur les normes de cybersécurité
ISO 27001 - Gestion de la sécurité de l'information

Tests et Validation

Avant le déploiement en production :

Tester les commandes individuelles sur des systèmes isolés
Vérifier la résolution DNS après application des politiques
Confirmer que les applications d'affaires restent accessibles
Tester les procédures d'urgence et la restauration
Valider la précision des rapports de conformité

Ce système complet transforme le blocage de sites web basique en une plateforme de contrôle d'accès de niveau entreprise avec gestion avancée de politiques, rapports de conformité et capacités de déploiement de flotte.

Guide

Avis important

Comprendre la Gestion de l'Historique de Connexion macOS

Commandes de Base de l'Historique de Connexion

Historique de Connexion Bref avec who

Historique de Connexion Détaillé avec last

Vérifier l'Historique de Connexion d'un Utilisateur Spécifique

Analyse Avancée de l'Historique de Connexion

Analyse Complète des Sessions Utilisateur

Découverte des Comptes Utilisateur

Système de Gestion de l'Historique de Connexion d'Entreprise

Fonctions de Gestion Rapide

Vérification Simple du Statut de Connexion

Résumé de Connexion Utilisateur

Fonctions de Surveillance de Sécurité

Détection de Connexions Échouées

Analyse de Durée de Session

Configuration et Conformité

Configuration de Politique de Connexion

Rapport de Conformité

Notes Techniques Importantes

Détails des Commandes

Emplacements des Fichiers de Journal

Considérations de Sécurité

Meilleures Pratiques

Guide

Comprendre la Gestion Réseau macOS

Opérations Wi-Fi Basiques

Activer/Désactiver l'Interface Wi-Fi

Activer/Désactiver le Service Wi-Fi

Informations Réseau Wi-Fi

Obtenir les Informations Réseau Actuelles

Système de Gestion Wi-Fi d'Entreprise

Configuration Réseau Avancée

Gestion de Profils Wi-Fi d'Entreprise

Surveillance de Qualité Réseau

Sécurité et Conformité

Audit de Sécurité Réseau

Application de Politiques de Conformité

Dépannage Réseau

Réparation Réseau Automatisée

Meilleures Pratiques

🚀 Optimisation des Performances

🔐 Directives de Sécurité

📋 Meilleures Pratiques de Gestion

🔍 Conseils de Dépannage

Notes Importantes

Comprendre la Gestion Wi-Fi macOS

Commandes de Contrôle Wi-Fi de Base

Désactiver le Wi-Fi

Activer le Wi-Fi

Vérifier le Statut Wi-Fi

Système de Contrôle Wi-Fi d'Entreprise

Modèles de Politiques Wi-Fi

Configuration de Politique Wi-Fi d'Entreprise

Politique Wi-Fi Axée Sécurité

Fonctions de Sécurité et Conformité

Gestion de Liste Blanche de Réseaux

Notes Techniques Importantes

Référence des Commandes NetworkSetup

Considérations de Sécurité

Meilleures Pratiques de Gestion de l'Alimentation

Cas d'Usage d'Entreprise

Comprendre les Méthodes de Contrôle d'Accès aux Sites Web

Blocage de Sites Web Basique

Bloquer un Site Web Unique

Bloquer Plusieurs Sites Web

Déblocage de Sites Web Basique

Débloquer un Site Web Unique

Débloquer Tous les Sites Web

Système de Contrôle d'Accès Web d'Entreprise

Système de Notification Utilisateur

Considérations de Sécurité Importantes

Conformité et Rapports

Tests et Validation

Historique de Connexion Bref avec `who`

Historique de Connexion Détaillé avec `last`