Application de Politiques de Mots de Passe en Entreprise sur macOS

Appliquez des politiques de mots de passe de niveau entreprise et des standards de sécurité sur vos appareils Roundfleet en utilisant des outils en ligne de commande complets et des frameworks de sécurité. Ce tutoriel couvre l'implémentation de politiques de mots de passe, la surveillance de la conformité et les systèmes d'application automatisés.

Comprendre la Sécurité des Mots de Passe sur macOS

macOS fournit plusieurs couches de sécurité pour les mots de passe :

Politiques de Mots de Passe - Exigences de complexité, longueur et rotation
Sécurité de Verrouillage d'Écran - Verrouillage automatique et exigences de déverrouillage
Gestion de Secure Token - Support FileVault et chiffrement
Sécurité des Comptes - Privilèges utilisateur et contrôles d'accès

Configuration des Politiques de Mots de Passe

Exigences de Base pour les Mots de Passe

#!/bin/bash

# Définir une politique de mots de passe de base avec pwpolicy
configure_password_policy() {
    # Configurer les exigences de complexité des mots de passe
    sudo pwpolicy -a diradmin -u $USER -setpolicy "minChars=8 requiresAlpha requiresNumeric"
    
    # Définir l'historique des mots de passe (empêcher la réutilisation des 5 derniers)
    sudo pwpolicy -a diradmin -u $USER -setpolicy "usingHistory=5"
    
    # Définir l'expiration des mots de passe (90 jours)
    sudo pwpolicy -a diradmin -u $USER -setpolicy "maxMinutesUntilChangePassword=129600"
    
    echo "Politique de mots de passe de base configurée avec succès"
}

configure_password_policy

Paramètres de Sécurité Avancés

#!/bin/bash

# Configurer les paramètres avancés de mots de passe et de sécurité
configure_advanced_security() {
    echo "=== Configuration de Sécurité Avancée ==="
    
    # Activer l'exigence de mot de passe pour le réveil
    osascript -e 'tell application "System Events" to set require password to wake of security preferences to true'
    
    # Définir l'exigence immédiate de mot de passe
    defaults write com.apple.screensaver askForPassword -int 1
    defaults write com.apple.screensaver askForPasswordDelay -int 0
    
    # Configurer la politique de verrouillage de compte
    sudo pwpolicy -a diradmin -setpolicy "maxFailedLoginAttempts=5"
    
    # Activer la déconnexion automatique après inactivité
    sudo defaults write /Library/Preferences/.GlobalPreferences com.apple.autologout.AutoLogOutDelay -int 3600
    
    echo "Paramètres de sécurité avancés configurés"
}

configure_advanced_security

Application du Verrouillage d'Écran

Verrouillage Automatique d'Écran

#!/bin/bash

# Configurer les paramètres de verrouillage automatique d'écran
configure_screen_lock() {
    local lock_delay="${1:-300}" # Par défaut 5 minutes
    
    echo "Configuration du verrouillage d'écran avec un délai de ${lock_delay} secondes"
    
    # Définir le temps d'activation de l'économiseur d'écran
    defaults -currentHost write com.apple.screensaver idleTime -int "$lock_delay"
    
    # Activer l'exigence de mot de passe pour l'économiseur d'écran
    defaults write com.apple.screensaver askForPassword -int 1
    defaults write com.apple.screensaver askForPasswordDelay -int 0
    
    # Configurer les paramètres d'économie d'énergie
    sudo pmset -a displaysleep 5    # Mise en veille de l'écran après 5 minutes
    sudo pmset -a sleep 30          # Mise en veille du système après 30 minutes
    
    # Arrêter les préférences d'économiseur d'écran pour appliquer les changements
    killall ScreenSaverEngine 2>/dev/null || true
    
    echo "Verrouillage d'écran configuré avec succès"
}

# Utilisation : configure_screen_lock [délai_en_secondes]
configure_screen_lock 300

Application de Verrouillage Immédiat

