Gestion des Jetons Sécurisés sur macOS

Gérez les jetons sécurisés sur vos appareils Roundfleet pour activer le chiffrement FileVault, les opérations de démarrage sécurisé et l'authentification cryptographique. Ce tutoriel couvre la vérification, l'octroi, la suppression des jetons sécurisés et la gestion à l'échelle de l'entreprise pour une conformité sécuritaire renforcée.

Comprendre les Jetons Sécurisés

Les jetons sécurisés sont des identifiants cryptographiques qui permettent aux utilisateurs d'effectuer des opérations sensibles au niveau sécurité sur macOS, particulièrement essentiels pour le chiffrement de disque FileVault :

Que sont les Jetons Sécurisés ?

Clés Cryptographiques - Permettent l'accès au stockage chiffré et aux fonctions de sécurité
Exigence FileVault - Requis pour que les utilisateurs puissent déverrouiller les disques chiffrés FileVault
Jetons Bootstrap - Facilitent le démarrage sécurisé et les processus de récupération système
Pont d'Authentification - Connectent les identifiants utilisateur aux opérations de sécurité système
Compatibilité Legacy - Remplacent les anciens mécanismes d'authentification dans macOS moderne

Exigences des Jetons Sécurisés

macOS 10.13+ - High Sierra et versions ultérieures supportent les jetons sécurisés
Privilèges Admin - L'octroi de jetons nécessite un admin existant avec jeton sécurisé
Authentification Utilisateur - Mots de passe admin et utilisateur cible requis
Intégrité Système - SIP (System Integrity Protection) doit être correctement configuré
Propriété Volume - Les utilisateurs ont besoin de permissions d'accès volume appropriées

Vérification du Statut des Jetons Sécurisés

Vérifier le Statut d'un Utilisateur Individuel

#!/bin/bash

# Vérifier le statut du jeton sécurisé pour un utilisateur spécifique
check_user_secure_token() {
    local username="$1"
    
    if [[ -z "$username" ]]; then
        echo "❌ Utilisation : check_user_secure_token <nom_utilisateur>"
        return 1
    fi
    
    # Vérifier que l'utilisateur existe
    if ! id "$username" >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$username' n'existe pas"
        return 1
    fi
    
    echo "🔍 Vérification du statut du jeton sécurisé pour l'utilisateur : $username"
    
    # Vérifier le statut du jeton sécurisé
    local token_status
    token_status=$(sysadminctl -secureTokenStatus "$username" 2>&1)
    
    if echo "$token_status" | grep -q "ENABLED"; then
        echo "✅ L'utilisateur '$username' a un jeton sécurisé activé"
        return 0
    elif echo "$token_status" | grep -q "DISABLED"; then
        echo "❌ L'utilisateur '$username' n'a pas de jeton sécurisé"
        return 1
    else
        echo "⚠️ Impossible de déterminer le statut du jeton sécurisé pour '$username'"
        echo "Sortie : $token_status"
        return 2
    fi
}

# Exemple d'utilisation
# check_user_secure_token "jean.dupont"

Vérifier le Statut de Tous les Utilisateurs

#!/bin/bash

