Gestion d'Entreprise des Utilisateurs de Partage sur macOS

Gérez les comptes utilisateurs de partage uniquement sur vos appareils Roundfleet en utilisant des commandes dscl avancées. Ce tutoriel couvre la création d'utilisateurs, les politiques de sécurité, le déploiement en masse et la gestion du cycle de vie des utilisateurs en entreprise.

Comprendre la Gestion d'Utilisateurs macOS

macOS utilise l'utilitaire de ligne de commande Directory Service (dscl) pour la gestion des utilisateurs :

dscl - Utilitaire de ligne de commande Directory Service
Répertoire Local - /var/db/dslocal/nodes/Default
Enregistrements Utilisateur - Stockés dans le chemin /Users/
Utilisateurs de Partage Uniquement - Comptes d'accès limité pour le partage de fichiers

Création d'Utilisateur de Partage de Base

Utilisateur de Partage Simple

#!/bin/bash

# Créer un compte utilisateur de partage uniquement de base
USERNAME="UtilisateurPartage"
DISPLAY_NAME="Compte de Partage"
PASSWORD="MotDePasseSecurise123"
USER_ID="550"

# Créer l'utilisateur
sudo dscl . create /Users/"$USERNAME"

# Définir le nom d'affichage
sudo dscl . create /Users/"$USERNAME" RealName "$DISPLAY_NAME"

# Définir le mot de passe
sudo dscl . passwd /Users/"$USERNAME" "$PASSWORD"

# Définir l'ID unique
sudo dscl . create /Users/"$USERNAME" UniqueID "$USER_ID"

# Définir l'ID de groupe (groupe staff)
sudo dscl . create /Users/"$USERNAME" PrimaryGroupID 20

# Refuser l'accès shell
sudo dscl . create /Users/"$USERNAME" UserShell /usr/bin/false

# Aucun répertoire home
sudo dscl . create /Users/"$USERNAME" NFSHomeDirectory /dev/null

echo "Utilisateur de partage '$USERNAME' créé avec succès"

Utilisateur de Partage Amélioré avec Options

#!/bin/bash

# Création d'utilisateur de partage améliorée avec options supplémentaires
create_sharing_user() {
    local username="$1"
    local display_name="$2"
    local password="$3"
    local hint="$4"
    local picture_path="$5"
    local user_id="$6"
    
    echo "Création de l'utilisateur de partage : $username"
    
    # Créer l'utilisateur
    sudo dscl . create /Users/"$username"
    
    # Définir le nom d'affichage
    sudo dscl . create /Users/"$username" RealName "$display_name"
    
    # Définir le mot de passe
    sudo dscl . passwd /Users/"$username" "$password"
    
    # Définir l'indice de mot de passe (optionnel)
    if [[ -n "$hint" ]]; then
        sudo dscl . create /Users/"$username" hint "$hint"
    fi
    
    # Définir l'image de profil (optionnel)
    if [[ -n "$picture_path" && -f "$picture_path" ]]; then
        sudo dscl . create /Users/"$username" picture "$picture_path"
    fi
    
    # Définir l'ID unique
    sudo dscl . create /Users/"$username" UniqueID "$user_id"
    
    # Définir l'ID de groupe
    sudo dscl . create /Users/"$username" PrimaryGroupID 20
    
    # Refuser l'accès shell
    sudo dscl . create /Users/"$username" UserShell /usr/bin/false
    
    # Aucun répertoire home
    sudo dscl . create /Users/"$username" NFSHomeDirectory /dev/null
    
    echo "✅ Utilisateur de partage '$username' créé avec succès"
    return 0
}

# Exemples d'utilisation
create_sharing_user "PartagerFichiers" "Compte de Partage de Fichiers" "FichierPass123" "Accès fichiers uniquement" "" "551"
create_sharing_user "AccesInvite" "Utilisateur Invité" "InvitePass456" "Accès temporaire" "/System/Library/User Pictures/Animals/Butterfly.tif" "552"

Catégories d'Utilisateurs d'Entreprise

Classifications de Types d'Utilisateurs

#!/bin/bash

