Guide

Configuration des paramètres de clavier sur les appareils Mac

La gestion cohérente des paramètres de clavier sur une flotte Mac est essentielle pour maintenir des standards de productivité et d'expérience utilisateur. Ce guide complet fournit des scripts shell et des techniques pour configurer divers paramètres de clavier sur les appareils macOS, incluant les taux de répétition des touches, les délais, la navigation au clavier et les fonctionnalités de correction automatique.

Comprendre les paramètres de clavier Mac

macOS propose plusieurs options de configuration de clavier qui peuvent considérablement impacter la productivité et le confort des utilisateurs :

Taux de répétition des touches

La vitesse à laquelle un caractère est répété quand une touche est maintenue enfoncée. Un taux plus élevé signifie une répétition plus rapide des caractères.

Délai avant répétition

Le temps que le clavier attend avant de commencer à répéter une touche maintenue enfoncée. Un délai plus court signifie que la répétition commence plus tôt.

Navigation au clavier

Permet aux utilisateurs de naviguer dans les éléments d'interface en utilisant le clavier au lieu des clics de souris, améliorant l'accessibilité et l'efficacité du flux de travail.

Correction automatique

Corrige automatiquement les mots mal orthographiés pendant la frappe, ce qui peut être utile ou perturbant selon les préférences utilisateur et les cas d'usage.

Prérequis

Avant de configurer les paramètres de clavier, assurez-vous d'avoir :

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

Commandes de base de configuration de clavier

Comprendre les outils de configuration

Les paramètres de clavier Mac sont gérés via plusieurs composants système :

• defaults : Interface en ligne de commande au système de valeurs par défaut utilisateur
• launchctl : Interface vers launchd pour exécuter des commandes dans le contexte utilisateur
• NSGlobalDomain : Domaine pour les paramètres système globaux
• Contexte utilisateur : Les paramètres doivent être appliqués dans la session utilisateur correcte

Détection de l'utilisateur actuel

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

#!/bin/bash

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

# Obtenir l'ID utilisateur
get_user_id() {
    local username=$1
    local user_id=$(id -u "$username")
    echo "$user_id"
}

# Exemple d'utilisation
current_user=$(get_current_user)
user_id=$(get_user_id "$current_user")

echo "Utilisateur actuel: $current_user"
echo "ID utilisateur: $user_id"

Configuration du taux de répétition des touches

Script de base pour le taux de répétition

Configurer la vitesse de répétition des touches :

#!/bin/bash

# Configurer le taux de répétition des touches
# Valeurs: 1-15 (1 = plus rapide, 15 = plus lent)
KEY_REPEAT_RATE=2

echo "Configuration du taux de répétition des touches à: $KEY_REPEAT_RATE"

# Obtenir l'utilisateur actuel et son ID
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

# Appliquer le paramètre dans le contexte utilisateur
if launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write -g KeyRepeat -int $KEY_REPEAT_RATE; then
    echo "✓ Taux de répétition des touches défini avec succès"
else
    echo "✗ Échec de la définition du taux de répétition des touches"
    exit 1
fi

echo "Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Script avancé de taux de répétition

Script plus complet avec validation et journalisation :

#!/bin/bash

# Script avancé de configuration du taux de répétition des touches
LOG_FILE="/var/log/keyboard_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

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

# Fonction pour valider le taux de répétition
validate_key_repeat_rate() {
    local rate=$1
    
    if [[ ! "$rate" =~ ^[0-9]+$ ]]; then
        log_message "ERREUR: Le taux de répétition doit être un nombre"
        return 1
    fi
    
    if [ "$rate" -lt 1 ] || [ "$rate" -gt 15 ]; then
        log_message "ERREUR: Le taux de répétition doit être entre 1-15"
        return 1
    fi
    
    return 0
}

# Fonction pour obtenir le taux de répétition actuel
get_current_key_repeat_rate() {
    local current_user=$1
    local current_uid=$2
    
    local current_rate=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read -g KeyRepeat 2>/dev/null)
    
    if [ -n "$current_rate" ]; then
        echo "$current_rate"
    else
        echo "Non défini"
    fi
}

# Fonction pour définir le taux de répétition
set_key_repeat_rate() {
    local rate=$1
    local current_user=$2
    local current_uid=$3
    
    log_message "Définition du taux de répétition à: $rate pour l'utilisateur: $current_user"
    
    # Obtenir le paramètre actuel
    local current_rate=$(get_current_key_repeat_rate "$current_user" "$current_uid")
    log_message "Taux de répétition actuel: $current_rate"
    
    # Appliquer le nouveau paramètre
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write -g KeyRepeat -int $rate; then
        log_message "SUCCÈS: Taux de répétition défini à $rate"
        
        # Vérifier le paramètre
        local new_rate=$(get_current_key_repeat_rate "$current_user" "$current_uid")
        log_message "Nouveau taux de répétition vérifié: $new_rate"
        
        return 0
    else
        log_message "ERREUR: Échec de la définition du taux de répétition"
        return 1
    fi
}

# Exécution principale
KEY_REPEAT_RATE=${1:-2}  # Par défaut à 2 si non spécifié

log_message "Début de la configuration du taux de répétition"

# Valider l'entrée
if ! validate_key_repeat_rate "$KEY_REPEAT_RATE"; then
    log_message "Taux de répétition invalide: $KEY_REPEAT_RATE"
    exit 1
fi

# Obtenir l'utilisateur actuel
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

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

log_message "Utilisateur actuel: $CurrentUser (UID: $CurrentUserUID)"

# Définir le taux de répétition
if set_key_repeat_rate "$KEY_REPEAT_RATE" "$CurrentUser" "$CurrentUserUID"; then
    log_message "Configuration du taux de répétition terminée avec succès"
else
    log_message "Configuration du taux de répétition échouée"
    exit 1
fi

log_message "Note: Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Configuration du délai avant répétition

Script de base pour le délai

Configurer le délai avant que la répétition des touches commence :

#!/bin/bash

# Configurer le délai avant répétition
# Valeurs: 0-3 (0 = délai le plus court, 3 = délai le plus long)
KEY_DELAY=1

echo "Configuration du délai avant répétition à: $KEY_DELAY"

# Obtenir l'utilisateur actuel et son ID
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

# Appliquer le paramètre dans le contexte utilisateur
if launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write -g InitialKeyRepeat -int $KEY_DELAY; then
    echo "✓ Délai avant répétition défini avec succès"
else
    echo "✗ Échec de la définition du délai avant répétition"
    exit 1
fi

echo "Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Script avancé de configuration du délai

Script complet avec validation et support multi-utilisateur :

#!/bin/bash

# Script avancé de configuration du délai avant répétition
LOG_FILE="/var/log/keyboard_settings.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

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

# Fonction pour valider la valeur du délai
validate_delay() {
    local delay=$1
    
    if [[ ! "$delay" =~ ^[0-9]+$ ]]; then
        log_message "ERREUR: Le délai doit être un nombre"
        return 1
    fi
    
    if [ "$delay" -lt 0 ] || [ "$delay" -gt 3 ]; then
        log_message "ERREUR: Le délai doit être entre 0-3"
        return 1
    fi
    
    return 0
}

# Fonction pour obtenir le paramètre de délai actuel
get_current_delay() {
    local current_user=$1
    local current_uid=$2
    
    local current_delay=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read -g InitialKeyRepeat 2>/dev/null)
    
    if [ -n "$current_delay" ]; then
        echo "$current_delay"
    else
        echo "Non défini"
    fi
}

# Fonction pour définir le délai avant répétition
set_delay_until_repeat() {
    local delay=$1
    local current_user=$2
    local current_uid=$3
    
    log_message "Définition du délai avant répétition à: $delay pour l'utilisateur: $current_user"
    
    # Obtenir le paramètre actuel
    local current_delay=$(get_current_delay "$current_user" "$current_uid")
    log_message "Délai avant répétition actuel: $current_delay"
    
    # Appliquer le nouveau paramètre
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write -g InitialKeyRepeat -int $delay; then
        log_message "SUCCÈS: Délai avant répétition défini à $delay"
        
        # Vérifier le paramètre
        local new_delay=$(get_current_delay "$current_user" "$current_uid")
        log_message "Nouveau délai avant répétition vérifié: $new_delay"
        
        return 0
    else
        log_message "ERREUR: Échec de la définition du délai avant répétition"
        return 1
    fi
}

# Exécution principale
KEY_DELAY=${1:-1}  # Par défaut à 1 si non spécifié

log_message "Début de la configuration du délai avant répétition"

# Valider l'entrée
if ! validate_delay "$KEY_DELAY"; then
    log_message "Valeur de délai invalide: $KEY_DELAY"
    exit 1
fi

# Obtenir l'utilisateur actuel
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

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

log_message "Utilisateur actuel: $CurrentUser (UID: $CurrentUserUID)"

# Définir le délai avant répétition
if set_delay_until_repeat "$KEY_DELAY" "$CurrentUser" "$CurrentUserUID"; then
    log_message "Configuration du délai avant répétition terminée avec succès"
else
    log_message "Configuration du délai avant répétition échouée"
    exit 1
fi

log_message "Note: Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Configuration de la navigation au clavier

Script de base pour la navigation au clavier

Activer la navigation au clavier pour une meilleure accessibilité :

#!/bin/bash

# Activer la navigation au clavier
echo "Activation de la navigation au clavier..."

# Obtenir l'utilisateur actuel et son ID
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

# Activer la navigation au clavier (3 = accès clavier complet)
if launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write NSGlobalDomain AppleKeyboardUIMode -int 3; then
    echo "✓ Navigation au clavier activée avec succès"
else
    echo "✗ Échec de l'activation de la navigation au clavier"
    exit 1
fi

echo "La navigation au clavier est maintenant activée"
echo "Note: Cette fonctionnalité requiert macOS 13.0 ou ultérieur"

Script avancé de navigation au clavier

Script complet avec vérification de version et options de configuration :

#!/bin/bash

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

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

# Fonction pour vérifier la version macOS
check_macos_version() {
    local version=$(sw_vers -productVersion)
    local major_version=$(echo "$version" | cut -d. -f1)
    
    log_message "Version macOS: $version"
    
    if [ "$major_version" -ge 13 ]; then
        log_message "La version macOS est compatible avec la navigation au clavier"
        return 0
    else
        log_message "AVERTISSEMENT: La version macOS peut ne pas supporter complètement la navigation au clavier"
        return 1
    fi
}

# Fonction pour obtenir le statut de navigation au clavier actuel
get_keyboard_navigation_status() {
    local current_user=$1
    local current_uid=$2
    
    local current_setting=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain AppleKeyboardUIMode 2>/dev/null)
    
    if [ -n "$current_setting" ]; then
        case "$current_setting" in
            0) echo "Désactivé (zones de texte et listes seulement)" ;;
            1) echo "Activé (zones de texte et listes seulement)" ;;
            2) echo "Activé (contrôles quand la touche Tab est pressée)" ;;
            3) echo "Activé (tous les contrôles)" ;;
            *) echo "Inconnu ($current_setting)" ;;
        esac
    else
        echo "Non défini (par défaut)"
    fi
}

