Surveillance Réseau d'Entreprise sur macOS
Surveillez et contrôlez l'activité réseau sur vos appareils MacFleet 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éseaunetstat- Afficher les connexions réseau et les tables de routagenettop- Utilisation réseau en temps réel par processustcpdump- 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 -20Activité 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 MacFleet
# Surveillance complète de l'activité réseau et gestion de sécurité
# Configuration
MACFLEET_DIR="/etc/macfleet"
MONITORING_DIR="$MACFLEET_DIR/network_monitoring"
REPORTS_DIR="$MACFLEET_DIR/reports"
COMPLIANCE_DIR="$MACFLEET_DIR/compliance"
AUDIT_DIR="$MACFLEET_DIR/audit"
LOG_FILE="/var/log/macfleet_network_monitoring.log"
ALERTS_DIR="$MACFLEET_DIR/alerts"
# Créer la structure de répertoires
create_directories() {
local dirs=("$MACFLEET_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 MacFleet: $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 MacFleet ==="
# 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/macfleet/{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 MacFleet"
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 -20Dé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_developpementContrô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.