Gestion Entreprise du Client Itinérant Cisco Umbrella sur macOS

Déployez et gérez les clients itinérants Cisco Umbrella dans votre Roundfleet avec une protection DNS de sécurité de niveau entreprise, des workflows de déploiement automatisés et des capacités de surveillance complètes. Ce tutoriel transforme le processus de déploiement de base en une solution de sécurité d'entreprise robuste.

Comprendre la Gestion Cisco Umbrella Entreprise

Le déploiement Cisco Umbrella en entreprise nécessite plus qu'une simple installation de client, exigeant :

Workflows de déploiement automatisés avec configurations spécifiques à l'organisation
Gestion centralisée des politiques de sécurité avec contrôles de filtrage DNS
Surveillance et rapports en temps réel des menaces et activités de sécurité
Gestion des certificats pour les fonctionnalités de sécurité avancées
Suivi de conformité pour la gestion de la posture de sécurité
Capacités d'intégration avec l'infrastructure de sécurité existante

Processus de Déploiement Cisco Umbrella de Base

Composants de Déploiement Basiques

Push de Configuration - Déployer OrgInfo.plist avec paramètres d'organisation
Installation PKG - Installer l'application client itinérant Umbrella
Distribution de Certificats - Déployer les certificats racine pour les fonctionnalités avancées
Application de Politiques - Configurer les politiques de sécurité et surveillance

Script de Configuration de Base

# Script de configuration de base
mkdir "/Library/Application Support/OpenDNS Roaming Client/"
cat <<EOF > "/Library/Application Support/OpenDNS Roaming Client/OrgInfo.plist"
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>APIFingerprint</key>
    <string>xxxxxxxxxxx</string>
    <key>APIOrganizationID</key>
    <string>xxxxxx</string>
    <key>APIUserID</key>
    <string>xxxxx</string>
    <key>InstallMenubar</key>
    <false/>
</dict>
</plist>
EOF

Système de Gestion Cisco Umbrella Entreprise

#!/bin/bash

# Système de Gestion Cisco Umbrella Entreprise Roundfleet
# Déploiement DNS de sécurité complet avec contrôles entreprise et surveillance

# Configuration
SCRIPT_NAME="Gestionnaire Cisco Umbrella Roundfleet"
VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_umbrella.log"
AUDIT_LOG="/var/log/roundfleet_umbrella_audit.log"
CONFIG_DIR="/Library/Application Support/OpenDNS Roaming Client"
UMBRELLA_CONFIG="$CONFIG_DIR/OrgInfo.plist"
CERTS_DIR="/etc/roundfleet/umbrella/certificates"
POLICIES_DIR="/etc/roundfleet/umbrella/policies"
TEMP_DIR="/tmp/roundfleet_umbrella"
BACKUP_DIR="/var/backups/umbrella"
MONITORING_INTERVAL=300  # 5 minutes
HEALTH_CHECK_TIMEOUT=30
ORGANIZATION_NAME="Roundfleet Entreprise"
DEPLOYMENT_MODE="enterprise"
ENABLE_ADVANCED_FEATURES=true
ENABLE_THREAT_MONITORING=true
AUTO_CERTIFICATE_RENEWAL=true

# Paramètres de Configuration Umbrella (à personnaliser par organisation)
declare -A UMBRELLA_CONFIG_PARAMS=(
    ["APIFingerprint"]=""           # À remplir depuis le tableau de bord Cisco
    ["APIOrganizationID"]=""        # À remplir depuis le tableau de bord Cisco
    ["APIUserID"]=""                # À remplir depuis le tableau de bord Cisco
    ["InstallMenubar"]="false"
    ["EnableLogging"]="true"
    ["LogLevel"]="INFO"
    ["UpdateInterval"]="3600"
    ["BackupDNS"]="8.8.8.8,1.1.1.1"
    ["EnforceSecureDNS"]="true"
    ["BlockMalware"]="true"
    ["BlockPhishing"]="true"
    ["BlockAdware"]="true"
    ["ContentFiltering"]="true"
    ["SafeSearch"]="true"
    ["YouTubeFiltering"]="strict"
)

# Modèles de Politiques de Sécurité
declare -A SECURITY_POLICIES=(
    ["executive"]="securite_elevee_blocage_minimal"
    ["standard"]="securite_equilibree_blocage_modere"
    ["guest"]="securite_basique_blocage_etendu"
    ["developer"]="securite_moyenne_blocage_minimal"
    ["kiosk"]="securite_maximale_blocage_etendu"
)

