Guide

Gestion à Distance d'Entreprise et Contrôle d'Accès Sécurisé sur macOS

Implémentez une gestion à distance complète et un contrôle d'accès sécurisé sur vos appareils Roundfleet. Ce tutoriel couvre la configuration d'Apple Remote Desktop, la gestion d'accès à distance multi-protocoles, l'application de politiques de sécurité, les cadres de conformité et le déploiement automatisé à l'échelle de la flotte pour les environnements d'entreprise.

Comprendre la Gestion à Distance macOS

macOS fournit plusieurs protocoles et services de gestion à distance :

• Apple Remote Desktop (ARD) - Solution de bureau à distance native macOS avec fonctionnalités de gestion complètes
• SSH (Secure Shell) - Accès à distance en ligne de commande avec chiffrement fort
• VNC (Virtual Network Computing) - Protocole de bureau à distance multi-plateforme
• Partage d'Écran - Fonctionnalité de partage d'écran intégrée à macOS
• Connexion à Distance - Accès à distance basé sur terminal
• Apple Configurator - Outil de configuration et gestion d'appareils

Configuration Basique de Gestion à Distance

Activer Apple Remote Desktop

#!/bin/bash

# Activer Apple Remote Desktop avec configuration de base
enable_remote_desktop() {
    echo "=== Activation d'Apple Remote Desktop ==="
    
    local kickstart_path="/System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart"
    
    if [[ ! -f "$kickstart_path" ]]; then
        echo "❌ Agent ARD non trouvé sur ce système"
        return 1
    fi
    
    # Activer la Gestion à Distance
    if sudo "$kickstart_path" -activate; then
        echo "✅ Apple Remote Desktop activé avec succès"
    else
        echo "❌ Échec de l'activation d'Apple Remote Desktop"
        return 1
    fi
    
    # Configurer les paramètres de base
    sudo "$kickstart_path" -configure -allowAccessFor -allUsers -privs -all
    
    # Redémarrer l'Agent ARD
    sudo "$kickstart_path" -restart -agent
    
    echo "✅ Configuration d'Apple Remote Desktop terminée"
    return 0
}

# Exécuter la fonction
enable_remote_desktop

Désactiver la Gestion à Distance

#!/bin/bash

# Désactiver Apple Remote Desktop
disable_remote_desktop() {
    echo "=== Désactivation d'Apple Remote Desktop ==="
    
    local kickstart_path="/System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart"
    
    if [[ ! -f "$kickstart_path" ]]; then
        echo "❌ Agent ARD non trouvé sur ce système"
        return 1
    fi
    
    # Désactiver la Gestion à Distance
    if sudo "$kickstart_path" -deactivate; then
        echo "✅ Apple Remote Desktop désactivé avec succès"
    else
        echo "❌ Échec de la désactivation d'Apple Remote Desktop"
        return 1
    fi
    
    return 0
}

# Exécuter la fonction
disable_remote_desktop

Configurer l'Accès Spécifique aux Utilisateurs

#!/bin/bash

# Configurer la Gestion à Distance pour des utilisateurs spécifiques
configure_user_access() {
    local target_users="$1"
    local privileges="$2"
    
    echo "=== Configuration de l'Accès à Distance Spécifique aux Utilisateurs ==="
    
    local kickstart_path="/System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart"
    
    if [[ -z "$target_users" ]]; then
        echo "❌ Utilisateurs cibles requis"
        echo "Usage: configure_user_access 'user1,user2' 'privileges'"
        return 1
    fi
    
    # Activer avec utilisateurs spécifiés
    sudo "$kickstart_path" -activate -configure -allowAccessFor -specifiedUsers
    
    # Configurer les privilèges utilisateur
    IFS=',' read -ra USERS <<< "$target_users"
    for user in "${USERS[@]}"; do
        if id "$user" &>/dev/null; then
            sudo "$kickstart_path" -configure -users "$user" -access -on -privs -all
            echo "✅ Accès configuré pour l'utilisateur: $user"
        else
            echo "⚠️  Utilisateur non trouvé: $user"
        fi
    done
    
    return 0
}

# Exemple d'utilisation
# configure_user_access "admin,support" "all"

Système de Gestion à Distance d'Entreprise

#!/bin/bash

# Système de Gestion à Distance d'Entreprise Roundfleet
# Contrôle d'accès à distance complet, conformité sécuritaire et gestion de flotte

# Configuration
LOG_FILE="/var/log/roundfleet_remote_management.log"
CONFIG_DIR="/etc/roundfleet/remote_management"
POLICIES_DIR="$CONFIG_DIR/policies"
REPORTS_DIR="$CONFIG_DIR/reports"
COMPLIANCE_DIR="$CONFIG_DIR/compliance"
SECURITY_DIR="$CONFIG_DIR/security"
SESSION_DIR="$CONFIG_DIR/sessions"

# Protocoles d'accès à distance
declare -A REMOTE_PROTOCOLS=(
    ["ard"]="Apple Remote Desktop"
    ["ssh"]="Secure Shell"
    ["vnc"]="Virtual Network Computing"
    ["screen_sharing"]="Partage d'Écran macOS"
    ["remote_login"]="Connexion à Distance Terminal"
)

# Cadres de conformité sécuritaire
declare -A COMPLIANCE_FRAMEWORKS=(
    ["nist"]="access_control,encryption_in_transit,session_management,audit_trails"
    ["iso27001"]="secure_remote_access,access_control,monitoring,documentation"
    ["cis"]="secure_protocols,authentication,session_limits,logging"
    ["sox"]="financial_access_control,audit_requirements,change_management"
    ["hipaa"]="minimum_necessary,access_controls,audit_logs,encryption"
    ["pci_dss"]="secure_protocols,access_control,monitoring,encryption"
)

# Niveaux de privilège d'accès
declare -A PRIVILEGE_LEVELS=(
    ["view_only"]="observe,report"
    ["control"]="observe,control,interact"
    ["manage"]="observe,control,interact,copy_files,restart"
    ["admin"]="observe,control,interact,copy_files,restart,change_settings"
    ["full"]="all_privileges"
)

# Politiques de sécurité
declare -A SECURITY_POLICIES=(
    ["strict"]="mfa_required,encryption_mandatory,session_timeout_15min,audit_all"
    ["standard"]="password_auth,encryption_preferred,session_timeout_30min,audit_admin"
    ["relaxed"]="basic_auth,session_timeout_60min,audit_changes"
    ["compliance"]="enterprise_auth,full_encryption,session_timeout_10min,comprehensive_audit"
)

# 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" "$SECURITY_DIR" "$SESSION_DIR"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir"
            log_action "Répertoire créé: $dir"
        fi
    done
}

# Vérifier le statut actuel de la gestion à distance
check_remote_management_status() {
    echo "=== Vérification du Statut de Gestion à Distance ==="
    
    local status_report="$REPORTS_DIR/remote_status_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$status_report" << EOF
{
    "status_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "os_version": "$(sw_vers -productVersion)"
    },
    "remote_services": {
EOF

    local first=true
    
    # Vérifier Apple Remote Desktop
    local ard_status="disabled"
    if ps aux | grep -q "ARDAgent" && ! echo "$!" | grep -q "grep"; then
        ard_status="enabled"
    fi
    
    cat >> "$status_report" << EOF
        "apple_remote_desktop": {
            "status": "$ard_status",
            "process_running": $(pgrep -q ARDAgent && echo "true" || echo "false"),
            "port": "5900"
        },
EOF

    # Vérifier SSH
    local ssh_status="disabled"
    if sudo systemsetup -getremotelogin | grep -q "On"; then
        ssh_status="enabled"
    fi
    
    cat >> "$status_report" << EOF
        "ssh": {
            "status": "$ssh_status",
            "port": "22",
            "service_running": $(launchctl list | grep -q "com.openssh.sshd" && echo "true" || echo "false")
        },
EOF

    # Vérifier VNC/Partage d'Écran
    local vnc_status="disabled"
    if launchctl list | grep -q "com.apple.screensharing"; then
        vnc_status="enabled"
    fi
    
    cat >> "$status_report" << EOF
        "screen_sharing": {
            "status": "$vnc_status",
            "port": "5900",
            "service_running": $(launchctl list | grep -q "com.apple.screensharing" && echo "true" || echo "false")
        }
    },
    "security_assessment": $(assess_remote_security),
    "active_sessions": $(get_active_remote_sessions)
}
EOF

    log_action "✅ Vérification du statut de gestion à distance terminée: $status_report"
    echo "$status_report"
}

# Évaluer la sécurité d'accès à distance
assess_remote_security() {
    local security_score=0
    local total_checks=10
    
    # Vérifier le chiffrement
    if sudo systemsetup -getremotelogin | grep -q "On"; then
        security_score=$((security_score + 2))  # SSH est chiffré
    fi
    
    # Vérifier le statut du pare-feu
    if sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate | grep -q "enabled"; then
        security_score=$((security_score + 2))
    fi
    
    # Vérifier la complexité des mots de passe
    if pwpolicy -getaccountpolicies 2>/dev/null | grep -q "minLength"; then
        security_score=$((security_score + 1))
    fi
    
    # Vérifier les tentatives de connexion échouées
    local failed_attempts
    failed_attempts=$(grep "authentication failure" /var/log/auth.log 2>/dev/null | wc -l || echo 0)
    if [[ $failed_attempts -lt 10 ]]; then
        security_score=$((security_score + 1))
    fi
    
    # Vérifier la surveillance active
    if [[ -f "$LOG_FILE" ]]; then
        security_score=$((security_score + 1))
    fi
    
    # Vérifications de sécurité supplémentaires
    security_score=$((security_score + 3))  # Placeholder pour vérifications supplémentaires
    
    local security_percentage
    security_percentage=$(awk "BEGIN {printf \"%.0f\", ($security_score/$total_checks)*100}")
    
    local risk_level="faible"
    if [[ $security_percentage -lt 60 ]]; then
        risk_level="eleve"
    elif [[ $security_percentage -lt 80 ]]; then
        risk_level="moyen"
    fi
    
    echo "{\"score\": $security_score, \"percentage\": $security_percentage, \"risk_level\": \"$risk_level\"}"
}

