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

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 :

1. Tester les commandes individuelles sur des systèmes isolés
2. Vérifier la résolution DNS après application des politiques
3. Confirmer que les applications d'affaires restent accessibles
4. Tester les procédures d'urgence et la restauration
5. 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.

Implémentez une gestion complète des privilèges utilisateur et la conformité sécuritaire sur vos appareils MacFleet. Ce tutoriel couvre la vérification d'accès administrateur, la surveillance d'escalade de privilèges, le contrôle d'accès basé sur les rôles (RBAC), l'application de politiques de sécurité et les cadres de conformité automatisés pour les environnements d'entreprise.

Comprendre le Système de Privilèges macOS

macOS utilise un système de privilèges en couches pour la sécurité et le contrôle d'accès :

• Utilisateurs Standard - Accès système de base avec capacités administratives limitées
• Utilisateurs Administrateur - Accès système complet et capacité de modifier les paramètres système
• Utilisateur Root - Superutilisateur avec accès système sans restriction (généralement désactivé)
• Comptes de Service - Comptes système pour exécuter des services et démons
• Appartenance aux Groupes - Privilèges supplémentaires via les affectations de groupes

Vérification Basique d'Administrateur

Vérifier le Statut Admin d'un Utilisateur Individuel

#!/bin/bash

# Vérifier si un utilisateur spécifique a les privilèges administrateur
check_user_admin_status() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "❌ Nom d'utilisateur requis"
        return 1
    fi
    
    echo "=== Vérification du Statut Admin pour l'Utilisateur: $username ==="
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read "/Users/$username" &>/dev/null; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Vérifier l'appartenance au groupe admin
    if groups "$username" | grep -q -w admin; then
        echo "✅ L'utilisateur '$username' EST un administrateur"
        return 0
    else
        echo "ℹ️  L'utilisateur '$username' n'est PAS un administrateur"
        return 1
    fi
}

# Exemple d'utilisation
# check_user_admin_status "testuser"

Lister Tous les Utilisateurs Administrateur

#!/bin/bash

# Obtenir la liste de tous les utilisateurs administrateur
list_admin_users() {
    echo "=== Liste des Utilisateurs Administrateur ==="
    
    # Obtenir les membres du groupe admin
    local admin_users
    admin_users=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | cut -d: -f2)
    
    if [[ -z "$admin_users" ]]; then
        echo "⚠️  Aucun utilisateur administrateur trouvé"
        return 1
    fi
    
    echo "Utilisateurs administrateur:"
    for user in $admin_users; do
        # Vérifier que l'utilisateur existe encore et obtenir des informations supplémentaires
        if dscl . -read "/Users/$user" &>/dev/null; then
            local real_name
            real_name=$(dscl . -read "/Users/$user" RealName 2>/dev/null | cut -d: -f2 | xargs)
            local uid
            uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | cut -d: -f2 | xargs)
            
            echo "  👤 $user (UID: $uid) - $real_name"
        else
            echo "  ⚠️  $user (Compte utilisateur non trouvé)"
        fi
    done
    
    return 0
}

# Exécuter la fonction
list_admin_users

Système de Gestion des Privilèges Utilisateur d'Entreprise

#!/bin/bash

# Système de Gestion des Privilèges Utilisateur d'Entreprise MacFleet
# Contrôle d'accès complet, conformité sécuritaire et surveillance des privilèges

# Configuration
LOG_FILE="/var/log/macfleet_user_privileges.log"
CONFIG_DIR="/etc/macfleet/user_management"
POLICIES_DIR="$CONFIG_DIR/policies"
REPORTS_DIR="$CONFIG_DIR/reports"
COMPLIANCE_DIR="$CONFIG_DIR/compliance"
AUDIT_DIR="$CONFIG_DIR/audit"

# Cadres de conformité sécuritaire
declare -A COMPLIANCE_FRAMEWORKS=(
    ["nist"]="least_privilege,separation_duties,access_review,audit_trails"
    ["iso27001"]="access_control,privilege_management,monitoring,documentation"
    ["cis"]="admin_minimization,privilege_escalation_monitoring,account_lifecycle"
    ["sox"]="financial_access_control,privilege_separation,audit_requirements"
    ["hipaa"]="minimum_necessary,access_controls,audit_logs,sanctions"
    ["pci_dss"]="unique_ids,access_control,privilege_limitation,monitoring"
)

