Guide

Nouvelles mises à jour et améliorations de Macfleet.

Gestion d'Utilisateur Invité sur macOS

Gérez les comptes d'utilisateur invité et l'accès temporaire sécurisé sur vos appareils MacFleet en utilisant des systèmes de gestion d'utilisateur invité avancés. Ce tutoriel couvre la configuration de compte invité, les politiques de sécurité, la surveillance d'accès et la gestion complète du cycle de vie d'invité.

Comprendre la Gestion d'Utilisateur Invité macOS

macOS fournit la fonctionnalité d'utilisateur invité pour l'accès temporaire et sécurisé :

  • defaults - Gestion des préférences système et configuration
  • Compte Utilisateur Invité - Accès temporaire sans authentification
  • Bac à Sable Sécurisé - Environnement isolé pour sessions invité
  • Nettoyage Automatique - Suppression des données de session à la déconnexion
  • Contrôles d'Accès - Gestion des restrictions et permissions

Opérations d'Utilisateur Invité de Base

Activer le Compte Utilisateur Invité

#!/bin/bash

# Activation d'utilisateur invité de base
defaults write /Library/Preferences/com.apple.loginwindow GuestEnabled -bool TRUE

echo "Compte utilisateur invité activé avec succès"

Configuration d'Utilisateur Invité Améliorée

#!/bin/bash

# Configuration complète d'utilisateur invité avec paramètres de sécurité
configure_guest_user() {
    echo "=== Configuration Complète d'Utilisateur Invité ==="
    
    # Activer l'utilisateur invité
    echo "Activation du compte utilisateur invité..."
    sudo defaults write /Library/Preferences/com.apple.loginwindow GuestEnabled -bool TRUE
    
    # Configurer les restrictions d'utilisateur invité
    echo "Configuration des paramètres de sécurité utilisateur invité..."
    
    # Empêcher l'utilisateur invité de faire des changements système
    sudo defaults write /Library/Preferences/com.apple.loginwindow GuestAllowedToChangeNetwork -bool FALSE
    
    # Définir les restrictions de dossier home utilisateur invité
    sudo defaults write /Library/Preferences/com.apple.loginwindow GuestHomeIsSeparateDisk -bool TRUE
    
    # Configurer la déconnexion automatique
    sudo defaults write /Library/Preferences/com.apple.loginwindow GuestAutoLogout -int 3600
    
    # Empêcher l'utilisateur invité d'accéder aux volumes chiffrés
    sudo defaults write /Library/Preferences/com.apple.loginwindow GuestCanAccessEncryptedVolumes -bool FALSE
    
    echo "Configuration utilisateur invité terminée"
}

# Exécuter la configuration complète
configure_guest_user

Catégories d'Utilisateur Invité

Classifications d'Accès Invité

#!/bin/bash

# Catégories d'utilisateur invité pour différents besoins organisationnels
declare -A GUEST_USER_CATEGORIES=(
    ["kiosque_hall"]="Accès public hall pour visiteurs et navigation d'informations"
    ["salle_conference"]="Accès salle de réunion pour présentations et collaboration"
    ["station_bibliotheque"]="Terminaux d'accès public institution éducative"
    ["vitrine_demo"]="Stations de démonstration produit et présentation ventes"
    ["poste_visiteur"]="Postes de travail temporaires pour visiteurs d'affaires"
    ["inscription_evenement"]="Terminaux d'enregistrement et inscription événement"
    ["service_client"]="Terminaux de service client et support"
    ["labo_formation"]="Accès temporaire formation et ateliers"
    ["portail_wifi_public"]="Accès WiFi public et acceptation conditions"
    ["acces_urgence"]="Stations d'accès d'urgence pour utilisation personnel"
)

# Niveaux de sécurité pour accès invité
declare -A SECURITY_LEVELS=(
    ["kiosque_hall"]="restriction_elevee"
    ["salle_conference"]="restriction_moyenne"
    ["station_bibliotheque"]="restriction_moyenne"
    ["vitrine_demo"]="restriction_faible"
    ["poste_visiteur"]="restriction_elevee"
    ["inscription_evenement"]="restriction_moyenne"
    ["service_client"]="restriction_elevee"
    ["labo_formation"]="restriction_faible"
    ["portail_wifi_public"]="restriction_maximale"
    ["acces_urgence"]="restriction_minimale"
)

# Limites de durée de session
declare -A SESSION_LIMITS=(
    ["kiosque_hall"]="1800"      # 30 minutes
    ["salle_conference"]="10800"  # 3 heures
    ["station_bibliotheque"]="7200"   # 2 heures
    ["vitrine_demo"]="3600"     # 1 heure
    ["poste_visiteur"]="14400" # 4 heures
    ["inscription_evenement"]="900"  # 15 minutes
    ["service_client"]="1800"   # 30 minutes
    ["labo_formation"]="21600"     # 6 heures
    ["portail_wifi_public"]="300"  # 5 minutes
    ["acces_urgence"]="illimite"
)

print_guest_categories() {
    echo "=== Catégories d'Utilisateur Invité ==="
    for category in "${!GUEST_USER_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${GUEST_USER_CATEGORIES[$category]}"
        echo "  Niveau de Sécurité : ${SECURITY_LEVELS[$category]}"
        echo "  Limite de Session : ${SESSION_LIMITS[$category]} secondes"
        echo ""
    done
}

# Afficher les catégories disponibles
print_guest_categories

Politiques d'Utilisateur Invité

Moteur de Politique d'Accès

#!/bin/bash

# Politiques de gestion d'utilisateur invité pour différentes exigences de sécurité
declare -A GUEST_POLICIES=(
    ["acces_public_securise"]="Accès public sécurisé avec restrictions maximales"
    ["visiteur_affaires_standard"]="Accès visiteur d'affaires standard avec surveillance"
    ["educatif_ouvert"]="Environnement éducatif avec accès axé apprentissage"
    ["demo_presentation"]="Accès optimisé démonstration et présentation"
    ["urgence_minimal"]="Accès d'urgence avec restrictions minimales"
    ["conformite_stricte"]="Conformité stricte avec audit et surveillance complets"
)

# Appliquer une politique d'utilisateur invité
apply_guest_policy() {
    local policy="$1"
    local config_file="/tmp/politique_invite.json"
    
    echo "Application de la politique d'utilisateur invité : $policy"
    
    case "$policy" in
        "acces_public_securise")
            cat > "$config_file" << EOF
{
    "invite_active": true,
    "timeout_session": 1800,
    "acces_reseau": false,
    "telechargements_fichiers": false,
    "acces_usb": false,
    "impression_autorisee": false,
    "applications_autorisees": ["Safari", "TextEdit", "Preview"],
    "acces_preferences_systeme": false,
    "deconnexion_auto_activee": true,
    "surveillance_session": "complete",
    "retention_donnees": "aucune",
    "journalisation_audit": "detaillee"
}
EOF
            ;;
        "visiteur_affaires_standard")
            cat > "$config_file" << EOF
{
    "invite_active": true,
    "timeout_session": 14400,
    "acces_reseau": true,
    "telechargements_fichiers": true,
    "acces_usb": false,
    "impression_autorisee": true,
    "applications_autorisees": ["Safari", "TextEdit", "Preview", "Mail", "Calendar"],
    "acces_preferences_systeme": false,
    "deconnexion_auto_activee": true,
    "surveillance_session": "standard",
    "retention_donnees": "session_seulement",
    "journalisation_audit": "standard"
}
EOF
            ;;
        *)
            echo "Politique d'invité inconnue : $policy"
            return 1
            ;;
    esac
    
    echo "✅ Politique d'utilisateur invité appliquée avec succès"
    echo "Configuration : $config_file"
    
    return 0
}

Surveillance Avancée d'Utilisateur Invité

Analyse de Session Invité

#!/bin/bash

# Surveillance et analyse complètes de session invité
monitor_guest_sessions() {
    local monitoring_profile="$1"
    local session_report="/tmp/session_invite_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Surveillance de Session Invité ==="
    echo "Profil de Surveillance : $monitoring_profile"
    
    # Vérifier l'état de l'utilisateur invité
    echo "Vérification de l'état utilisateur invité..."
    local guest_enabled
    guest_enabled=$(defaults read /Library/Preferences/com.apple.loginwindow GuestEnabled 2>/dev/null || echo "false")
    
    local guest_auto_logout
    guest_auto_logout=$(defaults read /Library/Preferences/com.apple.loginwindow GuestAutoLogout 2>/dev/null || echo "0")
    
    # Vérifier les sessions invité actives
    echo "Analyse des sessions actives..."
    local active_users
    active_users=$(who | grep -v "^$USER" | wc -l | tr -d ' ')
    
    local guest_sessions
    guest_sessions=$(who | grep "Guest" | wc -l | tr -d ' ')
    
    # Afficher les résultats
    echo ""
    echo "Résultats d'Analyse de Session Invité :"
    echo "  Utilisateur Invité Activé : $([ "$guest_enabled" = "1" ] && echo "✅ OUI" || echo "❌ NON")"
    echo "  Déconnexion Auto : ${guest_auto_logout} secondes"
    echo "  Utilisateurs Actifs : $active_users"
    echo "  Sessions Invité Actives : $guest_sessions"
    echo "  Rapport de Session : $session_report"
    
    return 0
}

Système de Gestion d'Utilisateur Invité

#!/bin/bash

# Système de Gestion d'Utilisateur Invité MacFleet
# Contrôle d'accès invité complet, surveillance et sécurité

# Configuration
CONFIG_DIR="/etc/macfleet/invite"
LOG_FILE="/var/log/macfleet_gestion_invite.log"
AUDIT_LOG="/var/log/macfleet_audit_invite.log"

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

audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}

# Application de sécurité utilisateur invité
enforce_guest_security() {
    local security_level="$1"
    
    log_action "Application du niveau de sécurité invité : $security_level"
    
    echo "=== Application de Sécurité Utilisateur Invité ==="
    echo "Niveau de Sécurité : $security_level"
    
    case "$security_level" in
        "restriction_maximale")
            echo "Application des restrictions de sécurité maximales..."
            
            # Désactiver l'accès réseau pour l'invité
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestNetworkAccess -bool FALSE
            
            # Désactiver l'accès aux médias amovibles
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestRemovableMediaAccess -bool FALSE
            
            # Désactiver l'impression
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestPrintingAccess -bool FALSE
            
            echo "  ✅ Restrictions de sécurité maximales appliquées"
            ;;
            
        "restriction_standard")
            echo "Application des restrictions de sécurité standard..."
            
            # Permettre accès réseau limité
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestNetworkAccess -bool TRUE
            
            # Désactiver l'accès aux médias amovibles
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestRemovableMediaAccess -bool FALSE
            
            echo "  ✅ Restrictions de sécurité standard appliquées"
            ;;
            
        *)
            echo "❌ Niveau de sécurité inconnu : $security_level"
            return 1
            ;;
    esac
    
    audit_log "Application de sécurité invité terminée : $security_level"
    
    return 0
}