# Créer les répertoires nécessaires
mkdir -p "$CONFIG_DIR"
mkdir -p "$CERTS_DIR"
mkdir -p "$POLICIES_DIR"
mkdir -p "$TEMP_DIR"
mkdir -p "$BACKUP_DIR"
mkdir -p "$(dirname "$LOG_FILE")"
mkdir -p "$(dirname "$AUDIT_LOG")"

# Définir les permissions sécurisées
chmod 755 "$CONFIG_DIR"
chmod 700 "$CERTS_DIR"
chmod 750 "$POLICIES_DIR"
chmod 700 "$TEMP_DIR"
chmod 750 "$BACKUP_DIR"

# Fonctions de journalisation
log_operation() {
    local level="$1"
    local message="$2"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local admin_user=$(whoami)
    echo "[$timestamp] [$level] [$admin_user] $message" | tee -a "$LOG_FILE"
}

log_security_event() {
    local event_type="$1"
    local details="$2"
    local severity="$3"
    local admin_user=$(whoami)
    
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local source_ip=$(who am i | awk '{print $5}' | tr -d '()')
    echo "SECURITY|$timestamp|$event_type|$severity|$admin_user|$source_ip|$details" >> "$AUDIT_LOG"
}

# Valider les paramètres de configuration Cisco Umbrella
validate_umbrella_config() {
    local errors=()
    
    # Vérifier les paramètres API requis
    if [[ -z "${UMBRELLA_CONFIG_PARAMS[APIFingerprint]}" ]]; then
        errors+=("APIFingerprint est requis")
    fi
    
    if [[ -z "${UMBRELLA_CONFIG_PARAMS[APIOrganizationID]}" ]]; then
        errors+=("APIOrganizationID est requis")
    fi
    
    if [[ -z "${UMBRELLA_CONFIG_PARAMS[APIUserID]}" ]]; then
        errors+=("APIUserID est requis")
    fi
    
    # Valider le format de l'empreinte (vérification basique)
    if [[ -n "${UMBRELLA_CONFIG_PARAMS[APIFingerprint]}" ]] && [[ ! "${UMBRELLA_CONFIG_PARAMS[APIFingerprint]}" =~ ^[A-Fa-f0-9]{40,}$ ]]; then
        errors+=("Le format de l'APIFingerprint semble invalide")
    fi
    
    if [[ ${#errors[@]} -gt 0 ]]; then
        echo "Validation de la configuration Umbrella échouée :"
        printf '  - %s\n' "${errors[@]}"
        return 1
    fi
    
    return 0
}

# Générer la configuration Umbrella entreprise
generate_umbrella_config() {
    local user_profile="${1:-standard}"
    local custom_settings="${2:-}"
    local admin_user=$(whoami)
    
    log_security_event "CONFIG_GENERATION" "profile=$user_profile" "INFO"
    
    echo "=== Génération Configuration Cisco Umbrella ==="
    echo "Profil Utilisateur : $user_profile"
    echo "Mode de Déploiement : $DEPLOYMENT_MODE"
    echo "Administrateur : $admin_user"
    echo ""
    
    # Valider la configuration avant génération
    if ! validate_umbrella_config; then
        log_operation "ERROR" "Validation de configuration échouée"
        return 1
    fi
    
    # Sauvegarder la configuration existante
    if [[ -f "$UMBRELLA_CONFIG" ]]; then
        local backup_file="$BACKUP_DIR/OrgInfo_$(date +%Y%m%d_%H%M%S).plist"
        cp "$UMBRELLA_CONFIG" "$backup_file"
        log_operation "INFO" "Configuration existante sauvegardée dans : $backup_file"
    fi
    
    # Appliquer les paramètres de sécurité spécifiques au profil
    case "$user_profile" in
        "executive")
            UMBRELLA_CONFIG_PARAMS["LogLevel"]="WARN"
            UMBRELLA_CONFIG_PARAMS["InstallMenubar"]="false"
            UMBRELLA_CONFIG_PARAMS["ContentFiltering"]="false"
            ;;
        "standard")
            UMBRELLA_CONFIG_PARAMS["LogLevel"]="INFO"
            UMBRELLA_CONFIG_PARAMS["InstallMenubar"]="false"
            UMBRELLA_CONFIG_PARAMS["ContentFiltering"]="true"
            ;;
        "guest")
            UMBRELLA_CONFIG_PARAMS["LogLevel"]="WARN"
            UMBRELLA_CONFIG_PARAMS["InstallMenubar"]="false"
            UMBRELLA_CONFIG_PARAMS["ContentFiltering"]="true"
            UMBRELLA_CONFIG_PARAMS["SafeSearch"]="true"
            ;;
        "developer")
            UMBRELLA_CONFIG_PARAMS["LogLevel"]="DEBUG"
            UMBRELLA_CONFIG_PARAMS["InstallMenubar"]="true"
            UMBRELLA_CONFIG_PARAMS["ContentFiltering"]="false"
            ;;
        "kiosk")
            UMBRELLA_CONFIG_PARAMS["LogLevel"]="ERROR"
            UMBRELLA_CONFIG_PARAMS["InstallMenubar"]="false"
            UMBRELLA_CONFIG_PARAMS["ContentFiltering"]="true"
            UMBRELLA_CONFIG_PARAMS["EnforceSecureDNS"]="true"
            ;;
    esac
    
    # Générer le fichier de configuration
    cat > "$UMBRELLA_CONFIG" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <!-- Configuration API Cisco Umbrella de Base -->
    <key>APIFingerprint</key>
    <string>${UMBRELLA_CONFIG_PARAMS[APIFingerprint]}</string>
    <key>APIOrganizationID</key>
    <string>${UMBRELLA_CONFIG_PARAMS[APIOrganizationID]}</string>
    <key>APIUserID</key>
    <string>${UMBRELLA_CONFIG_PARAMS[APIUserID]}</string>
    
    <!-- Configuration Interface Utilisateur Entreprise -->
    <key>InstallMenubar</key>
    <${UMBRELLA_CONFIG_PARAMS[InstallMenubar]}/>
    <key>ShowNotifications</key>
    <true/>
    <key>AutoStart</key>
    <true/>
    
    <!-- Journalisation et Surveillance -->
    <key>EnableLogging</key>
    <${UMBRELLA_CONFIG_PARAMS[EnableLogging]}/>
    <key>LogLevel</key>
    <string>${UMBRELLA_CONFIG_PARAMS[LogLevel]}</string>
    <key>LogRotationDays</key>
    <integer>30</integer>
    
    <!-- Configuration Réseau -->
    <key>UpdateInterval</key>
    <integer>${UMBRELLA_CONFIG_PARAMS[UpdateInterval]}</integer>
    <key>BackupDNS</key>
    <string>${UMBRELLA_CONFIG_PARAMS[BackupDNS]}</string>
    <key>EnforceSecureDNS</key>
    <${UMBRELLA_CONFIG_PARAMS[EnforceSecureDNS]}/>
    
    <!-- Politiques de Sécurité -->
    <key>BlockMalware</key>
    <${UMBRELLA_CONFIG_PARAMS[BlockMalware]}/>
    <key>BlockPhishing</key>
    <${UMBRELLA_CONFIG_PARAMS[BlockPhishing]}/>
    <key>BlockAdware</key>
    <${UMBRELLA_CONFIG_PARAMS[BlockAdware]}/>
    
    <!-- Filtrage de Contenu -->
    <key>ContentFiltering</key>
    <${UMBRELLA_CONFIG_PARAMS[ContentFiltering]}/>
    <key>SafeSearch</key>
    <${UMBRELLA_CONFIG_PARAMS[SafeSearch]}/>
    <key>YouTubeFiltering</key>
    <string>${UMBRELLA_CONFIG_PARAMS[YouTubeFiltering]}</string>
    
    <!-- Métadonnées Entreprise -->
    <key>OrganizationName</key>
    <string>$ORGANIZATION_NAME</string>
    <key>DeploymentMode</key>
    <string>$DEPLOYMENT_MODE</string>
    <key>ConfigurationVersion</key>
    <string>$(date +%Y%m%d%H%M%S)</string>
    <key>DeployedBy</key>
    <string>$admin_user</string>
    <key>DeploymentDate</key>
    <string>$(date)</string>
    <key>UserProfile</key>
    <string>$user_profile</string>
