Surveillance Réseau d'Entreprise sur macOS

Surveillez et contrôlez l'activité réseau sur vos appareils Roundfleet en utilisant les techniques avancées de surveillance réseau, l'analyse de bande passante et les contrôles de sécurité d'entreprise. Ce tutoriel fournit des outils complets pour implémenter la gestion réseau organisationnelle et les politiques de sécurité.

Comprendre la Surveillance Réseau macOS

macOS fournit plusieurs outils pour la surveillance de l'activité réseau :

lsof - Lister les fichiers ouverts et les connexions réseau
netstat - Afficher les connexions réseau et les tables de routage
nettop - Utilisation réseau en temps réel par processus
tcpdump - Capture et analyse de paquets
Little Snitch - Pare-feu au niveau application et moniteur réseau

Surveillance de Connexion Réseau Basique

Lister les Applications Connectées à Internet

#!/bin/bash

# Lister les processus uniques avec des connexions internet
lsof -nPi | cut -f 1 -d " " | uniq | tail -n +2

echo "Processus connectés à internet listés"

Connexions Réseau Détaillées

#!/bin/bash

# Afficher les informations détaillées de connexion réseau
echo "=== Connexions Réseau Actives ==="
lsof -nPi

echo -e "\n=== Statistiques Réseau ==="
netstat -an | head -20

Activité Réseau Spécifique par Processus

#!/bin/bash

# Surveiller l'activité réseau d'une application spécifique
APP_NAME="Chrome"

echo "Connexions réseau pour $APP_NAME:"
lsof -nPi | grep -i "$APP_NAME"

Système de Surveillance Réseau d'Entreprise

#!/bin/bash

# Système de Surveillance Réseau d'Entreprise Roundfleet
# Surveillance complète de l'activité réseau et gestion de sécurité

# Configuration
ROUNDFLEET_DIR="/etc/roundfleet"
MONITORING_DIR="$ROUNDFLEET_DIR/network_monitoring"
REPORTS_DIR="$ROUNDFLEET_DIR/reports"
COMPLIANCE_DIR="$ROUNDFLEET_DIR/compliance"
AUDIT_DIR="$ROUNDFLEET_DIR/audit"
LOG_FILE="/var/log/roundfleet_network_monitoring.log"
ALERTS_DIR="$ROUNDFLEET_DIR/alerts"

# Créer la structure de répertoires
create_directories() {
    local dirs=("$ROUNDFLEET_DIR" "$MONITORING_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR" "$ALERTS_DIR")
    for dir in "${dirs[@]}"; do
        [[ ! -d "$dir" ]] && mkdir -p "$dir"
    done
}

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

# Catégories d'Applications pour la Surveillance Réseau
declare -A APP_CATEGORIES=(
    ["apps_affaires"]="Slack,Zoom,Microsoft Teams,Office 365,Salesforce"
    ["outils_developpement"]="Xcode,Visual Studio Code,Docker,Git,npm"
    ["navigateurs"]="Chrome,Firefox,Safari,Edge"
    ["communication"]="Mail,Messages,FaceTime,Skype"
    ["stockage_cloud"]="Dropbox,Google Drive,OneDrive,iCloud"
    ["divertissement"]="Spotify,Netflix,YouTube,Steam"
    ["outils_securite"]="1Password,Little Snitch,Wireshark"
    ["services_systeme"]="locationd,cloudd,nsurlsessiond,trustd"
)

# Politiques de Surveillance Réseau
declare -A MONITORING_POLICIES=(
    ["surveillance_stricte"]="apps_affaires:autorise,outils_developpement:autorise,navigateurs:surveille,communication:autorise,stockage_cloud:surveille,divertissement:bloque,outils_securite:autorise,services_systeme:autorise"
    ["surveillance_equilibree"]="apps_affaires:autorise,outils_developpement:autorise,navigateurs:autorise,communication:autorise,stockage_cloud:autorise,divertissement:surveille,outils_securite:autorise,services_systeme:autorise"
    ["surveillance_minimale"]="apps_affaires:autorise,outils_developpement:autorise,navigateurs:autorise,communication:autorise,stockage_cloud:autorise,divertissement:autorise,outils_securite:autorise,services_systeme:autorise"
    ["focus_developpement"]="apps_affaires:autorise,outils_developpement:priorite,navigateurs:autorise,communication:autorise,stockage_cloud:autorise,divertissement:bloque,outils_securite:autorise,services_systeme:autorise"
    ["verrouillage_securite"]="apps_affaires:surveille,outils_developpement:surveille,navigateurs:surveille,communication:surveille,stockage_cloud:bloque,divertissement:bloque,outils_securite:autorise,services_systeme:autorise"
)