# Catégories d'utilisateurs d'entreprise avec configurations spécifiques
declare -A USER_CATEGORIES=(
    ["partage_standard"]="Accès de partage de fichiers standard"
    ["partage_securise"]="Partage haute sécurité avec restrictions"
    ["invite_temporaire"]="Accès invité temporaire avec expiration"
    ["compte_service"]="Comptes de service pour applications"
    ["partage_departemental"]="Comptes partagés spécifiques au département"
    ["partenaire_externe"]="Accès limité partenaire externe"
    ["kiosque_public"]="Comptes d'accès kiosque public"
)

# Politiques de sécurité pour chaque catégorie
declare -A SECURITY_POLICIES=(
    ["partage_standard"]="politique_mot_de_passe:standard,niveau_audit:basique,delai_session:8h"
    ["partage_securise"]="politique_mot_de_passe:fort,niveau_audit:complet,delai_session:2h,mfa_requis:true"
    ["invite_temporaire"]="politique_mot_de_passe:basique,niveau_audit:complet,delai_session:1h,expiration_auto:24h"
    ["compte_service"]="politique_mot_de_passe:service,niveau_audit:systeme,non_interactif:true"
    ["partage_departemental"]="politique_mot_de_passe:departement,niveau_audit:departement,restrictions_groupe:true"
    ["partenaire_externe"]="politique_mot_de_passe:externe,niveau_audit:complet,restrictions_reseau:true"
    ["kiosque_public"]="politique_mot_de_passe:public,niveau_audit:minimal,delai_session:30m,reinitialisation_deconnexion:true"
)

# Définitions de contrôle d'accès
declare -A ACCESS_CONTROLS=(
    ["partage_standard"]="partage_fichiers:lecture_ecriture,acces_impression:oui,acces_reseau:local"
    ["partage_securise"]="partage_fichiers:lecture_seule,acces_impression:restreint,acces_reseau:vpn_seulement"
    ["invite_temporaire"]="partage_fichiers:dossier_invite,acces_impression:non,acces_reseau:wifi_invite"
    ["compte_service"]="partage_fichiers:repertoires_service,acces_impression:non,acces_reseau:ports_service"
    ["partage_departemental"]="partage_fichiers:repertoires_departement,acces_impression:departement,acces_reseau:vlan_departement"
    ["partenaire_externe"]="partage_fichiers:repertoires_partenaire,acces_impression:non,acces_reseau:dmz_partenaire"
    ["kiosque_public"]="partage_fichiers:documents_publics,acces_impression:public,acces_reseau:wifi_public"
)

print_user_categories() {
    echo "=== Catégories d'Utilisateurs Disponibles ==="
    for category in "${!USER_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${USER_CATEGORIES[$category]}"
        echo "  Sécurité : ${SECURITY_POLICIES[$category]}"
        echo "  Accès : ${ACCESS_CONTROLS[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_user_categories

Politiques de Gestion d'Utilisateurs

Moteur de Politique de Mot de Passe

#!/bin/bash

# Définitions de politiques de mot de passe pour différents types d'utilisateurs
generate_password_policy() {
    local policy_type="$1"
    
    case "$policy_type" in
        "standard")
            echo "longueur_min:8,complexite:moyenne,expiration:90j,historique:5"
            ;;
        "fort")
            echo "longueur_min:12,complexite:haute,expiration:60j,historique:10,caracteres_speciaux:requis"
            ;;
        "basique")
            echo "longueur_min:6,complexite:faible,expiration:jamais,historique:3"
            ;;
        "service")
            echo "longueur_min:16,complexite:haute,expiration:180j,historique:20,genere_machine:true"
            ;;
        "departement")
            echo "longueur_min:10,complexite:moyenne,expiration:120j,historique:8,prefixe_departement:requis"
            ;;
        "externe")
            echo "longueur_min:14,complexite:haute,expiration:30j,historique:15,validation_externe:requise"
            ;;
        "public")
            echo "longueur_min:4,complexite:aucune,expiration:quotidienne,historique:1,reinitialisation_auto:true"
            ;;
        *)
            echo "longueur_min:8,complexite:moyenne,expiration:90j,historique:5"
            ;;
    esac
}