# Fonction pour définir la navigation au clavier
set_keyboard_navigation() {
    local mode=$1
    local current_user=$2
    local current_uid=$3
    
    log_message "Définition du mode de navigation au clavier à: $mode pour l'utilisateur: $current_user"
    
    # Obtenir le paramètre actuel
    local current_status=$(get_keyboard_navigation_status "$current_user" "$current_uid")
    log_message "Navigation au clavier actuelle: $current_status"
    
    # Appliquer le nouveau paramètre
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain AppleKeyboardUIMode -int $mode; then
        log_message "SUCCÈS: Navigation au clavier définie au mode $mode"
        
        # Vérifier le paramètre
        local new_status=$(get_keyboard_navigation_status "$current_user" "$current_uid")
        log_message "Nouvelle navigation au clavier vérifiée: $new_status"
        
        return 0
    else
        log_message "ERREUR: Échec de la définition de la navigation au clavier"
        return 1
    fi
}

# Exécution principale
KEYBOARD_MODE=${1:-3}  # Par défaut à 3 (accès clavier complet) si non spécifié

log_message "Début de la configuration de la navigation au clavier"

# Vérifier la version macOS
check_macos_version

# Valider le mode
if [[ ! "$KEYBOARD_MODE" =~ ^[0-3]$ ]]; then
    log_message "ERREUR: Mode clavier invalide: $KEYBOARD_MODE (doit être 0-3)"
    exit 1
fi

# Obtenir l'utilisateur actuel
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

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

log_message "Utilisateur actuel: $CurrentUser (UID: $CurrentUserUID)"

# Définir la navigation au clavier
if set_keyboard_navigation "$KEYBOARD_MODE" "$CurrentUser" "$CurrentUserUID"; then
    log_message "Configuration de la navigation au clavier terminée avec succès"
else
    log_message "Configuration de la navigation au clavier échouée"
    exit 1
fi

log_message "Navigation au clavier maintenant configurée"

Configuration de la correction automatique

Script de base pour désactiver la correction automatique

Désactiver la correction orthographique automatique :

#!/bin/bash

# Désactiver la correction automatique
echo "Désactivation de la correction automatique..."

# Obtenir l'utilisateur actuel et son ID
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

# Désactiver la correction automatique
if launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write NSGlobalDomain NSAutomaticSpellingCorrectionEnabled -bool false; then
    echo "✓ Correction automatique désactivée avec succès"
else
    echo "✗ Échec de la désactivation de la correction automatique"
    exit 1
fi

echo "La correction automatique est maintenant désactivée"
echo "Note: Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Script avancé de gestion de la correction automatique

Script complet pour gérer diverses fonctionnalités de correction automatique :

#!/bin/bash

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

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

# Fonction pour obtenir les paramètres de correction automatique actuels
get_autocorrect_settings() {
    local current_user=$1
    local current_uid=$2
    
    log_message "Obtention des paramètres de correction automatique pour l'utilisateur: $current_user"
    
    # Correction orthographique
    local spelling_correction=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain NSAutomaticSpellingCorrectionEnabled 2>/dev/null)
    
    # Capitalisation des mots
    local capitalize_words=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain NSAutomaticCapitalizationEnabled 2>/dev/null)
    
    # Ajout de point avec double espace
    local period_substitution=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain NSAutomaticPeriodSubstitutionEnabled 2>/dev/null)
    
    # Guillemets intelligents
    local smart_quotes=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain NSAutomaticQuoteSubstitutionEnabled 2>/dev/null)
    
    # Tirets intelligents
    local smart_dashes=$(launchctl asuser $current_uid sudo -iu "$current_user" defaults read NSGlobalDomain NSAutomaticDashSubstitutionEnabled 2>/dev/null)
    
    echo "Paramètres de correction automatique actuels:"
    echo "  Correction orthographique: ${spelling_correction:-Non défini}"
    echo "  Capitalisation des mots: ${capitalize_words:-Non défini}"
    echo "  Substitution de point: ${period_substitution:-Non défini}"
    echo "  Guillemets intelligents: ${smart_quotes:-Non défini}"
    echo "  Tirets intelligents: ${smart_dashes:-Non défini}"
}

# Fonction pour configurer les fonctionnalités de correction automatique
configure_autocorrect() {
    local current_user=$1
    local current_uid=$2
    local spelling_correction=$3
    local capitalize_words=$4
    local period_substitution=$5
    local smart_quotes=$6
    local smart_dashes=$7
    
    log_message "Configuration des paramètres de correction automatique pour l'utilisateur: $current_user"
    
    local success=0
    
    # Configurer la correction orthographique
    if [ -n "$spelling_correction" ]; then
        if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticSpellingCorrectionEnabled -bool $spelling_correction; then
            log_message "SUCCÈS: Correction orthographique définie à $spelling_correction"
        else
            log_message "ERREUR: Échec de la définition de la correction orthographique"
            success=1
        fi
    fi
    
    # Configurer la capitalisation des mots
    if [ -n "$capitalize_words" ]; then
        if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticCapitalizationEnabled -bool $capitalize_words; then
            log_message "SUCCÈS: Capitalisation des mots définie à $capitalize_words"
        else
            log_message "ERREUR: Échec de la définition de la capitalisation des mots"
            success=1
        fi
    fi
    
    # Configurer la substitution de point
    if [ -n "$period_substitution" ]; then
        if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticPeriodSubstitutionEnabled -bool $period_substitution; then
            log_message "SUCCÈS: Substitution de point définie à $period_substitution"
        else
            log_message "ERREUR: Échec de la définition de la substitution de point"
            success=1
        fi
    fi
    
    # Configurer les guillemets intelligents
    if [ -n "$smart_quotes" ]; then
        if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticQuoteSubstitutionEnabled -bool $smart_quotes; then
            log_message "SUCCÈS: Guillemets intelligents définis à $smart_quotes"
        else
            log_message "ERREUR: Échec de la définition des guillemets intelligents"
            success=1
        fi
    fi
    
    # Configurer les tirets intelligents
    if [ -n "$smart_dashes" ]; then
        if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticDashSubstitutionEnabled -bool $smart_dashes; then
            log_message "SUCCÈS: Tirets intelligents définis à $smart_dashes"
        else
            log_message "ERREUR: Échec de la définition des tirets intelligents"
            success=1
        fi
    fi
    
    return $success
}

# Exécution principale
log_message "Début de la configuration de la correction automatique"

# Options de configuration (modifier selon les besoins)
SPELLING_CORRECTION=${1:-false}
CAPITALIZE_WORDS=${2:-false}
PERIOD_SUBSTITUTION=${3:-false}
SMART_QUOTES=${4:-false}
SMART_DASHES=${5:-false}

# Obtenir l'utilisateur actuel
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

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

log_message "Utilisateur actuel: $CurrentUser (UID: $CurrentUserUID)"

# Afficher les paramètres actuels
get_autocorrect_settings "$CurrentUser" "$CurrentUserUID"

# Configurer la correction automatique
if configure_autocorrect "$CurrentUser" "$CurrentUserUID" "$SPELLING_CORRECTION" "$CAPITALIZE_WORDS" "$PERIOD_SUBSTITUTION" "$SMART_QUOTES" "$SMART_DASHES"; then
    log_message "Configuration de la correction automatique terminée avec succès"
else
    log_message "Certaines configurations de correction automatique ont échoué"
    exit 1
fi

log_message "Note: Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"

Configuration complète du clavier

Script de configuration tout-en-un

Script pour configurer tous les paramètres de clavier en une fois :

#!/bin/bash

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

# Variables de configuration
KEY_REPEAT_RATE=2
KEY_DELAY=1
KEYBOARD_NAVIGATION=3
DISABLE_AUTOCORRECT=true
DISABLE_CAPITALIZE=true
DISABLE_PERIOD_SUB=true
DISABLE_SMART_QUOTES=true
DISABLE_SMART_DASHES=true

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

# Fonction pour appliquer tous les paramètres de clavier
apply_keyboard_settings() {
    local current_user=$1
    local current_uid=$2
    
    log_message "Application des paramètres de clavier complets pour l'utilisateur: $current_user"
    
    local success=0
    
    # Taux de répétition des touches
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write -g KeyRepeat -int $KEY_REPEAT_RATE; then
        log_message "SUCCÈS: Taux de répétition défini à $KEY_REPEAT_RATE"
    else
        log_message "ERREUR: Échec de la définition du taux de répétition"
        success=1
    fi
    
    # Délai avant répétition
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write -g InitialKeyRepeat -int $KEY_DELAY; then
        log_message "SUCCÈS: Délai avant répétition défini à $KEY_DELAY"
    else
        log_message "ERREUR: Échec de la définition du délai avant répétition"
        success=1
    fi
    
    # Navigation au clavier
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain AppleKeyboardUIMode -int $KEYBOARD_NAVIGATION; then
        log_message "SUCCÈS: Navigation au clavier définie à $KEYBOARD_NAVIGATION"
    else
        log_message "ERREUR: Échec de la définition de la navigation au clavier"
        success=1
    fi
    
    # Fonctionnalités de correction automatique
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticSpellingCorrectionEnabled -bool $DISABLE_AUTOCORRECT; then
        log_message "SUCCÈS: Correction automatique désactivée"
    else
        log_message "ERREUR: Échec de la désactivation de la correction automatique"
        success=1
    fi
    
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticCapitalizationEnabled -bool $DISABLE_CAPITALIZE; then
        log_message "SUCCÈS: Capitalisation automatique désactivée"
    else
        log_message "ERREUR: Échec de la désactivation de la capitalisation automatique"
        success=1
    fi
    
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticPeriodSubstitutionEnabled -bool $DISABLE_PERIOD_SUB; then
        log_message "SUCCÈS: Substitution de point désactivée"
    else
        log_message "ERREUR: Échec de la désactivation de la substitution de point"
        success=1
    fi
    
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticQuoteSubstitutionEnabled -bool $DISABLE_SMART_QUOTES; then
        log_message "SUCCÈS: Guillemets intelligents désactivés"
    else
        log_message "ERREUR: Échec de la désactivation des guillemets intelligents"
        success=1
    fi
    
    if launchctl asuser $current_uid sudo -iu "$current_user" defaults write NSGlobalDomain NSAutomaticDashSubstitutionEnabled -bool $DISABLE_SMART_DASHES; then
        log_message "SUCCÈS: Tirets intelligents désactivés"
    else
        log_message "ERREUR: Échec de la désactivation des tirets intelligents"
        success=1
    fi
    
    return $success
}

# Exécution principale
log_message "Début de la configuration complète du clavier"

# Obtenir l'utilisateur actuel
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

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

