Guide

Nouvelles mises à jour et améliorations de Roundfleet.
Suivez-nous sur X.com

Avis important

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

← Tous les articles

Gestion d'AirDrop sur macOS

Contrôlez la fonctionnalité AirDrop sur vos appareils Roundfleet 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 Roundfleet
# Contrôle et surveillance complets d'AirDrop pour les appareils de flotte

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_airdrop.log"
REPORT_DIR="/etc/roundfleet/reports/airdrop"
CONFIG_DIR="/etc/roundfleet/airdrop"
POLICY_DIR="/etc/roundfleet/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/roundfleet_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/roundfleet_airdrop_activity.log
    sleep 30
done
EOF
            chmod +x "/usr/local/bin/roundfleet_airdrop_monitor.sh"
            
            # Créer LaunchDaemon pour la surveillance
            cat > "/Library/LaunchDaemons/com.roundfleet.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.roundfleet.airdrop.monitor</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/roundfleet_airdrop_monitor.sh</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF
            launchctl load "/Library/LaunchDaemons/com.roundfleet.airdrop.monitor.plist"
            ;;
        "monitoring_disabled")
            # Supprimer les composants de surveillance
            launchctl unload "/Library/LaunchDaemons/com.roundfleet.airdrop.monitor.plist" 2>/dev/null
            rm -f "/Library/LaunchDaemons/com.roundfleet.airdrop.monitor.plist"
            rm -f "/usr/local/bin/roundfleet_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 Roundfleet 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

Related Tutorials

Gestion de Réseau Wi-Fi sur macOS

Gérez les réseaux Wi-Fi, configurez les paramètres proxy, serveurs DNS et implémentez les politiques de réseau d'entreprise sur les appareils macOS en utilisant les commandes networksetup avancées et la gestion de flotte centralisée.

7 juil. 2025

Gestion d'Entreprise des Proxies sur macOS

Guide complet pour configurer et gérer les proxies web, web sécurisé, streaming, Gopher et SOCKS firewall sur les appareils macOS avec les commandes networksetup pour les environnements d'entreprise.

7 juil. 2025

Gestion Entreprise du Client Itinérant Cisco Umbrella sur macOS

Guide complet pour le déploiement et la gestion du client itinérant Cisco Umbrella en entreprise sur les appareils Roundfleet avec protection DNS de sécurité automatisée, surveillance et contrôle centralisé.

7 juil. 2025

Gestion d'Entreprise du Bluetooth sur macOS

Guide complet pour gérer les paramètres Bluetooth, surveiller le statut, et contrôler les états d'alimentation sur les appareils macOS avec les commandes defaults et la gestion du daemon bluetoothd pour les environnements d'entreprise.

7 juil. 2025

Contrôle Wi-Fi d'Entreprise sur macOS

Guide complet pour contrôler les paramètres Wi-Fi sur les appareils macOS en utilisant les commandes networksetup pour la gestion sans fil d'entreprise, les politiques de sécurité et l'optimisation énergétique dans les déploiements de flotte.

7 juil. 2025

Surveillance Réseau d'Entreprise sur macOS

Surveillez et analysez les applications et processus connectés au réseau sur les appareils macOS en utilisant la surveillance réseau avancée, l'analyse de bande passante et les contrôles de sécurité d'entreprise pour la gestion réseau organisationnelle.

7 juil. 2025

Surveillance d'Applications Premier Plan d'Entreprise sur macOS

Apprenez à surveiller et gérer les applications au premier plan sur les appareils macOS en utilisant AppleScript avec sécurité de niveau entreprise, suivi de productivité, rapports de conformité et capacités de gestion de flotte.

7 juil. 2025

Gérer le menu Bluetooth dans la barre d'état sur macOS

Apprenez à afficher ou masquer le menu Bluetooth dans la barre d'état des appareils macOS à l'aide de scripts shell pour la gestion de flotte Mac.

7 juil. 2025
View all tutorials →