Guide

Implémentez une gestion complète des privilèges utilisateur et la conformité sécuritaire sur vos appareils Roundfleet. Ce tutoriel couvre la vérification d'accès administrateur, la surveillance d'escalade de privilèges, le contrôle d'accès basé sur les rôles (RBAC), l'application de politiques de sécurité et les cadres de conformité automatisés pour les environnements d'entreprise.

Comprendre le Système de Privilèges macOS

macOS utilise un système de privilèges en couches pour la sécurité et le contrôle d'accès :

• Utilisateurs Standard - Accès système de base avec capacités administratives limitées
• Utilisateurs Administrateur - Accès système complet et capacité de modifier les paramètres système
• Utilisateur Root - Superutilisateur avec accès système sans restriction (généralement désactivé)
• Comptes de Service - Comptes système pour exécuter des services et démons
• Appartenance aux Groupes - Privilèges supplémentaires via les affectations de groupes

Vérification Basique d'Administrateur

Vérifier le Statut Admin d'un Utilisateur Individuel

#!/bin/bash

# Vérifier si un utilisateur spécifique a les privilèges administrateur
check_user_admin_status() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "❌ Nom d'utilisateur requis"
        return 1
    fi
    
    echo "=== Vérification du Statut Admin pour l'Utilisateur: $username ==="
    
    # Vérifier que l'utilisateur existe
    if ! dscl . -read "/Users/$username" &>/dev/null; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    # Vérifier l'appartenance au groupe admin
    if groups "$username" | grep -q -w admin; then
        echo "✅ L'utilisateur '$username' EST un administrateur"
        return 0
    else
        echo "ℹ️  L'utilisateur '$username' n'est PAS un administrateur"
        return 1
    fi
}

# Exemple d'utilisation
# check_user_admin_status "testuser"

Lister Tous les Utilisateurs Administrateur

#!/bin/bash

# Obtenir la liste de tous les utilisateurs administrateur
list_admin_users() {
    echo "=== Liste des Utilisateurs Administrateur ==="
    
    # Obtenir les membres du groupe admin
    local admin_users
    admin_users=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | cut -d: -f2)
    
    if [[ -z "$admin_users" ]]; then
        echo "⚠️  Aucun utilisateur administrateur trouvé"
        return 1
    fi
    
    echo "Utilisateurs administrateur:"
    for user in $admin_users; do
        # Vérifier que l'utilisateur existe encore et obtenir des informations supplémentaires
        if dscl . -read "/Users/$user" &>/dev/null; then
            local real_name
            real_name=$(dscl . -read "/Users/$user" RealName 2>/dev/null | cut -d: -f2 | xargs)
            local uid
            uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | cut -d: -f2 | xargs)
            
            echo "  👤 $user (UID: $uid) - $real_name"
        else
            echo "  ⚠️  $user (Compte utilisateur non trouvé)"
        fi
    done
    
    return 0
}

# Exécuter la fonction
list_admin_users

Système de Gestion des Privilèges Utilisateur d'Entreprise

#!/bin/bash

# Système de Gestion des Privilèges Utilisateur d'Entreprise Roundfleet
# Contrôle d'accès complet, conformité sécuritaire et surveillance des privilèges

# Configuration
LOG_FILE="/var/log/roundfleet_user_privileges.log"
CONFIG_DIR="/etc/roundfleet/user_management"
POLICIES_DIR="$CONFIG_DIR/policies"
REPORTS_DIR="$CONFIG_DIR/reports"
COMPLIANCE_DIR="$CONFIG_DIR/compliance"
AUDIT_DIR="$CONFIG_DIR/audit"

# Cadres de conformité sécuritaire
declare -A COMPLIANCE_FRAMEWORKS=(
    ["nist"]="least_privilege,separation_duties,access_review,audit_trails"
    ["iso27001"]="access_control,privilege_management,monitoring,documentation"
    ["cis"]="admin_minimization,privilege_escalation_monitoring,account_lifecycle"
    ["sox"]="financial_access_control,privilege_separation,audit_requirements"
    ["hipaa"]="minimum_necessary,access_controls,audit_logs,sanctions"
    ["pci_dss"]="unique_ids,access_control,privilege_limitation,monitoring"
)

