Contrôlez la fonctionnalité AirDrop sur vos appareils MacFleet pour améliorer la sécurité et prévenir les transferts de fichiers non autorisés. Ce tutoriel couvre l'activation, la désactivation, la surveillance et la gestion des paramètres AirDrop pour la conformité d'entreprise et la protection des données.

Comprendre AirDrop sur macOS

AirDrop est la technologie de partage de fichiers sans fil d'Apple qui permet aux utilisateurs de transférer des fichiers entre les appareils Apple proches, notamment :

• Ordinateurs Mac fonctionnant sous macOS Lion (10.7) ou ultérieur
• Appareils iOS (iPhone, iPad, iPod touch) avec iOS 7 ou ultérieur
• Apple Watch pour les types de contenu pris en charge

Considérations de Sécurité

Dans les environnements d'entreprise, AirDrop peut poser des risques de sécurité :

• Fuite de données par des transferts de fichiers non autorisés
• Distribution de malware via des fichiers infectés
• Violations des politiques d'entreprise par un partage incontrôlé
• Sécurité réseau contournant les contrôles traditionnels de transfert de fichiers

Commandes de Contrôle AirDrop de Base

Désactiver la Fonctionnalité AirDrop

#!/bin/sh

# Désactiver AirDrop en arrêtant l'interface AWDL
sudo ifconfig awdl0 down

echo "Fonctionnalité AirDrop désactivée"

Activer la Fonctionnalité AirDrop

#!/bin/sh

# Activer AirDrop en démarrant l'interface AWDL
sudo ifconfig awdl0 up

echo "Fonctionnalité AirDrop activée"

Vérifier le Statut d'AirDrop

#!/bin/bash

# Vérifier le statut actuel de l'interface AirDrop/AWDL
check_airdrop_status() {
    local awdl_status
    awdl_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}')
    
    if [[ "$awdl_status" == "active" ]]; then
        echo "AirDrop : ACTIVÉ"
        return 0
    elif [[ "$awdl_status" == "inactive" ]]; then
        echo "AirDrop : DÉSACTIVÉ"
        return 1
    else
        echo "AirDrop : STATUT INCONNU"
        return 2
    fi
}

check_airdrop_status

Gestion Avancée d'AirDrop

Script de Contrôle AirDrop Complet

#!/bin/bash

# Gestion avancée d'AirDrop avec validation et journalisation
manage_airdrop() {
    local action="$1"
    local force="${2:-false}"
    
    # Valider les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "Erreur : Ce script nécessite des privilèges administrateur"
        echo "Veuillez exécuter avec sudo : sudo $0"
        exit 1
    fi
    
    case "$action" in
        "disable")
            echo "Désactivation de la fonctionnalité AirDrop..."
            
            # Vérifier le statut actuel
            local current_status
            current_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}')
            
            if [[ "$current_status" == "inactive" ]]; then
                echo "AirDrop est déjà désactivé"
                return 0
            fi
            
            # Désactiver l'interface AWDL
            if ifconfig awdl0 down 2>/dev/null; then
                echo "✓ AirDrop désactivé avec succès"
                
                # Vérifier le changement
                sleep 2
                local new_status
                new_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}')
                
                if [[ "$new_status" == "inactive" ]]; then
                    echo "✓ Statut AirDrop vérifié : DÉSACTIVÉ"
                    return 0
                else
                    echo "⚠ Attention : Échec de la vérification du statut AirDrop"
                    return 1
                fi
            else
                echo "✗ Échec de la désactivation d'AirDrop"
                return 1
            fi
            ;;
        "enable")
            echo "Activation de la fonctionnalité AirDrop..."
            
            # Vérifier le statut actuel
            local current_status
            current_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}')
            
            if [[ "$current_status" == "active" ]]; then
                echo "AirDrop est déjà activé"
                return 0
            fi
            
            # Activer l'interface AWDL
            if ifconfig awdl0 up 2>/dev/null; then
                echo "✓ AirDrop activé avec succès"
                
                # Vérifier le changement
                sleep 2
                local new_status
                new_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}')
                
                if [[ "$new_status" == "active" ]]; then
                    echo "✓ Statut AirDrop vérifié : ACTIVÉ"
                    return 0
                else
                    echo "⚠ Attention : Échec de la vérification du statut AirDrop"
                    return 1
                fi
            else
                echo "✗ Échec de l'activation d'AirDrop"
                return 1
            fi
            ;;
        "status")
            echo "Vérification du statut d'AirDrop..."
            
            # Obtenir des informations détaillées sur l'interface
            if ifconfig awdl0 &>/dev/null; then
                local status_line
                status_line=$(ifconfig awdl0 | grep "status:")
                echo "Interface AWDL : $status_line"
                
                local flags_line
                flags_line=$(ifconfig awdl0 | head -1 | cut -d'<' -f2 | cut -d'>' -f1)
                echo "Indicateurs d'Interface : $flags_line"
                
                # Vérifier si l'interface est active et en marche
                if echo "$flags_line" | grep -q "UP"; then
                    echo "Statut AirDrop : ACTIVÉ"
                else
                    echo "Statut AirDrop : DÉSACTIVÉ"
                fi
            else
                echo "Interface AWDL : NON DISPONIBLE"
                echo "Statut AirDrop : NON PRIS EN CHARGE"
            fi
            ;;
        *)
            echo "Usage : manage_airdrop [disable|enable|status]"
            echo "  disable - Désactiver la fonctionnalité AirDrop"
            echo "  enable  - Activer la fonctionnalité AirDrop"
            echo "  status  - Vérifier le statut actuel d'AirDrop"
            return 1
            ;;
    esac
}

# Exécuter la fonction avec les arguments fournis
manage_airdrop "$@"

Gestion des Paramètres de Découverte AirDrop au Niveau Utilisateur

#!/bin/bash

# Gérer les paramètres de découverte AirDrop au niveau utilisateur
manage_airdrop_discovery() {
    local username="$1"
    local setting="$2"
    
    # Valider les entrées
    if [[ -z "$username" || -z "$setting" ]]; then
        echo "Usage : manage_airdrop_discovery <username> <off|contacts|everyone>"
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! id "$username" &>/dev/null; then
        echo "Erreur : L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Mapper le paramètre à une valeur numérique
    local discovery_value
    case "$setting" in
        "off")
            discovery_value="0"
            ;;
        "contacts")
            discovery_value="1"
            ;;
        "everyone")
            discovery_value="2"
            ;;
        *)
            echo "Erreur : Paramètre invalide '$setting'"
            echo "Options valides : off, contacts, everyone"
            return 1
            ;;
    esac
    
    echo "Configuration de la découverte AirDrop à '$setting' pour l'utilisateur : $username"
    
    # Définir la préférence pour l'utilisateur
    if sudo -u "$username" defaults write com.apple.sharingd DiscoverableMode -int "$discovery_value"; then
        echo "✓ Paramètre de découverte AirDrop mis à jour"
        
        # Redémarrer le démon de partage pour appliquer les changements
        sudo -u "$username" killall sharingd 2>/dev/null
        
        echo "✓ Paramètres appliqués avec succès"
        return 0
    else
        echo "✗ Échec de la mise à jour du paramètre de découverte AirDrop"
        return 1
    fi
}

# Exemples d'utilisation
manage_airdrop_discovery "$(whoami)" "contacts"

Gestion des Politiques AirDrop d'Entreprise

#!/bin/bash