# Générer un mot de passe sécurisé basé sur la politique
generate_secure_password() {
    local policy="$1"
    local length
    local complexity
    
    # Analyser la politique
    length=$(echo "$policy" | grep -o 'longueur_min:[0-9]*' | cut -d: -f2)
    complexity=$(echo "$policy" | grep -o 'complexite:[a-z]*' | cut -d: -f2)
    
    case "$complexity" in
        "haute")
            # Haute complexité : majuscules, minuscules, chiffres, caractères spéciaux
            openssl rand -base64 $((length * 2)) | tr -d "=+/" | cut -c1-"$length" | sed 's/./&@1A/4'
            ;;
        "moyenne")
            # Complexité moyenne : majuscules, minuscules, chiffres
            openssl rand -base64 "$length" | tr -d "=+/" | cut -c1-"$length"
            ;;
        "faible")
            # Faible complexité : alphanumérique
            openssl rand -hex "$((length/2))" | cut -c1-"$length"
            ;;
        *)
            # Complexité moyenne par défaut
            openssl rand -base64 "$length" | tr -d "=+/" | cut -c1-"$length"
            ;;
    esac
}

# Valider le mot de passe contre la politique
validate_password() {
    local password="$1"
    local policy="$2"
    local min_length complexity
    
    min_length=$(echo "$policy" | grep -o 'longueur_min:[0-9]*' | cut -d: -f2)
    complexity=$(echo "$policy" | grep -o 'complexite:[a-z]*' | cut -d: -f2)
    
    # Vérifier la longueur
    if [[ ${#password} -lt $min_length ]]; then
        echo "❌ Mot de passe trop court (minimum $min_length caractères)"
        return 1
    fi
    
    # Vérifier la complexité
    case "$complexity" in
        "haute")
            if ! [[ "$password" =~ [A-Z] && "$password" =~ [a-z] && "$password" =~ [0-9] && "$password" =~ [^A-Za-z0-9] ]]; then
                echo "❌ Le mot de passe doit contenir majuscules, minuscules, chiffres et caractères spéciaux"
                return 1
            fi
            ;;
        "moyenne")
            if ! [[ "$password" =~ [A-Z] && "$password" =~ [a-z] && "$password" =~ [0-9] ]]; then
                echo "❌ Le mot de passe doit contenir majuscules, minuscules et chiffres"
                return 1
            fi
            ;;
    esac
    
    echo "✅ Le mot de passe respecte les exigences de la politique"
    return 0
}

Profils de Déploiement d'Entreprise

Modèles de Configuration de Déploiement

#!/bin/bash

# Profils de déploiement d'entreprise pour différents besoins organisationnels
declare -A DEPLOYMENT_PROFILES=(
    ["entreprise_standard"]="Déploiement d'entreprise standard avec sécurité de base"
    ["haute_securite_finance"]="Déploiement haute sécurité pour départements financiers"
    ["acces_invite_accueil"]="Déploiement d'accès invité pour zones d'accueil/publiques"
    ["collaboration_partenaire"]="Déploiement de collaboration partenaire externe"
    ["kiosque_public_bibliotheque"]="Déploiement kiosque public pour bibliothèques/espaces publics"
    ["recherche_developpement"]="Déploiement équipe recherche et développement"
    ["executif_securise"]="Déploiement sécurisé niveau exécutif"
)

# Configurations spécifiques aux profils
get_deployment_config() {
    local profile="$1"
    
    case "$profile" in
        "entreprise_standard")
            cat << EOF
{
    "categorie_utilisateur": "partage_standard",
    "politique_mot_de_passe": "standard",
    "niveau_acces": "fichiers_departement",
    "delai_session": "8h",
    "niveau_audit": "basique",
    "appartenance_groupe": ["staff", "partage_fichiers"],
    "restrictions": {
        "acces_shell": false,
        "repertoire_home": false,
        "privileges_admin": false
    },
    "surveillance": {
        "suivi_connexion": true,
        "journal_acces_fichiers": true,
        "tentatives_echec": 5
    }
}
EOF
            ;;
        "haute_securite_finance")
            cat << EOF
{
    "categorie_utilisateur": "partage_securise",
    "politique_mot_de_passe": "fort",
    "niveau_acces": "finance_restreint",
    "delai_session": "2h",
    "niveau_audit": "complet",
    "appartenance_groupe": ["finance", "partage_securise"],
    "restrictions": {
        "acces_shell": false,
        "repertoire_home": false,
        "privileges_admin": false,
        "acces_reseau": "vlan_finance_seulement",
        "restrictions_horaires": "heures_bureau"
    },
    "securite": {
        "mfa_requis": true,
        "chiffrement": "aes256",
        "rotation_cles": "mensuelle"
    },
    "surveillance": {
        "alertes_temps_reel": true,
        "suivi_connexion": true,
        "journal_acces_fichiers": true,
        "tentatives_echec": 3,
        "rapport_conformite": "sox_hipaa"
    }
}
EOF
            ;;
        "acces_invite_accueil")
            cat << EOF
{
    "categorie_utilisateur": "invite_temporaire",
    "politique_mot_de_passe": "basique",
    "niveau_acces": "ressources_invite",
    "delai_session": "1h",
    "niveau_audit": "complet",
    "appartenance_groupe": ["invite", "acces_public"],
    "restrictions": {
        "acces_shell": false,
        "repertoire_home": false,
        "privileges_admin": false,
        "acces_internet": "wifi_invite_seulement",
        "telechargement_fichiers": false
    },
    "automatisation": {
        "expiration_auto": "24h",
        "nettoyage_auto": true,
        "reinitialisation_deconnexion": true
    },
    "surveillance": {
        "enregistrement_session": true,
        "suivi_connexion": true,
        "journal_activite": true,
        "tentatives_echec": 3
    }
}
EOF
            ;;
        *)
            echo "Profil de déploiement inconnu : $profile"
            return 1
            ;;
    esac
}