# Gestion du cycle de vie invité
manage_guest_lifecycle() {
    local action="$1"
    
    log_action "Gestion du cycle de vie invité : $action"
    
    case "$action" in
        "nettoyer_sessions_expirees")
            echo "Nettoyage des sessions invité expirées..."
            
            # Forcer la déconnexion des sessions invité inactives
            pkill -u Guest 2>/dev/null
            
            # Nettoyer le répertoire home invité
            sudo rm -rf /Users/Guest/* 2>/dev/null
            
            echo "  ✅ Sessions expirées nettoyées"
            ;;
            
        "reinitialiser_environnement_invite")
            echo "Réinitialisation de l'environnement invité..."
            
            # Réinitialiser les préférences utilisateur invité
            sudo rm -rf /Users/Guest/Library/Preferences/* 2>/dev/null
            
            # Effacer les données d'application invité
            sudo rm -rf /Users/Guest/Library/Application\ Support/* 2>/dev/null
            
            echo "  ✅ Environnement invité réinitialisé"
            ;;
            
        *)
            echo "❌ Action de cycle de vie inconnue : $action"
            return 1
            ;;
    esac
    
    return 0
}

# Surveillance de conformité invité
monitor_guest_compliance() {
    local compliance_framework="$1"
    
    log_action "Surveillance de conformité utilisateur invité : $compliance_framework"
    
    echo "=== Surveillance de Conformité Utilisateur Invité ==="
    echo "Cadre : $compliance_framework"
    
    local violations=()
    local compliance_score=100
    
    case "$compliance_framework" in
        "standard_securite")
            # Vérifier si l'utilisateur invité est correctement configuré
            local guest_enabled
            guest_enabled=$(defaults read /Library/Preferences/com.apple.loginwindow GuestEnabled 2>/dev/null || echo "false")
            
            if [[ "$guest_enabled" != "1" && "$guest_enabled" != "true" ]]; then
                violations+=("utilisateur_invite_mal_configure")
                ((compliance_score -= 20))
            fi
            ;;
            
        "protection_vie_privee")
            # Vérifier les politiques de rétention de données
            if [[ -d "/Users/Guest" && -n "$(ls -A /Users/Guest 2>/dev/null)" ]]; then
                violations+=("donnees_invite_non_nettoyees")
                ((compliance_score -= 25))
            fi
            ;;
            
        *)
            echo "❌ Cadre de conformité inconnu : $compliance_framework"
            return 1
            ;;
    esac
    
    echo ""
    echo "Résultats de Conformité :"
    echo "  Cadre : $compliance_framework"
    echo "  Score de Conformité : $compliance_score/100"
    echo "  Violations Trouvées : ${#violations[@]}"
    
    if [[ ${#violations[@]} -gt 0 ]]; then
        echo "  Violations :"
        for violation in "${violations[@]}"; do
            echo "    - $violation"
        done
    else
        echo "  ✅ Aucune violation trouvée"
    fi
    
    audit_log "Surveillance conformité invité terminée : $compliance_framework (Score : $compliance_score/100)"
    
    return 0
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    case "$command" in
        "activer")
            # Activer l'utilisateur invité avec configuration de base
            configure_guest_user
            ;;
        "desactiver")
            # Désactiver l'utilisateur invité
            sudo defaults write /Library/Preferences/com.apple.loginwindow GuestEnabled -bool FALSE
            echo "Utilisateur invité désactivé"
            ;;
        "statut")
            # Vérifier l'état de l'utilisateur invité
            local status
            status=$(defaults read /Library/Preferences/com.apple.loginwindow GuestEnabled 2>/dev/null || echo "false")
            echo "État Utilisateur Invité : $([ "$status" = "1" ] && echo "Activé" || echo "Désactivé")"
            ;;
        "surveiller_sessions")
            monitor_guest_sessions "$@"
            ;;
        "appliquer_politique")
            apply_guest_policy "$@"
            ;;
        "appliquer_securite")
            enforce_guest_security "$@"
            ;;
        "gerer_cycle_vie")
            manage_guest_lifecycle "$@"
            ;;
        "verification_conformite")
            monitor_guest_compliance "$@"
            ;;
        "afficher_categories")
            print_guest_categories
            ;;
        *)
            echo "Système de Gestion d'Utilisateur Invité MacFleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  activer                                   - Activer utilisateur invité avec configuration"
            echo "  desactiver                                - Désactiver utilisateur invité"
            echo "  statut                                    - Vérifier état utilisateur invité"
            echo "  surveiller_sessions <profil>              - Surveiller sessions invité"
            echo "  appliquer_politique <politique>           - Appliquer politique utilisateur invité"
            echo "  appliquer_securite <niveau>               - Appliquer restrictions de sécurité"
            echo "  gerer_cycle_vie <action>                  - Gérer cycle de vie invité"
            echo "  verification_conformite <cadre>           - Vérifier conformité"
            echo "  afficher_categories                       - Afficher catégories utilisateur invité"
            echo ""
            echo "Exemples :"
            echo "  $0 activer"
            echo "  $0 appliquer_politique acces_public_securise"
            echo "  $0 appliquer_securite restriction_maximale"
            echo "  $0 surveiller_sessions complet"
            echo "  $0 gerer_cycle_vie nettoyer_sessions_expirees"
            echo "  $0 verification_conformite standard_securite"
            ;;
    esac
}

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

Considérations de Sécurité

Sécurité Utilisateur Invité

  • Isolation de Session - Isolation complète des sessions invité des données système et utilisateur
  • Prévention de Données - Empêcher la persistance de données et fuite d'informations
  • Restrictions Réseau - Contrôler l'accès réseau et communications externes
  • Contrôles d'Application - Restreindre les applications disponibles et accès système
  • Surveillance et Audit - Journalisation complète des activités invité

Cadre de Conformité

  • Protection de Vie Privée - S'assurer que les sessions invité ne compromettent pas la vie privée utilisateur
  • Sécurité des Données - Empêcher l'accès non autorisé aux informations sensibles
  • Contrôles d'Accès - Implémenter des restrictions et limitations d'accès appropriées
  • Gestion de Session - Cycle de vie de session approprié et procédures de nettoyage
  • Exigences d'Audit - Maintenir la conformité avec les standards d'audit et surveillance

Guide de Dépannage

Problèmes Courants

Utilisateur Invité N'Apparaît Pas

  • Vérifier que l'utilisateur invité est activé : defaults read /Library/Preferences/com.apple.loginwindow GuestEnabled
  • Vérifier les paramètres de fenêtre de connexion dans Préférences Système
  • Redémarrer le processus de fenêtre de connexion : sudo killall loginwindow

Session Invité Ne Se Déconnecte Pas Automatiquement

  • Vérifier la configuration de déconnexion automatique : defaults read /Library/Preferences/com.apple.loginwindow GuestAutoLogout
  • Vérifier les processus invité en cours empêchant la déconnexion
  • Forcer manuellement la déconnexion invité si nécessaire

Commandes de Diagnostic

# Vérifier l'état utilisateur invité
defaults read /Library/Preferences/com.apple.loginwindow GuestEnabled

# Vérifier le paramètre de déconnexion automatique
defaults read /Library/Preferences/com.apple.loginwindow GuestAutoLogout

# Lister les sessions invité actives
who | grep Guest

# Voir l'historique de connexion invité
last | grep Guest

Notes Importantes

  • Sécurité des Données - Les sessions invité ne doivent jamais avoir accès aux données sensibles
  • Nettoyage de Session - S'assurer du nettoyage approprié des données invité à la déconnexion
  • Restrictions d'Accès - Implémenter des restrictions appropriées basées sur le cas d'usage
  • Surveillance - Maintenir des journaux et surveillance pour sécurité et conformité
  • Maintenance Régulière - Nettoyer et réinitialiser régulièrement les environnements invité
  • Tests de Sécurité - Tester les restrictions invité pour s'assurer de l'isolation appropriée

Récupérer les versions des applications installées sur macOS

La gestion d'une flotte Mac nécessite de suivre les versions d'applications sur tous les appareils. Ce tutoriel vous montre comment créer et déployer des scripts pour récupérer les versions d'applications sur les appareils macOS à distance.

Pourquoi le suivi des versions d'applications est important

Le suivi des versions d'applications est crucial pour :

  • Conformité de sécurité : S'assurer que tous les appareils exécutent des versions logicielles supportées
  • Gestion des licences : Suivre les déploiements logiciels et la conformité
  • Planification des mises à jour : Identifier les appareils qui nécessitent des mises à jour d'applications
  • Efficacité du support : Identifier rapidement les versions logicielles lors du dépannage
  • Gestion d'inventaire : Maintenir des enregistrements précis des ressources logicielles

Récupération basique des versions d'applications

Utilisation de la commande mdls

La commande mdls lit les attributs de métadonnées des fichiers, y compris les informations de version d'application stockées dans l'attribut kMDItemVersion.

#!/bin/bash

# Script basique pour récupérer les versions d'applications
applications=("Safari" "Mail" "Calendar" "Notes" "Contacts")
heading_printed=false

for app in "${applications[@]}"; do
    version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    
    if [ -z "$version" ]; then
        echo "Impossible de récupérer la version pour ${app}"
    else
        if [ "$heading_printed" = false ]; then
            echo "Versions des applications :"
            heading_printed=true
        fi
        echo "${app}: ${version}"
    fi
done

Script de version amélioré avec contexte utilisateur

Pour les applications installées dans des emplacements spécifiques à l'utilisateur, vous devrez peut-être exécuter le script avec le contexte utilisateur :

#!/bin/bash

# Script amélioré avec support du contexte utilisateur
applications=("Safari" "Mail" "Calendar" "Notes" "Contacts" "Xcode" "Final Cut Pro")
current_user=$(whoami)
heading_printed=false

echo "Vérification des versions d'applications pour l'utilisateur : $current_user"
echo "Date : $(date)"
echo "----------------------------------------"

for app in "${applications[@]}"; do
    # Essayer d'abord le dossier Applications système
    version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    
    # Si non trouvé, essayer le dossier Applications utilisateur
    if [ -z "$version" ]; then
        version=$(mdls -name kMDItemVersion "/Users/$current_user/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    fi
    
    if [ -z "$version" ]; then
        echo "❌ Impossible de récupérer la version pour ${app}"
    else
        if [ "$heading_printed" = false ]; then
            echo "Versions des applications :"
            heading_printed=true
        fi
        echo "✅ ${app}: ${version}"
    fi
done

Scripts d'inventaire avancés

Scanner d'applications complet

#!/bin/bash

# Scanner complet des versions d'applications
OUTPUT_FILE="/tmp/app_versions_$(date +%Y%m%d_%H%M%S).txt"
DEVICE_NAME=$(scutil --get ComputerName)
DEVICE_USER=$(whoami)

echo "Rapport des versions d'applications MacFleet" > "$OUTPUT_FILE"
echo "===========================================" >> "$OUTPUT_FILE"
echo "Appareil : $DEVICE_NAME" >> "$OUTPUT_FILE"
echo "Utilisateur : $DEVICE_USER" >> "$OUTPUT_FILE"
echo "Date : $(date)" >> "$OUTPUT_FILE"
echo "Version macOS : $(sw_vers -productVersion)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# Fonction pour récupérer les informations de l'application
get_app_info() {
    local app_path="$1"
    local app_name=$(basename "$app_path" .app)
    
    if [ -d "$app_path" ]; then
        local version=$(mdls -name kMDItemVersion "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        local bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        local size=$(du -sh "$app_path" 2>/dev/null | cut -f1)
        local modified=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path" 2>/dev/null)
        
        if [ -n "$version" ]; then
            echo "Application : $app_name" >> "$OUTPUT_FILE"
            echo "  Version : $version" >> "$OUTPUT_FILE"
            echo "  Bundle ID : $bundle_id" >> "$OUTPUT_FILE"
            echo "  Taille : $size" >> "$OUTPUT_FILE"
            echo "  Modifié : $modified" >> "$OUTPUT_FILE"
            echo "  Chemin : $app_path" >> "$OUTPUT_FILE"
            echo "" >> "$OUTPUT_FILE"
        fi
    fi
}

# Scanner le dossier Applications système
echo "Applications système :" >> "$OUTPUT_FILE"
echo "--------------------" >> "$OUTPUT_FILE"
if [ -d "/Applications" ]; then
    for app in /Applications/*.app; do
        get_app_info "$app"
    done
fi

# Scanner le dossier Applications utilisateur
echo "Applications utilisateur :" >> "$OUTPUT_FILE"
echo "------------------------" >> "$OUTPUT_FILE"
if [ -d "/Users/$DEVICE_USER/Applications" ]; then
    for app in "/Users/$DEVICE_USER/Applications"/*.app; do
        get_app_info "$app"
    done
fi

# Scanner le dossier Utilitaires
echo "Utilitaires :" >> "$OUTPUT_FILE"
echo "------------" >> "$OUTPUT_FILE"
if [ -d "/Applications/Utilities" ]; then
    for app in "/Applications/Utilities"/*.app; do
        get_app_info "$app"
    done
fi

echo "Rapport généré : $OUTPUT_FILE"
echo "Total d'applications trouvées : $(grep -c "Application :" "$OUTPUT_FILE")"

# Optionnel : Afficher le rapport
cat "$OUTPUT_FILE"

Vérificateur de versions d'applications spécifiques

#!/bin/bash

# Vérifier les applications spécifiques couramment utilisées en entreprise
declare -A enterprise_apps=(
    ["Microsoft Word"]="/Applications/Microsoft Word.app"
    ["Microsoft Excel"]="/Applications/Microsoft Excel.app"
    ["Microsoft PowerPoint"]="/Applications/Microsoft PowerPoint.app"
    ["Microsoft Outlook"]="/Applications/Microsoft Outlook.app"
    ["Adobe Photoshop 2024"]="/Applications/Adobe Photoshop 2024/Adobe Photoshop 2024.app"
    ["Adobe Illustrator 2024"]="/Applications/Adobe Illustrator 2024/Adobe Illustrator 2024.app"
    ["Slack"]="/Applications/Slack.app"
    ["Zoom"]="/Applications/zoom.us.app"
    ["Google Chrome"]="/Applications/Google Chrome.app"
    ["Firefox"]="/Applications/Firefox.app"
    ["Visual Studio Code"]="/Applications/Visual Studio Code.app"
    ["Docker Desktop"]="/Applications/Docker.app"
    ["Xcode"]="/Applications/Xcode.app"
)

echo "Vérification des versions d'applications d'entreprise"
echo "===================================================="
echo "Appareil : $(scutil --get ComputerName)"
echo "Date : $(date)"
echo ""

for app_name in "${!enterprise_apps[@]}"; do
    app_path="${enterprise_apps[$app_name]}"
    
    if [ -d "$app_path" ]; then
        version=$(mdls -name kMDItemVersion "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        
        if [ -n "$version" ]; then
            echo "✅ $app_name : $version"
            echo "   Bundle ID : $bundle_id"
        else
            echo "⚠️  $app_name : Installé mais version non disponible"
        fi
    else
        echo "❌ $app_name : Non installé"
    fi
done

# Vérifier les applications de sécurité critiques
echo ""
echo "Applications de sécurité :"
echo "------------------------"
security_apps=("Antivirus One" "Malwarebytes" "CleanMyMac" "Little Snitch")

for app in "${security_apps[@]}"; do
    if [ -d "/Applications/${app}.app" ]; then
        version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        echo "✅ $app : ${version:-Version non disponible}"
    else
        echo "❌ $app : Non installé"
    fi
done

Scripts de déploiement à distance

Collecte de versions multi-appareils

#!/bin/bash

# Script pour collecter les versions d'applications de plusieurs appareils Mac
# Ce script doit être déployé sur chaque appareil et les résultats collectés centralement

CENTRAL_SERVER="your-macfleet-server.com"
DEVICE_ID=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')
REPORT_FILE="/tmp/device_app_report_${DEVICE_ID}.json"

# Créer un rapport JSON
create_json_report() {
    local device_name=$(scutil --get ComputerName)
    local device_user=$(whoami)
    local os_version=$(sw_vers -productVersion)
    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    
    cat > "$REPORT_FILE" << EOF
{
  "device_info": {
    "device_id": "$DEVICE_ID",
    "device_name": "$device_name",
    "user": "$device_user",
    "os_version": "$os_version",
    "timestamp": "$timestamp"
  },
  "applications": [
EOF

    local first_app=true
    for app in /Applications/*.app; do
        if [ -d "$app" ]; then
            local app_name=$(basename "$app" .app)
            local version=$(mdls -name kMDItemVersion "$app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
            local bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
            
            if [ -n "$version" ]; then
                if [ "$first_app" = false ]; then
                    echo "," >> "$REPORT_FILE"
                fi
                
                cat >> "$REPORT_FILE" << EOF
    {
      "name": "$app_name",
      "version": "$version",
      "bundle_id": "$bundle_id",
      "path": "$app"
    }EOF
                first_app=false
            fi
        fi
    done
    
    echo "" >> "$REPORT_FILE"
    echo "  ]" >> "$REPORT_FILE"
    echo "}" >> "$REPORT_FILE"
}

# Créer le rapport
create_json_report

# Afficher les résultats locaux
echo "Rapport des versions d'applications créé : $REPORT_FILE"
echo "ID de l'appareil : $DEVICE_ID"
echo "Total d'applications : $(grep -c '"name":' "$REPORT_FILE")"

# Optionnel : Envoyer au serveur central (décommentez si nécessaire)
# curl -X POST -H "Content-Type: application/json" -d @"$REPORT_FILE" "https://$CENTRAL_SERVER/api/device-reports"

Surveillance automatisée des versions

#!/bin/bash

# Surveillance automatisée des versions d'applications avec alertes
ALERT_THRESHOLD_DAYS=30
LOG_FILE="/var/log/macfleet_app_monitor.log"
ALERT_FILE="/tmp/app_version_alerts.txt"

# Fonction pour enregistrer les messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Fonction pour vérifier si l'application nécessite une mise à jour
check_app_age() {
    local app_path="$1"
    local app_name=$(basename "$app_path" .app)
    local modified_date=$(stat -f "%Sm" -t "%Y-%m-%d" "$app_path" 2>/dev/null)
    
    if [ -n "$modified_date" ]; then
        local days_old=$(( ($(date +%s) - $(date -j -f "%Y-%m-%d" "$modified_date" +%s)) / 86400 ))
        
        if [ $days_old -gt $ALERT_THRESHOLD_DAYS ]; then
            echo "⚠️  $app_name : Dernière modification il y a $days_old jours ($modified_date)" >> "$ALERT_FILE"
            log_message "ALERTE : $app_name a $days_old jours"
        fi
    fi
}

# Initialiser le fichier d'alertes
echo "Alertes d'âge des applications MacFleet" > "$ALERT_FILE"
echo "=======================================" >> "$ALERT_FILE"
echo "Généré : $(date)" >> "$ALERT_FILE"
echo "Seuil : $ALERT_THRESHOLD_DAYS jours" >> "$ALERT_FILE"
echo "" >> "$ALERT_FILE"

log_message "Début de la surveillance des versions d'applications"

# Vérifier les applications critiques
critical_apps=("Safari" "Mail" "Calendar" "Microsoft Word" "Microsoft Excel" "Google Chrome" "Slack" "Zoom")

for app in "${critical_apps[@]}"; do
    if [ -d "/Applications/${app}.app" ]; then
        check_app_age "/Applications/${app}.app"
        
        version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        log_message "Vérifié $app : Version $version"
    else
        log_message "AVERTISSEMENT : $app non trouvé"
    fi
done

# Afficher les alertes s'il y en a
if [ -s "$ALERT_FILE" ] && [ $(wc -l < "$ALERT_FILE") -gt 4 ]; then
    echo "⚠️  Alertes d'âge des applications trouvées :"
    cat "$ALERT_FILE"
    
    # Optionnel : Envoyer les alertes par email ou service de notification
    # mail -s "Alertes de versions d'applications MacFleet - $(hostname)" admin@votreentreprise.com < "$ALERT_FILE"
fi

log_message "Surveillance des versions d'applications terminée"

Meilleures pratiques pour la gestion de flotte Mac

1. Surveillance régulière

  • Planifier les vérifications de versions hebdomadaires ou bihebdomadaires
  • Surveiller les applications métier critiques plus fréquemment
  • Suivre les applications installées système et utilisateur

2. Standardisation des versions

  • Maintenir des listes de versions d'applications approuvées
  • Créer des politiques pour les mises à jour automatiques
  • Documenter les exigences de compatibilité des versions

3. Considérations de sécurité

  • Prioriser les mises à jour de sécurité pour toutes les applications
  • Surveiller les applications avec des vulnérabilités connues
  • Implémenter des flux d'approbation pour les mises à jour majeures

4. Reporting et analytique

  • Générer des rapports de conformité réguliers
  • Suivre les taux de succès de déploiement des mises à jour
  • Surveiller les modèles d'utilisation des applications

5. Intégration d'automatisation

  • Intégrer avec les outils de gestion de configuration
  • Automatiser les vérifications de versions de routine
  • Configurer des alertes pour les divergences de versions

Résolution des problèmes courants

Problème : Commande mdls introuvable

# Vérifier la disponibilité de la commande
which mdls
# Si non trouvé, vérifier l'intégrité du système
sudo /usr/bin/mdutil -i on /

Problème : Permission refusée

# Exécuter avec les permissions appropriées
sudo -u [nomutilisateur] mdls -name kMDItemVersion "/Applications/NomApp.app"

Problème : Informations de version non disponibles

# Essayer des méthodes alternatives
defaults read "/Applications/NomApp.app/Contents/Info.plist" CFBundleShortVersionString
plutil -p "/Applications/NomApp.app/Contents/Info.plist" | grep -i version

Problème : Applications dans des emplacements non standard

# Rechercher les applications dans tout le système
find /Applications /Users/*/Applications -name "*.app" -type d 2>/dev/null