# Obtenir les sessions à distance actives
get_active_remote_sessions() {
    local sessions='['
    local first=true
    
    # Vérifier les sessions SSH
    local ssh_sessions
    ssh_sessions=$(who | grep "pts/" || echo "")
    
    while IFS= read -r session; do
        if [[ -n "$session" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                sessions+=','
            fi
            
            local user
            user=$(echo "$session" | awk '{print $1}')
            local terminal
            terminal=$(echo "$session" | awk '{print $2}')
            local login_time
            login_time=$(echo "$session" | awk '{print $3, $4}')
            local remote_host
            remote_host=$(echo "$session" | awk '{print $5}' | tr -d '()')
            
            sessions+="{\"type\": \"ssh\", \"user\": \"$user\", \"terminal\": \"$terminal\", \"login_time\": \"$login_time\", \"remote_host\": \"$remote_host\"}"
        fi
    done <<< "$ssh_sessions"
    
    # Vérifier les sessions VNC/ARD
    local vnc_sessions
    vnc_sessions=$(netstat -an | grep ":5900" | grep "ESTABLISHED" || echo "")
    
    while IFS= read -r connection; do
        if [[ -n "$connection" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                sessions+=','
            fi
            
            local remote_ip
            remote_ip=$(echo "$connection" | awk '{print $5}' | cut -d: -f1)
            
            sessions+="{\"type\": \"vnc_ard\", \"remote_ip\": \"$remote_ip\", \"port\": \"5900\"}"
        fi
    done <<< "$vnc_sessions"
    
    sessions+=']'
    echo "$sessions"
}

# Configurer l'accès à distance d'entreprise
configure_enterprise_remote_access() {
    local access_policy="$1"
    local target_protocols="$2"
    local user_groups="$3"
    
    log_action "Configuration de l'accès à distance d'entreprise avec politique: $access_policy"
    
    # Analyser la configuration de politique
    local policy_config="${SECURITY_POLICIES[$access_policy]}"
    if [[ -z "$policy_config" ]]; then
        log_action "❌ Politique de sécurité inconnue: $access_policy"
        return 1
    fi
    
    # Configurer chaque protocole spécifié
    IFS=',' read -ra PROTOCOLS <<< "$target_protocols"
    for protocol in "${PROTOCOLS[@]}"; do
        case "$protocol" in
            "ard")
                configure_ard_enterprise "$access_policy" "$user_groups"
                ;;
            "ssh")
                configure_ssh_enterprise "$access_policy" "$user_groups"
                ;;
            "vnc")
                configure_vnc_enterprise "$access_policy" "$user_groups"
                ;;
            "screen_sharing")
                configure_screen_sharing_enterprise "$access_policy" "$user_groups"
                ;;
            *)
                log_action "⚠️  Protocole inconnu: $protocol"
                ;;
        esac
    done
    
    # Appliquer les paramètres de politique de sécurité
    apply_security_policy_settings "$access_policy"
    
    log_action "✅ Configuration d'accès à distance d'entreprise terminée"
}

# Configurer Apple Remote Desktop pour l'entreprise
configure_ard_enterprise() {
    local policy="$1"
    local user_groups="$2"
    
    echo "🖥️  Configuration d'Apple Remote Desktop pour l'entreprise"
    
    local kickstart_path="/System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart"
    
    # Activer ARD
    sudo "$kickstart_path" -activate -restart
    
    # Configurer selon la politique
    case "$policy" in
        "strict"|"compliance")
            # Accès restreint avec utilisateurs spécifiques uniquement
            sudo "$kickstart_path" -configure -allowAccessFor -specifiedUsers
            sudo "$kickstart_path" -configure -privs -observe -control -interact
            ;;
        "standard")
            # Configuration standard
            sudo "$kickstart_path" -configure -allowAccessFor -specifiedUsers
            sudo "$kickstart_path" -configure -privs -observe -control
            ;;
        "relaxed")
            # Configuration plus permissive
            sudo "$kickstart_path" -configure -allowAccessFor -allUsers
            sudo "$kickstart_path" -configure -privs -all
            ;;
    esac
    
    # Configurer des utilisateurs spécifiques si fournis
    if [[ -n "$user_groups" ]]; then
        IFS=',' read -ra GROUPS <<< "$user_groups"
        for group in "${GROUPS[@]}"; do
            # Ajouter les utilisateurs du groupe à l'accès ARD
            local group_users
            group_users=$(dscl . -read "/Groups/$group" GroupMembership 2>/dev/null | cut -d: -f2)
            
            for user in $group_users; do
                if id "$user" &>/dev/null; then
                    sudo "$kickstart_path" -configure -users "$user" -access -on
                    log_action "Accès ARD ajouté pour l'utilisateur: $user"
                fi
            done
        done
    fi
    
    # Créer une sauvegarde de configuration ARD
    local ard_config="$SECURITY_DIR/ard_config_$(date '+%Y%m%d_%H%M%S').conf"
    cat > "$ard_config" << EOF
# Configuration Apple Remote Desktop
# Politique: $policy
# Configuré: $(date)

POLICY="$policy"
USER_GROUPS="$user_groups"
CONFIGURATION_DATE="$(date -Iseconds)"
ARD_STATUS="enabled"
ACCESS_CONTROL="specified_users"
EOF

    log_action "✅ Configuration ARD d'entreprise terminée"
}

# Configurer SSH pour l'entreprise
configure_ssh_enterprise() {
    local policy="$1"
    local user_groups="$2"
    
    echo "🔐 Configuration SSH pour l'entreprise"
    
    # Activer SSH (Connexion à Distance)
    sudo systemsetup -setremotelogin on
    
    # Configurer la sécurité SSH selon la politique
    local sshd_config="/etc/ssh/sshd_config"
    local custom_config="$SECURITY_DIR/ssh_custom_config"
    
    case "$policy" in
        "strict"|"compliance")
            cat > "$custom_config" << EOF
# Configuration SSH d'Entreprise - Politique Stricte
Protocol 2
PermitRootLogin no
PasswordAuthentication yes
PubkeyAuthentication yes
MaxAuthTries 3
ClientAliveInterval 300
ClientAliveCountMax 2
MaxSessions 5
LoginGraceTime 60
PermitEmptyPasswords no
ChallengeResponseAuthentication no
UsePAM yes
EOF
            ;;
        "standard")
            cat > "$custom_config" << EOF
# Configuration SSH d'Entreprise - Politique Standard
Protocol 2
PermitRootLogin no
PasswordAuthentication yes
PubkeyAuthentication yes
MaxAuthTries 5
ClientAliveInterval 600
ClientAliveCountMax 3
MaxSessions 10
LoginGraceTime 120
PermitEmptyPasswords no
EOF
            ;;
        "relaxed")
            cat > "$custom_config" << EOF
# Configuration SSH d'Entreprise - Politique Souple
Protocol 2
PermitRootLogin no
PasswordAuthentication yes
PubkeyAuthentication yes
MaxAuthTries 10
ClientAliveInterval 900
MaxSessions 20
EOF
            ;;
    esac
    
    # Sauvegarder la configuration originale et appliquer la configuration personnalisée
    if [[ -f "$sshd_config" ]]; then
        sudo cp "$sshd_config" "$sshd_config.backup.$(date '+%Y%m%d_%H%M%S')"
    fi
    
    # Appliquer la configuration SSH personnalisée
    sudo cp "$custom_config" "/etc/ssh/sshd_config.d/roundfleet_enterprise.conf"
    
    # Redémarrer le service SSH
    sudo launchctl unload /System/Library/LaunchDaemons/ssh.plist 2>/dev/null
    sudo launchctl load /System/Library/LaunchDaemons/ssh.plist
    
    log_action "✅ Configuration SSH d'entreprise terminée"
}

# Surveiller les sessions d'accès à distance
monitor_remote_sessions() {
    log_action "Démarrage de la surveillance des sessions à distance"
    
    local monitoring_report="$SESSION_DIR/session_monitoring_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$monitoring_report" << EOF
{
    "monitoring_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "monitoring_period": "temps_reel"
    },
    "active_sessions": $(get_active_remote_sessions),
    "session_analytics": {
        "total_active_sessions": $(get_active_remote_sessions | jq '. | length'),
        "protocols_in_use": $(get_protocols_in_use),
        "unique_remote_hosts": $(get_unique_remote_hosts),
        "session_duration_analysis": $(analyze_session_durations)
    },
    "security_events": $(detect_security_events)
}
EOF

    log_action "✅ Surveillance des sessions à distance terminée: $monitoring_report"
    echo "$monitoring_report"
}

# Détecter les événements de sécurité
detect_security_events() {
    local events='['
    local first=true
    
    # Vérifier les tentatives de connexion échouées
    local failed_logins
    failed_logins=$(grep "authentication failure" /var/log/auth.log 2>/dev/null | tail -10)
    
    while IFS= read -r event; do
        if [[ -n "$event" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                events+=','
            fi
            
            local timestamp
            timestamp=$(echo "$event" | awk '{print $1, $2, $3}')
            local user
            user=$(echo "$event" | grep -o "user=[^ ]*" | cut -d= -f2 || echo "inconnu")
            
            events+="{\"type\": \"failed_login\", \"timestamp\": \"$timestamp\", \"user\": \"$user\", \"severity\": \"moyen\"}"
        fi
    done <<< "$failed_logins"
    
    # Vérifier les modèles de connexion inhabituels
    local unusual_connections
    unusual_connections=$(netstat -an | grep ":22\|:5900" | grep "ESTABLISHED" | wc -l)
    
    if [[ $unusual_connections -gt 10 ]]; then
        if [[ "$first" == true ]]; then
            first=false
        else
            events+=','
        fi
        
        events+="{\"type\": \"high_connection_count\", \"count\": $unusual_connections, \"severity\": \"eleve\"}"
    fi
    
    events+=']'
    echo "$events"
}

# Générer un rapport de conformité
generate_compliance_report() {
    local framework="$1"
    
    log_action "Génération du rapport de conformité d'accès à distance pour: $framework"
    
    local compliance_report="$COMPLIANCE_DIR/remote_compliance_${framework}_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$compliance_report" << EOF
{
    "compliance_metadata": {
        "timestamp": "$(date -Iseconds)",
        "framework": "$framework",
        "hostname": "$(hostname)",
        "generator": "Roundfleet Remote Management Compliance"
    },
    "framework_requirements": $(get_framework_requirements "$framework"),
    "compliance_assessment": {
        "overall_score": $(calculate_compliance_score "$framework"),
        "protocol_compliance": $(assess_protocol_compliance "$framework"),
        "security_compliance": $(assess_security_compliance "$framework"),
        "access_control_compliance": $(assess_access_control_compliance "$framework")
    },
    "recommendations": $(generate_compliance_recommendations "$framework"),
    "remediation_actions": $(generate_remediation_actions "$framework")
}
EOF

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

# Calculer le score de conformité
calculate_compliance_score() {
    local framework="$1"
    
    local total_score=0
    local check_count=0
    
    # Vérifications de conformité de base
    check_count=$((check_count + 1))
    if sudo /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate | grep -q "enabled"; 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 sudo systemsetup -getremotelogin | grep -q "On"; then
        total_score=$((total_score + 15))  # Chiffrement SSH
    fi
    
    check_count=$((check_count + 1))
    if [[ -d "$SECURITY_DIR" ]]; then
        total_score=$((total_score + 15))
    fi
    
    # Vérifications spécifiques au cadre
    case "$framework" in
        "nist"|"iso27001")
            check_count=$((check_count + 1))
            if [[ -f "$SECURITY_DIR/ard_config"* ]]; then
                total_score=$((total_score + 15))
            fi
            
            check_count=$((check_count + 1))
            if [[ -f "/etc/ssh/sshd_config.d/roundfleet_enterprise.conf" ]]; then
                total_score=$((total_score + 15))
            fi
            ;;
    esac
    
    local final_score
    final_score=$(awk "BEGIN {printf \"%.0f\", ($total_score/$check_count)}")
    
    echo "$final_score"
}

# Appliquer les politiques de sécurité automatisées
apply_automated_security_policies() {
    local policy_type="$1"
    
    log_action "Application des politiques de sécurité automatisées: $policy_type"
    
    case "$policy_type" in
        "session_timeout")
            configure_session_timeouts
            ;;
        "failed_login_protection")
            configure_failed_login_protection
            ;;
        "encryption_enforcement")
            enforce_encryption_policies
            ;;
        "access_logging")
            configure_comprehensive_logging
            ;;
        *)
            log_action "⚠️  Type de politique inconnu: $policy_type"
            return 1
            ;;
    esac
    
    log_action "✅ Politiques de sécurité automatisées appliquées"
}