# Appliquer un profil de déploiement
apply_deployment_profile() {
    local profile="$1"
    local config_file="/tmp/deployment_config.json"
    
    echo "Application du profil de déploiement : $profile"
    
    # Obtenir la configuration
    get_deployment_config "$profile" > "$config_file"
    
    if [[ ! -f "$config_file" ]]; then
        echo "❌ Échec de génération de configuration pour le profil : $profile"
        return 1
    fi
    
    echo "✅ Configuration de déploiement prête"
    echo "Configuration sauvegardée dans : $config_file"
    
    # Analyser et afficher les paramètres clés
    echo "=== Résumé du Profil ==="
    echo "Catégorie Utilisateur : $(jq -r '.categorie_utilisateur' "$config_file")"
    echo "Politique Mot de Passe : $(jq -r '.politique_mot_de_passe' "$config_file")"
    echo "Niveau d'Accès : $(jq -r '.niveau_acces' "$config_file")"
    echo "Délai Session : $(jq -r '.delai_session' "$config_file")"
    echo "Niveau Audit : $(jq -r '.niveau_audit' "$config_file")"
    
    return 0
}

Système de Gestion d'Utilisateurs d'Entreprise

#!/bin/bash

# Système de Gestion d'Utilisateurs d'Entreprise Roundfleet
# Création et gestion complètes d'utilisateurs de partage

# Configuration
CONFIG_DIR="/etc/roundfleet/users"
LOG_FILE="/var/log/roundfleet_gestion_utilisateurs.log"
BACKUP_DIR="/var/backups/roundfleet/users"
REPORTS_DIR="/var/reports/roundfleet/users"
AUDIT_LOG="/var/log/roundfleet_audit_utilisateurs.log"

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

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

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

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

# Gestion d'ID utilisateur
get_next_user_id() {
    local start_id="$1"
    local current_id="$start_id"
    
    while dscl . list /Users UniqueID | awk '{print $2}' | grep -q "^${current_id}$"; do
        ((current_id++))
    done
    
    echo "$current_id"
}

