Suppression de Comptes Utilisateur et Gestion du Cycle de Vie sur macOS
Gérez le cycle de vie des comptes utilisateur et les processus de suppression sécurisée sur vos appareils Roundfleet avec une gestion complète des utilisateurs, des politiques de rétention des données et des procédures de départ d'entreprise. Ce tutoriel couvre la suppression sécurisée des utilisateurs, l'archivage des données et la gestion du cycle de vie conforme aux réglementations.
Comprendre la Suppression de Comptes Utilisateur
La suppression de comptes utilisateur sur macOS implique plusieurs composants et considérations de sécurité :
- Suppression de Compte - Supprimer le compte utilisateur des bases de données système
- Gestion des Données - Traiter les répertoires personnels et fichiers associés
- Jetons de Sécurité - Gérer les exigences de jeton sécurisé pour la suppression
- Conformité d'Entreprise - Respecter les exigences de rétention des données et de confidentialité
Considérations d'Entreprise
Une suppression appropriée de compte utilisateur nécessite une planification d'entreprise :
- Politiques de Rétention des Données - Conformité aux exigences légales et réglementaires
- Protocoles de Sécurité - Assurer la suppression complète des données et la révocation d'accès
- Exigences d'Audit - Maintenir les journaux de suppression pour le suivi de conformité
- Procédures de Récupération - Capacités de sauvegarde et récupération avant suppression
- Automatisation des Processus - Procédures de départ rationalisées pour les employés qui partent
Suppression de Base de Comptes Utilisateur
Prérequis et Exigences de Sécurité
#!/bin/bash
# Vérifier les prérequis pour la suppression d'utilisateur
check_deletion_prerequisites() {
echo "=== Vérification des Prérequis de Suppression d'Utilisateur ==="
# Vérifier si exécuté avec privilèges administrateur
if [[ $EUID -ne 0 ]]; then
echo "⚠️ Avertissement : Ce script nécessite des privilèges administrateur"
echo "Exécuter avec : sudo $0"
else
echo "✓ Privilèges administrateur confirmés"
fi
# Vérifier l'accès disque complet de l'app Service
echo ""
echo "--- Vérification Accès Disque Complet ---"
local tcc_db="/Library/Application Support/com.apple.TCC/TCC.db"
if [[ -r "$tcc_db" ]]; then
echo "✓ Base de données TCC accessible - Accès disque complet probablement accordé"
else
echo "⚠️ Avertissement : Base de données TCC non accessible"
echo "Assurez-vous que l'app Service a l'Accès Disque Complet dans Préférences Système"
fi
# Vérifier les détenteurs de jeton sécurisé disponibles
echo ""
echo "--- Analyse Jeton Sécurisé ---"
local secure_token_users=$(sysadminctl -secureTokenStatus 2>/dev/null | grep "Enabled" | wc -l | tr -d ' ')
echo "Détenteurs de jeton sécurisé trouvés : $secure_token_users"
if [[ $secure_token_users -lt 2 ]]; then
echo "⚠️ Avertissement : Moins de 2 détenteurs de jeton sécurisé détectés"
echo "Impossible de supprimer l'unique détenteur de jeton sécurisé"
echo "Ajouter un autre utilisateur admin avec jeton sécurisé avant suppression"
else
echo "✓ Plusieurs détenteurs de jeton sécurisé disponibles"
fi
}
# Usage
check_deletion_prerequisitesSuppression Sécurisée de Compte Utilisateur
#!/bin/bash
# Supprimer un compte utilisateur en toute sécurité avec validation
delete_user_account() {
local username="$1"
local method="${2:-sysadminctl}" # sysadminctl ou dscl
local backup_data="${3:-true}"
if [[ -z "$username" ]]; then
echo "Usage : delete_user_account <nom_utilisateur> [méthode] [sauvegarder_données]"
echo "Méthodes : sysadminctl (par défaut), dscl"
echo "Sauvegarder données : true (par défaut), false"
return 1
fi
echo "=== Suppression Sécurisée de Compte Utilisateur ==="
echo "Utilisateur cible : $username"
echo "Méthode de suppression : $method"
echo "Sauvegarder données : $backup_data"
echo ""
# Valider que l'utilisateur existe
if ! id "$username" >/dev/null 2>&1; then
echo "Erreur : L'utilisateur '$username' n'existe pas"
return 1
fi
# Vérifier si l'utilisateur est actuellement connecté
local logged_in_users=$(who | awk '{print $1}' | sort -u)
if echo "$logged_in_users" | grep -q "^$username$"; then
echo "⚠️ Avertissement : L'utilisateur '$username' est actuellement connecté"
echo "Forcer la déconnexion ou attendre que l'utilisateur se déconnecte avant suppression"
return 1
fi
# Vérifier le statut du jeton sécurisé
local token_status=$(sysadminctl -secureTokenStatus "$username" 2>/dev/null | grep "Enabled")
if [[ -n "$token_status" ]]; then
echo "L'utilisateur '$username' a un jeton sécurisé"
# Compter le total des détenteurs de jeton sécurisé
local total_tokens=$(sysadminctl -secureTokenStatus 2>/dev/null | grep "Enabled" | wc -l | tr -d ' ')
if [[ $total_tokens -eq 1 ]]; then
echo "Erreur : Impossible de supprimer l'unique détenteur de jeton sécurisé"
echo "Ajouter d'abord un autre utilisateur admin avec jeton sécurisé"
return 1
fi
fi
# Sauvegarder les données utilisateur si demandé
if [[ "$backup_data" == "true" ]]; then
echo "Création de sauvegarde des données utilisateur..."
backup_user_data "$username"
fi
# Effectuer la suppression basée sur la méthode
echo ""
echo "--- Suppression du Compte Utilisateur ---"
case "$method" in
"sysadminctl")
delete_user_sysadminctl "$username"
;;
"dscl")
delete_user_dscl "$username"
;;
*)
echo "Erreur : Méthode de suppression inconnue : $method"
return 1
;;
esac
}
# Supprimer utilisateur avec sysadminctl (macOS 10.13+)
delete_user_sysadminctl() {
local username="$1"
echo "Utilisation de sysadminctl pour supprimer l'utilisateur : $username"
if sysadminctl -deleteUser "$username" 2>/dev/null; then
echo "✓ Compte utilisateur '$username' supprimé avec succès avec sysadminctl"
return 0
else
echo "✗ Échec de suppression de l'utilisateur '$username' avec sysadminctl"
return 1
fi
}
# Supprimer utilisateur avec dscl (méthode héritée)
delete_user_dscl() {
local username="$1"
echo "Utilisation de dscl pour supprimer l'utilisateur : $username"
if dscl . delete "/Users/$username" 2>/dev/null; then
echo "✓ Compte utilisateur '$username' supprimé avec succès avec dscl"
return 0
else
echo "✗ Échec de suppression de l'utilisateur '$username' avec dscl"
return 1
fi
}
# Exemple d'utilisation (commenté pour sécurité)
# delete_user_account "employe_partant" "sysadminctl" "true"Gestion des Données et Répertoires Utilisateur
#!/bin/bash
# Gestion complète des données utilisateur
manage_user_data() {
local username="$1"
local action="${2:-archive}" # archive, delete, preserve
local backup_location="${3:-/var/backups/user_data}"
if [[ -z "$username" ]]; then
echo "Usage : manage_user_data <nom_utilisateur> [action] [emplacement_sauvegarde]"
echo "Actions : archive (par défaut), delete, preserve"
return 1
fi
echo "=== Gestion des Données Utilisateur ==="
echo "Nom d'utilisateur : $username"
echo "Action : $action"
echo "Emplacement de sauvegarde : $backup_location"
echo ""
local user_home="/Users/$username"
# Vérifier si le répertoire personnel utilisateur existe
if [[ ! -d "$user_home" ]]; then
echo "Répertoire personnel utilisateur non trouvé : $user_home"
return 1
fi
# Obtenir la taille du répertoire pour rapport
local dir_size=$(du -sh "$user_home" 2>/dev/null | awk '{print $1}')
echo "Taille du répertoire personnel utilisateur : $dir_size"
case "$action" in
"archive")
archive_user_data "$username" "$backup_location"
;;
"delete")
delete_user_data "$username"
;;
"preserve")
preserve_user_data "$username"
;;
*)
echo "Erreur : Action inconnue : $action"
return 1
;;
esac
}
# Archiver les données utilisateur avant suppression
archive_user_data() {
local username="$1"
local backup_location="$2"
echo "--- Archivage des Données Utilisateur ---"
# Créer le répertoire de sauvegarde s'il n'existe pas
mkdir -p "$backup_location"
local timestamp=$(date +%Y%m%d_%H%M%S)
local archive_name="${username}_backup_${timestamp}.tar.gz"
local archive_path="$backup_location/$archive_name"
echo "Création de l'archive : $archive_path"
# Créer une archive compressée du répertoire personnel utilisateur
if tar -czf "$archive_path" -C "/Users" "$username" 2>/dev/null; then
echo "✓ Données utilisateur archivées avec succès"
# Créer un fichier de métadonnées
local metadata_file="$backup_location/${username}_metadata_${timestamp}.json"
cat > "$metadata_file" << EOF
{
"backup_metadata": {
"username": "$username",
"backup_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"archive_file": "$archive_name",
"archive_size": "$(du -sh "$archive_path" | awk '{print $1}')",
"original_path": "/Users/$username",
"backup_location": "$backup_location",
"hostname": "$(hostname)",
"created_by": "$(whoami)"
}
}
EOF
echo "✓ Fichier de métadonnées créé : $metadata_file"
echo "Détails de l'archive :"
echo " Fichier : $archive_path"
echo " Taille : $(du -sh "$archive_path" | awk '{print $1}')"
return 0
else
echo "✗ Échec de création de l'archive"
return 1
fi
}
# Supprimer les données et répertoires utilisateur
delete_user_data() {
local username="$1"
local user_home="/Users/$username"
echo "--- Suppression des Données Utilisateur ---"
echo "⚠️ AVERTISSEMENT : Ceci supprimera définitivement toutes les données utilisateur"
echo "Répertoire cible : $user_home"
# Vérification de sécurité - ne pas supprimer les répertoires système
case "$username" in
"root"|"admin"|"administrator"|"Guest"|"Shared")
echo "Erreur : Impossible de supprimer les données utilisateur système : $username"
return 1
;;
esac
if [[ "$user_home" == "/Users/"* && ${#username} -gt 2 ]]; then
echo "Suppression du répertoire personnel utilisateur..."
if rm -rf "$user_home" 2>/dev/null; then
echo "✓ Données utilisateur supprimées avec succès : $user_home"
return 0
else
echo "✗ Échec de suppression des données utilisateur : $user_home"
return 1
fi
else
echo "Erreur : Chemin de répertoire personnel invalide : $user_home"
return 1
fi
}
# Préserver les données utilisateur avec changement de propriété
preserve_user_data() {
local username="$1"
local user_home="/Users/$username"
local preserved_name="${username}_preserved_$(date +%Y%m%d)"
local preserved_path="/Users/$preserved_name"
echo "--- Préservation des Données Utilisateur ---"
echo "Renommage du répertoire utilisateur pour préservation"
echo "De : $user_home"
echo "Vers : $preserved_path"
if mv "$user_home" "$preserved_path" 2>/dev/null; then
# Changer la propriété vers l'utilisateur admin
chown -R root:admin "$preserved_path" 2>/dev/null
chmod -R 755 "$preserved_path" 2>/dev/null
echo "✓ Données utilisateur préservées à : $preserved_path"
echo "✓ Propriété changée vers root:admin"
return 0
else
echo "✗ Échec de préservation des données utilisateur"
return 1
fi
}
# Exemple d'utilisation
# manage_user_data "employe_partant" "archive" "/var/backups/user_data"Système de Gestion du Cycle de Vie d'Entreprise
#!/bin/bash
# Outil de Suppression de Comptes Utilisateur et Gestion du Cycle de Vie Roundfleet
# Départ d'entreprise complet, gestion des données et conformité
# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_user_lifecycle.log"
REPORT_DIR="/etc/roundfleet/reports/users"
CONFIG_DIR="/etc/roundfleet/user_management"
POLICY_DIR="/etc/roundfleet/policies/users"
BACKUP_DIR="/var/backups/roundfleet/users"
COMPLIANCE_DIR="/etc/roundfleet/compliance/users"
# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR" "$BACKUP_DIR" "$COMPLIANCE_DIR"
# Politiques de cycle de vie utilisateur
declare -A LIFECYCLE_POLICIES=(
["immediate_deletion"]="delete_account,delete_data,no_backup,audit_log"
["secure_archival"]="backup_data,delete_account,delete_data,compliance_report"
["data_preservation"]="backup_data,preserve_home,delete_account,extended_audit"
["legal_hold"]="preserve_all,disable_account,legal_compliance,no_deletion"
["healthcare_hipaa"]="encrypted_backup,secure_deletion,hipaa_compliance,audit_trail"
["financial_compliance"]="full_backup,sox_compliance,retention_policy,secure_deletion"
["education_ferpa"]="student_data_protection,ferpa_compliance,selective_backup,audit_log"
["government_classified"]="classified_data_handling,security_clearance_check,secure_deletion,audit_trail"
["contractor_offboarding"]="project_data_separation,limited_backup,quick_deletion,access_revocation"
["temporary_disable"]="disable_only,preserve_all,no_deletion,reactivation_ready"
)
# Périodes de rétention des données (en jours)
declare -A RETENTION_PERIODS=(
["immediate"]="0"
["short_term"]="30"
["medium_term"]="90"
["long_term"]="365"
["legal_hold"]="indefinite"
["compliance_minimum"]="2555" # 7 ans
)
# Cadres de conformité
declare -A COMPLIANCE_FRAMEWORKS=(
["hipaa"]="healthcare_data_protection,encrypted_storage,audit_logs,secure_deletion"
["sox"]="financial_records_retention,change_management,access_controls,audit_trail"
["ferpa"]="student_privacy,educational_records,consent_management,access_restrictions"
["gdpr"]="data_minimization,consent_withdrawal,right_to_erasure,data_portability"
["pci_dss"]="payment_data_protection,secure_deletion,access_monitoring,compliance_reporting"
)
# Fonction de journalisation
log_action() {
local message="$1"
local severity="${2:-INFO}"
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$timestamp] [$severity] $message" | tee -a "$LOG_FILE"
}
# Suppression de compte utilisateur d'entreprise avec fonctionnalités avancées
enterprise_user_deletion() {
local username="$1"
local policy="${2:-secure_archival}"
local compliance_framework="${3:-}"
local retention_period="${4:-medium_term}"
local authorized_by="${5:-$(whoami)}"
log_action "Démarrage du processus de suppression d'utilisateur d'entreprise" "INFO"
log_action "Nom d'utilisateur : $username, Politique : $policy, Autorisé par : $authorized_by" "INFO"
echo "=== Processus de Suppression d'Utilisateur d'Entreprise ==="
echo "Nom d'utilisateur : $username"
echo "Politique : $policy"
echo "Cadre de Conformité : $compliance_framework"
echo "Période de Rétention : $retention_period"
echo "Autorisé Par : $authorized_by"
echo "ID de Processus : $(uuidgen)"
echo ""
# Valider que l'utilisateur existe
if ! id "$username" >/dev/null 2>&1; then
log_action "ERREUR : L'utilisateur '$username' n'existe pas" "ERROR"
return 1
fi
# Validation pré-suppression
if ! pre_deletion_validation "$username"; then
log_action "ERREUR : Validation pré-suppression échouée pour utilisateur : $username" "ERROR"
return 1
fi
# Appliquer le processus de suppression basé sur politique
apply_deletion_policy "$username" "$policy" "$compliance_framework" "$retention_period" "$authorized_by"
# Générer le rapport de conformité
generate_deletion_compliance_report "$username" "$policy" "$compliance_framework" "$authorized_by"
log_action "Processus de suppression d'utilisateur d'entreprise terminé pour utilisateur : $username" "INFO"
}
# Validation pré-suppression et vérifications de sécurité
pre_deletion_validation() {
local username="$1"
echo "--- Validation Pré-Suppression ---"
# Vérifier si l'utilisateur est un utilisateur système
local user_id=$(id -u "$username" 2>/dev/null)
if [[ $user_id -lt 500 ]]; then
echo "✗ Impossible de supprimer l'utilisateur système (UID < 500) : $username"
return 1
fi
# Vérifier si l'utilisateur est actuellement connecté
if who | grep -q "^$username "; then
echo "✗ L'utilisateur est actuellement connecté : $username"
log_action "Suppression bloquée : L'utilisateur $username est actuellement connecté" "WARNING"
return 1
fi
# Vérifier les exigences de jeton sécurisé
local has_secure_token=$(sysadminctl -secureTokenStatus "$username" 2>/dev/null | grep -c "Enabled")
if [[ $has_secure_token -eq 1 ]]; then
local total_secure_tokens=$(sysadminctl -secureTokenStatus 2>/dev/null | grep -c "Enabled")
if [[ $total_secure_tokens -eq 1 ]]; then
echo "✗ Impossible de supprimer l'unique détenteur de jeton sécurisé : $username"
log_action "Suppression bloquée : $username est l'unique détenteur de jeton sécurisé" "ERROR"
return 1
fi
fi
# Vérifier les processus actifs appartenant à l'utilisateur
local user_processes=$(ps aux | awk -v user="$username" '$1 == user {print $2}' | wc -l | tr -d ' ')
if [[ $user_processes -gt 0 ]]; then
echo "⚠️ Avertissement : L'utilisateur a $user_processes processus actifs"
echo "Arrêt des processus utilisateur..."
pkill -u "$username" 2>/dev/null
sleep 2
fi
# Vérifier la taille du répertoire personnel pour planification de sauvegarde
local home_dir="/Users/$username"
if [[ -d "$home_dir" ]]; then
local dir_size=$(du -sm "$home_dir" 2>/dev/null | awk '{print $1}')
echo "✓ Taille du répertoire personnel : ${dir_size}MB"
# Vérifier l'espace disque disponible pour sauvegarde
local available_space=$(df -m "$BACKUP_DIR" | tail -1 | awk '{print $4}')
if [[ $dir_size -gt $available_space ]]; then
echo "⚠️ Avertissement : Espace insuffisant pour sauvegarde"
echo "Requis : ${dir_size}MB, Disponible : ${available_space}MB"
fi
fi
echo "✓ Validation pré-suppression terminée"
return 0
}
# Appliquer la politique de suppression
apply_deletion_policy() {
local username="$1"
local policy="$2"
local compliance_framework="$3"
local retention_period="$4"
local authorized_by="$5"
echo "--- Application de la Politique de Suppression : $policy ---"
# Obtenir les actions de politique
local policy_actions="${LIFECYCLE_POLICIES[$policy]}"
if [[ -z "$policy_actions" ]]; then
log_action "ERREUR : Politique de suppression inconnue : $policy" "ERROR"
return 1
fi
echo "Actions de politique : $policy_actions"
# Exécuter les actions de politique
IFS=',' read -ra ACTIONS <<< "$policy_actions"
for action in "${ACTIONS[@]}"; do
case "$action" in
"backup_data")
echo "Exécution : Sauvegarde des données utilisateur"
backup_user_data_enterprise "$username" "$compliance_framework"
;;
"delete_account")
echo "Exécution : Suppression du compte utilisateur"
delete_user_account_enterprise "$username"
;;
"delete_data")
echo "Exécution : Suppression des données utilisateur"
delete_user_data_secure "$username"
;;
"preserve_home")
echo "Exécution : Préservation du répertoire personnel"
preserve_user_data "$username"
;;
"disable_account")
echo "Exécution : Désactivation du compte utilisateur"
disable_user_account "$username"
;;
"audit_log")
echo "Exécution : Création du journal d'audit"
create_audit_log "$username" "$policy" "$authorized_by"
;;
"compliance_report")
echo "Exécution : Génération du rapport de conformité"
# Sera traité séparément
;;
*)
echo "Action inconnue : $action"
;;
esac
done
}
# Sauvegarde d'entreprise avec chiffrement et conformité
backup_user_data_enterprise() {
local username="$1"
local compliance_framework="$2"
echo "--- Sauvegarde de Données d'Entreprise ---"
local timestamp=$(date +%Y%m%d_%H%M%S)
local backup_name="${username}_enterprise_backup_${timestamp}"
local backup_path="$BACKUP_DIR/$backup_name"
# Créer la sauvegarde avec métadonnées
mkdir -p "$backup_path"
# Copier les données utilisateur
local user_home="/Users/$username"
if [[ -d "$user_home" ]]; then
echo "Sauvegarde du répertoire personnel utilisateur..."
tar -czf "$backup_path/home_directory.tar.gz" -C "/Users" "$username" 2>/dev/null
fi
# Sauvegarder les informations de compte utilisateur
echo "Sauvegarde des métadonnées de compte..."
dscl . read "/Users/$username" > "$backup_path/account_metadata.txt" 2>/dev/null
# Créer le manifeste de sauvegarde
cat > "$backup_path/backup_manifest.json" << EOF
{
"backup_manifest": {
"username": "$username",
"backup_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"backup_type": "enterprise_offboarding",
"compliance_framework": "$compliance_framework",
"backup_location": "$backup_path",
"files_included": [
"home_directory.tar.gz",
"account_metadata.txt",
"backup_manifest.json"
],
"backup_size": "$(du -sh "$backup_path" | awk '{print $1}')",
"hostname": "$(hostname)",
"authorized_by": "$(whoami)",
"backup_integrity": "$(find "$backup_path" -type f -exec md5 {} \; | md5)"
}
}
EOF
# Appliquer les protections spécifiques à la conformité
if [[ -n "$compliance_framework" ]]; then
apply_compliance_protections "$backup_path" "$compliance_framework"
fi
echo "✓ Sauvegarde d'entreprise terminée : $backup_path"
log_action "Sauvegarde d'entreprise créée pour utilisateur $username à $backup_path" "INFO"
}
# Suppression sécurisée avec exigences de conformité
delete_user_data_secure() {
local username="$1"
local user_home="/Users/$username"
echo "--- Suppression Sécurisée des Données ---"
if [[ -d "$user_home" ]]; then
echo "Exécution de la suppression sécurisée des données utilisateur..."
# Suppression sécurisée multi-passes (standard DoD 5220.22-M)
if command -v gshred >/dev/null 2>&1; then
echo "Utilisation de gshred pour suppression sécurisée..."
find "$user_home" -type f -exec gshred -vfz -n 3 {} \; 2>/dev/null
elif command -v shred >/dev/null 2>&1; then
echo "Utilisation de shred pour suppression sécurisée..."
find "$user_home" -type f -exec shred -vfz -n 3 {} \; 2>/dev/null
else
echo "Outils de suppression sécurisée non disponibles, utilisation suppression standard..."
fi
# Supprimer la structure de répertoire
rm -rf "$user_home" 2>/dev/null
echo "✓ Suppression sécurisée terminée"
log_action "Suppression sécurisée terminée pour données utilisateur : $user_home" "INFO"
else
echo "Aucun répertoire personnel utilisateur trouvé : $user_home"
fi
}
# Désactiver le compte utilisateur au lieu de la suppression
disable_user_account() {
local username="$1"
echo "--- Désactivation du Compte Utilisateur ---"
# Désactiver le compte avec dscl
if dscl . create "/Users/$username" AuthenticationAuthority ";DisabledUser;" 2>/dev/null; then
echo "✓ Compte utilisateur désactivé : $username"
log_action "Compte utilisateur désactivé : $username" "INFO"
else
echo "✗ Échec de désactivation du compte utilisateur : $username"
log_action "Échec de désactivation du compte utilisateur : $username" "ERROR"
fi
# Définir le shell de compte à /usr/bin/false
dscl . create "/Users/$username" UserShell "/usr/bin/false" 2>/dev/null
# Verrouiller le répertoire personnel
local user_home="/Users/$username"
if [[ -d "$user_home" ]]; then
chmod 000 "$user_home" 2>/dev/null
echo "✓ Accès au répertoire personnel révoqué"
fi
}
# Générer un rapport de conformité complet
generate_deletion_compliance_report() {
local username="$1"
local policy="$2"
local compliance_framework="$3"
local authorized_by="$4"
local report_file="$REPORT_DIR/user_deletion_report_${username}_$(date +%Y%m%d_%H%M%S).json"
cat > "$report_file" << EOF
{
"user_deletion_compliance_report": {
"report_metadata": {
"report_id": "$(uuidgen)",
"generated_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"report_type": "user_account_deletion",
"compliance_framework": "$compliance_framework",
"hostname": "$(hostname)",
"script_version": "$SCRIPT_VERSION"
},
"user_information": {
"username": "$username",
"deletion_policy": "$policy",
"authorized_by": "$authorized_by",
"deletion_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
},
"compliance_details": {
"framework": "$compliance_framework",
"data_retention_requirements": "$(echo "${RETENTION_PERIODS[medium_term]}" | sed 's/indefinite/Rétention légale - rétention indéfinie/')",
"secure_deletion_method": "Standard DoD 5220.22-M",
"backup_location": "$BACKUP_DIR",
"audit_trail": "$LOG_FILE"
},
"system_information": {
"os_version": "$(sw_vers -productVersion)",
"hardware_model": "$(system_profiler SPHardwareDataType | grep 'Model Identifier' | awk '{print $3}')",
"secure_token_holders": $(sysadminctl -secureTokenStatus 2>/dev/null | grep -c "Enabled")
}
}
}
EOF
echo "Rapport de conformité généré : $report_file"
log_action "Rapport de conformité généré : $report_file" "INFO"
}
# Opérations de gestion d'utilisateurs de flotte
manage_fleet_users() {
local operation="$1"
local user_list="$2"
local policy="${3:-secure_archival}"
local compliance_framework="${4:-}"
echo "=== Gestion d'Utilisateurs de Flotte ==="
echo "Opération : $operation"
echo "Politique : $policy"
echo "Cadre de Conformité : $compliance_framework"
echo ""
case "$operation" in
"bulk_delete")
echo "Traitement de suppression d'utilisateurs en lot..."
IFS=',' read -ra USERS <<< "$user_list"
for username in "${USERS[@]}"; do
echo "Traitement de l'utilisateur : $username"
enterprise_user_deletion "$username" "$policy" "$compliance_framework"
echo ""
done
;;
"audit_all")
echo "Audit de tous les comptes utilisateur..."
audit_all_users
;;
"compliance_check")
echo "Exécution de vérification de conformité..."
compliance_check_users "$compliance_framework"
;;
*)
echo "Opération inconnue : $operation"
return 1
;;
esac
}
# Fonction d'exécution principale
main() {
local action="${1:-help}"
local param1="${2:-}"
local param2="${3:-}"
local param3="${4:-}"
local param4="${5:-}"
local param5="${6:-}"
log_action "=== Gestion du Cycle de Vie Utilisateur Roundfleet Démarrée ===" "INFO"
log_action "Action : $action" "INFO"
case "$action" in
"delete")
if [[ -z "$param1" ]]; then
echo "Usage : $0 delete <nom_utilisateur> [politique] [cadre_conformité] [période_rétention] [autorisé_par]"
echo "Politiques : ${!LIFECYCLE_POLICIES[*]}"
echo "Conformité : ${!COMPLIANCE_FRAMEWORKS[*]}"
echo "Rétention : ${!RETENTION_PERIODS[*]}"
exit 1
fi
enterprise_user_deletion "$param1" "$param2" "$param3" "$param4" "$param5"
;;
"backup")
if [[ -z "$param1" ]]; then
echo "Usage : $0 backup <nom_utilisateur> [cadre_conformité]"
exit 1
fi
backup_user_data_enterprise "$param1" "$param2"
;;
"disable")
if [[ -z "$param1" ]]; then
echo "Usage : $0 disable <nom_utilisateur>"
exit 1
fi
disable_user_account "$param1"
;;
"fleet")
if [[ -z "$param1" || -z "$param2" ]]; then
echo "Usage : $0 fleet <opération> <liste_utilisateurs> [politique] [cadre_conformité]"
echo "Opérations : bulk_delete, audit_all, compliance_check"
exit 1
fi
manage_fleet_users "$param1" "$param2" "$param3" "$param4"
;;
"validate")
if [[ -z "$param1" ]]; then
echo "Usage : $0 validate <nom_utilisateur>"
exit 1
fi
pre_deletion_validation "$param1"
;;
"prereq")
check_deletion_prerequisites
;;
"help")
echo "Usage : $0 [action] [options...]"
echo "Actions :"
echo " delete <nom_utilisateur> [politique] [conformité] [rétention] [autorisé_par] - Supprimer utilisateur avec politiques d'entreprise"
echo " backup <nom_utilisateur> [conformité] - Sauvegarder données utilisateur"
echo " disable <nom_utilisateur> - Désactiver compte utilisateur"
echo " fleet <opération> <liste_utilisateurs> [politique] [conformité] - Opérations utilisateurs de flotte"
echo " validate <nom_utilisateur> - Valider prérequis suppression"
echo " prereq - Vérifier prérequis système"
echo " help - Afficher cette aide"
echo ""
echo "Politiques : ${!LIFECYCLE_POLICIES[*]}"
echo "Conformité : ${!COMPLIANCE_FRAMEWORKS[*]}"
echo "Rétention : ${!RETENTION_PERIODS[*]}"
;;
*)
log_action "ERREUR : Action inconnue : $action" "ERROR"
echo "Utilisez '$0 help' pour les informations d'utilisation"
exit 1
;;
esac
log_action "=== Gestion du cycle de vie utilisateur terminée ===" "INFO"
}
# Exécuter la fonction principale
main "$@"Considérations de Sécurité Importantes
Exigences de Jeton Sécurisé
#!/bin/bash
# Gérer les exigences de jeton sécurisé pour suppression d'utilisateur
manage_secure_tokens() {
echo "=== Gestion des Jetons Sécurisés ==="
# Lister tous les détenteurs de jeton sécurisé
echo "Détenteurs de jeton sécurisé actuels :"
sysadminctl -secureTokenStatus 2>/dev/null | grep -E "(Username|Enabled)"
echo ""
echo "--- Directives Jeton Sécurisé ---"
echo "1. Impossible de supprimer l'unique détenteur de jeton sécurisé"
echo "2. Doit avoir au moins un admin avec jeton sécurisé"
echo "3. Accorder jeton sécurisé avant tentative de suppression"
echo "4. Jeton sécurisé requis pour FileVault et certaines opérations"
}
# Accorder jeton sécurisé à utilisateur admin
grant_secure_token() {
local admin_user="$1"
local target_user="$2"
if [[ -z "$admin_user" || -z "$target_user" ]]; then
echo "Usage : grant_secure_token <utilisateur_admin> <utilisateur_cible>"
return 1
fi
echo "Accord de jeton sécurisé à $target_user via $admin_user..."
sysadminctl -secureTokenOn "$target_user" -password -adminUser "$admin_user"
}
# Usage
manage_secure_tokensRétention des Données et Conformité
#!/bin/bash
# Implémenter les politiques de rétention des données
implement_retention_policy() {
local policy_name="$1"
local retention_days="${2:-90}"
echo "=== Implémentation de Politique de Rétention des Données ==="
echo "Politique : $policy_name"
echo "Période de Rétention : $retention_days jours"
# Trouver les anciennes sauvegardes pour nettoyage
local old_backups=$(find "$BACKUP_DIR" -type d -mtime +$retention_days 2>/dev/null)
if [[ -n "$old_backups" ]]; then
echo "Sauvegardes trouvées plus anciennes que $retention_days jours :"
echo "$old_backups"
# Archiver les anciennes sauvegardes avant suppression (si requis par politique)
case "$policy_name" in
"legal_hold")
echo "Rétention légale active - aucune suppression effectuée"
;;
"compliance_minimum")
echo "Rétention minimum de conformité - archivage vers stockage long terme"
;;
*)
echo "Rétention standard - marquage pour suppression"
;;
esac
else
echo "Aucune sauvegarde trouvée plus ancienne que $retention_days jours"
fi
}
# Usage
implement_retention_policy "standard" "90"Notes Importantes
- Privilèges Administrateur - La suppression d'utilisateur nécessite des privilèges administrateur et une authentification appropriée
- Gestion de Jeton Sécurisé - Impossible de supprimer l'unique détenteur de jeton sécurisé ; s'assurer que plusieurs utilisateurs admin existent
- Accès Disque Complet - L'app Service nécessite la permission Accès Disque Complet dans Préférences Système
- Sauvegarde des Données - Toujours sauvegarder les données utilisateur avant suppression si requis par les politiques organisationnelles
- Exigences de Conformité - Différentes industries ont des exigences spécifiques de rétention et suppression des données
- Pistes d'Audit - Maintenir des journaux complets de toutes les activités de suppression d'utilisateur pour conformité
- Procédures de Récupération - Tester les procédures de sauvegarde et récupération avant d'implémenter les politiques de suppression