# Configurer les timeouts de session
configure_session_timeouts() {
    echo "⏰ Configuration des timeouts de session"
    
    # Timeouts de session SSH (déjà configurés dans la configuration SSH d'entreprise)
    # Configuration du timeout de session ARD
    local timeout_config="$SECURITY_DIR/session_timeouts.conf"
    
    cat > "$timeout_config" << EOF
# Configuration des Timeouts de Session
SSH_CLIENT_ALIVE_INTERVAL=300
SSH_CLIENT_ALIVE_COUNT_MAX=2
ARD_SESSION_TIMEOUT=1800
VNC_SESSION_TIMEOUT=1800
SCREEN_SHARING_TIMEOUT=1800
IDLE_DISCONNECT_TIME=900
EOF

    log_action "✅ Timeouts de session configurés"
}

# Fonction d'exécution principale
main() {
    local action="${1:-status}"
    local parameter="$2"
    local additional_param="$3"
    local extra_param="$4"
    
    log_action "=== Gestion à Distance Roundfleet Démarrée ==="
    log_action "Action: $action"
    log_action "Paramètre: ${parameter:-N/A}"
    
    setup_directories
    
    case "$action" in
        "enable")
            if [[ -z "$parameter" ]]; then
                enable_remote_desktop
            else
                configure_enterprise_remote_access "$parameter" "${additional_param:-ard}" "$extra_param"
            fi
            ;;
        "disable")
            disable_remote_desktop
            ;;
        "status")
            check_remote_management_status
            ;;
        "configure")
            if [[ -z "$parameter" || -z "$additional_param" ]]; then
                echo "Usage: $0 configure <politique> <protocoles> [groupes_utilisateurs]"
                echo "Politiques: ${!SECURITY_POLICIES[*]}"
                echo "Protocoles: ${!REMOTE_PROTOCOLS[*]}"
                exit 1
            fi
            configure_enterprise_remote_access "$parameter" "$additional_param" "$extra_param"
            ;;
        "monitor")
            monitor_remote_sessions
            ;;
        "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"
            ;;
        "users")
            if [[ -z "$parameter" || -z "$additional_param" ]]; then
                echo "Usage: $0 users <liste_utilisateurs> <privileges>"
                echo "Exemple: $0 users 'admin,support' 'control'"
                exit 1
            fi
            configure_user_access "$parameter" "$additional_param"
            ;;
        "security")
            if [[ -z "$parameter" ]]; then
                echo "Politiques de sécurité disponibles:"
                echo "  - session_timeout"
                echo "  - failed_login_protection"
                echo "  - encryption_enforcement"
                echo "  - access_logging"
                echo ""
                echo "Usage: $0 security <type_politique>"
                exit 1
            fi
            apply_automated_security_policies "$parameter"
            ;;
        *)
            echo "Usage: $0 {enable|disable|status|configure|monitor|compliance|users|security}"
            echo "  enable      - Activer la gestion à distance de base ou configurer une politique d'entreprise"
            echo "  disable     - Désactiver la gestion à distance"
            echo "  status      - Vérifier le statut actuel de la gestion à distance"
            echo "  configure   - Configurer l'accès à distance d'entreprise avec politiques"
            echo "  monitor     - Surveiller les sessions à distance actives"
            echo "  compliance  - Générer un rapport de conformité"
            echo "  users       - Configurer l'accès spécifique aux utilisateurs"
            echo "  security    - Appliquer les politiques de sécurité automatisées"
            exit 1
            ;;
    esac
    
    log_action "=== Opération de gestion à distance terminée ==="
}

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

Fonctionnalités Avancées de Gestion à Distance

Gestion de Sessions Multi-Protocoles

#!/bin/bash

# Gestion complète de sessions multi-protocoles
manage_multi_protocol_sessions() {
    echo "=== Gestion de Sessions Multi-Protocoles ==="
    
    local session_config="$SESSION_DIR/protocol_management.json"
    
    cat > "$session_config" << EOF
{
    "protocol_management": {
        "apple_remote_desktop": {
            "port": 5900,
            "encryption": "AES-128",
            "authentication": "comptes_systeme",
            "max_concurrent_sessions": 5,
            "session_timeout": 1800
        },
        "ssh": {
            "port": 22,
            "encryption": "AES-256",
            "authentication": "cles_preferees",
            "max_concurrent_sessions": 10,
            "session_timeout": 3600
        },
        "vnc": {
            "port": 5900,
            "encryption": "optionnel",
            "authentication": "mot_de_passe_vnc",
            "max_concurrent_sessions": 3,
            "session_timeout": 1800
        },
        "screen_sharing": {
            "port": 5900,
            "encryption": "integre",
            "authentication": "comptes_systeme",
            "max_concurrent_sessions": 2,
            "session_timeout": 2700
        }
    },
    "security_policies": {
        "force_encryption": true,
        "require_mfa": false,
        "log_all_sessions": true,
        "geographic_restrictions": false,
        "time_based_access": false
    }
}
EOF

    echo "📊 Gestion de sessions multi-protocoles configurée: $session_config"
}

# Surveillance de sécurité avancée
advanced_security_monitoring() {
    echo "🔍 Surveillance de Sécurité Avancée"
    
    local monitoring_script="$SECURITY_DIR/advanced_monitoring.sh"
    
    cat > "$monitoring_script" << 'EOF'
#!/bin/bash

# Surveillance de Sécurité d'Accès à Distance Avancée

while true; do
    # Surveiller les tentatives de connexion
    CONNECTION_ATTEMPTS=$(netstat -an | grep -E ":22|:5900" | grep "SYN_RECV" | wc -l)
    
    if [[ $CONNECTION_ATTEMPTS -gt 20 ]]; then
        logger "Roundfleet: Nombre élevé de tentatives de connexion à distance détecté: $CONNECTION_ATTEMPTS"
        # Envoyer une alerte
        echo "Tentatives de connexion élevées: $CONNECTION_ATTEMPTS" | mail -s "Alerte Sécurité Roundfleet" [email protected]
    fi
    
    # Surveiller les échecs d'authentification
    FAILED_AUTH=$(grep "authentication failure" /var/log/auth.log | grep "$(date '+%Y-%m-%d')" | wc -l)
    
    if [[ $FAILED_AUTH -gt 10 ]]; then
        logger "Roundfleet: Nombre élevé d'échecs d'authentification: $FAILED_AUTH"
    fi
    
    # Surveiller les modèles d'accès à distance inhabituels
    UNIQUE_IPS=$(netstat -an | grep -E ":22|:5900" | grep "ESTABLISHED" | awk '{print $5}' | cut -d: -f1 | sort -u | wc -l)
    
    if [[ $UNIQUE_IPS -gt 5 ]]; then
        logger "Roundfleet: Plusieurs IPs à distance uniques détectées: $UNIQUE_IPS"
    fi
    
    sleep 300  # Vérifier toutes les 5 minutes
done
EOF

    chmod +x "$monitoring_script"
    echo "🔐 Script de surveillance de sécurité avancée créé"
}

Accès à Distance Zero Trust

#!/bin/bash

# Implémenter les principes d'accès à distance Zero Trust
implement_zero_trust_remote_access() {
    echo "🛡️  Implémentation de l'Accès à Distance Zero Trust"
    
    local zero_trust_config="$SECURITY_DIR/zero_trust_config.json"
    
    cat > "$zero_trust_config" << EOF
{
    "zero_trust_principles": {
        "verify_explicitly": {
            "device_verification": true,
            "user_verification": true,
            "location_verification": true,
            "behavior_analysis": true
        },
        "least_privilege_access": {
            "session_based_permissions": true,
            "time_limited_access": true,
            "resource_specific_access": true,
            "privilege_escalation_monitoring": true
        },
        "assume_breach": {
            "continuous_monitoring": true,
            "anomaly_detection": true,
            "session_recording": true,
            "immediate_response": true
        }
    },
    "implementation_controls": {
        "device_trust_score": "requis",
        "user_risk_assessment": "continu",
        "network_segmentation": "active",
        "encrypted_channels_only": true,
        "session_isolation": true
    }
}
EOF

    echo "🎯 Configuration d'accès à distance Zero Trust créée"
}

Meilleures Pratiques de Sécurité

🔐 Contrôle d'Accès et Authentification

• Authentification multi-facteurs avec intégration d'identité d'entreprise
• Contrôle d'accès basé sur les rôles avec gestion granulaire des permissions
• Vérification de confiance d'appareil avec authentification basée sur certificats
• Contrôle d'accès basé sur session avec permissions limitées dans le temps

🛡️ Sécurité Réseau et Chiffrement

• Chiffrement de bout en bout pour tous les protocoles à distance (AES-256)
• Intégration VPN avec établissement de tunnel sécurisé
• Segmentation réseau avec application de micro-périmètre
• Analyse de trafic avec détection d'anomalies et intelligence des menaces

