Guide

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

Avis important

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

← Tous les articles

Gestion des Mots de Passe d'Entreprise sur macOS

Implémentez une gestion complète des mots de passe et un contrôle d'authentification sur vos appareils Roundfleet en utilisant des outils avancés de services d'annuaire et d'administration système. Ce tutoriel couvre l'effacement de mots de passe, l'application de politiques et la gestion d'authentification d'entreprise.

Comprendre la Gestion des Mots de Passe macOS

macOS fournit plusieurs outils pour la gestion des mots de passe :

  • dscl - Utilitaire en ligne de commande des Services d'Annuaire pour la gestion utilisateur
  • sysadminctl - Outil de contrôle d'administrateur système pour les opérations utilisateur
  • Services d'Annuaire - Framework central d'authentification et d'autorisation
  • Framework de Sécurité - Mécanismes avancés de politique et d'application de mots de passe

Opérations de Base sur les Mots de Passe

Effacer le Mot de Passe Utilisateur (Méthode de Base)

#!/bin/bash

# Effacement de base du mot de passe avec dscl
clear_user_password_dscl() {
    local username="$1"
    local current_password="$2"
    
    echo "=== Effacement du Mot de Passe pour l'Utilisateur : $username ==="
    
    # Valider les paramètres
    if [[ -z "$username" || -z "$current_password" ]]; then
        echo "❌ Usage : clear_user_password_dscl <nom_utilisateur> <mot_de_passe_actuel>"
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! dscl . -read "/Users/$username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Effacer le mot de passe avec dscl
    echo "Effacement du mot de passe pour l'utilisateur : $username"
    if dscl . passwd "/Users/$username" "$current_password" ""; then
        echo "✅ Mot de passe effacé avec succès pour l'utilisateur : $username"
        echo "ℹ️  L'utilisateur peut maintenant se connecter en appuyant sur Entrée sans mot de passe"
    else
        echo "❌ Échec d'effacement du mot de passe pour l'utilisateur : $username"
        echo "   Vérifiez que le mot de passe actuel est correct"
        return 1
    fi
}

# Usage : clear_user_password_dscl "jean.dupont" "motdepasseactuel123"

Effacer le Mot de Passe avec sysadminctl

#!/bin/bash

# Effacement avancé du mot de passe avec sysadminctl
clear_user_password_sysadminctl() {
    local target_username="$1"
    local admin_username="$2"
    local admin_password="$3"
    
    echo "=== Effacement du Mot de Passe avec sysadminctl ==="
    echo "Utilisateur cible : $target_username"
    echo "Utilisateur admin : $admin_username"
    
    # Valider les paramètres
    if [[ -z "$target_username" || -z "$admin_username" || -z "$admin_password" ]]; then
        echo "❌ Usage : clear_user_password_sysadminctl <utilisateur_cible> <utilisateur_admin> <mot_de_passe_admin>"
        return 1
    fi
    
    # Vérifier si l'utilisateur cible existe
    if ! dscl . -read "/Users/$target_username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur cible '$target_username' n'existe pas"
        return 1
    fi
    
    # Vérifier si l'utilisateur admin existe et a les privilèges admin
    if ! dscl . -read "/Users/$admin_username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur admin '$admin_username' n'existe pas"
        return 1
    fi
    
    # Effacer le mot de passe avec sysadminctl
    echo "Effacement du mot de passe pour l'utilisateur : $target_username"
    if sysadminctl -resetPasswordFor "$target_username" -newPassword "" -adminUser "$admin_username" -adminPassword "$admin_password"; then
        echo "✅ Mot de passe effacé avec succès pour l'utilisateur : $target_username"
        echo "ℹ️  L'utilisateur peut maintenant se connecter sans saisir de mot de passe"
    else
        echo "❌ Échec d'effacement du mot de passe pour l'utilisateur : $target_username"
        echo "   Vérifiez les identifiants admin et les permissions utilisateur"
        return 1
    fi
}

# Usage : clear_user_password_sysadminctl "marie.martin" "admin" "motdepasseadmin123"

Gestion Avancée des Mots de Passe

Vérifier le Statut du Mot de Passe

#!/bin/bash