log_message "Utilisateur actuel: $CurrentUser (UID: $CurrentUserUID)"

# Appliquer tous les paramètres
if apply_keyboard_settings "$CurrentUser" "$CurrentUserUID"; then
    log_message "Configuration complète du clavier terminée avec succès"
    echo "✓ Tous les paramètres de clavier appliqués avec succès"
else
    log_message "Certaines configurations de clavier ont échoué"
    echo "⚠ Certains paramètres peuvent ne pas avoir été appliqués. Vérifiez le journal: $LOG_FILE"
    exit 1
fi

log_message "Note: Les changements prendront effet après déconnexion/reconnexion de l'utilisateur"
echo "Note: Veuillez vous déconnecter et vous reconnecter pour que les changements prennent effet"

Conclusion

La gestion efficace de la configuration du clavier est essentielle pour maintenir des expériences utilisateur cohérentes sur les flottes Mac. Les scripts et techniques fournis dans ce guide offrent des solutions complètes pour divers scénarios de configuration de clavier.

Points clés à retenir :

• Utiliser le contexte utilisateur approprié pour l'application des paramètres
• Implémenter une validation et une gestion d'erreurs appropriées
• Tester les configurations avant un déploiement de masse
• Surveiller et journaliser tous les changements de configuration
• Considérer les préférences utilisateur et les besoins d'accessibilité

N'oubliez pas que les paramètres de clavier sont très personnels, donc considérez fournir des options permettant aux utilisateurs de personnaliser leur expérience tout en maintenant les standards d'entreprise lorsque nécessaire.

Gérer les extensions de noyau sur macOS

Surveillez et gérez les extensions de noyau sur vos appareils Roundfleet à l'aide d'outils en ligne de commande. Ce tutoriel couvre l'affichage des kexts chargées, le chargement/déchargement d'extensions, la recherche d'extensions spécifiques, et la surveillance sécuritaire d'entreprise.

Comprendre les extensions de noyau macOS

Les Extensions de Noyau (kexts) sont des pilotes qui permettent au noyau macOS de communiquer avec les périphériques matériels et les composants système. Comprendre la gestion des kext est crucial pour :

• Compatibilité matérielle - Pilotes de périphériques et communication matérielle
• Stabilité système - Surveillance des extensions potentiellement problématiques
• Évaluation sécuritaire - Identification des kexts non autorisées ou malveillantes
• Exigences de conformité - Sécurité d'entreprise et pistes d'audit

Outils clés pour la gestion des kext :

• kextstat - Afficher les extensions de noyau chargées
• kextload - Charger les extensions de noyau
• kextunload - Décharger les extensions de noyau
• kextfind - Trouver les extensions de noyau par critères

Afficher les extensions de noyau chargées

Lister toutes les extensions chargées

#!/bin/bash

# Afficher toutes les extensions de noyau actuellement chargées
kextstat

echo "Liste des extensions de noyau récupérée avec succès"

Afficher les détails d'une extension spécifique

#!/bin/bash

# Afficher les détails d'une extension de noyau spécifique par ID de bundle
BUNDLE_ID="${1:-com.apple.kpi.bsd}"

echo "Recherche de l'extension de noyau : $BUNDLE_ID"
kextstat | grep "$BUNDLE_ID"

if [[ $? -eq 0 ]]; then
    echo "Extension trouvée et chargée"
else
    echo "Extension non trouvée ou non chargée"
fi

Lister uniquement les extensions tierces

#!/bin/bash

# Afficher uniquement les extensions de noyau tierces (non-Apple)
echo "=== Extensions de Noyau Tierces ==="
echo "Appareil : $(hostname)"
echo "Date : $(date)"
echo "===================================="

echo -e "\n🔍 Extensions de noyau non-Apple :"
third_party_kexts=$(kextstat | grep -v com.apple)

if [[ -n "$third_party_kexts" ]]; then
    echo "$third_party_kexts"
    echo -e "\n📊 Nombre d'extensions tierces : $(echo "$third_party_kexts" | wc -l)"
else
    echo "Aucune extension de noyau tierce détectée"
fi

Analyse complète des Kext

#!/bin/bash

# Analyse détaillée des extensions de noyau
echo "=== Analyse des extensions de noyau Roundfleet ==="
echo "Appareil : $(hostname)"
echo "Version OS : $(sw_vers -productVersion)"
echo "Version noyau : $(uname -r)"
echo "Date : $(date)"
echo "==============================================="

# Total des extensions chargées
total_kexts=$(kextstat | tail -n +2 | wc -l)
echo "🔧 Total d'extensions chargées : $total_kexts"

# Répartition Apple vs tierces
apple_kexts=$(kextstat | grep -c com.apple)
third_party_kexts=$(kextstat | grep -v com.apple | tail -n +2 | wc -l)

echo "🍎 Extensions Apple : $apple_kexts"
echo "🔌 Extensions tierces : $third_party_kexts"

# Afficher les extensions tierces s'il y en a
if [[ $third_party_kexts -gt 0 ]]; then
    echo -e "\n⚠️  Extensions tierces :"
    kextstat | grep -v com.apple | tail -n +2
fi

# Vérifier les extensions potentiellement suspectes
echo -e "\n🔒 Analyse de sécurité :"
suspicious_patterns=("hack" "crack" "cheat" "bypass" "inject")
for pattern in "${suspicious_patterns[@]}"; do
    suspicious=$(kextstat | grep -i "$pattern")
    if [[ -n "$suspicious" ]]; then
        echo "🚨 Extension suspecte détectée : $suspicious"
    fi
done

echo "✅ Analyse de sécurité terminée"

Charger les extensions de noyau

Chargement basique d'extension

#!/bin/bash

# Charger une extension de noyau par chemin
KEXT_PATH="${1}"

if [[ -z "$KEXT_PATH" ]]; then
    echo "Usage : $0 <chemin_vers_kext>"
    echo "Exemple : $0 /System/Library/Extensions/FakeSMC.kext"
    exit 1
fi

if [[ ! -d "$KEXT_PATH" ]]; then
    echo "❌ Extension de noyau non trouvée : $KEXT_PATH"
    exit 1
fi

echo "Chargement de l'extension de noyau : $KEXT_PATH"
if sudo kextload "$KEXT_PATH"; then
    echo "✅ Extension de noyau chargée avec succès"
else
    echo "❌ Échec du chargement de l'extension de noyau"
    exit 1
fi

Chargement sûr d'extension avec vérification

#!/bin/bash

# Charger une extension de noyau en toute sécurité avec vérification
load_kext_safely() {
    local kext_path="$1"
    local bundle_id="$2"
    
    if [[ -z "$kext_path" ]]; then
        echo "❌ Chemin d'extension de noyau requis"
        return 1
    fi
    
    # Vérifier que l'extension existe
    if [[ ! -d "$kext_path" ]]; then
        echo "❌ Extension de noyau non trouvée : $kext_path"
        return 1
    fi
    
    # Vérifier si déjà chargée
    if [[ -n "$bundle_id" ]]; then
        if kextstat | grep -q "$bundle_id"; then
            echo "⚠️  Extension déjà chargée : $bundle_id"
            return 0
        fi
    fi
    
    # Valider l'extension
    echo "🔍 Validation de l'extension de noyau..."
    if ! kextutil -t "$kext_path" 2>/dev/null; then
        echo "❌ Échec de la validation de l'extension"
        return 1
    fi
    
    # Charger l'extension
    echo "📦 Chargement de l'extension de noyau : $kext_path"
    if sudo kextload "$kext_path"; then
        echo "✅ Extension de noyau chargée avec succès"
        
        # Vérifier qu'elle est réellement chargée
        if [[ -n "$bundle_id" ]]; then
            sleep 1
            if kextstat | grep -q "$bundle_id"; then
                echo "✅ Extension vérifiée comme chargée"
            else
                echo "⚠️  État de chargement de l'extension incertain"
            fi
        fi
        
        return 0
    else
        echo "❌ Échec du chargement de l'extension de noyau"
        return 1
    fi
}

# Exemple d'utilisation
# load_kext_safely "/System/Library/Extensions/FakeSMC.kext" "com.apple.driver.FakeSMC"

Chargement d'extension d'entreprise

#!/bin/bash

# Chargement d'extension de noyau d'entreprise avec journalisation
LOG_FILE="/var/log/roundfleet_kext_operations.log"

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

load_enterprise_kext() {
    local kext_path="$1"
    local description="$2"
    
    log_action "=== Opération de chargement d'extension de noyau ==="
    log_action "Appareil : $(hostname)"
    log_action "Utilisateur : $(whoami)"
    log_action "Extension : $kext_path"
    log_action "Description : ${description:-Aucune description fournie}"
    
    # Vérifications pré-chargement
    if [[ ! -d "$kext_path" ]]; then
        log_action "ERREUR : Extension non trouvée au chemin : $kext_path"
        return 1
    fi
    
    # Vérifier l'état actuel du système
    local pre_count=$(kextstat | tail -n +2 | wc -l)
    log_action "Nombre d'extensions pré-chargement : $pre_count"
    
    # Tentative de chargement
    log_action "Tentative de chargement de l'extension..."
    if sudo kextload "$kext_path" 2>&1 | tee -a "$LOG_FILE"; then
        local post_count=$(kextstat | tail -n +2 | wc -l)
        log_action "SUCCÈS : Extension chargée"
        log_action "Nombre d'extensions post-chargement : $post_count"
        
        # Générer le rapport de chargement
        {
            echo "Rapport de chargement d'extension de noyau Roundfleet"
            echo "Heure : $(date)"
            echo "Extension : $kext_path"
            echo "État : SUCCÈS"
            echo "Nombre pré-chargement : $pre_count"
            echo "Nombre post-chargement : $post_count"
        } >> "$LOG_FILE"
        
        return 0
    else
        log_action "ERREUR : Échec du chargement de l'extension"
        return 1
    fi
}

# Usage : load_enterprise_kext "/chemin/vers/extension.kext" "Description"

Décharger les extensions de noyau

Déchargement basique d'extension

#!/bin/bash

# Décharger une extension de noyau par chemin
KEXT_PATH="${1}"

if [[ -z "$KEXT_PATH" ]]; then
    echo "Usage : $0 <chemin_vers_kext>"
    echo "Exemple : $0 /System/Library/Extensions/FakeSMC.kext"
    exit 1
fi

echo "Déchargement de l'extension de noyau : $KEXT_PATH"
if sudo kextunload "$KEXT_PATH"; then
    echo "✅ Extension de noyau déchargée avec succès"
else
    echo "❌ Échec du déchargement de l'extension de noyau"
    exit 1
fi

Décharger par ID de bundle

#!/bin/bash

# Décharger une extension de noyau par identifiant de bundle
BUNDLE_ID="${1}"

if [[ -z "$BUNDLE_ID" ]]; then
    echo "Usage : $0 <bundle_id>"
    echo "Exemple : $0 com.apple.driver.FakeSMC"
    exit 1
