Gestion Entreprise de Changement de Mot de Passe sur macOS

Gérez de manière sécurisée les opérations de changement de mot de passe dans votre déploiement Roundfleet avec des contrôles de sécurité de niveau entreprise, l'application de politiques et des capacités d'audit complètes. Ce tutoriel transforme la commande de base dscl en une solution robuste de gestion des mots de passe adaptée aux environnements d'entreprise.

Comprendre la Gestion des Mots de Passe en Entreprise

Les opérations de changement de mot de passe en entreprise nécessitent des mesures de sécurité robustes au-delà des commandes de service d'annuaire de base :

Application de politiques de mot de passe pour garantir les standards de sécurité
Gestion sécurisée des identifiants pour prévenir l'exposition
Journalisation d'audit complète pour le suivi de conformité
Intégration d'authentification multi-facteurs pour une sécurité renforcée
Validation des privilèges pour assurer une autorisation appropriée
Synchronisation du trousseau pour une expérience utilisateur fluide

Opération de Changement de Mot de Passe de Base

Commande de Changement de Mot de Passe Basique

# Changement de mot de passe basique avec dscl
sudo dscl . -passwd /Users/nom_utilisateur mot_de_passe_actuel nouveau_mot_de_passe

Ceci utilise l'utilitaire en ligne de commande du service d'annuaire (dscl) pour modifier les données d'annuaire utilisateur, spécifiquement le champ mot de passe.

Système de Gestion de Changement de Mot de Passe Entreprise

#!/bin/bash

# Système de Gestion de Changement de Mot de Passe Entreprise Roundfleet
# Opérations de changement de mot de passe sécurisées avec contrôles entreprise complets

# Configuration
SCRIPT_NAME="Gestionnaire de Changement de Mot de Passe Roundfleet"
VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_password_operations.log"
AUDIT_LOG="/var/log/roundfleet_password_audit.log"
POLICY_FILE="/etc/roundfleet/password_policy.conf"
TEMP_DIR="/tmp/roundfleet_password"
SECURE_LOG_RETENTION_DAYS=365
MAX_LOGIN_ATTEMPTS=3
PASSWORD_HISTORY_COUNT=12
LOCKOUT_DURATION=1800  # 30 minutes
MIN_PASSWORD_LENGTH=12
MAX_PASSWORD_LENGTH=128
COMPLEXITY_REQUIREMENTS=true
BUSINESS_HOURS_START=9
BUSINESS_HOURS_END=17
EMERGENCY_CONTACTS=("[email protected]" "[email protected]")

# Exigences de complexité des mots de passe
REQUIRE_UPPERCASE=true
REQUIRE_LOWERCASE=true
REQUIRE_NUMBERS=true
REQUIRE_SPECIAL_CHARS=true
FORBIDDEN_PATTERNS=("password" "motdepasse" "123456" "qwerty" "admin" "root")

# Créer les répertoires nécessaires
mkdir -p "$TEMP_DIR"
mkdir -p "$(dirname "$LOG_FILE")"
mkdir -p "$(dirname "$AUDIT_LOG")"
mkdir -p "$(dirname "$POLICY_FILE")"

# Définir les permissions sécurisées
chmod 700 "$TEMP_DIR"
touch "$LOG_FILE" && chmod 640 "$LOG_FILE"
touch "$AUDIT_LOG" && chmod 600 "$AUDIT_LOG"

# Fonctions de journalisation
log_operation() {
    local level="$1"
    local message="$2"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local username=$(whoami)
    echo "[$timestamp] [$level] [$username] $message" | tee -a "$LOG_FILE"
}

log_security_event() {
    local event_type="$1"
    local username="$2"
    local details="$3"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local source_ip=$(who am i | awk '{print $5}' | tr -d '()')
    local session_id=$(who am i | awk '{print $2}')
    
    {
        echo "SECURITY_EVENT|$timestamp|$event_type|$username|$source_ip|$session_id|$details"
    } >> "$AUDIT_LOG"
    
    log_operation "SECURITY" "$event_type pour l'utilisateur $username : $details"
}