Conclusion

Le suivi des versions d'applications est essentiel pour maintenir une flotte Mac sécurisée et conforme. Ces scripts fournissent une base pour :

  • La découverte automatisée des versions et le reporting
  • La surveillance de la conformité et les alertes
  • L'évaluation des vulnérabilités de sécurité
  • La gestion des ressources logicielles

L'implémentation régulière de ces pratiques de surveillance aidera à s'assurer que votre flotte Mac reste sécurisée, conforme et correctement gérée.

Pour des capacités de gestion de flotte Mac plus avancées, envisagez d'intégrer ces scripts avec vos outils existants de gestion de configuration et de surveillance.

Obtenir le Chemin d'Application sur macOS

Apprenez à trouver et récupérer les chemins d'installation d'applications sur Mac à l'aide de scripts. Ceci est essentiel pour la gestion d'applications, le déploiement de scripts et la configuration de listes autorisées/bloquées.

Trouveur de Chemin d'App Basique

Trouvez le chemin d'une application en utilisant son identifiant de bundle :

#!/bin/bash

# Spécifier l'ID de bundle
BUNDLE_ID="com.apple.Safari"

# Trouver le chemin d'app avec mdfind
APP_PATH=$(mdfind "kMDItemCFBundleIdentifier=='${BUNDLE_ID}'")

if [[ -n "$APP_PATH" ]]; then
    echo "Chemin d'application : $APP_PATH"
else
    echo "Application non trouvée : $BUNDLE_ID"
fi

Découverte de Chemin Avancée

Script avec validation et méthodes de recherche multiples :

#!/bin/bash

# Fonction pour trouver le chemin d'app
find_app_path() {
    local bundle_id="$1"
    
    # Méthode 1 : Utiliser mdfind avec identifiant de bundle
    local app_path=$(mdfind "kMDItemCFBundleIdentifier=='${bundle_id}'" | head -1)
    
    if [[ -n "$app_path" && -d "$app_path" ]]; then
        echo "$app_path"
        return 0
    fi
    
    # Méthode 2 : Rechercher dans répertoires communs
    local common_paths=(
        "/Applications"
        "/System/Applications"
        "/Applications/Utilities"
        "/System/Library/CoreServices"
    )
    
    for path in "${common_paths[@]}"; do
        if [[ -d "$path" ]]; then
            local found=$(find "$path" -name "*.app" -maxdepth 2 -exec defaults read {}/Contents/Info.plist CFBundleIdentifier \; -print 2>/dev/null | grep -B1 "^${bundle_id}$" | grep "\.app$")
            if [[ -n "$found" ]]; then
                echo "$found"
                return 0
            fi
        fi
    done
    
    return 1
}

# Exemple d'utilisation
BUNDLE_ID="${1:-com.apple.Safari}"

echo "Recherche de l'application : $BUNDLE_ID"

