Guide

Assurez la conformité de sécurité d'entreprise en surveillant et gérant le statut Find My Mac sur vos appareils Roundfleet. Ce tutoriel couvre l'audit de sécurité, la vérification Apple ID, les rapports de conformité automatisés, et l'application des politiques de sécurité d'entreprise.

Comprendre la Sécurité Find My Mac

Find My Mac est le service intégré de localisation et de sécurité d'Apple qui fournit :

• Suivi de Localisation d'Appareil - Services de localisation en temps réel pour les appareils perdus ou volés
• Verrouillage et Effacement à Distance - Sécuriser les données de l'appareil à distance
• Verrou d'Activation - Empêche la réactivation non autorisée de l'appareil
• Intégration de Sécurité - Fonctionne avec les services Apple ID et iCloud

Vérification Basique du Statut Find My Mac

Vérification Simple du Statut

#!/bin/bash

# Vérification basique du statut Find My Mac
fmmToken=$(/usr/sbin/nvram -x -p | /usr/bin/grep fmm-mobileme-token-FMM)

if [ -z "$fmmToken" ]; then
    echo "Find My Mac est désactivé"
else
    echo "Find My Mac est activé"
fi

Vérification Améliorée du Statut avec Détails

#!/bin/bash

# Vérification améliorée de Find My Mac
check_find_my_mac_basic() {
    echo "=== Vérification du Statut Find My Mac ==="
    
    # Vérifier le token Find My Mac
    local fmm_token
    fmm_token=$(/usr/sbin/nvram -x -p | /usr/bin/grep fmm-mobileme-token-FMM 2>/dev/null)
    
    if [ -z "$fmm_token" ]; then
        echo "❌ Find My Mac : DÉSACTIVÉ"
        return 1
    else
        echo "✅ Find My Mac : ACTIVÉ"
        
        # Extraire des détails supplémentaires si disponibles
        echo "Token trouvé dans NVRAM"
        return 0
    fi
}

# Exécuter la vérification
check_find_my_mac_basic

Script de Gestion de Sécurité d'Entreprise

#!/bin/bash

# Gestion de Sécurité Find My Mac Roundfleet
# Audit de sécurité complet et surveillance de conformité

# Configuration
LOG_FILE="/var/log/roundfleet_security.log"
REPORT_DIR="/var/reports/security"
COMPLIANCE_DIR="/var/compliance"
TEMP_DIR="/tmp/roundfleet_security"

# Configuration des politiques de sécurité
REQUIRE_FIND_MY_MAC=true
REQUIRE_APPLE_ID=true
REQUIRE_ACTIVATION_LOCK=true
MAX_OFFLINE_DAYS=30

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

# Créer les répertoires nécessaires
setup_directories() {
    for dir in "$REPORT_DIR" "$COMPLIANCE_DIR" "$TEMP_DIR"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# Vérifier le statut Find My Mac avec analyse détaillée
check_find_my_mac_status() {
    log_action "Vérification du statut Find My Mac"
    
    local status_report="$TEMP_DIR/fmm_status.json"
    
    # Initialiser l'objet de statut
    cat > "$status_report" << EOF
{
    "timestamp": "$(date -Iseconds)",
    "hostname": "$(hostname)",
    "find_my_mac": {
        "enabled": false,
        "token_present": false,
        "activation_lock": false,
        "apple_id_signed_in": false
    },
    "compliance": {
        "status": "non_compliant",
        "issues": []
    }
}
EOF

    # Vérifier le token Find My Mac dans NVRAM
    local fmm_token
    fmm_token=$(/usr/sbin/nvram -x -p | /usr/bin/grep fmm-mobileme-token-FMM 2>/dev/null)
    
    if [[ -n "$fmm_token" ]]; then
        log_action "✅ Token Find My Mac trouvé dans NVRAM"
        
        # Mettre à jour le statut JSON
        /usr/bin/python3 -c "
import json
with open('$status_report', 'r') as f:
    data = json.load(f)
data['find_my_mac']['enabled'] = True
data['find_my_mac']['token_present'] = True
with open('$status_report', 'w') as f:
    json.dump(data, f, indent=2)
"
        echo "enabled"
    else
        log_action "❌ Find My Mac non activé - aucun token trouvé"
        
        # Ajouter un problème de conformité
        /usr/bin/python3 -c "
import json
with open('$status_report', 'r') as f:
    data = json.load(f)
data['compliance']['issues'].append('Find My Mac non activé')
with open('$status_report', 'w') as f:
    json.dump(data, f, indent=2)
"
        echo "disabled"
    fi
}

# Vérifier le statut de connexion Apple ID
check_apple_id_status() {
    log_action "Vérification du statut de connexion Apple ID"
    
    # Vérifier si l'utilisateur est connecté à iCloud
    local icloud_account
    icloud_account=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep -c AccountID || echo "0")
    
    if [[ "$icloud_account" -gt 0 ]]; then
        log_action "✅ Apple ID connecté à iCloud"
        
        # Obtenir les détails Apple ID (masqués pour la confidentialité)
        local apple_id_info
        apple_id_info=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep AccountID | head -1 | sed 's/.*= "\(.*\)";/\1/' | sed 's/\(.*@\)\(.*\)/\1***/g')
        log_action "Apple ID : $apple_id_info"
        
        return 0
    else
        log_action "❌ Aucun Apple ID connecté"
        return 1
    fi
}