📊 Surveillance et Conformité

• Surveillance de session en temps réel avec journalisation complète
• Support de cadres de conformité (NIST, ISO 27001, CIS, SOX, HIPAA, PCI DSS)
• Évaluation de sécurité automatisée avec scoring de risque et alertes
• Capacités forensiques avec pistes d'audit détaillées et enregistrement de sessions

🚀 Opérations d'Entreprise

• Déploiement à l'échelle de la flotte avec gestion centralisée des politiques
• Provisioning automatisé avec intégration du cycle de vie d'identité
• Haute disponibilité avec équilibrage de charge et capacités de basculement
• Écosystème d'intégration avec SIEM, IAM et outils de sécurité

Notes Importantes

• Apple Remote Desktop nécessite une licence appropriée pour un usage d'entreprise
• Gestion des clés SSH essentielle pour les déploiements d'entreprise sécurisés
• Configuration du pare-feu réseau requise pour compléter la sécurité au niveau appareil
• Évaluations de sécurité régulières nécessaires pour maintenir la posture de conformité
• Formation utilisateur critique pour les pratiques d'accès à distance sécurisé
• Procédures de réponse aux incidents doivent être établies pour les événements de sécurité

Réduction du mouvement et de la transparence sur les appareils macOS

macOS propose diverses options d'accessibilité pour améliorer l'expérience utilisateur, particulièrement pour les utilisateurs sensibles aux effets visuels ou nécessitant des performances optimisées. La section Affichage des paramètres d'Accessibilité permet aux utilisateurs de modifier les paramètres d'affichage selon leurs besoins, incluant les options pour réduire le mouvement et la transparence. Ce guide complet fournit des scripts et techniques pour gérer ces paramètres sur les flottes Mac.

Comprendre les paramètres de mouvement et de transparence

Réduire le mouvement

Le paramètre "Réduire le mouvement" modifie les animations d'interface pour les rendre plus simples et visuellement plus confortables. Quand activé, il remplace les animations complexes par des effets de fondu croisé plus simples, réduisant l'inconfort potentiel pour les utilisateurs sensibles au mouvement.

Avantages :

• Réduit la fatigue oculaire et le mal des transports
• Améliore les performances sur le matériel plus ancien
• Crée une interface utilisateur plus prévisible
• Aide les utilisateurs avec des troubles vestibulaires ou une sensibilité au mouvement

Réduire la transparence

Le paramètre "Réduire la transparence" change les éléments semi-transparents de l'interface utilisateur en éléments solides, supprimant les effets de flou et de transparence à travers le système.

Avantages :

• Améliore la lisibilité et le contraste
• Réduit les distractions visuelles
• Meilleures performances sur les systèmes avec des capacités graphiques limitées
• Aide les utilisateurs avec des déficiences visuelles

Prérequis

Avant de configurer les paramètres de mouvement et de transparence, assurez-vous d'avoir :

• Privilèges administrateur sur le Mac
• Accès Terminal ou SSH
• Compréhension des exigences de contexte utilisateur
• Sauvegarde des paramètres actuels (recommandé)

Commandes de configuration de base

Comprendre le processus de configuration

Les paramètres d'accessibilité macOS sont stockés dans les préférences utilisateur et nécessitent des approches spécifiques :

• Contexte utilisateur : Les paramètres doivent être appliqués pour l'utilisateur correct
• Fichiers de préférences : Les paramètres sont stockés dans com.apple.universalaccess.plist
• Intégration système : Les changements affectent toute l'interface utilisateur
• Application en temps réel : Les paramètres prennent effet immédiatement

Détection de l'utilisateur actuel

La plupart des paramètres d'accessibilité requièrent un contexte utilisateur. Voici comment détecter l'utilisateur actuel :

#!/bin/bash

# Obtenir l'utilisateur de console actuel
get_current_user() {
    local current_user=$(ls -l /dev/console | awk '{ print $3 }')
    echo "$current_user"
}

# Obtenir le répertoire home de l'utilisateur
get_user_home() {
    local username=$1
    local user_home=$(eval echo ~$username)
    echo "$user_home"
}

# Exemple d'utilisation
current_user=$(get_current_user)
user_home=$(get_user_home "$current_user")

echo "Utilisateur actuel: $current_user"
echo "Répertoire home: $user_home"

Réduction de base du mouvement et de la transparence

Script d'activation simple

Script de base pour activer à la fois la réduction du mouvement et de la transparence :

#!/bin/bash

# Activer la réduction du mouvement et de la transparence
echo "Configuration des paramètres d'accessibilité..."

# Obtenir l'utilisateur actuel
loggedInUser=$(ls -l /dev/console | awk '{ print $3 }')

if [ -z "$loggedInUser" ] || [ "$loggedInUser" = "root" ]; then
    echo "Erreur: Aucune session utilisateur valide trouvée"
    exit 1
fi

echo "Configuration des paramètres pour l'utilisateur: $loggedInUser"

# Activer la réduction du mouvement
if su -l "$loggedInUser" -c "defaults write com.apple.universalaccess reduceMotion -bool true"; then
    echo "✓ Réduction du mouvement activée"
else
    echo "✗ Échec de l'activation de la réduction du mouvement"
    exit 1
fi

# Activer la réduction de la transparence
if su -l "$loggedInUser" -c "defaults write com.apple.universalaccess reduceTransparency -bool true"; then
    echo "✓ Réduction de la transparence activée"
else
    echo "✗ Échec de l'activation de la réduction de la transparence"
    exit 1
fi

echo "Paramètres d'accessibilité configurés avec succès"

Script de configuration avancé

Script plus complet avec validation et journalisation :

#!/bin/bash

# Script avancé de configuration d'accessibilité
LOG_FILE="/var/log/accessibility_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Options de configuration
REDUCE_MOTION=${1:-true}
REDUCE_TRANSPARENCY=${2:-true}

# Fonction pour enregistrer les messages
log_message() {
    echo "[$TIMESTAMP] $1" | tee -a "$LOG_FILE"
}

# Fonction pour valider les entrées booléennes
validate_boolean() {
    local value=$1
    local setting_name=$2
    
    if [[ "$value" != "true" && "$value" != "false" ]]; then
        log_message "ERREUR: Valeur invalide pour $setting_name: $value (doit être true ou false)"
        return 1
    fi
    
    return 0
}

# Fonction pour obtenir les paramètres d'accessibilité actuels
get_current_settings() {
    local username=$1
    
    log_message "Obtention des paramètres d'accessibilité actuels pour l'utilisateur: $username"
    
    # Obtenir le paramètre de réduction du mouvement
    local motion_setting=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceMotion 2>/dev/null")
    if [ -z "$motion_setting" ]; then
        motion_setting="Non défini"
    fi
    
    # Obtenir le paramètre de réduction de la transparence
    local transparency_setting=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceTransparency 2>/dev/null")
    if [ -z "$transparency_setting" ]; then
        transparency_setting="Non défini"
    fi
    
    echo "Paramètres d'accessibilité actuels:"
    echo "  Réduction du mouvement: $motion_setting"
    echo "  Réduction de la transparence: $transparency_setting"
    
    log_message "Paramètres actuels - Mouvement: $motion_setting, Transparence: $transparency_setting"
}

# Fonction pour configurer la réduction du mouvement
configure_reduce_motion() {
    local username=$1
    local enable_motion=$2
    
    log_message "Configuration de la réduction du mouvement à: $enable_motion pour l'utilisateur: $username"
    
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceMotion -bool $enable_motion"; then
        log_message "SUCCÈS: Réduction du mouvement définie à $enable_motion"
        return 0
    else
        log_message "ERREUR: Échec de la configuration de la réduction du mouvement"
        return 1
    fi
}

# Fonction pour configurer la réduction de la transparence
configure_reduce_transparency() {
    local username=$1
    local enable_transparency=$2
    
    log_message "Configuration de la réduction de la transparence à: $enable_transparency pour l'utilisateur: $username"
    
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceTransparency -bool $enable_transparency"; then
        log_message "SUCCÈS: Réduction de la transparence définie à $enable_transparency"
        return 0
    else
        log_message "ERREUR: Échec de la configuration de la réduction de la transparence"
        return 1
    fi
}

# Fonction pour vérifier les paramètres
verify_settings() {
    local username=$1
    local expected_motion=$2
    local expected_transparency=$3
    
    log_message "Vérification des paramètres d'accessibilité pour l'utilisateur: $username"
    
    # Vérifier la réduction du mouvement
    local actual_motion=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceMotion 2>/dev/null")
    if [ "$actual_motion" = "$expected_motion" ]; then
        log_message "VÉRIFIÉ: Réduction du mouvement correctement définie à $expected_motion"
    else
        log_message "AVERTISSEMENT: Vérification de la réduction du mouvement échouée. Attendu: $expected_motion, Actuel: $actual_motion"
    fi
    
    # Vérifier la réduction de la transparence
    local actual_transparency=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceTransparency 2>/dev/null")
    if [ "$actual_transparency" = "$expected_transparency" ]; then
        log_message "VÉRIFIÉ: Réduction de la transparence correctement définie à $expected_transparency"
    else
        log_message "AVERTISSEMENT: Vérification de la réduction de la transparence échouée. Attendu: $expected_transparency, Actuel: $actual_transparency"
    fi
}

# Exécution principale
log_message "Début de la configuration d'accessibilité"

# Valider les entrées
if ! validate_boolean "$REDUCE_MOTION" "réduction du mouvement"; then
    exit 1
fi

if ! validate_boolean "$REDUCE_TRANSPARENCY" "réduction de la transparence"; then
    exit 1
fi

# Obtenir l'utilisateur actuel
loggedInUser=$(ls -l /dev/console | awk '{ print $3 }')

if [ -z "$loggedInUser" ] || [ "$loggedInUser" = "root" ]; then
    log_message "ERREUR: Aucune session utilisateur valide trouvée"
    exit 1
fi

log_message "Utilisateur actuel: $loggedInUser"

# Afficher les paramètres actuels
get_current_settings "$loggedInUser"

# Configurer la réduction du mouvement
if ! configure_reduce_motion "$loggedInUser" "$REDUCE_MOTION"; then
    log_message "Échec de la configuration de la réduction du mouvement"
    exit 1
fi

# Configurer la réduction de la transparence
if ! configure_reduce_transparency "$loggedInUser" "$REDUCE_TRANSPARENCY"; then
    log_message "Échec de la configuration de la réduction de la transparence"
    exit 1
fi

# Vérifier les paramètres
verify_settings "$loggedInUser" "$REDUCE_MOTION" "$REDUCE_TRANSPARENCY"