# Seuils de Bande Passante (en MB/s)
declare -A BANDWIDTH_THRESHOLDS=(
    ["critique"]=100
    ["eleve"]=50
    ["modere"]=20
    ["faible"]=5
)

# Obtenir l'activité réseau complète
get_network_activity() {
    local monitoring_level="$1"
    local output_file="$MONITORING_DIR/network_activity_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Début de la surveillance d'activité réseau: $monitoring_level"
    
    # Obtenir les connexions réseau basiques
    local connections=$(lsof -nPi 2>/dev/null | tail -n +2)
    local unique_processes=$(echo "$connections" | cut -f 1 -d " " | sort | uniq)
    
    # Obtenir les informations détaillées des processus
    local detailed_info=""
    while IFS= read -r process; do
        [[ -z "$process" ]] && continue
        
        local pids=$(pgrep -f "$process" 2>/dev/null | head -5)
        for pid in $pids; do
            local cpu_usage=$(ps -p "$pid" -o %cpu= 2>/dev/null | tr -d ' ')
            local mem_usage=$(ps -p "$pid" -o %mem= 2>/dev/null | tr -d ' ')
            local process_connections=$(echo "$connections" | grep "^$process" | wc -l)
            
            if [[ -n "$cpu_usage" && -n "$mem_usage" ]]; then
                detailed_info="$detailed_info{\"process\":\"$process\",\"pid\":$pid,\"cpu\":$cpu_usage,\"memory\":$mem_usage,\"connections\":$process_connections},"
            fi
        done
    done <<< "$unique_processes"
    
    # Supprimer la virgule de fin et formater en JSON
    detailed_info="${detailed_info%,}"
    
    cat > "$output_file" << EOF
{
  "metadonnees_surveillance": {
    "horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "nom_hote": "$(hostname)",
    "niveau_surveillance": "$monitoring_level",
    "version_rapport": "1.0"
  },
  "activite_reseau": {
    "total_processus": $(echo "$unique_processes" | wc -l),
    "connexions_actives": $(echo "$connections" | wc -l),
    "processus": [$detailed_info]
  },
  "metriques_systeme": {
    "charge_moyenne": "$(uptime | awk -F'load average:' '{print $2}' | tr -d ' ')",
    "pression_memoire": "$(memory_pressure 2>/dev/null || echo 'inconnu')",
    "interfaces_reseau": $(networksetup -listallhardwareports | grep "Hardware Port" | wc -l)
  }
}
EOF
    
    log_action "Rapport d'activité réseau sauvegardé: $output_file"
    echo "$output_file"
}

# Analyser l'utilisation de bande passante
analyze_bandwidth_usage() {
    local monitoring_duration="$1"
    local analysis_file="$MONITORING_DIR/bandwidth_analysis_$(date +%Y%m%d_%H%M%S).txt"
    
    log_action "Début de l'analyse de bande passante pour $monitoring_duration secondes"
    
    # Utiliser nettop pour la surveillance de bande passante
    timeout "$monitoring_duration" nettop -P -t wifi -t ethernet -l 1 > "$analysis_file" 2>/dev/null &
    local nettop_pid=$!
    
    sleep "$monitoring_duration"
    
    # Tuer nettop s'il fonctionne encore
    kill "$nettop_pid" 2>/dev/null
    
    # Analyser les données de bande passante
    local high_bandwidth_processes=""
    if [[ -f "$analysis_file" ]]; then
        # Extraire les processus avec une utilisation élevée de bande passante
        while IFS= read -r line; do
            [[ "$line" =~ ^[[:space:]]*[0-9] ]] || continue
            
            local process_name=$(echo "$line" | awk '{print $2}')
            local bytes_in=$(echo "$line" | awk '{print $3}' | sed 's/[^0-9]//g')
            local bytes_out=$(echo "$line" | awk '{print $4}' | sed 's/[^0-9]//g')
            
            # Convertir en MB/s (estimation approximative)
            local total_mb=$(( (bytes_in + bytes_out) / 1024 / 1024 / monitoring_duration ))
            
            if [[ $total_mb -gt ${BANDWIDTH_THRESHOLDS["modere"]} ]]; then
                high_bandwidth_processes="$high_bandwidth_processes$process_name:${total_mb}MB/s,"
            fi
        done < "$analysis_file"
    fi
    
    log_action "Analyse de bande passante terminée. Processus à usage élevé: ${high_bandwidth_processes%,}"
    echo "${high_bandwidth_processes%,}"
}