#!/bin/bash

# Forcer le verrouillage immédiat de l'écran
force_screen_lock() {
    echo "Forçage du verrouillage immédiat de l'écran..."
    
    # Méthodes multiples pour assurer le verrouillage
    /System/Library/CoreServices/Menu\ Extras/User.menu/Contents/Resources/CGSession -suspend
    
    # Méthode alternative utilisant pmset
    pmset displaysleepnow
    
    # Activer l'économiseur d'écran comme solution de secours
    /System/Library/Frameworks/ScreenSaver.framework/Resources/ScreenSaverEngine.app/Contents/MacOS/ScreenSaverEngine -background &
    
    echo "Écran verrouillé avec succès"
}

force_screen_lock

Application de la Complexité des Mots de Passe

Validation de la Complexité des Mots de Passe

#!/bin/bash

# Valider la complexité des mots de passe
validate_password_complexity() {
    local password="$1"
    local min_length=8
    local errors=0
    
    echo "=== Validation de la Complexité des Mots de Passe ==="
    
    # Vérifier la longueur minimale
    if [[ ${#password} -lt $min_length ]]; then
        echo "❌ Le mot de passe doit contenir au moins $min_length caractères"
        ((errors++))
    else
        echo "✅ Exigence de longueur respectée"
    fi
    
    # Vérifier la présence d'une lettre majuscule
    if [[ ! "$password" =~ [A-Z] ]]; then
        echo "❌ Le mot de passe doit contenir au moins une lettre majuscule"
        ((errors++))
    else
        echo "✅ Lettre majuscule trouvée"
    fi
    
    # Vérifier la présence d'une lettre minuscule
    if [[ ! "$password" =~ [a-z] ]]; then
        echo "❌ Le mot de passe doit contenir au moins une lettre minuscule"
        ((errors++))
    else
        echo "✅ Lettre minuscule trouvée"
    fi
    
    # Vérifier la présence d'un chiffre
    if [[ ! "$password" =~ [0-9] ]]; then
        echo "❌ Le mot de passe doit contenir au moins un chiffre"
        ((errors++))
    else
        echo "✅ Chiffre trouvé"
    fi
    
    # Vérifier la présence d'un caractère spécial
    if [[ ! "$password" =~ [^a-zA-Z0-9] ]]; then
        echo "❌ Le mot de passe doit contenir au moins un caractère spécial"
        ((errors++))
    else
        echo "✅ Caractère spécial trouvé"
    fi
    
    # Vérifier les motifs courants
    if [[ "$password" =~ (123|abc|password|qwerty) ]]; then
        echo "❌ Le mot de passe contient des motifs courants"
        ((errors++))
    else
        echo "✅ Aucun motif courant détecté"
    fi
    
    if [[ $errors -eq 0 ]]; then
        echo "✅ Le mot de passe respecte toutes les exigences de complexité"
        return 0
    else
        echo "❌ Le mot de passe a échoué à $errors vérifications de complexité"
        return 1
    fi
}

# Exemple d'utilisation (ne pas utiliser en production avec de vrais mots de passe)
# validate_password_complexity "MotDePasseTest123!"

Génération de Mots de Passe

#!/bin/bash

# Générer des mots de passe sécurisés
generate_secure_password() {
    local length="${1:-12}"
    local include_symbols="${2:-true}"
    
    echo "=== Génération de Mots de Passe Sécurisés ==="
    
    if [[ "$include_symbols" == "true" ]]; then
        # Générer un mot de passe avec des symboles
        local charset='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
    else
        # Générer un mot de passe alphanumérique
        local charset='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
    fi
    
    # Générer un mot de passe aléatoire
    local password=$(openssl rand -base64 32 | tr -d "=+/" | cut -c1-${length})
    
    # Assurer les exigences de complexité
    password="${password:0:$((length-4))}A1@z"
    
    echo "Longueur du mot de passe généré : ${#password}"
    echo "Complexité du mot de passe vérifiée"
    
    # Valider le mot de passe généré
    if validate_password_complexity "$password"; then
        echo "✅ Le mot de passe généré respecte toutes les exigences"
    fi
}

generate_secure_password 12 true

Gestion des Comptes Utilisateur

Réinitialisation et Gestion des Mots de Passe

#!/bin/bash

# Gestion des mots de passe des comptes utilisateur
manage_user_passwords() {
    local username="$1"
    local action="$2"
    
    echo "=== Gestion des Mots de Passe Utilisateur ==="
    echo "Gestion du mot de passe pour l'utilisateur : $username"
    
    case "$action" in
        "reset")
            # Forcer la réinitialisation du mot de passe à la prochaine connexion
            sudo pwpolicy -a diradmin -u "$username" -setpolicy "newPasswordRequired=1"
            echo "Réinitialisation du mot de passe requise pour $username à la prochaine connexion"
            ;;
        "expire")
            # Faire expirer le mot de passe immédiatement
            sudo pwpolicy -a diradmin -u "$username" -setpolicy "passwordLastSetTime=0"
            echo "Mot de passe expiré pour $username"
            ;;
        "unlock")
            # Déverrouiller le compte après des tentatives échouées
            sudo pwpolicy -a diradmin -u "$username" -clearfailedlogins
            echo "Compte déverrouillé pour $username"
            ;;
        "status")
            # Vérifier le statut du mot de passe
            sudo pwpolicy -a diradmin -u "$username" -getpolicy
            ;;
        *)
            echo "Usage : manage_user_passwords <nom_utilisateur> <reset|expire|unlock|status>"
            return 1
            ;;
    esac
}