# Définitions des rôles utilisateur
declare -A USER_ROLES=(
    ["standard"]="basic_access,file_management,application_usage"
    ["power_user"]="advanced_settings,software_installation,system_preferences"
    ["developer"]="development_tools,system_debugging,certificate_management"
    ["administrator"]="full_system_access,user_management,security_settings"
    ["security_admin"]="security_policies,audit_access,compliance_management"
    ["service_account"]="automated_processes,background_services,api_access"
)

# Modèles d'escalade de privilèges
declare -A ESCALATION_PATTERNS=(
    ["sudo_abuse"]="excessive_sudo_usage,sudo_without_password,sudo_all_commands"
    ["group_manipulation"]="unauthorized_group_addition,privilege_group_access"
    ["file_permissions"]="setuid_modifications,sensitive_file_access,system_file_changes"
    ["service_abuse"]="service_account_usage,daemon_manipulation,system_service_access"
)

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

# Configuration des répertoires
setup_directories() {
    for dir in "$CONFIG_DIR" "$POLICIES_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir"
            log_action "Répertoire créé: $dir"
        fi
    done
}

# Obtenir des informations complètes sur l'utilisateur
get_user_details() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        return 1
    fi
    
    # Vérifier si l'utilisateur existe
    if ! dscl . -read "/Users/$username" &>/dev/null; then
        return 1
    fi
    
    local user_info="{}"
    
    # Informations de base sur l'utilisateur
    local uid
    uid=$(dscl . -read "/Users/$username" UniqueID 2>/dev/null | awk '{print $2}')
    local gid
    gid=$(dscl . -read "/Users/$username" PrimaryGroupID 2>/dev/null | awk '{print $2}')
    local real_name
    real_name=$(dscl . -read "/Users/$username" RealName 2>/dev/null | cut -d: -f2- | xargs)
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    local shell
    shell=$(dscl . -read "/Users/$username" UserShell 2>/dev/null | awk '{print $2}')
    
    # Appartenances aux groupes
    local groups_list
    groups_list=$(groups "$username" 2>/dev/null | cut -d: -f2)
    
    # Vérifier le statut admin
    local is_admin="false"
    if groups "$username" | grep -q -w admin; then
        is_admin="true"
    fi
    
    # Informations de dernière connexion
    local last_login
    last_login=$(last -1 "$username" 2>/dev/null | head -1 | awk '{print $4, $5, $6, $7}' || echo "Jamais")
    
    # Permissions du répertoire home
    local home_permissions=""
    if [[ -d "$home_dir" ]]; then
        home_permissions=$(ls -ld "$home_dir" | awk '{print $1}')
    fi
    
    # Informations sur les clés SSH
    local ssh_keys_count=0
    if [[ -d "$home_dir/.ssh" ]]; then
        ssh_keys_count=$(find "$home_dir/.ssh" -name "*.pub" 2>/dev/null | wc -l | xargs)
    fi
    
    user_info=$(cat << EOF
{
    "username": "$username",
    "uid": $uid,
    "gid": $gid,
    "real_name": "$real_name",
    "home_directory": "$home_dir",
    "shell": "$shell",
    "is_administrator": $is_admin,
    "groups": "$(echo $groups_list | sed 's/ /,/g')",
    "last_login": "$last_login",
    "home_permissions": "$home_permissions",
    "ssh_keys_count": $ssh_keys_count
}
EOF
)
    
    echo "$user_info"
}