# Application des politiques AirDrop d'entreprise
apply_airdrop_policy() {
    local policy_type="$1"
    local apply_to_all_users="${2:-false}"
    
    echo "=== Application de la Politique AirDrop : $policy_type ==="
    
    case "$policy_type" in
        "corporate_lockdown")
            echo "Application de la politique de verrouillage d'entreprise..."
            
            # Désactiver AirDrop à l'échelle du système
            sudo ifconfig awdl0 down
            
            # Désactiver pour tous les utilisateurs
            if [[ "$apply_to_all_users" == "true" ]]; then
                local users
                users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
                
                for user in $users; do
                    echo "Désactivation d'AirDrop pour l'utilisateur : $user"
                    sudo -u "$user" defaults write com.apple.sharingd DiscoverableMode -int 0
                done
            fi
            
            echo "✓ Politique de verrouillage d'entreprise appliquée"
            ;;
        "contacts_only")
            echo "Application de la politique contacts uniquement..."
            
            # Activer AirDrop mais restreindre aux contacts
            sudo ifconfig awdl0 up
            
            if [[ "$apply_to_all_users" == "true" ]]; then
                local users
                users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
                
                for user in $users; do
                    echo "Configuration contacts uniquement pour l'utilisateur : $user"
                    sudo -u "$user" defaults write com.apple.sharingd DiscoverableMode -int 1
                done
            fi
            
            echo "✓ Politique contacts uniquement appliquée"
            ;;
        "unrestricted")
            echo "Application de la politique non restreinte..."
            
            # Activer AirDrop avec découverte complète
            sudo ifconfig awdl0 up
            
            if [[ "$apply_to_all_users" == "true" ]]; then
                local users
                users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
                
                for user in $users; do
                    echo "Configuration non restreinte pour l'utilisateur : $user"
                    sudo -u "$user" defaults write com.apple.sharingd DiscoverableMode -int 2
                done
            fi
            
            echo "✓ Politique non restreinte appliquée"
            ;;
        *)
            echo "Erreur : Type de politique inconnu '$policy_type'"
            echo "Politiques disponibles : corporate_lockdown, contacts_only, unrestricted"
            return 1
            ;;
    esac
}

# Utilisation
apply_airdrop_policy "corporate_lockdown" "true"

Système de Gestion AirDrop d'Entreprise

#!/bin/bash

# Outil de Gestion AirDrop MacFleet
# Contrôle et surveillance complets d'AirDrop pour les appareils de flotte

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/macfleet_airdrop.log"
REPORT_DIR="/etc/macfleet/reports/airdrop"
CONFIG_DIR="/etc/macfleet/airdrop"
POLICY_DIR="/etc/macfleet/policies/airdrop"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR"

# Modèles de politiques AirDrop
declare -A AIRDROP_POLICIES=(
    ["high_security"]="disabled,no_discovery,monitoring_enabled,audit_logging"
    ["medium_security"]="enabled,contacts_only,monitoring_enabled,audit_logging"
    ["low_security"]="enabled,everyone,monitoring_disabled,basic_logging"
    ["development"]="enabled,everyone,monitoring_enabled,debug_logging"
    ["kiosk_mode"]="disabled,no_discovery,monitoring_disabled,no_logging"
    ["guest_network"]="enabled,contacts_only,monitoring_enabled,audit_logging"
    ["executive"]="enabled,contacts_only,monitoring_enabled,executive_reporting"
    ["classroom"]="disabled,no_discovery,monitoring_enabled,educational_logging"
    ["healthcare"]="disabled,no_discovery,monitoring_enabled,hipaa_compliance"
    ["financial"]="disabled,no_discovery,monitoring_enabled,sox_compliance"
)

# Paramètres de conformité de sécurité
declare -A COMPLIANCE_SETTINGS=(
    ["hipaa"]="airdrop_disabled,audit_all_attempts,data_loss_prevention"
    ["sox"]="airdrop_disabled,financial_data_protection,executive_monitoring"
    ["gdpr"]="privacy_controls,user_consent_required,data_transfer_logging"
    ["pci_dss"]="payment_data_protection,cardholder_isolation,secure_networks"
    ["iso27001"]="information_security,access_controls,incident_management"
)

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

# Surveillance avancée du statut AirDrop
monitor_airdrop_status() {
    local detailed="${1:-false}"
    
    log_action "Surveillance du statut AirDrop (détaillé : $detailed)"
    
    echo "=== Moniteur de Statut AirDrop ==="
    
    # Vérifier le statut de l'interface AWDL
    local awdl_status="unknown"
    local awdl_flags=""
    local awdl_ip=""
    
    if ifconfig awdl0 &>/dev/null; then
        awdl_status=$(ifconfig awdl0 | grep "status:" | awk '{print $2}' || echo "unknown")
        awdl_flags=$(ifconfig awdl0 | head -1 | grep -o '<.*>' | tr -d '<>')
        awdl_ip=$(ifconfig awdl0 | grep "inet " | awk '{print $2}' || echo "none")
    fi
    
    echo "Statut Interface AWDL : $awdl_status"
    echo "Indicateurs d'Interface : $awdl_flags"
    echo "Adresse IP AWDL : $awdl_ip"
    
    # Vérifier l'activation d'AirDrop à l'échelle du système
    local system_airdrop_enabled="false"
    if [[ "$awdl_status" == "active" ]] && echo "$awdl_flags" | grep -q "UP"; then
        system_airdrop_enabled="true"
    fi
    
    echo "Statut AirDrop Système : $([ "$system_airdrop_enabled" == "true" ] && echo "ACTIVÉ" || echo "DÉSACTIVÉ")"
    
    if [[ "$detailed" == "true" ]]; then
        echo ""
        echo "=== Analyse Détaillée ==="
        
        # Vérifier les paramètres au niveau utilisateur
        local users
        users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
        
        echo "Paramètres AirDrop au Niveau Utilisateur :"
        for user in $users; do
            local user_setting
            user_setting=$(sudo -u "$user" defaults read com.apple.sharingd DiscoverableMode 2>/dev/null || echo "not_set")
            
            local setting_text
            case "$user_setting" in
                "0") setting_text="DÉSACTIVÉ" ;;
                "1") setting_text="CONTACTS UNIQUEMENT" ;;
                "2") setting_text="TOUT LE MONDE" ;;
                *) setting_text="NON DÉFINI" ;;
            esac
            
            echo "  $user : $setting_text"
        done
        
        # Vérifier la connectivité réseau
        echo ""
        echo "Informations Interface Réseau :"
        echo "Statut Wi-Fi : $(networksetup -getairportpower en0 | awk '{print $4}')"
        echo "Statut Bluetooth : $(system_profiler SPBluetoothDataType | grep "State:" | awk '{print $2}' | head -1)"
        
        # Vérifier les processus en cours d'exécution
        echo ""
        echo "Processus Connexes :"
        ps aux | grep -E "(sharingd|airportd)" | grep -v grep | awk '{print $11}'
    fi
}

# Application complète des politiques AirDrop
enforce_airdrop_policy() {
    local policy_name="$1"
    local target_users="$2"
    local dry_run="${3:-false}"
    
    log_action "Application de la politique AirDrop : $policy_name (dry_run : $dry_run)"
    
    if [[ -z "${AIRDROP_POLICIES[$policy_name]}" ]]; then
        log_action "ERREUR : Politique inconnue '$policy_name'"
        echo "Politiques disponibles : ${!AIRDROP_POLICIES[*]}"
        return 1
    fi
    
    # Analyser la configuration de politique
    IFS=',' read -ra POLICY_PARTS <<< "${AIRDROP_POLICIES[$policy_name]}"
    local airdrop_state="${POLICY_PARTS[0]}"
    local discovery_setting="${POLICY_PARTS[1]}"
    local monitoring_level="${POLICY_PARTS[2]}"
    local logging_level="${POLICY_PARTS[3]}"
    
    echo "=== Application de la Politique : $policy_name ==="
    echo "État AirDrop : $airdrop_state"
    echo "Paramètre de Découverte : $discovery_setting"
    echo "Niveau de Surveillance : $monitoring_level"
    echo "Niveau de Journalisation : $logging_level"
    
    if [[ "$dry_run" == "true" ]]; then
        echo "MODE TEST - Aucun changement ne sera appliqué"
        return 0
    fi
    
    # Appliquer les paramètres au niveau système
    case "$airdrop_state" in
        "enabled")
            echo "Activation d'AirDrop à l'échelle du système..."
            sudo ifconfig awdl0 up
            ;;
        "disabled")
            echo "Désactivation d'AirDrop à l'échelle du système..."
            sudo ifconfig awdl0 down
            ;;
    esac
    
    # Appliquer les paramètres au niveau utilisateur
    if [[ "$target_users" == "all" ]]; then
        local users
        users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    else
        IFS=',' read -ra users <<< "$target_users"
    fi
    
    local discovery_value
    case "$discovery_setting" in
        "no_discovery") discovery_value="0" ;;
        "contacts_only") discovery_value="1" ;;
        "everyone") discovery_value="2" ;;
    esac
    
    for user in "${users[@]}"; do
        if id "$user" &>/dev/null; then
            echo "Application des paramètres pour l'utilisateur : $user"
            sudo -u "$user" defaults write com.apple.sharingd DiscoverableMode -int "$discovery_value"
            
            # Redémarrer le démon de partage
            sudo -u "$user" killall sharingd 2>/dev/null
        fi
    done
    
    # Configurer la surveillance
    configure_airdrop_monitoring "$monitoring_level" "$logging_level"
    
    # Générer un rapport de conformité de politique
    local report_file="$REPORT_DIR/policy_enforcement_${policy_name}_$(date +%Y%m%d_%H%M%S).json"
    generate_policy_report "$policy_name" "$report_file"
    
    log_action "Application de politique terminée : $report_file"
    echo "$report_file"
}