fi

# Vérifier si l'extension est chargée
if ! kextstat | grep -q "$BUNDLE_ID"; then
    echo "⚠️  Extension pas actuellement chargée : $BUNDLE_ID"
    exit 0
fi

echo "Déchargement de l'extension de noyau : $BUNDLE_ID"
if sudo kextunload -b "$BUNDLE_ID"; then
    echo "✅ Extension de noyau déchargée avec succès"
    
    # Vérifier le déchargement
    sleep 1
    if ! kextstat | grep -q "$BUNDLE_ID"; then
        echo "✅ Extension confirmée comme déchargée"
    else
        echo "⚠️  L'extension peut encore être chargée"
    fi
else
    echo "❌ Échec du déchargement de l'extension de noyau"
    exit 1
fi

Déchargement sûr d'extension

#!/bin/bash

# Décharger les extensions de noyau en toute sécurité avec vérification des dépendances
unload_kext_safely() {
    local bundle_id="$1"
    local force_unload="${2:-false}"
    
    if [[ -z "$bundle_id" ]]; then
        echo "❌ ID de bundle requis"
        return 1
    fi
    
    # Vérifier si l'extension est chargée
    if ! kextstat | grep -q "$bundle_id"; then
        echo "ℹ️  Extension non chargée : $bundle_id"
        return 0
    fi
    
    # Vérifier les extensions Apple (avertir mais permettre)
    if [[ "$bundle_id" == com.apple.* ]]; then
        echo "⚠️  AVERTISSEMENT : Tentative de déchargement d'une extension système Apple"
        echo "Cela peut causer une instabilité du système"
        
        if [[ "$force_unload" != "true" ]]; then
            echo "❌ Abandon du déchargement de l'extension Apple (utilisez force_unload=true pour forcer)"
            return 1
        fi
    fi
    
    # Afficher les infos de l'extension avant déchargement
    echo "🔍 Informations de l'extension :"
    kextstat | grep "$bundle_id"
    
    # Tentative de déchargement
    echo "📤 Déchargement de l'extension : $bundle_id"
    if sudo kextunload -b "$bundle_id"; then
        echo "✅ Extension déchargée avec succès"
        
        # Vérifier le déchargement
        sleep 2
        if ! kextstat | grep -q "$bundle_id"; then
            echo "✅ Extension confirmée comme déchargée"
            return 0
        else
            echo "⚠️  L'extension semble encore être chargée"
            return 1
        fi
    else
        echo "❌ Échec du déchargement de l'extension"
        return 1
    fi
}

# Exemple d'utilisation
# unload_kext_safely "com.third.party.driver"
# unload_kext_safely "com.apple.driver.something" "true"  # Forcer extension Apple

Trouver les extensions de noyau

Trouver par ID de bundle

#!/bin/bash

# Trouver les extensions de noyau par ID de bundle
BUNDLE_ID="${1}"

if [[ -z "$BUNDLE_ID" ]]; then
    echo "Usage : $0 <bundle_id>"
    echo "Exemple : $0 com.apple.driver.AppleHDA"
    exit 1
fi

echo "Recherche de l'extension de noyau : $BUNDLE_ID"
kextfind -b "$BUNDLE_ID"

# Vérifier aussi si elle est actuellement chargée
echo -e "\nÉtat de chargement :"
if kextstat | grep -q "$BUNDLE_ID"; then
    echo "✅ Extension actuellement chargée"
    kextstat | grep "$BUNDLE_ID"
else
    echo "❌ Extension pas actuellement chargée"
fi

Recherche complète d'extension

#!/bin/bash

# Recherche et analyse complètes d'extensions de noyau
search_kext_comprehensive() {
    local search_term="$1"
    
    if [[ -z "$search_term" ]]; then
        echo "Usage : search_kext_comprehensive <terme_recherche>"
        return 1
    fi
    
    echo "=== Recherche complète d'extensions de noyau ==="
    echo "Terme de recherche : $search_term"
    echo "Appareil : $(hostname)"
    echo "Date : $(date)"
    echo "==============================================="
    
    # Recherche par ID de bundle
    echo -e "\n🔍 Recherche par ID de bundle :"
    local found_by_bundle=$(kextfind -b "*$search_term*" 2>/dev/null)
    if [[ -n "$found_by_bundle" ]]; then
        echo "$found_by_bundle"
    else
        echo "Aucune extension trouvée correspondant au motif d'ID de bundle"
    fi
    
    # Rechercher les extensions chargées
    echo -e "\n📋 Vérification des extensions chargées :"
    local loaded_matches=$(kextstat | grep -i "$search_term")
    if [[ -n "$loaded_matches" ]]; then
        echo "Trouvé dans les extensions chargées :"
        echo "$loaded_matches"
    else
        echo "Aucune extension chargée ne correspond au terme de recherche"
    fi
    
    # Rechercher dans le système de fichiers
    echo -e "\n💾 Recherche dans le système de fichiers :"
    echo "Répertoire des extensions système :"
    find /System/Library/Extensions -name "*$search_term*" -type d 2>/dev/null | head -10
    
    echo -e "\nRépertoire des extensions de bibliothèque :"
    find /Library/Extensions -name "*$search_term*" -type d 2>/dev/null | head -10
    
    echo -e "\n✅ Recherche terminée"
}

# Exemple d'utilisation
# search_kext_comprehensive "bluetooth"
# search_kext_comprehensive "audio"

Trouver les extensions par motif

#!/bin/bash

# Trouver les extensions de noyau correspondant à divers motifs
echo "=== Recherche par motifs d'extensions de noyau ==="

# Extensions liées à l'audio
echo -e "\n🔊 Extensions audio :"
kextstat | grep -i -E "(audio|sound|hda)"

# Extensions liées au réseau
echo -e "\n🌐 Extensions réseau :"
kextstat | grep -i -E "(network|wifi|ethernet|bluetooth)"

# Extensions liées aux graphiques
echo -e "\n🖥️  Extensions graphiques :"
kextstat | grep -i -E "(graphics|display|amd|nvidia|intel)"

# Extensions liées à l'USB
echo -e "\n🔌 Extensions USB :"
kextstat | grep -i -E "(usb|port)"

# Extensions liées à la sécurité
echo -e "\n🔒 Extensions sécurité :"
kextstat | grep -i -E "(security|firewall|antivirus)"

# Extensions de virtualisation
echo -e "\n☁️  Extensions virtualisation :"
kextstat | grep -i -E "(vmware|parallels|virtual|hypervisor)"

Surveillance d'entreprise des extensions de noyau

Script de surveillance sécuritaire

#!/bin/bash

# Surveillance sécuritaire d'entreprise des extensions de noyau
LOG_FILE="/var/log/roundfleet_kext_security.log"
ALERT_FILE="/var/log/roundfleet_kext_alerts.log"

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

# Fonction d'alerte
send_alert() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - ALERTE : $1" | tee -a "$ALERT_FILE"
}

# Évaluation de sécurité
assess_kext_security() {
    log_security "=== Évaluation de sécurité des extensions de noyau ==="
    log_security "Appareil : $(hostname)"
    log_security "Version OS : $(sw_vers -productVersion)"
    
    # Compter les extensions
    local total_kexts=$(kextstat | tail -n +2 | wc -l)
    local apple_kexts=$(kextstat | grep -c com.apple)
    local third_party=$(kextstat | grep -v com.apple | tail -n +2 | wc -l)
    
    log_security "Extensions totales : $total_kexts"
    log_security "Extensions Apple : $apple_kexts"
    log_security "Extensions tierces : $third_party"
    
    # Alerte sur un nombre élevé d'extensions tierces
    if [[ $third_party -gt 5 ]]; then
        send_alert "Nombre élevé d'extensions tierces : $third_party"
    fi
    
    # Vérifier les extensions suspectes
    local suspicious_keywords=("hack" "crack" "cheat" "bypass" "inject" "hook" "patch")
    for keyword in "${suspicious_keywords[@]}"; do
        local matches=$(kextstat | grep -i "$keyword")
        if [[ -n "$matches" ]]; then
            send_alert "Extension suspecte détectée ($keyword) : $matches"
        fi
    done
    
    # Vérifier les extensions non signées
    echo -e "\n🔍 Vérification des signatures d'extensions..."
    kextstat | grep -v com.apple | tail -n +2 | while read line; do
        local bundle_id=$(echo "$line" | awk '{print $6}')
        if [[ -n "$bundle_id" ]]; then
            # Ceci est une vérification simplifiée - en réalité, vous voudriez une vérification de signature plus sophistiquée
            log_security "Extension tierce : $bundle_id"
        fi
    done
    
    log_security "Évaluation de sécurité terminée"
}

# Générer un rapport de sécurité
generate_security_report() {
    local report_file="/tmp/rapport_securite_kext_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de sécurité des extensions de noyau Roundfleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "Version OS : $(sw_vers -productVersion)"
        echo "=============================================="
        echo ""
        
        echo "📊 Statistiques d'extensions :"
        echo "Total chargées : $(kextstat | tail -n +2 | wc -l)"
        echo "Extensions Apple : $(kextstat | grep -c com.apple)"
        echo "Tierces : $(kextstat | grep -v com.apple | tail -n +2 | wc -l)"
        echo ""
        
        echo "🔍 Extensions tierces :"
        kextstat | grep -v com.apple | tail -n +2
        echo ""
        
        echo "🔒 Recommandations de sécurité :"
        local third_party_count=$(kextstat | grep -v com.apple | tail -n +2 | wc -l)
        if [[ $third_party_count -eq 0 ]]; then
            echo "✅ Aucune extension tierce détectée"
        else
            echo "⚠️  Examiner toutes les extensions tierces pour leur nécessité"
            echo "⚠️  Vérifier les signatures numériques et les sources"
            echo "⚠️  Considérer la suppression des extensions inutilisées"
        fi
        
    } > "$report_file"
    
    echo "📋 Rapport de sécurité généré : $report_file"
}

# Surveillance sécuritaire principale
main() {
    assess_kext_security
    generate_security_report
}

# Exécuter la surveillance
main "$@"

Surveillance des changements d'extension

#!/bin/bash

# Surveiller les changements d'extensions de noyau dans le temps
BASELINE_FILE="/var/lib/roundfleet/kext_baseline.txt"
CHANGES_LOG="/var/log/roundfleet_kext_changes.log"

# Créer les répertoires si nécessaire
sudo mkdir -p "$(dirname "$BASELINE_FILE")"
sudo mkdir -p "$(dirname "$CHANGES_LOG")"

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

# Créer ou mettre à jour la référence
create_baseline() {
    echo "📋 Création de la référence des extensions de noyau..."
    kextstat > "$BASELINE_FILE"
    log_change "Référence créée avec $(kextstat | tail -n +2 | wc -l) extensions"
}