# Définitions des rôles utilisateur
declare -A USER_ROLES=(
    ["standard"]="basic_access,file_management,application_usage"
    ["power_user"]="advanced_settings,software_installation,system_preferences"
    ["developer"]="development_tools,system_debugging,certificate_management"
    ["administrator"]="full_system_access,user_management,security_settings"
    ["security_admin"]="security_policies,audit_access,compliance_management"
    ["service_account"]="automated_processes,background_services,api_access"
)

# Modèles d'escalade de privilèges
declare -A ESCALATION_PATTERNS=(
    ["sudo_abuse"]="excessive_sudo_usage,sudo_without_password,sudo_all_commands"
    ["group_manipulation"]="unauthorized_group_addition,privilege_group_access"
    ["file_permissions"]="setuid_modifications,sensitive_file_access,system_file_changes"
    ["service_abuse"]="service_account_usage,daemon_manipulation,system_service_access"
)

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

# Configuration des répertoires
setup_directories() {
    for dir in "$CONFIG_DIR" "$POLICIES_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir"
            log_action "Répertoire créé: $dir"
        fi
    done
}

# Obtenir des informations complètes sur l'utilisateur
get_user_details() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! dscl . -read "/Users/$username" &>/dev/null; then
        return 1
    fi
    
    local user_info="{}"
    
    # Informations de base sur l'utilisateur
    local uid
    uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
    local gid
    gid=$(dscl . -read "/Users/$username" PrimaryGroupID 2>/dev/null | awk '{print $2}')
    local real_name
    real_name=$(dscl . -read "/Users/$username" RealName 2>/dev/null | cut -d: -f2- | xargs)
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    local shell
    shell=$(dscl . -read "/Users/$username" UserShell 2>/dev/null | awk '{print $2}')
    
    # Appartenances aux groupes
    local groups_list
    groups_list=$(groups "$username" 2>/dev/null | cut -d: -f2)
    
    # Vérifier le statut admin
    local is_admin="false"
    if groups "$username" | grep -q -w admin; then
        is_admin="true"
    fi
    
    # Informations de dernière connexion
    local last_login
    last_login=$(last -1 "$username" 2>/dev/null | head -1 | awk '{print $4, $5, $6, $7}' || echo "Jamais")
    
    # Permissions du répertoire home
    local home_permissions=""
    if [[ -d "$home_dir" ]]; then
        home_permissions=$(ls -ld "$home_dir" | awk '{print $1}')
    fi
    
    # Informations sur les clés SSH
    local ssh_keys_count=0
    if [[ -d "$home_dir/.ssh" ]]; then
        ssh_keys_count=$(find "$home_dir/.ssh" -name "*.pub" 2>/dev/null | wc -l | xargs)
    fi
    
    user_info=$(cat << EOF
{
    "username": "$username",
    "uid": $uid,
    "gid": $gid,
    "real_name": "$real_name",
    "home_directory": "$home_dir",
    "shell": "$shell",
    "is_administrator": $is_admin,
    "groups": "$(echo $groups_list | sed 's/ /,/g')",
    "last_login": "$last_login",
    "home_permissions": "$home_permissions",
    "ssh_keys_count": $ssh_keys_count
}
EOF
)
    
    echo "$user_info"
}