log_message "Configuration d'accessibilité terminée avec succès"
echo "Paramètres d'accessibilité configurés avec succès"
echo "Les paramètres seront appliqués immédiatement"

Gestion individuelle des paramètres

Réduction du mouvement uniquement

Script pour gérer uniquement le paramètre de réduction du mouvement :

#!/bin/bash

# Script de configuration de la réduction du mouvement
LOG_FILE="/var/log/accessibility_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Configuration
ENABLE_REDUCE_MOTION=${1:-true}

# Fonction pour enregistrer les messages
log_message() {
    echo "[$TIMESTAMP] $1" | tee -a "$LOG_FILE"
}

# Fonction pour obtenir le statut de réduction du mouvement actuel
get_reduce_motion_status() {
    local username=$1
    
    local motion_setting=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceMotion 2>/dev/null")
    
    if [ -z "$motion_setting" ]; then
        echo "Non configuré"
    else
        if [ "$motion_setting" = "1" ]; then
            echo "Activé"
        else
            echo "Désactivé"
        fi
    fi
}

# Fonction pour configurer la réduction du mouvement
set_reduce_motion() {
    local username=$1
    local enable=$2
    
    log_message "Définition de la réduction du mouvement à: $enable pour l'utilisateur: $username"
    
    # Obtenir le statut actuel
    local current_status=$(get_reduce_motion_status "$username")
    log_message "Statut actuel de la réduction du mouvement: $current_status"
    
    # Appliquer le paramètre
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceMotion -bool $enable"; then
        log_message "SUCCÈS: Réduction du mouvement configurée"
        
        # Vérifier le paramètre
        local new_status=$(get_reduce_motion_status "$username")
        log_message "Nouveau statut de la réduction du mouvement: $new_status"
        
        return 0
    else
        log_message "ERREUR: Échec de la configuration de la réduction du mouvement"
        return 1
    fi
}

# Exécution principale
log_message "Début de la configuration de la réduction du mouvement"

# Valider l'entrée
if [[ "$ENABLE_REDUCE_MOTION" != "true" && "$ENABLE_REDUCE_MOTION" != "false" ]]; then
    log_message "ERREUR: Valeur invalide: $ENABLE_REDUCE_MOTION (doit être true ou false)"
    exit 1
fi

# Obtenir l'utilisateur actuel
loggedInUser=$(ls -l /dev/console | awk '{ print $3 }')

if [ -z "$loggedInUser" ] || [ "$loggedInUser" = "root" ]; then
    log_message "ERREUR: Aucune session utilisateur valide trouvée"
    exit 1
fi

log_message "Utilisateur actuel: $loggedInUser"

# Configurer la réduction du mouvement
if set_reduce_motion "$loggedInUser" "$ENABLE_REDUCE_MOTION"; then
    log_message "Configuration de la réduction du mouvement terminée avec succès"
    echo "✓ Réduction du mouvement configurée avec succès"
    
    # Afficher l'explication selon le paramètre
    if [ "$ENABLE_REDUCE_MOTION" = "true" ]; then
        echo ""
        echo "La réduction du mouvement est maintenant ACTIVÉE:"
        echo "  - Les animations d'interface sont simplifiées"
        echo "  - Les effets de fondu croisé remplacent les animations complexes"
        echo "  - Réduit le mal des transports potentiel"
        echo "  - Améliore les performances sur le matériel plus ancien"
    else
        echo ""
        echo "La réduction du mouvement est maintenant DÉSACTIVÉE:"
        echo "  - Les animations d'interface complètes sont restaurées"
        echo "  - Les effets visuels complexes sont activés"
        echo "  - Expérience visuelle macOS standard"
    fi
else
    log_message "Configuration de la réduction du mouvement échouée"
    exit 1
fi

Réduction de la transparence uniquement

Script pour gérer uniquement le paramètre de réduction de la transparence :

#!/bin/bash

# Script de configuration de la réduction de la transparence
LOG_FILE="/var/log/accessibility_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Configuration
ENABLE_REDUCE_TRANSPARENCY=${1:-true}

# Fonction pour enregistrer les messages
log_message() {
    echo "[$TIMESTAMP] $1" | tee -a "$LOG_FILE"
}

# Fonction pour obtenir le statut de réduction de la transparence actuel
get_reduce_transparency_status() {
    local username=$1
    
    local transparency_setting=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceTransparency 2>/dev/null")
    
    if [ -z "$transparency_setting" ]; then
        echo "Non configuré"
    else
        if [ "$transparency_setting" = "1" ]; then
            echo "Activé"
        else
            echo "Désactivé"
        fi
    fi
}

# Fonction pour configurer la réduction de la transparence
set_reduce_transparency() {
    local username=$1
    local enable=$2
    
    log_message "Définition de la réduction de la transparence à: $enable pour l'utilisateur: $username"
    
    # Obtenir le statut actuel
    local current_status=$(get_reduce_transparency_status "$username")
    log_message "Statut actuel de la réduction de la transparence: $current_status"
    
    # Appliquer le paramètre
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceTransparency -bool $enable"; then
        log_message "SUCCÈS: Réduction de la transparence configurée"
        
        # Vérifier le paramètre
        local new_status=$(get_reduce_transparency_status "$username")
        log_message "Nouveau statut de la réduction de la transparence: $new_status"
        
        return 0
    else
        log_message "ERREUR: Échec de la configuration de la réduction de la transparence"
        return 1
    fi
}

# Exécution principale
log_message "Début de la configuration de la réduction de la transparence"

# Valider l'entrée
if [[ "$ENABLE_REDUCE_TRANSPARENCY" != "true" && "$ENABLE_REDUCE_TRANSPARENCY" != "false" ]]; then
    log_message "ERREUR: Valeur invalide: $ENABLE_REDUCE_TRANSPARENCY (doit être true ou false)"
    exit 1
fi

# Obtenir l'utilisateur actuel
loggedInUser=$(ls -l /dev/console | awk '{ print $3 }')

if [ -z "$loggedInUser" ] || [ "$loggedInUser" = "root" ]; then
    log_message "ERREUR: Aucune session utilisateur valide trouvée"
    exit 1
fi

log_message "Utilisateur actuel: $loggedInUser"

# Configurer la réduction de la transparence
if set_reduce_transparency "$loggedInUser" "$ENABLE_REDUCE_TRANSPARENCY"; then
    log_message "Configuration de la réduction de la transparence terminée avec succès"
    echo "✓ Réduction de la transparence configurée avec succès"
    
    # Afficher l'explication selon le paramètre
    if [ "$ENABLE_REDUCE_TRANSPARENCY" = "true" ]; then
        echo ""
        echo "La réduction de la transparence est maintenant ACTIVÉE:"
        echo "  - Les éléments semi-transparents deviennent solides"
        echo "  - Le dock, la barre de menu et les barres latérales sont opaques"
        echo "  - Améliore la lisibilité et le contraste"
        echo "  - Meilleures performances sur le matériel plus ancien"
    else
        echo ""
        echo "La réduction de la transparence est maintenant DÉSACTIVÉE:"
        echo "  - Les éléments semi-transparents sont restaurés"
        echo "  - Les effets de flou et de transparence sont activés"
        echo "  - Expérience visuelle macOS standard"
    fi
else
    log_message "Configuration de la réduction de la transparence échouée"
    exit 1
fi

Gestion complète de l'accessibilité

Script d'accessibilité tout-en-un

Script pour gérer plusieurs paramètres d'accessibilité :

#!/bin/bash

# Script de configuration complète d'accessibilité
LOG_FILE="/var/log/accessibility_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Options de configuration
REDUCE_MOTION=${1:-true}
REDUCE_TRANSPARENCY=${2:-true}
INCREASE_CONTRAST=${3:-false}
DIFFERENTIATE_WITHOUT_COLOR=${4:-false}

# Fonction pour enregistrer les messages
log_message() {
    echo "[$TIMESTAMP] $1" | tee -a "$LOG_FILE"
}

# Fonction pour obtenir tous les paramètres d'accessibilité
get_all_accessibility_settings() {
    local username=$1
    
    log_message "Obtention de tous les paramètres d'accessibilité pour l'utilisateur: $username"
    
    # Obtenir divers paramètres d'accessibilité
    local motion=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceMotion 2>/dev/null" || echo "Non défini")
    local transparency=$(su -l "$username" -c "defaults read com.apple.universalaccess reduceTransparency 2>/dev/null" || echo "Non défini")
    local contrast=$(su -l "$username" -c "defaults read com.apple.universalaccess increaseContrast 2>/dev/null" || echo "Non défini")
    local diff_color=$(su -l "$username" -c "defaults read com.apple.universalaccess differentiateWithoutColor 2>/dev/null" || echo "Non défini")
    
    echo "Paramètres d'accessibilité actuels:"
    echo "=================================="
    echo "  Réduction du mouvement: $motion"
    echo "  Réduction de la transparence: $transparency"
    echo "  Augmentation du contraste: $contrast"
    echo "  Différenciation sans couleur: $diff_color"
    echo ""
    
    log_message "Paramètres actuels - Mouvement: $motion, Transparence: $transparency, Contraste: $contrast, Couleur: $diff_color"
}

# Fonction pour configurer tous les paramètres d'accessibilité
configure_all_accessibility() {
    local username=$1
    local motion=$2
    local transparency=$3
    local contrast=$4
    local diff_color=$5
    
    log_message "Configuration de tous les paramètres d'accessibilité pour l'utilisateur: $username"
    
    local success=0
    
    # Configurer la réduction du mouvement
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceMotion -bool $motion"; then
        log_message "SUCCÈS: Réduction du mouvement définie à $motion"
    else
        log_message "ERREUR: Échec de la définition de la réduction du mouvement"
        success=1
    fi
    
    # Configurer la réduction de la transparence
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceTransparency -bool $transparency"; then
        log_message "SUCCÈS: Réduction de la transparence définie à $transparency"
    else
        log_message "ERREUR: Échec de la définition de la réduction de la transparence"
        success=1
    fi
    
    # Configurer l'augmentation du contraste
    if su -l "$username" -c "defaults write com.apple.universalaccess increaseContrast -bool $contrast"; then
        log_message "SUCCÈS: Augmentation du contraste définie à $contrast"
    else
        log_message "ERREUR: Échec de la définition de l'augmentation du contraste"
        success=1
    fi
    
    # Configurer la différenciation sans couleur
    if su -l "$username" -c "defaults write com.apple.universalaccess differentiateWithoutColor -bool $diff_color"; then
        log_message "SUCCÈS: Différenciation sans couleur définie à $diff_color"
    else
        log_message "ERREUR: Échec de la définition de la différenciation sans couleur"
        success=1
    fi
    
    return $success
}