# Configurer la surveillance et la journalisation AirDrop
configure_airdrop_monitoring() {
    local monitoring_level="$1"
    local logging_level="$2"
    
    echo "Configuration de la surveillance (niveau : $monitoring_level, journalisation : $logging_level)"
    
    case "$monitoring_level" in
        "monitoring_enabled")
            # Créer un script de surveillance
            cat > "/usr/local/bin/macfleet_airdrop_monitor.sh" << 'EOF'
#!/bin/bash
# Moniteur d'activité AirDrop
while true; do
    # Surveiller les changements d'interface AWDL
    ifconfig awdl0 | grep "status:" >> /var/log/macfleet_airdrop_activity.log
    sleep 30
done
EOF
            chmod +x "/usr/local/bin/macfleet_airdrop_monitor.sh"
            
            # Créer LaunchDaemon pour la surveillance
            cat > "/Library/LaunchDaemons/com.macfleet.airdrop.monitor.plist" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.macfleet.airdrop.monitor</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/macfleet_airdrop_monitor.sh</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF
            launchctl load "/Library/LaunchDaemons/com.macfleet.airdrop.monitor.plist"
            ;;
        "monitoring_disabled")
            # Supprimer les composants de surveillance
            launchctl unload "/Library/LaunchDaemons/com.macfleet.airdrop.monitor.plist" 2>/dev/null
            rm -f "/Library/LaunchDaemons/com.macfleet.airdrop.monitor.plist"
            rm -f "/usr/local/bin/macfleet_airdrop_monitor.sh"
            ;;
    esac
}

# Générer un rapport complet de conformité de politique
generate_policy_report() {
    local policy_name="$1"
    local report_file="$2"
    
    # Obtenir l'état actuel du système
    local awdl_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}' || echo "unknown")
    local system_enabled="false"
    [[ "$awdl_status" == "active" ]] && system_enabled="true"
    
    # Obtenir les paramètres utilisateur
    local users
    users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    
    cat > "$report_file" << EOF
{
    "policy_report": {
        "policy_name": "$policy_name",
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "script_version": "$SCRIPT_VERSION",
        "system_status": {
            "awdl_interface": "$awdl_status",
            "system_airdrop_enabled": $system_enabled
        },
        "user_settings": [],
        "compliance_status": "compliant",
        "recommendations": []
    }
}
EOF
    
    # Ajouter les paramètres spécifiques aux utilisateurs
    for user in $users; do
        local user_setting
        user_setting=$(sudo -u "$user" defaults read com.apple.sharingd DiscoverableMode 2>/dev/null || echo "-1")
        
        jq --arg user "$user" \
           --argjson setting "$user_setting" \
           '.policy_report.user_settings += [{
               "username": $user,
               "discovery_mode": $setting,
               "discovery_text": (if $setting == 0 then "DÉSACTIVÉ" elif $setting == 1 then "CONTACTS_UNIQUEMENT" elif $setting == 2 then "TOUT_LE_MONDE" else "NON_DÉFINI" end)
           }]' "$report_file" > "${report_file}.tmp" && mv "${report_file}.tmp" "$report_file"
    done
    
    log_action "Rapport de politique généré : $report_file"
}

# Audit AirDrop à l'échelle de la flotte
audit_fleet_airdrop() {
    local scope="${1:-all}"
    
    echo "=== Audit AirDrop de Flotte ==="
    log_action "Début de l'audit AirDrop de flotte (portée : $scope)"
    
    local audit_report="$REPORT_DIR/fleet_airdrop_audit_$(date +%Y%m%d_%H%M%S).json"
    
    cat > "$audit_report" << EOF
{
    "audit_info": {
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "scope": "$scope",
        "audit_type": "airdrop_security"
    },
    "system_analysis": {},
    "user_analysis": [],
    "security_findings": [],
    "recommendations": []
}
EOF
    
    # Analyse au niveau système
    local awdl_status=$(ifconfig awdl0 2>/dev/null | grep "status:" | awk '{print $2}' || echo "unknown")
    local wifi_status=$(networksetup -getairportpower en0 | awk '{print $4}')
    local bluetooth_status=$(system_profiler SPBluetoothDataType | grep "State:" | awk '{print $2}' | head -1)
    
    jq --arg awdl "$awdl_status" \
       --arg wifi "$wifi_status" \
       --arg bluetooth "$bluetooth_status" \
       '.audit_info.system_analysis = {
           "awdl_interface": $awdl,
           "wifi_enabled": ($wifi == "On"),
           "bluetooth_enabled": ($bluetooth == "On"),
           "airdrop_capable": (($wifi == "On") and ($bluetooth == "On"))
       }' "$audit_report" > "${audit_report}.tmp" && mv "${audit_report}.tmp" "$audit_report"
    
    # Analyse au niveau utilisateur
    local users
    users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    
    local security_issues=0
    
    for user in $users; do
        local discovery_mode
        discovery_mode=$(sudo -u "$user" defaults read com.apple.sharingd DiscoverableMode 2>/dev/null || echo "-1")
        
        local home_dir
        home_dir=$(dscl . -read "/Users/$user" NFSHomeDirectory 2>/dev/null | cut -d: -f2 | xargs)
        
        local is_admin="false"
        if dseditgroup -o checkmember -m "$user" admin &>/dev/null; then
            is_admin="true"
        fi
        
        # Vérifier les préoccupations de sécurité
        local security_concern="none"
        if [[ "$discovery_mode" == "2" ]] && [[ "$is_admin" == "true" ]]; then
            security_concern="admin_user_unrestricted_airdrop"
            ((security_issues++))
        elif [[ "$discovery_mode" == "2" ]]; then
            security_concern="unrestricted_airdrop_enabled"
        fi
        
        jq --arg user "$user" \
           --argjson discovery "$discovery_mode" \
           --arg home "$home_dir" \
           --arg admin "$is_admin" \
           --arg concern "$security_concern" \
           '.audit_info.user_analysis += [{
               "username": $user,
               "discovery_mode": $discovery,
               "home_directory": $home,
               "is_admin": ($admin == "true"),
               "security_concern": $concern
           }]' "$audit_report" > "${audit_report}.tmp" && mv "${audit_report}.tmp" "$audit_report"
    done
    
    # Générer un résumé de sécurité
    jq --argjson issues "$security_issues" \
       '.audit_info.security_findings = [
           {
               "total_security_issues": $issues,
               "severity": (if $issues == 0 then "low" elif $issues < 3 then "medium" else "high" end),
               "compliance_status": (if $issues == 0 then "compliant" else "non_compliant" end)
           }
       ]' "$audit_report" > "${audit_report}.tmp" && mv "${audit_report}.tmp" "$audit_report"
    
    echo "Audit terminé. $security_issues problèmes de sécurité trouvés."
    log_action "Audit de flotte terminé : $audit_report"
    echo "$audit_report"
}