# Audit complet des privilèges
audit_user_privileges() {
    log_action "Démarrage de l'audit complet des privilèges utilisateur"
    
    local audit_report="$REPORTS_DIR/privilege_audit_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$audit_report" << EOF
{
    "audit_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "os_version": "$(sw_vers -productVersion)",
        "generator": "MacFleet User Privilege Manager"
    },
    "system_users": [
EOF

    local first=true
    local total_users=0
    local admin_users=0
    local standard_users=0
    local service_accounts=0
    
    # Obtenir tous les utilisateurs avec UID >= 500 (utilisateurs réguliers) et comptes système
    while IFS= read -r user; do
        local uid
        uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | awk '{print $2}')
        
        if [[ -n "$uid" ]]; then
            total_users=$((total_users + 1))
            
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$audit_report"
            fi
            
            local user_details
            user_details=$(get_user_details "$user")
            
            # Catégoriser le type d'utilisateur
            if [[ $uid -lt 500 ]]; then
                service_accounts=$((service_accounts + 1))
            elif echo "$user_details" | jq -r '.is_administrator' | grep -q "true"; then
                admin_users=$((admin_users + 1))
            else
                standard_users=$((standard_users + 1))
            fi
            
            # Ajouter l'évaluation du risque de privilège
            local risk_score
            risk_score=$(assess_privilege_risk "$user")
            
            # Ajouter le statut de conformité sécuritaire
            local compliance_status
            compliance_status=$(assess_user_compliance "$user")
            
            local enhanced_details
            enhanced_details=$(echo "$user_details" | jq ". + {\"privilege_risk_score\": $risk_score, \"compliance_status\": $compliance_status}")
            
            echo "        $enhanced_details" >> "$audit_report"
            
            log_action "Utilisateur audité: $user (UID: $uid)"
        fi
    done < <(dscl . list /Users | grep -v "^_")
    
    cat >> "$audit_report" << EOF
    ],
    "summary": {
        "total_users": $total_users,
        "administrator_users": $admin_users,
        "standard_users": $standard_users,
        "service_accounts": $service_accounts,
        "admin_percentage": $(awk "BEGIN {printf \"%.1f\", ($admin_users/$total_users)*100}")
    },
    "security_recommendations": $(generate_security_recommendations)
}
EOF

    log_action "✅ Audit des privilèges utilisateur terminé: $audit_report"
    echo "$audit_report"
}

# Évaluer le risque de privilège pour un utilisateur
assess_privilege_risk() {
    local username="$1"
    local risk_score=0
    
    # Vérifier si l'utilisateur est admin (risque élevé)
    if groups "$username" | grep -q -w admin; then
        risk_score=$((risk_score + 5))
    fi
    
    # Vérifier les appartenances excessives aux groupes
    local group_count
    group_count=$(groups "$username" | tr ' ' '\n' | wc -l)
    if [[ $group_count -gt 5 ]]; then
        risk_score=$((risk_score + 2))
    fi
    
    # Vérifier les modèles d'utilisation de sudo
    local sudo_entries
    sudo_entries=$(grep "sudo.*$username" /var/log/auth.log 2>/dev/null | wc -l || echo 0)
    if [[ $sudo_entries -gt 50 ]]; then
        risk_score=$((risk_score + 3))
    elif [[ $sudo_entries -gt 10 ]]; then
        risk_score=$((risk_score + 1))
    fi
    
    # Vérifier les clés SSH (mouvement latéral potentiel)
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    if [[ -d "$home_dir/.ssh" ]]; then
        local key_count
        key_count=$(find "$home_dir/.ssh" -name "*.pub" 2>/dev/null | wc -l)
        if [[ $key_count -gt 3 ]]; then
            risk_score=$((risk_score + 2))
        fi
    fi
    
    # Vérifier les modèles de compte de service
    if [[ "$username" =~ ^(service|daemon|app).*$ ]]; then
        risk_score=$((risk_score + 1))
    fi
    
    # Plafonner à 10
    if [[ $risk_score -gt 10 ]]; then
        risk_score=10
    fi
    
    echo "$risk_score"
}

# Évaluer la conformité utilisateur avec les cadres de sécurité
assess_user_compliance() {
    local username="$1"
    
    local compliance_issues=0
    local total_checks=4
    
    # Vérification 1: Principe du moindre privilège
    if groups "$username" | grep -q -w admin; then
        # Les utilisateurs admin ont besoin de justification
        if [[ ! -f "$POLICIES_DIR/admin_justification_$username.conf" ]]; then
            compliance_issues=$((compliance_issues + 1))
        fi
    fi
    
    # Vérification 2: Activité du compte
    local last_login
    last_login=$(last -1 "$username" | head -1 | awk '{print $4}' | grep -v "^$")
    if [[ -z "$last_login" || "$last_login" == "Jamais" ]]; then
        compliance_issues=$((compliance_issues + 1))
    fi
    
    # Vérification 3: Permissions du répertoire home
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    if [[ -d "$home_dir" ]]; then
        local perms
        perms=$(ls -ld "$home_dir" | cut -c1-10)
        if [[ "$perms" =~ ^d.......w.$ ]] || [[ "$perms" =~ ^d........w$ ]]; then
            compliance_issues=$((compliance_issues + 1))
        fi
    fi
    
    # Vérification 4: Conformité à la politique de mot de passe
    local password_policy_compliant="true"
    # Ceci s'intégrerait typiquement avec la vérification de politique de mot de passe
    # Pour la démonstration, nous assumons la conformité
    
    local compliance_score
    compliance_score=$(awk "BEGIN {printf \"%.0f\", (($total_checks - $compliance_issues)/$total_checks)*100}")
    
    local status="conforme"
    if [[ $compliance_score -lt 80 ]]; then
        status="non_conforme"
    elif [[ $compliance_score -lt 90 ]]; then
        status="necessite_attention"
    fi
    
    echo "{\"score\": $compliance_score, \"status\": \"$status\", \"issues\": $compliance_issues}"
}