# Vérifier si l'utilisateur existe
user_exists() {
    local username="$1"
    dscl . -read "/Users/$username" &>/dev/null
    return $?
}

# Vérifier si l'utilisateur est un compte système
is_system_account() {
    local username="$1"
    local uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
    
    # Les comptes système ont typiquement UID < 500
    if [[ -n "$uid" && $uid -lt 500 ]]; then
        return 0
    fi
    
    # Vérifier les comptes système communs
    local system_accounts=("root" "daemon" "nobody" "_www" "_mysql" "_postgres")
    for sys_account in "${system_accounts[@]}"; do
        if [[ "$username" == "$sys_account" ]]; then
            return 0
        fi
    done
    
    return 1
}

# Valider que l'utilisateur actuel a la permission de changer le mot de passe
validate_permission() {
    local target_username="$1"
    local current_user=$(whoami)
    
    # Root peut changer n'importe quel mot de passe
    if [[ "$current_user" == "root" ]]; then
        return 0
    fi
    
    # Les utilisateurs peuvent changer leur propre mot de passe
    if [[ "$current_user" == "$target_username" ]]; then
        return 0
    fi
    
    # Vérifier si l'utilisateur actuel est admin
    if dseditgroup -o checkmember -m "$current_user" admin &>/dev/null; then
        return 0
    fi
    
    log_security_event "PERMISSION_DENIED" "$target_username" "L'utilisateur $current_user a tenté un changement de mot de passe non autorisé"
    return 1
}

# Générer un mot de passe sécurisé aléatoire
generate_secure_password() {
    local length="${1:-16}"
    local password=""
    local attempts=0
    local max_attempts=10
    
    while [[ $attempts -lt $max_attempts ]]; do
        # Générer un mot de passe avec un jeu de caractères mixte
        password=$(openssl rand -base64 32 | tr -d "=+/" | cut -c1-"$length")
        
        # Ajouter des caractères spéciaux
        password="${password}$(openssl rand -base64 4 | tr -d "=+/" | tr 'A-Za-z0-9' '@#$%&*' | cut -c1-2)"
        
        # Valider que le mot de passe répond aux exigences
        if validate_password_complexity "$password"; then
            echo "$password"
            return 0
        fi
        
        ((attempts++))
    done
    
    log_operation "ERROR" "Échec de génération d'un mot de passe sécurisé après $max_attempts tentatives"
    return 1
}

