Guide

Gérer les paramètres de trackpad dans votre Roundfleet assure une expérience utilisateur cohérente et une productivité optimale. Ce tutoriel couvre les configurations de trackpad courantes avec des scripts shell pour le déploiement entreprise.

Comprendre les Paramètres de Trackpad

Les paramètres de trackpad sont stockés dans le domaine de préférences com.apple.AppleMultitouchTrackpad et nécessitent un contexte utilisateur pour une application correcte.

Fonction de Contexte Utilisateur de Base

Tous les scripts de trackpad nécessitent un contexte utilisateur approprié :

#!/bin/bash

# Obtenir l'utilisateur actuellement connecté
get_current_user() {
    /bin/ls -l /dev/console | /usr/bin/awk '{ print $3 }'
}

# Exécuter une commande dans le contexte utilisateur
execute_as_user() {
    local user="$1"
    local command="$2"
    su -l "$user" -c "$command"
}

Configuration de la Vitesse de Suivi

Définir la Vitesse de Suivi

#!/bin/bash

loggedInUser=$(get_current_user)

# Définir la vitesse de suivi (0.0 à 3.0)
# 0.0 = Lent, 1.5 = Moyen, 3.0 = Rapide
execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad TrackingSpeed -float 1.5"

launchctl bootout user/$(id -u $loggedInUser)

Configuration du Clic

Définir la Pression de Clic

#!/bin/bash

loggedInUser=$(get_current_user)

# Options de clic : 0 = Léger, 1 = Moyen, 2 = Ferme
execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad FirstClickThreshold -int 1"

launchctl bootout user/$(id -u $loggedInUser)

Activer le Clic Silencieux

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad ActuationStrength -int 0"

launchctl bootout user/$(id -u $loggedInUser)

Paramètres Tap pour Cliquer

Activer Tap pour Cliquer

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad Clicking -bool true"

launchctl bootout user/$(id -u $loggedInUser)

Désactiver Tap pour Cliquer

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad Clicking -bool false"

launchctl bootout user/$(id -u $loggedInUser)

Clic Secondaire (Clic Droit)

Activer le Clic Secondaire à Deux Doigts

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad TrackpadRightClick -bool true"

launchctl bootout user/$(id -u $loggedInUser)

Défilement Naturel

Activer le Défilement Naturel

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad TrackpadScroll -bool true"

launchctl bootout user/$(id -u $loggedInUser)

Désactiver le Défilement Naturel

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad TrackpadScroll -bool false"

launchctl bootout user/$(id -u $loggedInUser)

Fonction de Recherche

Désactiver la Recherche (Tap à Trois Doigts)

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad ForceSuppressed -bool true"

launchctl bootout user/$(id -u $loggedInUser)

Activer la Recherche

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad ForceSuppressed -bool false"

launchctl bootout user/$(id -u $loggedInUser)

Configuration du Verrouillage de Glissement

Activer le Verrouillage de Glissement

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad Dragging -bool true"
execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad DragLock -bool true"

launchctl bootout user/$(id -u $loggedInUser)

Désactiver le Verrouillage de Glissement

#!/bin/bash

loggedInUser=$(get_current_user)

execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad Dragging -bool false"
execute_as_user "$loggedInUser" "defaults write com.apple.AppleMultitouchTrackpad DragLock -bool false"

launchctl bootout user/$(id -u $loggedInUser)

Script de Configuration Entreprise

Configuration complète du trackpad pour le déploiement entreprise :

#!/bin/bash

# Script de Configuration Trackpad pour Roundfleet
# Compatible avec macOS 10.14+

# Fonction pour enregistrer les messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a /var/log/trackpad_config.log
}

# Obtenir l'utilisateur actuel
get_current_user() {
    /bin/ls -l /dev/console | /usr/bin/awk '{ print $3 }'
}

# Exécuter une commande dans le contexte utilisateur
execute_as_user() {
    local user="$1"
    local command="$2"
    su -l "$user" -c "$command"
}