if APP_PATH=$(find_app_path "$BUNDLE_ID"); then
    echo "Application trouvée à : $APP_PATH"
    
    # Obtenir infos supplémentaires
    APP_NAME=$(defaults read "$APP_PATH/Contents/Info.plist" CFBundleName 2>/dev/null)
    APP_VERSION=$(defaults read "$APP_PATH/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
    
    echo "Nom d'application : ${APP_NAME:-Inconnu}"
    echo "Version : ${APP_VERSION:-Inconnue}"
else
    echo "Application non trouvée : $BUNDLE_ID"
    exit 1
fi

Trouveur de Chemins Multiples

Trouvez les chemins de plusieurs applications à la fois :

#!/bin/bash

# Tableau d'IDs de bundle à rechercher
BUNDLE_IDS=(
    "com.apple.Safari"
    "com.apple.finder"
    "com.apple.systempreferences"
    "com.microsoft.Excel"
    "com.adobe.Photoshop"
)

# Fonction pour trouver le chemin d'app
find_app_path() {
    local bundle_id="$1"
    mdfind "kMDItemCFBundleIdentifier=='${bundle_id}'" | head -1
}

echo "=== Rapport Chemins d'Applications ==="
echo "Généré : $(date)"
echo "Appareil : $(hostname)"
echo "======================================="

for bundle_id in "${BUNDLE_IDS[@]}"; do
    echo "Recherche : $bundle_id"
    
    app_path=$(find_app_path "$bundle_id")
    
    if [[ -n "$app_path" && -d "$app_path" ]]; then
        echo "  ✓ Trouvée : $app_path"
        
        # Obtenir version d'app si disponible
        version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
        if [[ -n "$version" ]]; then
            echo "  📦 Version : $version"
        fi
    else
        echo "  ✗ Non trouvée"
    fi
    echo
done

Découverte d'ID de Bundle

Trouvez les IDs de bundle des applications installées :

#!/bin/bash

echo "=== IDs de Bundle Applications Installées ==="

# Rechercher dans répertoires d'applications communs
SEARCH_PATHS=(
    "/Applications"
    "/System/Applications"
    "/Applications/Utilities"
)

for search_path in "${SEARCH_PATHS[@]}"; do
    if [[ -d "$search_path" ]]; then
        echo "Scan : $search_path"
        
        find "$search_path" -name "*.app" -maxdepth 2 | while read app_path; do
            app_name=$(basename "$app_path" .app)
            bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null)
            
            if [[ -n "$bundle_id" ]]; then
                echo "  $app_name -> $bundle_id"
            fi
        done
        echo
    fi
done

Utilisation avec MacFleet

  1. Modifiez la variable BUNDLE_ID avec votre application cible
  2. Pour plusieurs apps, mettez à jour le tableau BUNDLE_IDS
  3. Déployez via l'exécution de script distant MacFleet
  4. Consultez les résultats dans l'historique des actions

IDs de Bundle Communs

ApplicationID de Bundle
Safaricom.apple.Safari
Findercom.apple.finder
Préférences Systèmecom.apple.systempreferences
Microsoft Wordcom.microsoft.Word
Google Chromecom.google.Chrome
Firefoxorg.mozilla.firefox
Slackcom.tinyspeck.slackmacgap
Zoomus.zoom.xos

Dépannage

Aucun résultat trouvé : Vérifiez que l'ID de bundle est correct et l'application installée Plusieurs chemins retournés : Utilisez head -1 pour obtenir le premier résultat ou filtrez par emplacement spécifique Permission refusée : Assurez-vous que le script a les permissions d'accès système de fichiers nécessaires


Note : Les IDs de bundle sont sensibles à la casse. Utilisez le format exact fourni par le développeur de l'application.

Surveillance d'Applications Premier Plan d'Entreprise sur macOS

Surveillez et gérez les applications au premier plan sur vos appareils MacFleet en utilisant AppleScript avancé et des outils de surveillance système. Ce tutoriel couvre le suivi d'applications, l'analyse de productivité, la surveillance de sécurité et la gestion du cycle de vie des applications d'entreprise.

Comprendre la Surveillance d'Applications macOS

macOS fournit plusieurs méthodes pour la surveillance et la gestion d'applications :

  • AppleScript - Langage d'automatisation pour le contrôle et la surveillance d'applications
  • Événements Système - Informations sur les processus et applications au niveau système
  • Moniteur d'Activité - Surveillance en temps réel des applications et ressources
  • Intégration Finder - Gestion de la visibilité et de l'état des applications

Détection d'Applications Premier Plan de Base

Liste d'Applications Simple

#!/bin/bash

# Script de base pour récupérer les applications au premier plan
osascript <<EOF
tell application "Finder"
    set visibleProcesses to name of every process whose visible is true
    return visibleProcesses
end tell
EOF

echo "Applications au premier plan récupérées avec succès"

Informations d'Applications Améliorées

#!/bin/bash

# Surveillance d'applications au premier plan améliorée avec informations détaillées
get_foreground_applications() {
    osascript <<EOF
tell application "System Events"
    set foregroundApps to {}
    set visibleProcesses to every process whose visible is true
    
    repeat with aProcess in visibleProcesses
        set appName to name of aProcess
        set appPID to unix id of aProcess
        try
            set appPath to POSIX path of (file of aProcess as alias)
        on error
            set appPath to "N/A"
        end try
        
        set appInfo to appName & "|" & appPID & "|" & appPath
        set foregroundApps to foregroundApps & {appInfo}
    end repeat
    
    return foregroundApps
end tell
EOF
}

# Exécuter et formater la sortie
echo "=== Applications au Premier Plan ==="
get_foreground_applications | tr ',' '\n' | while read -r app_info; do
    if [[ -n "$app_info" ]]; then
        IFS='|' read -r name pid path <<< "$app_info"
        echo "Application : $name"
        echo "  PID : $pid"
        echo "  Chemin : $path"
        echo ""
    fi
done

Catégories de Surveillance d'Applications

Classifications de Types d'Applications

#!/bin/bash

# Catégories d'applications d'entreprise pour surveillance et application de politiques
declare -A APPLICATION_CATEGORIES=(
    ["apps_productivite"]="Suites bureautiques, éditeurs de documents, outils de gestion de projet"
    ["outils_developpement"]="IDE, éditeurs de code, environnements de développement, contrôle de version"
    ["apps_communication"]="Clients email, messagerie, visioconférence, collaboration"
    ["logiciels_creatifs"]="Outils de design, édition média, applications créatives"
    ["applications_navigateur"]="Navigateurs web, applications basées internet"
    ["utilitaires_systeme"]="Outils système, applications maintenance, logiciels sécurité"
    ["media_divertissement"]="Jeux, streaming, réseaux sociaux, plateformes divertissement"
    ["logiciels_financiers"]="Comptabilité, finance, banque, applications paiement"
    ["outils_securite"]="Antivirus, VPN, surveillance sécurité, outils chiffrement"
    ["apps_non_autorisees"]="Applications non approuvées, potentiellement dangereuses ou restreintes"
)

# Niveaux de risque des applications
declare -A RISK_LEVELS=(
    ["apps_productivite"]="faible"
    ["outils_developpement"]="moyen"
    ["apps_communication"]="faible"
    ["logiciels_creatifs"]="moyen"
    ["applications_navigateur"]="moyen"
    ["utilitaires_systeme"]="eleve"
    ["media_divertissement"]="eleve"
    ["logiciels_financiers"]="moyen"
    ["outils_securite"]="faible"
    ["apps_non_autorisees"]="critique"
)

# Classifications d'impact business
declare -A BUSINESS_IMPACT=(
    ["apps_productivite"]="eleve_positif"
    ["outils_developpement"]="eleve_positif"
    ["apps_communication"]="eleve_positif"
    ["logiciels_creatifs"]="moyen_positif"
    ["applications_navigateur"]="moyen_neutre"
    ["utilitaires_systeme"]="moyen_positif"
    ["media_divertissement"]="eleve_negatif"
    ["logiciels_financiers"]="eleve_positif"
    ["outils_securite"]="eleve_positif"
    ["apps_non_autorisees"]="eleve_negatif"
)

print_application_categories() {
    echo "=== Catégories de Surveillance d'Applications ==="
    for category in "${!APPLICATION_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${APPLICATION_CATEGORIES[$category]}"
        echo "  Niveau de Risque : ${RISK_LEVELS[$category]}"
        echo "  Impact Business : ${BUSINESS_IMPACT[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_application_categories

Système de Gestion d'Applications d'Entreprise

#!/bin/bash

# Système de Surveillance d'Applications d'Entreprise MacFleet
# Surveillance et gestion complètes d'applications au premier plan

# Configuration
CONFIG_DIR="/etc/macfleet/surveillance_applications"
LOG_FILE="/var/log/macfleet_surveillance_apps.log"
DATA_DIR="/var/data/macfleet/applications"
REPORTS_DIR="/var/reports/macfleet/applications"
AUDIT_LOG="/var/log/macfleet_audit_apps.log"
ALERTS_DIR="/var/alerts/macfleet/applications"

# Créer les répertoires requis
create_directories() {
    local directories=("$CONFIG_DIR" "$DATA_DIR" "$REPORTS_DIR" "$ALERTS_DIR")
    
    for dir in "${directories[@]}"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            sudo chmod 755 "$dir"
        fi
    done
}

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

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [ERREUR] $1" | tee -a "$LOG_FILE" >&2
}

audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}

# Gestion de base de données d'applications
initialize_app_database() {
    local db_file="$DATA_DIR/base_donnees_applications.json"
    
    if [[ ! -f "$db_file" ]]; then
        cat > "$db_file" << EOF
{
    "version": "1.0",
    "cree": "$(date -Iseconds)",
    "applications": {},
    "sessions_surveillance": {},
    "metriques_productivite": {},
    "evenements_securite": {}
}
EOF
        log_action "Base de données d'applications initialisée : $db_file"
    fi
}

# Détection d'applications avancée
get_comprehensive_app_info() {
    local output_file="$1"
    local timestamp="$(date -Iseconds)"
    
    # Obtenir les applications au premier plan avec informations détaillées
    osascript <<EOF > "$output_file"
tell application "System Events"
    set appList to {}
    set visibleProcesses to every process whose visible is true
    
    repeat with aProcess in visibleProcesses
        try
            set appName to name of aProcess
            set appPID to unix id of aProcess
            set appMemory to ""
            set appCPU to ""
            set appPath to ""
            set appBundle to ""
            set appVersion to ""
            
            try
                set appPath to POSIX path of (file of aProcess as alias)
            end try
            
            try
                tell application "Finder"
                    set appFile to POSIX file appPath as alias
                    set appBundle to id of (info for appFile)
                    set appVersion to version of (info for appFile)
                end tell
            end try
            
            set appInfo to "{"
            set appInfo to appInfo & "\\"nom\\": \\"" & appName & "\\", "
            set appInfo to appInfo & "\\"pid\\": " & appPID & ", "
            set appInfo to appInfo & "\\"chemin\\": \\"" & appPath & "\\", "
            set appInfo to appInfo & "\\"bundle_id\\": \\"" & appBundle & "\\", "
            set appInfo to appInfo & "\\"version\\": \\"" & appVersion & "\\", "
            set appInfo to appInfo & "\\"horodatage\\": \\"$timestamp\\""
            set appInfo to appInfo & "}"
            
            set appList to appList & {appInfo}
        end try
    end repeat
    
    set AppleScript's text item delimiters to ","
    set result to "[" & (appList as string) & "]"
    set AppleScript's text item delimiters to ""
    
    return result
end tell
EOF
}

# Catégorisation d'applications et évaluation des risques
categorize_application() {
    local app_name="$1"
    local app_path="$2"
    local app_bundle="$3"
    
    # Logique de catégorisation d'applications
    case "$app_name" in
        *"Safari"*|*"Chrome"*|*"Firefox"*|*"Edge"*)
            echo "applications_navigateur"
            ;;
        *"Office"*|*"Word"*|*"Excel"*|*"PowerPoint"*|*"Pages"*|*"Numbers"*|*"Keynote"*)
            echo "apps_productivite"
            ;;
        *"Xcode"*|*"Visual Studio"*|*"IntelliJ"*|*"Eclipse"*|*"Sublime"*|*"Atom"*)
            echo "outils_developpement"
            ;;
        *"Photoshop"*|*"Illustrator"*|*"Final Cut"*|*"Logic"*|*"Sketch"*|*"Figma"*)
            echo "logiciels_creatifs"
            ;;
        *"Slack"*|*"Teams"*|*"Zoom"*|*"Skype"*|*"Mail"*|*"Messages"*)
            echo "apps_communication"
            ;;
        *"iTunes"*|*"Spotify"*|*"Netflix"*|*"YouTube"*|*"Game"*|*"Steam"*)
            echo "media_divertissement"
            ;;
        *"Finder"*|*"Terminal"*|*"Activity Monitor"*|*"System Preferences"*)
            echo "utilitaires_systeme"
            ;;
        *)
            # Vérifier l'ID bundle pour une meilleure catégorisation
            case "$app_bundle" in
                com.apple.*)
                    echo "utilitaires_systeme"
                    ;;
                com.microsoft.*)
                    echo "apps_productivite"
                    ;;
                com.adobe.*)
                    echo "logiciels_creatifs"
                    ;;
                *)
                    echo "application_inconnue"
                    ;;
            esac
            ;;
    esac
}