# Audit complet des privilèges
audit_user_privileges() {
    log_action "Démarrage de l'audit complet des privilèges utilisateur"
    
    local audit_report="$REPORTS_DIR/privilege_audit_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$audit_report" << EOF
{
    "audit_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "os_version": "$(sw_vers -productVersion)",
        "generator": "Roundfleet User Privilege Manager"
    },
    "system_users": [
EOF

    local first=true
    local total_users=0
    local admin_users=0
    local standard_users=0
    local service_accounts=0
    
    # Obtenir tous les utilisateurs avec UID >= 500 (utilisateurs réguliers) et comptes système
    while IFS= read -r user; do
        local uid
        uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | awk '{print $2}')
        
        if [[ -n "$uid" ]]; then
            total_users=$((total_users + 1))
            
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$audit_report"
            fi
            
            local user_details
            user_details=$(get_user_details "$user")
            
            # Catégoriser le type d'utilisateur
            if [[ $uid -lt 500 ]]; then
                service_accounts=$((service_accounts + 1))
            elif echo "$user_details" | jq -r '.is_administrator' | grep -q "true"; then
                admin_users=$((admin_users + 1))
            else
                standard_users=$((standard_users + 1))
            fi
            
            # Ajouter l'évaluation du risque de privilège
            local risk_score
            risk_score=$(assess_privilege_risk "$user")
            
            # Ajouter le statut de conformité sécuritaire
            local compliance_status
            compliance_status=$(assess_user_compliance "$user")
            
            local enhanced_details
            enhanced_details=$(echo "$user_details" | jq ". + {\"privilege_risk_score\": $risk_score, \"compliance_status\": $compliance_status}")
            
            echo "        $enhanced_details" >> "$audit_report"
            
            log_action "Utilisateur audité: $user (UID: $uid)"
        fi
    done < <(dscl . list /Users | grep -v "^_")
    
    cat >> "$audit_report" << EOF
    ],
    "summary": {
        "total_users": $total_users,
        "administrator_users": $admin_users,
        "standard_users": $standard_users,
        "service_accounts": $service_accounts,
        "admin_percentage": $(awk "BEGIN {printf \"%.1f\", ($admin_users/$total_users)*100}")
    },
    "security_recommendations": $(generate_security_recommendations)
}
EOF

    log_action "✅ Audit des privilèges utilisateur terminé: $audit_report"
    echo "$audit_report"
}

# Évaluer le risque de privilège pour un utilisateur
assess_privilege_risk() {
    local username="$1"
    local risk_score=0
    
    # Vérifier si l'utilisateur est admin (risque élevé)
    if groups "$username" | grep -q -w admin; then
        risk_score=$((risk_score + 5))
    fi
    
    # Vérifier les appartenances excessives aux groupes
    local group_count
    group_count=$(groups "$username" | tr ' ' '\n' | wc -l)
    if [[ $group_count -gt 5 ]]; then
        risk_score=$((risk_score + 2))
    fi
    
    # Vérifier les modèles d'utilisation de sudo
    local sudo_entries
    sudo_entries=$(grep "sudo.*$username" /var/log/auth.log 2>/dev/null | wc -l || echo 0)
    if [[ $sudo_entries -gt 50 ]]; then
        risk_score=$((risk_score + 3))
    elif [[ $sudo_entries -gt 10 ]]; then
        risk_score=$((risk_score + 1))
    fi
    
    # Vérifier les clés SSH (mouvement latéral potentiel)
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    if [[ -d "$home_dir/.ssh" ]]; then
        local key_count
        key_count=$(find "$home_dir/.ssh" -name "*.pub" 2>/dev/null | wc -l)
        if [[ $key_count -gt 3 ]]; then
            risk_score=$((risk_score + 2))
        fi
    fi
    
    # Vérifier les modèles de compte de service
    if [[ "$username" =~ ^(service|daemon|app).*$ ]]; then
        risk_score=$((risk_score + 1))
    fi
    
    # Plafonner à 10
    if [[ $risk_score -gt 10 ]]; then
        risk_score=10
    fi
    
    echo "$risk_score"
}