# Exemple d'utilisation
# manage_user_passwords "johndoe" "status"

Gestion des Secure Tokens

#!/bin/bash

# Ajouter un secure token au compte utilisateur
add_secure_token() {
    local admin_user="$1"
    local admin_password="$2"
    local target_user="$3"
    local target_password="$4"
    
    echo "=== Gestion des Secure Tokens ==="
    
    # Vérifier la compatibilité de la version macOS
    local macos_version=$(sw_vers -productVersion)
    echo "Version macOS : $macos_version"
    
    # Vérifier si l'utilisateur cible a déjà un secure token
    if sysadminctl -secureTokenStatus "$target_user" 2>&1 | grep -q "ENABLED"; then
        echo "✅ $target_user a déjà un SecureToken"
        return 0
    fi
    
    # Vérifier si l'utilisateur admin a un secure token
    if sysadminctl -secureTokenStatus "$admin_user" 2>&1 | grep -q "DISABLED"; then
        echo "❌ L'utilisateur admin $admin_user n'a pas de SecureToken"
        return 1
    fi
    
    echo "Ajout du SecureToken à $target_user..."
    
    # Ajouter le secure token
    if sysadminctl -adminUser "$admin_user" \
                   -adminPassword "$admin_password" \
                   -secureTokenOn "$target_user" \
                   -password "$target_password"; then
        echo "✅ SecureToken ajouté avec succès à $target_user"
    else
        echo "❌ Échec de l'ajout du SecureToken à $target_user"
        return 1
    fi
}

# Exemple d'utilisation (remplacer par les vraies informations d'identification dans un environnement sécurisé)
# add_secure_token "admin" "mot_passe_admin" "utilisateur" "mot_passe_utilisateur"

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

#!/bin/bash

# Système de Gestion de Mots de Passe d'Entreprise Roundfleet
# Application et surveillance complètes des politiques de mots de passe

# Configuration
LOG_FILE="/var/log/roundfleet_password_security.log"
POLICY_CONFIG="/etc/roundfleet/password_policy.conf"
COMPLIANCE_REPORT="/var/log/roundfleet_password_compliance.json"

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