# Vérifier les changements
check_changes() {
    if [[ ! -f "$BASELINE_FILE" ]]; then
        echo "⚠️  Aucune référence trouvée, en créer une..."
        create_baseline
        return
    fi
    
    local current_file="/tmp/kext_current_$(date +%Y%m%d_%H%M%S).txt"
    kextstat > "$current_file"
    
    # Comparer avec la référence
    local changes=$(diff "$BASELINE_FILE" "$current_file")
    
    if [[ -n "$changes" ]]; then
        log_change "Changements d'extensions de noyau détectés :"
        echo "$changes" | sudo tee -a "$CHANGES_LOG"
        
        # Analyser les changements
        local added=$(echo "$changes" | grep "^>" | wc -l)
        local removed=$(echo "$changes" | grep "^<" | wc -l)
        
        log_change "Extensions ajoutées : $added"
        log_change "Extensions supprimées : $removed"
        
        echo "🔄 Changements détectés - vérifiez $CHANGES_LOG pour les détails"
    else
        echo "✅ Aucun changement détecté depuis la référence"
    fi
    
    # Nettoyer
    rm -f "$current_file"
}

# Utilisation
case "${1:-check}" in
    "baseline")
        create_baseline
        ;;
    "check")
        check_changes
        ;;
    *)
        echo "Usage : $0 [baseline|check]"
        ;;
esac

Référence des extensions de noyau

Catégories d'extensions communes

Catégorie	Motif d'ID de bundle	Objectif
Audio	com.apple.driver.*HDA*	Pilotes matériel audio
Graphiques	com.apple.driver.*Graphics*	Pilotes d'affichage et GPU
Réseau	com.apple.driver.*Ethernet*	Pilotes d'interface réseau
USB	com.apple.driver.*USB*	Support de périphériques USB
Stockage	com.apple.driver.*Storage*	Pilotes de disque et stockage
Bluetooth	com.apple.driver.*Bluetooth*	Connectivité Bluetooth
Sécurité	com.apple.security.*	Frameworks de sécurité

Référence des commandes

# Lister toutes les extensions chargées
kextstat

# Lister avec des colonnes spécifiques
kextstat -l

# Trouver une extension par ID de bundle
kextfind -b com.apple.driver.AppleHDA

# Charger une extension
sudo kextload /chemin/vers/extension.kext

# Décharger par chemin
sudo kextunload /chemin/vers/extension.kext

# Décharger par ID de bundle
sudo kextunload -b com.example.driver

# Tester une extension sans la charger
kextutil -t /chemin/vers/extension.kext

# Afficher les dépendances d'extension
kextutil -d /chemin/vers/extension.kext

Notes de sécurité importantes

• Extensions Apple - Généralement sûres mais le déchargement peut causer de l'instabilité
• Extensions tierces - Nécessitent une évaluation sécuritaire minutieuse
• Extensions non signées - Risque de sécurité potentiel, auditer soigneusement
• Privilèges administrateur - Le chargement/déchargement nécessite sudo
• Impact système - Les changements d'extensions peuvent affecter la stabilité du système
• Mode de récupération - Peut être nécessaire si le système devient instable

Dépannage

Problèmes courants

L'extension ne se charge pas :

# Vérifier la validité de l'extension
kextutil -t /chemin/vers/extension.kext

# Vérifier les journaux système
log show --predicate 'subsystem == "com.apple.kernel"' --last 1h

L'extension ne se décharge pas :

# Vérifier les dépendances
kextutil -d /chemin/vers/extension.kext

# Forcer le déchargement (dangereux)
sudo kextunload -b bundle.id -f

Permission refusée :

# Assurer les privilèges admin
sudo -v

# Vérifier la protection d'intégrité système
csrutil status

N'oubliez pas de tester les opérations d'extensions de noyau sur des appareils individuels avant de les déployer dans votre environnement Roundfleet, car une gestion inappropriée des kext peut causer une instabilité du système.

Installer des Packages Non Signés sur macOS

Apprenez à installer des packages non signés sur Mac à l'aide de scripts. Les packages non signés sont des logiciels qui n'ont pas été signés numériquement par le développeur, souvent nécessaires pour des outils de développement spécialisés et logiciels open-source.

Script d'Installation Basique

Installer un package non signé depuis une URL :

#!/bin/bash

# Télécharger et installer un package non signé
PACKAGE_NAME="votre_package"
DOWNLOAD_URL="https://example.com/package.pkg"

# Télécharger le package vers le répertoire temporaire
curl -o /tmp/${PACKAGE_NAME}.pkg "${DOWNLOAD_URL}"

# Installer le package avec privilèges admin
sudo installer -verboseR -pkg /tmp/${PACKAGE_NAME}.pkg -target /

# Nettoyer
rm /tmp/${PACKAGE_NAME}.pkg

echo "Installation du package terminée"

Installation Avancée avec Validation

Script avec gestion d'erreur et validation :

#!/bin/bash

PACKAGE_NAME="votre_package"
DOWNLOAD_URL="https://example.com/package.pkg"
TEMP_PATH="/tmp/${PACKAGE_NAME}.pkg"

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

# Télécharger le package
log_message "Téléchargement du package depuis ${DOWNLOAD_URL}"
if curl -f -o "${TEMP_PATH}" "${DOWNLOAD_URL}"; then
    log_message "Téléchargement réussi"
else
    log_message "Échec du téléchargement"
    exit 1
fi

# Vérifier que le fichier existe et contient des données
if [[ -f "${TEMP_PATH}" && -s "${TEMP_PATH}" ]]; then
    log_message "Fichier package validé"
else
    log_message "Échec de validation du fichier package"
    exit 1
fi

# Installer le package
log_message "Installation du package"
if sudo installer -verboseR -pkg "${TEMP_PATH}" -target /; then
    log_message "Installation terminée avec succès"
else
    log_message "Échec de l'installation"
    exit 1
fi

# Nettoyer
rm "${TEMP_PATH}"
log_message "Nettoyage terminé"

Utilisation avec Roundfleet

1. Remplacez PACKAGE_NAME par le nom de votre package
2. Remplacez DOWNLOAD_URL par l'URL réelle du package
3. Déployez le script via l'exécution de script distant Roundfleet
4. Surveillez le progrès d'installation dans l'historique des actions

Considérations de Sécurité

Attention : L'installation de packages non signés peut compromettre la sécurité car leur authenticité ne peut être vérifiée. N'installez que des packages de sources fiables.

• Vérifiez les sources de packages avant déploiement
• Testez d'abord sur un ensemble limité d'appareils
• Surveillez les alertes de sécurité post-installation

Dépannage

L'installation échoue : Vérifiez la connectivité réseau et l'accessibilité de l'URL Permission refusée : Assurez-vous que le script s'exécute avec privilèges administrateur Package corrompu : Vérifiez que le téléchargement s'est terminé avec succès

---

Note : Validez toujours l'exécution du script sur des systèmes de test avant le déploiement en masse. Roundfleet n'est pas responsable des dommages système causés par l'installation de packages non signés.

Installer la dernière version de Firefox sur les appareils macOS

Ce guide complet démontre comment installer et gérer la dernière version de Firefox sur les appareils macOS pour le déploiement d'entreprise, les mises à jour automatiques et la gestion de configuration.

Aperçu

Firefox privilégie la confidentialité des utilisateurs, la sécurité et fournit de nombreuses options de personnalisation pour la navigation selon les préférences organisationnelles, ce qui le rend idéal pour l'utilisation en entreprise.

Avantages clés

• Axé sur la confidentialité : Protection renforcée de la confidentialité et des données utilisateur
• Sécurité : Mises à jour de sécurité régulières et protection de niveau entreprise
• Personnalisation : Options de configuration étendues pour les politiques d'entreprise
• Multiplateforme : Expérience cohérente sur différents systèmes d'exploitation
• Open source : Développement transparent et audit de sécurité

Installation de base de Firefox

Script d'installation Firefox simple

#!/bin/bash

# Script d'installation basique de Firefox
# Utilisation : ./installer_firefox.sh

installer_firefox() {
    echo "Démarrage du processus d'installation de Firefox..."
    
    # Vérifier si Firefox est déjà installé
    if [ -d "/Applications/Firefox.app" ]; then
        echo "Firefox est déjà installé."
        exit 0
    fi
    
    # URL de téléchargement Firefox
    firefox_url="https://download.mozilla.org/?product=firefox-latest&os=osx&lang=fr"
    repertoire_telechargement="$HOME/Applications"
    
    # Créer le répertoire de téléchargement
    mkdir -p "$repertoire_telechargement"
    
    echo "Téléchargement de Firefox..."
    curl -L -o "$repertoire_telechargement/Firefox.dmg" "$firefox_url"
    
    echo "Montage de l'image disque Firefox..."
    hdiutil attach "$repertoire_telechargement/Firefox.dmg"
    
    echo "Installation de Firefox..."
    cp -r "/Volumes/Firefox/Firefox.app" "/Applications/"
    
    echo "Démontage de l'image disque Firefox..."
    hdiutil detach "/Volumes/Firefox"
    
    echo "Nettoyage..."
    rm "$repertoire_telechargement/Firefox.dmg"
    
    echo "Installation de Firefox terminée."
}

# Exécuter l'installation
installer_firefox

Installation Firefox avancée avec validation

#!/bin/bash

# Installation Firefox avancée avec validation et journalisation
# Utilisation : ./installation_firefox_avancee.sh

installation_firefox_avancee() {
    local fichier_log="/var/log/roundfleet_firefox_install.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local repertoire_telechargement="/tmp/roundfleet_firefox"
    
    # Créer le répertoire de log
    mkdir -p /var/log
    mkdir -p "$repertoire_telechargement"
    
    echo "[$timestamp] Installation Firefox avancée démarrée" >> "$fichier_log"
    
    # Vérifier si s'exécute en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Attention : Exécution en tant qu'utilisateur. Certaines fonctionnalités peuvent être limitées."
        echo "[$timestamp] Exécution en tant qu'utilisateur, pas root" >> "$fichier_log"
    fi
    
    # Vérifier l'installation Firefox existante
    verifier_firefox_existant
    
    # Télécharger et installer Firefox
    telecharger_firefox
    installer_application_firefox
    verifier_installation
    nettoyer_installation
    
    echo "[$timestamp] Installation Firefox avancée terminée" >> "$fichier_log"
}

verifier_firefox_existant() {
    echo "Vérification de l'installation Firefox existante..."
    
    if [ -d "/Applications/Firefox.app" ]; then
        local version_actuelle=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        
        echo "Firefox est déjà installé (Version : $version_actuelle)"
        echo "[$timestamp] Firefox déjà installé - Version : $version_actuelle" >> "$fichier_log"
        
        read -p "Voulez-vous mettre à jour vers la dernière version ? (o/N) : " choix_mise_a_jour
        if [ "$choix_mise_a_jour" != "o" ] && [ "$choix_mise_a_jour" != "O" ]; then
            echo "Installation annulée."
            exit 0
        fi
        
        echo "Poursuite avec la mise à jour de Firefox..."
    else
        echo "Aucune installation Firefox existante trouvée."
        echo "[$timestamp] Aucune installation Firefox existante trouvée" >> "$fichier_log"
    fi
}