# Fonction pour créer un rapport d'accessibilité
create_accessibility_report() {
    local username=$1
    local report_file="/tmp/accessibility_report_${username}.txt"
    
    log_message "Création du rapport d'accessibilité pour l'utilisateur: $username"
    
    {
        echo "Rapport de configuration d'accessibilité"
        echo "========================================"
        echo "Utilisateur: $username"
        echo "Date: $(date)"
        echo ""
        echo "Paramètres configurés:"
        echo "  Réduction du mouvement: $REDUCE_MOTION"
        echo "  Réduction de la transparence: $REDUCE_TRANSPARENCY"
        echo "  Augmentation du contraste: $INCREASE_CONTRAST"
        echo "  Différenciation sans couleur: $DIFFERENTIATE_WITHOUT_COLOR"
        echo ""
        echo "Impact sur l'expérience utilisateur:"
        echo "-----------------------------------"
        
        if [ "$REDUCE_MOTION" = "true" ]; then
            echo "• Effets de mouvement réduits - expérience plus fluide pour les utilisateurs sensibles au mouvement"
        fi
        
        if [ "$REDUCE_TRANSPARENCY" = "true" ]; then
            echo "• Éléments d'interface solides - lisibilité et performances améliorées"
        fi
        
        if [ "$INCREASE_CONTRAST" = "true" ]; then
            echo "• Contraste amélioré - meilleure visibilité pour les utilisateurs avec déficiences visuelles"
        fi
        
        if [ "$DIFFERENTIATE_WITHOUT_COLOR" = "true" ]; then
            echo "• Différenciation indépendante de la couleur - accessibilité pour les utilisateurs daltoniens"
        fi
        
        echo ""
        echo "Performances système:"
        echo "• Utilisation GPU réduite grâce aux effets désactivés"
        echo "• Autonomie améliorée sur les ordinateurs portables"
        echo "• Meilleures performances sur le matériel plus ancien"
        
    } > "$report_file"
    
    echo "Rapport d'accessibilité créé: $report_file"
    log_message "Rapport d'accessibilité créé: $report_file"
}

# Exécution principale
log_message "Début de la configuration complète d'accessibilité"

# Valider les entrées
for setting in "$REDUCE_MOTION" "$REDUCE_TRANSPARENCY" "$INCREASE_CONTRAST" "$DIFFERENTIATE_WITHOUT_COLOR"; do
    if [[ "$setting" != "true" && "$setting" != "false" ]]; then
        log_message "ERREUR: Valeur de paramètre invalide: $setting (doit être true ou false)"
        exit 1
    fi
done

# Obtenir l'utilisateur actuel
loggedInUser=$(ls -l /dev/console | awk '{ print $3 }')

if [ -z "$loggedInUser" ] || [ "$loggedInUser" = "root" ]; then
    log_message "ERREUR: Aucune session utilisateur valide trouvée"
    exit 1
fi

log_message "Utilisateur actuel: $loggedInUser"

# Afficher les paramètres actuels
get_all_accessibility_settings "$loggedInUser"

# Configurer tous les paramètres d'accessibilité
if configure_all_accessibility "$loggedInUser" "$REDUCE_MOTION" "$REDUCE_TRANSPARENCY" "$INCREASE_CONTRAST" "$DIFFERENTIATE_WITHOUT_COLOR"; then
    log_message "Tous les paramètres d'accessibilité configurés avec succès"
    echo "✓ Tous les paramètres d'accessibilité configurés avec succès"
    
    # Créer le rapport
    create_accessibility_report "$loggedInUser"
    
    # Afficher les nouveaux paramètres
    echo ""
    echo "Paramètres mis à jour:"
    get_all_accessibility_settings "$loggedInUser"
    
else
    log_message "Certains paramètres d'accessibilité ont échoué à la configuration"
    echo "⚠ Certains paramètres d'accessibilité peuvent ne pas avoir été configurés correctement"
    exit 1
fi

log_message "Configuration complète d'accessibilité terminée"

Scripts de déploiement d'entreprise

Configuration multi-utilisateur

Script pour configurer les paramètres d'accessibilité sur plusieurs utilisateurs :

#!/bin/bash

# Script de configuration d'accessibilité multi-utilisateur
LOG_FILE="/var/log/accessibility_deployment.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Configuration
REDUCE_MOTION=${1:-true}
REDUCE_TRANSPARENCY=${2:-true}
TARGET_USERS=${3:-"all"}  # "all" ou liste d'utilisateurs séparés par des virgules

# Fonction pour enregistrer les messages
log_message() {
    echo "[$TIMESTAMP] $1" | tee -a "$LOG_FILE"
}

# Fonction pour obtenir tous les utilisateurs réguliers
get_all_users() {
    # Obtenir les utilisateurs avec UID >= 500 (utilisateurs réguliers)
    local users=$(dscl . -list /Users UniqueID | awk '$2 >= 500 && $2 < 65534 { print $1 }')
    echo "$users"
}

# Fonction pour analyser les utilisateurs cibles
parse_target_users() {
    local target=$1
    
    if [ "$target" = "all" ]; then
        get_all_users
    else
        echo "$target" | tr ',' '\n'
    fi
}

# Fonction pour configurer l'accessibilité d'un utilisateur
configure_user_accessibility() {
    local username=$1
    local motion=$2
    local transparency=$3
    
    log_message "Configuration de l'accessibilité pour l'utilisateur: $username"
    
    # Vérifier si l'utilisateur existe
    if ! id "$username" &>/dev/null; then
        log_message "AVERTISSEMENT: L'utilisateur $username n'existe pas"
        return 1
    fi
    
    # Vérifier si l'utilisateur a un répertoire home
    local home_dir=$(eval echo ~$username)
    if [ ! -d "$home_dir" ]; then
        log_message "AVERTISSEMENT: Répertoire home non trouvé pour l'utilisateur: $username"
        return 1
    fi
    
    # Configurer les paramètres
    local success=0
    
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceMotion -bool $motion"; then
        log_message "SUCCÈS: Réduction du mouvement configurée pour $username"
    else
        log_message "ERREUR: Échec de la configuration de la réduction du mouvement pour $username"
        success=1
    fi
    
    if su -l "$username" -c "defaults write com.apple.universalaccess reduceTransparency -bool $transparency"; then
        log_message "SUCCÈS: Réduction de la transparence configurée pour $username"
    else
        log_message "ERREUR: Échec de la configuration de la réduction de la transparence pour $username"
        success=1
    fi
    
    if [ $success -eq 0 ]; then
        log_message "SUCCÈS: Tous les paramètres d'accessibilité configurés pour $username"
        return 0
    else
        log_message "ERREUR: Certains paramètres ont échoué pour $username"
        return 1
    fi
}

# Exécution principale
log_message "Début du déploiement d'accessibilité multi-utilisateur"

# Analyser les utilisateurs cibles
target_users=$(parse_target_users "$TARGET_USERS")

if [ -z "$target_users" ]; then
    log_message "ERREUR: Aucun utilisateur cible spécifié"
    exit 1
fi

log_message "Utilisateurs cibles: $target_users"

# Configurer chaque utilisateur
successful=0
failed=0

for user in $target_users; do
    echo "Configuration de l'accessibilité pour l'utilisateur: $user"
    
    if configure_user_accessibility "$user" "$REDUCE_MOTION" "$REDUCE_TRANSPARENCY"; then
        echo "  ✓ Succès"
        ((successful++))
    else
        echo "  ✗ Échec"
        ((failed++))
    fi
done

log_message "Déploiement multi-utilisateur terminé"
log_message "Configurés avec succès: $successful utilisateurs"
log_message "Échecs: $failed utilisateurs"

echo ""
echo "Résumé du déploiement:"
echo "  Configurés avec succès: $successful utilisateurs"
echo "  Échecs: $failed utilisateurs"
echo "  Fichier journal: $LOG_FILE"

if [ $failed -gt 0 ]; then
    exit 1
fi

Meilleures pratiques et recommandations

1. Considérations de performance

• Surveiller les performances système avant et après les changements
• Considérer l'impact sur le matériel plus ancien
• Tester les paramètres sur différents modèles de Mac
• Documenter les améliorations de performance

2. Expérience utilisateur

• Communiquer les changements aux utilisateurs à l'avance
• Fournir une formation sur le nouveau comportement d'interface
• Offrir des options de désactivation le cas échéant
• Recueillir les commentaires des utilisateurs sur les améliorations d'accessibilité

3. Gestion d'entreprise

• Standardiser les politiques d'accessibilité sur les appareils
• Utiliser des outils de gestion de configuration pour le déploiement
• Implémenter la surveillance de la conformité des paramètres
• Maintenir la documentation de toutes les personnalisations

4. Conformité à l'accessibilité

• S'assurer que les paramètres répondent aux exigences d'accessibilité
• Considérer différents types de handicaps
• Tester avec les technologies d'assistance
• Suivre les directives WCAG le cas échéant

Conclusion

La gestion efficace des paramètres de mouvement et de transparence est cruciale pour créer des environnements Mac accessibles et performants. Les scripts et techniques fournis dans ce guide offrent des solutions complètes pour divers scénarios de configuration d'accessibilité.

Points clés à retenir :

• Comprendre l'impact des paramètres d'accessibilité sur l'expérience utilisateur
• Utiliser des scripts appropriés pour différents scénarios de déploiement
• Implémenter des procédures de test et de validation appropriées
• Surveiller les performances système et les commentaires des utilisateurs
• Considérer les besoins d'accessibilité de toute votre base d'utilisateurs

N'oubliez pas que les paramètres d'accessibilité impactent significativement l'expérience utilisateur, donc testez toujours les changements soigneusement et considérez offrir aux utilisateurs des options pour personnaliser leur expérience selon leurs besoins individuels.

Gestion d'Entreprise des Proxies sur macOS

Configurez et gérez les paramètres de proxy d'entreprise sur vos appareils Roundfleet en utilisant des commandes networksetup avancées. Ce tutoriel couvre tous les types de proxy incluant web, web sécurisé, streaming, Gopher et SOCKS firewall avec des capacités de gestion de niveau entreprise.

Comprendre la Gestion des Proxies macOS

macOS fournit une configuration de proxy complète via l'utilitaire en ligne de commande networksetup, supportant :