# Vérifier le statut des jetons sécurisés pour tous les utilisateurs
check_all_users_secure_tokens() {
    echo "🔍 Vérification du statut des jetons sécurisés pour tous les utilisateurs..."
    echo ""
    
    local enabled_count=0
    local disabled_count=0
    local error_count=0
    
    # Obtenir tous les utilisateurs avec UID >= 500 (utilisateurs non-système)
    local users
    users=$(dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}')
    
    printf "%-20s %-15s %-30s\n" "Nom d'utilisateur" "Statut" "Détails"
    printf "%-20s %-15s %-30s\n" "----------------" "------" "-------"
    
    for user in $users; do
        local status
        local details=""
        
        # Ignorer les comptes système qui pourraient avoir des UID élevés
        if [[ "$user" =~ ^(_|com\.|root|daemon|nobody) ]]; then
            continue
        fi
        
        # Vérifier le statut du jeton sécurisé
        local token_output
        token_output=$(sysadminctl -secureTokenStatus "$user" 2>&1)
        
        if echo "$token_output" | grep -q "ENABLED"; then
            status="✅ Activé"
            details="Jeton sécurisé actif"
            ((enabled_count++))
        elif echo "$token_output" | grep -q "DISABLED"; then
            status="❌ Désactivé"
            details="Pas de jeton sécurisé"
            ((disabled_count++))
        else
            status="⚠️ Erreur"
            details="Impossible de déterminer"
            ((error_count++))
        fi
        
        printf "%-20s %-15s %-30s\n" "$user" "$status" "$details"
    done
    
    echo ""
    echo "=== Résumé ==="
    echo "Utilisateurs avec jeton sécurisé : $enabled_count"
    echo "Utilisateurs sans jeton sécurisé : $disabled_count"
    echo "Erreurs/Inconnu : $error_count"
    
    # Recommandations
    if [[ "$disabled_count" -gt 0 ]]; then
        echo ""
        echo "💡 $disabled_count utilisateurs manquent de jetons sécurisés - considérez l'octroi pour l'accès FileVault"
    fi
    
    if [[ "$enabled_count" -eq 0 ]]; then
        echo ""
        echo "⚠️ Aucun utilisateur n'a de jetons sécurisés - le système peut avoir des limitations de sécurité"
    fi
}

# Exécuter la vérification
check_all_users_secure_tokens

Octroi de Jetons Sécurisés

Octroi Basique de Jeton Sécurisé

#!/bin/bash

# Accorder un jeton sécurisé à un utilisateur
grant_secure_token() {
    local admin_user="$1"
    local admin_password="$2"
    local target_user="$3"
    local target_password="$4"
    
    if [[ -z "$admin_user" || -z "$admin_password" || -z "$target_user" || -z "$target_password" ]]; then
        echo "❌ Utilisation : grant_secure_token <utilisateur_admin> <mot_de_passe_admin> <utilisateur_cible> <mot_de_passe_cible>"
        return 1
    fi
    
    echo "🔐 Octroi du jeton sécurisé à l'utilisateur : $target_user"
    
    # Vérifier que l'utilisateur admin a un jeton sécurisé
    echo "Vérification des identifiants admin..."
    local admin_token_status
    admin_token_status=$(sysadminctl -secureTokenStatus "$admin_user" 2>&1)
    
    if ! echo "$admin_token_status" | grep -q "ENABLED"; then
        echo "❌ L'utilisateur admin '$admin_user' n'a pas de jeton sécurisé"
        echo "Impossible d'accorder un jeton sécurisé sans un utilisateur admin qui en a déjà un"
        return 1
    fi
    
    echo "✅ L'utilisateur admin '$admin_user' a un jeton sécurisé"
    
    # Vérifier si l'utilisateur cible a déjà un jeton sécurisé
    echo "Vérification du statut de l'utilisateur cible..."
    local target_token_status
    target_token_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$target_token_status" | grep -q "ENABLED"; then
        echo "ℹ️ L'utilisateur '$target_user' a déjà un jeton sécurisé - aucune action nécessaire"
        return 0
    fi
    
    # Accorder le jeton sécurisé
    echo "Octroi du jeton sécurisé à '$target_user'..."
    
    if sysadminctl \
        -adminUser "$admin_user" \
        -adminPassword "$admin_password" \
        -secureTokenOn "$target_user" \
        -password "$target_password"; then
        
        echo "✅ Jeton sécurisé accordé avec succès à '$target_user'"
        
        # Vérifier que l'octroi a réussi
        echo "Vérification de l'octroi du jeton sécurisé..."
        local verify_status
        verify_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
        
        if echo "$verify_status" | grep -q "ENABLED"; then
            echo "✅ Vérification réussie - '$target_user' a maintenant un jeton sécurisé"
            return 0
        else
            echo "❌ Échec de la vérification - le jeton sécurisé n'a peut-être pas été accordé correctement"
            return 1
        fi
    else
        echo "❌ Échec de l'octroi du jeton sécurisé à '$target_user'"
        echo "Vérifiez les identifiants et les permissions utilisateur"
        return 1
    fi
}