# Évaluer la conformité utilisateur avec les cadres de sécurité
assess_user_compliance() {
    local username="$1"
    
    local compliance_issues=0
    local total_checks=4
    
    # Vérification 1: Principe du moindre privilège
    if groups "$username" | grep -q -w admin; then
        # Les utilisateurs admin ont besoin de justification
        if [[ ! -f "$POLICIES_DIR/admin_justification_$username.conf" ]]; then
            compliance_issues=$((compliance_issues + 1))
        fi
    fi
    
    # Vérification 2: Activité du compte
    local last_login
    last_login=$(last -1 "$username" | head -1 | awk '{print $4}' | grep -v "^$")
    if [[ -z "$last_login" || "$last_login" == "Jamais" ]]; then
        compliance_issues=$((compliance_issues + 1))
    fi
    
    # Vérification 3: Permissions du répertoire home
    local home_dir
    home_dir=$(dscl . -read "/Users/$username" NFSHomeDirectory 2>/dev/null | awk '{print $2}')
    if [[ -d "$home_dir" ]]; then
        local perms
        perms=$(ls -ld "$home_dir" | cut -c1-10)
        if [[ "$perms" =~ ^d.......w.$ ]] || [[ "$perms" =~ ^d........w$ ]]; then
            compliance_issues=$((compliance_issues + 1))
        fi
    fi
    
    # Vérification 4: Conformité à la politique de mot de passe
    local password_policy_compliant="true"
    # Ceci s'intégrerait typiquement avec la vérification de politique de mot de passe
    # Pour la démonstration, nous assumons la conformité
    
    local compliance_score
    compliance_score=$(awk "BEGIN {printf \"%.0f\", (($total_checks - $compliance_issues)/$total_checks)*100}")
    
    local status="conforme"
    if [[ $compliance_score -lt 80 ]]; then
        status="non_conforme"
    elif [[ $compliance_score -lt 90 ]]; then
        status="necessite_attention"
    fi
    
    echo "{\"score\": $compliance_score, \"status\": \"$status\", \"issues\": $compliance_issues}"
}

# Surveiller les tentatives d'escalade de privilèges
monitor_privilege_escalation() {
    log_action "Démarrage de la surveillance d'escalade de privilèges"
    
    local monitoring_report="$AUDIT_DIR/privilege_escalation_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$monitoring_report" << EOF
{
    "monitoring_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "monitoring_period": "last_24_hours"
    },
    "escalation_events": [
EOF

    local first=true
    local event_count=0
    
    # Surveiller l'utilisation de sudo
    if [[ -f "/var/log/auth.log" ]]; then
        local sudo_events
        sudo_events=$(grep "sudo" /var/log/auth.log | tail -50)
        
        while IFS= read -r line; do
            if [[ -n "$line" ]]; then
                if [[ "$first" == true ]]; then
                    first=false
                else
                    echo "," >> "$monitoring_report"
                fi
                
                local timestamp
                timestamp=$(echo "$line" | awk '{print $1, $2, $3}')
                local user
                user=$(echo "$line" | grep -o "USER=[^ ]*" | cut -d= -f2)
                local command
                command=$(echo "$line" | grep -o "COMMAND=.*" | cut -d= -f2-)
                
                cat >> "$monitoring_report" << EOF
        {
            "type": "sudo_usage",
            "timestamp": "$timestamp",
            "user": "$user",
            "command": "$command",
            "risk_level": "$(assess_command_risk "$command")"
        }
EOF
                event_count=$((event_count + 1))
            fi
        done <<< "$sudo_events"
    fi
    
    # Surveiller les changements d'appartenance aux groupes
    local group_changes
    group_changes=$(grep "group" /var/log/system.log 2>/dev/null | grep -E "(add|remove)" | tail -10)
    
    while IFS= read -r line; do
        if [[ -n "$line" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$monitoring_report"
            fi
            
            cat >> "$monitoring_report" << EOF
        {
            "type": "group_change",
            "event": "$line",
            "risk_level": "moyen"
        }
EOF
            event_count=$((event_count + 1))
        fi
    done <<< "$group_changes"
    
    cat >> "$monitoring_report" << EOF
    ],
    "summary": {
        "total_events": $event_count,
        "high_risk_events": $(grep -c '"risk_level": "eleve"' "$monitoring_report" 2>/dev/null || echo 0),
        "medium_risk_events": $(grep -c '"risk_level": "moyen"' "$monitoring_report" 2>/dev/null || echo 0)
    }
}
EOF

    log_action "✅ Surveillance d'escalade de privilèges terminée: $monitoring_report"
    echo "$monitoring_report"
}

# Évaluer le niveau de risque des commandes
assess_command_risk() {
    local command="$1"
    
    # Commandes à haut risque
    if echo "$command" | grep -qE "(rm -rf|chmod 777|chown root|passwd|visudo|su -|sudo su)"; then
        echo "eleve"
    # Commandes à risque moyen
    elif echo "$command" | grep -qE "(install|update|systemctl|launchctl|diskutil)"; then
        echo "moyen"
    # Commandes à faible risque
    else
        echo "faible"
    fi
}

# Appliquer les politiques de sécurité
apply_security_policy() {
    local policy_name="$1"
    local target_users="$2"
    
    log_action "Application de la politique de sécurité: $policy_name"
    
    # Obtenir les utilisateurs cibles
    local users=()
    if [[ -n "$target_users" ]]; then
        IFS=',' read -ra users <<< "$target_users"
    else
        # Appliquer à tous les utilisateurs non-système
        while IFS= read -r user; do
            local uid
            uid=$(dscl . -read "/Users/$user" UniqueID 2>/dev/null | awk '{print $2}')
            if [[ $uid -ge 500 ]]; then
                users+=("$user")
            fi
        done < <(dscl . list /Users | grep -v "^_")
    fi
    
    for user in "${users[@]}"; do
        case "$policy_name" in
            "least_privilege")
                enforce_least_privilege "$user"
                ;;
            "admin_review")
                review_admin_privileges "$user"
                ;;
            "password_policy")
                enforce_password_policy "$user"
                ;;
            "session_limits")
                configure_session_limits "$user"
                ;;
            *)
                log_action "⚠️  Politique inconnue: $policy_name"
                ;;
        esac
    done
    
    log_action "✅ Politique de sécurité '$policy_name' appliquée"
}