# Fonction principale de configuration
configure_trackpad() {
    local current_user
    current_user=$(get_current_user)
    
    log_message "Début de la configuration du trackpad pour l'utilisateur : $current_user"
    
    # Définir la vitesse de suivi à moyen
    if execute_as_user "$current_user" "defaults write com.apple.AppleMultitouchTrackpad TrackingSpeed -float 1.5"; then
        log_message "✓ Vitesse de suivi définie à moyen"
    else
        log_message "✗ Échec de la définition de la vitesse de suivi"
    fi
    
    # Activer tap pour cliquer
    if execute_as_user "$current_user" "defaults write com.apple.AppleMultitouchTrackpad Clicking -bool true"; then
        log_message "✓ Tap pour cliquer activé"
    else
        log_message "✗ Échec de l'activation du tap pour cliquer"
    fi
    
    # Activer le clic secondaire à deux doigts
    if execute_as_user "$current_user" "defaults write com.apple.AppleMultitouchTrackpad TrackpadRightClick -bool true"; then
        log_message "✓ Clic secondaire à deux doigts activé"
    else
        log_message "✗ Échec de l'activation du clic secondaire"
    fi
    
    # Activer le défilement naturel
    if execute_as_user "$current_user" "defaults write com.apple.AppleMultitouchTrackpad TrackpadScroll -bool true"; then
        log_message "✓ Défilement naturel activé"
    else
        log_message "✗ Échec de l'activation du défilement naturel"
    fi
    
    # Définir la pression de clic à moyen
    if execute_as_user "$current_user" "defaults write com.apple.AppleMultitouchTrackpad FirstClickThreshold -int 1"; then
        log_message "✓ Pression de clic définie à moyen"
    else
        log_message "✗ Échec de la définition de la pression de clic"
    fi
    
    # Redémarrer la session utilisateur pour que les changements prennent effet
    if launchctl bootout user/$(id -u $current_user) 2>/dev/null; then
        log_message "✓ Session utilisateur redémarrée"
    else
        log_message "! Tentative de redémarrage de session utilisateur"
    fi
    
    log_message "Configuration du trackpad terminée"
    return 0
}

# Fonction de vérification
verify_configuration() {
    local current_user
    current_user=$(get_current_user)
    
    log_message "Vérification de la configuration du trackpad :"
    
    local tracking_speed
    tracking_speed=$(execute_as_user "$current_user" "defaults read com.apple.AppleMultitouchTrackpad TrackingSpeed 2>/dev/null" || echo "non défini")
    log_message "  Vitesse de Suivi : $tracking_speed"
    
    local tap_click
    tap_click=$(execute_as_user "$current_user" "defaults read com.apple.AppleMultitouchTrackpad Clicking 2>/dev/null" || echo "non défini")
    log_message "  Tap pour Cliquer : $tap_click"
    
    local right_click
    right_click=$(execute_as_user "$current_user" "defaults read com.apple.AppleMultitouchTrackpad TrackpadRightClick 2>/dev/null" || echo "non défini")
    log_message "  Clic Secondaire : $right_click"
}

# Exécuter la fonction principale
if configure_trackpad; then
    verify_configuration
    log_message "Script exécuté avec succès"
    exit 0
else
    log_message "Échec de l'exécution du script"
    exit 1
fi

Script de Vérification

Vérifier les paramètres actuels du trackpad :

#!/bin/bash

current_user=$(get_current_user)

echo "=== État des Paramètres de Trackpad ==="
echo "Vitesse de Suivi : $(su -l "$current_user" -c "defaults read com.apple.AppleMultitouchTrackpad TrackingSpeed 2>/dev/null" || echo 'Non configuré')"
echo "Tap pour Cliquer : $(su -l "$current_user" -c "defaults read com.apple.AppleMultitouchTrackpad Clicking 2>/dev/null" || echo 'Non configuré')"
echo "Clic Secondaire : $(su -l "$current_user" -c "defaults read com.apple.AppleMultitouchTrackpad TrackpadRightClick 2>/dev/null" || echo 'Non configuré')"
echo "Défilement Naturel : $(su -l "$current_user" -c "defaults read com.apple.AppleMultitouchTrackpad TrackpadScroll 2>/dev/null" || echo 'Non configuré')"
echo "Verrouillage de Glissement : $(su -l "$current_user" -c "defaults read com.apple.AppleMultitouchTrackpad DragLock 2>/dev/null" || echo 'Non configuré')"

Dépannage

Valeurs de Référence

Vitesse de Suivi

• 0.0 - Lent
• 1.5 - Moyen (recommandé)
• 3.0 - Rapide

Pression de Clic

• 0 - Clic léger
• 1 - Clic moyen (recommandé)
• 2 - Clic ferme

Notes Importantes

• Tous les paramètres de trackpad nécessitent un redémarrage de session utilisateur pour prendre effet
• Utiliser launchctl bootout user/$(id -u $user) pour redémarrer la session utilisateur
• Tester les paramètres sur un petit groupe avant le déploiement à l'échelle de l'entreprise
• Les utilisateurs peuvent manuellement remplacer ces paramètres dans Préférences Système

Analysez et gérez les signatures de code des applications sur vos appareils Roundfleet pour améliorer la sécurité, vérifier l'authenticité des applications et implémenter les politiques de signature d'entreprise. Ce tutoriel couvre l'extraction des exigences de code, la vérification des signatures et l'analyse de sécurité complète.

Comprendre les Signatures de Code macOS