telecharger_firefox() {
    echo "Téléchargement de la dernière version de Firefox..."
    
    local firefox_url="https://download.mozilla.org/?product=firefox-latest&os=osx&lang=fr"
    local firefox_dmg="$repertoire_telechargement/Firefox.dmg"
    
    # Vérifier la connectivité réseau
    if ! ping -c 1 download.mozilla.org >/dev/null 2>&1; then
        echo "Erreur : Pas de connectivité réseau vers les serveurs Mozilla"
        echo "[$timestamp] Échec de la vérification de connectivité réseau" >> "$fichier_log"
        exit 1
    fi
    
    # Télécharger Firefox avec barre de progression et gestion d'erreurs
    if curl -L --progress-bar -o "$firefox_dmg" "$firefox_url"; then
        echo "Téléchargement de Firefox terminé avec succès"
        echo "[$timestamp] Téléchargement de Firefox terminé" >> "$fichier_log"
    else
        echo "Erreur : Échec du téléchargement de Firefox"
        echo "[$timestamp] Échec du téléchargement de Firefox" >> "$fichier_log"
        exit 1
    fi
    
    # Vérifier le téléchargement
    if [ -f "$firefox_dmg" ]; then
        local taille_fichier=$(stat -f%z "$firefox_dmg" 2>/dev/null || echo "0")
        echo "Taille du fichier téléchargé : $taille_fichier octets"
        echo "[$timestamp] Taille du fichier téléchargé : $taille_fichier octets" >> "$fichier_log"
        
        if [ "$taille_fichier" -lt 50000000 ]; then  # Moins de 50MB indique un problème potentiel
            echo "Attention : Le fichier téléchargé semble trop petit. Problème de téléchargement possible."
            echo "[$timestamp] Avertissement taille du fichier téléchargé" >> "$fichier_log"
        fi
    else
        echo "Erreur : Fichier de téléchargement non trouvé"
        echo "[$timestamp] Fichier de téléchargement non trouvé" >> "$fichier_log"
        exit 1
    fi
}

installer_application_firefox() {
    echo "Installation de l'application Firefox..."
    
    local firefox_dmg="$repertoire_telechargement/Firefox.dmg"
    local point_montage="/tmp/firefox_mount"
    
    # Créer le point de montage
    mkdir -p "$point_montage"
    
    # Monter le fichier DMG
    if hdiutil attach "$firefox_dmg" -mountpoint "$point_montage" -quiet; then
        echo "Image disque Firefox montée avec succès"
        echo "[$timestamp] Image disque Firefox montée" >> "$fichier_log"
    else
        echo "Erreur : Échec du montage de l'image disque Firefox"
        echo "[$timestamp] Échec du montage de l'image disque Firefox" >> "$fichier_log"
        exit 1
    fi
    
    # Copier l'application Firefox
    if [ -d "$point_montage/Firefox.app" ]; then
        echo "Copie de l'application Firefox vers /Applications..."
        
        # Supprimer l'installation existante si présente
        if [ -d "/Applications/Firefox.app" ]; then
            rm -rf "/Applications/Firefox.app"
        fi
        
        # Copier la nouvelle application Firefox
        if cp -R "$point_montage/Firefox.app" "/Applications/"; then
            echo "Application Firefox copiée avec succès"
            echo "[$timestamp] Application Firefox copiée avec succès" >> "$fichier_log"
        else
            echo "Erreur : Échec de la copie de l'application Firefox"
            echo "[$timestamp] Échec de la copie de l'application Firefox" >> "$fichier_log"
            hdiutil detach "$point_montage" -quiet
            exit 1
        fi
    else
        echo "Erreur : Firefox.app non trouvé dans l'image disque"
        echo "[$timestamp] Firefox.app non trouvé dans l'image disque" >> "$fichier_log"
        hdiutil detach "$point_montage" -quiet
        exit 1
    fi
    
    # Démonter l'image disque
    if hdiutil detach "$point_montage" -quiet; then
        echo "Image disque Firefox démontée avec succès"
        echo "[$timestamp] Image disque Firefox démontée" >> "$fichier_log"
    else
        echo "Attention : Échec du démontage de l'image disque Firefox"
        echo "[$timestamp] Échec du démontage de l'image disque Firefox" >> "$fichier_log"
    fi
}

verifier_installation() {
    echo "Vérification de l'installation Firefox..."
    
    if [ -d "/Applications/Firefox.app" ]; then
        local version_installee=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        local bundle_id=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        
        echo "Installation Firefox vérifiée :"
        echo "  Version : $version_installee"
        echo "  Bundle ID : $bundle_id"
        echo "  Emplacement : /Applications/Firefox.app"
        
        echo "[$timestamp] Installation Firefox vérifiée - Version : $version_installee" >> "$fichier_log"
        
        # Tester le lancement de Firefox (optionnel)
        echo "Test de lancement de Firefox..."
        if timeout 10 /Applications/Firefox.app/Contents/MacOS/firefox --version >/dev/null 2>&1; then
            echo "Test de lancement de Firefox réussi"
            echo "[$timestamp] Test de lancement de Firefox réussi" >> "$fichier_log"
        else
            echo "Attention : Test de lancement de Firefox échoué ou timeout"
            echo "[$timestamp] Test de lancement de Firefox échoué" >> "$fichier_log"
        fi
    else
        echo "Erreur : Vérification de l'installation Firefox échouée"
        echo "[$timestamp] Vérification de l'installation Firefox échouée" >> "$fichier_log"
        exit 1
    fi
}

nettoyer_installation() {
    echo "Nettoyage des fichiers d'installation..."
    
    if [ -d "$repertoire_telechargement" ]; then
        rm -rf "$repertoire_telechargement"
        echo "Fichiers d'installation nettoyés"
        echo "[$timestamp] Fichiers d'installation nettoyés" >> "$fichier_log"
    fi
}

# Exécuter l'installation avancée
installation_firefox_avancee

Gestion Firefox d'entreprise

Gestionnaire de déploiement Firefox d'entreprise

#!/bin/bash

# Gestionnaire de déploiement Firefox d'entreprise
# Utilisation : ./gestionnaire_firefox_entreprise.sh

gestionnaire_firefox_entreprise() {
    local fichier_config="/etc/roundfleet/firefox_config.conf"
    local fichier_log="/var/log/roundfleet_firefox_entreprise.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Vérifier si s'exécute en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root pour le déploiement d'entreprise"
        exit 1
    fi
    
    # Créer le répertoire de configuration
    mkdir -p /etc/roundfleet
    
    # Charger ou créer la configuration
    if [ -f "$fichier_config" ]; then
        source "$fichier_config"
    else
        creer_config_entreprise
        source "$fichier_config"
    fi
    
    echo "[$timestamp] Gestionnaire Firefox d'entreprise démarré" >> "$fichier_log"
    
    # Afficher le menu d'entreprise
    afficher_menu_entreprise
}

creer_config_entreprise() {
    cat > "/etc/roundfleet/firefox_config.conf" << 'EOF'
# Configuration Firefox d'entreprise Roundfleet

# Paramètres de l'organisation
NOM_ORGANISATION="Organisation Roundfleet"
CONTACT_IT="[email protected]"

# Paramètres d'installation Firefox
LANGUE_FIREFOX="fr"
CANAL_FIREFOX="release"  # release, beta, nightly
MISE_A_JOUR_AUTO_ACTIVEE="true"
INSTALLATION_SILENCIEUSE="true"

# Politiques d'entreprise
ACTIVER_POLITIQUES_ENTREPRISE="true"
DESACTIVER_TELEMETRIE="true"
DESACTIVER_ETUDES="true"
BLOQUER_ABOUT_CONFIG="false"
URL_PAGE_ACCUEIL="https://www.roundfleet.com"

# Paramètres de sécurité
ACTIVER_POLITIQUES_SECURITE="true"
BLOQUER_TELECHARGEMENTS_DANGEREUX="true"
ACTIVER_NAVIGATION_SECURISEE="true"
DESACTIVER_OUTILS_DEVELOPPEUR="false"

# Journalisation et surveillance
ACTIVER_JOURNALISATION_DETAILLEE="true"
RETENTION_LOGS_JOURS="30"
ENVOYER_RAPPORTS_DEPLOIEMENT="true"
EOF
    
    echo "Configuration d'entreprise créée à /etc/roundfleet/firefox_config.conf"
}

afficher_menu_entreprise() {
    while true; do
        clear
        echo "======================================="
        echo "Gestionnaire Firefox d'entreprise Roundfleet"
        echo "======================================="
        echo ""
        echo "Organisation : $NOM_ORGANISATION"
        echo "Contact : $CONTACT_IT"
        echo ""
        echo "Actions disponibles :"
        echo "1. Installer/Mettre à jour Firefox"
        echo "2. Configurer les politiques d'entreprise"
        echo "3. Vérifier le statut Firefox"
        echo "4. Générer un rapport de déploiement"
        echo "5. Voir la configuration"
        echo "6. Quitter"
        echo ""
        read -p "Sélectionnez une option (1-6) : " choix
        
        case $choix in
            1)
                installer_mettre_a_jour_firefox
                ;;
            2)
                configurer_politiques_entreprise
                ;;
            3)
                verifier_statut_firefox
                ;;
            4)
                generer_rapport_deploiement
                ;;
            5)
                voir_configuration
                ;;
            6)
                echo "Fermeture du gestionnaire Firefox d'entreprise."
                exit 0
                ;;
            *)
                echo "Option invalide. Veuillez réessayer."
                ;;
        esac
        
        echo ""
        read -p "Appuyez sur Entrée pour continuer..."
    done
}

installer_mettre_a_jour_firefox() {
    echo "======================================="
    echo "Installer/Mettre à jour Firefox"
    echo "======================================="
    
    local version_actuelle=""
    if [ -d "/Applications/Firefox.app" ]; then
        version_actuelle=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        echo "Version actuelle de Firefox : $version_actuelle"
    else
        echo "Firefox n'est pas actuellement installé"
    fi
    
    echo ""
    echo "Options d'installation :"
    echo "1. Installer/Mettre à jour vers la dernière version stable"
    echo "2. Installer/Mettre à jour vers la dernière version beta"
    echo "3. Annuler"
    echo ""
    read -p "Sélectionnez l'option d'installation (1-3) : " choix_installation
    
    case $choix_installation in
        1)
            installer_version_firefox "release"
            ;;
        2)
            installer_version_firefox "beta"
            ;;
        3)
            echo "Installation annulée."
            ;;
        *)
            echo "Option invalide."
            ;;
    esac
}