# Fonction d'exécution principale
main() {
    local action="${1:-status}"
    local param1="${2:-}"
    local param2="${3:-}"
    local param3="${4:-}"
    
    log_action "=== Gestion AirDrop MacFleet Démarrée ==="
    log_action "Action : $action"
    
    # Assurer les privilèges requis pour la plupart des opérations
    if [[ "$action" != "status" && "$action" != "help" && $EUID -ne 0 ]]; then
        echo "Erreur : Cette action nécessite des privilèges administrateur"
        echo "Veuillez exécuter avec sudo : sudo $0 $*"
        exit 1
    fi
    
    case "$action" in
        "disable")
            echo "Désactivation d'AirDrop..."
            sudo ifconfig awdl0 down && echo "✓ AirDrop désactivé" || echo "✗ Échec de la désactivation d'AirDrop"
            ;;
        "enable")
            echo "Activation d'AirDrop..."
            sudo ifconfig awdl0 up && echo "✓ AirDrop activé" || echo "✗ Échec de l'activation d'AirDrop"
            ;;
        "status")
            monitor_airdrop_status "$param1"
            ;;
        "policy")
            if [[ -z "$param1" ]]; then
                echo "Politiques disponibles : ${!AIRDROP_POLICIES[*]}"
                exit 1
            fi
            enforce_airdrop_policy "$param1" "${param2:-all}" "$param3"
            ;;
        "audit")
            audit_fleet_airdrop "$param1"
            ;;
        "user")
            if [[ -z "$param1" || -z "$param2" ]]; then
                echo "Usage : $0 user <username> <off|contacts|everyone>"
                exit 1
            fi
            manage_airdrop_discovery "$param1" "$param2"
            ;;
        "help")
            echo "Usage : $0 [action] [options...]"
            echo "Actions :"
            echo "  disable - Désactiver AirDrop à l'échelle du système"
            echo "  enable - Activer AirDrop à l'échelle du système"
            echo "  status [detailed] - Vérifier le statut d'AirDrop"
            echo "  policy <policy_name> [users] [dry_run] - Appliquer une politique"
            echo "  user <username> <setting> - Définir le paramètre AirDrop utilisateur"
            echo "  audit [scope] - Auditer la sécurité AirDrop"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Politiques : ${!AIRDROP_POLICIES[*]}"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion AirDrop terminée ==="
}

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

Meilleures Pratiques de Sécurité AirDrop

Politiques de Sécurité d'Entreprise

#!/bin/bash

# Implémenter les politiques de sécurité AirDrop d'entreprise
implement_corporate_security() {
    echo "=== Implémentation de la Sécurité AirDrop d'Entreprise ==="
    
    # 1. Désactiver AirDrop sur les ordinateurs partagés/publics
    echo "Désactivation d'AirDrop sur les postes de travail partagés..."
    sudo ifconfig awdl0 down
    
    # 2. Définir des paramètres par défaut restrictifs pour les utilisateurs
    echo "Configuration des paramètres par défaut restrictifs pour AirDrop..."
    local users
    users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    
    for user in $users; do
        sudo -u "$user" defaults write com.apple.sharingd DiscoverableMode -int 0
    done
    
    # 3. Créer une application de politique à l'échelle du système
    cat > "/Library/Preferences/com.apple.sharingd.plist" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>DiscoverableMode</key>
    <integer>0</integer>
    <key>AirDropEnabled</key>
    <false/>
</dict>
</plist>
EOF
    
    # 4. Définir les permissions appropriées
    chmod 644 "/Library/Preferences/com.apple.sharingd.plist"
    chown root:wheel "/Library/Preferences/com.apple.sharingd.plist"
    
    echo "✓ Politiques de sécurité d'entreprise implémentées"
}

implement_corporate_security

Surveillance de Conformité

#!/bin/bash

# Surveiller la conformité AirDrop avec les politiques de sécurité
monitor_compliance() {
    local compliance_standard="$1"
    
    echo "=== Surveillance de Conformité AirDrop : $compliance_standard ==="
    
    case "$compliance_standard" in
        "hipaa")
            # Conformité santé - AirDrop doit être désactivé
            if ifconfig awdl0 | grep -q "status: active"; then
                echo "⚠ VIOLATION HIPAA : AirDrop est activé"
                echo "Recommandation : Désactiver AirDrop pour prévenir les fuites de PHI"
                return 1
            else
                echo "✓ CONFORME HIPAA : AirDrop est désactivé"
            fi
            ;;
        "pci_dss")
            # Conformité industrie des cartes de paiement
            if ifconfig awdl0 | grep -q "status: active"; then
                echo "⚠ VIOLATION PCI DSS : AirDrop crée un chemin réseau incontrôlé"
                echo "Recommandation : Désactiver AirDrop dans l'environnement de données des porteurs de cartes"
                return 1
            else
                echo "✓ CONFORME PCI DSS : AirDrop est désactivé"
            fi
            ;;
        "sox")
            # Conformité Sarbanes-Oxley pour les données financières
            echo "Vérification de la conformité SOX pour la protection des données financières..."
            # Implémentation spécifique au traitement des données financières
            ;;
        *)
            echo "Standard de conformité inconnu : $compliance_standard"
            return 1
            ;;
    esac
}

# Utilisation
monitor_compliance "hipaa"

Dépannage des Problèmes AirDrop

Diagnostics Réseau

#!/bin/bash

# Dépannage complet d'AirDrop
troubleshoot_airdrop() {
    echo "=== Diagnostics de Dépannage AirDrop ==="
    
    echo "1. Vérification de l'Interface AWDL..."
    if ifconfig awdl0 &>/dev/null; then
        ifconfig awdl0 | head -10
    else
        echo "Interface AWDL non disponible"
    fi
    
    echo -e "\n2. Vérification du Statut Wi-Fi..."
    networksetup -getairportpower en0
    
    echo -e "\n3. Vérification du Statut Bluetooth..."
    system_profiler SPBluetoothDataType | grep -A 5 "State:"
    
    echo -e "\n4. Vérification des Paramètres du Pare-feu..."
    /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate
    
    echo -e "\n5. Vérification des Préférences de Partage..."
    local users
    users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    
    for user in $users; do
        local setting
        setting=$(sudo -u "$user" defaults read com.apple.sharingd DiscoverableMode 2>/dev/null || echo "non défini")
        echo "Utilisateur $user : $setting"
    done
    
    echo -e "\n6. Vérification des Processus Connexes..."
    ps aux | grep -E "(sharingd|airportd|bluetoothd)" | grep -v grep
    
    echo -e "\n7. Résumé des Interfaces Réseau..."
    networksetup -listallhardwareports | grep -A 1 "Wi-Fi\|Bluetooth"
}

troubleshoot_airdrop

Réinitialiser la Configuration AirDrop

#!/bin/bash

# Réinitialiser AirDrop à la configuration par défaut
reset_airdrop_config() {
    echo "=== Réinitialisation de la Configuration AirDrop ==="
    
    # Arrêter le démon de partage
    echo "Arrêt du démon de partage..."
    sudo killall sharingd 2>/dev/null
    
    # Réinitialiser l'interface AWDL
    echo "Réinitialisation de l'interface AWDL..."
    sudo ifconfig awdl0 down
    sleep 2
    sudo ifconfig awdl0 up
    
    # Effacer les préférences utilisateur
    echo "Effacement des préférences AirDrop utilisateur..."
    local users
    users=$(dscl . -list /Users | grep -v "^_" | grep -v "daemon\|nobody\|root")
    
    for user in $users; do
        echo "Réinitialisation des préférences pour l'utilisateur : $user"
        sudo -u "$user" defaults delete com.apple.sharingd DiscoverableMode 2>/dev/null || true
    done
    
    # Supprimer les politiques à l'échelle du système
    echo "Suppression des politiques AirDrop à l'échelle du système..."
    sudo rm -f "/Library/Preferences/com.apple.sharingd.plist"
    
    # Redémarrer le démon de partage
    echo "Redémarrage du démon de partage..."
    sudo launchctl kickstart -k system/com.apple.sharingd
    
    echo "✓ Configuration AirDrop réinitialisée aux paramètres par défaut"
}

reset_airdrop_config

Notes Importantes