# Appliquer le principe du moindre privilège
enforce_least_privilege() {
    local username="$1"
    
    log_action "Application du moindre privilège pour l'utilisateur: $username"
    
    # Vérifier si l'utilisateur a vraiment besoin des privilèges admin
    if groups "$username" | grep -q -w admin; then
        local justification_file="$POLICIES_DIR/admin_justification_$username.conf"
        
        if [[ ! -f "$justification_file" ]]; then
            log_action "⚠️  L'utilisateur admin '$username' manque de documentation de justification"
            
            # Créer un modèle de justification
            cat > "$justification_file" << EOF
# Justification Admin pour l'Utilisateur: $username
# Créé: $(date)
# Statut: EN_ATTENTE_REVISION

JUSTIFICATION_METIER=""
APPROUVE_PAR=""
DATE_APPROBATION=""
DATE_REVISION=""
DATE_REVOCATION=""

# Évaluation des Risques
NIVEAU_PRIVILEGE="admin"
SCORE_JUSTIFICATION=0
REVISION_REQUISE=true

# Notes
COMMENTAIRES=""
EOF
            
            log_action "📝 Modèle de justification créé: $justification_file"
        fi
    fi
}

# Générer des recommandations de sécurité
generate_security_recommendations() {
    local recommendations='['
    local first=true
    
    # Obtenir le nombre d'utilisateurs admin
    local admin_count
    admin_count=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | wc -w)
    
    if [[ $admin_count -gt 5 ]]; then
        if [[ "$first" == true ]]; then
            first=false
        else
            recommendations+=','
        fi
        recommendations+='"Considérer réduire le nombre de comptes administrateur pour une meilleure sécurité"'
    fi
    
    # Vérifier les comptes inutilisés
    local unused_accounts=0
    while IFS= read -r user; do
        local last_login
        last_login=$(last -1 "$user" | head -1 | awk '{print $4}')
        if [[ -z "$last_login" || "$last_login" == "Jamais" ]]; then
            unused_accounts=$((unused_accounts + 1))
        fi
    done < <(dscl . list /Users | grep -v "^_")
    
    if [[ $unused_accounts -gt 0 ]]; then
        if [[ "$first" == true ]]; then
            first=false
        else
            recommendations+=','
        fi
        recommendations+="\"Considérer désactiver ou supprimer $unused_accounts comptes utilisateur inutilisés\""
    fi
    
    # Ajouter des recommandations par défaut
    if [[ "$first" == true ]]; then
        first=false
    else
        recommendations+=','
    fi
    recommendations+='"Implémenter des cycles de révision de privilèges réguliers"'
    
    recommendations+=','
    recommendations+='"Activer la journalisation d'audit complète"'
    
    recommendations+=','
    recommendations+='"Configurer la surveillance automatisée d\'escalade de privilèges"'
    
    recommendations+=']'
    echo "$recommendations"
}