# Détection de menaces de sécurité
detect_security_threats() {
    local app_data="$1"
    local threats_file="$ALERTS_DIR/menaces_securite_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Détection de Menaces de Sécurité ==="
    echo "Analyse des applications pour détecter les menaces de sécurité..."
    
    # Modèles d'applications malveillantes connues
    local malicious_patterns=(
        "keylogger"
        "spyware"
        "adware"
        "trojan"
        "backdoor"
        "cryptominer"
        "ransomware"
    )
    
    # Détection d'applications non autorisées
    local unauthorized_apps=()
    local suspicious_apps=()
    
    # Analyser les données d'applications et vérifier les menaces
    while IFS= read -r app_line; do
        if [[ -n "$app_line" ]]; then
            local app_name=$(echo "$app_line" | jq -r '.nom' 2>/dev/null)
            local app_path=$(echo "$app_line" | jq -r '.chemin' 2>/dev/null)
            
            # Vérifier contre les modèles malveillants
            for pattern in "${malicious_patterns[@]}"; do
                if [[ "$app_name" =~ $pattern ]] || [[ "$app_path" =~ $pattern ]]; then
                    suspicious_apps+=("$app_name:$pattern")
                    audit_log "Application suspecte détectée : $app_name (modèle : $pattern)"
                fi
            done
            
            # Vérifier les applications dans des emplacements non autorisés
            if [[ "$app_path" =~ /tmp/ ]] || [[ "$app_path" =~ /var/tmp/ ]] || [[ "$app_path" =~ /Downloads/ ]]; then
                unauthorized_apps+=("$app_name:$app_path")
                audit_log "Application dans emplacement non autorisé : $app_name (chemin : $app_path)"
            fi
        fi
    done <<< "$(echo "$app_data" | jq -c '.[]' 2>/dev/null)"
    
    # Générer le rapport de menaces
    local threat_report=$(cat << EOF
{
    "horodatage_analyse": "$(date -Iseconds)",
    "nom_hote": "$(hostname)",
    "applications_suspectes": $(printf '%s\n' "${suspicious_apps[@]}" | jq -R . | jq -s .),
    "applications_non_autorisees": $(printf '%s\n' "${unauthorized_apps[@]}" | jq -R . | jq -s .),
    "niveau_menace": "$([ ${#suspicious_apps[@]} -gt 0 ] && echo "eleve" || echo "faible")",
    "recommandations": {
        "action_immediate": $([ ${#suspicious_apps[@]} -gt 0 ] && echo "true" || echo "false"),
        "quarantaine_requise": $([ ${#suspicious_apps[@]} -gt 2 ] && echo "true" || echo "false"),
        "analyse_securite": "recommandee"
    }
}
EOF
)
    
    echo "$threat_report" > "$threats_file"
    
    if [[ ${#suspicious_apps[@]} -gt 0 ]] || [[ ${#unauthorized_apps[@]} -gt 0 ]]; then
        echo "⚠️  Menaces de sécurité détectées !"
        echo "  Applications suspectes : ${#suspicious_apps[@]}"
        echo "  Applications non autorisées : ${#unauthorized_apps[@]}"
        echo "  Rapport de menaces : $threats_file"
        
        # Envoyer une alerte immédiate si des menaces à haut risque sont trouvées
        if [[ ${#suspicious_apps[@]} -gt 0 ]]; then
            send_security_alert "$threats_file"
        fi
    else
        echo "✅ Aucune menace de sécurité détectée"
    fi
}

# Analyse de productivité
analyze_productivity() {
    local app_data="$1"
    local analysis_file="$REPORTS_DIR/analyse_productivite_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Analyse de Productivité ==="
    
    # Catégoriser les applications par impact productivité
    local productive_apps=0
    local neutral_apps=0
    local distracting_apps=0
    local total_apps=0
    
    declare -A category_counts
    
    while IFS= read -r app_line; do
        if [[ -n "$app_line" ]]; then
            local app_name=$(echo "$app_line" | jq -r '.nom' 2>/dev/null)
            local category=$(categorize_application "$app_name" "" "")
            
            ((total_apps++))
            ((category_counts["$category"]++))
            
            case "$category" in
                "apps_productivite"|"outils_developpement"|"apps_communication")
                    ((productive_apps++))
                    ;;
                "utilitaires_systeme"|"logiciels_creatifs")
                    ((neutral_apps++))
                    ;;
                "media_divertissement"|"application_inconnue")
                    ((distracting_apps++))
                    ;;
            esac
        fi
    done <<< "$(echo "$app_data" | jq -c '.[]' 2>/dev/null)"
    
    # Calculer le score de productivité (0-100)
    local productivity_score=0
    if [[ $total_apps -gt 0 ]]; then
        productivity_score=$(( (productive_apps * 100 + neutral_apps * 50) / total_apps ))
    fi
    
    # Générer le rapport de productivité
    local productivity_report=$(cat << EOF
{
    "horodatage_analyse": "$(date -Iseconds)",
    "nom_hote": "$(hostname)",
    "metriques_productivite": {
        "total_applications": $total_apps,
        "applications_productives": $productive_apps,
        "applications_neutres": $neutral_apps,
        "applications_distrayantes": $distracting_apps,
        "score_productivite": $productivity_score
    },
    "repartition_categories": $(for category in "${!category_counts[@]}"; do echo "\"$category\": ${category_counts[$category]}"; done | jq -s 'add'),
    "recommandations": {
        "niveau_productivite": "$([ $productivity_score -gt 80 ] && echo "excellent" || [ $productivity_score -gt 60 ] && echo "bon" || [ $productivity_score -gt 40 ] && echo "modere" || echo "necessite_amelioration")",
        "amelioration_focus": $([ $distracting_apps -gt 3 ] && echo "true" || echo "false"),
        "actions_suggerees": $([ $productivity_score -lt 50 ] && echo "[\"bloquer_apps_distrayantes\", \"formation_productivite\"]" || echo "[\"maintenir_habitudes_actuelles\"]")
    }
}
EOF
)
    
    echo "$productivity_report" > "$analysis_file"
    
    echo "Résultats d'Analyse de Productivité :"
    echo "  Total Applications : $total_apps"
    echo "  Productives : $productive_apps | Neutres : $neutral_apps | Distrayantes : $distracting_apps"
    echo "  Score Productivité : $productivity_score/100"
    echo "  Rapport d'Analyse : $analysis_file"
}

# Session de surveillance en temps réel
start_monitoring_session() {
    local profile="$1"
    local duration="${2:-3600}" # Défaut 1 heure
    local session_id="session_$(date +%Y%m%d_%H%M%S)"
    local session_file="$DATA_DIR/${session_id}.json"
    
    log_action "Démarrage session de surveillance : $session_id (Profil : $profile, Durée : ${duration}s)"
    
    # Initialiser les données de session
    cat > "$session_file" << EOF
{
    "id_session": "$session_id",
    "profil": "$profile",
    "heure_debut": "$(date -Iseconds)",
    "duree": $duration,
    "nom_hote": "$(hostname)",
    "donnees_surveillance": []
}
EOF
    
    local end_time=$(($(date +%s) + duration))
    local interval=30 # Surveiller toutes les 30 secondes
    
    echo "Session de surveillance démarrée : $session_id"
    echo "Durée : $duration secondes"
    echo "Profil : $profile"
    echo "Fichier de données : $session_file"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        local temp_file="/tmp/snapshot_app_$$.json"
        
        # Obtenir l'instantané d'application actuel
        get_comprehensive_app_info "$temp_file"
        
        if [[ -f "$temp_file" ]]; then
            local timestamp="$(date -Iseconds)"
            
            # Ajouter aux données de session
            local snapshot=$(cat "$temp_file" | sed 's/^/    /')
            
            # Mettre à jour le fichier de session avec le nouveau point de données
            jq --argjson snapshot "$(cat "$temp_file")" --arg timestamp "$timestamp" \
               '.donnees_surveillance += [{"horodatage": $timestamp, "applications": $snapshot}]' \
               "$session_file" > "${session_file}.tmp" && mv "${session_file}.tmp" "$session_file"
            
            rm -f "$temp_file"
            
            echo "$(date '+%H:%M:%S') - Instantané capturé ($(jq '.applications | length' <<< "$(cat "$temp_file")" 2>/dev/null || echo "0") apps)"
        fi
        
        sleep $interval
    done
    
    # Finaliser la session
    jq '.heure_fin = "'"$(date -Iseconds)"'" | .statut = "complete"' "$session_file" > "${session_file}.tmp" && mv "${session_file}.tmp" "$session_file"
    
    log_action "Session de surveillance terminée : $session_id"
    
    # Générer l'analyse de session
    analyze_monitoring_session "$session_file"
    
    echo "✅ Session de surveillance terminée : $session_id"
    echo "Données de session : $session_file"
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    # Initialiser
    create_directories
    initialize_app_database
    
    case "$command" in
        "surveiller")
            # Surveillance de base une fois
            local temp_file="/tmp/apps_actuelles.json"
            get_comprehensive_app_info "$temp_file"
            if [[ -f "$temp_file" ]]; then
                echo "=== Applications Actuelles au Premier Plan ==="
                jq -r '.[] | "Application : \(.nom) | PID : \(.pid) | Chemin : \(.chemin)"' "$temp_file"
                rm -f "$temp_file"
            fi
            ;;
        "demarrer_surveillance")
            start_monitoring_session "$@"
            ;;
        "analyse_securite")
            local temp_file="/tmp/analyse_securite.json"
            get_comprehensive_app_info "$temp_file"
            if [[ -f "$temp_file" ]]; then
                detect_security_threats "$(cat "$temp_file")"
                rm -f "$temp_file"
            fi
            ;;
        "analyse_productivite")
            local temp_file="/tmp/analyse_productivite.json"
            get_comprehensive_app_info "$temp_file"
            if [[ -f "$temp_file" ]]; then
                analyze_productivity "$(cat "$temp_file")"
                rm -f "$temp_file"
            fi
            ;;
        "afficher_categories")
            print_application_categories
            ;;
        *)
            echo "Système de Surveillance d'Applications d'Entreprise MacFleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  surveiller                                    - Obtenir applications actuelles au premier plan"
            echo "  demarrer_surveillance <profil> [duree]       - Démarrer session de surveillance"
            echo "  analyse_securite                             - Analyser les menaces de sécurité"
            echo "  analyse_productivite                         - Analyser les métriques de productivité"
            echo "  afficher_categories                          - Afficher les catégories d'applications"
            echo ""
            echo "Exemples :"
            echo "  $0 surveiller"
            echo "  $0 demarrer_surveillance focus_productivite 3600"
            echo "  $0 analyse_securite"
            echo "  $0 analyse_productivite"
            ;;
    esac
}

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

Configuration de Déploiement en Flotte

Exemple de Configuration de Flotte

{
    "nom_flotte": "Réseau d'Entreprise MacFleet",
    "date_deploiement": "2025-07-07",
    "hotes": [
        "mac-dev-01.entreprise.com",
        "mac-design-01.entreprise.com", 
        "mac-exec-01.entreprise.com",
        "mac-support-01.entreprise.com"
    ],
    "planning_surveillance": {
        "heures_bureau": "09:00-18:00",
        "fuseau_horaire": "UTC+1",
        "jours_semaine_seulement": true
    },
    "parametres_globaux": {
        "retention_donnees": "90_jours",
        "frequence_rapport": "quotidienne",
        "escalade_alerte": true
    }
}

Exemple de Session de Surveillance

# Démarrer session surveillance productivité de 2 heures
./macfleet_monitor.sh demarrer_surveillance focus_productivite 7200

# Analyse de sécurité des applications actuelles
./macfleet_monitor.sh analyse_securite

# Analyse de productivité
./macfleet_monitor.sh analyse_productivite

# Générer rapport quotidien de productivité
./macfleet_monitor.sh generer_rapport resume_quotidien

Considérations de Sécurité

Sécurité des Applications

  • Détection de Menaces - Analyse en temps réel pour applications malveillantes
  • Blocage d'Apps Non Autorisées - Empêcher l'exécution de logiciels non approuvés
  • Analyse Comportementale - Surveiller les modèles d'utilisation d'applications pour anomalies
  • Prévention de Perte de Données - Suivre les applications avec capacités d'accès aux données
  • Vérification de Chiffrement - S'assurer que les applications sensibles utilisent un chiffrement approprié

Protection de la Vie Privée

  • Capture d'Écran Configurable - Respecter la vie privée des utilisateurs selon les politiques
  • Confidentialité des Applications Personnelles - Surveillance séparée pour apps personnelles vs professionnelles
  • Anonymisation des Données - Retirer les informations personnellement identifiables des rapports
  • Gestion du Consentement - Consentement utilisateur clair pour les activités de surveillance

Cadre de Conformité

Conformité Réglementaire

  • Conformité SOX - Surveillance et contrôles d'applications financières
  • Conformité HIPAA - Sécurité des applications de santé et suivi d'accès
  • Conformité RGPD - Conformité protection des données et vie privée
  • PCI DSS - Surveillance de sécurité des applications de paiement
  • Cadre NIST - Implémentation du cadre de cybersécurité

Exigences d'Audit

  • Journalisation Complète - Toutes les activités d'applications suivies et journalisées
  • Politiques de Rétention de Données - Rétention configurable selon les besoins de conformité
  • Contrôles d'Accès - Accès basé sur les rôles aux données et rapports de surveillance
  • Chaîne de Custody - Gestion sécurisée des données de surveillance et preuves

Guide de Dépannage

Problèmes Courants

Erreurs de Permission AppleScript

  • Accorder permissions à macfleetagentd pour accès Finder et Événements Système
  • Vérifier Préférences Système > Sécurité et Confidentialité > Confidentialité > Automatisation
  • Vérifier que le profil MDM autorise l'accès automatisation

Données d'Application Incomplètes

  • Certaines applications peuvent ne pas rapporter toutes les informations
  • Les applications système peuvent avoir des métadonnées limitées
  • Les applications en bac à sable peuvent restreindre l'accès à certaines propriétés

Impact sur les Performances

  • La surveillance continue peut affecter les performances système
  • Ajuster la fréquence de surveillance selon les capacités système
  • Surveiller les ressources système pendant les sessions de surveillance étendues

Commandes de Diagnostic

# Tester l'exécution AppleScript
osascript -e 'tell application "System Events" to get name of every process whose visible is true'

# Vérifier les permissions
sqlite3 ~/Library/Application\ Support/com.apple.TCC/TCC.db "SELECT client,service,auth_value FROM access WHERE service='kTCCServiceAppleEvents';"

# Surveiller les ressources système
top -l 1 -s 0 | grep "CPU usage"

Notes Importantes

  • Vie Privée Utilisateur - Respecter la vie privée des utilisateurs et obtenir consentement approprié pour surveillance
  • Impact Performance - Surveiller les performances système pendant sessions de surveillance étendues
  • Sécurité des Données - Chiffrer et sécuriser toutes les données et rapports de surveillance
  • Exigences de Conformité - S'assurer que les pratiques de surveillance respectent les exigences réglementaires
  • Mises à Jour Régulières - Maintenir à jour les signatures d'applications et modèles de détection de menaces
  • Documentation - Maintenir des enregistrements détaillés des politiques et procédures de surveillance

Gestion d'Entreprise des Polices sur macOS

Gérez et déployez des polices sur vos appareils MacFleet en utilisant des outils de ligne de commande avancés et des méthodes de distribution centralisées. Ce tutoriel couvre l'installation de polices, la standardisation typographique, la conformité des licences et la gestion de polices de niveau entreprise avec des capacités complètes de surveillance et de rapport.

Comprendre la Gestion des Polices macOS

macOS fournit plusieurs emplacements et méthodes pour la gestion des polices :

  • ~/Library/Fonts/ - Polices spécifiques à l'utilisateur (utilisateur actuel uniquement)
  • /Library/Fonts/ - Polices système (tous les utilisateurs)
  • /Library/User Template/Non_localized/Library/Fonts/ - Modèle pour nouveaux utilisateurs
  • Font Book - Application native macOS de gestion des polices
  • Formats de polices : TTF (TrueType), OTF (OpenType), WOFF, et formats hérités

La gestion d'entreprise des polices nécessite une attention particulière aux licences, à la standardisation et aux stratégies de déploiement.

Commandes d'Installation de Base des Polices

Installer une Police pour l'Utilisateur Actuel

#!/bin/bash

# Installer une police pour l'utilisateur actuel uniquement
install_user_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_user_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Copier la police vers le répertoire de polices de l'utilisateur
    cp -R "$font_path/$font_name" ~/Library/Fonts/
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' installée pour l'utilisateur actuel"
        return 0
    else
        echo "❌ Échec de l'installation de la police '$font_name'"
        return 1
    fi
}

# Exemple d'utilisation
# install_user_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Installer une Police pour Tout le Système

#!/bin/bash

# Installer une police pour tous les utilisateurs (nécessite des privilèges admin)
install_system_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_system_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Vérifier les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "❌ Privilèges administrateur requis pour l'installation système"
        return 1
    fi
    
    # Copier la police vers le répertoire de polices système
    cp -R "$font_path/$font_name" /Library/Fonts/
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' installée sur tout le système"
        
        # Vider le cache des polices pour assurer la disponibilité immédiate
        atsutil databases -remove
        atsutil server -shutdown
        atsutil server -ping
        
        return 0
    else
        echo "❌ Échec de l'installation système de la police '$font_name'"
        return 1
    fi
}

# Exemple d'utilisation (exécuter avec sudo)
# install_system_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Installer une Police pour le Modèle Nouvel Utilisateur

#!/bin/bash

# Installer une police dans le modèle utilisateur (affecte uniquement les nouveaux utilisateurs)
install_template_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_template_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Vérifier les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "❌ Privilèges administrateur requis pour modifier le modèle utilisateur"
        return 1
    fi
    
    # Créer le répertoire de polices du modèle s'il n'existe pas
    mkdir -p "/Library/User Template/Non_localized/Library/Fonts"
    
    # Copier la police vers le modèle utilisateur
    cp -R "$font_path/$font_name" "/Library/User Template/Non_localized/Library/Fonts/"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' ajoutée au modèle utilisateur"
        return 0
    else
        echo "❌ Échec de l'ajout de la police '$font_name' au modèle utilisateur"
        return 1
    fi
}