• Interface AWDL - Apple Wireless Direct Link est la technologie sous-jacente d'AirDrop
• Privilèges administrateur requis pour le contrôle AirDrop à l'échelle du système
• Paramètres au niveau utilisateur peuvent remplacer les politiques système sauf si appliquées
• Dépendances réseau - Nécessite que le Wi-Fi et le Bluetooth soient activés
• Implications de sécurité - Considérer les politiques d'entreprise avant l'activation
• Exigences de conformité - Certaines industries nécessitent la désactivation d'AirDrop
• Tester minutieusement - Valider les changements sur les appareils de test avant le déploiement en flotte

Gérez et contrôlez les privilèges administrateur sur vos appareils MacFleet en utilisant des outils de ligne de commande avancés et des politiques de gestion de privilèges centralisées. Ce tutoriel couvre les droits admin temporaires, le contrôle d'escalade de privilèges, la gouvernance de sécurité et la gestion de droits administrateur de niveau entreprise avec des capacités complètes d'audit et de conformité.

Comprendre la Gestion des Droits Admin macOS

macOS fournit plusieurs outils et méthodes pour gérer les privilèges administrateur :

• dscl - Utilitaire en ligne de commande des Services d'Annuaire pour la gestion des utilisateurs et groupes
• sudo - Exécuter des commandes avec des privilèges élevés
• launchctl - Gestion des daemons de lancement pour les tâches programmées
• Framework des Groupes - Gestion intégrée de l'appartenance au groupe admin
• Framework de Sécurité - Autorisation et validation des privilèges

La gestion d'entreprise des droits admin nécessite un équilibre délicat entre sécurité, productivité et exigences de conformité.

Commandes de Base des Droits Admin

Accorder des Droits Admin (Base)

#!/bin/bash

# Octroi de base des droits admin
grant_admin_rights_basic() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "Usage : grant_admin_rights_basic <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read /Users/"$username" >/dev/null 2>&1; then
        echo "❌ Utilisateur '$username' non trouvé"
        return 1
    fi
    
    # Ajouter l'utilisateur au groupe admin
    dscl . -append /Groups/admin GroupMembership "$username"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Droits admin accordés à l'utilisateur : $username"
        return 0
    else
        echo "❌ Échec de l'octroi des droits admin à l'utilisateur : $username"
        return 1
    fi
}

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

Révoquer les Droits Admin (Base)

#!/bin/bash

# Révocation de base des droits admin
revoke_admin_rights_basic() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "Usage : revoke_admin_rights_basic <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read /Users/"$username" >/dev/null 2>&1; then
        echo "❌ Utilisateur '$username' non trouvé"
        return 1
    fi
    
    # Supprimer l'utilisateur du groupe admin
    dscl . -delete /Groups/admin GroupMembership "$username"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Droits admin révoqués de l'utilisateur : $username"
        return 0
    else
        echo "❌ Échec de la révocation des droits admin de l'utilisateur : $username"
        return 1
    fi
}

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

Vérifier le Statut Admin

#!/bin/bash

# Vérifier si l'utilisateur a des privilèges admin
check_admin_status() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "Usage : check_admin_status <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier si l'utilisateur est dans le groupe admin
    local admin_members
    admin_members=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | grep -o "$username")
    
    if [[ -n "$admin_members" ]]; then
        echo "✅ L'utilisateur '$username' a des privilèges admin"
        return 0
    else
        echo "❌ L'utilisateur '$username' n'a pas de privilèges admin"
        return 1
    fi
}

# Lister tous les utilisateurs admin
list_admin_users() {
    echo "=== Utilisateurs Admin Actuels ==="
    echo ""
    
    local admin_users
    admin_users=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | cut -d: -f2 | tr ' ' '\n' | grep -v '^$' | sort)
    
    if [[ -n "$admin_users" ]]; then
        echo "Comptes administrateur :"
        while IFS= read -r user; do
            # Obtenir le nom réel de l'utilisateur si disponible
            local real_name
            real_name=$(dscl . -read /Users/"$user" RealName 2>/dev/null | cut -d: -f2 | sed 's/^ *//')
            
            if [[ -n "$real_name" && "$real_name" != "$user" ]]; then
                echo "  • $user ($real_name)"
            else
                echo "  • $user"
            fi
        done <<< "$admin_users"
    else
        echo "Aucun utilisateur admin trouvé"
    fi
    echo ""
}

# Exemple d'utilisation
# check_admin_status "jean.dupont"
# list_admin_users

Gestion Avancée des Droits Admin

Droits Admin Temporaires

#!/bin/bash

# Droits admin temporaires améliorés
grant_temporary_admin_rights() {
    local username="$1"
    local duration_minutes="${2:-30}"
    local reason="${3:-Tâche administrative}"
    local require_confirmation="${4:-true}"
    
    if [[ -z "$username" ]]; then
        echo "Usage : grant_temporary_admin_rights <nom_utilisateur> [durée_minutes] [raison] [confirmation_requise]"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read /Users/"$username" >/dev/null 2>&1; then
        echo "❌ Utilisateur '$username' non trouvé"
        return 1
    fi
    
    # Vérifier si l'utilisateur a déjà des droits admin
    if check_admin_status "$username" >/dev/null; then
        echo "⚠️  L'utilisateur '$username' a déjà des privilèges admin"
        read -p "Continuer avec la configuration admin temporaire ? (o/N) : " -n 1 -r
        echo
        if [[ ! $REPLY =~ ^[OoYy]$ ]]; then
            return 1
        fi
    fi
    
    # Afficher la boîte de dialogue de confirmation si requise
    if [[ "$require_confirmation" == "true" ]]; then
        osascript -e "display dialog \"Vous avez reçu des droits administrateur pour $duration_minutes minutes.\\n\\nRaison : $reason\\n\\nVeuillez ne pas abuser de ce privilège.\" buttons {\"Accepter les Droits Admin\"} default button 1 with title \"Octroi de Droits Admin MacFleet\""
        
        if [[ $? -ne 0 ]]; then
            echo "❌ L'utilisateur a refusé l'octroi des droits admin"
            return 1
        fi
    fi
    
    # Créer le répertoire de suivi
    local tracking_dir="/private/var/macfleet_admin_tracking"
    sudo mkdir -p "$tracking_dir"
    
    # Créer le fichier de suivi utilisateur avec métadonnées
    local tracking_file="$tracking_dir/${username}_admin.json"
    cat > "$tracking_file" <<EOF
{
    "username": "$username",
    "granted_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "duration_minutes": $duration_minutes,
    "reason": "$reason",
    "granted_by": "$(whoami)",
    "hostname": "$(hostname)",
    "pid": $$,
    "expires_at": "$(date -u -v+${duration_minutes}M +%Y-%m-%dT%H:%M:%SZ)"
}
EOF
    
    # Accorder les droits admin
    dscl . -append /Groups/admin GroupMembership "$username"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Droits admin temporaires accordés à '$username' pour $duration_minutes minutes"
        
        # Créer le script de suppression
        create_admin_removal_script "$username" "$duration_minutes"
        
        # Programmer la suppression
        schedule_admin_removal "$username" "$duration_minutes"
        
        return 0
    else
        echo "❌ Échec de l'octroi des droits admin à '$username'"
        rm -f "$tracking_file"
        return 1
    fi
}