</dict>
</plist>
EOF
    
    # Définir les permissions sécurisées
    chmod 644 "$UMBRELLA_CONFIG"
    chown root:wheel "$UMBRELLA_CONFIG"
    
    # Valider la configuration générée
    if plutil -lint "$UMBRELLA_CONFIG" &>/dev/null; then
        echo "✅ Configuration générée avec succès"
        log_operation "INFO" "Configuration Umbrella générée pour le profil : $user_profile"
        log_security_event "CONFIG_DEPLOYED" "profile=$user_profile,file=$UMBRELLA_CONFIG" "INFO"
        return 0
    else
        echo "❌ Validation de configuration échouée"
        log_operation "ERROR" "Le fichier de configuration généré est invalide"
        return 1
    fi
}

# Installer les certificats Cisco Umbrella
install_umbrella_certificates() {
    local cert_source="${1:-auto}"
    local admin_user=$(whoami)
    
    log_security_event "CERT_INSTALLATION" "source=$cert_source" "INFO"
    
    echo "=== Installation des Certificats Cisco Umbrella ==="
    echo "Source de Certificat : $cert_source"
    echo "Administrateur : $admin_user"
    echo ""
    
    local cert_files=()
    
    case "$cert_source" in
        "auto")
            # Télécharger les certificats depuis Cisco (nécessite authentification)
            echo "Téléchargement des derniers certificats racine Cisco Umbrella..."
            
            # Note : En production, ceux-ci seraient téléchargés depuis le portail Cisco
            # Pour cet exemple, nous vérifierons les certificats pré-téléchargés
            if [[ -f "$CERTS_DIR/cisco_umbrella_root.pem" ]]; then
                cert_files+=("$CERTS_DIR/cisco_umbrella_root.pem")
            else
                echo "⚠️  Fichiers de certificats non trouvés dans $CERTS_DIR"
                echo "Veuillez télécharger les certificats depuis le portail Cisco Umbrella :"
                echo "Deployments > Configuration > Root Certificate"
                return 1
            fi
            ;;
        "local")
            # Utiliser les certificats fournis localement
            cert_files=($(find "$CERTS_DIR" -name "*.pem" -o -name "*.crt" -o -name "*.cer"))
            ;;
        *)
            # Fichier de certificat spécifique
            if [[ -f "$cert_source" ]]; then
                cert_files=("$cert_source")
            else
                echo "Fichier de certificat non trouvé : $cert_source"
                return 1
            fi
            ;;
    esac
    
    if [[ ${#cert_files[@]} -eq 0 ]]; then
        echo "Aucun fichier de certificat trouvé"
        return 1
    fi
    
    # Installer les certificats
    local installed_count=0
    for cert_file in "${cert_files[@]}"; do
        echo "Installation du certificat : $(basename "$cert_file")"
        
        # Vérifier le certificat avant installation
        if openssl x509 -in "$cert_file" -text -noout &>/dev/null; then
            # Installer dans le trousseau système
            if security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "$cert_file"; then
                echo "✅ Certificat installé avec succès"
                installed_count=$((installed_count + 1))
                log_operation "INFO" "Certificat installé : $(basename "$cert_file")"
            else
                echo "❌ Échec d'installation du certificat : $(basename "$cert_file")"
                log_operation "ERROR" "Échec d'installation du certificat : $(basename "$cert_file")"
            fi
        else
            echo "❌ Format de certificat invalide : $(basename "$cert_file")"
            log_operation "ERROR" "Format de certificat invalide : $(basename "$cert_file")"
        fi
    done
    
    echo ""
    echo "Installation de certificat terminée : $installed_count/${#cert_files[@]} réussies"
    
    if [[ $installed_count -gt 0 ]]; then
        log_security_event "CERTS_INSTALLED" "count=$installed_count" "INFO"
        return 0
    else
        log_security_event "CERT_INSTALL_FAILED" "all_failed=true" "ERROR"
        return 1
    fi
}

# Surveiller la santé du service Cisco Umbrella
monitor_umbrella_health() {
    local check_type="${1:-basic}"
    local admin_user=$(whoami)
    
    echo "=== Surveillance Santé Cisco Umbrella ==="
    echo "Type de Vérification : $check_type"
    echo "Surveillant : $admin_user"
    echo ""
    
    local health_status="HEALTHY"
    local issues=()
    
    # Vérifier si le fichier de configuration existe et est valide
    if [[ ! -f "$UMBRELLA_CONFIG" ]]; then
        health_status="CRITICAL"
        issues+=("Fichier de configuration manquant")
    elif ! plutil -lint "$UMBRELLA_CONFIG" &>/dev/null; then
        health_status="CRITICAL"
        issues+=("Fichier de configuration corrompu")
    fi
    
    # Vérifier si le processus Umbrella est en cours d'exécution
    if ! pgrep -f "Umbrella" &>/dev/null; then
        health_status="WARNING"
        issues+=("Client Umbrella non en cours d'exécution")
    fi
    
    # Vérifier la résolution DNS via Umbrella
    echo "Test de résolution DNS via Cisco Umbrella..."
    local test_domains=("cisco.com" "umbrella.com" "google.com")
    local dns_failures=0
    
    for domain in "${test_domains[@]}"; do
        if timeout "$HEALTH_CHECK_TIMEOUT" nslookup "$domain" &>/dev/null; then
            echo "✅ Résolution DNS réussie : $domain"
        else
            echo "❌ Résolution DNS échouée : $domain"
            dns_failures=$((dns_failures + 1))
        fi
    done
    
    if [[ $dns_failures -gt 0 ]]; then
        health_status="WARNING"
        issues+=("Problèmes de résolution DNS ($dns_failures échecs)")
    fi
    
    # Vérifier la validité des certificats
    echo ""
    echo "Vérification des certificats Cisco Umbrella..."
    local expired_certs=0
    
    # Obtenir les certificats liés à Umbrella depuis le trousseau système
    local umbrella_certs=$(security find-certificate -a -c "Cisco" /Library/Keychains/System.keychain 2>/dev/null | grep "alis" | wc -l)
    
    if [[ $umbrella_certs -eq 0 ]]; then
        health_status="WARNING"
        issues+=("Aucun certificat Cisco trouvé")
    else
        echo "✅ Trouvé $umbrella_certs certificats Cisco"
    fi
    
    # Vérifications avancées
    if [[ "$check_type" == "comprehensive" ]]; then
        echo ""
        echo "Exécution des vérifications de santé complètes..."
        
        # Vérifier le fichier log pour les erreurs
        if [[ -f "/Library/Logs/OpenDNSRoamingClient.log" ]]; then
            local recent_errors=$(tail -100 "/Library/Logs/OpenDNSRoamingClient.log" 2>/dev/null | grep -i "error" | wc -l)
            if [[ $recent_errors -gt 5 ]]; then
                health_status="WARNING"
                issues+=("Nombre élevé d'erreurs dans les logs ($recent_errors)")
            fi
        fi
        
        # Vérifier la connectivité réseau vers les serveurs Umbrella
        local umbrella_servers=("208.67.222.222" "208.67.220.220")
        for server in "${umbrella_servers[@]}"; do
            if timeout 5 ping -c 1 "$server" &>/dev/null; then
                echo "✅ Connectivité vers le serveur Umbrella : $server"
            else
                echo "❌ Impossible de joindre le serveur Umbrella : $server"
                health_status="WARNING"
                issues+=("Problèmes de connectivité vers $server")
            fi
        done
    fi
    
    # Générer le rapport de santé
    echo ""
    echo "=== Rapport d'État de Santé ==="
    echo "État Global : $health_status"
    echo "Horodatage : $(date)"
    
    if [[ ${#issues[@]} -gt 0 ]]; then
        echo "Problèmes Trouvés :"
        printf '  - %s\n' "${issues[@]}"
    else
        echo "✅ Tous les systèmes opérationnels"
    fi
    
    # Enregistrer l'état de santé
    log_operation "INFO" "Vérification de santé terminée : $health_status (${#issues[@]} problèmes)"
    log_security_event "HEALTH_CHECK" "status=$health_status,issues=${#issues[@]}" "INFO"
    
    # Retourner le code de sortie approprié
    case "$health_status" in
        "HEALTHY") return 0 ;;
        "WARNING") return 1 ;;
        "CRITICAL") return 2 ;;
        *) return 3 ;;
    esac
}

# Générer un rapport de déploiement Umbrella
generate_umbrella_report() {
    local report_type="${1:-summary}"
    local admin_user=$(whoami)
    local report_file="/var/reports/umbrella_report_$(date +%Y%m%d_%H%M%S).txt"
    
    mkdir -p "$(dirname "$report_file")"
    
    log_security_event "REPORT_GENERATION" "type=$report_type" "INFO"
    
    {
        echo "Rapport de Déploiement Cisco Umbrella Roundfleet"
        echo "=============================================="
        echo "Type de Rapport : $report_type"
        echo "Généré : $(date)"
        echo "Généré Par : $admin_user"
        echo "Nom d'hôte : $(hostname)"
        echo ""
        
        case "$report_type" in
            "summary")
                echo "== Résumé de Déploiement =="
                echo "Organisation : $ORGANIZATION_NAME"
                echo "Mode de Déploiement : $DEPLOYMENT_MODE"
                echo "Fichier de Configuration : $UMBRELLA_CONFIG"
                
                if [[ -f "$UMBRELLA_CONFIG" ]]; then
                    echo "État de Configuration : Déployé"
                    local config_date=$(stat -f %Sm "$UMBRELLA_CONFIG")
                    echo "Dernière Modification : $config_date"
                else
                    echo "État de Configuration : Non Déployé"
                fi
                
                # État du client
                if pgrep -f "Umbrella" &>/dev/null; then
                    echo "État du Client : En cours d'exécution"
                else
                    echo "État du Client : Non en cours d'exécution"
                fi
                ;;
            "security")
                echo "== Évaluation de Sécurité =="
                echo "Fonctionnalités de Sécurité Activées :"
                
                if [[ -f "$UMBRELLA_CONFIG" ]]; then
                    local malware_blocking=$(plutil -extract BlockMalware xml1 -o - "$UMBRELLA_CONFIG" 2>/dev/null | grep -o "<true/>" && echo "Activé" || echo "Désactivé")
                    local phishing_blocking=$(plutil -extract BlockPhishing xml1 -o - "$UMBRELLA_CONFIG" 2>/dev/null | grep -o "<true/>" && echo "Activé" || echo "Désactivé")
                    local content_filtering=$(plutil -extract ContentFiltering xml1 -o - "$UMBRELLA_CONFIG" 2>/dev/null | grep -o "<true/>" && echo "Activé" || echo "Désactivé")
                    
                    echo "  Blocage Malware : $malware_blocking"
                    echo "  Blocage Phishing : $phishing_blocking"
                    echo "  Filtrage Contenu : $content_filtering"
                else
                    echo "  Configuration non disponible pour analyse"
                fi
                
                # État des certificats
                local cisco_certs=$(security find-certificate -a -c "Cisco" /Library/Keychains/System.keychain 2>/dev/null | grep "alis" | wc -l)
                echo "  Certificats Cisco Installés : $cisco_certs"
                ;;
            "audit")
                echo "== Information d'Audit =="
                if [[ -f "$AUDIT_LOG" ]]; then
                    echo "Événements de sécurité récents (10 derniers) :"
                    tail -10 "$AUDIT_LOG"
                else
                    echo "Aucun log d'audit disponible"
                fi
                ;;
        esac
        
        echo ""
        echo "== Détails de Configuration =="
        if [[ -f "$UMBRELLA_CONFIG" ]]; then
            echo "Contenu du fichier de configuration :"
            cat "$UMBRELLA_CONFIG"
        else
            echo "Aucun fichier de configuration trouvé"
        fi
        
    } > "$report_file"
    
    echo "Rapport de déploiement Umbrella généré : $report_file"
    log_operation "INFO" "Rapport Umbrella généré : $report_file"
}