# Exemple d'utilisation (exécuter avec sudo)
# install_template_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Gestion Avancée des Polices

Validation et Informations des Polices

#!/bin/bash

# Valider et extraire les informations des polices
validate_font() {
    local font_file="$1"
    
    if [[ ! -f "$font_file" ]]; then
        echo "❌ Fichier de police non trouvé : $font_file"
        return 1
    fi
    
    echo "=== Rapport de Validation de Police ==="
    echo "Fichier Police : $font_file"
    echo "Taille Fichier : $(ls -lh "$font_file" | awk '{print $5}')"
    echo "Type Fichier : $(file "$font_file")"
    echo ""
    
    # Vérifier s'il s'agit d'un fichier de police valide
    local file_type
    file_type=$(file -b "$font_file")
    
    if echo "$file_type" | grep -qi "font\|truetype\|opentype"; then
        echo "✅ Fichier de police valide détecté"
        
        # Extraire les informations de police en utilisant fc-query si disponible
        if command -v fc-query >/dev/null 2>&1; then
            echo ""
            echo "Détails de la Police :"
            fc-query "$font_file" | grep -E "(family|style|weight|slant)" | head -10
        fi
        
        # Vérifier les problèmes potentiels
        local file_size
        file_size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file" 2>/dev/null)
        
        if [[ "$file_size" -gt 10485760 ]]; then  # 10MB
            echo "⚠️  Avertissement : Fichier de police volumineux (>10MB) - peut impacter les performances système"
        fi
        
        if [[ "$file_size" -lt 1024 ]]; then  # 1KB
            echo "⚠️  Avertissement : Fichier de police très petit (<1KB) - peut être corrompu"
        fi
        
        return 0
    else
        echo "❌ Format de fichier de police invalide"
        return 1
    fi
}

# Exemple d'utilisation
# validate_font "/Users/user1/Downloads/CROCHETPATTERN.ttf"

Découverte et Inventaire des Polices

#!/bin/bash