# Vérifier l'intégrité du système et les paramètres de sécurité
check_system_security() {
    log_action "Exécution de l'audit de sécurité système"
    
    local security_report="$TEMP_DIR/security_audit.json"
    
    cat > "$security_report" << EOF
{
    "timestamp": "$(date -Iseconds)",
    "hostname": "$(hostname)",
    "security_audit": {
        "sip_status": "unknown",
        "gatekeeper_status": "unknown",
        "filevault_status": "unknown",
        "firewall_status": "unknown",
        "secure_boot": "unknown"
    }
}
EOF

    # Vérifier System Integrity Protection (SIP)
    local sip_status
    sip_status=$(csrutil status 2>/dev/null | grep -i enabled && echo "enabled" || echo "disabled")
    log_action "Statut SIP : $sip_status"
    
    # Vérifier Gatekeeper
    local gatekeeper_status
    gatekeeper_status=$(spctl --status 2>/dev/null | grep -i enabled && echo "enabled" || echo "disabled")
    log_action "Statut Gatekeeper : $gatekeeper_status"
    
    # Vérifier FileVault
    local filevault_status
    filevault_status=$(fdesetup status 2>/dev/null | grep -i "on" && echo "enabled" || echo "disabled")
    log_action "Statut FileVault : $filevault_status"
    
    # Vérifier le Pare-feu
    local firewall_status
    firewall_status=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate 2>/dev/null | grep -i enabled && echo "enabled" || echo "disabled")
    log_action "Statut Pare-feu : $firewall_status"
    
    # Mettre à jour le rapport de sécurité
    /usr/bin/python3 -c "
import json
with open('$security_report', 'r') as f:
    data = json.load(f)
data['security_audit']['sip_status'] = '$sip_status'
data['security_audit']['gatekeeper_status'] = '$gatekeeper_status'
data['security_audit']['filevault_status'] = '$filevault_status'
data['security_audit']['firewall_status'] = '$firewall_status'
with open('$security_report', 'w') as f:
    json.dump(data, f, indent=2)
"

    echo "$security_report"
}

# Vérifier le statut du verrou d'activation
check_activation_lock() {
    log_action "Vérification du statut du verrou d'activation"
    
    # Vérifier si l'appareil a le verrou d'activation activé
    # Cela nécessite de vérifier avec les serveurs Apple ou l'inscription MDM
    local activation_lock_status="unknown"
    
    # Pour les appareils d'entreprise, vérifier l'inscription MDM
    if profiles -P 2>/dev/null | grep -q "com.apple.mdm"; then
        log_action "✅ Appareil inscrit en MDM"
        activation_lock_status="mdm_managed"
    else
        log_action "⚠️  Appareil non inscrit en MDM"
        activation_lock_status="not_managed"
    fi
    
    # Vérifier l'inscription DEP/ABM
    if profiles -e 2>/dev/null | grep -q "DEP"; then
        log_action "✅ Appareil inscrit DEP/ABM"
        activation_lock_status="dep_enrolled"
    fi
    
    echo "$activation_lock_status"
}