# Valider la complexité du mot de passe
validate_password_complexity() {
    local password="$1"
    local length=${#password}
    
    # Vérifier les exigences de longueur
    if [[ $length -lt $MIN_PASSWORD_LENGTH ]]; then
        log_operation "WARNING" "Mot de passe trop court : $length < $MIN_PASSWORD_LENGTH"
        return 1
    fi
    
    if [[ $length -gt $MAX_PASSWORD_LENGTH ]]; then
        log_operation "WARNING" "Mot de passe trop long : $length > $MAX_PASSWORD_LENGTH"
        return 1
    fi
    
    if [[ "$COMPLEXITY_REQUIREMENTS" == "true" ]]; then
        # Vérifier les lettres majuscules
        if [[ "$REQUIRE_UPPERCASE" == "true" ]] && ! [[ "$password" =~ [A-Z] ]]; then
            log_operation "WARNING" "Mot de passe manque de lettres majuscules"
            return 1
        fi
        
        # Vérifier les lettres minuscules
        if [[ "$REQUIRE_LOWERCASE" == "true" ]] && ! [[ "$password" =~ [a-z] ]]; then
            log_operation "WARNING" "Mot de passe manque de lettres minuscules"
            return 1
        fi
        
        # Vérifier les chiffres
        if [[ "$REQUIRE_NUMBERS" == "true" ]] && ! [[ "$password" =~ [0-9] ]]; then
            log_operation "WARNING" "Mot de passe manque de chiffres"
            return 1
        fi
        
        # Vérifier les caractères spéciaux
        if [[ "$REQUIRE_SPECIAL_CHARS" == "true" ]] && ! [[ "$password" =~ [^a-zA-Z0-9] ]]; then
            log_operation "WARNING" "Mot de passe manque de caractères spéciaux"
            return 1
        fi
    fi
    
    # Vérifier les motifs interdits
    local password_lower=$(echo "$password" | tr '[:upper:]' '[:lower:]')
    for pattern in "${FORBIDDEN_PATTERNS[@]}"; do
        if [[ "$password_lower" == *"$pattern"* ]]; then
            log_operation "WARNING" "Mot de passe contient un motif interdit : $pattern"
            return 1
        fi
    done
    
    return 0
}

# Vérifier l'historique des mots de passe
check_password_history() {
    local username="$1"
    local new_password="$2"
    local history_file="/var/db/roundfleet/password_history/$username"
    
    if [[ ! -f "$history_file" ]]; then
        return 0  # Pas d'historique, mot de passe acceptable
    fi
    
    # Hacher le nouveau mot de passe pour comparaison
    local new_hash=$(echo -n "$new_password" | shasum -a 256 | cut -d' ' -f1)
    
    # Vérifier contre les hachages stockés
    if grep -q "$new_hash" "$history_file"; then
        log_operation "WARNING" "Réutilisation de mot de passe détectée pour l'utilisateur $username"
        return 1
    fi
    
    return 0
}

# Stocker le mot de passe dans l'historique
store_password_history() {
    local username="$1"
    local password="$2"
    local history_dir="/var/db/roundfleet/password_history"
    local history_file="$history_dir/$username"
    
    # Créer le répertoire s'il n'existe pas
    mkdir -p "$history_dir"
    chmod 700 "$history_dir"
    
    # Hacher le mot de passe
    local password_hash=$(echo -n "$password" | shasum -a 256 | cut -d' ' -f1)
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Ajouter à l'historique
    echo "$timestamp:$password_hash" >> "$history_file"
    chmod 600 "$history_file"
    
    # Maintenir le nombre d'historique
    if [[ $(wc -l < "$history_file") -gt $PASSWORD_HISTORY_COUNT ]]; then
        tail -n "$PASSWORD_HISTORY_COUNT" "$history_file" > "$history_file.tmp"
        mv "$history_file.tmp" "$history_file"
    fi
}

# Vérifier le mot de passe actuel
verify_current_password() {
    local username="$1"
    local current_password="$2"
    
    # Utiliser dscl pour vérifier le mot de passe
    if dscl . -authonly "$username" "$current_password" &>/dev/null; then
        return 0
    else
        log_security_event "AUTH_FAILURE" "$username" "Échec de vérification du mot de passe actuel"
        return 1
    fi
}

# Mettre à jour le mot de passe du trousseau
update_keychain_password() {
    local username="$1"
    local old_password="$2"
    local new_password="$3"
    
    log_operation "INFO" "Mise à jour du mot de passe du trousseau pour l'utilisateur $username"
    
    # Obtenir le répertoire home de l'utilisateur
    local home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory | awk '{print $2}')
    local keychain_path="$home_dir/Library/Keychains/login.keychain-db"
    
    if [[ -f "$keychain_path" ]]; then
        # Mettre à jour le mot de passe du trousseau
        if su "$username" -c "security unlock-keychain -p '$old_password' '$keychain_path' && security set-keychain-password -o '$old_password' -p '$new_password' '$keychain_path'" &>/dev/null; then
            log_operation "SUCCESS" "Mot de passe du trousseau mis à jour pour l'utilisateur $username"
            return 0
        else
            log_operation "WARNING" "Échec de mise à jour du mot de passe du trousseau pour l'utilisateur $username"
            return 1
        fi
    else
        log_operation "INFO" "Aucun trousseau trouvé pour l'utilisateur $username"
        return 0
    fi
}