# Créer le script de suppression admin
create_admin_removal_script() {
    local username="$1"
    local duration_minutes="$2"
    
    local script_path="/Library/Application Support/MacFleet/remove_admin_${username}.sh"
    mkdir -p "$(dirname "$script_path")"
    
    cat > "$script_path" <<'EOF'
#!/bin/bash

USERNAME="{{USERNAME}}"
TRACKING_DIR="/private/var/macfleet_admin_tracking"
TRACKING_FILE="$TRACKING_DIR/${USERNAME}_admin.json"
LOG_FILE="/var/log/macfleet_admin_rights.log"

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

log_action "Début de suppression des droits admin pour l'utilisateur : $USERNAME"

# Vérifier si l'utilisateur a encore des droits admin
if dscl . -read /Groups/admin GroupMembership 2>/dev/null | grep -q "$USERNAME"; then
    # Supprimer les droits admin
    dscl . -delete /Groups/admin GroupMembership "$USERNAME"
    
    if [[ $? -eq 0 ]]; then
        log_action "✅ Droits admin supprimés avec succès de l'utilisateur : $USERNAME"
        
        # Notifier l'utilisateur s'il est connecté
        if pgrep -u "$USERNAME" >/dev/null; then
            sudo -u "$USERNAME" osascript -e 'display notification "Vos privilèges administrateur temporaires ont expiré." with title "Droits Admin MacFleet"' 2>/dev/null
        fi
    else
        log_action "❌ Échec de suppression des droits admin de l'utilisateur : $USERNAME"
    fi
else
    log_action "⚠️  L'utilisateur $USERNAME n'avait pas de droits admin (déjà supprimés ou jamais accordés)"
fi

# Nettoyer le fichier de suivi
if [[ -f "$TRACKING_FILE" ]]; then
    # Archiver les données de suivi
    ARCHIVE_DIR="/var/log/macfleet_admin_archive"
    mkdir -p "$ARCHIVE_DIR"
    mv "$TRACKING_FILE" "$ARCHIVE_DIR/${USERNAME}_admin_$(date +%Y%m%d_%H%M%S).json"
    log_action "Données de suivi des droits admin archivées pour l'utilisateur : $USERNAME"
fi

# Supprimer le daemon de lancement
PLIST_PATH="/Library/LaunchDaemons/com.macfleet.remove_admin_${USERNAME}.plist"
if [[ -f "$PLIST_PATH" ]]; then
    launchctl unload "$PLIST_PATH" 2>/dev/null
    rm -f "$PLIST_PATH"
    log_action "Daemon de lancement supprimé pour l'utilisateur : $USERNAME"
fi

# Supprimer ce script
rm -f "$0"

log_action "Processus de suppression des droits admin terminé pour l'utilisateur : $USERNAME"
exit 0
EOF
    
    # Remplacer le placeholder par le nom d'utilisateur réel
    sed -i '' "s/{{USERNAME}}/$username/g" "$script_path"
    
    # Définir les permissions
    chmod 755 "$script_path"
    chown root:wheel "$script_path"
}

# Programmer la suppression admin avec launchd
schedule_admin_removal() {
    local username="$1"
    local duration_minutes="$2"
    
    local plist_path="/Library/LaunchDaemons/com.macfleet.remove_admin_${username}.plist"
    local script_path="/Library/Application Support/MacFleet/remove_admin_${username}.sh"
    
    # Calculer l'heure d'exécution
    local start_time
    start_time=$(date -u -v+${duration_minutes}M +%Y-%m-%dT%H:%M:%SZ)
    
    # Créer le plist du daemon de lancement
    cat > "$plist_path" <<EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.macfleet.remove_admin_${username}</string>
    <key>ProgramArguments</key>
    <array>
        <string>/bin/bash</string>
        <string>${script_path}</string>
    </array>
    <key>StartCalendarInterval</key>
    <dict>
        <key>Year</key>
        <integer>$(date -u -v+${duration_minutes}M +%Y)</integer>
        <key>Month</key>
        <integer>$(date -u -v+${duration_minutes}M +%m)</integer>
        <key>Day</key>
        <integer>$(date -u -v+${duration_minutes}M +%d)</integer>
        <key>Hour</key>
        <integer>$(date -u -v+${duration_minutes}M +%H)</integer>
        <key>Minute</key>
        <integer>$(date -u -v+${duration_minutes}M +%M)</integer>
    </dict>
    <key>RunAtLoad</key>
    <false/>
</dict>
</plist>
EOF
    
    # Définir les permissions
    chown root:wheel "$plist_path"
    chmod 644 "$plist_path"
    
    # Charger le daemon
    launchctl load "$plist_path"
    
    echo "⏰ Suppression des droits admin programmée pour $start_time"
}

# Exemple d'utilisation
# grant_temporary_admin_rights "jean.dupont" 30 "Installation logiciel" true

Système de Gestion des Droits Admin d'Entreprise

#!/bin/bash

# Système de Gestion des Droits Admin d'Entreprise MacFleet
# Gestion complète des privilèges, gouvernance de sécurité et surveillance de conformité

# Configuration
LOG_FILE="/var/log/macfleet_admin_rights.log"
CONFIG_FILE="/etc/macfleet/admin_rights_config.conf"
AUDIT_DIR="/var/log/macfleet_admin_audit"
POLICY_DIR="/etc/macfleet/admin_policies"
TRACKING_DIR="/private/var/macfleet_admin_tracking"

# Créer la structure de répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$AUDIT_DIR" "$POLICY_DIR" "$TRACKING_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
    
    # Définir les permissions appropriées
    chmod 755 "$AUDIT_DIR" "$POLICY_DIR"
    chmod 700 "$TRACKING_DIR"  # Restreindre l'accès aux données de suivi
}

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

# Charger la configuration
load_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
    else
        # Définir les valeurs par défaut
        MAX_ADMIN_DURATION="${MAX_ADMIN_DURATION:-480}"  # 8 heures max
        DEFAULT_ADMIN_DURATION="${DEFAULT_ADMIN_DURATION:-30}"  # 30 minutes par défaut
        REQUIRE_JUSTIFICATION="${REQUIRE_JUSTIFICATION:-true}"
        ENABLE_NOTIFICATIONS="${ENABLE_NOTIFICATIONS:-true}"
        AUDIT_ALL_CHANGES="${AUDIT_ALL_CHANGES:-true}"
        PROTECTED_ACCOUNTS="${PROTECTED_ACCOUNTS:-root,admin,macfleet}"
    fi
}

# Octroi de droits admin d'entreprise avec application de politique
enterprise_grant_admin() {
    local username="$1"
    local duration_minutes="$2"
    local reason="$3"
    local approved_by="$4"
    
    load_config
    
    if [[ -z "$username" ]]; then
        log_action "ERREUR : Nom d'utilisateur requis pour l'octroi de droits admin"
        return 1
    fi
    
    # Définir la durée par défaut si non fournie
    if [[ -z "$duration_minutes" ]]; then
        duration_minutes="$DEFAULT_ADMIN_DURATION"
    fi
    
    # Valider la durée par rapport à la politique
    if [[ "$duration_minutes" -gt "$MAX_ADMIN_DURATION" ]]; then
        log_action "ERREUR : Durée demandée ($duration_minutes min) dépasse le maximum autorisé ($MAX_ADMIN_DURATION min)"
        return 1
    fi
    
    # Exiger une justification si la politique est activée
    if [[ "$REQUIRE_JUSTIFICATION" == "true" && -z "$reason" ]]; then
        log_action "ERREUR : Justification requise pour l'octroi de droits admin"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read /Users/"$username" >/dev/null 2>&1; then
        log_action "ERREUR : Utilisateur '$username' non trouvé"
        return 1
    fi
    
    # Vérifier les comptes protégés
    if echo "$PROTECTED_ACCOUNTS" | grep -q "$username"; then
        log_action "ERREUR : Impossible de modifier les droits admin pour le compte protégé : $username"
        return 1
    fi
    
    # Vérifier les droits admin existants
    local current_admin_status
    if check_admin_status "$username" >/dev/null; then
        current_admin_status="already_admin"
    else
        current_admin_status="standard_user"
    fi
    
    # Créer une entrée d'audit
    local audit_id
    audit_id=$(create_audit_entry "grant" "$username" "$duration_minutes" "$reason" "$approved_by" "$current_admin_status")
    
    # Accorder les droits admin
    if [[ "$current_admin_status" == "standard_user" ]]; then
        dscl . -append /Groups/admin GroupMembership "$username"
        
        if [[ $? -ne 0 ]]; then
            log_action "ERREUR : Échec de l'octroi des droits admin à '$username'"
            update_audit_entry "$audit_id" "failed" "Échec de modification du groupe admin"
            return 1
        fi
    fi
    
    # Créer une entrée de suivi
    create_tracking_entry "$username" "$duration_minutes" "$reason" "$approved_by" "$audit_id"
    
    # Programmer la suppression si temporaire
    if [[ "$duration_minutes" -gt 0 ]]; then
        schedule_enterprise_admin_removal "$username" "$duration_minutes" "$audit_id"
    fi
    
    # Envoyer des notifications
    if [[ "$ENABLE_NOTIFICATIONS" == "true" ]]; then
        send_admin_notification "$username" "granted" "$duration_minutes" "$reason"
    fi
    
    log_action "✅ Droits admin accordés à '$username' pour $duration_minutes minutes (ID Audit : $audit_id)"
    update_audit_entry "$audit_id" "success" "Droits admin accordés avec succès"
    
    return 0
}