# Découvrir et inventorier les polices installées
discover_fonts() {
    echo "=== Rapport d'Inventaire des Polices ==="
    echo "Généré : $(date)"
    echo "Nom d'hôte : $(hostname)"
    echo "========================================="
    echo ""
    
    # Polices système
    echo "1. POLICES SYSTÈME (/Library/Fonts/) :"
    echo "--------------------------------------"
    if [[ -d "/Library/Fonts" ]]; then
        local sys_count
        sys_count=$(ls -1 /Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        echo "Total polices système : $sys_count"
        echo ""
        ls -la /Library/Fonts/ | head -10
        if [[ "$sys_count" -gt 10 ]]; then
            echo "... et $((sys_count - 10)) polices supplémentaires"
        fi
    else
        echo "Répertoire des polices système non trouvé"
    fi
    echo ""
    
    # Polices utilisateur (utilisateur actuel)
    echo "2. POLICES UTILISATEUR (~/Library/Fonts/) :"
    echo "-------------------------------------------"
    if [[ -d "$HOME/Library/Fonts" ]]; then
        local user_count
        user_count=$(ls -1 ~/Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        echo "Total polices utilisateur : $user_count"
        echo ""
        if [[ "$user_count" -gt 0 ]]; then
            ls -la ~/Library/Fonts/ | head -10
            if [[ "$user_count" -gt 10 ]]; then
                echo "... et $((user_count - 10)) polices supplémentaires"
            fi
        else
            echo "Aucune police spécifique à l'utilisateur installée"
        fi
    else
        echo "Répertoire des polices utilisateur non trouvé"
    fi
    echo ""
    
    # Analyse des formats de polices
    echo "3. ANALYSE DES FORMATS DE POLICES :"
    echo "-----------------------------------"
    local ttf_count otf_count other_count
    ttf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.ttf" 2>/dev/null | wc -l | tr -d ' ')
    otf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    other_count=$(find /Library/Fonts ~/Library/Fonts -type f ! -name "*.ttf" ! -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    
    echo "Polices TrueType (.ttf) : $ttf_count"
    echo "Polices OpenType (.otf) : $otf_count"
    echo "Autres formats : $other_count"
}

# Exécuter la découverte des polices
discover_fonts

Système de Gestion d'Entreprise des Polices

#!/bin/bash

# Système de Gestion d'Entreprise des Polices MacFleet
# Déploiement, gestion et surveillance de conformité complets des polices

# Configuration
LOG_FILE="/var/log/macfleet_font_management.log"
FONT_REPO_DIR="/var/lib/macfleet/fonts"
CONFIG_FILE="/etc/macfleet/font_config.conf"
BACKUP_DIR="/var/backups/macfleet/fonts"
STAGING_DIR="/tmp/macfleet_fonts"

# Créer la structure de répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$FONT_REPO_DIR" "$BACKUP_DIR" "$STAGING_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
    
    # Définir les permissions appropriées
    chmod 755 "$FONT_REPO_DIR" "$BACKUP_DIR" "$STAGING_DIR"
}

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

# Télécharger et valider une police depuis une URL
download_font() {
    local font_url="$1"
    local font_name="$2"
    local license_info="$3"
    
    if [[ -z "$font_url" || -z "$font_name" ]]; then
        log_action "ERREUR : URL et nom de police requis"
        return 1
    fi
    
    log_action "Téléchargement de la police : $font_name depuis $font_url"
    
    # Télécharger vers le répertoire de préparation
    local download_path="$STAGING_DIR/$font_name"
    
    if command -v curl >/dev/null 2>&1; then
        curl -L -o "$download_path" "$font_url"
    elif command -v wget >/dev/null 2>&1; then
        wget -O "$download_path" "$font_url"
    else
        log_action "ERREUR : Aucun outil de téléchargement disponible (curl ou wget requis)"
        return 1
    fi
    
    if [[ ! -f "$download_path" ]]; then
        log_action "ERREUR : Échec du téléchargement pour $font_name"
        return 1
    fi
    
    # Valider la police téléchargée
    if validate_font "$download_path" >/dev/null; then
        # Déplacer vers le dépôt de polices
        mv "$download_path" "$FONT_REPO_DIR/"
        
        # Créer un fichier de métadonnées
        cat > "$FONT_REPO_DIR/${font_name}.meta" <<EOF
{
    "font_name": "$font_name",
    "download_url": "$font_url",
    "download_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "license_info": "$license_info",
    "file_size": $(stat -f%z "$FONT_REPO_DIR/$font_name" 2>/dev/null || stat -c%s "$FONT_REPO_DIR/$font_name"),
    "checksum": "$(md5 -q "$FONT_REPO_DIR/$font_name" 2>/dev/null || md5sum "$FONT_REPO_DIR/$font_name" | cut -d' ' -f1)"
}
EOF
        
        log_action "✅ Police téléchargée et validée : $font_name"
        return 0
    else
        log_action "❌ Échec de validation de la police : $font_name"
        rm -f "$download_path"
        return 1
    fi
}

# Déployer une police sur la flotte avec options
deploy_font() {
    local font_name="$1"
    local deployment_scope="${2:-system}"  # user, system, template
    local force_install="${3:-false}"
    
    if [[ ! -f "$FONT_REPO_DIR/$font_name" ]]; then
        log_action "ERREUR : Police non trouvée dans le dépôt : $font_name"
        return 1
    fi
    
    log_action "Déploiement de la police : $font_name (portée : $deployment_scope)"
    
    # Créer une sauvegarde des polices existantes
    backup_fonts
    
    case "$deployment_scope" in
        "user")
            # Installer pour l'utilisateur actuel
            mkdir -p ~/Library/Fonts
            cp -R "$FONT_REPO_DIR/$font_name" ~/Library/Fonts/
            local result=$?
            ;;
        "system")
            # Installer sur tout le système (nécessite admin)
            if [[ $EUID -ne 0 ]]; then
                log_action "ERREUR : Privilèges administrateur requis pour le déploiement système"
                return 1
            fi
            cp -R "$FONT_REPO_DIR/$font_name" /Library/Fonts/
            local result=$?
            ;;
        "template")
            # Installer dans le modèle utilisateur
            if [[ $EUID -ne 0 ]]; then
                log_action "ERREUR : Privilèges administrateur requis pour le déploiement modèle"
                return 1
            fi
            mkdir -p "/Library/User Template/Non_localized/Library/Fonts"
            cp -R "$FONT_REPO_DIR/$font_name" "/Library/User Template/Non_localized/Library/Fonts/"
            local result=$?
            ;;
        *)
            log_action "ERREUR : Portée de déploiement invalide : $deployment_scope"
            return 1
            ;;
    esac
    
    if [[ $result -eq 0 ]]; then
        # Vider le cache des polices
        refresh_font_cache
        
        # Vérifier l'installation
        verify_font_installation "$font_name" "$deployment_scope"
        
        log_action "✅ Police déployée avec succès : $font_name"
        return 0
    else
        log_action "❌ Échec du déploiement de la police : $font_name"
        return 1
    fi
}

# Actualiser le cache des polices
refresh_font_cache() {
    log_action "Actualisation du cache des polices système..."
    
    # Vider le cache des polices macOS
    atsutil databases -remove 2>/dev/null
    atsutil server -shutdown 2>/dev/null
    sleep 2
    atsutil server -ping 2>/dev/null
    
    # Vider le cache des polices utilisateur si fontconfig est disponible
    if command -v fc-cache >/dev/null 2>&1; then
        fc-cache -f -v 2>/dev/null
    fi
    
    log_action "Cache des polices actualisé"
}