Gestion Avancée des Jetons Sécurisés

#!/bin/bash

# Gestion avancée des jetons sécurisés avec validation
advanced_secure_token_grant() {
    local admin_user="$1"
    local admin_password="$2"
    local target_user="$3"
    local target_password="$4"
    local force_mode="${5:-false}"
    
    echo "🔐 Gestion Avancée des Jetons Sécurisés"
    echo "Utilisateur cible : $target_user"
    echo "Utilisateur admin : $admin_user"
    echo "Mode forcé : $force_mode"
    echo ""
    
    # Vérification de la version macOS
    local macos_version
    macos_version=$(sw_vers -productVersion)
    local macos_major
    macos_major=$(echo "$macos_version" | cut -d. -f1)
    local macos_minor
    macos_minor=$(echo "$macos_version" | cut -d. -f2)
    
    echo "Version macOS : $macos_version"
    
    # Vérifier la compatibilité macOS
    if [[ "$macos_major" -lt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -lt 13 ]]; then
        echo "❌ Les jetons sécurisés nécessitent macOS 10.13 (High Sierra) ou ultérieur"
        echo "Version actuelle ($macos_version) non supportée"
        return 1
    fi
    
    # Vérifier que les utilisateurs existent
    if ! id "$admin_user" >/dev/null 2>&1; then
        echo "❌ L'utilisateur admin '$admin_user' n'existe pas"
        return 1
    fi
    
    if ! id "$target_user" >/dev/null 2>&1; then
        echo "❌ L'utilisateur cible '$target_user' n'existe pas"
        return 1
    fi
    
    # Vérifier si l'utilisateur admin est vraiment un administrateur
    if ! dseditgroup -o checkmember -m "$admin_user" admin >/dev/null 2>&1; then
        echo "❌ L'utilisateur '$admin_user' n'est pas membre du groupe admin"
        return 1
    fi
    
    echo "✅ Validation des utilisateurs réussie"
    
    # Vérifier le statut du jeton sécurisé pour l'admin
    local admin_token_status
    admin_token_status=$(sysadminctl -secureTokenStatus "$admin_user" 2>&1)
    
    if echo "$admin_token_status" | grep -q "DISABLED"; then
        # Gestion spéciale pour macOS 10.15+
        if [[ "$macos_major" -gt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -gt 14 ]]; then
            echo "⚠️ Dans macOS 10.15+, les jetons sécurisés peuvent être accordés automatiquement"
            echo "   au premier utilisateur qui active FileVault si aucun autre utilisateur n'a de jetons"
            if [[ "$force_mode" != "true" ]]; then
                echo "   Utilisez force_mode=true pour contourner cette vérification"
                return 1
            fi
        else
            echo "❌ L'utilisateur admin '$admin_user' n'a pas de jeton sécurisé"
            echo "   Impossible d'accorder un jeton sans un admin qui en a déjà un"
            return 1
        fi
    else
        echo "✅ L'utilisateur admin '$admin_user' a un jeton sécurisé"
    fi
    
    # Vérifier le statut actuel de l'utilisateur cible
    local target_token_status
    target_token_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$target_token_status" | grep -q "ENABLED"; then
        echo "ℹ️ L'utilisateur '$target_user' a déjà un jeton sécurisé"
        if [[ "$force_mode" != "true" ]]; then
            echo "   Aucune action nécessaire"
            return 0
        else
            echo "   Mode forcé activé - tentera de rafraîchir le jeton"
        fi
    fi
    
    # Tenter d'accorder le jeton sécurisé
    echo ""
    echo "Octroi du jeton sécurisé à '$target_user'..."
    
    if sysadminctl \
        -adminUser "$admin_user" \
        -adminPassword "$admin_password" \
        -secureTokenOn "$target_user" \
        -password "$target_password" >/dev/null 2>&1; then
        
        echo "✅ Commande d'octroi de jeton sécurisé exécutée avec succès"
    else
        echo "❌ Échec de la commande d'octroi de jeton sécurisé"
        return 1
    fi
    
    # Vérifier le résultat
    echo "Vérification du statut du jeton sécurisé..."
    local final_status
    final_status=$(sysadminctl -secureTokenStatus "$target_user" 2>&1)
    
    if echo "$final_status" | grep -q "ENABLED"; then
        echo "✅ Vérification réussie - '$target_user' a maintenant un jeton sécurisé"
        
        # Informations supplémentaires
        echo ""
        echo "=== Informations Supplémentaires ==="
        echo "Éligibilité FileVault : L'utilisateur peut maintenant déverrouiller les volumes FileVault"
        echo "Opérations de sécurité : L'utilisateur peut effectuer des opérations cryptographiques"
        echo "Récupération système : L'utilisateur peut participer aux processus de démarrage sécurisé"
        
        return 0
    else
        echo "❌ Échec de la vérification - le jeton sécurisé n'a pas été accordé"
        echo "Ceci peut indiquer :"
        echo "  - Identifiants incorrects"
        echo "  - Restrictions de sécurité système"
        echo "  - Problèmes de configuration FileVault"
        return 1
    fi
}