# Générer un rapport de conformité
generate_compliance_report() {
    local framework="$1"
    
    log_action "Génération du rapport de conformité pour le cadre: $framework"
    
    local compliance_report="$COMPLIANCE_DIR/compliance_${framework}_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$compliance_report" << EOF
{
    "compliance_metadata": {
        "timestamp": "$(date -Iseconds)",
        "framework": "$framework",
        "hostname": "$(hostname)",
        "generator": "Roundfleet User Privilege Compliance Manager"
    },
    "framework_requirements": $(get_framework_requirements "$framework"),
    "compliance_assessment": {
        "overall_score": $(calculate_overall_compliance "$framework"),
        "user_compliance": $(assess_all_users_compliance "$framework"),
        "policy_compliance": $(assess_policy_compliance "$framework"),
        "recommendations": $(generate_compliance_recommendations "$framework")
    }
}
EOF

    log_action "✅ Rapport de conformité généré: $compliance_report"
    echo "$compliance_report"
}

# Obtenir les exigences du cadre
get_framework_requirements() {
    local framework="$1"
    
    case "$framework" in
        "nist")
            echo '{"least_privilege": true, "separation_of_duties": true, "access_review": true, "audit_trails": true}'
            ;;
        "iso27001")
            echo '{"access_control": true, "privilege_management": true, "monitoring": true, "documentation": true}'
            ;;
        "cis")
            echo '{"admin_minimization": true, "privilege_escalation_monitoring": true, "account_lifecycle": true}'
            ;;
        *)
            echo '{"basic_access_control": true, "user_management": true}'
            ;;
    esac
}

# Calculer le score de conformité global
calculate_overall_compliance() {
    local framework="$1"
    
    local total_score=0
    local check_count=0
    
    # Vérifications de conformité de base
    check_count=$((check_count + 1))
    local admin_count
    admin_count=$(dscl . -read /Groups/admin GroupMembership 2>/dev/null | wc -w)
    if [[ $admin_count -le 5 ]]; then
        total_score=$((total_score + 20))
    fi
    
    check_count=$((check_count + 1))
    if [[ -f "$LOG_FILE" ]]; then
        total_score=$((total_score + 20))
    fi
    
    check_count=$((check_count + 1))
    if [[ -d "$POLICIES_DIR" ]]; then
        total_score=$((total_score + 20))
    fi
    
    # Vérifications spécifiques au cadre
    case "$framework" in
        "nist")
            check_count=$((check_count + 2))
            # Vérifier la documentation des privilèges
            if find "$POLICIES_DIR" -name "admin_justification_*.conf" | grep -q .; then
                total_score=$((total_score + 20))
            fi
            # Vérifier les capacités d'audit
            if [[ -d "$AUDIT_DIR" ]]; then
                total_score=$((total_score + 20))
            fi
            ;;
    esac
    
    local final_score
    final_score=$(awk "BEGIN {printf \"%.0f\", ($total_score/$check_count)}")
    
    echo "$final_score"
}