# Définir les paramètres spécifiques à l'organisation
set_organization_params() {
    local api_fingerprint="$1"
    local api_org_id="$2"
    local api_user_id="$3"
    
    if [[ -z "$api_fingerprint" || -z "$api_org_id" || -z "$api_user_id" ]]; then
        echo "Usage : set_organization_params <api_fingerprint> <api_org_id> <api_user_id>"
        echo ""
        echo "Ces paramètres peuvent être obtenus depuis :"
        echo "Portail Cisco Umbrella > Deployments > Core Identities > Roaming Computers"
        return 1
    fi
    
    UMBRELLA_CONFIG_PARAMS["APIFingerprint"]="$api_fingerprint"
    UMBRELLA_CONFIG_PARAMS["APIOrganizationID"]="$api_org_id"
    UMBRELLA_CONFIG_PARAMS["APIUserID"]="$api_user_id"
    
    echo "Paramètres d'organisation mis à jour avec succès"
    log_security_event "ORG_PARAMS_SET" "org_id=$api_org_id" "INFO"
}

# Fonction principale de gestion Cisco Umbrella
main() {
    local action="${1:-help}"
    
    case "$action" in
        "configure")
            local user_profile="${2:-standard}"
            local custom_settings="$3"
            
            generate_umbrella_config "$user_profile" "$custom_settings"
            ;;
        "install-certs")
            local cert_source="${2:-auto}"
            
            install_umbrella_certificates "$cert_source"
            ;;
        "health")
            local check_type="${2:-basic}"
            
            monitor_umbrella_health "$check_type"
            ;;
        "report")
            local report_type="${2:-summary}"
            
            generate_umbrella_report "$report_type"
            ;;
        "set-params")
            local api_fingerprint="$2"
            local api_org_id="$3"
            local api_user_id="$4"
            
            set_organization_params "$api_fingerprint" "$api_org_id" "$api_user_id"
            ;;
        "deploy")
            local user_profile="${2:-standard}"
            
            echo "=== Déploiement Complet Cisco Umbrella ==="
            echo "Démarrage du déploiement complet..."
            echo ""
            
            # Étape 1 : Générer la configuration
            if generate_umbrella_config "$user_profile"; then
                echo "✅ Déploiement de configuration réussi"
            else
                echo "❌ Déploiement de configuration échoué"
                exit 1
            fi
            
            echo ""
            
            # Étape 2 : Installer les certificats
            if install_umbrella_certificates "auto"; then
                echo "✅ Installation de certificats réussie"
            else
                echo "⚠️  Installation de certificats a eu des problèmes"
            fi
            
            echo ""
            
            # Étape 3 : Vérification de santé
            echo "Exécution de la vérification de santé post-déploiement..."
            monitor_umbrella_health "basic"
            
            echo ""
            echo "🎉 Déploiement Cisco Umbrella terminé !"
            echo "Étapes suivantes :"
            echo "1. Installer le fichier PKG Cisco Umbrella via JAMF ou installation manuelle"
            echo "2. Vérifier que le client fonctionne et est connecté"
            echo "3. Tester le filtrage DNS et les fonctionnalités de sécurité"
            ;;
        "help"|*)
            echo "$SCRIPT_NAME v$VERSION"
            echo "Gestion Entreprise du Client Itinérant Cisco Umbrella"
            echo ""
            echo "Usage : $0 <action> [options]"
            echo ""
            echo "Actions :"
            echo "  configure [profil]                         - Générer la configuration Umbrella"
            echo "  install-certs [source]                     - Installer les certificats Cisco"
            echo "  health [type]                              - Surveiller la santé Umbrella"
            echo "  report [type]                              - Générer des rapports de déploiement"
            echo "  set-params <fingerprint> <org_id> <user_id> - Définir les paramètres d'organisation"
            echo "  deploy [profil]                            - Workflow de déploiement complet"
            echo "  help                                       - Afficher ce message d'aide"
            echo ""
            echo "Profils Utilisateur :"
            echo "  executive   - Sécurité élevée, blocage minimal"
            echo "  standard    - Sécurité équilibrée et utilisabilité (défaut)"
            echo "  guest       - Sécurité basique, blocage étendu"
            echo "  developer   - Sécurité moyenne, blocage minimal"
            echo "  kiosk       - Sécurité maximale, blocage étendu"
            echo ""
            echo "Sources de Certificats :"
            echo "  auto        - Télécharger depuis Cisco (défaut)"
            echo "  local       - Utiliser les certificats dans $CERTS_DIR"
            echo "  <fichier>   - Fichier de certificat spécifique"
            echo ""
            echo "Types de Vérification de Santé :"
            echo "  basic       - Vérifications de connectivité et configuration de base"
            echo "  comprehensive - Surveillance étendue et diagnostics"
            echo ""
            echo "Types de Rapport :"
            echo "  summary     - Aperçu du déploiement (défaut)"
            echo "  security    - Analyse de configuration de sécurité"
            echo "  audit       - Piste d'audit et événements"
            echo ""
            echo "Fonctionnalités :"
            echo "  • Déploiement automatisé du client Cisco Umbrella"
            echo "  • Configuration de sécurité basée sur les profils"
            echo "  • Gestion des certificats d'entreprise"
            echo "  • Surveillance de santé en temps réel et diagnostics"
            echo "  • Journalisation d'audit complète et conformité"
            echo "  • Intégration avec l'infrastructure de sécurité Roundfleet"
            echo "  • Protection avancée contre les menaces et filtrage DNS"
            ;;
    esac
}

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