Gestion d'Entreprise des Jetons Sécurisés

#!/bin/bash

# Outil de Gestion des Jetons Sécurisés Roundfleet
# Gestion complète des jetons sécurisés pour environnements d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_securetoken.log"
REPORT_DIR="/var/reports/roundfleet/securetoken"
CONFIG_FILE="/etc/roundfleet/securetoken_policy.conf"
BACKUP_DIR="/var/backups/roundfleet/securetoken"

# Paramètres de politique
REQUIRE_SECURE_TOKENS=true
AUTO_GRANT_ON_CREATION=false
MINIMUM_ADMIN_TOKENS=2
ALERT_ON_TOKEN_LOSS=true
AUDIT_TOKEN_CHANGES=true

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

# Configurer les répertoires
setup_directories() {
    for dir in "$REPORT_DIR" "$(dirname "$CONFIG_FILE")" "$BACKUP_DIR"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# Générer un rapport complet des jetons sécurisés
generate_secure_token_report() {
    local report_file="$REPORT_DIR/rapport_jetons_securises_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "📊 Génération d'un rapport complet des jetons sécurisés..."
    
    {
        echo "Rapport de Gestion des Jetons Sécurisés Roundfleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "=============================================="
        echo ""
        
        # Informations système
        echo "=== Informations Système ==="
        echo "Appareil : $(system_profiler SPHardwareDataType | grep "Model Name" | awk -F': ' '{print $2}' | xargs)"
        echo "Série : $(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F': ' '{print $2}' | xargs)"
        echo "Version macOS : $(sw_vers -productVersion)"
        echo "Build : $(sw_vers -buildVersion)"
        echo ""
        
        # Statut FileVault
        echo "=== Informations FileVault ==="
        local fv_status=$(fdesetup status 2>/dev/null || echo "Statut FileVault non disponible")
        echo "Statut FileVault : $fv_status"
        
        if echo "$fv_status" | grep -q "On"; then
            echo "Utilisateurs FileVault :"
            fdesetup list 2>/dev/null | while read -r user; do
                echo "  - $user"
            done
        fi
        echo ""
        
        # Analyse des jetons sécurisés
        echo "=== Analyse des Jetons Sécurisés ==="
        
        local total_users=0
        local enabled_tokens=0
        local disabled_tokens=0
        local admin_with_tokens=0
        local standard_with_tokens=0
        
        # Analyser tous les utilisateurs
        local users
        users=$(dscl . list /Users UniqueID | awk '$2 >= 500 {print $1}')
        
        printf "%-25s %-12s %-10s %-15s\n" "Nom d'utilisateur" "Statut Jeton" "Admin" "UID"
        printf "%-25s %-12s %-10s %-15s\n" "----------------" "------------" "-----" "---"
        
        for user in $users; do
            # Ignorer les comptes système
            if [[ "$user" =~ ^(_|com\.|root|daemon|nobody) ]]; then
                continue
            fi
            
            ((total_users++))
            
            local uid
            uid=$(id -u "$user" 2>/dev/null || echo "N/A")
            
            local is_admin="Non"
            if dseditgroup -o checkmember -m "$user" admin >/dev/null 2>&1; then
                is_admin="Oui"
            fi
            
            local token_status
            local token_output
            token_output=$(sysadminctl -secureTokenStatus "$user" 2>&1)
            
            if echo "$token_output" | grep -q "ENABLED"; then
                token_status="✅ Activé"
                ((enabled_tokens++))
                if [[ "$is_admin" == "Oui" ]]; then
                    ((admin_with_tokens++))
                else
                    ((standard_with_tokens++))
                fi
            elif echo "$token_output" | grep -q "DISABLED"; then
                token_status="❌ Désactivé"
                ((disabled_tokens++))
            else
                token_status="⚠️ Inconnu"
            fi
            
            printf "%-25s %-12s %-10s %-15s\n" "$user" "$token_status" "$is_admin" "$uid"
        done
        
        echo ""
        echo "=== Statistiques ==="
        echo "Total utilisateurs analysés : $total_users"
        echo "Utilisateurs avec jetons sécurisés : $enabled_tokens"
        echo "Utilisateurs sans jetons sécurisés : $disabled_tokens"
        echo "Utilisateurs admin avec jetons : $admin_with_tokens"
        echo "Utilisateurs standard avec jetons : $standard_with_tokens"
        
        # Évaluation de sécurité
        echo ""
        echo "=== Évaluation de Sécurité ==="
        
        local security_score=100
        local issues_found=0
        
        if [[ "$enabled_tokens" -eq 0 ]]; then
            echo "❌ CRITIQUE : Aucun utilisateur n'a de jetons sécurisés"
            security_score=$((security_score - 50))
            ((issues_found++))
        fi
        
        if [[ "$admin_with_tokens" -eq 0 ]]; then
            echo "❌ CRITIQUE : Aucun utilisateur admin n'a de jetons sécurisés"
            security_score=$((security_score - 40))
            ((issues_found++))
        elif [[ "$admin_with_tokens" -lt "$MINIMUM_ADMIN_TOKENS" ]]; then
            echo "⚠️ AVERTISSEMENT : Moins de $MINIMUM_ADMIN_TOKENS utilisateurs admin ont des jetons sécurisés"
            security_score=$((security_score - 20))
            ((issues_found++))
        fi
        
        if [[ "$disabled_tokens" -gt "$enabled_tokens" ]]; then
            echo "⚠️ AVERTISSEMENT : Plus d'utilisateurs manquent de jetons sécurisés que n'en ont"
            security_score=$((security_score - 15))
            ((issues_found++))
        fi
        
        if [[ "$issues_found" -eq 0 ]]; then
            echo "✅ Aucun problème de sécurité détecté"
        fi
        
        echo ""
        echo "Score de Sécurité : $security_score/100"
        
        # Recommandations
        echo ""
        echo "=== Recommandations ==="
        
        if [[ "$disabled_tokens" -gt 0 ]]; then
            echo "💡 Accordez des jetons sécurisés à $disabled_tokens utilisateurs pour une compatibilité FileVault complète"
        fi
        
        if [[ "$admin_with_tokens" -lt 2 ]]; then
            echo "💡 Assurez-vous qu'au moins 2 utilisateurs admin ont des jetons sécurisés pour la redondance"
        fi
        
        echo "💡 Audits réguliers des jetons sécurisés recommandés pour la conformité"
        
    } > "$report_file"
    
    echo "📊 Rapport sauvegardé dans : $report_file"
    log_action "Rapport de jetons sécurisés généré : $report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-aide}"
    local target_user="${2:-}"
    local admin_user="${3:-}"
    
    log_action "=== Gestion des Jetons Sécurisés Roundfleet Démarrée ==="
    
    setup_directories
    
    case "$action" in
        "verifier")
            if [[ -n "$target_user" ]]; then
                check_user_secure_token "$target_user"
            else
                check_all_users_secure_tokens
            fi
            ;;
        "accorder")
            if [[ -n "$target_user" && -n "$admin_user" ]]; then
                echo "Octroi interactif de jeton sécurisé pour $target_user"
                read -s -p "Mot de passe admin pour $admin_user : " admin_pass
                echo ""
                read -s -p "Mot de passe pour $target_user : " target_pass
                echo ""
                advanced_secure_token_grant "$admin_user" "$admin_pass" "$target_user" "$target_pass"
            else
                echo "❌ Utilisation : $0 accorder <utilisateur_cible> <utilisateur_admin>"
            fi
            ;;
        "rapport")
            generate_secure_token_report
            ;;
        "version")
            local macos_version
            macos_version=$(sw_vers -productVersion)
            echo "Version macOS : $macos_version"
            
            local macos_major
            macos_major=$(echo "$macos_version" | cut -d. -f1)
            local macos_minor
            macos_minor=$(echo "$macos_version" | cut -d. -f2)
            
            if [[ "$macos_major" -lt 10 ]] || [[ "$macos_major" -eq 10 && "$macos_minor" -lt 13 ]]; then
                echo "❌ Les jetons sécurisés nécessitent macOS 10.13 ou ultérieur"
            else
                echo "✅ Jetons sécurisés supportés sur cette version macOS"
            fi
            ;;
        "aide"|*)
            echo "Outil de Gestion des Jetons Sécurisés Roundfleet"
            echo "Utilisation : $0 [action] [options]"
            echo ""
            echo "Actions :"
            echo "  verifier [utilisateur]           - Vérifier le statut des jetons sécurisés (tous les utilisateurs si aucun utilisateur spécifié)"
            echo "  accorder <utilisateur> <admin>   - Accorder un jeton sécurisé à l'utilisateur (mots de passe interactifs)"
            echo "  rapport                          - Générer un rapport complet des jetons sécurisés"
            echo "  version                          - Vérifier la compatibilité de version macOS"
            echo "  aide                             - Afficher ce message d'aide"
            echo ""
            echo "Exemples :"
            echo "  $0 verifier                      # Vérifier tous les utilisateurs"
            echo "  $0 verifier jean.dupont          # Vérifier un utilisateur spécifique"
            echo "  $0 accorder jean.dupont admin.utilisateur  # Accorder jeton interactivement"
            echo "  $0 rapport                       # Générer rapport détaillé"
            echo ""
            echo "Exigences des Jetons Sécurisés :"
            echo "  - macOS 10.13 (High Sierra) ou ultérieur"
            echo "  - Utilisateur admin avec jeton sécurisé existant"
            echo "  - Identifiants valides pour admin et utilisateurs cibles"
            echo "  - Permissions système appropriées et configuration SIP"
            ;;
    esac
    
    log_action "=== Gestion des Jetons Sécurisés Roundfleet Terminée ==="
}

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