# Fonction d'exécution principale
main() {
    local action="${1:-audit}"
    local parameter="$2"
    local additional_param="$3"
    
    log_action "=== Gestion des Privilèges Utilisateur Roundfleet Démarrée ==="
    log_action "Action: $action"
    log_action "Paramètre: ${parameter:-N/A}"
    
    setup_directories
    
    case "$action" in
        "check")
            if [[ -z "$parameter" ]]; then
                echo "Usage: $0 check <nom_utilisateur>"
                exit 1
            fi
            check_user_admin_status "$parameter"
            ;;
        "list")
            list_admin_users
            ;;
        "audit")
            audit_user_privileges
            ;;
        "monitor")
            monitor_privilege_escalation
            ;;
        "policy")
            if [[ -z "$parameter" ]]; then
                echo "Politiques de sécurité disponibles:"
                echo "  - least_privilege"
                echo "  - admin_review"
                echo "  - password_policy"
                echo "  - session_limits"
                echo ""
                echo "Usage: $0 policy <nom_politique> [utilisateurs_cibles]"
                exit 1
            fi
            apply_security_policy "$parameter" "$additional_param"
            ;;
        "compliance")
            if [[ -z "$parameter" ]]; then
                echo "Cadres de conformité disponibles:"
                for framework in "${!COMPLIANCE_FRAMEWORKS[@]}"; do
                    echo "  - $framework: ${COMPLIANCE_FRAMEWORKS[$framework]}"
                done
                echo ""
                echo "Usage: $0 compliance <cadre>"
                exit 1
            fi
            generate_compliance_report "$parameter"
            ;;
        "details")
            if [[ -z "$parameter" ]]; then
                echo "Usage: $0 details <nom_utilisateur>"
                exit 1
            fi
            get_user_details "$parameter" | jq .
            ;;
        *)
            echo "Usage: $0 {check|list|audit|monitor|policy|compliance|details}"
            echo "  check       - Vérifier si un utilisateur spécifique est administrateur"
            echo "  list        - Lister tous les utilisateurs administrateur"
            echo "  audit       - Générer un audit complet des privilèges"
            echo "  monitor     - Surveiller les tentatives d'escalade de privilèges"
            echo "  policy      - Appliquer une politique de sécurité aux utilisateurs"
            echo "  compliance  - Générer un rapport de conformité"
            echo "  details     - Obtenir des informations détaillées sur l'utilisateur"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des privilèges utilisateur terminée ==="
}

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

Fonctionnalités Avancées de Gestion Utilisateur

Contrôle d'Accès Basé sur les Rôles (RBAC)

#!/bin/bash

# Implémenter le système de contrôle d'accès basé sur les rôles
implement_rbac() {
    echo "=== Implémentation du Contrôle d'Accès Basé sur les Rôles ==="
    
    local rbac_config="$CONFIG_DIR/rbac_configuration.json"
    
    cat > "$rbac_config" << EOF
{
    "rbac_configuration": {
        "roles": {
            "utilisateur_standard": {
                "permissions": ["lire_fichiers", "executer_applications", "modifier_preferences_utilisateur"],
                "groups": ["users"],
                "restrictions": ["pas_modifications_systeme", "pas_creation_utilisateur"]
            },
            "utilisateur_avance": {
                "permissions": ["installer_logiciels", "modifier_preferences_systeme", "acces_outils_dev"],
                "groups": ["users", "developer"],
                "restrictions": ["pas_gestion_utilisateur", "pas_parametres_securite"]
            },
            "administrateur": {
                "permissions": ["acces_systeme_complet", "gestion_utilisateur", "configuration_securite"],
                "groups": ["admin", "users"],
                "restrictions": ["audit_requis", "justification_necessaire"]
            },
            "admin_securite": {
                "permissions": ["politiques_securite", "acces_audit", "gestion_conformite"],
                "groups": ["admin", "security"],
                "restrictions": ["approbation_double_requise"]
            }
        },
        "regles_affectation": {
            "affectation_auto": false,
            "approbation_requise": true,
            "periode_revision": "90_jours"
        }
    }
}
EOF

    echo "📋 Configuration RBAC créée: $rbac_config"
}

# Assigner un rôle à l'utilisateur
assign_user_role() {
    local username="$1"
    local role="$2"
    
    if [[ -z "$username" || -z "$role" ]]; then
        echo "Usage: assign_user_role <nom_utilisateur> <role>"
        return 1
    fi
    
    echo "👤 Attribution du rôle '$role' à l'utilisateur '$username'"
    
    # Créer un enregistrement d'attribution de rôle
    local role_file="$POLICIES_DIR/role_assignment_$username.conf"
    
    cat > "$role_file" << EOF
# Attribution de Rôle pour l'Utilisateur: $username
# Attribué: $(date)

ROLE_ATTRIBUE="$role"
ATTRIBUE_PAR="$(whoami)"
DATE_ATTRIBUTION="$(date -Iseconds)"
DATE_REVISION="$(date -d '+90 days' -Iseconds)"
JUSTIFICATION=""

# Permissions du Rôle
$(grep -A 10 "\"$role\":" "$CONFIG_DIR/rbac_configuration.json" 2>/dev/null || echo "# Définition de rôle non trouvée")

# Statut d'Approbation
STATUT_APPROBATION="en_attente"
APPROUVE_PAR=""
DATE_APPROBATION=""
EOF

    log_action "Rôle '$role' attribué à l'utilisateur '$username'"
}