installer_version_firefox() {
    local canal="$1"
    local repertoire_telechargement="/tmp/roundfleet_firefox_entreprise"
    
    echo "Installation de Firefox version $canal..."
    
    # Créer le répertoire de téléchargement
    mkdir -p "$repertoire_telechargement"
    
    # Déterminer l'URL de téléchargement basée sur le canal
    local firefox_url
    case $canal in
        "release")
            firefox_url="https://download.mozilla.org/?product=firefox-latest&os=osx&lang=$LANGUE_FIREFOX"
            ;;
        "beta")
            firefox_url="https://download.mozilla.org/?product=firefox-beta-latest&os=osx&lang=$LANGUE_FIREFOX"
            ;;
        *)
            echo "Erreur : Canal Firefox invalide"
            return 1
            ;;
    esac
    
    echo "Téléchargement de Firefox $canal..."
    local firefox_dmg="$repertoire_telechargement/Firefox-$canal.dmg"
    
    if curl -L --progress-bar -o "$firefox_dmg" "$firefox_url"; then
        echo "Téléchargement terminé avec succès"
        echo "[$timestamp] Téléchargement Firefox $canal terminé" >> "$fichier_log"
    else
        echo "Erreur : Échec du téléchargement"
        echo "[$timestamp] Échec du téléchargement Firefox $canal" >> "$fichier_log"
        return 1
    fi
    
    # Installer Firefox
    echo "Installation de Firefox..."
    local point_montage="/tmp/firefox_${canal}_mount"
    mkdir -p "$point_montage"
    
    if hdiutil attach "$firefox_dmg" -mountpoint "$point_montage" -quiet; then
        # Supprimer l'installation existante
        if [ -d "/Applications/Firefox.app" ]; then
            rm -rf "/Applications/Firefox.app"
        fi
        
        # Copier la nouvelle installation
        if cp -R "$point_montage/Firefox.app" "/Applications/"; then
            echo "Firefox $canal installé avec succès"
            echo "[$timestamp] Firefox $canal installé avec succès" >> "$fichier_log"
            
            # Appliquer les politiques d'entreprise si activées
            if [ "$ACTIVER_POLITIQUES_ENTREPRISE" = "true" ]; then
                appliquer_politiques_entreprise
            fi
        else
            echo "Erreur : Échec de l'installation"
            echo "[$timestamp] Échec de l'installation Firefox $canal" >> "$fichier_log"
        fi
        
        hdiutil detach "$point_montage" -quiet
    else
        echo "Erreur : Échec du montage de l'image disque"
        echo "[$timestamp] Échec du montage de l'image disque Firefox $canal" >> "$fichier_log"
    fi
    
    # Nettoyage
    rm -rf "$repertoire_telechargement"
}

configurer_politiques_entreprise() {
    echo "======================================="
    echo "Configurer les politiques d'entreprise"
    echo "======================================="
    
    local repertoire_politiques="/Applications/Firefox.app/Contents/Resources/distribution"
    local fichier_politiques="$repertoire_politiques/policies.json"
    
    echo "Création de la configuration des politiques d'entreprise..."
    
    # Créer le répertoire de distribution
    mkdir -p "$repertoire_politiques"
    
    # Générer policies.json
    cat > "$fichier_politiques" << EOF
{
  "policies": {
    "DisableTelemetry": $DESACTIVER_TELEMETRIE,
    "DisableFirefoxStudies": $DESACTIVER_ETUDES,
    "BlockAboutConfig": $BLOQUER_ABOUT_CONFIG,
    "Homepage": {
      "URL": "$URL_PAGE_ACCUEIL",
      "Locked": true
    },
    "DisableSystemAddonUpdate": true,
    "DisableAppUpdate": $([ "$MISE_A_JOUR_AUTO_ACTIVEE" = "true" ] && echo "false" || echo "true"),
    "NoDefaultBookmarks": true,
    "OfferToSaveLogins": false,
    "PasswordManagerEnabled": false,
    "DisableDeveloperTools": $DESACTIVER_OUTILS_DEVELOPPEUR,
    "DisablePrivateBrowsing": false,
    "DisableProfileImport": true,
    "DisableFeedbackCommands": true,
    "DisableFirefoxAccounts": false,
    "DisableForgetButton": true,
    "DisablePocket": true,
    "DisableSetDesktopBackground": true,
    "DisplayBookmarksToolbar": false,
    "DontCheckDefaultBrowser": true,
    "EnableTrackingProtection": {
      "Value": true,
      "Locked": true
    }
  }
}
EOF
    
    echo "Configuration des politiques d'entreprise créée"
    echo "[$timestamp] Politiques d'entreprise configurées" >> "$fichier_log"
    
    # Définir les permissions appropriées
    chmod 644 "$fichier_politiques"
    
    echo "Politiques d'entreprise appliquées à l'installation Firefox"
}

appliquer_politiques_entreprise() {
    echo "Application des politiques d'entreprise..."
    configurer_politiques_entreprise
}

verifier_statut_firefox() {
    echo "======================================="
    echo "Rapport de statut Firefox"
    echo "======================================="
    
    local nom_appareil=$(scutil --get ComputerName)
    local version_os=$(sw_vers -productVersion)
    
    echo "Appareil : $nom_appareil"
    echo "Version macOS : $version_os"
    echo "Horodatage : $(date)"
    echo ""
    
    if [ -d "/Applications/Firefox.app" ]; then
        local version_firefox=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        local bundle_id=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        
        echo "Statut Firefox : INSTALLÉ"
        echo "Version : $version_firefox"
        echo "Bundle ID : $bundle_id"
        echo "Chemin d'installation : /Applications/Firefox.app"
        
        # Vérifier si Firefox est en cours d'exécution
        if pgrep -x "firefox" >/dev/null; then
            echo "Statut du processus : EN COURS D'EXÉCUTION"
        else
            echo "Statut du processus : NON EN COURS D'EXÉCUTION"
        fi
        
        # Vérifier les politiques d'entreprise
        local fichier_politiques="/Applications/Firefox.app/Contents/Resources/distribution/policies.json"
        if [ -f "$fichier_politiques" ]; then
            echo "Politiques d'entreprise : CONFIGURÉES"
        else
            echo "Politiques d'entreprise : NON CONFIGURÉES"
        fi
        
    else
        echo "Statut Firefox : NON INSTALLÉ"
    fi
}

generer_rapport_deploiement() {
    echo "======================================="
    echo "Générer un rapport de déploiement"
    echo "======================================="
    
    local fichier_rapport="/tmp/firefox_rapport_deploiement_$(date +%Y%m%d_%H%M%S).txt"
    
    cat > "$fichier_rapport" << EOF
Rapport de déploiement Firefox Roundfleet
Généré : $(date)
Organisation : $NOM_ORGANISATION

Informations sur l'appareil :
  Nom de l'ordinateur : $(scutil --get ComputerName)
  Version macOS : $(sw_vers -productVersion)
  Modèle matériel : $(system_profiler SPHardwareDataType | grep "Model Name" | cut -d: -f2 | xargs)

Installation Firefox :
EOF
    
    if [ -d "/Applications/Firefox.app" ]; then
        local version_firefox=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        
        echo "  Statut : Installé" >> "$fichier_rapport"
        echo "  Version : $version_firefox" >> "$fichier_rapport"
        echo "  Date d'installation : $(stat -f "%Sm" /Applications/Firefox.app)" >> "$fichier_rapport"
        
        # Vérifier les politiques d'entreprise
        local fichier_politiques="/Applications/Firefox.app/Contents/Resources/distribution/policies.json"
        if [ -f "$fichier_politiques" ]; then
            echo "  Politiques d'entreprise : Configurées" >> "$fichier_rapport"
        else
            echo "  Politiques d'entreprise : Non configurées" >> "$fichier_rapport"
        fi
    else
        echo "  Statut : Non installé" >> "$fichier_rapport"
    fi
    
    cat >> "$fichier_rapport" << EOF

Configuration :
  Langue : $LANGUE_FIREFOX
  Canal : $CANAL_FIREFOX
  Mise à jour automatique : $MISE_A_JOUR_AUTO_ACTIVEE
  Politiques d'entreprise : $ACTIVER_POLITIQUES_ENTREPRISE

Contact : $CONTACT_IT
EOF
    
    echo "Rapport de déploiement généré : $fichier_rapport"
}

voir_configuration() {
    echo "======================================="
    echo "Configuration actuelle"
    echo "======================================="
    
    if [ -f "/etc/roundfleet/firefox_config.conf" ]; then
        cat "/etc/roundfleet/firefox_config.conf"
    else
        echo "Aucun fichier de configuration trouvé."
    fi
}

# Exécuter le gestionnaire d'entreprise
gestionnaire_firefox_entreprise

Système de mise à jour automatisé

Mise à jour automatique de Firefox

#!/bin/bash

# Système de mise à jour automatique de Firefox
# Utilisation : ./mise_a_jour_firefox_automatique.sh

mise_a_jour_firefox_automatique() {
    local fichier_config="/etc/roundfleet/firefox_mise_a_jour_auto.conf"
    local fichier_log="/var/log/roundfleet_firefox_mises_a_jour.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Vérifier si s'exécute en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root"
        exit 1
    fi
    
    # Créer la configuration si elle n'existe pas
    if [ ! -f "$fichier_config" ]; then
        creer_config_mise_a_jour
    fi
    
    source "$fichier_config"
    
    echo "[$timestamp] Mise à jour automatique de Firefox démarrée" >> "$fichier_log"
    
    # Vérifier si les mises à jour sont activées
    if [ "$ACTIVER_MISES_A_JOUR_AUTO" = "true" ]; then
        verifier_et_mettre_a_jour_firefox
    else
        echo "Les mises à jour automatiques sont désactivées"
        echo "[$timestamp] Les mises à jour automatiques sont désactivées" >> "$fichier_log"
    fi
}

creer_config_mise_a_jour() {
    mkdir -p /etc/roundfleet
    
    cat > "/etc/roundfleet/firefox_mise_a_jour_auto.conf" << 'EOF'
# Configuration de mise à jour automatique Firefox Roundfleet

# Paramètres de mise à jour
ACTIVER_MISES_A_JOUR_AUTO="true"
CANAL_MISE_A_JOUR="release"
INTERVALLE_VERIFICATION="quotidien"
HEURE_MISE_A_JOUR="02:00"

# Paramètres de sécurité
SAUVEGARDER_PROFILS="true"
RETENTION_SAUVEGARDE_JOURS="7"
NECESSITER_CONSENTEMENT_UTILISATEUR="false"
IGNORER_SI_EN_COURS="true"

# Paramètres de notification
ENVOYER_NOTIFICATIONS="true"
EMAIL_NOTIFICATION="[email protected]"
NOTIFIER_SUCCES="true"
NOTIFIER_ECHEC="true"

# Paramètres d'entreprise
MAINTENIR_POLITIQUES="true"
PRESERVER_PERSONNALISATIONS="true"
VERIFIER_INSTALLATION="true"
EOF
    
    echo "Configuration de mise à jour automatique créée à /etc/roundfleet/firefox_mise_a_jour_auto.conf"
}