# Vérifier le statut du mot de passe et de l'authentification utilisateur
check_password_status() {
    local username="$1"
    
    echo "=== Vérification du Statut de Mot de Passe pour l'Utilisateur : $username ==="
    
    if [[ -z "$username" ]]; then
        echo "❌ Usage : check_password_status <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! dscl . -read "/Users/$username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Obtenir les informations utilisateur
    echo "Informations Utilisateur :"
    echo "Nom Réel : $(dscl . -read "/Users/$username" RealName | cut -d' ' -f2- || echo 'Non défini')"
    echo "UID : $(dscl . -read "/Users/$username" UniqueID | awk '{print $2}')"
    echo "ID Groupe Principal : $(dscl . -read "/Users/$username" PrimaryGroupID | awk '{print $2}')"
    echo "Répertoire Personnel : $(dscl . -read "/Users/$username" NFSHomeDirectory | cut -d' ' -f2-)"
    echo "Shell : $(dscl . -read "/Users/$username" UserShell | cut -d' ' -f2-)"
    
    # Vérifier la politique de mot de passe
    echo ""
    echo "Informations de Politique de Mot de Passe :"
    local password_policy=$(pwpolicy -u "$username" -getpolicy 2>/dev/null || echo "Aucune politique spécifique")
    echo "Politique de Mot de Passe : $password_policy"
    
    # Vérifier le statut du compte
    echo ""
    echo "Statut du Compte :"
    local account_policy=$(pwpolicy -u "$username" -getaccountpolicy 2>/dev/null || echo "Aucune politique de compte")
    echo "Politique de Compte : $account_policy"
    
    # Vérifier si le mot de passe est vide
    echo ""
    echo "Statut du Mot de Passe :"
    local auth_authority=$(dscl . -read "/Users/$username" AuthenticationAuthority 2>/dev/null)
    if [[ -z "$auth_authority" ]] || echo "$auth_authority" | grep -q "ShadowHash"; then
        echo "Type de Mot de Passe : Shadow Hash (Standard)"
    else
        echo "Type de Mot de Passe : $auth_authority"
    fi
}

check_password_status

Définir un Mot de Passe Sécurisé

#!/bin/bash

# Définir un mot de passe sécurisé avec validation
set_secure_password() {
    local username="$1"
    local new_password="$2"
    local admin_username="$3"
    local admin_password="$4"
    
    echo "=== Définition d'un Mot de Passe Sécurisé pour l'Utilisateur : $username ==="
    
    # Valider les paramètres
    if [[ -z "$username" || -z "$new_password" || -z "$admin_username" || -z "$admin_password" ]]; then
        echo "❌ Usage : set_secure_password <nom_utilisateur> <nouveau_mot_de_passe> <utilisateur_admin> <mot_de_passe_admin>"
        return 1
    fi
    
    # Vérifier la force du mot de passe
    if ! validate_password_strength "$new_password"; then
        echo "❌ Le mot de passe ne répond pas aux exigences de sécurité"
        return 1
    fi
    
    # Définir le mot de passe avec sysadminctl
    echo "Définition d'un mot de passe sécurisé pour l'utilisateur : $username"
    if sysadminctl -resetPasswordFor "$username" -newPassword "$new_password" -adminUser "$admin_username" -adminPassword "$admin_password"; then
        echo "✅ Mot de passe sécurisé défini avec succès pour l'utilisateur : $username"
        
        # Appliquer la politique de mot de passe
        apply_password_policy "$username"
    else
        echo "❌ Échec de définition du mot de passe pour l'utilisateur : $username"
        return 1
    fi
}