# Générer un rapport de sécurité complet
generate_security_report() {
    local report_timestamp
    report_timestamp=$(date '+%Y%m%d_%H%M%S')
    local report_file="$REPORT_DIR/security_report_$report_timestamp.json"
    
    log_action "Génération du rapport de sécurité complet : $report_file"
    
    # Obtenir les informations système
    local os_version
    local serial_number
    local hardware_uuid
    os_version=$(sw_vers -productVersion)
    serial_number=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')
    hardware_uuid=$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')
    
    # Compiler le rapport complet
    cat > "$report_file" << EOF
{
    "report_metadata": {
        "timestamp": "$(date -Iseconds)",
        "report_version": "1.0",
        "generator": "Roundfleet Security Audit"
    },
    "device_info": {
        "hostname": "$(hostname)",
        "serial_number": "$serial_number",
        "hardware_uuid": "$hardware_uuid",
        "os_version": "$os_version",
        "model": "$(system_profiler SPHardwareDataType | grep "Model Name" | awk -F': ' '{print $2}')"
    },
    "security_status": {
        "find_my_mac": {
            "enabled": $(check_find_my_mac_status >/dev/null && echo "true" || echo "false"),
            "compliance": $([ "$REQUIRE_FIND_MY_MAC" = true ] && check_find_my_mac_status >/dev/null && echo "true" || echo "false")
        },
        "apple_id": {
            "signed_in": $(check_apple_id_status >/dev/null && echo "true" || echo "false"),
            "compliance": $([ "$REQUIRE_APPLE_ID" = true ] && check_apple_id_status >/dev/null && echo "true" || echo "false")
        },
        "activation_lock": {
            "status": "$(check_activation_lock)",
            "compliance": $([ "$REQUIRE_ACTIVATION_LOCK" = true ] && echo "true" || echo "false")
        }
    },
    "compliance_summary": {
        "overall_status": "$(calculate_compliance_status)",
        "required_actions": $(generate_required_actions),
        "risk_level": "$(calculate_risk_level)"
    }
}
EOF

    log_action "Rapport de sécurité généré : $report_file"
    echo "$report_file"
}

# Calculer le statut de conformité global
calculate_compliance_status() {
    local fmm_status
    local apple_id_status
    local issues=0
    
    fmm_status=$(check_find_my_mac_status)
    if [[ "$REQUIRE_FIND_MY_MAC" = true && "$fmm_status" != "enabled" ]]; then
        ((issues++))
    fi
    
    if ! check_apple_id_status >/dev/null 2>&1; then
        if [[ "$REQUIRE_APPLE_ID" = true ]]; then
            ((issues++))
        fi
    fi
    
    if [[ $issues -eq 0 ]]; then
        echo "compliant"
    elif [[ $issues -le 2 ]]; then
        echo "partially_compliant"
    else
        echo "non_compliant"
    fi
}