Les signatures de code sur macOS fournissent une vérification cryptographique que les applications n'ont pas été altérées et proviennent de sources fiables. Les composants clés incluent :

• Exigences de Code - Contraintes que le code doit satisfaire pour être considéré comme valide
• Identifiants de Bundle - Identifiants uniques pour les applications
• Certificats de Développeur - Certificats numériques utilisés pour signer les applications
• Droits - Permissions et capacités accordées aux applications

Importance de la Sécurité d'Entreprise

L'analyse des signatures de code est cruciale pour la sécurité d'entreprise :

• Authenticité des Applications - Vérifier que les applications proviennent de développeurs de confiance
• Détection d'Altération - Identifier les applications modifiées ou compromises
• Application de Politique de Confidentialité - Contrôler l'accès aux données utilisateur protégées
• Exigences de Conformité - Respecter les normes de sécurité pour les industries réglementées
• Prévention des Malwares - Bloquer les applications non autorisées ou suspectes

Analyse de Base des Signatures de Code

Extraire les Exigences de Code

#!/bin/bash

# Extraction basique des exigences de code
APP_PATH="/System/Applications/Time Machine.app"

echo "Extraction des exigences de code pour : $APP_PATH"
codesign -dr - "$APP_PATH"

Extraction des Exigences de Code avec Gestion d'Erreurs

#!/bin/bash

# Extraction améliorée des exigences de code avec validation
extract_code_requirement() {
    local app_path="$1"
    
    # Valider l'entrée
    if [[ -z "$app_path" ]]; then
        echo "Erreur : Aucun chemin d'application fourni"
        echo "Usage : extract_code_requirement <chemin_app>"
        return 1
    fi
    
    # Vérifier si l'application existe
    if [[ ! -e "$app_path" ]]; then
        echo "Erreur : Application non trouvée au chemin : $app_path"
        return 1
    fi
    
    echo "=== Analyse des Exigences de Code ==="
    echo "Application : $app_path"
    echo ""
    
    # Extraire les exigences de code
    local code_req
    code_req=$(codesign -dr - "$app_path" 2>&1)
    
    if [[ $? -eq 0 ]]; then
        echo "Exigences de Code :"
        echo "$code_req"
        
        # Extraire seulement l'exigence désignée
        local designated_req
        designated_req=$(echo "$code_req" | grep "designated =>" | sed 's/designated => //')
        
        if [[ -n "$designated_req" ]]; then
            echo ""
            echo "Exigence Désignée :"
            echo "$designated_req"
        fi
    else
        echo "Erreur lors de l'extraction des exigences de code :"
        echo "$code_req"
        return 1
    fi
}

# Exemples d'utilisation
extract_code_requirement "/System/Applications/Safari.app"
extract_code_requirement "/Applications/Microsoft Word.app"

Analyse Complète de l'Application

#!/bin/bash

# Analyse complète de la signature d'application
analyze_application_signature() {
    local app_path="$1"
    local detailed="${2:-false}"
    
    if [[ ! -e "$app_path" ]]; then
        echo "Erreur : Application non trouvée : $app_path"
        return 1
    fi
    
    echo "=== Analyse Complète de la Signature d'Application ==="
    echo "Application : $app_path"
    echo "Date d'Analyse : $(date)"
    echo ""
    
    # Informations de base
    echo "--- Informations de Base ---"
    if [[ -d "$app_path" ]]; then
        local bundle_id
        bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        echo "ID Bundle : $bundle_id"
        
        local app_version
        app_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        echo "Version : $app_version"
    fi
    
    # Vérification de la signature de code
    echo ""
    echo "--- Vérification de la Signature de Code ---"
    if codesign -v "$app_path" 2>/dev/null; then
        echo "✓ La signature de code est valide"
    else
        echo "⚠️ La vérification de la signature de code a échoué"
    fi
    
    # Informations détaillées de signature
    echo ""
    echo "--- Détails de la Signature ---"
    codesign -dv "$app_path" 2>&1
    
    # Exigences de code
    echo ""
    echo "--- Exigences de Code ---"
    codesign -dr - "$app_path" 2>&1
    
    # Droits (si analyse détaillée demandée)
    if [[ "$detailed" == "true" ]]; then
        echo ""
        echo "--- Droits ---"
        codesign -d --entitlements - "$app_path" 2>/dev/null || echo "Aucun droit trouvé"
    fi
    
    echo ""
    echo "=== Analyse Terminée ==="
}

# Usage
analyze_application_signature "/Applications/Safari.app" "true"

Gestion des Signatures de Code d'Entreprise

Analyse d'Applications par Lots

#!/bin/bash