Meilleures Pratiques des Jetons Sécurisés

Considérations de Sécurité

Aspect	Recommandation	Justification
Redondance Admin	Maintenir 2+ utilisateurs admin avec jetons	Évite les scénarios de verrouillage
Sécurité Mot de Passe	Utiliser des mots de passe forts et uniques	Les jetons ne sont sécurisés que par les mots de passe
Audits Réguliers	Révisions mensuelles du statut des jetons	Détecter les changements non autorisés
Intégration FileVault	Accorder les jetons avant d'activer FileVault	Assure que tous les utilisateurs peuvent déverrouiller les disques
Documentation	Maintenir un registre des jetons utilisateur	Suivre la conformité d'entreprise

Notes Importantes

Exigences de Version macOS - Les jetons sécurisés nécessitent macOS 10.13 (High Sierra) ou ultérieur
Prérequis Admin - L'octroi de jetons nécessite un utilisateur admin existant avec jeton sécurisé
Sécurité Mot de Passe - Les mots de passe admin et utilisateur cible doivent être fournis pour l'octroi de jetons
Intégration FileVault - Les utilisateurs ont besoin de jetons sécurisés pour déverrouiller les volumes chiffrés FileVault
Déploiement d'Entreprise - Testez les opérations de jetons sur des appareils individuels avant le déploiement de flotte
Surveillance - Les audits réguliers assurent la conformité avec les politiques de sécurité d'entreprise

Guide

Avis important