# Générer les actions requises pour la conformité
generate_required_actions() {
    local actions=()
    
    if [[ "$REQUIRE_FIND_MY_MAC" = true ]] && [[ "$(check_find_my_mac_status)" != "enabled" ]]; then
        actions+=("\"Activer Find My Mac dans les Préférences Système\"")
    fi
    
    if [[ "$REQUIRE_APPLE_ID" = true ]] && ! check_apple_id_status >/dev/null 2>&1; then
        actions+=("\"Se connecter avec Apple ID dans les Préférences Système\"")
    fi
    
    if [[ ${#actions[@]} -eq 0 ]]; then
        echo "[]"
    else
        printf "[%s]" "$(IFS=,; echo "${actions[*]}")"
    fi
}

# Calculer le niveau de risque basé sur le statut de sécurité
calculate_risk_level() {
    local risk_score=0
    
    # Find My Mac désactivé ajoute du risque
    if [[ "$(check_find_my_mac_status)" != "enabled" ]]; then
        ((risk_score += 3))
    fi
    
    # Absence d'Apple ID ajoute du risque
    if ! check_apple_id_status >/dev/null 2>&1; then
        ((risk_score += 2))
    fi
    
    # Problèmes de sécurité système ajoutent du risque
    if [[ "$(csrutil status 2>/dev/null | grep -i disabled)" ]]; then
        ((risk_score += 2))
    fi
    
    if [[ $risk_score -le 1 ]]; then
        echo "low"
    elif [[ $risk_score -le 4 ]]; then
        echo "medium"
    else
        echo "high"
    fi
}

# Actions de remédiation pour les problèmes courants
remediate_security_issues() {
    log_action "Démarrage du processus de remédiation automatisé"
    
    local remediation_report="$TEMP_DIR/remediation_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$remediation_report" << EOF
{
    "timestamp": "$(date -Iseconds)",
    "hostname": "$(hostname)",
    "remediation_actions": []
}
EOF

    # Vérifier si Find My Mac peut être activé par programmation
    if [[ "$(check_find_my_mac_status)" != "enabled" ]]; then
        log_action "⚠️  Find My Mac est désactivé - intervention manuelle requise"
        log_action "   L'utilisateur doit activer Find My Mac dans Préférences Système > Apple ID > Localiser"
        
        # Ajouter au rapport de remédiation
        /usr/bin/python3 -c "
import json
with open('$remediation_report', 'r') as f:
    data = json.load(f)
data['remediation_actions'].append({
    'issue': 'Find My Mac désactivé',
    'action': 'intervention_manuelle_requise',
    'instructions': 'Activer Find My Mac dans Préférences Système > Apple ID > Localiser'
})
with open('$remediation_report', 'w') as f:
    json.dump(data, f, indent=2)
"
    fi
    
    # Générer une notification utilisateur si nécessaire
    if [[ "$(calculate_compliance_status)" != "compliant" ]]; then
        create_user_notification
    fi
    
    echo "$remediation_report"
}

# Créer une notification utilisateur pour la conformité de sécurité
create_user_notification() {
    log_action "Création d'une notification utilisateur pour la conformité de sécurité"
    
    local notification_title="Conformité de Sécurité Roundfleet"
    local notification_message="Votre appareil nécessite des mises à jour de configuration de sécurité. Veuillez contacter le support IT."
    
    # Utiliser AppleScript pour afficher la notification
    osascript -e "display notification \"$notification_message\" with title \"$notification_title\""
    
    # Créer un fichier de rappel persistant
    cat > "/tmp/roundfleet_security_reminder.txt" << EOF
Conformité de Sécurité Roundfleet Requise

Votre appareil nécessite l'activation des fonctionnalités de sécurité suivantes :
- Find My Mac
- Connexion Apple ID
- Verrou d'Activation

Veuillez contacter le support IT pour assistance.
Généré : $(date)
EOF
}

# Surveiller le statut Find My Mac dans le temps
monitor_security_status() {
    log_action "Démarrage de la surveillance de sécurité continue"
    
    local monitoring_interval=3600  # 1 heure
    local monitoring_log="$LOG_FILE.monitoring"
    
    while true; do
        {
            echo "=== Vérification du Statut de Sécurité - $(date) ==="
            echo "Find My Mac : $(check_find_my_mac_status)"
            echo "Apple ID : $(check_apple_id_status >/dev/null && echo "connecté" || echo "non_connecté")"
            echo "Conformité : $(calculate_compliance_status)"
            echo "Niveau de Risque : $(calculate_risk_level)"
            echo "----------------------------------------"
        } >> "$monitoring_log"
        
        sleep "$monitoring_interval"
    done
}

# Évaluation de sécurité à l'échelle de la flotte
fleet_security_assessment() {
    log_action "Exécution de l'évaluation de sécurité à l'échelle de la flotte"
    
    local fleet_report="$REPORT_DIR/fleet_security_$(date '+%Y%m%d_%H%M%S').json"
    
    # Cela s'intégrerait typiquement avec MDM ou gestion de configuration
    # Pour démonstration, nous montrerons l'évaluation de l'appareil actuel
    
    cat > "$fleet_report" << EOF
{
    "assessment_timestamp": "$(date -Iseconds)",
    "fleet_summary": {
        "total_devices": 1,
        "compliant_devices": $([ "$(calculate_compliance_status)" = "compliant" ] && echo "1" || echo "0"),
        "non_compliant_devices": $([ "$(calculate_compliance_status)" != "compliant" ] && echo "1" || echo "0")
    },
    "devices": [
        $(generate_security_report | tail -n +2 | head -n -1)
    ],
    "recommendations": [
        "Implémenter l'activation automatisée de Find My Mac via MDM",
        "Imposer la connexion Apple ID via l'inscription d'appareil",
        "Audit de conformité de sécurité régulier",
        "Éducation des utilisateurs sur les fonctionnalités de sécurité"
    ]
}
EOF

    log_action "Évaluation de sécurité de flotte terminée : $fleet_report"
    echo "$fleet_report"
}

# Fonction d'exécution principale
main() {
    local action="${1:-check}"
    
    log_action "=== Démarrage de la Gestion de Sécurité Roundfleet ==="
    log_action "Action : $action"
    log_action "Nom d'hôte : $(hostname)"
    log_action "Utilisateur : $(whoami)"
    
    # Configuration
    setup_directories
    
    case "$action" in
        "check")
            echo "=== Vérification de Sécurité Find My Mac ==="
            echo "Statut Find My Mac : $(check_find_my_mac_status)"
            echo "Statut Apple ID : $(check_apple_id_status >/dev/null && echo "connecté" || echo "non_connecté")"
            echo "Verrou d'Activation : $(check_activation_lock)"
            echo "Statut de Conformité : $(calculate_compliance_status)"
            echo "Niveau de Risque : $(calculate_risk_level)"
            ;;
        "audit")
            echo "Exécution de l'audit de sécurité complet..."
            security_report=$(generate_security_report)
            echo "Audit de sécurité terminé : $security_report"
            ;;
        "remediate")
            echo "Démarrage du processus de remédiation..."
            remediation_report=$(remediate_security_issues)
            echo "Remédiation terminée : $remediation_report"
            ;;
        "monitor")
            echo "Démarrage de la surveillance continue..."
            monitor_security_status
            ;;
        "fleet")
            echo "Exécution de l'évaluation à l'échelle de la flotte..."
            fleet_report=$(fleet_security_assessment)
            echo "Évaluation de flotte terminée : $fleet_report"
            ;;
        *)
            echo "Usage : $0 {check|audit|remediate|monitor|fleet}"
            echo "  check     - Vérification rapide du statut de sécurité"
            echo "  audit     - Audit de sécurité complet"
            echo "  remediate - Actions de remédiation automatisées"
            echo "  monitor   - Surveillance de sécurité continue"
            echo "  fleet     - Évaluation de sécurité à l'échelle de la flotte"
            exit 1
            ;;
    esac
    
    # Nettoyage
    rm -rf "$TEMP_DIR"
    
    log_action "=== Gestion de sécurité terminée ==="
}

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