# Analyser plusieurs applications pour la revue de sécurité d'entreprise
batch_analyze_applications() {
    local scan_path="${1:-/Applications}"
    local output_format="${2:-table}"
    local include_system="${3:-false}"
    
    echo "=== Analyse par Lots des Signatures d'Applications ==="
    echo "Chemin de Scan : $scan_path"
    echo "Inclure Apps Système : $include_system"
    echo "Format de Sortie : $output_format"
    echo ""
    
    local app_count=0
    local valid_count=0
    local invalid_count=0
    local results=()
    
    # Trouver toutes les applications
    local find_paths=("$scan_path")
    if [[ "$include_system" == "true" ]]; then
        find_paths+=("/System/Applications" "/System/Library/CoreServices")
    fi
    
    for search_path in "${find_paths[@]}"; do
        if [[ -d "$search_path" ]]; then
            while IFS= read -r -d '' app_path; do
                ((app_count++))
                
                local app_name=$(basename "$app_path" .app)
                local bundle_id="Inconnu"
                local signature_status="Invalide"
                local developer="Inconnu"
                local code_req="Inconnu"
                
                # Extraire l'ID bundle
                if [[ -f "$app_path/Contents/Info.plist" ]]; then
                    bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
                fi
                
                # Vérifier la validité de la signature
                if codesign -v "$app_path" 2>/dev/null; then
                    signature_status="Valide"
                    ((valid_count++))
                    
                    # Extraire les informations du développeur
                    local sig_info
                    sig_info=$(codesign -dv "$app_path" 2>&1)
                    developer=$(echo "$sig_info" | grep "Authority=" | head -1 | sed 's/Authority=//' | tr -d '\n')
                    
                    # Extraire l'exigence de code
                    code_req=$(codesign -dr - "$app_path" 2>/dev/null | grep "designated =>" | sed 's/designated => //')
                else
                    ((invalid_count++))
                fi
                
                # Stocker les résultats
                results+=("$app_name|$bundle_id|$signature_status|$developer|$code_req")
                
                # Indicateur de progression
                if (( app_count % 10 == 0 )); then
                    echo "Analysé $app_count applications..."
                fi
                
            done < <(find "$search_path" -name "*.app" -type d -print0 2>/dev/null)
        fi
    done
    
    echo ""
    echo "=== Résumé de l'Analyse ==="
    echo "Total des Applications : $app_count"
    echo "Signatures Valides : $valid_count"
    echo "Signatures Invalides : $invalid_count"
    echo ""
    
    # Sortir les résultats dans le format demandé
    case "$output_format" in
        "table")
            printf "%-30s %-40s %-10s %-50s\n" "Application" "ID Bundle" "Signature" "Développeur"
            printf "%-30s %-40s %-10s %-50s\n" "----------" "---------" "---------" "-----------"
            
            for result in "${results[@]}"; do
                IFS='|' read -r app_name bundle_id sig_status developer code_req <<< "$result"
                printf "%-30s %-40s %-10s %-50s\n" \
                    "${app_name:0:29}" \
                    "${bundle_id:0:39}" \
                    "$sig_status" \
                    "${developer:0:49}"
            done
            ;;
        "csv")
            echo "Application,ID Bundle,Statut Signature,Développeur,Exigence Code"
            for result in "${results[@]}"; do
                echo "$result" | tr '|' ','
            done
            ;;
        "json")
            echo "{"
            echo "  \"analysis_summary\": {"
            echo "    \"total_applications\": $app_count,"
            echo "    \"valid_signatures\": $valid_count,"
            echo "    \"invalid_signatures\": $invalid_count,"
            echo "    \"scan_date\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\""
            echo "  },"
            echo "  \"applications\": ["
            
            local first=true
            for result in "${results[@]}"; do
                IFS='|' read -r app_name bundle_id sig_status developer code_req <<< "$result"
                
                if [[ "$first" == "true" ]]; then
                    first=false
                else
                    echo ","
                fi
                
                echo -n "    {"
                echo -n "\"name\": \"$app_name\", "
                echo -n "\"bundle_id\": \"$bundle_id\", "
                echo -n "\"signature_valid\": $([ "$sig_status" == "Valide" ] && echo "true" || echo "false"), "
                echo -n "\"developer\": \"$developer\", "
                echo -n "\"code_requirement\": \"$code_req\""
                echo -n "}"
            done
            
            echo ""
            echo "  ]"
            echo "}"
            ;;
    esac
}

# Exemples d'utilisation
batch_analyze_applications "/Applications" "table" "false"
batch_analyze_applications "/Applications" "json" "true" > /tmp/app_analysis.json

Système de Gestion des Signatures de Code d'Entreprise

#!/bin/bash

# Outil de Gestion des Signatures de Code Roundfleet
# Analyse complète des signatures de code et application des politiques de sécurité

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_codesigning.log"
REPORT_DIR="/etc/roundfleet/reports/codesigning"
CONFIG_DIR="/etc/roundfleet/codesigning"
POLICY_DIR="/etc/roundfleet/policies/codesigning"
QUARANTINE_DIR="/var/quarantine/applications"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR" "$QUARANTINE_DIR"