# Fonction de création d'utilisateur complète
create_enterprise_user() {
    local username="$1"
    local display_name="$2"
    local user_category="$3"
    local deployment_profile="$4"
    local department="$5"
    local expiry_date="$6"
    
    log_action "Début création utilisateur : $username (Catégorie : $user_category, Profil : $deployment_profile)"
    
    # Valider les entrées
    if [[ -z "$username" || -z "$display_name" || -z "$user_category" ]]; then
        log_error "Paramètres requis manquants pour la création d'utilisateur"
        return 1
    fi
    
    # Vérifier si l'utilisateur existe déjà
    if dscl . read /Users/"$username" &>/dev/null; then
        log_error "L'utilisateur $username existe déjà"
        return 1
    fi
    
    # Obtenir la configuration de déploiement
    local config_file="/tmp/user_config_${username}.json"
    get_deployment_config "$deployment_profile" > "$config_file"
    
    # Analyser la configuration
    local password_policy
    password_policy=$(jq -r '.politique_mot_de_passe' "$config_file")
    
    # Obtenir le prochain ID utilisateur disponible
    local user_id
    user_id=$(get_next_user_id 550)
    
    # Générer un mot de passe sécurisé
    local policy_details
    policy_details=$(generate_password_policy "$password_policy")
    local password
    password=$(generate_secure_password "$policy_details")
    
    # Créer les métadonnées utilisateur
    local metadata_file="$CONFIG_DIR/${username}_metadata.json"
    cat > "$metadata_file" << EOF
{
    "nom_utilisateur": "$username",
    "nom_affichage": "$display_name",
    "categorie_utilisateur": "$user_category",
    "profil_deploiement": "$deployment_profile",
    "departement": "$department",
    "id_utilisateur": $user_id,
    "date_creation": "$(date -Iseconds)",
    "cree_par": "$(whoami)",
    "date_expiration": "$expiry_date",
    "politique_mot_de_passe": "$password_policy",
    "statut": "actif"
}
EOF
    
    # Créer l'utilisateur
    log_action "Création de l'enregistrement utilisateur pour $username"
    sudo dscl . create /Users/"$username" || {
        log_error "Échec de création de l'enregistrement utilisateur pour $username"
        return 1
    }
    
    # Définir les propriétés de base
    sudo dscl . create /Users/"$username" RealName "$display_name"
    sudo dscl . passwd /Users/"$username" "$password"
    sudo dscl . create /Users/"$username" UniqueID "$user_id"
    sudo dscl . create /Users/"$username" PrimaryGroupID 20
    sudo dscl . create /Users/"$username" UserShell /usr/bin/false
    sudo dscl . create /Users/"$username" NFSHomeDirectory /dev/null
    
    # Ajouter des attributs personnalisés
    sudo dscl . create /Users/"$username" Comment "Utilisateur géré Roundfleet - $user_category"
    sudo dscl . create /Users/"$username" Keywords "roundfleet,$user_category,$deployment_profile,$department"
    
    # Définir la date d'expiration si fournie
    if [[ -n "$expiry_date" ]]; then
        sudo dscl . create /Users/"$username" ExpiryDate "$expiry_date"
    fi
    
    # Appliquer les appartenances de groupe
    local groups
    groups=$(jq -r '.appartenance_groupe[]' "$config_file" 2>/dev/null)
    while IFS= read -r group; do
        if [[ -n "$group" && "$group" != "null" ]]; then
            sudo dseditgroup -o edit -a "$username" -t user "$group" 2>/dev/null || {
                log_action "Le groupe $group n'existe pas, ignoré"
            }
        fi
    done <<< "$groups"
    
    # Stocker le mot de passe sécurisé (chiffré)
    echo "$password" | openssl enc -aes-256-cbc -pbkdf2 -k "roundfleet_$(hostname)" -out "$CONFIG_DIR/${username}_password.enc"
    
    # Créer une sauvegarde
    create_user_backup "$username"
    
    # Journalisation d'audit
    audit_log "Utilisateur créé : $username (UID : $user_id, Catégorie : $user_category, Profil : $deployment_profile)"
    
    log_action "✅ Utilisateur $username créé avec succès (UID : $user_id)"
    
    # Retourner le mot de passe pour communication initiale (en production, utiliser une livraison sécurisée)
    echo "INFO_UTILISATEUR_CREE:$username:$password:$user_id"
    
    return 0
}

# Création d'utilisateurs en masse
bulk_create_users() {
    local csv_file="$1"
    local created_count=0
    local failed_count=0
    
    if [[ ! -f "$csv_file" ]]; then
        log_error "Fichier CSV non trouvé : $csv_file"
        return 1
    fi
    
    log_action "Début création en masse d'utilisateurs depuis : $csv_file"
    
    # Traiter le fichier CSV (ignorer l'en-tête)
    tail -n +2 "$csv_file" | while IFS=',' read -r username display_name category profile department expiry; do
        if create_enterprise_user "$username" "$display_name" "$category" "$profile" "$department" "$expiry"; then
            ((created_count++))
        else
            ((failed_count++))
        fi
    done
    
    log_action "Création en masse terminée. Créés : $created_count, Échecs : $failed_count"
    
    # Générer un rapport
    generate_user_report "creation_masse_$(date +%Y%m%d_%H%M%S)"
}