# Vérifier l'installation de la police
verify_font_installation() {
    local font_name="$1"
    local scope="$2"
    
    local installed=false
    
    case "$scope" in
        "user")
            if [[ -f "$HOME/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
        "system")
            if [[ -f "/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
        "template")
            if [[ -f "/Library/User Template/Non_localized/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
    esac
    
    if [[ "$installed" == "true" ]]; then
        log_action "✅ Installation de police vérifiée : $font_name ($scope)"
        return 0
    else
        log_action "❌ Échec de vérification d'installation de police : $font_name ($scope)"
        return 1
    fi
}

# Sauvegarder les polices existantes
backup_fonts() {
    local backup_timestamp="$(date +%Y%m%d_%H%M%S)"
    local backup_path="$BACKUP_DIR/fonts_backup_$backup_timestamp"
    
    log_action "Création de sauvegarde des polices : $backup_path"
    
    mkdir -p "$backup_path"
    
    # Sauvegarder les polices système
    if [[ -d "/Library/Fonts" ]]; then
        cp -R /Library/Fonts "$backup_path/system_fonts" 2>/dev/null
    fi
    
    # Sauvegarder les polices utilisateur
    if [[ -d "$HOME/Library/Fonts" ]]; then
        cp -R "$HOME/Library/Fonts" "$backup_path/user_fonts" 2>/dev/null
    fi
    
    # Créer un manifeste de sauvegarde
    {
        echo "Manifeste de Sauvegarde des Polices"
        echo "==================================="
        echo "Date de Sauvegarde : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Utilisateur : $(whoami)"
        echo ""
        echo "Polices Système :"
        ls -la "$backup_path/system_fonts/" 2>/dev/null || echo "Aucune"
        echo ""
        echo "Polices Utilisateur :"
        ls -la "$backup_path/user_fonts/" 2>/dev/null || echo "Aucune"
    } > "$backup_path/manifest.txt"
    
    log_action "Sauvegarde des polices terminée : $backup_path"
}

# Audit de conformité et licences des polices
audit_font_compliance() {
    local audit_file="$BACKUP_DIR/font_compliance_audit_$(date +%Y%m%d_%H%M%S).txt"
    
    log_action "Exécution d'audit de conformité des polices : $audit_file"
    
    {
        echo "Audit de Conformité des Polices MacFleet"
        echo "========================================"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Auditeur : $(whoami)"
        echo ""
        
        echo "INVENTAIRE DU DÉPÔT DE POLICES :"
        echo "--------------------------------"
        if [[ -d "$FONT_REPO_DIR" ]]; then
            ls -la "$FONT_REPO_DIR" | grep -v "\.meta$"
            echo ""
            
            echo "RÉVISION DES MÉTADONNÉES DES POLICES :"
            echo "--------------------------------------"
            for meta_file in "$FONT_REPO_DIR"/*.meta; do
                if [[ -f "$meta_file" ]]; then
                    echo "Police : $(basename "$meta_file" .meta)"
                    cat "$meta_file" | grep -E "(license_info|download_url)" || echo "Aucune information de licence disponible"
                    echo ""
                fi
            done
        else
            echo "Dépôt de polices non trouvé"
        fi
        
        echo "ANALYSE DES POLICES INSTALLÉES :"
        echo "-------------------------------"
        echo "Emplacement Polices Système : /Library/Fonts/"
        ls -la /Library/Fonts/ | wc -l | awk '{print "Total polices système : " $1-1}'
        echo ""
        
        echo "Emplacement Polices Utilisateur : ~/Library/Fonts/"
        ls -la ~/Library/Fonts/ 2>/dev/null | wc -l | awk '{print "Total polices utilisateur : " $1-1}' || echo "Aucun répertoire de polices utilisateur"
        echo ""
        
        echo "RECOMMANDATIONS DE CONFORMITÉ :"
        echo "-------------------------------"
        echo "• Vérifier que toutes les polices ont une documentation de licence appropriée"
        echo "• Supprimer toute police sans termes de licence clairs"
        echo "• Documenter l'utilisation des polices pour la conformité d'entreprise"
        echo "• Implémenter des audits réguliers des polices"
        echo "• Maintenir des journaux de déploiement des polices pour le suivi"
        
    } > "$audit_file"
    
    log_action "Audit de conformité des polices terminé : $audit_file"
    echo "$audit_file"
}

# Supprimer une police
remove_font() {
    local font_name="$1"
    local scope="${2:-all}"  # user, system, template, all
    
    log_action "Suppression de la police : $font_name (portée : $scope)"
    
    local removed=false
    
    case "$scope" in
        "user"|"all")
            if [[ -f "$HOME/Library/Fonts/$font_name" ]]; then
                rm -f "$HOME/Library/Fonts/$font_name"
                log_action "Police utilisateur supprimée : $font_name"
                removed=true
            fi
            ;;& # Continuer vers le cas suivant
        "system"|"all")
            if [[ -f "/Library/Fonts/$font_name" ]]; then
                if [[ $EUID -eq 0 ]]; then
                    rm -f "/Library/Fonts/$font_name"
                    log_action "Police système supprimée : $font_name"
                    removed=true
                else
                    log_action "AVERTISSEMENT : Privilèges administrateur requis pour supprimer la police système"
                fi
            fi
            ;;& # Continuer vers le cas suivant
        "template"|"all")
            if [[ -f "/Library/User Template/Non_localized/Library/Fonts/$font_name" ]]; then
                if [[ $EUID -eq 0 ]]; then
                    rm -f "/Library/User Template/Non_localized/Library/Fonts/$font_name"
                    log_action "Police modèle supprimée : $font_name"
                    removed=true
                else
                    log_action "AVERTISSEMENT : Privilèges administrateur requis pour supprimer la police modèle"
                fi
            fi
            ;;
    esac
    
    if [[ "$removed" == "true" ]]; then
        refresh_font_cache
        log_action "✅ Suppression de police terminée : $font_name"
        return 0
    else
        log_action "❌ Police non trouvée ou échec de suppression : $font_name"
        return 1
    fi
}

# Générer un rapport de déploiement des polices
generate_font_report() {
    local report_file="$BACKUP_DIR/font_deployment_report_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Génération du rapport de déploiement des polices : $report_file"
    
    {
        echo "{"
        echo "  \"report_type\": \"font_deployment\","
        echo "  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","
        echo "  \"hostname\": \"$(hostname)\","
        echo "  \"system_info\": {"
        echo "    \"macos_version\": \"$(sw_vers -productVersion)\","
        echo "    \"user\": \"$(whoami)\""
        echo "  },"
        echo "  \"font_statistics\": {"
        
        # Compter les polices
        local sys_fonts user_fonts repo_fonts
        sys_fonts=$(ls -1 /Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        user_fonts=$(ls -1 ~/Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        repo_fonts=$(ls -1 "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf 2>/dev/null | wc -l | tr -d ' ')
        
        echo "    \"system_fonts\": $sys_fonts,"
        echo "    \"user_fonts\": $user_fonts,"
        echo "    \"repository_fonts\": $repo_fonts"
        echo "  },"
        
        echo "  \"repository_fonts\": ["
        local first_font=true
        for font_file in "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf; do
            if [[ -f "$font_file" ]]; then
                if [[ "$first_font" == "false" ]]; then
                    echo ","
                fi
                first_font=false
                
                local font_name
                font_name=$(basename "$font_file")
                local file_size
                file_size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file")
                
                echo "    {"
                echo "      \"name\": \"$font_name\","
                echo "      \"size\": $file_size,"
                echo "      \"path\": \"$font_file\""
                echo -n "    }"
            fi
        done
        echo ""
        echo "  ]"
        echo "}"
    } > "$report_file"
    
    log_action "Rapport de déploiement des polices généré : $report_file"
    echo "$report_file"
}

# Fonction de gestion principale
main() {
    local action="${1:-status}"
    local parameter1="$2"
    local parameter2="$3"
    local parameter3="$4"
    
    setup_directories
    log_action "Gestion des polices MacFleet démarrée avec l'action : $action"
    
    case "$action" in
        "download")
            download_font "$parameter1" "$parameter2" "$parameter3"
            ;;
        "deploy")
            deploy_font "$parameter1" "$parameter2" "$parameter3"
            ;;
        "remove")
            remove_font "$parameter1" "$parameter2"
            ;;
        "validate")
            validate_font "$parameter1"
            ;;
        "discover")
            discover_fonts
            ;;
        "audit")
            audit_font_compliance
            ;;
        "backup")
            backup_fonts
            ;;
        "cache")
            refresh_font_cache
            ;;
        "report")
            generate_font_report
            ;;
        "status"|*)
            discover_fonts
            ;;
    esac
    
    log_action "Gestion des polices MacFleet terminée avec l'action : $action"
}

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

Modèles de Gestion des Polices

Configuration de Package de Polices d'Entreprise

# /etc/macfleet/font_config.conf
# Configuration de Gestion des Polices MacFleet

# Packages de polices d'entreprise
CORPORATE_FONTS=(
    "Arial-Bold.ttf"
    "Helvetica-Light.otf"
    "TimesNewRoman.ttf"
    "Calibri-Regular.ttf"
    "CompanyLogo-Font.otf"
)

# Paramètres du dépôt de polices
FONT_REPO_URL="https://fonts.company.com/repository"
AUTO_UPDATE_FONTS="true"
UPDATE_INTERVAL_HOURS="24"

# Paramètres de déploiement
DEFAULT_DEPLOYMENT_SCOPE="system"
REQUIRE_LICENSE_VALIDATION="true"
BACKUP_BEFORE_DEPLOYMENT="true"

# Paramètres de conformité
FONT_AUDIT_ENABLED="true"
LICENSE_TRACKING="mandatory"
USAGE_ANALYTICS="enabled"

Script de Déploiement de Polices

#!/bin/bash

# Déploiement automatisé des polices pour les standards d'entreprise
deploy_corporate_fonts() {
    local font_package_url="$1"
    local deployment_scope="${2:-system}"
    
    echo "🎨 Déploiement du Package de Polices d'Entreprise"
    echo "================================================="
    
    # Télécharger le package de polices
    local package_file="/tmp/corporate_fonts.zip"
    echo "Téléchargement du package de polices..."
    
    if curl -L -o "$package_file" "$font_package_url"; then
        echo "✅ Package téléchargé avec succès"
    else
        echo "❌ Échec du téléchargement du package"
        return 1
    fi
    
    # Extraire et valider les polices
    local extract_dir="/tmp/corporate_fonts"
    mkdir -p "$extract_dir"
    
    if command -v unzip >/dev/null 2>&1; then
        unzip -q "$package_file" -d "$extract_dir"
    else
        echo "❌ Commande unzip non disponible"
        return 1
    fi
    
    # Installer chaque police
    local installed_count=0
    local failed_count=0
    
    for font_file in "$extract_dir"/*.ttf "$extract_dir"/*.otf; do
        if [[ -f "$font_file" ]]; then
            local font_name
            font_name=$(basename "$font_file")
            
            echo "Installation : $font_name"
            
            if validate_font "$font_file" >/dev/null 2>&1; then
                case "$deployment_scope" in
                    "system")
                        sudo cp "$font_file" /Library/Fonts/
                        ;;
                    "user")
                        cp "$font_file" ~/Library/Fonts/
                        ;;
                    "template")
                        sudo cp "$font_file" "/Library/User Template/Non_localized/Library/Fonts/"
                        ;;
                esac
                
                if [[ $? -eq 0 ]]; then
                    echo "  ✅ $font_name installée"
                    ((installed_count++))
                else
                    echo "  ❌ Échec d'installation $font_name"
                    ((failed_count++))
                fi
            else
                echo "  ⚠️  Échec de validation $font_name - ignorée"
                ((failed_count++))
            fi
        fi
    done
    
    # Nettoyage
    rm -rf "$extract_dir" "$package_file"
    
    # Actualiser le cache des polices
    echo "Actualisation du cache des polices..."
    refresh_font_cache
    
    echo ""
    echo "📊 Résumé du Déploiement :"
    echo "  Installées avec succès : $installed_count polices"
    echo "  Échecs d'installation : $failed_count polices"
    echo "  Portée de déploiement : $deployment_scope"
    
    if [[ $failed_count -eq 0 ]]; then
        return 0
    else
        return 1
    fi
}

# Exemple d'utilisation
# deploy_corporate_fonts "https://fonts.company.com/corporate-package.zip" "system"

Fonctions de Sécurité et Conformité

Validation des Licences de Polices

#!/bin/bash

# Valider les licences de polices et la conformité
validate_font_licenses() {
    echo "🔍 Validation des Licences de Polices"
    echo "====================================="
    echo ""
    
    local compliance_issues=()
    
    # Vérifier les polices du dépôt
    if [[ -d "$FONT_REPO_DIR" ]]; then
        echo "Statut des Licences de Polices du Dépôt :"
        echo "------------------------------------------"
        
        for font_file in "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf; do
            if [[ -f "$font_file" ]]; then
                local font_name
                font_name=$(basename "$font_file")
                local meta_file="$FONT_REPO_DIR/${font_name}.meta"
                
                if [[ -f "$meta_file" ]]; then
                    local license_info
                    license_info=$(grep "license_info" "$meta_file" | cut -d'"' -f4)
                    
                    if [[ -n "$license_info" && "$license_info" != "null" ]]; then
                        echo "  ✅ $font_name : $license_info"
                    else
                        echo "  ⚠️  $font_name : Aucune information de licence"
                        compliance_issues+=("$font_name : Information de licence manquante")
                    fi
                else
                    echo "  ❌ $font_name : Aucun fichier de métadonnées"
                    compliance_issues+=("$font_name : Métadonnées manquantes")
                fi
            fi
        done
    fi
    
    echo ""
    
    # Vérifier les polices potentiellement problématiques
    echo "Détection de Polices Problématiques :"
    echo "------------------------------------"
    
    local problematic_fonts=(
        "Arial.ttf"
        "TimesNewRoman.ttf"
        "Helvetica.otf"
        "Calibri.ttf"
    )
    
    for problem_font in "${problematic_fonts[@]}"; do
        if [[ -f "/Library/Fonts/$problem_font" ]] || [[ -f "~/Library/Fonts/$problem_font" ]]; then
            echo "  ⚠️  Police potentiellement sous licence trouvée : $problem_font"
            compliance_issues+=("$problem_font : Nécessite vérification de licence")
        fi
    done
    
    echo ""
    
    # Générer le rapport de conformité
    if [[ ${#compliance_issues[@]} -eq 0 ]]; then
        echo "✅ Vérification de conformité des licences de polices réussie"
        return 0
    else
        echo "❌ Problèmes de conformité des licences de polices trouvés :"
        for issue in "${compliance_issues[@]}"; do
            echo "  - $issue"
        done
        return 1
    fi
}

validate_font_licenses

Analytiques d'Utilisation des Polices

#!/bin/bash

# Générer des analytiques d'utilisation des polices
analyze_font_usage() {
    echo "📊 Analytiques d'Utilisation des Polices"
    echo "========================================"
    echo ""
    
    # Nombre de polices par format
    echo "Distribution des Formats de Polices :"
    echo "------------------------------------"
    local ttf_count otf_count woff_count other_count
    
    ttf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.ttf" 2>/dev/null | wc -l | tr -d ' ')
    otf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    woff_count=$(find /Library/Fonts ~/Library/Fonts -name "*.woff*" 2>/dev/null | wc -l | tr -d ' ')
    other_count=$(find /Library/Fonts ~/Library/Fonts -type f ! -name "*.ttf" ! -name "*.otf" ! -name "*.woff*" 2>/dev/null | wc -l | tr -d ' ')
    
    echo "  TrueType (.ttf) : $ttf_count"
    echo "  OpenType (.otf) : $otf_count" 
    echo "  Polices Web (.woff) : $woff_count"
    echo "  Autres formats : $other_count"
    echo ""
    
    # Analyse de la taille des polices
    echo "Analyse de la Taille des Polices :"
    echo "----------------------------------"
    local total_size large_fonts
    total_size=0
    large_fonts=0
    
    while IFS= read -r font_file; do
        if [[ -f "$font_file" ]]; then
            local size
            size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file" 2>/dev/null || echo "0")
            total_size=$((total_size + size))
            
            if [[ "$size" -gt 1048576 ]]; then  # 1MB
                ((large_fonts++))
            fi
        fi
    done < <(find /Library/Fonts ~/Library/Fonts -type f 2>/dev/null)
    
    echo "  Stockage total des polices : $(( total_size / 1024 / 1024 )) MB"
    echo "  Polices volumineuses (>1MB) : $large_fonts"
    echo ""
    
    # Évaluation de l'impact système
    echo "Évaluation de l'Impact Système :"
    echo "-------------------------------"
    local total_fonts
    total_fonts=$(find /Library/Fonts ~/Library/Fonts -type f 2>/dev/null | wc -l | tr -d ' ')
    
    if [[ "$total_fonts" -gt 200 ]]; then
        echo "  ⚠️  Nombre élevé de polices ($total_fonts) - peut impacter les performances système"
    elif [[ "$total_fonts" -gt 100 ]]; then
        echo "  ⚠️  Nombre modéré de polices ($total_fonts) - surveiller les performances"
    else
        echo "  ✅ Nombre raisonnable de polices ($total_fonts)"
    fi
    
    if [[ "$total_size" -gt 104857600 ]]; then  # 100MB
        echo "  ⚠️  Utilisation élevée du stockage de polices - considérer un nettoyage"
    else
        echo "  ✅ Utilisation raisonnable du stockage de polices"
    fi
}

analyze_font_usage

Notes Techniques Importantes

Emplacements d'Installation des Polices

  • /Library/Fonts/ : Polices système (tous utilisateurs, nécessite admin)
  • ~/Library/Fonts/ : Polices spécifiques utilisateur (utilisateur actuel uniquement)
  • /Library/User Template/Non_localized/Library/Fonts/ : Modèle nouvel utilisateur

Formats de Polices Supportés

  • TTF (TrueType) : Format standard, bonne compatibilité
  • OTF (OpenType) : Format avancé avec meilleures fonctionnalités typographiques
  • WOFF/WOFF2 : Polices web (support desktop limité)
  • Formats hérités : Type 1, polices bitmap (dépréciés)

Considérations de Sécurité

  1. Accès Disque Complet : Requis pour l'installation de polices système
  2. Validation des Polices : Toujours valider les polices avant installation
  3. Conformité des Licences : Assurer le licenciement approprié pour les polices commerciales
  4. Vérification des Sources : Installer uniquement des polices de sources fiables

Meilleures Pratiques

  1. Standardisation : Maintenir des bibliothèques de polices cohérentes sur la flotte
  2. Gestion des Licences : Suivre et valider toutes les licences de polices
  3. Impact Performance : Surveiller les performances système avec de grandes bibliothèques de polices
  4. Contrôle de Version : Maintenir les versions de polices et les procédures de mise à jour
  5. Stratégie de Sauvegarde : Sauvegardes régulières avant les changements de polices
  6. Formation Utilisateur : Éduquer les utilisateurs sur l'utilisation appropriée des polices
  7. Audit de Conformité : Audits réguliers des licences et de l'utilisation
  8. Déploiement Flotte : Tester les déploiements de polices sur de petits groupes d'abord

N'oubliez pas de valider tous les scripts sur des appareils de test avant de les déployer sur votre environnement MacFleet, et d'assurer la conformité avec les accords de licence de polices lors de l'implémentation de systèmes de gestion de polices d'entreprise.