# Modèles de politiques de signature de code
declare -A SIGNING_POLICIES=(
    ["enterprise_standard"]="signed_required,developer_id_preferred,apple_signed_trusted,third_party_review"
    ["enterprise_strict"]="apple_signed_only,developer_id_required,no_unsigned,enterprise_review"
    ["development"]="signed_preferred,developer_id_optional,self_signed_allowed,minimal_restrictions"
    ["kiosk_lockdown"]="apple_signed_only,no_third_party,system_apps_only,maximum_security"
    ["healthcare"]="apple_signed_required,enterprise_approved_only,no_unsigned,hipaa_compliant"
    ["financial"]="apple_signed_required,enterprise_certified_only,strict_validation,sox_compliant"
    ["education"]="signed_required,educational_approved,apple_preferred,moderate_security"
    ["government"]="apple_signed_only,government_approved,no_unsigned,maximum_security"
    ["retail"]="signed_required,pos_approved,apple_preferred,moderate_security"
    ["manufacturing"]="signed_required,industrial_approved,apple_preferred,operational_security"
)

# Registre des développeurs de confiance
declare -A TRUSTED_DEVELOPERS=(
    ["apple"]="Apple Inc.,Software Signing,Apple Mac OS Application Signing"
    ["microsoft"]="Microsoft Corporation,Microsoft Corporation"
    ["adobe"]="Adobe Inc.,Adobe Systems Incorporated"
    ["google"]="Google LLC,Google Inc."
    ["zoom"]="Zoom Video Communications, Inc."
    ["slack"]="Slack Technologies, Inc."
    ["dropbox"]="Dropbox, Inc."
    ["1password"]="AgileBits Inc."
    ["firefox"]="Mozilla Corporation"
    ["chrome"]="Google LLC"
)

# Niveaux de classification de sécurité
declare -A SECURITY_LEVELS=(
    ["maximum"]="apple_signed_only,no_exceptions,immediate_quarantine"
    ["high"]="signed_required,trusted_developers_only,review_required"
    ["medium"]="signed_preferred,warnings_enabled,monitoring_active"
    ["low"]="unsigned_allowed,notification_only,basic_monitoring"
)

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

# Analyse avancée des signatures de code
analyze_code_signature() {
    local app_path="$1"
    local output_format="${2:-detailed}"
    local security_check="${3:-true}"
    
    log_action "Analyse de la signature de code pour : $app_path"
    
    if [[ ! -e "$app_path" ]]; then
        log_action "ERREUR : Application non trouvée : $app_path"
        return 1
    fi
    
    local analysis_data=()
    local app_name=$(basename "$app_path" .app)
    
    echo "=== Analyse Avancée des Signatures de Code ==="
    echo "Application : $app_name"
    echo "Chemin : $app_path"
    echo "Date d'Analyse : $(date)"
    echo ""
    
    # Informations de base de l'application
    extract_app_metadata "$app_path" analysis_data
    
    # Vérification de la signature de code
    verify_code_signature "$app_path" analysis_data
    
    # Extraire les exigences de code
    extract_code_requirements "$app_path" analysis_data
    
    # Analyse de sécurité
    if [[ "$security_check" == "true" ]]; then
        perform_security_analysis "$app_path" analysis_data
    fi
    
    # Générer la sortie dans le format demandé
    case "$output_format" in
        "detailed")
            display_detailed_analysis analysis_data
            ;;
        "summary")
            display_summary_analysis analysis_data
            ;;
        "json")
            generate_json_analysis "$app_path" analysis_data
            ;;
        "csv")
            generate_csv_analysis "$app_path" analysis_data
            ;;
    esac
    
    log_action "Analyse de signature de code terminée pour : $app_path"
}

# Extraire les métadonnées de l'application
extract_app_metadata() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo "--- Métadonnées de l'Application ---"
    
    if [[ -f "$app_path/Contents/Info.plist" ]]; then
        local bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        local version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        local build=$(defaults read "$app_path/Contents/Info.plist" CFBundleVersion 2>/dev/null || echo "Inconnue")
        local min_os=$(defaults read "$app_path/Contents/Info.plist" LSMinimumSystemVersion 2>/dev/null || echo "Inconnu")
        
        echo "ID Bundle : $bundle_id"
        echo "Version : $version"
        echo "Build : $build"
        echo "OS Minimum : $min_os"
        
        data_ref+=("bundle_id:$bundle_id")
        data_ref+=("version:$version")
        data_ref+=("build:$build")
        data_ref+=("min_os:$min_os")
    else
        echo "Aucun Info.plist trouvé"
        data_ref+=("bundle_id:Inconnu")
    fi
    
    # Taille du fichier et date de modification
    local file_size=$(du -sh "$app_path" | cut -f1)
    local mod_date=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path")
    
    echo "Taille de l'Application : $file_size"
    echo "Dernière Modification : $mod_date"
    
    data_ref+=("size:$file_size")
    data_ref+=("modified:$mod_date")
}