# Surveiller les tentatives d'escalade de privilèges
monitor_privilege_escalation() {
    log_action "Démarrage de la surveillance d'escalade de privilèges"
    
    local monitoring_report="$AUDIT_DIR/privilege_escalation_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$monitoring_report" << EOF
{
    "monitoring_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "monitoring_period": "last_24_hours"
    },
    "escalation_events": [
EOF

    local first=true
    local event_count=0
    
    # Surveiller l'utilisation de sudo
    if [[ -f "/var/log/auth.log" ]]; then
        local sudo_events
        sudo_events=$(grep "sudo" /var/log/auth.log | tail -50)
        
        while IFS= read -r line; do
            if [[ -n "$line" ]]; then
                if [[ "$first" == true ]]; then
                    first=false
                else
                    echo "," >> "$monitoring_report"
                fi
                
                local timestamp
                timestamp=$(echo "$line" | awk '{print $1, $2, $3}')
                local user
                user=$(echo "$line" | grep -o "USER=[^ ]*" | cut -d= -f2)
                local command
                command=$(echo "$line" | grep -o "COMMAND=.*" | cut -d= -f2-)
                
                cat >> "$monitoring_report" << EOF
        {
            "type": "sudo_usage",
            "timestamp": "$timestamp",
            "user": "$user",
            "command": "$command",
            "risk_level": "$(assess_command_risk "$command")"
        }
EOF
                event_count=$((event_count + 1))
            fi
        done <<< "$sudo_events"
    fi
    
    # Surveiller les changements d'appartenance aux groupes
    local group_changes
    group_changes=$(grep "group" /var/log/system.log 2>/dev/null | grep -E "(add|remove)" | tail -10)
    
    while IFS= read -r line; do
        if [[ -n "$line" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$monitoring_report"
            fi
            
            cat >> "$monitoring_report" << EOF
        {
            "type": "group_change",
            "event": "$line",
            "risk_level": "moyen"
        }
EOF
            event_count=$((event_count + 1))
        fi
    done <<< "$group_changes"
    
    cat >> "$monitoring_report" << EOF
    ],
    "summary": {
        "total_events": $event_count,
        "high_risk_events": $(grep -c '"risk_level": "eleve"' "$monitoring_report" 2>/dev/null || echo 0),
        "medium_risk_events": $(grep -c '"risk_level": "moyen"' "$monitoring_report" 2>/dev/null || echo 0)
    }
}
EOF

    log_action "✅ Surveillance d'escalade de privilèges terminée: $monitoring_report"
    echo "$monitoring_report"
}

# Évaluer le niveau de risque des commandes
assess_command_risk() {
    local command="$1"
    
    # Commandes à haut risque
    if echo "$command" | grep -qE "(rm -rf|chmod 777|chown root|passwd|visudo|su -|sudo su)"; then
        echo "eleve"
    # Commandes à risque moyen
    elif echo "$command" | grep -qE "(install|update|systemctl|launchctl|diskutil)"; then
        echo "moyen"
    # Commandes à faible risque
    else
        echo "faible"
    fi
}

# Appliquer les politiques de sécurité
apply_security_policy() {
    local policy_name="$1"
    local target_users="$2"
    
    log_action "Application de la politique de sécurité: $policy_name"
    
    # Obtenir les utilisateurs cibles
    local users=()
    if [[ -n "$target_users" ]]; then
        IFS=',' read -ra users <<< "$target_users"
    else
        # Appliquer à tous les utilisateurs non-système
        while IFS= read -r user; do
            local uid
            uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | awk '{print $2}')
            if [[ $uid -ge 500 ]]; then
                users+=("$user")
            fi
        done < <(dscl . list /Users | grep -v "^_")
    fi
    
    for user in "${users[@]}"; do
        case "$policy_name" in
            "least_privilege")
                enforce_least_privilege "$user"
                ;;
            "admin_review")
                review_admin_privileges "$user"
                ;;
            "password_policy")
                enforce_password_policy "$user"
                ;;
            "session_limits")
                configure_session_limits "$user"
                ;;
            *)
                log_action "⚠️  Politique inconnue: $policy_name"
                ;;
        esac
    done
    
    log_action "✅ Politique de sécurité '$policy_name' appliquée"
}