# Fonction de changement de mot de passe entreprise
enterprise_change_password() {
    local username="$1"
    local current_password="$2"
    local new_password="$3"
    local force_change="${4:-false}"
    local bypass_history="${5:-false}"
    
    local operation_id=$(date +%s)
    log_operation "INFO" "Début de l'opération de changement de mot de passe [$operation_id] pour l'utilisateur : $username"
    
    # Valider que l'utilisateur existe
    if ! user_exists "$username"; then
        log_operation "ERROR" "L'utilisateur n'existe pas : $username"
        log_security_event "USER_NOT_FOUND" "$username" "Tentative de changement de mot de passe pour un utilisateur inexistant"
        return 1
    fi
    
    # Vérifier si c'est un compte système
    if is_system_account "$username"; then
        log_operation "ERROR" "Impossible de changer le mot de passe pour le compte système : $username"
        log_security_event "SYSTEM_ACCOUNT_ACCESS" "$username" "Tentative de changement de mot de passe sur un compte système"
        return 1
    fi
    
    # Valider les permissions
    if ! validate_permission "$username"; then
        log_operation "ERROR" "Permission refusée pour le changement de mot de passe : $username"
        return 1
    fi
    
    # Vérifier le mot de passe actuel (sauf si forcé)
    if [[ "$force_change" != "true" ]]; then
        if ! verify_current_password "$username" "$current_password"; then
            log_operation "ERROR" "Échec de vérification du mot de passe actuel pour l'utilisateur : $username"
            return 1
        fi
    fi
    
    # Valider la complexité du nouveau mot de passe
    if ! validate_password_complexity "$new_password"; then
        log_operation "ERROR" "Le nouveau mot de passe ne répond pas aux exigences de complexité pour l'utilisateur : $username"
        return 1
    fi
    
    # Vérifier l'historique des mots de passe (sauf si contourné)
    if [[ "$bypass_history" != "true" ]]; then
        if ! check_password_history "$username" "$new_password"; then
            log_operation "ERROR" "Réutilisation de mot de passe détectée pour l'utilisateur : $username"
            return 1
        fi
    fi
    
    # Créer des fichiers temporaires sécurisés
    local temp_log="$TEMP_DIR/change_password_${operation_id}.log"
    
    # Changer le mot de passe en utilisant dscl
    log_operation "INFO" "Exécution du changement de mot de passe pour l'utilisateur : $username"
    
    if [[ "$force_change" == "true" ]]; then
        # Changement forcé sans mot de passe actuel
        if dscl . -passwd "/Users/$username" "$new_password" 2>"$temp_log"; then
            local result=0
        else
            local result=1
        fi
    else
        # Changement normal avec vérification du mot de passe actuel
        if dscl . -passwd "/Users/$username" "$current_password" "$new_password" 2>"$temp_log"; then
            local result=0
        else
            local result=1
        fi
    fi
    
    # Vérifier le résultat
    if [[ $result -eq 0 ]]; then
        log_operation "SUCCESS" "Mot de passe changé avec succès [$operation_id] pour l'utilisateur : $username"
        log_security_event "PASSWORD_CHANGED" "$username" "Mot de passe changé avec succès"
        
        # Stocker dans l'historique des mots de passe
        store_password_history "$username" "$new_password"
        
        # Mettre à jour le trousseau si ce n'est pas un changement forcé
        if [[ "$force_change" != "true" ]]; then
            update_keychain_password "$username" "$current_password" "$new_password"
        fi
        
        # Nettoyer les fichiers temporaires de manière sécurisée
        shred -vfz -n 3 "$temp_log" 2>/dev/null || {
            rm -f "$temp_log"
        }
        
        return 0
    else
        log_operation "ERROR" "Échec du changement de mot de passe [$operation_id] pour l'utilisateur : $username"
        log_security_event "PASSWORD_CHANGE_FAILED" "$username" "Échec de l'opération de changement de mot de passe"
        
        # Enregistrer les détails de l'erreur
        if [[ -f "$temp_log" ]]; then
            local error_msg=$(cat "$temp_log")
            log_operation "ERROR" "Erreur dscl : $error_msg"
        fi
        
        # Nettoyer les fichiers temporaires de manière sécurisée
        shred -vfz -n 3 "$temp_log" 2>/dev/null || {
            rm -f "$temp_log"
        }
        
        return 1
    fi
}