# Valider la force du mot de passe
validate_password_strength() {
    local password="$1"
    local min_length=8
    local has_upper=false
    local has_lower=false
    local has_digit=false
    local has_special=false
    
    # Vérifier la longueur minimale
    if [[ ${#password} -lt $min_length ]]; then
        echo "⚠️  Le mot de passe doit contenir au moins $min_length caractères"
        return 1
    fi
    
    # Vérifier la présence d'une lettre majuscule
    if [[ "$password" =~ [A-Z] ]]; then
        has_upper=true
    fi
    
    # Vérifier la présence d'une lettre minuscule
    if [[ "$password" =~ [a-z] ]]; then
        has_lower=true
    fi
    
    # Vérifier la présence d'un chiffre
    if [[ "$password" =~ [0-9] ]]; then
        has_digit=true
    fi
    
    # Vérifier la présence d'un caractère spécial
    if [[ "$password" =~ [^a-zA-Z0-9] ]]; then
        has_special=true
    fi
    
    # Valider toutes les exigences
    if [[ "$has_upper" == true && "$has_lower" == true && "$has_digit" == true && "$has_special" == true ]]; then
        echo "✅ Le mot de passe répond aux exigences de sécurité"
        return 0
    else
        echo "⚠️  Le mot de passe doit contenir majuscule, minuscule, chiffre et caractère spécial"
        return 1
    fi
}

# Appliquer la politique de mot de passe
apply_password_policy() {
    local username="$1"
    
    echo "Application de la politique de mot de passe pour l'utilisateur : $username"
    
    # Définir la politique de mot de passe (nécessite des privilèges admin)
    pwpolicy -u "$username" -setpolicy "minChars=8 requiresAlpha requiresNumeric requiresMixedCase requiresSymbol passwordCannotBeName maxMinutesUntilChangePassword=7776000" 2>/dev/null || true
    
    echo "✅ Politique de mot de passe appliquée"
}

Système de Gestion des Mots de Passe d'Entreprise

#!/bin/bash

# Système de Gestion des Mots de Passe d'Entreprise Roundfleet
# Gestion complète de l'authentification utilisateur et des politiques de mots de passe

# Configuration
PASSWORD_CONFIG_FILE="/etc/roundfleet/password_config.conf"
LOG_FILE="/var/log/roundfleet_password_management.log"
AUDIT_FILE="/var/log/roundfleet_password_audit.log"
BACKUP_DIR="/var/backups/roundfleet/user_accounts"

# Paramètres par défaut
DEFAULT_MIN_PASSWORD_LENGTH=12
DEFAULT_PASSWORD_EXPIRY_DAYS=90
DEFAULT_MAX_FAILED_ATTEMPTS=5
DEFAULT_LOCKOUT_DURATION=30

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

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

# Charger la configuration de gestion des mots de passe
load_password_config() {
    if [[ -f "$PASSWORD_CONFIG_FILE" ]]; then
        source "$PASSWORD_CONFIG_FILE"
        log_action "Configuration de mot de passe chargée depuis $PASSWORD_CONFIG_FILE"
    else
        log_action "Utilisation de la configuration de mot de passe par défaut"
    fi
}

# Sauvegarder les informations de compte utilisateur
backup_user_account() {
    local username="$1"
    local backup_file="$BACKUP_DIR/user_backup_${username}_$(date +%Y%m%d_%H%M%S).plist"
    
    # Créer le répertoire de sauvegarde
    sudo mkdir -p "$BACKUP_DIR"
    
    # Exporter l'enregistrement utilisateur
    if dscl . -read "/Users/$username" > "$backup_file" 2>/dev/null; then
        log_action "Sauvegarde de compte utilisateur créée : $backup_file"
        audit_log "SAUVEGARDE_CRÉÉE pour l'utilisateur : $username"
    else
        log_action "Échec de création de sauvegarde pour l'utilisateur : $username"
    fi
}

# Effacement de mot de passe d'entreprise avec vérifications de sécurité
enterprise_clear_password() {
    local username="$1"
    local admin_username="$2"
    local admin_password="$3"
    local force_clear="${4:-false}"
    
    log_action "Démarrage de l'effacement de mot de passe d'entreprise pour l'utilisateur : $username"
    audit_log "EFFACEMENT_MOT_DE_PASSE_INITIÉ pour l'utilisateur : $username par l'admin : $admin_username"
    
    # Valider les paramètres
    if [[ -z "$username" || -z "$admin_username" || -z "$admin_password" ]]; then
        log_action "❌ Paramètres requis manquants pour l'effacement de mot de passe"
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! dscl . -read "/Users/$username" >/dev/null 2>&1; then
        log_action "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Vérifications de sécurité
    if ! perform_security_checks "$username" "$force_clear"; then
        log_action "❌ Échec des vérifications de sécurité pour l'utilisateur : $username"
        return 1
    fi
    
    # Créer une sauvegarde avant de faire des changements
    backup_user_account "$username"
    
    # Effacer le mot de passe avec sysadminctl (méthode plus sécurisée)
    log_action "Effacement du mot de passe pour l'utilisateur : $username avec sysadminctl"
    if sysadminctl -resetPasswordFor "$username" -newPassword "" -adminUser "$admin_username" -adminPassword "$admin_password" 2>/dev/null; then
        log_action "✅ Mot de passe effacé avec succès pour l'utilisateur : $username"
        audit_log "MOT_DE_PASSE_EFFACÉ pour l'utilisateur : $username"
        
        # Appliquer les mesures de sécurité post-effacement
        apply_post_clear_security "$username"
        
        # Générer un rapport de conformité
        generate_password_compliance_report "$username"
        
        return 0
    else
        log_action "❌ Échec d'effacement du mot de passe pour l'utilisateur : $username"
        audit_log "ÉCHEC_EFFACEMENT_MOT_DE_PASSE pour l'utilisateur : $username"
        return 1
    fi
}

# Effectuer des vérifications de sécurité avant les opérations de mot de passe
perform_security_checks() {
    local username="$1"
    local force_clear="$2"
    
    log_action "Exécution des vérifications de sécurité pour l'utilisateur : $username"
    
    # Vérifier si l'utilisateur est admin (précaution supplémentaire requise)
    if dscl . -read "/Groups/admin" GroupMembership 2>/dev/null | grep -q "$username"; then
        if [[ "$force_clear" != "true" ]]; then
            log_action "⚠️  L'utilisateur '$username' est un administrateur - utilisez force_clear=true pour procéder"
            return 1
        else
            log_action "⚠️  Procédure avec effacement de mot de passe utilisateur admin (forcé)"
            audit_log "EFFACEMENT_MOT_DE_PASSE_ADMIN_FORCÉ pour l'utilisateur : $username"
        fi
    fi
    
    # Vérifier le statut FileVault
    if fdesetup status | grep -q "FileVault is On"; then
        local filevault_users=$(fdesetup list | cut -d',' -f1)
        if echo "$filevault_users" | grep -q "$username"; then
            log_action "⚠️  L'utilisateur '$username' est un utilisateur FileVault - l'effacement de mot de passe peut affecter le chiffrement du disque"
            audit_log "EFFACEMENT_MOT_DE_PASSE_UTILISATEUR_FILEVAULT pour l'utilisateur : $username"
        fi
    fi
    
    # Vérifier si l'utilisateur est actuellement connecté
    if who | grep -q "$username"; then
        log_action "⚠️  L'utilisateur '$username' est actuellement connecté"
        audit_log "EFFACEMENT_MOT_DE_PASSE_UTILISATEUR_ACTIF pour l'utilisateur : $username"
    fi
    
    # Vérifier l'heure de dernière connexion
    local last_login=$(last "$username" | head -1 | awk '{print $4, $5, $6}')
    log_action "Dernière connexion pour l'utilisateur '$username' : $last_login"
    
    return 0
}

# Appliquer des mesures de sécurité après l'effacement du mot de passe
apply_post_clear_security() {
    local username="$1"
    
    log_action "Application des mesures de sécurité post-effacement pour l'utilisateur : $username"
    
    # Définir la politique de compte pour exiger un changement de mot de passe à la prochaine connexion
    pwpolicy -u "$username" -setpolicy "requiresPasswordReset=1" 2>/dev/null || true
    
    # Enregistrer l'événement de sécurité
    audit_log "SÉCURITÉ_POST_EFFACEMENT_APPLIQUÉE pour l'utilisateur : $username"
    
    # Optionnel : Envoyer une notification à l'équipe de sécurité
    if [[ "${ENABLE_SECURITY_NOTIFICATIONS}" == "true" ]]; then
        send_security_notification "$username" "password_cleared"
    fi
}

# Générer un rapport de conformité des mots de passe
generate_password_compliance_report() {
    local username="$1"
    local report_file="/var/log/roundfleet_password_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    # Obtenir les informations utilisateur
    local uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
    local real_name=$(dscl . -read "/Users/$username" RealName 2>/dev/null | cut -d' ' -f2-)
    local home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | cut -d' ' -f2-)
    
    # Vérifier le statut admin
    local is_admin=false
    if dscl . -read "/Groups/admin" GroupMembership 2>/dev/null | grep -q "$username"; then
        is_admin=true
    fi
    
    # Vérifier le statut FileVault
    local is_filevault_user=false
    if fdesetup status | grep -q "FileVault is On"; then
        if fdesetup list | cut -d',' -f1 | grep -q "$username"; then
            is_filevault_user=true
        fi
    fi
    
    # Générer le rapport de conformité
    local compliance_data='{
        "timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'",
        "device_id": "'$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')'",
        "hostname": "'$(hostname)'",
        "operation": "password_cleared",
        "user_details": {
            "username": "'$username'",
            "uid": "'$uid'",
            "real_name": "'$real_name'",
            "home_directory": "'$home_dir'",
            "is_admin": '$is_admin',
            "is_filevault_user": '$is_filevault_user'
        },
        "security_status": {
            "password_cleared": true,
            "backup_created": true,
            "security_checks_passed": true,
            "post_clear_measures_applied": true
        }
    }'
    
    # Sauvegarder le rapport de conformité
    echo "$compliance_data" | jq . > "$report_file"
    log_action "Rapport de conformité des mots de passe généré : $report_file"
}

# Opérations de mots de passe en lot pour plusieurs utilisateurs
bulk_password_operations() {
    local operation="$1"
    local users_file="$2"
    local admin_username="$3"
    local admin_password="$4"
    
    log_action "Démarrage des opérations de mots de passe en lot : $operation"
    
    if [[ ! -f "$users_file" ]]; then
        log_action "❌ Fichier utilisateurs non trouvé : $users_file"
        return 1
    fi
    
    local success_count=0
    local failure_count=0
    
    while IFS= read -r username; do
        # Ignorer les lignes vides et les commentaires
        [[ -z "$username" || "$username" =~ ^# ]] && continue
        
        log_action "Traitement de l'utilisateur : $username"
        
        case "$operation" in
            "clear")
                if enterprise_clear_password "$username" "$admin_username" "$admin_password" "false"; then
                    ((success_count++))
                else
                    ((failure_count++))
                fi
                ;;
            "check")
                check_password_status "$username"
                ;;
            *)
                log_action "❌ Opération inconnue : $operation"
                return 1
                ;;
        esac
        
        # Petit délai entre les opérations
        sleep 1
        
    done < "$users_file"
    
    log_action "Opérations en lot terminées - Succès : $success_count, Échecs : $failure_count"
    audit_log "OPÉRATION_EN_LOT_TERMINÉE opération : $operation, succès : $success_count, échecs : $failure_count"
}

