Gestion d'Entreprise des Utilisateurs de Partage sur macOS
Gérez les comptes utilisateurs de partage uniquement sur vos appareils MacFleet 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_categoriesPolitiques 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 MacFleet
# Création et gestion complètes d'utilisateurs de partage
# Configuration
CONFIG_DIR="/etc/macfleet/users"
LOG_FILE="/var/log/macfleet_gestion_utilisateurs.log"
BACKUP_DIR="/var/backups/macfleet/users"
REPORTS_DIR="/var/reports/macfleet/users"
AUDIT_LOG="/var/log/macfleet_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é MacFleet - $user_category"
sudo dscl . create /Users/"$username" Keywords "macfleet,$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 "macfleet_$(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 MacFleet ==="
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_macfleet": "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 MacFleet"
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": "MacFleet 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_utilisateurNotes 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