# Appliquer le principe du moindre privilège
enforce_least_privilege() {
    local username="$1"
    
    log_action "Application du moindre privilège pour l'utilisateur: $username"
    
    # Vérifier si l'utilisateur a vraiment besoin des privilèges admin
    if groups "$username" | grep -q -w admin; then
        local justification_file="$POLICIES_DIR/admin_justification_$username.conf"
        
        if [[ ! -f "$justification_file" ]]; then
            log_action "⚠️  L'utilisateur admin '$username' manque de documentation de justification"
            
            # Créer un modèle de justification
            cat > "$justification_file" << EOF
# Justification Admin pour l'Utilisateur: $username
# Créé: $(date)
# Statut: EN_ATTENTE_REVISION

JUSTIFICATION_METIER=""
APPROUVE_PAR=""
DATE_APPROBATION=""
DATE_REVISION=""
DATE_REVOCATION=""

# Évaluation des Risques
NIVEAU_PRIVILEGE="admin"
SCORE_JUSTIFICATION=0
REVISION_REQUISE=true

# Notes
COMMENTAIRES=""
EOF
            
            log_action "📝 Modèle de justification créé: $justification_file"
        fi
    fi
}

# Générer des recommandations de sécurité
generate_security_recommendations() {
    local recommendations='['
    local first=true
    
    # Obtenir le nombre d'utilisateurs admin
    local admin_count
    admin_count=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | wc -w)
    
    if [[ $admin_count -gt 5 ]]; then
        if [[ "$first" == true ]]; then
            first=false
        else
            recommendations+=','
        fi
        recommendations+='"Considérer réduire le nombre de comptes administrateur pour une meilleure sécurité"'
    fi
    
    # Vérifier les comptes inutilisés
    local unused_accounts=0
    while IFS= read -r user; do
        local last_login
        last_login=$(last -1 "$user" | head -1 | awk '{print $4}')
        if [[ -z "$last_login" || "$last_login" == "Jamais" ]]; then
            unused_accounts=$((unused_accounts + 1))
        fi
    done < <(dscl . list /Users | grep -v "^_")
    
    if [[ $unused_accounts -gt 0 ]]; then
        if [[ "$first" == true ]]; then
            first=false
        else
            recommendations+=','
        fi
        recommendations+="\"Considérer désactiver ou supprimer $unused_accounts comptes utilisateur inutilisés\""
    fi
    
    # Ajouter des recommandations par défaut
    if [[ "$first" == true ]]; then
        first=false
    else
        recommendations+=','
    fi
    recommendations+='"Implémenter des cycles de révision de privilèges réguliers"'
    
    recommendations+=','
    recommendations+='"Activer la journalisation d'audit complète"'
    
    recommendations+=','
    recommendations+='"Configurer la surveillance automatisée d\'escalade de privilèges"'
    
    recommendations+=']'
    echo "$recommendations"
}

# Générer un rapport de conformité
generate_compliance_report() {
    local framework="$1"
    
    log_action "Génération du rapport de conformité pour le cadre: $framework"
    
    local compliance_report="$COMPLIANCE_DIR/compliance_${framework}_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$compliance_report" << EOF
{
    "compliance_metadata": {
        "timestamp": "$(date -Iseconds)",
        "framework": "$framework",
        "hostname": "$(hostname)",
        "generator": "MacFleet User Privilege Compliance Manager"
    },
    "framework_requirements": $(get_framework_requirements "$framework"),
    "compliance_assessment": {
        "overall_score": $(calculate_overall_compliance "$framework"),
        "user_compliance": $(assess_all_users_compliance "$framework"),
        "policy_compliance": $(assess_policy_compliance "$framework"),
        "recommendations": $(generate_compliance_recommendations "$framework")
    }
}
EOF

    log_action "✅ Rapport de conformité généré: $compliance_report"
    echo "$compliance_report"
}