Intégration Apple ID et iCloud

Vérifier le Statut de Connexion Apple ID

#!/bin/bash

# Vérification complète de l'Apple ID
check_apple_id_comprehensive() {
    echo "=== Vérification du Statut Apple ID ==="
    
    # Vérifier les comptes iCloud
    local icloud_accounts
    icloud_accounts=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep -c AccountID || echo "0")
    
    if [[ "$icloud_accounts" -gt 0 ]]; then
        echo "✅ Apple ID connecté ($icloud_accounts compte(s))"
        
        # Obtenir les détails du compte (respectueux de la confidentialité)
        defaults read MobileMeAccounts Accounts 2>/dev/null | grep AccountID | while read -r line; do
            local account_id
            account_id=$(echo "$line" | sed 's/.*= "\(.*\)";/\1/' | sed 's/\(.*@\)\(.*\)/\1***/g')
            echo "   Compte : $account_id"
        done
        
        # Vérifier les services iCloud
        echo "Services iCloud :"
        defaults read MobileMeAccounts Accounts 2>/dev/null | grep -E "(BookmarksSyncEnabled|ContactsSyncEnabled|MailSyncEnabled)" | while read -r service; do
            echo "   $service"
        done
        
        return 0
    else
        echo "❌ Aucun Apple ID connecté"
        return 1
    fi
}

Vérifier le Statut des Services iCloud

#!/bin/bash

# Vérifier les services iCloud spécifiques
check_icloud_services() {
    echo "=== Statut des Services iCloud ==="
    
    # Vérifier Find My Mac spécifiquement
    local fmf_token
    fmf_token=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep -i findmyfriends || echo "")
    
    if [[ -n "$fmf_token" ]]; then
        echo "✅ Service Find My Friends/Family actif"
    else
        echo "⚠️  Service Find My Friends/Family non configuré"
    fi
    
    # Vérifier d'autres services critiques
    local services=(
        "BookmarksSyncEnabled:Signets Safari"
        "ContactsSyncEnabled:Contacts"
        "CalendarSyncEnabled:Calendrier"
        "KeychainSyncEnabled:Trousseau"
    )
    
    for service in "${services[@]}"; do
        local key="${service%%:*}"
        local name="${service##*:}"
        local status
        status=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep "$key" | head -1 | grep -o "[01]" || echo "0")
        
        if [[ "$status" = "1" ]]; then
            echo "✅ Synchronisation $name activée"
        else
            echo "❌ Synchronisation $name désactivée"
        fi
    done
}