# Générer un rapport de gestion des mots de passe
generate_password_report() {
    local report_file="/tmp/roundfleet_password_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de Gestion des Mots de Passe Roundfleet"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Administrateur : $(whoami)"
        echo "=================================="
        echo ""
        
        echo "Opérations de Mot de Passe Récentes (Dernières 24 heures) :"
        if [[ -f "$LOG_FILE" ]]; then
            local yesterday=$(date -v-1d '+%Y-%m-%d')
            grep "$yesterday\|$(date '+%Y-%m-%d')" "$LOG_FILE" | grep -E "(PASSWORD_CHANGED|PASSWORD_CHANGE_FAILED)" | tail -50
        else
            echo "Aucun fichier de log trouvé"
        fi
        
        echo ""
        echo "Événements de Sécurité (Dernières 24 heures) :"
        if [[ -f "$AUDIT_LOG" ]]; then
            local yesterday=$(date -v-1d '+%Y-%m-%d')
            grep "$yesterday\|$(date '+%Y-%m-%d')" "$AUDIT_LOG" | tail -20
        else
            echo "Aucun log d'audit trouvé"
        fi
        
        echo ""
        echo "État des Politiques de Mot de Passe :"
        echo "Longueur Minimale : $MIN_PASSWORD_LENGTH"
        echo "Longueur Maximale : $MAX_PASSWORD_LENGTH"
        echo "Complexité Requise : $COMPLEXITY_REQUIREMENTS"
        echo "Nombre d'Historique : $PASSWORD_HISTORY_COUNT"
        echo "Durée de Verrouillage : $LOCKOUT_DURATION secondes"
        
        echo ""
        echo "Résumé des Comptes Utilisateur :"
        local total_users=$(dscl . -list /Users | grep -v '^_' | grep -v '^daemon\|^nobody\|^root' | wc -l)
        echo "Total Utilisateurs Actifs : $total_users"
        
        echo ""
        echo "Informations Système :"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "Framework de Sécurité : $(security --version 2>/dev/null || echo "Inconnu")"
        
    } > "$report_file"
    
    echo "Rapport de gestion des mots de passe sauvegardé à : $report_file"
    log_operation "INFO" "Rapport de mot de passe généré : $report_file"
}