• Proxy Web (HTTP) - Routage du trafic HTTP standard
• Proxy Web Sécurisé (HTTPS) - Trafic HTTPS chiffré avec sécurité de bout en bout
• Proxy Streaming - Optimisation du contenu multimédia (déprécié dans macOS 13.0+)
• Proxy Gopher - Support du protocole Gopher hérité (déprécié dans macOS 13.0+)
• Proxy Firewall SOCKS - Protocole générique supportant la plupart des applications

Configuration du Proxy Web

Configuration de Base du Proxy Web

#!/bin/bash

# Configurer le proxy web HTTP
NETWORK_SERVICE="Wi-Fi"
PROXY_SERVER="proxy.entreprise.com"
PROXY_PORT="8080"
AUTHENTICATED="on"
USERNAME="utilisateurproxy"
PASSWORD="motdepasseproxy"

# Définir la configuration du proxy web
networksetup -setwebproxy "$NETWORK_SERVICE" "$PROXY_SERVER" "$PROXY_PORT" "$AUTHENTICATED" "$USERNAME" "$PASSWORD"

# Activer le proxy web
networksetup -setwebproxystate "$NETWORK_SERVICE" on

echo "Proxy web configuré avec succès pour $NETWORK_SERVICE"

Gestion Avancée du Proxy Web

#!/bin/bash

# Système de Configuration de Proxy Web d'Entreprise
NETWORK_SERVICE="Wi-Fi"
CONFIG_FILE="/etc/roundfleet/proxy_config.conf"
LOG_FILE="/var/log/roundfleet_proxy.log"

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

# Charger la configuration proxy depuis un fichier
load_proxy_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
        log_action "Configuration proxy chargée depuis $CONFIG_FILE"
    else
        echo "Fichier de configuration non trouvé : $CONFIG_FILE"
        exit 1
    fi
}

# Configurer le proxy web avec validation
configure_web_proxy() {
    local server="$1"
    local port="$2"
    local auth="$3"
    local username="$4"
    local password="$5"
    
    # Valider l'existence du service réseau
    if ! networksetup -listallnetworkservices | grep -q "^$NETWORK_SERVICE$"; then
        log_action "ERREUR : Service réseau '$NETWORK_SERVICE' non trouvé"
        return 1
    fi
    
    # Tester la connectivité proxy
    if ! nc -z "$server" "$port" 2>/dev/null; then
        log_action "ATTENTION : Impossible d'atteindre le serveur proxy $server:$port"
    fi
    
    # Configurer le proxy
    if networksetup -setwebproxy "$NETWORK_SERVICE" "$server" "$port" "$auth" "$username" "$password"; then
        networksetup -setwebproxystate "$NETWORK_SERVICE" on
        log_action "Proxy web configuré : $server:$port (Auth : $auth)"
        return 0
    else
        log_action "ERREUR : Échec de la configuration du proxy web"
        return 1
    fi
}

# Vérifier la configuration proxy
verify_proxy_config() {
    local proxy_info
    proxy_info=$(networksetup -getwebproxy "$NETWORK_SERVICE")
    
    echo "Configuration Actuelle du Proxy Web :"
    echo "$proxy_info"
    
    if echo "$proxy_info" | grep -q "Enabled: Yes"; then
        log_action "Vérification du proxy web réussie"
        return 0
    else
        log_action "Vérification du proxy web échouée"
        return 1
    fi
}

# Exécution principale
main() {
    log_action "Démarrage de la configuration du proxy web"
    
    # Exemple de configuration (remplacer par les vraies valeurs)
    configure_web_proxy "proxy.entreprise.com" "8080" "on" "utilisateurproxy" "motdepasseproxy"
    
    # Vérifier la configuration
    verify_proxy_config
    
    log_action "Configuration du proxy web terminée"
}

# Exécuter si le script est lancé directement
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi

Proxy Web Sécurisé (HTTPS)

Configuration de Base du Proxy HTTPS

#!/bin/bash

# Configurer le proxy web sécurisé HTTPS
networksetup -setsecurewebproxy "Wi-Fi" "proxy-securise.entreprise.com" "8443" on "utilisateursecurise" "motdepassesecurise"
networksetup -setsecurewebproxystate "Wi-Fi" on

echo "Proxy web sécurisé configuré avec succès"

Gestion d'Entreprise du Proxy HTTPS

#!/bin/bash

# Configuration du Proxy Web Sécurisé d'Entreprise
configure_secure_proxy() {
    local network_service="$1"
    local proxy_server="$2"
    local proxy_port="$3"
    local username="$4"
    local password="$5"
    
    echo "Configuration du proxy web sécurisé pour $network_service..."
    
    # Valider la connectivité SSL/TLS
    if openssl s_client -connect "$proxy_server:$proxy_port" -verify_return_error < /dev/null 2>/dev/null; then
        echo "✅ Connectivité SSL vérifiée pour $proxy_server:$proxy_port"
    else
        echo "⚠️  ATTENTION : Problèmes de connectivité SSL détectés"
    fi
    
    # Configurer le proxy sécurisé
    if networksetup -setsecurewebproxy "$network_service" "$proxy_server" "$proxy_port" on "$username" "$password"; then
        networksetup -setsecurewebproxystate "$network_service" on
        echo "✅ Proxy web sécurisé configuré avec succès"
        
        # Vérifier la configuration
        echo "Détails de configuration :"
        networksetup -getsecurewebproxy "$network_service"
        
        return 0
    else
        echo "❌ Échec de la configuration du proxy web sécurisé"
        return 1
    fi
}

# Validation des certificats pour les proxies sécurisés
validate_proxy_certificate() {
    local proxy_server="$1"
    local proxy_port="$2"
    
    echo "Validation du certificat proxy..."
    
    local cert_info
    cert_info=$(openssl s_client -connect "$proxy_server:$proxy_port" -servername "$proxy_server" < /dev/null 2>/dev/null | openssl x509 -text -noout)
    
    if [[ -n "$cert_info" ]]; then
        echo "Validation du certificat réussie"
        echo "Sujet du certificat : $(echo "$cert_info" | grep "Subject:" | head -1)"
        echo "Émetteur du certificat : $(echo "$cert_info" | grep "Issuer:" | head -1)"
        return 0
    else
        echo "Validation du certificat échouée"
        return 1
    fi
}

# Exemple d'utilisation
configure_secure_proxy "Wi-Fi" "proxy-securise.entreprise.com" "8443" "utilisateursecurise" "motdepassesecurise"
validate_proxy_certificate "proxy-securise.entreprise.com" "8443"

Proxy Firewall SOCKS

Configuration de Base du Proxy SOCKS

#!/bin/bash

# Configurer le proxy firewall SOCKS
networksetup -setsocksfirewallproxy "Wi-Fi" "proxy-socks.entreprise.com" "1080" on "utilisateursocks" "motdepassesocks"
networksetup -setsocksfirewallproxystate "Wi-Fi" on

echo "Proxy firewall SOCKS configuré avec succès"

Gestion Avancée du Proxy SOCKS

#!/bin/bash

# Système de Configuration de Proxy SOCKS d'Entreprise
setup_socks_proxy() {
    local network_service="$1"
    local socks_server="$2"
    local socks_port="$3"
    local auth_required="$4"
    local username="$5"
    local password="$6"
    
    echo "Configuration du proxy SOCKS : $socks_server:$socks_port"
    
    # Tester la connectivité SOCKS
    if command -v nc >/dev/null 2>&1; then
        if nc -z "$socks_server" "$socks_port" 2>/dev/null; then
            echo "✅ Connectivité proxy SOCKS vérifiée"
        else
            echo "⚠️  ATTENTION : Impossible d'atteindre le proxy SOCKS"
        fi
    fi
    
    # Configurer le proxy SOCKS
    if networksetup -setsocksfirewallproxy "$network_service" "$socks_server" "$socks_port" "$auth_required" "$username" "$password"; then
        networksetup -setsocksfirewallproxystate "$network_service" on
        echo "✅ Proxy firewall SOCKS configuré"
        
        # Vérifier la configuration
        echo "Détails du proxy SOCKS :"
        networksetup -getsocksfirewallproxy "$network_service"
        
        return 0
    else
        echo "❌ Échec de la configuration du proxy SOCKS"
        return 1
    fi
}

# Tester la fonctionnalité du proxy SOCKS
test_socks_proxy() {
    local test_url="http://httpbin.org/ip"
    
    echo "Test de la fonctionnalité du proxy SOCKS..."
    
    # Test avec curl via le proxy SOCKS
    if command -v curl >/dev/null 2>&1; then
        local proxy_response
        proxy_response=$(curl -s --socks5 "proxy-socks.entreprise.com:1080" "$test_url" 2>/dev/null)
        
        if [[ -n "$proxy_response" ]]; then
            echo "✅ Test du proxy SOCKS réussi"
            echo "Réponse : $proxy_response"
        else
            echo "❌ Test du proxy SOCKS échoué"
        fi
    else
        echo "curl non disponible pour les tests"
    fi
}

# Utilisation
setup_socks_proxy "Wi-Fi" "proxy-socks.entreprise.com" "1080" "on" "utilisateursocks" "motdepassesocks"
test_socks_proxy

Support des Proxies Hérités (macOS < 13.0)

Configuration du Proxy Streaming

#!/bin/bash

# Configurer le proxy streaming (déprécié dans macOS 13.0+)
check_macos_version() {
    local version
    version=$(sw_vers -productVersion)
    local major_version
    major_version=$(echo "$version" | cut -d. -f1)
    
    if [[ "$major_version" -ge 13 ]]; then
        echo "⚠️  Proxy streaming non supporté sur macOS 13.0+"
        return 1
    fi
    return 0
}

configure_streaming_proxy() {
    if check_macos_version; then
        networksetup -setstreamingproxy "Wi-Fi" "proxy-stream.entreprise.com" "8080" on "utilisateurstream" "motdepassestream"
        networksetup -setstreamingproxystate "Wi-Fi" on
        echo "✅ Proxy streaming configuré"
    else
        echo "❌ Proxy streaming non disponible sur cette version de macOS"
    fi
}

configure_gopher_proxy() {
    if check_macos_version; then
        networksetup -setgopherproxy "Wi-Fi" "proxy-gopher.entreprise.com" "70" on "utilisateurgopher" "motdepassegopher"
        networksetup -setgopherproxystate "Wi-Fi" on
        echo "✅ Proxy Gopher configuré"
    else
        echo "❌ Proxy Gopher non disponible sur cette version de macOS"
    fi
}

# Exécuter la configuration des proxies hérités
configure_streaming_proxy
configure_gopher_proxy

Système de Gestion de Proxy d'Entreprise