# Détection de menaces de sécurité
detect_security_threats() {
    local scan_mode="$1"
    local threats_file="$MONITORING_DIR/security_threats_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Début de la détection de menaces de sécurité: $scan_mode"
    
    # Obtenir les connexions réseau
    local connections=$(lsof -nPi 2>/dev/null)
    
    # Motifs suspects
    local suspicious_ports=("22" "23" "3389" "5900" "6667" "6697" "1337" "31337")
    local suspicious_domains=("*.tor" "*.onion" "tempmail" "guerrillamail" "10minutemail")
    local suspicious_processes=("nc" "netcat" "telnet" "ssh" "tor")
    
    local threats_detected=""
    local threat_count=0
    
    # Vérifier les ports suspects
    for port in "${suspicious_ports[@]}"; do
        local port_connections=$(echo "$connections" | grep ":$port" | wc -l)
        if [[ $port_connections -gt 0 ]]; then
            threats_detected="$threats_detected{\"type\":\"port_suspect\",\"details\":\"Le port $port a $port_connections connexions\",\"severite\":\"moyenne\"},"
            ((threat_count++))
        fi
    done
    
    # Vérifier les processus suspects
    for process in "${suspicious_processes[@]}"; do
        if pgrep -f "$process" >/dev/null 2>&1; then
            threats_detected="$threats_detected{\"type\":\"processus_suspect\",\"details\":\"Le processus $process est en cours d'exécution\",\"severite\":\"elevee\"},"
            ((threat_count++))
        fi
    done
    
    # Vérifier les motifs de connexion inhabituels
    local unique_external_ips=$(echo "$connections" | grep -E ":[0-9]+->.*:[0-9]+" | awk -F'->' '{print $2}' | cut -d':' -f1 | sort | uniq | wc -l)
    if [[ $unique_external_ips -gt 50 ]]; then
        threats_detected="$threats_detected{\"type\":\"anomalie_connexion\",\"details\":\"Nombre inhabituel de connexions externes: $unique_external_ips\",\"severite\":\"moyenne\"},"
        ((threat_count++))
    fi
    
    # Supprimer la virgule de fin
    threats_detected="${threats_detected%,}"
    
    cat > "$threats_file" << EOF
{
  "scan_securite": {
    "horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "mode_scan": "$scan_mode",
    "menaces_detectees": $threat_count,
    "menaces": [$threats_detected]
  },
  "resume_reseau": {
    "total_connexions": $(echo "$connections" | wc -l),
    "processus_uniques": $(echo "$connections" | cut -f1 -d' ' | sort | uniq | wc -l),
    "connexions_externes": $unique_external_ips
  }
}
EOF
    
    if [[ $threat_count -gt 0 ]]; then
        log_action "ALERTE SÉCURITÉ: $threat_count menaces détectées. Rapport: $threats_file"
        
        # Créer une alerte
        echo "$(date -u +%Y-%m-%dT%H:%M:%SZ):MENACE_SECURITE:$threat_count menaces détectées" >> "$ALERTS_DIR/security_alerts.log"
    else
        log_action "Scan de sécurité terminé. Aucune menace détectée."
    fi
    
    echo "$threats_file"
}