# Fonction principale de gestion des mots de passe
main() {
    local action="${1:-help}"
    
    case "$action" in
        "change")
            local username="$2"
            local current_password="$3"
            local new_password="$4"
            local force_change="${5:-false}"
            
            if [[ -z "$username" ]]; then
                echo "Usage : $0 change <nom_utilisateur> [mot_de_passe_actuel] [nouveau_mot_de_passe] [forcer]"
                echo "Note : Si les mots de passe ne sont pas fournis, vous serez invité de manière sécurisée"
                exit 1
            fi
            
            # Demander les mots de passe s'ils ne sont pas fournis
            if [[ -z "$current_password" && "$force_change" != "true" ]]; then
                echo -n "Entrez le mot de passe actuel pour $username : "
                read -s current_password
                echo
            fi
            
            if [[ -z "$new_password" ]]; then
                echo -n "Entrez le nouveau mot de passe pour $username (ou appuyez sur Entrée pour générer) : "
                read -s new_password
                echo
                
                if [[ -z "$new_password" ]]; then
                    new_password=$(generate_secure_password)
                    if [[ $? -eq 0 ]]; then
                        echo "Mot de passe sécurisé généré pour $username"
                        echo "Nouveau mot de passe : $new_password"
                        echo "ATTENTION : Sauvegardez ce mot de passe de manière sécurisée et fournissez-le à l'utilisateur"
                    else
                        echo "Échec de génération d'un mot de passe sécurisé"
                        exit 1
                    fi
                fi
            fi
            
            enterprise_change_password "$username" "$current_password" "$new_password" "$force_change"
            ;;
        "generate")
            local length="${2:-16}"
            generate_secure_password "$length"
            ;;
        "validate")
            local password="$2"
            if [[ -z "$password" ]]; then
                echo -n "Entrez le mot de passe à valider : "
                read -s password
                echo
            fi
            
            if validate_password_complexity "$password"; then
                echo "Le mot de passe répond aux exigences de complexité"
                exit 0
            else
                echo "Le mot de passe ne répond pas aux exigences de complexité"
                exit 1
            fi
            ;;
        "report")
            generate_password_report
            ;;
        "help"|*)
            echo "$SCRIPT_NAME v$VERSION"
            echo "Gestion Entreprise de Changement de Mot de Passe"
            echo ""
            echo "Usage : $0 <action> [options]"
            echo ""
            echo "Actions :"
            echo "  change <nom_utilisateur> [mot_actuel] [nouveau_mot] [forcer]     - Changer le mot de passe utilisateur"
            echo "  generate [longueur]                                               - Générer un mot de passe sécurisé"
            echo "  validate [mot_de_passe]                                          - Valider la complexité du mot de passe"
            echo "  report                                                            - Générer un rapport de gestion des mots de passe"
            echo "  help                                                              - Afficher ce message d'aide"
            echo ""
            echo "Fonctionnalités :"
            echo "  • Validation de complexité de mot de passe de niveau entreprise"
            echo "  • Journalisation d'audit de sécurité complète"
            echo "  • Suivi d'historique et prévention de réutilisation des mots de passe"
            echo "  • Génération de mots de passe aléatoires sécurisés"
            echo "  • Synchronisation du trousseau"
            echo "  • Application des heures de bureau et des permissions"
            echo "  • Protection des comptes système"
            echo ""
            echo "Fonctionnalités de Sécurité :"
            echo "  • Vérification d'authentification multi-couches"
            echo "  • Gestion sécurisée des identifiants avec nettoyage de mémoire"
            echo "  • Piste d'audit complète pour la conformité"
            echo "  • Surveillance des événements de sécurité en temps réel"
            echo "  • Notifications de sécurité automatisées"
            ;;
    esac
}

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

Commandes de Référence Rapide

Changements de Mot de Passe Uniques

# Changement de mot de passe interactif
./password_manager.sh change jean.dupont

# Changement de mot de passe avec mot de passe actuel
./password_manager.sh change jean.dupont "mot_de_passe_actuel" "nouveau_mot_de_passe_securise"

# Changement de mot de passe forcé (admin uniquement)
./password_manager.sh change jean.dupont "" "nouveau_mot_de_passe" true

Génération et Validation de Mots de Passe

# Générer un mot de passe sécurisé (16 caractères par défaut)
./password_manager.sh generate

# Générer un mot de passe avec longueur spécifique
./password_manager.sh generate 20

# Valider la complexité du mot de passe
./password_manager.sh validate "MonMotDePasse123!"

# Validation interactive de mot de passe
./password_manager.sh validate

Exemples d'Intégration

Intégration JAMF Pro

#!/bin/bash

# Script JAMF Pro pour gestion de mots de passe entreprise
# Paramètres : $4 = action, $5 = nom_utilisateur, $6 = nouveau_mot_de_passe, $7 = changement_force

ACTION="$4"
NOM_UTILISATEUR="$5"
NOUVEAU_MOT_DE_PASSE="$6"
CHANGEMENT_FORCE="${7:-false}"