# Vérifier la signature de code
verify_code_signature() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Vérification de la Signature de Code ---"
    
    # Vérification de base
    if codesign -v "$app_path" 2>/dev/null; then
        echo "✓ La signature de code est valide"
        data_ref+=("signature_valid:true")
        
        # Informations détaillées de signature
        local sig_info=$(codesign -dv "$app_path" 2>&1)
        
        # Extraire les informations clés
        local identifier=$(echo "$sig_info" | grep "Identifier=" | sed 's/Identifier=//')
        local format=$(echo "$sig_info" | grep "Format=" | sed 's/Format=//')
        local cdhash=$(echo "$sig_info" | grep "CDHash=" | sed 's/CDHash=//')
        local team_id=$(echo "$sig_info" | grep "TeamIdentifier=" | sed 's/TeamIdentifier=//')
        
        echo "Identifiant : $identifier"
        echo "Format : $format"
        echo "CDHash : $cdhash"
        echo "ID Équipe : $team_id"
        
        data_ref+=("identifier:$identifier")
        data_ref+=("format:$format")
        data_ref+=("cdhash:$cdhash")
        data_ref+=("team_id:$team_id")
        
        # Extraire la chaîne de certificats
        local authorities=$(echo "$sig_info" | grep "Authority=" | sed 's/Authority=//')
        echo "Chaîne de Certificats :"
        while IFS= read -r authority; do
            echo "  - $authority"
        done <<< "$authorities"
        
        data_ref+=("authorities:$authorities")
        
    else
        echo "⚠️ La vérification de la signature de code a ÉCHOUÉ"
        data_ref+=("signature_valid:false")
        
        local error=$(codesign -v "$app_path" 2>&1)
        echo "Erreur : $error"
        data_ref+=("signature_error:$error")
    fi
}

# Extraire les exigences de code
extract_code_requirements() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Exigences de Code ---"
    
    local req_output=$(codesign -dr - "$app_path" 2>&1)
    
    if [[ $? -eq 0 ]]; then
        echo "$req_output"
        
        # Extraire l'exigence désignée
        local designated_req=$(echo "$req_output" | grep "designated =>" | sed 's/designated => //')
        if [[ -n "$designated_req" ]]; then
            echo ""
            echo "Exigence Désignée :"
            echo "$designated_req"
            data_ref+=("designated_requirement:$designated_req")
        fi
        
        data_ref+=("requirements_extracted:true")
    else
        echo "Échec de l'extraction des exigences de code"
        echo "$req_output"
        data_ref+=("requirements_extracted:false")
    fi
}

# Effectuer une analyse de sécurité
perform_security_analysis() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Analyse de Sécurité ---"
    
    local security_score=100
    local security_issues=()
    
    # Vérifier si l'application est signée
    if ! codesign -v "$app_path" 2>/dev/null; then
        security_score=$((security_score - 50))
        security_issues+=("L'application n'est pas signée")
    fi
    
    # Vérifier le runtime durci
    local flags=$(codesign -dv "$app_path" 2>&1 | grep "CodeDirectory" | grep "runtime")
    if [[ -n "$flags" ]]; then
        echo "✓ Runtime durci activé"
        data_ref+=("hardened_runtime:true")
    else
        echo "⚠️ Runtime durci non activé"
        security_score=$((security_score - 20))
        security_issues+=("Runtime durci non activé")
        data_ref+=("hardened_runtime:false")
    fi
    
    # Vérifier la notarisation
    if spctl -a -v "$app_path" 2>&1 | grep -q "notarized"; then
        echo "✓ L'application est notarisée"
        data_ref+=("notarized:true")
    else
        echo "⚠️ L'application n'est pas notarisée"
        security_score=$((security_score - 15))
        security_issues+=("Application non notarisée")
        data_ref+=("notarized:false")
    fi
    
    # Vérifier les vulnérabilités connues (vérification de base)
    check_known_vulnerabilities "$app_path" security_score security_issues
    
    echo ""
    echo "Score de Sécurité : $security_score/100"
    data_ref+=("security_score:$security_score")
    
    if [[ ${#security_issues[@]} -gt 0 ]]; then
        echo "Problèmes de Sécurité Trouvés :"
        for issue in "${security_issues[@]}"; do
            echo "  ⚠️ $issue"
        done
        data_ref+=("security_issues:${security_issues[*]}")
    else
        echo "✓ Aucun problème de sécurité trouvé"
        data_ref+=("security_issues:none")
    fi
}

# Vérifier les vulnérabilités connues
check_known_vulnerabilities() {
    local app_path="$1"
    local -n score_ref=$2
    local -n issues_ref=$3
    
    local bundle_id
    bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
    
    # Vérifier contre les applications vulnérables connues (exemple simplifié)
    case "$bundle_id" in
        "com.adobe.flashplayer"*)
            score_ref=$((score_ref - 30))
            issues_ref+=("Flash Player a des vulnérabilités de sécurité connues")
            ;;
        "com.java."*)
            # Vérifier la version Java pour les vulnérabilités connues
            local java_version
            java_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
            if [[ -n "$java_version" ]]; then
                echo "Version Java détectée : $java_version"
                # Ajouter des vérifications de version spécifiques ici
            fi
            ;;
    esac
    
    # Vérifier les applications avec des certificats expirés
    local cert_info=$(codesign -dv "$app_path" 2>&1 | grep "Timestamp=")
    if [[ -n "$cert_info" ]]; then
        # Extraire l'horodatage et vérifier si le certificat est ancien
        local timestamp=$(echo "$cert_info" | sed 's/Timestamp=//')
        echo "Horodatage du certificat : $timestamp"
    fi
}