Politiques de Sécurité d'Entreprise

Définir les Exigences de Sécurité

#!/bin/bash

# Configuration des politiques de sécurité d'entreprise
apply_security_policies() {
    echo "=== Application des Politiques de Sécurité d'Entreprise ==="
    
    local policy_file="/etc/roundfleet/security_policies.json"
    
    # Créer la configuration des politiques de sécurité
    mkdir -p "$(dirname "$policy_file")"
    cat > "$policy_file" << 'EOF'
{
    "security_policies": {
        "find_my_mac": {
            "required": true,
            "enforcement": "advisory",
            "grace_period_days": 7
        },
        "apple_id": {
            "required": true,
            "corporate_domain_only": false,
            "enforcement": "mandatory"
        },
        "activation_lock": {
            "required": true,
            "mdm_managed": true
        },
        "system_security": {
            "sip_required": true,
            "gatekeeper_required": true,
            "filevault_required": true,
            "firewall_required": true
        }
    },
    "compliance_reporting": {
        "frequency": "daily",
        "recipients": ["[email protected]"],
        "escalation_threshold": "medium"
    }
}
EOF

    echo "Politiques de sécurité configurées : $policy_file"
}

Surveillance de Conformité

#!/bin/bash

# Surveillance de conformité automatisée
setup_compliance_monitoring() {
    local monitoring_script="/usr/local/bin/roundfleet_compliance_monitor.sh"
    local launchd_plist="/Library/LaunchDaemons/com.roundfleet.security.compliance.plist"
    
    # Créer le script de surveillance
    cat > "$monitoring_script" << 'EOF'
#!/bin/bash
LOG_FILE="/var/log/roundfleet_compliance.log"
exec > >(tee -a "$LOG_FILE") 2>&1

echo "$(date): Démarrage de la vérification de conformité de sécurité"

# Exécuter l'audit de sécurité
/usr/local/bin/roundfleet_security_manager.sh audit

# Vérifier la non-conformité
COMPLIANCE_STATUS=$(calculate_compliance_status)
if [[ "$COMPLIANCE_STATUS" != "compliant" ]]; then
    echo "$(date): Non-conformité détectée - $COMPLIANCE_STATUS"
    
    # Envoyer une alerte (implémenter selon votre système de notification)
    echo "L'appareil $(hostname) est non-conforme" | mail -s "Alerte de Conformité de Sécurité" [email protected]
fi

echo "$(date): Vérification de conformité terminée"
EOF

    chmod +x "$monitoring_script"
    
    # Créer le LaunchDaemon pour les vérifications de conformité programmées
    cat > "$launchd_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.security.compliance</string>
    <key>ProgramArguments</key>
    <array>
        <string>$monitoring_script</string>
    </array>
    <key>StartCalendarInterval</key>
    <array>
        <dict>
            <key>Hour</key>
            <integer>9</integer>
            <key>Minute</key>
            <integer>0</integer>
        </dict>
        <dict>
            <key>Hour</key>
            <integer>17</integer>
            <key>Minute</key>
            <integer>0</integer>
        </dict>
    </array>
    <key>RunAtLoad</key>
    <false/>
</dict>
</plist>
EOF

    # Charger le LaunchDaemon
    sudo launchctl load "$launchd_plist"
    
    echo "Surveillance de conformité configurée"
    echo "Script : $monitoring_script"
    echo "Planification : Quotidien à 9h00 et 17h00"
}

Indicateurs de Statut de Sécurité

Comprendre les Tokens NVRAM

Le statut Find My Mac est stocké dans les tokens NVRAM (Non-Volatile Random Access Memory) :

Interpréter les États de Sécurité

Dépannage des Problèmes Courants

Find My Mac Ne S'Active Pas

#!/bin/bash