# Obtenir les exigences du cadre
get_framework_requirements() {
    local framework="$1"
    
    case "$framework" in
        "nist")
            echo '{"least_privilege": true, "separation_of_duties": true, "access_review": true, "audit_trails": true}'
            ;;
        "iso27001")
            echo '{"access_control": true, "privilege_management": true, "monitoring": true, "documentation": true}'
            ;;
        "cis")
            echo '{"admin_minimization": true, "privilege_escalation_monitoring": true, "account_lifecycle": true}'
            ;;
        *)
            echo '{"basic_access_control": true, "user_management": true}'
            ;;
    esac
}

# Calculer le score de conformité global
calculate_overall_compliance() {
    local framework="$1"
    
    local total_score=0
    local check_count=0
    
    # Vérifications de conformité de base
    check_count=$((check_count + 1))
    local admin_count
    admin_count=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | wc -w)
    if [[ $admin_count -le 5 ]]; then
        total_score=$((total_score + 20))
    fi
    
    check_count=$((check_count + 1))
    if [[ -f "$LOG_FILE" ]]; then
        total_score=$((total_score + 20))
    fi
    
    check_count=$((check_count + 1))
    if [[ -d "$POLICIES_DIR" ]]; then
        total_score=$((total_score + 20))
    fi
    
    # Vérifications spécifiques au cadre
    case "$framework" in
        "nist")
            check_count=$((check_count + 2))
            # Vérifier la documentation des privilèges
            if find "$POLICIES_DIR" -name "admin_justification_*.conf" | grep -q .; then
                total_score=$((total_score + 20))
            fi
            # Vérifier les capacités d'audit
            if [[ -d "$AUDIT_DIR" ]]; then
                total_score=$((total_score + 20))
            fi
            ;;
    esac
    
    local final_score
    final_score=$(awk "BEGIN {printf \"%.0f\", ($total_score/$check_count)}")
    
    echo "$final_score"
}

# Fonction d'exécution principale
main() {
    local action="${1:-audit}"
    local parameter="$2"
    local additional_param="$3"
    
    log_action "=== Gestion des Privilèges Utilisateur MacFleet Démarrée ==="
    log_action "Action: $action"
    log_action "Paramètre: ${parameter:-N/A}"
    
    setup_directories
    
    case "$action" in
        "check")
            if [[ -z "$parameter" ]]; then
                echo "Usage: $0 check <nom_utilisateur>"
                exit 1
            fi
            check_user_admin_status "$parameter"
            ;;
        "list")
            list_admin_users
            ;;
        "audit")
            audit_user_privileges
            ;;
        "monitor")
            monitor_privilege_escalation
            ;;
        "policy")
            if [[ -z "$parameter" ]]; then
                echo "Politiques de sécurité disponibles:"
                echo "  - least_privilege"
                echo "  - admin_review"
                echo "  - password_policy"
                echo "  - session_limits"
                echo ""
                echo "Usage: $0 policy <nom_politique> [utilisateurs_cibles]"
                exit 1
            fi
            apply_security_policy "$parameter" "$additional_param"
            ;;
        "compliance")
            if [[ -z "$parameter" ]]; then
                echo "Cadres de conformité disponibles:"
                for framework in "${!COMPLIANCE_FRAMEWORKS[@]}"; do
                    echo "  - $framework: ${COMPLIANCE_FRAMEWORKS[$framework]}"
                done
                echo ""
                echo "Usage: $0 compliance <cadre>"
                exit 1
            fi
            generate_compliance_report "$parameter"
            ;;
        "details")
            if [[ -z "$parameter" ]]; then
                echo "Usage: $0 details <nom_utilisateur>"
                exit 1
            fi
            get_user_details "$parameter" | jq .
            ;;
        *)
            echo "Usage: $0 {check|list|audit|monitor|policy|compliance|details}"
            echo "  check       - Vérifier si un utilisateur spécifique est administrateur"
            echo "  list        - Lister tous les utilisateurs administrateur"
            echo "  audit       - Générer un audit complet des privilèges"
            echo "  monitor     - Surveiller les tentatives d'escalade de privilèges"
            echo "  policy      - Appliquer une politique de sécurité aux utilisateurs"
            echo "  compliance  - Générer un rapport de conformité"
            echo "  details     - Obtenir des informations détaillées sur l'utilisateur"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des privilèges utilisateur terminée ==="
}

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