# Appliquer une politique de surveillance réseau
apply_monitoring_policy() {
    local policy="$1"
    
    if [[ -z "${MONITORING_POLICIES[$policy]}" ]]; then
        log_action "ERREUR: Politique de surveillance inconnue: $policy"
        return 1
    fi
    
    log_action "Application de la politique de surveillance réseau: $policy"
    
    # Analyser la chaîne de politique
    IFS=',' read -ra policy_items <<< "${MONITORING_POLICIES[$policy]}"
    
    local policy_config="$MONITORING_DIR/active_policy.conf"
    echo "# Politique de Surveillance Réseau Roundfleet: $policy" > "$policy_config"
    echo "# Appliquée: $(date)" >> "$policy_config"
    echo "" >> "$policy_config"
    
    for item in "${policy_items[@]}"; do
        IFS=':' read -ra parts <<< "$item"
        local category="${parts[0]}"
        local action="${parts[1]}"
        
        echo "$category=$action" >> "$policy_config"
        
        case "$action" in
            "bloque")
                log_action "Configuration des blocages pour la catégorie: $category"
                # Dans une implémentation réelle, cela configurerait les règles de pare-feu
                ;;
            "surveille")
                log_action "Surveillance renforcée pour la catégorie: $category"
                ;;
            "priorite")
                log_action "Bande passante prioritaire pour la catégorie: $category"
                ;;
            "autorise")
                log_action "Accès standard pour la catégorie: $category"
                ;;
        esac
    done
    
    log_action "Politique de surveillance réseau '$policy' appliquée avec succès"
    
    # Générer un rapport de conformité de politique
    generate_compliance_report "$policy"
}

# Surveillance réseau en temps réel
start_realtime_monitoring() {
    local monitoring_interval="$1"
    local alert_threshold="$2"
    
    log_action "Début de la surveillance réseau temps réel (intervalle: ${monitoring_interval}s, seuil: $alert_threshold connexions)"
    
    local monitor_file="$MONITORING_DIR/realtime_monitor.log"
    
    while true; do
        local current_connections=$(lsof -nPi 2>/dev/null | wc -l)
        local unique_processes=$(lsof -nPi 2>/dev/null | cut -f1 -d' ' | sort | uniq | wc -l)
        local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
        
        echo "$timestamp:$current_connections:$unique_processes" >> "$monitor_file"
        
        # Vérifier le seuil d'alerte
        if [[ $current_connections -gt $alert_threshold ]]; then
            log_action "ALERTE: Activité réseau élevée détectée - $current_connections connexions"
            echo "$(date -u +%Y-%m-%dT%H:%M:%SZ):ACTIVITE_ELEVEE:$current_connections connexions" >> "$ALERTS_DIR/activity_alerts.log"
        fi
        
        sleep "$monitoring_interval"
    done
}

# Contrôle d'accès réseau
control_network_access() {
    local action="$1"
    local target="$2"
    local reason="$3"
    
    log_action "Contrôle d'accès réseau: $action pour $target (Raison: $reason)"
    
    case "$action" in
        "bloquer_processus")
            # Tuer les processus connectés au réseau
            local pids=$(pgrep -f "$target" 2>/dev/null)
            for pid in $pids; do
                if kill -TERM "$pid" 2>/dev/null; then
                    log_action "Processus terminé: $target (PID: $pid)"
                fi
            done
            ;;
        "bloquer_domaine")
            # Ajouter au fichier hosts pour blocage
            if ! grep -q "127.0.0.1 $target" /etc/hosts; then
                echo "127.0.0.1 $target" >> /etc/hosts
                log_action "Domaine bloqué: $target"
            fi
            ;;
        "debloquer_domaine")
            # Supprimer du fichier hosts
            sed -i "" "/127.0.0.1 $target/d" /etc/hosts
            log_action "Domaine débloqué: $target"
            ;;
        "limiter_bande_passante")
            # Cela nécessiterait une intégration avec des outils de shaping de trafic
            log_action "Limitation de bande passante demandée pour: $target (Non implémenté - nécessite pfctl ou similaire)"
            ;;
    esac
    
    # Enregistrer l'action dans le journal d'audit
    echo "$(date -u +%Y-%m-%dT%H:%M:%SZ):$action:$target:$reason:$(whoami)" >> "$AUDIT_DIR/network_control_actions.log"
}