# Application des politiques de mots de passe
enforce_password_policies() {
    log_action "Application des politiques de mots de passe d'entreprise"
    
    # Obtenir tous les utilisateurs (excluant les utilisateurs système)
    local users=$(dscl . -list /Users | grep -v '^_' | grep -v '^root' | grep -v '^daemon' | grep -v '^nobody')
    
    for username in $users; do
        local uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
        
        # Ignorer les utilisateurs système (UID < 500)
        if [[ "$uid" -lt 500 ]]; then
            continue
        fi
        
        log_action "Application de la politique de mot de passe pour l'utilisateur : $username"
        
        # Appliquer la politique de mot de passe d'entreprise
        local min_length="${MIN_PASSWORD_LENGTH:-$DEFAULT_MIN_PASSWORD_LENGTH}"
        local expiry_days="${PASSWORD_EXPIRY_DAYS:-$DEFAULT_PASSWORD_EXPIRY_DAYS}"
        local max_attempts="${MAX_FAILED_ATTEMPTS:-$DEFAULT_MAX_FAILED_ATTEMPTS}"
        
        pwpolicy -u "$username" -setpolicy "minChars=$min_length requiresAlpha requiresNumeric requiresMixedCase requiresSymbol passwordCannotBeName maxMinutesUntilChangePassword=$((expiry_days * 24 * 60)) maxFailedLoginAttempts=$max_attempts" 2>/dev/null || true
        
    done
    
    log_action "Application des politiques de mots de passe terminée"
}