# Charger la configuration de politique de mots de passe
load_policy_config() {
    if [[ -f "$POLICY_CONFIG" ]]; then
        source "$POLICY_CONFIG"
    else
        # Valeurs par défaut
        MIN_PASSWORD_LENGTH=8
        MAX_PASSWORD_AGE=90
        PASSWORD_HISTORY=5
        MAX_FAILED_ATTEMPTS=5
        LOCK_TIMEOUT=300
        COMPLEXITY_REQUIRED=true
    fi
}

# Vérifier la conformité des mots de passe pour tous les utilisateurs
check_password_compliance() {
    log_action "Début de la vérification de conformité des mots de passe"
    
    local compliance_data='{"timestamp":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","users":[]}'
    local non_compliant_count=0
    
    # Obtenir tous les utilisateurs locaux
    local users=$(dscl . list /Users | grep -v '^_' | grep -v 'daemon\|nobody\|root')
    
    while IFS= read -r username; do
        if [[ -n "$username" ]]; then
            log_action "Vérification de la conformité pour l'utilisateur : $username"
            
            local user_data='{"username":"'$username'","compliant":true,"issues":[]}'
            local issues=()
            
            # Vérifier l'âge du mot de passe
            local last_change=$(dscl . read "/Users/$username" passwordPolicyOptions | grep -o 'passwordLastSetTime</key><real>[0-9.]*' | cut -d'>' -f2 || echo "0")
            if [[ -n "$last_change" && "$last_change" != "0" ]]; then
                local age_days=$(( ($(date +%s) - ${last_change%.*}) / 86400 ))
                if [[ $age_days -gt $MAX_PASSWORD_AGE ]]; then
                    issues+=("Mot de passe expiré ($age_days jours)")
                fi
            fi
            
            # Vérifier le statut de verrouillage du compte
            local failed_attempts=$(dscl . read "/Users/$username" | grep -c "authenticationHint" || echo "0")
            
            # Vérifier le statut du secure token
            if ! sysadminctl -secureTokenStatus "$username" 2>&1 | grep -q "ENABLED"; then
                issues+=("Pas de SecureToken")
            fi
            
            # Mettre à jour les données de conformité
            if [[ ${#issues[@]} -gt 0 ]]; then
                user_data='{"username":"'$username'","compliant":false,"issues":["'$(IFS='","'; echo "${issues[*]}")'"]}' 
                ((non_compliant_count++))
            fi
            
            # Ajouter au rapport de conformité
            compliance_data=$(echo "$compliance_data" | jq --argjson user "$user_data" '.users += [$user]')
        fi
    done <<< "$users"
    
    # Sauvegarder le rapport de conformité
    echo "$compliance_data" | jq . > "$COMPLIANCE_REPORT"
    
    log_action "Vérification de conformité terminée : $non_compliant_count utilisateurs non conformes trouvés"
    
    if [[ $non_compliant_count -gt 0 ]]; then
        log_action "⚠️ Problèmes de conformité des mots de passe détectés"
        return 1
    else
        log_action "✅ Tous les utilisateurs sont conformes aux mots de passe"
        return 0
    fi
}

# Appliquer les politiques de mots de passe
enforce_password_policies() {
    log_action "Début de l'application des politiques de mots de passe"
    
    # Configurer les politiques de mots de passe à l'échelle du système
    log_action "Application des politiques de mots de passe à l'échelle du système"
    
    # Définir les exigences de complexité des mots de passe
    if [[ "$COMPLEXITY_REQUIRED" == "true" ]]; then
        sudo pwpolicy -a diradmin -setglobalpolicy "minChars=$MIN_PASSWORD_LENGTH requiresAlpha requiresNumeric"
        log_action "Exigences de complexité des mots de passe définies"
    fi
    
    # Configurer le verrouillage de compte
    sudo pwpolicy -a diradmin -setglobalpolicy "maxFailedLoginAttempts=$MAX_FAILED_ATTEMPTS"
    log_action "Politique de verrouillage de compte définie à $MAX_FAILED_ATTEMPTS tentatives échouées"
    
    # Configurer l'historique des mots de passe
    sudo pwpolicy -a diradmin -setglobalpolicy "usingHistory=$PASSWORD_HISTORY"
    log_action "Historique des mots de passe défini à $PASSWORD_HISTORY mots de passe précédents"
    
    # Configurer le verrouillage d'écran
    defaults write com.apple.screensaver askForPassword -int 1
    defaults write com.apple.screensaver askForPasswordDelay -int 0
    log_action "Exigence de mot de passe pour le verrouillage d'écran activée"
    
    # Définir le verrouillage automatique d'écran
    defaults -currentHost write com.apple.screensaver idleTime -int "$LOCK_TIMEOUT"
    log_action "Verrouillage automatique d'écran défini à $LOCK_TIMEOUT secondes"
}

# Générer un rapport de conformité des mots de passe
generate_compliance_report() {
    log_action "Génération du rapport de conformité des mots de passe"
    
    if [[ -f "$COMPLIANCE_REPORT" ]]; then
        local total_users=$(jq '.users | length' "$COMPLIANCE_REPORT")
        local compliant_users=$(jq '.users | map(select(.compliant == true)) | length' "$COMPLIANCE_REPORT")
        local non_compliant_users=$(jq '.users | map(select(.compliant == false)) | length' "$COMPLIANCE_REPORT")
        
        echo "=== Rapport de Conformité des Mots de Passe ==="
        echo "Rapport Généré : $(jq -r '.timestamp' "$COMPLIANCE_REPORT")"
        echo "Total des Utilisateurs : $total_users"
        echo "Utilisateurs Conformes : $compliant_users"
        echo "Utilisateurs Non Conformes : $non_compliant_users"
        echo "Taux de Conformité : $(( (compliant_users * 100) / total_users ))%"
        
        if [[ $non_compliant_users -gt 0 ]]; then
            echo ""
            echo "Utilisateurs Non Conformes :"
            jq -r '.users[] | select(.compliant == false) | "- " + .username + ": " + (.issues | join(", "))' "$COMPLIANCE_REPORT"
        fi
    else
        echo "Aucun rapport de conformité trouvé. Exécutez d'abord la vérification de conformité."
    fi
}

# Tâches automatisées de sécurité des mots de passe
run_security_maintenance() {
    log_action "=== Début de la maintenance automatisée de sécurité des mots de passe ==="
    
    # Charger la configuration
    load_policy_config
    
    # Vérifier la conformité
    check_password_compliance
    
    # Appliquer les politiques
    enforce_password_policies
    
    # Générer le rapport
    generate_compliance_report
    
    log_action "=== Maintenance de sécurité des mots de passe terminée ==="
}

# Exécution principale
main() {
    local action="${1:-maintenance}"
    
    case "$action" in
        "compliance")
            load_policy_config
            check_password_compliance
            ;;
        "enforce")
            load_policy_config
            enforce_password_policies
            ;;
        "report")
            generate_compliance_report
            ;;
        "maintenance")
            run_security_maintenance
            ;;
        *)
            echo "Usage : $0 [compliance|enforce|report|maintenance]"
            echo "  compliance - Vérifier la conformité des mots de passe pour tous les utilisateurs"
            echo "  enforce    - Appliquer les politiques de mots de passe"
            echo "  report     - Générer le rapport de conformité"
            echo "  maintenance - Exécuter le cycle de maintenance complet (par défaut)"
            exit 1
            ;;
    esac
}

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