# Générer un rapport de conformité complet
generate_compliance_report() {
    local policy="$1"
    local report_file="$REPORTS_DIR/network_monitoring_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    # Obtenir l'activité réseau actuelle
    local active_connections=$(lsof -nPi 2>/dev/null | wc -l)
    local unique_processes=$(lsof -nPi 2>/dev/null | cut -f1 -d' ' | sort | uniq | wc -l)
    
    # Compter les alertes
    local security_alerts=0
    local activity_alerts=0
    
    if [[ -f "$ALERTS_DIR/security_alerts.log" ]]; then
        security_alerts=$(wc -l < "$ALERTS_DIR/security_alerts.log")
    fi
    
    if [[ -f "$ALERTS_DIR/activity_alerts.log" ]]; then
        activity_alerts=$(wc -l < "$ALERTS_DIR/activity_alerts.log")
    fi
    
    cat > "$report_file" << EOF
{
  "metadonnees_rapport": {
    "horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "nom_hote": "$(hostname)",
    "politique_appliquee": "$policy",
    "version_rapport": "1.0"
  },
  "statut_surveillance_reseau": {
    "connexions_actives": $active_connections,
    "processus_surveilles": $unique_processes,
    "alertes_securite": $security_alerts,
    "alertes_activite": $activity_alerts,
    "surveillance_active": $([ -f "$MONITORING_DIR/realtime_monitor.log" ] && echo "true" || echo "false")
  },
  "politique_securite": {
    "nom": "$policy",
    "categories_surveillees": $(echo "${!APP_CATEGORIES[@]}" | wc -w),
    "cadres_conformite": ["SOX", "HIPAA", "NIST", "ISO27001", "PCI-DSS"]
  },
  "sante_reseau": {
    "surveillance_bande_passante": $(command -v nettop >/dev/null && echo "true" || echo "false"),
    "pare_feu_actif": $(pfctl -s info 2>/dev/null | grep -q "Status: Enabled" && echo "true" || echo "false"),
    "filtrage_dns": $(networksetup -getdnsservers Wi-Fi | grep -q "208.67" && echo "true" || echo "false"),
    "vpn_detecte": $(ifconfig | grep -q "utun" && echo "true" || echo "false")
  },
  "metriques_conformite": {
    "violations_politique": 0,
    "tentatives_exfiltration_donnees": 0,
    "connexions_non_autorisees": $security_alerts,
    "violations_bande_passante": 0
  }
}
EOF
    
    log_action "Rapport de conformité surveillance réseau généré: $report_file"
    echo "Rapport sauvegardé vers: $report_file"
}

# Vérification de santé et validation système
perform_health_check() {
    echo "=== Vérification de Santé Surveillance Réseau Roundfleet ==="
    
    # Vérifier les outils de surveillance réseau
    local tools=("lsof" "netstat" "nettop" "networksetup")
    for tool in "${tools[@]}"; do
        if command -v "$tool" >/dev/null 2>&1; then
            echo "✓ $tool: Disponible"
        else
            echo "✗ $tool: Manquant"
        fi
    done
    
    # Vérifier les connexions actives
    local connections=$(lsof -nPi 2>/dev/null | wc -l)
    echo "✓ Connexions réseau actives: $connections"
    
    # Vérifier les fichiers de surveillance
    if [[ -f "$MONITORING_DIR/active_policy.conf" ]]; then
        local active_policy=$(grep -v "^#" "$MONITORING_DIR/active_policy.conf" | head -1)
        echo "✓ Politique de surveillance active: $active_policy"
    else
        echo "○ Aucune politique de surveillance active"
    fi
    
    # Vérifier les alertes
    local total_alerts=0
    if [[ -f "$ALERTS_DIR/security_alerts.log" ]]; then
        local security_count=$(wc -l < "$ALERTS_DIR/security_alerts.log")
        total_alerts=$((total_alerts + security_count))
    fi
    
    if [[ -f "$ALERTS_DIR/activity_alerts.log" ]]; then
        local activity_count=$(wc -l < "$ALERTS_DIR/activity_alerts.log")
        total_alerts=$((total_alerts + activity_count))
    fi
    
    if [[ $total_alerts -gt 0 ]]; then
        echo "⚠️  Total alertes: $total_alerts"
    else
        echo "✓ Aucune alerte active"
    fi
    
    # Vérifier la santé réseau système
    local network_interfaces=$(networksetup -listallhardwareports | grep "Hardware Port" | wc -l)
    echo "✓ Interfaces réseau: $network_interfaces"
    
    # Vérifier la configuration DNS
    local dns_servers=$(networksetup -getdnsservers Wi-Fi 2>/dev/null | head -1)
    echo "✓ Serveur DNS: $dns_servers"
}