# Dépanner les problèmes Find My Mac
troubleshoot_find_my_mac() {
    echo "=== Dépannage Find My Mac ==="
    
    # Vérifier les prérequis
    echo "Vérification des prérequis..."
    
    # 1. Vérifier la connectivité internet
    if ping -c 1 apple.com >/dev/null 2>&1; then
        echo "✅ Connectivité internet : OK"
    else
        echo "❌ Connectivité internet : ÉCHEC"
        echo "   - Vérifiez la connexion réseau"
        echo "   - Vérifiez les paramètres DNS"
    fi
    
    # 2. Vérifier la connexion Apple ID
    if check_apple_id_status >/dev/null 2>&1; then
        echo "✅ Connexion Apple ID : OK"
    else
        echo "❌ Connexion Apple ID : REQUISE"
        echo "   - Se connecter à Apple ID dans Préférences Système"
        echo "   - Activer les services iCloud"
    fi
    
    # 3. Vérifier les services iCloud
    local icloud_enabled
    icloud_enabled=$(defaults read MobileMeAccounts Accounts 2>/dev/null | grep -c "Enabled.*1" || echo "0")
    
    if [[ "$icloud_enabled" -gt 0 ]]; then
        echo "✅ Services iCloud : ACTIVÉS"
    else
        echo "❌ Services iCloud : DÉSACTIVÉS"
        echo "   - Activer iCloud dans Préférences Système"
        echo "   - S'assurer que Find My Mac est coché"
    fi
    
    # 4. Vérifier les exigences système
    local os_version
    os_version=$(sw_vers -productVersion)
    
    if [[ "$(echo "$os_version" | cut -d. -f1)" -ge 10 ]] && [[ "$(echo "$os_version" | cut -d. -f2)" -ge 11 ]]; then
        echo "✅ Version macOS : SUPPORTÉE ($os_version)"
    else
        echo "❌ Version macOS : NON SUPPORTÉE ($os_version)"
        echo "   - Find My Mac nécessite macOS 10.11 ou ultérieur"
    fi
}

Étapes de Remédiation Manuelle

#!/bin/bash

# Générer un guide de remédiation manuelle
generate_remediation_guide() {
    local guide_file="/tmp/roundfleet_remediation_guide.txt"
    
    cat > "$guide_file" << EOF
Guide de Remédiation de Sécurité Roundfleet
==========================================

Appareil : $(hostname)
Date : $(date)

Actions Requises :
EOF

    if [[ "$(check_find_my_mac_status)" != "enabled" ]]; then
        cat >> "$guide_file" << EOF

1. Activer Find My Mac :
   - Ouvrez Préférences Système
   - Cliquez sur Apple ID (ou iCloud sur les anciens systèmes)
   - Connectez-vous avec votre Apple ID si pas déjà connecté
   - Cliquez sur "Localiser" dans la barre latérale
   - Cochez "Find My Mac"
   - Cochez "Activer la recherche hors ligne" (si disponible)
   - Cliquez sur "Autoriser" quand demandé pour l'accès à la localisation

EOF
    fi
    
    if ! check_apple_id_status >/dev/null 2>&1; then
        cat >> "$guide_file" << EOF

2. Se connecter à Apple ID :
   - Ouvrez Préférences Système
   - Cliquez sur Apple ID en haut
   - Entrez votre Apple ID et mot de passe
   - Complétez l'authentification à deux facteurs si demandée
   - Activez les services iCloud selon les besoins

EOF
    fi
    
    cat >> "$guide_file" << EOF

Pour assistance, contactez le Support IT :
- Email : [email protected]
- Téléphone : +1-555-0123
- Système de Tickets : https://support.company.com

EOF

    echo "Guide de remédiation créé : $guide_file"
    open "$guide_file"
}

Meilleures Pratiques

🔐 Directives de Sécurité

• Activez Find My Mac sur tous les appareils d'entreprise
• Exigez la connexion Apple ID pour la responsabilité des appareils
• Surveillez le statut de conformité régulièrement
• Implémentez des alertes automatisées pour la non-conformité

📋 Recommandations de Gestion

• Utilisez l'inscription MDM pour le verrou d'activation d'entreprise
• Audits de sécurité réguliers sur la flotte d'appareils
• Éducation des utilisateurs sur l'importance des fonctionnalités de sécurité
• Surveillance et rapports de conformité automatisés

🔍 Stratégie de Surveillance

• Vérifications de conformité quotidiennes pendant les heures de bureau
• Alertes immédiates pour les violations de sécurité
• Analyse des tendances des métriques de conformité
• Révision régulière des politiques et mises à jour

Notes Importantes

• Find My Mac nécessite macOS 10.11 ou ultérieur pour une fonctionnalité complète
• La connexion Apple ID est obligatoire pour le fonctionnement de Find My Mac
• Connectivité réseau requise pour la configuration initiale et le fonctionnement continu
• Considérations de confidentialité doivent être documentées pour l'usage d'entreprise
• Testez les procédures de remédiation avant le déploiement d'entreprise