Surveillance Continue de Conformité

#!/bin/bash

# Surveillance continue de conformité
continuous_compliance_monitoring() {
    echo "=== Surveillance Continue de Conformité ==="
    
    local monitoring_config="$CONFIG_DIR/compliance_monitoring.conf"
    
    cat > "$monitoring_config" << EOF
# Configuration de Surveillance de Conformité Roundfleet

# Intervalles de Surveillance
PRIVILEGE_CHECK_INTERVAL=3600    # 1 heure
AUDIT_INTERVAL=86400            # 24 heures
COMPLIANCE_REPORT_INTERVAL=604800  # 1 semaine

# Seuils d'Alerte
MAX_ADMIN_USERS=5
MAX_PRIVILEGE_RISK_SCORE=7
MAX_INACTIVE_DAYS=30

# Cadres de Conformité
ENABLED_FRAMEWORKS="nist,iso27001,cis"

# Paramètres de Notification
ALERT_EMAIL="[email protected]"
SLACK_WEBHOOK_URL=""

# Paramètres de Remédiation
AUTO_REMEDIATION=false
REQUIRE_APPROVAL=true
EOF

    # Créer le script de démon de surveillance
    local daemon_script="/usr/local/bin/roundfleet-compliance-monitor"
    
    cat > "$daemon_script" << 'EOF'
#!/bin/bash

# Démon de Surveillance de Conformité Roundfleet
source /etc/roundfleet/user_management/compliance_monitoring.conf

while true; do
    # Exécuter les vérifications de privilèges
    /usr/local/bin/roundfleet-user-management audit
    
    # Vérifier les violations de conformité
    /usr/local/bin/roundfleet-user-management monitor
    
    # Attendre jusqu'à la prochaine vérification
    sleep $PRIVILEGE_CHECK_INTERVAL
done
EOF

    chmod +x "$daemon_script"
    
    echo "🔄 Surveillance de conformité configurée"
}

Meilleures Pratiques de Sécurité

🔐 Gestion des Privilèges

• Principe du moindre privilège avec révisions d'accès régulières et exigences de justification
• Contrôle d'accès basé sur les rôles avec ensembles de permissions prédéfinis et flux d'approbation
• Surveillance d'escalade de privilèges avec détection en temps réel et alertes
• Minimisation des comptes administrateur avec justifications documentées pour l'accès admin

📊 Conformité et Audit

• Support multi-cadres (NIST, ISO 27001, CIS, SOX, HIPAA, PCI DSS)
• Surveillance continue de conformité avec évaluation et rapports automatisés
• Pistes d'audit complètes avec journalisation détaillée et capacités forensiques
• Rapports de conformité réguliers avec scoring de risque et recommandations de remédiation

🛡️ Contrôles de Sécurité

• Application du contrôle d'accès avec validation d'appartenance aux groupes et surveillance des permissions
• Gestion de session avec contrôles de timeout et limites de sessions concurrentes
• Automatisation des politiques de sécurité avec déploiement à l'échelle de la flotte et suivi de conformité
• Réponse aux incidents avec détection automatisée et capacités de notification

🔧 Opérations d'Entreprise

• Gestion utilisateur à l'échelle de la flotte avec déploiement centralisé des politiques et surveillance
• Embarquement/débarquement automatisé avec attribution de rôles et provisioning d'accès
• Capacités d'intégration avec systèmes existants de gestion d'identité et de sécurité
• Architecture évolutive supportant des milliers d'appareils et d'utilisateurs

Notes Importantes

• Privilèges administrateur doivent être accordés avec parcimonie et justification appropriée
• Révisions d'accès régulières sont essentielles pour maintenir la conformité sécuritaire
• Configurations de surveillance doivent être adaptées aux exigences de sécurité organisationnelles
• Cadres de conformité peuvent nécessiter une documentation spécifique et des procédures d'audit
• Procédures d'accès d'urgence doivent être établies pour l'accès système critique
• Formation utilisateur sur la gestion des privilèges et les politiques de sécurité améliore la conformité globale