# Envoyer une notification de sécurité
send_security_notification() {
    local username="$1"
    local event_type="$2"
    
    # Ceci s'intégrerait avec votre système de notification
    # Pour l'instant, enregistrer simplement l'événement
    audit_log "NOTIFICATION_SÉCURITÉ envoyée pour l'utilisateur : $username, événement : $event_type"
}

# Fonction principale de gestion des mots de passe
main() {
    local action="${1:-status}"
    local username="${2}"
    local admin_username="${3}"
    local admin_password="${4}"
    
    log_action "=== Gestion des Mots de Passe Roundfleet Démarrée ==="
    
    case "$action" in
        "clear")
            if [[ -z "$username" || -z "$admin_username" || -z "$admin_password" ]]; then
                echo "Usage : $0 clear <nom_utilisateur> <nom_utilisateur_admin> <mot_de_passe_admin>"
                exit 1
            fi
            load_password_config
            enterprise_clear_password "$username" "$admin_username" "$admin_password"
            ;;
        "clear-force")
            if [[ -z "$username" || -z "$admin_username" || -z "$admin_password" ]]; then
                echo "Usage : $0 clear-force <nom_utilisateur> <nom_utilisateur_admin> <mot_de_passe_admin>"
                exit 1
            fi
            load_password_config
            enterprise_clear_password "$username" "$admin_username" "$admin_password" "true"
            ;;
        "check")
            if [[ -z "$username" ]]; then
                echo "Usage : $0 check <nom_utilisateur>"
                exit 1
            fi
            check_password_status "$username"
            ;;
        "bulk")
            local operation="$2"
            local users_file="$3"
            shift 3
            admin_username="$1"
            admin_password="$2"
            load_password_config
            bulk_password_operations "$operation" "$users_file" "$admin_username" "$admin_password"
            ;;
        "enforce-policies")
            load_password_config
            enforce_password_policies
            ;;
        "status")
            echo "Système de Gestion des Mots de Passe Roundfleet"
            echo "Commandes disponibles :"
            echo "  clear <utilisateur> <admin_utilisateur> <admin_pass>  - Effacer le mot de passe utilisateur"
            echo "  clear-force <utilisateur> <admin_utilisateur> <admin_pass>  - Forcer l'effacement (utilisateurs admin)"
            echo "  check <utilisateur>                            - Vérifier le statut du mot de passe"
            echo "  bulk <opération> <fichier_utilisateurs> <admin_utilisateur> <admin_pass>  - Opérations en lot"
            echo "  enforce-policies                        - Appliquer les politiques de mots de passe"
            echo "  status                                  - Afficher cette aide"
            ;;
        *)
            echo "❌ Action inconnue : $action"
            echo "Utilisez '$0 status' pour les commandes disponibles"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des Mots de Passe Roundfleet Terminée ==="
}

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