verifier_et_mettre_a_jour_firefox() {
    echo "[$timestamp] Vérification des mises à jour Firefox" >> "$fichier_log"
    
    # Vérifier si Firefox est installé
    if [ ! -d "/Applications/Firefox.app" ]; then
        echo "Firefox n'est pas installé. Installation de la dernière version..."
        installer_firefox_derniere_version
        return
    fi
    
    # Obtenir la version actuelle
    local version_actuelle=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
    
    # Vérifier si Firefox est en cours d'exécution et ignorer si configuré
    if [ "$IGNORER_SI_EN_COURS" = "true" ] && pgrep -x "firefox" >/dev/null; then
        echo "Firefox est actuellement en cours d'exécution. Mise à jour ignorée."
        echo "[$timestamp] Firefox en cours d'exécution - mise à jour ignorée" >> "$fichier_log"
        return
    fi
    
    # Créer une sauvegarde si activé
    if [ "$SAUVEGARDER_PROFILS" = "true" ]; then
        sauvegarder_profils_firefox
    fi
    
    # Télécharger et vérifier la dernière version
    local repertoire_telechargement="/tmp/roundfleet_firefox_mise_a_jour"
    mkdir -p "$repertoire_telechargement"
    
    local firefox_url="https://download.mozilla.org/?product=firefox-latest&os=osx&lang=fr"
    local firefox_dmg="$repertoire_telechargement/Firefox-derniere.dmg"
    
    echo "Téléchargement de la dernière version de Firefox pour comparaison..."
    if curl -L -s -o "$firefox_dmg" "$firefox_url"; then
        # Monter et vérifier la version
        local point_montage="/tmp/firefox_mise_a_jour_mount"
        mkdir -p "$point_montage"
        
        if hdiutil attach "$firefox_dmg" -mountpoint "$point_montage" -quiet; then
            local derniere_version=$(defaults read "$point_montage/Firefox.app/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
            
            echo "Version actuelle : $version_actuelle"
            echo "Dernière version : $derniere_version"
            
            if [ "$version_actuelle" != "$derniere_version" ]; then
                echo "Mise à jour disponible. Mise à jour de Firefox..."
                echo "[$timestamp] Mise à jour disponible - Actuelle : $version_actuelle, Dernière : $derniere_version" >> "$fichier_log"
                
                # Effectuer la mise à jour
                mettre_a_jour_installation_firefox "$point_montage"
                
                # Vérifier la mise à jour
                if verifier_mise_a_jour_firefox "$derniere_version"; then
                    echo "Firefox mis à jour avec succès vers la version $derniere_version"
                    echo "[$timestamp] Firefox mis à jour avec succès vers la version $derniere_version" >> "$fichier_log"
                    
                    if [ "$ENVOYER_NOTIFICATIONS" = "true" ] && [ "$NOTIFIER_SUCCES" = "true" ]; then
                        envoyer_notification_mise_a_jour "succes" "$version_actuelle" "$derniere_version"
                    fi
                else
                    echo "Échec de la vérification de la mise à jour Firefox"
                    echo "[$timestamp] Échec de la vérification de la mise à jour Firefox" >> "$fichier_log"
                    
                    if [ "$ENVOYER_NOTIFICATIONS" = "true" ] && [ "$NOTIFIER_ECHEC" = "true" ]; then
                        envoyer_notification_mise_a_jour "echec" "$version_actuelle" "$derniere_version"
                    fi
                fi
            else
                echo "Firefox est déjà à jour (version $version_actuelle)"
                echo "[$timestamp] Firefox est déjà à jour (version $version_actuelle)" >> "$fichier_log"
            fi
            
            hdiutil detach "$point_montage" -quiet
        else
            echo "Échec du montage de l'image disque Firefox"
            echo "[$timestamp] Échec du montage de l'image disque Firefox pour vérification de mise à jour" >> "$fichier_log"
        fi
    else
        echo "Échec du téléchargement de Firefox pour vérification de version"
        echo "[$timestamp] Échec du téléchargement de Firefox pour vérification de version" >> "$fichier_log"
    fi
    
    # Nettoyage
    rm -rf "$repertoire_telechargement"
}

installer_firefox_derniere_version() {
    echo "Installation de la dernière version de Firefox..."
    
    local repertoire_telechargement="/tmp/roundfleet_firefox_installation"
    mkdir -p "$repertoire_telechargement"
    
    local firefox_url="https://download.mozilla.org/?product=firefox-latest&os=osx&lang=fr"
    local firefox_dmg="$repertoire_telechargement/Firefox.dmg"
    
    if curl -L --progress-bar -o "$firefox_dmg" "$firefox_url"; then
        local point_montage="/tmp/firefox_installation_mount"
        mkdir -p "$point_montage"
        
        if hdiutil attach "$firefox_dmg" -mountpoint "$point_montage" -quiet; then
            if cp -R "$point_montage/Firefox.app" "/Applications/"; then
                local version_installee=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
                echo "Firefox installé avec succès (version $version_installee)"
                echo "[$timestamp] Firefox installé avec succès (version $version_installee)" >> "$fichier_log"
                
                # Appliquer les politiques d'entreprise si nécessaire
                if [ "$MAINTENIR_POLITIQUES" = "true" ]; then
                    appliquer_politiques_entreprise
                fi
            else
                echo "Échec de l'installation de Firefox"
                echo "[$timestamp] Échec de l'installation de Firefox" >> "$fichier_log"
            fi
            
            hdiutil detach "$point_montage" -quiet
        else
            echo "Échec du montage de l'image disque Firefox"
            echo "[$timestamp] Échec du montage de l'image disque Firefox pour installation" >> "$fichier_log"
        fi
    else
        echo "Échec du téléchargement de Firefox"
        echo "[$timestamp] Échec du téléchargement de Firefox pour installation" >> "$fichier_log"
    fi
    
    rm -rf "$repertoire_telechargement"
}

mettre_a_jour_installation_firefox() {
    local point_montage="$1"
    
    echo "Mise à jour de l'installation Firefox..."
    
    # Supprimer l'ancienne installation
    if [ -d "/Applications/Firefox.app" ]; then
        rm -rf "/Applications/Firefox.app"
    fi
    
    # Installer la nouvelle version
    if cp -R "$point_montage/Firefox.app" "/Applications/"; then
        echo "Application Firefox mise à jour avec succès"
        
        # Restaurer les politiques d'entreprise si activé
        if [ "$MAINTENIR_POLITIQUES" = "true" ]; then
            appliquer_politiques_entreprise
        fi
        
        return 0
    else
        echo "Échec de la mise à jour de l'application Firefox"
        return 1
    fi
}

verifier_mise_a_jour_firefox() {
    local version_attendue="$1"
    
    if [ -d "/Applications/Firefox.app" ]; then
        local version_reelle=$(defaults read /Applications/Firefox.app/Contents/Info.plist CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        
        if [ "$version_reelle" = "$version_attendue" ]; then
            return 0
        else
            echo "Discordance de version - Attendue : $version_attendue, Réelle : $version_reelle"
            return 1
        fi
    else
        echo "Application Firefox non trouvée après mise à jour"
        return 1
    fi
}

sauvegarder_profils_firefox() {
    echo "Création d'une sauvegarde des profils Firefox..."
    
    local repertoire_profils="$HOME/Library/Application Support/Firefox"
    local repertoire_sauvegarde="/var/backups/roundfleet/firefox_profils"
    local timestamp_sauvegarde=$(date +%Y%m%d_%H%M%S)
    
    mkdir -p "$repertoire_sauvegarde"
    
    if [ -d "$repertoire_profils" ]; then
        if tar -czf "$repertoire_sauvegarde/firefox_profils_sauvegarde_$timestamp_sauvegarde.tar.gz" -C "$HOME/Library/Application Support" "Firefox"; then
            echo "Profils Firefox sauvegardés avec succès"
            echo "[$timestamp] Profils Firefox sauvegardés" >> "$fichier_log"
            
            # Nettoyer les anciennes sauvegardes
            find "$repertoire_sauvegarde" -name "firefox_profils_sauvegarde_*.tar.gz" -mtime +$RETENTION_SAUVEGARDE_JOURS -delete
        else
            echo "Échec de la sauvegarde des profils Firefox"
            echo "[$timestamp] Échec de la sauvegarde des profils Firefox" >> "$fichier_log"
        fi
    else
        echo "Répertoire des profils Firefox non trouvé"
    fi
}

envoyer_notification_mise_a_jour() {
    local statut="$1"
    local ancienne_version="$2"
    local nouvelle_version="$3"
    
    local titre_notification="Mise à jour Firefox Roundfleet"
    local message_notification
    
    case $statut in
        "succes")
            message_notification="Firefox mis à jour avec succès de $ancienne_version vers $nouvelle_version"
            ;;
        "echec")
            message_notification="Échec de la mise à jour Firefox - tentative de mise à jour de $ancienne_version vers $nouvelle_version"
            ;;
        *)
            message_notification="Statut de mise à jour Firefox : $statut"
            ;;
    esac
    
    # Utiliser osascript pour afficher la notification
    osascript -e "display notification \"$message_notification\" with title \"$titre_notification\""
    
    echo "[$timestamp] Notification de mise à jour envoyée - Statut : $statut" >> "$fichier_log"
}

appliquer_politiques_entreprise() {
    echo "Application des politiques d'entreprise..."
    # Cela appellerait la fonction de configuration des politiques d'entreprise
}

# Exécuter la mise à jour automatique
mise_a_jour_firefox_automatique

Dépannage et bonnes pratiques

Problèmes courants et solutions

1. Connectivité réseau : S'assurer d'une connexion internet stable pour les téléchargements
2. Permissions : Exécuter les scripts d'installation avec les privilèges appropriés
3. Espace disque : Vérifier l'espace disque suffisant avant l'installation
4. Processus existants : Vérifier les processus Firefox en cours avant les mises à jour
5. Politiques d'entreprise : Valider les configurations de politiques après déploiement

Bonnes pratiques

• Tester les déploiements : Toujours tester dans des environnements contrôlés d'abord
• Sauvegarder les profils : Créer des sauvegardes avant les mises à jour majeures
• Surveiller les installations : Utiliser la journalisation et la surveillance pour les déploiements d'entreprise
• Contrôle de version : Suivre les versions de Firefox dans votre flotte
• Mises à jour de sécurité : Prioriser les mises à jour et correctifs de sécurité

Conclusion

Le déploiement et la gestion de Firefox sur macOS nécessitent une planification et une exécution minutieuses. Ces scripts fournissent des solutions complètes pour installer, mettre à jour et gérer Firefox à travers les flottes Mac. Des installations de base à l'automatisation de niveau entreprise, ces outils assurent des déploiements Firefox cohérents et sécurisés tout en maintenant les politiques organisationnelles et les préférences utilisateur.