Commandes de Référence Rapide

Configuration Initiale

# Définir les paramètres d'organisation (obtenus depuis le tableau de bord Cisco)
./umbrella_manager.sh set-params "votre_api_fingerprint" "votre_org_id" "votre_user_id"

# Déployer avec profil standard
./umbrella_manager.sh deploy standard

# Déployer avec profil executive
./umbrella_manager.sh deploy executive

Gestion de Configuration

# Générer la configuration pour différents profils utilisateur
./umbrella_manager.sh configure standard
./umbrella_manager.sh configure executive
./umbrella_manager.sh configure guest
./umbrella_manager.sh configure developer
./umbrella_manager.sh configure kiosk

Gestion de Certificats

# Installer les certificats automatiquement
./umbrella_manager.sh install-certs auto

# Installer depuis un répertoire local
./umbrella_manager.sh install-certs local

# Installer un fichier de certificat spécifique
./umbrella_manager.sh install-certs /path/to/cisco_cert.pem

Surveillance de Santé

# Vérification de santé basique
./umbrella_manager.sh health

# Vérification de santé complète
./umbrella_manager.sh health comprehensive

Opérations de Rapport

# Générer un rapport résumé
./umbrella_manager.sh report

# Générer une évaluation de sécurité
./umbrella_manager.sh report security