Configuration de Gestion des Mots de Passe

Créer un fichier de configuration pour les politiques de mots de passe d'entreprise :

#!/bin/bash

# Créer un fichier de configuration de gestion des mots de passe
create_password_config() {
    local config_dir="/etc/roundfleet"
    local config_file="$config_dir/password_config.conf"
    
    # Créer le répertoire s'il n'existe pas
    sudo mkdir -p "$config_dir"
    
    # Créer le fichier de configuration
    sudo tee "$config_file" > /dev/null << 'EOF'
# Configuration de Gestion des Mots de Passe Roundfleet

# Paramètres de politique de mot de passe
MIN_PASSWORD_LENGTH=12
PASSWORD_EXPIRY_DAYS=90
MAX_FAILED_ATTEMPTS=5
LOCKOUT_DURATION=30

# Exigences de sécurité
REQUIRE_UPPERCASE=true
REQUIRE_LOWERCASE=true
REQUIRE_NUMBERS=true
REQUIRE_SPECIAL_CHARS=true
PREVENT_COMMON_PASSWORDS=true

# Paramètres opérationnels
ENABLE_AUDIT_LOGGING=true
ENABLE_SECURITY_NOTIFICATIONS=true
ENABLE_AUTOMATIC_BACKUP=true
BACKUP_RETENTION_DAYS=365

# Considérations FileVault
WARN_FILEVAULT_USERS=true
REQUIRE_FORCE_FOR_FILEVAULT=true

# Protection des utilisateurs admin
WARN_ADMIN_USERS=true
REQUIRE_FORCE_FOR_ADMIN=true

# Paramètres de conformité
ENABLE_COMPLIANCE_REPORTING=true
COMPLIANCE_REPORT_INTERVAL=7200  # 2 heures
SEND_COMPLIANCE_ALERTS=true
EOF

    echo "Configuration de gestion des mots de passe créée dans : $config_file"
    echo "Veuillez réviser et modifier les paramètres selon vos politiques de sécurité"
}

create_password_config