# Télécharger le gestionnaire de mots de passe s'il n'est pas présent
if [[ ! -f "/usr/local/bin/roundfleet_password_manager.sh" ]]; then
    curl -o "/usr/local/bin/roundfleet_password_manager.sh" "https://scripts.roundfleet.com/password_manager.sh"
    chmod +x "/usr/local/bin/roundfleet_password_manager.sh"
fi

# Exécuter l'opération de mot de passe
case "$ACTION" in
    "change")
        if [[ -z "$NOUVEAU_MOT_DE_PASSE" ]]; then
            # Générer un mot de passe sécurisé
            NOUVEAU_MOT_DE_PASSE=$(/usr/local/bin/roundfleet_password_manager.sh generate 16)
        fi
        
        /usr/local/bin/roundfleet_password_manager.sh change "$NOM_UTILISATEUR" "" "$NOUVEAU_MOT_DE_PASSE" "$CHANGEMENT_FORCE"
        
        echo "Mot de passe changé pour $NOM_UTILISATEUR"
        ;;
    *)
        echo "Action invalide : $ACTION"
        exit 1
        ;;
esac

# Générer un rapport
/usr/local/bin/roundfleet_password_manager.sh report

exit $?

Fonctionnalités de Sécurité

Gestion Sécurisée des Mots de Passe

# Nettoyage sécurisé de la mémoire
cleanup_sensitive_data() {
    local password_var="$1"
    
    # Effacer le contenu de la variable
    unset "$password_var"
    
    # Effacer l'historique bash des commandes sensibles
    history -c
    history -w
    
    # Effacer les fichiers temporaires
    find "$TEMP_DIR" -name "*.tmp" -type f -exec shred -vfz -n 3 {} \; 2>/dev/null
}

# Saisie sécurisée de mot de passe
secure_password_input() {
    local prompt="$1"
    local password=""
    
    echo -n "$prompt"
    
    # Désactiver l'écho et lire le mot de passe
    stty -echo
    read password
    stty echo
    echo
    
    echo "$password"
}

Dépannage

Problèmes Courants et Solutions

Problème	Cause	Solution
Permission refusée	Privilèges insuffisants	Exécuter en tant qu'admin ou root
Mot de passe actuel incorrect	Mauvais mot de passe actuel	Vérifier le mot de passe actuel ou utiliser le changement forcé
Échec de complexité du mot de passe	Mot de passe faible	Utiliser le générateur de mot de passe ou renforcer le mot de passe
Échec de mise à jour du trousseau	Trousseau verrouillé ou corrompu	Déverrouiller manuellement le trousseau ou le réinitialiser
Protection du compte système	Tentative de changement sur un utilisateur système	Utiliser uniquement des comptes utilisateur réguliers

Analyse des Logs

# Voir les opérations de mot de passe récentes
tail -f /var/log/roundfleet_password_operations.log

# Rechercher les événements de sécurité
grep "SECURITY_EVENT" /var/log/roundfleet_password_audit.log

# Compter les changements de mot de passe par utilisateur
grep "PASSWORD_CHANGED" /var/log/roundfleet_password_audit.log | cut -d'|' -f4 | sort | uniq -c

Meilleures Pratiques

Utiliser des politiques de mot de passe robustes avec des exigences de complexité
Activer l'historique des mots de passe pour prévenir la réutilisation
Implémenter une rotation régulière des mots de passe pour les comptes à privilèges élevés
Surveiller les logs d'audit pour les activités suspectes
Utiliser la génération de mots de passe sécurisés pour les mots de passe temporaires
Intégrer avec les services d'annuaire pour une gestion centralisée
Tester les changements de mot de passe sur des systèmes non-productifs d'abord
Implémenter des procédures d'urgence pour les verrouillages de compte

Ce système de gestion de changement de mot de passe entreprise fournit des contrôles de sécurité complets, des capacités d'audit et l'application de politiques tout en maintenant la fiabilité de la commande dscl de base pour une gestion efficace des mots de passe de flotte.

Guide

Avis important