# Fonction de gestion principale
main() {
    local action="${1:-status}"
    local parameter1="$2"
    local parameter2="$3"
    local parameter3="$4"
    local parameter4="$5"
    
    setup_directories
    log_action "Gestion des Droits Admin MacFleet démarrée avec l'action : $action"
    
    case "$action" in
        "grant")
            enterprise_grant_admin "$parameter1" "$parameter2" "$parameter3" "$parameter4"
            ;;
        "revoke")
            enterprise_revoke_admin "$parameter1" "$parameter2" "$parameter3"
            ;;
        "temp"|"temporary")
            grant_temporary_admin_rights "$parameter1" "$parameter2" "$parameter3" "$parameter4"
            ;;
        "check")
            check_admin_status "$parameter1"
            ;;
        "list")
            list_admin_users
            ;;
        "status"|*)
            list_admin_users
            ;;
    esac
    
    log_action "Gestion des Droits Admin MacFleet terminée avec l'action : $action"
}

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

Modèles de Politiques de Droits Admin

Politique de Droits Admin d'Entreprise

# /etc/macfleet/admin_rights_config.conf
# Configuration des Droits Admin d'Entreprise MacFleet

# Limites de durée (en minutes)
MAX_ADMIN_DURATION="480"        # 8 heures maximum
DEFAULT_ADMIN_DURATION="30"     # 30 minutes par défaut
WARNING_BEFORE_EXPIRY="5"       # Avertissement 5 minutes avant

# Exigences de sécurité
REQUIRE_JUSTIFICATION="true"
REQUIRE_APPROVAL="true"
MINIMUM_JUSTIFICATION_LENGTH="10"

# Paramètres de notification
ENABLE_NOTIFICATIONS="true"
NOTIFY_SECURITY_TEAM="true"
SECURITY_TEAM_EMAIL="securite@entreprise.com"

# Paramètres d'audit
AUDIT_ALL_CHANGES="true"
RETAIN_AUDIT_LOGS="90"          # 90 jours
ENABLE_REALTIME_MONITORING="true"

# Comptes protégés (ne peuvent pas être modifiés)
PROTECTED_ACCOUNTS="root,admin,macfleet,securite"

# Flux d'approbation
REQUIRE_MANAGER_APPROVAL="true"
ENABLE_EMERGENCY_BYPASS="false"
EMERGENCY_BYPASS_ACCOUNTS="securite,ciso"

Politique Environnement Haute Sécurité

# /etc/macfleet/admin_policies/high_security.policy
# Politique de Droits Admin Haute Sécurité MacFleet

# Limites de durée strictes
MAX_ADMIN_DURATION="60"         # 1 heure maximum
DEFAULT_ADMIN_DURATION="15"     # 15 minutes par défaut
AUTO_REVOKE_IDLE="true"         # Révoquer si utilisateur inactif
IDLE_TIMEOUT_MINUTES="10"       # 10 minutes timeout inactivité

# Sécurité renforcée
REQUIRE_JUSTIFICATION="true"
REQUIRE_TWO_PERSON_APPROVAL="true"
ENABLE_SESSION_RECORDING="true"
BLOCK_ADMIN_OUTSIDE_HOURS="true"
ALLOWED_HOURS="09-17"           # 9h à 17h
ALLOWED_DAYS="1-5"              # Lundi au vendredi

# Surveillance
ENABLE_REALTIME_ALERTS="true"
ALERT_ON_ADMIN_GRANT="true"
ALERT_ON_SUSPICIOUS_ACTIVITY="true"
LOG_ALL_ADMIN_COMMANDS="true"

Fonctions de Sécurité et Conformité

Vérification de Conformité des Droits Admin

#!/bin/bash