# Générer une analyse complète de la flotte
analyze_fleet_applications() {
    local scan_paths=("$@")
    local report_file="$REPORT_DIR/fleet_analysis_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Analyse des Applications à l'Échelle de la Flotte ==="
    echo "Chemins de scan : ${scan_paths[*]}"
    echo ""
    
    local total_apps=0
    local signed_apps=0
    local unsigned_apps=0
    local notarized_apps=0
    local security_issues=0
    local applications=()
    
    for scan_path in "${scan_paths[@]}"; do
        if [[ -d "$scan_path" ]]; then
            echo "Scan : $scan_path"
            
            while IFS= read -r -d '' app_path; do
                ((total_apps++))
                
                local app_name=$(basename "$app_path" .app)
                local analysis_data=()
                
                # Analyse rapide pour aperçu de la flotte
                analyze_code_signature "$app_path" "summary" "true" > /dev/null
                
                # Extraire les métriques clés
                if codesign -v "$app_path" 2>/dev/null; then
                    ((signed_apps++))
                else
                    ((unsigned_apps++))
                fi
                
                if spctl -a -v "$app_path" 2>&1 | grep -q "notarized"; then
                    ((notarized_apps++))
                fi
                
                # Ajouter au tableau des applications
                applications+=("$app_path")
                
                # Indicateur de progression
                if (( total_apps % 25 == 0 )); then
                    echo "Analysé $total_apps applications..."
                fi
                
            done < <(find "$scan_path" -name "*.app" -type d -maxdepth 2 -print0 2>/dev/null)
        fi
    done
    
    # Générer le rapport d'analyse de flotte
    cat > "$report_file" << EOF
{
    "fleet_analysis": {
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "scan_paths": [$(printf '"%s",' "${scan_paths[@]}" | sed 's/,$//')],
        "summary": {
            "total_applications": $total_apps,
            "signed_applications": $signed_apps,
            "unsigned_applications": $unsigned_apps,
            "notarized_applications": $notarized_apps,
            "signing_compliance": $(( signed_apps * 100 / total_apps )),
            "notarization_compliance": $(( notarized_apps * 100 / total_apps ))
        },
        "analysis_date": "$(date)",
        "script_version": "$SCRIPT_VERSION"
    }
}
EOF
    
    echo ""
    echo "=== Résumé de l'Analyse de Flotte ==="
    echo "Total des Applications : $total_apps"
    echo "Applications Signées : $signed_apps ($(( signed_apps * 100 / total_apps ))%)"
    echo "Applications Non Signées : $unsigned_apps ($(( unsigned_apps * 100 / total_apps ))%)"
    echo "Applications Notarisées : $notarized_apps ($(( notarized_apps * 100 / total_apps ))%)"
    echo ""
    echo "Rapport d'analyse de flotte : $report_file"
    
    log_action "Analyse de flotte terminée : $total_apps applications analysées"
}