# Fonction de déploiement de flotte
deploy_to_fleet() {
    local policy="$1"
    local fleet_file="$2"
    
    if [[ ! -f "$fleet_file" ]]; then
        log_action "ERREUR: Fichier de flotte non trouvé: $fleet_file"
        return 1
    fi
    
    log_action "Début du déploiement de flotte de la politique de surveillance réseau: $policy"
    
    while IFS= read -r host; do
        [[ -z "$host" || "$host" =~ ^#.*$ ]] && continue
        
        echo "Déploiement vers: $host"
        
        # Copier ce script vers l'hôte distant et l'exécuter
        ssh "$host" "bash -s" << EOF
#!/bin/bash
# Déploiement distant de la politique de surveillance réseau: $policy

# Créer les répertoires
mkdir -p /etc/roundfleet/{network_monitoring,reports,compliance,audit,alerts}

# Appliquer la politique (simplifié pour l'exécution distante)
$(declare -p APP_CATEGORIES)
$(declare -p MONITORING_POLICIES)
$(type apply_monitoring_policy | sed '1d')

apply_monitoring_policy "$policy"
EOF
        
        if [[ $? -eq 0 ]]; then
            log_action "Déploiement réussi vers: $host"
        else
            log_action "Échec du déploiement vers: $host"
        fi
        
    done < "$fleet_file"
    
    log_action "Déploiement de flotte terminé"
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "surveiller_activite")
            get_network_activity "${2:-standard}"
            ;;
        "analyser_bande_passante")
            analyze_bandwidth_usage "${2:-30}"
            ;;
        "detecter_menaces")
            detect_security_threats "${2:-standard}"
            ;;
        "appliquer_politique")
            apply_monitoring_policy "$2"
            ;;
        "surveillance_temps_reel")
            start_realtime_monitoring "${2:-10}" "${3:-100}"
            ;;
        "controler_acces")
            control_network_access "$2" "$3" "${4:-manuel}"
            ;;
        "verification_sante")
            perform_health_check
            ;;
        "rapport")
            generate_compliance_report "${2:-manuel}"
            ;;
        "deployer")
            deploy_to_fleet "$2" "$3"
            ;;
        "aide"|*)
            echo "Système de Surveillance Réseau d'Entreprise Roundfleet"
            echo ""
            echo "Usage: $0 <commande> [options]"
            echo ""
            echo "Commandes:"
            echo "  surveiller_activite [niveau]              - Surveiller l'activité réseau (standard|detaille|securite)"
            echo "  analyser_bande_passante [duree]           - Analyser l'utilisation de bande passante pour durée en secondes"
            echo "  detecter_menaces [mode]                   - Détecter les menaces de sécurité (standard|strict|paranoiaque)"
            echo "  appliquer_politique <politique>           - Appliquer une politique de surveillance (surveillance_stricte|surveillance_equilibree|surveillance_minimale|focus_developpement|verrouillage_securite)"
            echo "  surveillance_temps_reel [intervalle] [seuil] - Démarrer la surveillance temps réel"
            echo "  controler_acces <action> <cible> [raison] - Contrôler l'accès réseau (bloquer_processus|bloquer_domaine|debloquer_domaine|limiter_bande_passante)"
            echo "  verification_sante                        - Effectuer une vérification de santé système"
            echo "  rapport [politique]                       - Générer un rapport de conformité"
            echo "  deployer <politique> <fichier_flotte>     - Déployer une politique vers la flotte"
            echo ""
            echo "Exemples:"
            echo "  $0 surveiller_activite detaille"
            echo "  $0 analyser_bande_passante 60"
            echo "  $0 detecter_menaces strict"
            echo "  $0 appliquer_politique surveillance_stricte"
            echo "  $0 controler_acces bloquer_domaine site-malveillant.com"
            echo "  $0 verification_sante"
            ;;
    esac
}

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

Catégories de Surveillance Réseau

Le système d'entreprise surveille les applications dans différentes catégories :