# Vérification complète de conformité des droits admin
check_admin_compliance() {
    echo "🔍 Vérification de Conformité des Droits Admin"
    echo "============================================="
    echo ""
    
    local compliance_issues=()
    local compliance_warnings=()
    
    # Vérifier les comptes admin permanents non autorisés
    echo "1. COMPTES ADMIN PERMANENTS NON AUTORISÉS :"
    echo "------------------------------------------"
    
    local admin_users
    admin_users=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | cut -d: -f2 | tr ' ' '\n' | grep -v '^$')
    
    while IFS= read -r user; do
        if [[ -n "$user" ]]; then
            local tracking_file="$TRACKING_DIR/${user}_admin.json"
            
            # Ignorer les comptes protégés
            if echo "$PROTECTED_ACCOUNTS" | grep -q "$user"; then
                echo "  ✅ $user (Compte protégé)"
                continue
            fi
            
            # Vérifier si l'utilisateur a un suivi admin temporaire
            if [[ ! -f "$tracking_file" ]]; then
                # Pas de suivi = admin permanent (violation potentielle)
                compliance_issues+=("Compte admin permanent sans suivi : $user")
                echo "  ❌ $user (Aucun suivi admin temporaire trouvé)"
            else
                # Vérifier si l'admin temporaire a expiré
                local expires_at
                expires_at=$(jq -r '.expires_at' "$tracking_file" 2>/dev/null)
                local current_time
                current_time=$(date -u +%Y-%m-%dT%H:%M:%SZ)
                
                if [[ "$expires_at" < "$current_time" ]]; then
                    compliance_issues+=("Admin temporaire expiré toujours actif : $user")
                    echo "  ⚠️  $user (Admin temporaire expiré mais toujours actif)"
                else
                    local reason
                    reason=$(jq -r '.reason' "$tracking_file" 2>/dev/null)
                    echo "  ✅ $user (Admin temporaire, expire : $expires_at, raison : $reason)"
                fi
            fi
        fi
    done <<< "$admin_users"
    echo ""
    
    # Générer le résumé de conformité
    echo "2. RÉSUMÉ DE CONFORMITÉ :"
    echo "------------------------"
    
    if [[ ${#compliance_issues[@]} -eq 0 ]]; then
        echo "  ✅ Aucun problème critique de conformité trouvé"
    else
        echo "  ❌ Problèmes critiques de conformité trouvés :"
        for issue in "${compliance_issues[@]}"; do
            echo "    - $issue"
        done
    fi
    
    if [[ ${#compliance_warnings[@]} -gt 0 ]]; then
        echo "  ⚠️  Avertissements :"
        for warning in "${compliance_warnings[@]}"; do
            echo "    - $warning"
        done
    fi
    
    echo ""
    echo "Recommandations :"
    echo "• Examiner et corriger tout compte admin permanent non autorisé"
    echo "• Implémenter des vérifications de conformité régulières (quotidiennes/hebdomadaires)"
    echo "• Activer la surveillance en temps réel des changements de droits admin"
    echo "• Établir des politiques claires de gouvernance des droits admin"
    echo "• Audit régulier des activités et justifications admin"
    
    # Retourner le code de sortie approprié
    if [[ ${#compliance_issues[@]} -gt 0 ]]; then
        return 1
    else
        return 0
    fi
}

check_admin_compliance

Notes Techniques Importantes

Référence des Commandes DSCL

• dscl . -append /Groups/admin GroupMembership <user> : Ajouter utilisateur au groupe admin
• dscl . -delete /Groups/admin GroupMembership <user> : Supprimer utilisateur du groupe admin
• dscl . -read /Groups/admin GroupMembership : Lister tous les membres du groupe admin
• dscl . -read /Users/<user> : Obtenir des informations détaillées sur l'utilisateur

Considérations de Sécurité

1. Principe du Moindre Privilège : Accorder les privilèges minimum nécessaires pour le temps minimum
2. Piste d'Audit : Maintenir des journaux complets de tous les changements de droits admin
3. Flux d'Approbation : Implémenter des processus d'approbation pour les octrois de droits admin
4. Limites de Temps : Toujours utiliser des droits admin temporaires avec expiration automatique
5. Surveillance : Surveillance en temps réel des activités admin et comportements suspects

Exigences de Conformité

1. Documentation : Maintenir des enregistrements détaillés des octrois et révocations de droits admin
2. Justification : Exiger une justification métier pour toutes les escalades de privilèges
3. Audits Réguliers : Effectuer des vérifications et examens de conformité réguliers
4. Comptes Protégés : Protéger les comptes système critiques contre les modifications
5. Politiques de Rétention : Implémenter des politiques appropriées de rétention et archivage des journaux

Cas d'Usage d'Entreprise

1. Installation de Logiciels : Droits admin temporaires pour les installations d'applications
2. Maintenance Système : Accès admin programmé pour les fenêtres de maintenance
3. Réponse d'Urgence : Escalade rapide de privilèges pour la réponse aux incidents
4. Audit de Conformité : Examens réguliers des droits et activités admin
5. Sécurité Zero Trust : Vérification continue et accès à privilège minimal

N'oubliez pas de tester tous les scripts sur des appareils individuels avant de les déployer sur votre environnement MacFleet, et d'assurer la conformité avec les politiques de sécurité d'entreprise et les exigences réglementaires lors de l'implémentation de systèmes de gestion de droits admin d'entreprise.

GitHub Actions est une plateforme CI/CD puissante qui vous permet d'automatiser vos workflows de développement logiciel. Bien que GitHub propose des runners hébergés, les runners auto-hébergés offrent un contrôle et une personnalisation accrus pour votre configuration CI/CD. Ce tutoriel vous guide dans la configuration, la mise en place et la connexion d'un runner auto-hébergé sur un Mac mini pour exécuter des pipelines macOS.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Un Mac mini (inscrivez-vous sur Macfleet)
• Un dépôt GitHub avec des droits d'administrateur
• Un gestionnaire de paquets installé (de préférence Homebrew)
• Git installé sur votre système

Étape 1 : Créer un compte utilisateur dédié

D'abord, créez un compte utilisateur dédié pour le runner GitHub Actions :

# Créer le compte utilisateur 'gh-runner'
sudo dscl . -create /Users/gh-runner
sudo dscl . -create /Users/gh-runner UserShell /bin/bash
sudo dscl . -create /Users/gh-runner RealName "GitHub runner"
sudo dscl . -create /Users/gh-runner UniqueID "1001"
sudo dscl . -create /Users/gh-runner PrimaryGroupID 20
sudo dscl . -create /Users/gh-runner NFSHomeDirectory /Users/gh-runner

# Définir le mot de passe pour l'utilisateur
sudo dscl . -passwd /Users/gh-runner votre_mot_de_passe

# Ajouter 'gh-runner' au groupe 'admin'
sudo dscl . -append /Groups/admin GroupMembership gh-runner

Basculez vers le nouveau compte utilisateur :

su gh-runner

Étape 2 : Installer les logiciels requis

Installez Git et Rosetta 2 (si vous utilisez Apple Silicon) :

# Installer Git s'il n'est pas déjà installé
brew install git

# Installer Rosetta 2 pour les Mac Apple Silicon
softwareupdate --install-rosetta

Étape 3 : Configurer le Runner GitHub Actions

1. Allez sur votre dépôt GitHub
2. Naviguez vers Settings > Actions > Runners

3. Cliquez sur "New self-hosted runner" (https://github.com/<nom_utilisateur>/<dépôt>/settings/actions/runners/new)
4. Sélectionnez macOS comme image de runner et ARM64 comme architecture
5. Suivez les commandes fournies pour télécharger et configurer le runner

Créez un fichier .env dans le répertoire _work du runner :

# Fichier _work/.env
ImageOS=macos15
XCODE_15_DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer

6. Exécutez le script run.sh dans votre répertoire de runner pour terminer la configuration.
7. Vérifiez que le runner est actif et écoute les tâches dans le terminal et vérifiez les paramètres du dépôt GitHub pour l'association du runner et le statut Idle.

Étape 4 : Configurer Sudoers (Optionnel)

Si vos actions nécessitent des privilèges root, configurez le fichier sudoers :

sudo visudo

Ajoutez la ligne suivante :

gh-runner ALL=(ALL) NOPASSWD: ALL

Étape 5 : Utiliser le Runner dans les Workflows

Configurez votre workflow GitHub Actions pour utiliser le runner auto-hébergé :

name: Workflow exemple

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: [self-hosted, macOS, ARM64]
    steps:
      - name: Installer NodeJS
        run: brew install node

Le runner est authentifié sur votre dépôt et étiqueté avec self-hosted, macOS, et ARM64. Utilisez-le dans vos workflows en spécifiant ces étiquettes dans le champ runs-on :

runs-on: [self-hosted, macOS, ARM64]

Bonnes Pratiques

• Maintenez votre logiciel de runner à jour
• Surveillez régulièrement les logs du runner pour détecter les problèmes
• Utilisez des étiquettes spécifiques pour différents types de runners
• Implémentez des mesures de sécurité appropriées
• Considérez l'utilisation de plusieurs runners pour l'équilibrage de charge

Dépannage

Problèmes courants et solutions :

1. Runner ne se connecte pas :

   • Vérifiez la connectivité réseau
   • Vérifiez la validité du token GitHub
   • Assurez-vous des permissions appropriées

2. Échecs de build :

   • Vérifiez l'installation de Xcode
   • Vérifiez les dépendances requises
   • Examinez les logs du workflow

3. Problèmes de permissions :

   • Vérifiez les permissions utilisateur
   • Vérifiez la configuration sudoers
   • Examinez les permissions du système de fichiers

Conclusion

Vous avez maintenant un runner GitHub Actions auto-hébergé configuré sur votre Mac mini. Cette configuration vous donne plus de contrôle sur votre environnement CI/CD et vous permet d'exécuter efficacement des workflows spécifiques à macOS.

N'oubliez pas de maintenir régulièrement votre runner et de le tenir à jour avec les derniers correctifs de sécurité et versions de logiciels.

Guide d'Installation Macfleet

Macfleet est une solution de gestion de flotte puissante conçue spécifiquement pour les environnements Mac Mini hébergés dans le cloud. En tant que fournisseur d'hébergement cloud Mac Mini, vous pouvez utiliser Macfleet pour surveiller, gérer et optimiser toute votre flotte d'instances Mac virtualisées.

Ce guide d'installation vous accompagnera dans la configuration de la surveillance Macfleet sur les systèmes macOS, Windows et Linux pour assurer une supervision complète de votre infrastructure cloud.

🍎 macOS

• Téléchargez le fichier .dmg pour Mac ici
• Double-cliquez sur le fichier .dmg téléchargé
• Glissez l'app Macfleet dans le dossier Applications
• Éjectez le fichier .dmg
• Ouvrez Préférences Système > Sécurité et confidentialité
  • Onglet Confidentialité > Accessibilité
  • Cochez Macfleet pour autoriser la surveillance
• Lancez Macfleet depuis Applications
• Le suivi démarre automatiquement

🪟 Windows

• Téléchargez le fichier .exe pour Windows ici
• Clic droit sur le fichier .exe > "Exécuter en tant qu'administrateur"
• Suivez l'assistant d'installation
• Acceptez les termes et conditions
• Autorisez dans Windows Defender si demandé
• Accordez les permissions de surveillance d'application
• Lancez Macfleet depuis le Menu Démarrer
• L'application commence le suivi automatiquement

🐧 Linux

• Téléchargez le paquet .deb (Ubuntu/Debian) ou .rpm (CentOS/RHEL) ici
• Installez en utilisant votre gestionnaire de paquets
  • Ubuntu/Debian : sudo dpkg -i Macfleet-linux.deb
  • CentOS/RHEL : sudo rpm -ivh Macfleet-linux.rpm
• Autorisez les permissions d'accès X11 si demandé
• Ajoutez l'utilisateur aux groupes appropriés si nécessaire
• Lancez Macfleet depuis le menu Applications
• L'application commence le suivi automatiquement

Note : Après l'installation sur tous les systèmes, connectez-vous avec vos identifiants Macfleet pour synchroniser les données avec votre tableau de bord.