# Fonction d'exécution principale
main() {
    local action="${1:-help}"
    local param1="${2:-}"
    local param2="${3:-}"
    local param3="${4:-}"
    local param4="${5:-}"
    
    log_action "=== Gestion des Signatures de Code Roundfleet Démarrée ==="
    log_action "Action : $action"
    
    case "$action" in
        "analyze")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 analyze <chemin_app> [format_sortie] [vérification_sécurité]"
                echo "Formats de sortie : detailed, summary, json, csv"
                exit 1
            fi
            analyze_code_signature "$param1" "${param2:-detailed}" "${param3:-true}"
            ;;
        "extract")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 extract <chemin_app>"
                exit 1
            fi
            extract_code_requirement "$param1"
            ;;
        "batch")
            if [[ -z "$param1" ]]; then
                param1="/Applications"
            fi
            batch_analyze_applications "$param1" "${param2:-table}" "${param3:-false}"
            ;;
        "fleet")
            local paths=("${@:2}")
            if [[ ${#paths[@]} -eq 0 ]]; then
                paths=("/Applications" "/System/Applications")
            fi
            analyze_fleet_applications "${paths[@]}"
            ;;
        "verify")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 verify <chemin_app>"
                exit 1
            fi
            if codesign -v "$param1" 2>/dev/null; then
                echo "✓ La signature de code est valide pour : $param1"
            else
                echo "⚠️ La vérification de la signature de code a échoué pour : $param1"
                codesign -v "$param1"
            fi
            ;;
        "help")
            echo "Usage : $0 [action] [options...]"
            echo "Actions :"
            echo "  analyze <chemin_app> [format] [sécurité] - Analyser la signature de l'application"
            echo "  extract <chemin_app> - Extraire seulement l'exigence de code"
            echo "  batch <chemin_scan> [format] [inclure_système] - Analyser les applications par lots"
            echo "  fleet [chemins...] - Analyser les applications à l'échelle de la flotte"
            echo "  verify <chemin_app> - Vérification rapide de signature"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Formats de Sortie : detailed, summary, json, csv, table"
            echo "Politiques : ${!SIGNING_POLICIES[*]}"
            echo "Niveaux de Sécurité : ${!SECURITY_LEVELS[*]}"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des signatures de code terminée ==="
}

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

Meilleures Pratiques de Sécurité

Gestion des Certificats d'Entreprise

#!/bin/bash

# Validation des certificats d'entreprise
validate_enterprise_certificates() {
    local cert_policy="${1:-strict}"
    
    echo "=== Validation des Certificats d'Entreprise ==="
    echo "Politique : $cert_policy"
    echo ""
    
    local expired_certs=()
    local revoked_certs=()
    local untrusted_certs=()
    
    # Vérifier le trousseau système pour les certificats d'entreprise
    security find-certificate -a -p /Library/Keychains/System.keychain | \
    while IFS= read -r cert_line; do
        if [[ "$cert_line" == "-----BEGIN CERTIFICATE-----" ]]; then
            # Traiter le certificat
            echo "Vérification du certificat d'entreprise..."
        fi
    done
    
    echo "✓ Validation des certificats d'entreprise terminée"
}

validate_enterprise_certificates "strict"

Rapport de Conformité

#!/bin/bash

# Générer un rapport de conformité pour les exigences réglementaires
generate_compliance_report() {
    local compliance_type="${1:-general}"
    local output_file="$REPORT_DIR/compliance_${compliance_type}_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Génération du Rapport de Conformité : $compliance_type ==="
    
    local total_apps=0
    local compliant_apps=0
    local non_compliant_apps=0
    
    # Scanner les applications pour la conformité
    while IFS= read -r -d '' app_path; do
        ((total_apps++))
        
        case "$compliance_type" in
            "hipaa")
                check_hipaa_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            "sox")
                check_sox_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            "pci_dss")
                check_pci_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            *)
                check_general_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
        esac
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    # Générer le rapport
    local compliance_percentage=$(( compliant_apps * 100 / total_apps ))
    
    cat > "$output_file" << EOF
{
    "compliance_report": {
        "type": "$compliance_type",
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "summary": {
            "total_applications": $total_apps,
            "compliant_applications": $compliant_apps,
            "non_compliant_applications": $non_compliant_apps,
            "compliance_percentage": $compliance_percentage
        }
    }
}
EOF
    
    echo "Rapport de conformité généré : $output_file"
    echo "Taux de conformité : $compliance_percentage%"
}

generate_compliance_report "general"

Notes Importantes

• Les signatures de code vérifient l'authenticité et l'intégrité des applications
• Les exigences de code spécifient les contraintes pour la validation des applications
• Les politiques d'entreprise doivent équilibrer sécurité et besoins opérationnels
• La surveillance régulière aide à détecter les applications non autorisées
• Les exigences de conformité varient selon l'industrie et le cadre réglementaire
• La notarisation fournit une validation de sécurité supplémentaire d'Apple
• La gestion des certificats est cruciale pour la sécurité d'entreprise
• L'analyse à l'échelle de la flotte permet une gestion proactive de la sécurité

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

1. Push de Configuration - Déployer OrgInfo.plist avec paramètres d'organisation
2. Installation PKG - Installer l'application client itinérant Umbrella
3. Distribution de Certificats - Déployer les certificats racine pour les fonctionnalités avancées
4. 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