Considérations de Sécurité et Bonnes Pratiques

Compatibilité FileVault

#!/bin/bash

# Vérifier la compatibilité FileVault avant les opérations de mot de passe
check_filevault_compatibility() {
    local username="$1"
    
    echo "=== Vérification de Compatibilité FileVault ==="
    
    # Vérifier si FileVault est activé
    if fdesetup status | grep -q "FileVault is On"; then
        echo "✅ FileVault est activé"
        
        # Vérifier si l'utilisateur est un utilisateur FileVault
        local filevault_users=$(fdesetup list)
        if echo "$filevault_users" | grep -q "$username"; then
            echo "⚠️  L'utilisateur '$username' est un utilisateur FileVault"
            echo "   L'effacement du mot de passe peut affecter l'accès au chiffrement du disque"
            echo "   Considérez les éléments suivants avant de procéder :"
            echo "   - S'assurer que d'autres utilisateurs FileVault existent"
            echo "   - Avoir la clé de récupération disponible"
            echo "   - L'utilisateur peut avoir besoin de réactiver FileVault après la réinitialisation du mot de passe"
            return 1
        else
            echo "✅ L'utilisateur '$username' n'est pas un utilisateur FileVault"
            return 0
        fi
    else
        echo "ℹ️  FileVault n'est pas activé"
        return 0
    fi
}

check_filevault_compatibility

Audit et Conformité

#!/bin/bash

# Générer un rapport d'audit complet
generate_audit_report() {
    local report_file="/var/log/roundfleet_password_audit_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport d'Audit de Gestion des Mots de Passe Roundfleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "====================================="
        echo ""
        
        echo "Utilisateurs Système (UID >= 500) :"
        dscl . -list /Users | while read username; do
            local uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
            if [[ "$uid" -ge 500 ]]; then
                local real_name=$(dscl . -read "/Users/$username" RealName 2>/dev/null | cut -d' ' -f2-)
                local is_admin=""
                if dscl . -read "/Groups/admin" GroupMembership 2>/dev/null | grep -q "$username"; then
                    is_admin=" (Admin)"
                fi
                echo "- $username (UID : $uid)$is_admin - $real_name"
            fi
        done
        echo ""
        
        echo "Statut FileVault :"
        fdesetup status
        if fdesetup status | grep -q "FileVault is On"; then
            echo "Utilisateurs FileVault :"
            fdesetup list
        fi
        echo ""
        
        echo "Activités Récentes de Gestion des Mots de Passe :"
        if [[ -f "$AUDIT_FILE" ]]; then
            tail -20 "$AUDIT_FILE"
        else
            echo "Aucun journal d'audit trouvé"
        fi
        
    } > "$report_file"
    
    echo "Rapport d'audit généré : $report_file"
}

generate_audit_report

Intégration avec la Gestion Roundfleet

#!/bin/bash

# Intégration de gestion des mots de passe Roundfleet
roundfleet_password_integration() {
    echo "=== Intégration de Gestion des Mots de Passe Roundfleet ==="
    
    # Informations de l'appareil
    local device_id=$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')
    local hostname=$(hostname)
    local macos_version=$(sw_vers -productVersion)
    
    # Obtenir les statistiques de comptes utilisateur
    local total_users=$(dscl . -list /Users | grep -v '^_' | grep -v '^root' | grep -v '^daemon' | grep -v '^nobody' | wc -l)
    local admin_users=$(dscl . -read "/Groups/admin" GroupMembership 2>/dev/null | wc -w)
    
    # Statut FileVault
    local filevault_enabled=false
    local filevault_users=0
    if fdesetup status | grep -q "FileVault is On"; then
        filevault_enabled=true
        filevault_users=$(fdesetup list | wc -l)
    fi
    
    # Activités récentes de gestion des mots de passe
    local recent_activities=0
    if [[ -f "$AUDIT_FILE" ]]; then
        recent_activities=$(grep "$(date +%Y-%m-%d)" "$AUDIT_FILE" | wc -l)
    fi
    
    # Rapporter à l'API Roundfleet
    local api_data='{
        "device_id": "'$device_id'",
        "hostname": "'$hostname'",
        "timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'",
        "macos_version": "'$macos_version'",
        "password_management": {
            "total_users": '$total_users',
            "admin_users": '$admin_users',
            "filevault_enabled": '$filevault_enabled',
            "filevault_users": '$filevault_users',
            "recent_activities": '$recent_activities'
        },
        "password_management_status": "actif"
    }'
    
    echo "Statut de gestion des mots de passe rapporté au système de gestion Roundfleet"
    echo "ID Appareil : $device_id"
    echo "Total Utilisateurs : $total_users"
    echo "Utilisateurs Admin : $admin_users"
    echo "FileVault Activé : $filevault_enabled"
    echo "Activités Récentes : $recent_activities"
}