# Générer un rapport d'audit
./umbrella_manager.sh report audit

Exemples d'Intégration

Intégration JAMF Pro

#!/bin/bash

# Script JAMF Pro pour déploiement Cisco Umbrella
# Paramètres : $4 = profil_utilisateur, $5 = api_fingerprint, $6 = api_org_id, $7 = api_user_id

PROFIL_UTILISATEUR="$4"
API_FINGERPRINT="$5"
API_ORG_ID="$6"
API_USER_ID="$7"

# Télécharger le gestionnaire Umbrella s'il n'est pas présent
if [[ ! -f "/usr/local/bin/roundfleet_umbrella_manager.sh" ]]; then
    curl -o "/usr/local/bin/roundfleet_umbrella_manager.sh" \
         "https://scripts.roundfleet.com/umbrella_manager.sh"
    chmod +x "/usr/local/bin/roundfleet_umbrella_manager.sh"
fi

# Définir les paramètres d'organisation
/usr/local/bin/roundfleet_umbrella_manager.sh set-params \
    "$API_FINGERPRINT" "$API_ORG_ID" "$API_USER_ID"

# Déployer la configuration Umbrella
/usr/local/bin/roundfleet_umbrella_manager.sh deploy "$PROFIL_UTILISATEUR"

# Rapporter le statut à JAMF
if [[ $? -eq 0 ]]; then
    echo "Cisco Umbrella déployé avec succès"
    exit 0