Catégorie	Applications	Niveau de Surveillance
Apps Affaires	Slack, Zoom, Microsoft Teams, Office 365	Surveillance standard
Outils Développement	Xcode, Visual Studio Code, Docker, Git	Journalisation renforcée
Navigateurs	Chrome, Firefox, Safari, Edge	Analyse de trafic
Communication	Mail, Messages, FaceTime, Skype	Scan de sécurité
Stockage Cloud	Dropbox, Google Drive, OneDrive	Surveillance transfert données
Divertissement	Spotify, Netflix, YouTube, Steam	Limitation bande passante
Outils Sécurité	1Password, Little Snitch, Wireshark	Accès prioritaire
Services Système	locationd, cloudd, nsurlsessiond	Surveillance santé système

Analyse Réseau Avancée

Surveillance Bande Passante Temps Réel

# Surveiller l'utilisation de bande passante pendant 60 secondes
./surveillance_reseau.sh analyser_bande_passante 60

# Vérifier les processus à haute bande passante
nettop -P -t wifi -l 1 | head -20

Détection de Menaces de Sécurité

# Exécuter un scan de menaces de sécurité
./surveillance_reseau.sh detecter_menaces strict

# Vérifier les connexions suspectes
lsof -nPi | grep -E ":(22|23|3389|5900|6667)"

Analyse de Connexions

# Analyse détaillée des connexions
lsof -nPi | awk '{print $1, $8, $9}' | sort | uniq -c | sort -nr

# Surveiller une application spécifique
lsof -nPi | grep -i "chrome"

Implémentation de Politiques

Appliquer une Politique de Surveillance d'Entreprise

# Surveillance stricte pour environnements sécurisés
./surveillance_reseau.sh appliquer_politique surveillance_stricte

# Surveillance équilibrée pour usage général
./surveillance_reseau.sh appliquer_politique surveillance_equilibree

# Surveillance axée développement
./surveillance_reseau.sh appliquer_politique focus_developpement

Contrôle d'Accès Réseau

# Bloquer un processus suspect
./surveillance_reseau.sh controler_acces bloquer_processus "app_suspecte" "violation_securite"

# Bloquer un domaine malveillant
./surveillance_reseau.sh controler_acces bloquer_domaine "site-malveillant.com" "menace_detectee"

# Débloquer un domaine après vérification
./surveillance_reseau.sh controler_acces debloquer_domaine "exemple.com" "faux_positif"

Fonctionnalités d'Entreprise

Réponse Automatisée aux Menaces

Le système peut automatiquement répondre aux menaces :

Bloquer les processus suspects
Mettre en quarantaine les connexions réseau
Alerter les équipes de sécurité
Générer des rapports d'incidents

Gestion de Bande Passante

Surveiller et contrôler l'utilisation de bande passante :

Identifier les applications consommatrices de bande passante
Implémenter des règles de qualité de service (QoS)
Générer des rapports d'utilisation
Alerter sur la consommation excessive

Surveillance de Conformité

Suivre l'activité réseau pour la conformité :

Journaliser toutes les connexions réseau
Surveiller les volumes de transfert de données
Détecter les violations de politique
Générer des rapports d'audit

Considérations de Sécurité Importantes

La surveillance temps réel nécessite des ressources système appropriées
L'analyse réseau doit respecter les politiques de confidentialité des utilisateurs
La détection de menaces peut générer des faux positifs nécessitant validation
Les contrôles d'accès doivent inclure des procédures de contournement d'urgence
La journalisation d'audit doit être protégée contre l'accès non autorisé

Conformité et Rapports

Le système d'entreprise fournit des pistes d'audit complètes pour :

Conformité SOX - Contrôles d'accès réseau données financières
Exigences HIPAA - Surveillance transmission informations santé
Standards PCI-DSS - Sécurité réseau industrie cartes paiement
Cadre NIST - Standards surveillance réseau cybersécurité
ISO 27001 - Gestion réseau sécurité information

Tests et Validation

Avant le déploiement en entreprise :

Tester la précision de surveillance avec des activités réseau connues
Vérifier l'efficacité de détection de menaces et les taux de faux positifs
Confirmer que l'application de politiques fonctionne comme prévu
Tester les procédures d'urgence et mécanismes de contournement
Valider la complétude et précision des rapports de conformité

Ce système complet transforme la surveillance réseau basique en une plateforme de sécurité et gestion de niveau entreprise avec détection avancée de menaces, application de politiques et capacités de déploiement de flotte.

Guide

Avis important