Fichier de Configuration de Politique de Mots de Passe

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

#!/bin/bash

# Créer la configuration de politique de mots de passe
create_policy_config() {
    local config_dir="/etc/roundfleet"
    local config_file="$config_dir/password_policy.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 Politique de Mots de Passe Roundfleet

# Exigences des Mots de Passe
MIN_PASSWORD_LENGTH=8
MAX_PASSWORD_LENGTH=128
REQUIRE_UPPERCASE=true
REQUIRE_LOWERCASE=true
REQUIRE_NUMBERS=true
REQUIRE_SPECIAL_CHARS=true

# Rotation des Mots de Passe
MAX_PASSWORD_AGE=90          # Jours avant expiration du mot de passe
PASSWORD_HISTORY=5           # Nombre de mots de passe précédents à mémoriser
EXPIRATION_WARNING_DAYS=14   # Jours avant expiration pour avertir l'utilisateur

# Sécurité des Comptes
MAX_FAILED_ATTEMPTS=5        # Tentatives de connexion échouées avant verrouillage
LOCKOUT_DURATION=1800        # Durée de verrouillage du compte en secondes
AUTO_UNLOCK=true             # Déverrouillage automatique après la durée de verrouillage

# Sécurité d'Écran
LOCK_TIMEOUT=300             # Délai de verrouillage d'écran en secondes
IMMEDIATE_LOCK=true          # Exiger le mot de passe immédiatement après verrouillage
SCREEN_SAVER_TIMEOUT=600     # Délai d'activation de l'économiseur d'écran

# Conformité
COMPLEXITY_REQUIRED=true     # Forcer la complexité des mots de passe
SECURE_TOKEN_REQUIRED=true   # Exiger SecureToken pour tous les utilisateurs
REGULAR_AUDITS=true          # Activer les audits de conformité réguliers
AUDIT_FREQUENCY=7            # Jours entre les audits de conformité

# Journalisation
ENABLE_LOGGING=true          # Activer la journalisation des événements de sécurité
LOG_LEVEL="INFO"             # Niveau de journalisation : DEBUG, INFO, WARN, ERROR
LOG_RETENTION=30             # Jours de rétention des fichiers journaux
EOF

    echo "Configuration de politique de mots de passe créée à : $config_file"
}