else
    echo "Déploiement Cisco Umbrella échoué"
    exit 1
fi

Fonctionnalités de Sécurité Avancées

Intégration d'Intelligence des Menaces

# Surveillance de sécurité renforcée avec intelligence des menaces
enhanced_threat_monitoring() {
    local threat_feeds=("malware" "phishing" "botnet" "ransomware")
    
    echo "=== Surveillance Avancée des Menaces ==="
    
    for feed in "${threat_feeds[@]}"; do
        local blocked_count=$(grep -c "$feed" /Library/Logs/OpenDNSRoamingClient.log 2>/dev/null || echo 0)
        echo "Menaces $feed bloquées : $blocked_count"
        
        if [[ $blocked_count -gt 100 ]]; then
            log_security_event "HIGH_THREAT_ACTIVITY" "feed=$feed,count=$blocked_count" "WARNING"
        fi
    done
}

Meilleures Pratiques

Sécuriser les identifiants API et utiliser des variables d'environnement pour les données sensibles
Implémenter des configurations basées sur les profils pour différents types d'utilisateurs
Activer la journalisation complète pour la surveillance de sécurité et la conformité
Automatiser la gestion et le renouvellement des certificats
Surveiller la santé du service en continu avec alertes
Intégrer avec les systèmes SIEM pour la surveillance de sécurité centralisée
Mises à jour régulières des politiques basées sur l'intelligence des menaces
Tester le filtrage DNS et les fonctionnalités de sécurité après déploiement

Ce système de gestion Cisco Umbrella entreprise fournit une protection DNS de sécurité complète avec déploiement automatisé, capacités de surveillance et contrôles de niveau entreprise pour une gestion de sécurité Roundfleet efficace.

Guide

Avis important