# Fonctions de gestion d'utilisateurs
list_enterprise_users() {
    echo "=== Utilisateurs Gérés Roundfleet ==="
    echo "Nom d'utilisateur | Nom d'affichage | Catégorie | Statut | Créé"
    echo "------------------|-----------------|-----------|--------|------"
    
    for metadata_file in "$CONFIG_DIR"/*_metadata.json; do
        if [[ -f "$metadata_file" ]]; then
            local username display_name category status created_date
            username=$(jq -r '.nom_utilisateur' "$metadata_file")
            display_name=$(jq -r '.nom_affichage' "$metadata_file")
            category=$(jq -r '.categorie_utilisateur' "$metadata_file")
            status=$(jq -r '.statut' "$metadata_file")
            created_date=$(jq -r '.date_creation' "$metadata_file" | cut -d'T' -f1)
            
            printf "%-17s | %-15s | %-9s | %-6s | %s\n" "$username" "$display_name" "$category" "$status" "$created_date"
        fi
    done
}

# Suppression d'utilisateur avec nettoyage
remove_enterprise_user() {
    local username="$1"
    local backup_before_removal="$2"
    
    log_action "Début suppression de l'utilisateur : $username"
    
    # Vérifier si l'utilisateur existe
    if ! dscl . read /Users/"$username" &>/dev/null; then
        log_error "L'utilisateur $username n'existe pas"
        return 1
    fi
    
    # Créer une sauvegarde avant suppression
    if [[ "$backup_before_removal" == "true" ]]; then
        create_user_backup "$username"
    fi
    
    # Supprimer l'utilisateur du système
    sudo dscl . delete /Users/"$username" || {
        log_error "Échec de suppression de l'utilisateur $username du système"
        return 1
    }
    
    # Mettre à jour les métadonnées
    local metadata_file="$CONFIG_DIR/${username}_metadata.json"
    if [[ -f "$metadata_file" ]]; then
        jq '.statut = "supprime" | .date_suppression = now | .supprime_par = "'"$(whoami)"'"' "$metadata_file" > "${metadata_file}.tmp" && mv "${metadata_file}.tmp" "$metadata_file"
    fi
    
    # Journalisation d'audit
    audit_log "Utilisateur supprimé : $username par $(whoami)"
    
    log_action "✅ Utilisateur $username supprimé avec succès"
    return 0
}

# Sauvegarde et restauration d'utilisateur
create_user_backup() {
    local username="$1"
    local backup_file="$BACKUP_DIR/${username}_backup_$(date +%Y%m%d_%H%M%S).plist"
    
    log_action "Création de sauvegarde pour l'utilisateur : $username"
    
    # Exporter l'enregistrement utilisateur
    sudo dscl . read /Users/"$username" > "$backup_file"
    
    # Sauvegarder les métadonnées
    local metadata_file="$CONFIG_DIR/${username}_metadata.json"
    if [[ -f "$metadata_file" ]]; then
        cp "$metadata_file" "$BACKUP_DIR/${username}_metadata_$(date +%Y%m%d_%H%M%S).json"
    fi
    
    log_action "✅ Sauvegarde utilisateur créée : $backup_file"
}

# Surveillance de la santé du système
monitor_user_system() {
    echo "=== Vérification de Santé du Système Utilisateur ==="
    
    # Vérifier les utilisateurs expirés
    local expired_users=0
    for metadata_file in "$CONFIG_DIR"/*_metadata.json; do
        if [[ -f "$metadata_file" ]]; then
            local expiry_date username
            expiry_date=$(jq -r '.date_expiration' "$metadata_file")
            username=$(jq -r '.nom_utilisateur' "$metadata_file")
            
            if [[ "$expiry_date" != "null" && "$expiry_date" != "" ]]; then
                if [[ $(date -d "$expiry_date" +%s 2>/dev/null) -lt $(date +%s) ]]; then
                    echo "⚠️  Utilisateur expiré : $username (expiré : $expiry_date)"
                    ((expired_users++))
                fi
            fi
        fi
    done
    
    # Vérifier les enregistrements d'utilisateurs orphelins
    local system_users
    system_users=$(dscl . list /Users | grep -E "^(Partage|Invite|Service|Externe)" || true)
    local orphaned_users=0
    
    while IFS= read -r user; do
        if [[ -n "$user" && ! -f "$CONFIG_DIR/${user}_metadata.json" ]]; then
            echo "⚠️  Utilisateur orphelin (pas de métadonnées) : $user"
            ((orphaned_users++))
        fi
    done <<< "$system_users"
    
    # Résumé
    echo ""
    echo "Résumé de Santé :"
    echo "  Utilisateurs expirés : $expired_users"
    echo "  Utilisateurs orphelins : $orphaned_users"
    
    if [[ $expired_users -eq 0 && $orphaned_users -eq 0 ]]; then
        echo "✅ Le système utilisateur est en bonne santé"
    else
        echo "⚠️  Le système utilisateur nécessite une attention"
    fi
}

# Générer des rapports complets
generate_user_report() {
    local report_name="$1"
    local report_file="$REPORTS_DIR/${report_name}.json"
    
    log_action "Génération du rapport utilisateur : $report_name"
    
    # Collecter les statistiques utilisateur
    local total_users active_users inactive_users
    total_users=$(find "$CONFIG_DIR" -name "*_metadata.json" | wc -l)
    active_users=$(grep -l '"statut": "actif"' "$CONFIG_DIR"/*_metadata.json 2>/dev/null | wc -l)
    inactive_users=$((total_users - active_users))
    
    # Répartition par catégorie
    local categories
    categories=$(jq -r '.categorie_utilisateur' "$CONFIG_DIR"/*_metadata.json 2>/dev/null | sort | uniq -c | awk '{print "{\"categorie\": \"" $2 "\", \"compte\": " $1 "}"}' | jq -s '.')
    
    # Générer le rapport
    cat > "$report_file" << EOF
{
    "nom_rapport": "$report_name",
    "date_generation": "$(date -Iseconds)",
    "genere_par": "$(whoami)",
    "nom_hote": "$(hostname)",
    "statistiques": {
        "total_utilisateurs": $total_users,
        "utilisateurs_actifs": $active_users,
        "utilisateurs_inactifs": $inactive_users
    },
    "repartition_categorie": $categories,
    "info_systeme": {
        "version_roundfleet": "2025.07.07",
        "version_os": "$(sw_vers -productVersion)",
        "nom_hote": "$(hostname)"
    }
}
EOF
    
    log_action "✅ Rapport généré : $report_file"
    echo "Rapport sauvegardé dans : $report_file"
}

# Fonctions de déploiement en flotte
deploy_to_fleet() {
    local fleet_config="$1"
    local user_config="$2"
    
    log_action "Début du déploiement en flotte"
    
    if [[ ! -f "$fleet_config" ]]; then
        log_error "Fichier de configuration de flotte non trouvé : $fleet_config"
        return 1
    fi
    
    if [[ ! -f "$user_config" ]]; then
        log_error "Fichier de configuration utilisateur non trouvé : $user_config"
        return 1
    fi
    
    # Lire la configuration de flotte
    local hosts
    hosts=$(jq -r '.hosts[]' "$fleet_config")
    
    # Déployer sur chaque hôte
    while IFS= read -r host; do
        if [[ -n "$host" ]]; then
            log_action "Déploiement sur l'hôte : $host"
            
            # Copier le script de gestion d'utilisateur et la configuration
            scp "$0" "$user_config" "root@${host}:/tmp/" || {
                log_error "Échec de copie des fichiers vers $host"
                continue
            }
            
            # Exécuter le déploiement sur l'hôte distant
            ssh "root@${host}" "chmod +x /tmp/$(basename "$0") && /tmp/$(basename "$0") deploy_from_config /tmp/$(basename "$user_config")" || {
                log_error "Échec d'exécution du déploiement sur $host"
                continue
            }
            
            log_action "✅ Déploiement terminé sur : $host"
        fi
    done <<< "$hosts"
    
    log_action "Déploiement en flotte terminé"
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    # Initialiser
    create_directories
    
    case "$command" in
        "creer")
            create_enterprise_user "$@"
            ;;
        "creation_masse")
            bulk_create_users "$@"
            ;;
        "lister")
            list_enterprise_users
            ;;
        "supprimer")
            remove_enterprise_user "$@"
            ;;
        "sauvegarder")
            create_user_backup "$@"
            ;;
        "surveiller")
            monitor_user_system
            ;;
        "rapport")
            generate_user_report "$@"
            ;;
        "deployer_flotte")
            deploy_to_fleet "$@"
            ;;
        "afficher_categories")
            print_user_categories
            ;;
        "afficher_politiques")
            for policy in standard fort basique service departement externe public; do
                echo "Politique : $policy"
                echo "  $(generate_password_policy "$policy")"
                echo ""
            done
            ;;
        *)
            echo "Système de Gestion d'Utilisateurs d'Entreprise Roundfleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  creer <nom_utilisateur> <nom_affichage> <categorie> <profil> [departement] [expiration]"
            echo "  creation_masse <fichier_csv>"
            echo "  lister"
            echo "  supprimer <nom_utilisateur> [sauvegarde_avant_suppression]"
            echo "  sauvegarder <nom_utilisateur>"
            echo "  surveiller"
            echo "  rapport <nom_rapport>"
            echo "  deployer_flotte <config_flotte> <config_utilisateur>"
            echo "  afficher_categories"
            echo "  afficher_politiques"
            echo ""
            echo "Exemples :"
            echo "  $0 creer PartagerFichiers 'Compte de Partage de Fichiers' partage_standard entreprise_standard IT"
            echo "  $0 creation_masse utilisateurs.csv"
            echo "  $0 lister"
            echo "  $0 surveiller"
            echo "  $0 rapport audit_mensuel"
            ;;
    esac
}

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

Exemple de Déploiement en Flotte

Modèle CSV pour Création en Masse

nom_utilisateur,nom_affichage,categorie,profil,departement,expiration
PartagerFichiers01,Compte de Partage de Fichiers 1,partage_standard,entreprise_standard,IT,
InviteAccueil,Accès Invité Accueil,invite_temporaire,acces_invite_accueil,Reception,2025-12-31
PartenaireExt,Accès Partenaire Externe,partage_securise,collaboration_partenaire,Legal,2025-09-30
KiosqueBib,Compte Kiosque Bibliothèque,kiosque_public,kiosque_public_bibliotheque,Public,
PartageFinance,Compte Partagé Finance,partage_securise,haute_securite_finance,Finance,
EquipeDev,Partage Équipe Développement,partage_standard,recherche_developpement,Ingenierie,

Exemple de Configuration de Flotte

{
    "nom_flotte": "Roundfleet Entreprise",
    "date_deploiement": "2025-07-07",
    "hotes": [
        "mac-bureau-01.entreprise.com",
        "mac-bureau-02.entreprise.com",
        "mac-conference-01.entreprise.com"
    ],
    "profil_deploiement": "entreprise_standard",
    "politique_securite": "standard_entreprise",
    "surveillance": {
        "active": true,
        "intervalle_rapport": "quotidien",
        "seuil_alerte": "haute"
    }
}

Considérations de Sécurité

Sécurité des Comptes Utilisateur

Pas d'Accès Shell - Les utilisateurs de partage ne peuvent pas accéder à la ligne de commande
Pas de Répertoire Home - Empêche le stockage de fichiers dans les répertoires utilisateur
Appartenance de Groupe Limitée - Restreint l'accès système
Politiques de Mot de Passe - Applique des exigences de mot de passe fort
Journalisation d'Audit - Suit toutes les activités de gestion d'utilisateur

Conformité d'Entreprise

Conformité SOX - Contrôles d'accès utilisateur financier
Conformité HIPAA - Protection des données de santé
Cadre NIST - Implémentation des contrôles de sécurité
ISO 27001 - Gestion de la sécurité de l'information

Guide de Dépannage

Problèmes Courants

Échec de Création d'Utilisateur

Vérifier si l'ID utilisateur est déjà utilisé
Vérifier les privilèges administratifs
S'assurer que les services d'annuaire fonctionnent

Problèmes d'Authentification

Vérifier la conformité à la politique de mot de passe
Vérifier le statut du compte utilisateur
Examiner les journaux d'audit pour les tentatives échouées

Erreurs de Permission

Confirmer les appartenances de groupe
Vérifier les permissions de partage de fichiers
Vérifier l'application de la politique de sécurité

Commandes de Diagnostic

# Vérifier l'existence de l'utilisateur
dscl . read /Users/nom_utilisateur

# Lister tous les utilisateurs
dscl . list /Users

# Vérifier les groupes utilisateur
groups nom_utilisateur

# Voir les propriétés utilisateur
id nom_utilisateur

Notes Importantes

Tester minutieusement avant le déploiement en flotte
Sauvegarder les données utilisateur avant d'apporter des modifications
Surveiller les journaux d'audit pour les événements de sécurité
Mettre à jour les politiques selon les exigences de sécurité
Documenter les changements pour l'audit de conformité
Utiliser des méthodes de livraison de mot de passe sécurisées en production

Guide

Avis important