create_policy_config

Intégration avec la Gestion Roundfleet

#!/bin/bash

# Intégration de gestion de mots de passe Roundfleet
roundfleet_password_integration() {
    echo "=== Intégration de Gestion de Mots de Passe Roundfleet ==="
    
    # Enregistrement d'appareil
    local device_id=$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')
    local hostname=$(hostname)
    
    echo "ID d'Appareil : $device_id"
    echo "Nom d'Hôte : $hostname"
    
    # Rapport à l'API Roundfleet (placeholder)
    local api_endpoint="https://api.roundfleet.com/devices/$device_id/security"
    local report_data='{
        "device_id": "'$device_id'",
        "hostname": "'$hostname'",
        "timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'",
        "password_policy_status": "enforced",
        "compliance_check": "'$(date +%s)'",
        "security_level": "enterprise"
    }'
    
    echo "Statut de sécurité rapporté à Roundfleet"
}

roundfleet_password_integration

Notes de Sécurité Importantes

Stockage et Manipulation des Mots de Passe

Ne jamais journaliser les vrais mots de passe dans les scripts ou les journaux
Utiliser une gestion sécurisée des informations d'identification pour les mots de passe administratifs
Implémenter un chiffrement approprié pour toute donnée d'authentification stockée
Audits de sécurité réguliers des politiques de mots de passe et de la conformité

Meilleures Pratiques

Tester les politiques sur des appareils de développement avant le déploiement de flotte
Déploiement progressif des nouvelles exigences de mots de passe
Communication utilisateur sur les changements de politique
Procédures d'urgence pour les verrouillages de compte et réinitialisations de mots de passe

Surveillance et Conformité

Audits réguliers de la conformité des mots de passe sur la flotte
Alertes automatisées pour les violations de politique
Tableau de bord de rapports pour le statut de sécurité
Intégration avec les systèmes de gestion d'identité d'entreprise

Ce système d'application de mots de passe d'entreprise fournit une gestion de sécurité complète pour les appareils Roundfleet tout en maintenant l'utilisabilité et la conformité aux standards de sécurité d'entreprise.

Guide

Avis important