roundfleet_password_integration

Notes de Sécurité Importantes

Avertissements de Sécurité

  • L'effacement de mot de passe crée des risques de sécurité - utilisez seulement quand nécessaire
  • Les utilisateurs FileVault nécessitent une considération spéciale - peut affecter le chiffrement du disque
  • Les utilisateurs admin nécessitent une prudence supplémentaire - peut compromettre la sécurité du système
  • Toujours créer des sauvegardes avant de faire des changements de mots de passe

Bonnes Pratiques

  • Utiliser sysadminctl plutôt que dscl pour une meilleure sécurité et des pistes d'audit
  • Implémenter des politiques de mots de passe fortes après l'effacement des mots de passe
  • Surveiller et auditer toutes les opérations de mots de passe
  • Tester sur des appareils pilotes avant le déploiement à l'échelle de la flotte

Considérations de Conformité

  • Documenter toutes les opérations de mots de passe pour les audits de sécurité
  • Maintenir des procédures de sauvegarde et de récupération
  • Évaluations de sécurité régulières des comptes utilisateur
  • Intégration avec les systèmes d'identité d'entreprise pour la gestion centralisée

Related Tutorials

Gestion Entreprise de Changement de Mot de Passe sur macOS

Guide complet pour les opérations sécurisées de changement de mot de passe en entreprise sur les appareils Roundfleet avec application de politiques, contrôles de sécurité et capacités d'audit complètes.

7 juil. 2025

Gestion des Jetons Sécurisés sur macOS

Apprenez à gérer et accorder des jetons sécurisés aux utilisateurs sur les appareils macOS en utilisant sysadminctl pour la sécurité d'entreprise, la gestion FileVault et l'authentification des opérations cryptographiques.

7 juil. 2025

Gestion Sécurisée d'Archives sur macOS

Apprenez à créer, gérer et sécuriser des archives sur les appareils macOS en utilisant des fichiers ZIP protégés par mot de passe avec sécurité de niveau entreprise, opérations par lots, suivi de conformité et capacités de gestion d'archives à l'échelle de la flotte.

7 juil. 2025

Gestion à Distance d'Entreprise et Contrôle d'Accès Sécurisé sur macOS

Configuration complète de la gestion à distance, contrôle d'accès sécurisé, support multi-protocoles et cadres de conformité d'entreprise pour les appareils macOS avec surveillance de sécurité avancée et application automatisée des politiques.

7 juil. 2025

Application de Politiques de Mots de Passe en Entreprise sur macOS

Implémentez des politiques de mots de passe complètes, appliquez des standards de sécurité et gérez l'authentification utilisateur sur les appareils macOS avec des outils en ligne de commande avancés et des frameworks de sécurité d'entreprise.

7 juil. 2025

Gestion d'Entreprise du Pare-feu pour macOS

Gérez les paramètres de pare-feu macOS sur les appareils Roundfleet avec des politiques de sécurité automatisées, une protection réseau avancée, une détection de menaces et une surveillance de conformité complète pour la sécurité réseau d'entreprise.

7 juil. 2025

Effacement Sécurisé de Données sur macOS

Apprenez à effacer de manière sécurisée l'espace libre et gérer la confidentialité des données sur les appareils macOS en utilisant des outils d'effacement sécurisé avancés avec surveillance de conformité, protection de la vie privée et capacités de sécurité des données à l'échelle de la flotte.

7 juil. 2025

Sécurité de Verrouillage d'Écran d'Entreprise sur macOS

Configurez et appliquez les exigences de mot de passe de verrouillage d'écran, les politiques de sécurité de veille et les mécanismes de verrouillage automatisés sur les appareils macOS en utilisant l'automatisation AppleScript et les frameworks de sécurité d'entreprise.

7 juil. 2025
View all tutorials →