#!/bin/bash

# Système de Gestion de Proxy d'Entreprise Roundfleet
# Configuration et surveillance complètes des proxies

# Configuration
PROXY_CONFIG_DIR="/etc/roundfleet/proxy"
LOG_FILE="/var/log/roundfleet_proxy.log"
BACKUP_DIR="/var/backups/roundfleet/proxy"
API_ENDPOINT="https://api.roundfleet.com/v1/proxy"

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

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

# Obtenir tous les services réseau
get_network_services() {
    networksetup -listallnetworkservices | grep -v "^An asterisk"
}

# Sauvegarder les paramètres proxy actuels
backup_proxy_settings() {
    local backup_file="$BACKUP_DIR/proxy_backup_$(date +%Y%m%d_%H%M%S).json"
    
    echo "{" > "$backup_file"
    echo "  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"," >> "$backup_file"
    echo "  \"hostname\": \"$(hostname)\"," >> "$backup_file"
    echo "  \"network_services\": {" >> "$backup_file"
    
    local first=true
    while IFS= read -r service; do
        if [[ "$first" == "false" ]]; then
            echo "," >> "$backup_file"
        fi
        first=false
        
        echo "    \"$service\": {" >> "$backup_file"
        echo "      \"web_proxy\": $(networksetup -getwebproxy "$service" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")" >> "$backup_file"
        echo "      \"secure_web_proxy\": $(networksetup -getsecurewebproxy "$service" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")" >> "$backup_file"
        echo "      \"socks_proxy\": $(networksetup -getsocksfirewallproxy "$service" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")" >> "$backup_file"
        echo "    }" >> "$backup_file"
    done < <(get_network_services)
    
    echo "  }" >> "$backup_file"
    echo "}" >> "$backup_file"
    
    log_action "Paramètres proxy sauvegardés dans : $backup_file"
}

# Configurer le proxy depuis une configuration JSON
configure_from_json() {
    local config_file="$1"
    
    if [[ ! -f "$config_file" ]]; then
        log_action "ERREUR : Fichier de configuration non trouvé : $config_file"
        return 1
    fi
    
    log_action "Application de la configuration proxy depuis : $config_file"
    
    # Analyser JSON et appliquer les paramètres avec jq ou python
    if command -v jq >/dev/null 2>&1; then
        # Utiliser jq pour l'analyse JSON
        local networks
        networks=$(jq -r '.networks | keys[]' "$config_file")
        
        while IFS= read -r network; do
            local web_proxy
            web_proxy=$(jq -r ".networks[\"$network\"].web_proxy" "$config_file")
            
            if [[ "$web_proxy" != "null" ]]; then
                local server port auth username password
                server=$(echo "$web_proxy" | jq -r '.server')
                port=$(echo "$web_proxy" | jq -r '.port')
                auth=$(echo "$web_proxy" | jq -r '.authentication')
                username=$(echo "$web_proxy" | jq -r '.username')
                password=$(echo "$web_proxy" | jq -r '.password')
                
                networksetup -setwebproxy "$network" "$server" "$port" "$auth" "$username" "$password"
                networksetup -setwebproxystate "$network" on
                
                log_action "Proxy web configuré pour $network : $server:$port"
            fi
        done <<< "$networks"
    else
        log_action "ERREUR : jq non disponible pour l'analyse JSON"
        return 1
    fi
}

# Surveiller la connectivité proxy
monitor_proxy_connectivity() {
    log_action "Démarrage de la surveillance de connectivité proxy"
    
    while IFS= read -r service; do
        local web_proxy_info
        web_proxy_info=$(networksetup -getwebproxy "$service")
        
        if echo "$web_proxy_info" | grep -q "Enabled: Yes"; then
            local server port
            server=$(echo "$web_proxy_info" | grep "Server:" | awk '{print $2}')
            port=$(echo "$web_proxy_info" | grep "Port:" | awk '{print $2}')
            
            if nc -z "$server" "$port" 2>/dev/null; then
                log_action "✅ Connectivité proxy OK : $service ($server:$port)"
            else
                log_action "❌ Connectivité proxy ÉCHOUÉE : $service ($server:$port)"
            fi
        fi
    done < <(get_network_services)
}

# Effacer tous les paramètres proxy
clear_all_proxies() {
    log_action "Effacement de tous les paramètres proxy"
    
    while IFS= read -r service; do
        # Désactiver tous les types de proxy
        networksetup -setwebproxystate "$service" off
        networksetup -setsecurewebproxystate "$service" off
        networksetup -setsocksfirewallproxystate "$service" off
        
        # Pour les versions plus anciennes de macOS
        networksetup -setstreamingproxystate "$service" off 2>/dev/null || true
        networksetup -setgopherproxystate "$service" off 2>/dev/null || true
        
        log_action "Proxies effacés pour : $service"
    done < <(get_network_services)
}

# Générer un rapport de statut proxy
generate_proxy_report() {
    local report_file="$PROXY_CONFIG_DIR/proxy_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de Statut Proxy Roundfleet"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "=================================="
        echo ""
        
        while IFS= read -r service; do
            echo "Service Réseau : $service"
            echo "--------------------------------"
            
            echo "Proxy Web :"
            networksetup -getwebproxy "$service" | sed 's/^/  /'
            echo ""
            
            echo "Proxy Web Sécurisé :"
            networksetup -getsecurewebproxy "$service" | sed 's/^/  /'
            echo ""
            
            echo "Proxy Firewall SOCKS :"
            networksetup -getsocksfirewallproxy "$service" | sed 's/^/  /'
            echo ""
            
            echo "=================================="
            echo ""
        done < <(get_network_services)
    } > "$report_file"
    
    echo "Rapport proxy généré : $report_file"
    log_action "Rapport de statut proxy généré : $report_file"
}

# Fonction principale
main() {
    local action="${1:-status}"
    
    setup_directories
    log_action "Gestion Proxy Roundfleet démarrée avec l'action : $action"
    
    case "$action" in
        "backup")
            backup_proxy_settings
            ;;
        "configure")
            configure_from_json "$2"
            ;;
        "monitor")
            monitor_proxy_connectivity
            ;;
        "clear")
            backup_proxy_settings
            clear_all_proxies
            ;;
        "report")
            generate_proxy_report
            ;;
        "status"|*)
            generate_proxy_report
            monitor_proxy_connectivity
            ;;
    esac
    
    log_action "Gestion Proxy Roundfleet terminée"
}

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

Modèles de Configuration Proxy

Modèle de Proxy Web d'Entreprise

# /etc/roundfleet/proxy/proxy_web_entreprise.conf
PROXY_TYPE="web"
NETWORK_SERVICE="Wi-Fi"
PROXY_SERVER="proxy.entreprise.com"
PROXY_PORT="8080"
AUTHENTICATION="on"
USERNAME="nom_utilisateur_employe"
PASSWORD="motdepasse_employe"
AUTO_CONFIG_URL=""
BYPASS_LIST="*.entreprise.com,localhost,127.0.0.1"

Modèle d'Entreprise Sécurisé

# /etc/roundfleet/proxy/entreprise_securise.conf
PROXY_TYPE="secure_web"
NETWORK_SERVICE="Wi-Fi"
PROXY_SERVER="proxy-securise.entreprise.com"
PROXY_PORT="8443"
AUTHENTICATION="on"
USERNAME="utilisateur_securise"
PASSWORD="motdepasse_securise"
SSL_VERIFICATION="enabled"
CERTIFICATE_PINNING="enabled"

Modèle de Proxy SOCKS

# /etc/roundfleet/proxy/proxy_socks.conf
PROXY_TYPE="socks"
NETWORK_SERVICE="Wi-Fi"
PROXY_SERVER="socks.entreprise.com"
PROXY_PORT="1080"
AUTHENTICATION="on"
USERNAME="utilisateur_socks"
PASSWORD="motdepasse_socks"
SOCKS_VERSION="5"

Considérations de Sécurité

Sécurité d'Authentification Proxy

#!/bin/bash

# Gestion sécurisée des identifiants proxy
encrypt_credentials() {
    local username="$1"
    local password="$2"
    local keychain="Roundfleet-Proxy"
    
    # Stocker les identifiants dans le trousseau
    security add-generic-password -a "$username" -s "proxy-credentials" -w "$password" -T "" "$keychain" 2>/dev/null
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Identifiants stockés de façon sécurisée dans le trousseau"
    else
        echo "❌ Échec du stockage des identifiants dans le trousseau"
    fi
}

# Récupérer les identifiants depuis le trousseau
decrypt_credentials() {
    local username="$1"
    local keychain="Roundfleet-Proxy"
    
    local password
    password=$(security find-generic-password -a "$username" -s "proxy-credentials" -w "$keychain" 2>/dev/null)
    
    if [[ -n "$password" ]]; then
        echo "$password"
    else
        echo "ERREUR : Impossible de récupérer le mot de passe pour $username"
        return 1
    fi
}

Notes de Configuration Importantes

Noms des Services Réseau

• Les noms de service sont sensibles à la casse
• Utilisez des guillemets pour les noms avec espaces : "Wi-Fi"
• Services communs : "Wi-Fi", "Ethernet", "USB 10/100/1000 LAN"

Authentification Proxy

• Définir authenticated à "on" pour activer l'authentification
• Définir authenticated à "off" pour désactiver l'authentification
• Les identifiants seront demandés si l'authentification est activée mais non fournie

Compatibilité des Versions macOS

• Proxy Streaming : Déprécié dans macOS 13.0+
• Proxy Gopher : Déprécié dans macOS 13.0+
• Web/Web Sécurisé/SOCKS : Disponible sur toutes les versions macOS supportées

Gestion des Erreurs

• Les configurations proxy existantes montreront des erreurs lors de la reconfiguration
• Utiliser networksetup -setproxystate pour désactiver avant de reconfigurer
• Tester la connectivité avant d'appliquer aux appareils de la flotte

Meilleures Pratiques

1. Toujours sauvegarder les paramètres actuels avant les changements
2. Tester la connectivité après la configuration proxy
3. Utiliser un stockage sécurisé pour les identifiants proxy
4. Surveiller la santé des proxies en continu
5. Valider les certificats pour les proxies HTTPS
6. Documenter les configurations pour la conformité
7. Implémenter la journalisation pour les pistes d'audit
8. Tester sur des appareils individuels avant le déploiement de flotte

N'oubliez pas de valider tous les scripts sur des appareils de test avant de les déployer sur votre environnement Roundfleet, et assurez-vous que les serveurs proxy sont accessibles et correctement configurés pour votre infrastructure réseau.