Guide

Nouvelles mises à jour et améliorations de Roundfleet.
Suivez-nous sur X.com

Avis important

Les exemples de code et scripts fournis dans ces tutoriels sont uniquement à des fins éducatives. Roundfleet n'est pas responsable des problèmes, dommages ou vulnérabilités de sécurité qui pourraient survenir lors de l'utilisation, modification ou implémentation de ces exemples. Toujours vérifier et tester le code dans un environnement sécurisé avant de l'utiliser dans des systèmes de production.

← Tous les articles

Gestion d'Entreprise du Pare-feu pour macOS

Implémentez une gestion de pare-feu de niveau entreprise sur votre déploiement Roundfleet avec des politiques de sécurité automatisées, une protection réseau avancée, une détection de menaces et une surveillance de conformité complète. Ce tutoriel fournit des solutions pour maintenir une sécurité réseau robuste tout en assurant la conformité réglementaire et l'efficacité opérationnelle.

Comprendre la Gestion du Pare-feu macOS

macOS fournit plusieurs outils et mécanismes de gestion de pare-feu :

  • Pare-feu d'Application - Pare-feu intégré qui bloque les connexions entrantes
  • socketfilterfw - Outil en ligne de commande pour la configuration du pare-feu
  • pfctl - Utilitaire de contrôle de filtre de paquets (filtrage avancé)
  • Préférences Système - Interface de gestion du pare-feu via GUI
  • Profils de Configuration - Déploiement de politiques de pare-feu via MDM

Opérations de Pare-feu de Base

Activer le Pare-feu

#!/bin/bash

# Activer le pare-feu macOS
sudo defaults write /Library/Preferences/com.apple.alf globalstate -int 1

Désactiver le Pare-feu

#!/bin/bash

# Désactiver le pare-feu macOS
sudo defaults write /Library/Preferences/com.apple.alf globalstate -int 0

Vérifier l'État du Pare-feu

#!/bin/bash

# Vérifier l'état du pare-feu
/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate

Système de Gestion de Pare-feu Entreprise

Outil de Gestion de Pare-feu Complet

#!/bin/bash

# Outil de Gestion de Pare-feu Entreprise Roundfleet
# Sécurité réseau avancée et surveillance de conformité

# Configuration
CONFIG_FILE="/etc/roundfleet/firewall_policy.conf"
LOG_FILE="/var/log/roundfleet_firewall.log"
RULES_DIR="/Library/Roundfleet/FirewallRules"
AUDIT_LOG="/var/log/roundfleet_firewall_audit.log"

# Créer les répertoires
mkdir -p "$(dirname "$CONFIG_FILE")" "$(dirname "$LOG_FILE")" "$RULES_DIR" "$(dirname "$AUDIT_LOG")"

# Politique de pare-feu par défaut
cat > "$CONFIG_FILE" 2>/dev/null << 'EOF' || true
# Politique de Gestion de Pare-feu Entreprise Roundfleet
# Version : 2.0

# Paramètres d'Application du Pare-feu
ENFORCE_FIREWALL_ENABLED=true
AUTO_ENABLE_ON_VIOLATION=true
BLOCK_ALL_INCOMING_DEFAULT=true
ALLOW_SIGNED_APPS=true
STEALTH_MODE_ENABLED=true

# Contrôle d'Application
WHITELIST_SYSTEM_APPS=true
REQUIRE_APP_SIGNATURES=true
BLOCK_UNSIGNED_APPS=true
LOG_ALL_CONNECTIONS=true
AUTO_BLOCK_SUSPICIOUS_APPS=true

# Politiques de Sécurité Réseau
BLOCK_PRIVATE_NETWORKS=false
ALLOW_APPLE_SERVICES=true
BLOCK_P2P_CONNECTIONS=true
MONITOR_OUTBOUND_CONNECTIONS=true
RATE_LIMIT_CONNECTIONS=true

# Fonctionnalités de Sécurité Avancées
INTRUSION_DETECTION=true
THREAT_INTELLIGENCE_ENABLED=true
GEO_BLOCKING_ENABLED=false
DLP_INSPECTION=true
MALWARE_DETECTION=true

# Conformité et Surveillance
COMPLIANCE_MONITORING=true
SECURITY_BASELINE_ENFORCEMENT=true
AUTOMATED_REPORTING=true
REAL_TIME_ALERTS=true
INCIDENT_RESPONSE=true

# Modèles de Politiques
DEFAULT_SECURITY_PROFILE="corporate_high"
ALLOWED_PORTS="22,53,80,443,993,995"
BLOCKED_COUNTRIES=""
WHITELIST_DOMAINS="*.apple.com,*.icloud.com"

# Paramètres de Maintenance
AUTO_UPDATE_RULES=true
BACKUP_CONFIGURATIONS=true
LOG_RETENTION_DAYS=90
PERFORMANCE_MONITORING=true
EOF

# Charger la configuration
source "$CONFIG_FILE" 2>/dev/null || true

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

# Fonction de journalisation d'audit
audit_log() {
    local action="$1"
    local result="$2"
    local details="$3"
    echo "$(date '+%Y-%m-%d %H:%M:%S') - ACTION:$action RESULT:$result DETAILS:$details USER:$(whoami)" >> "$AUDIT_LOG"
}

# Obtenir l'état actuel du pare-feu
get_firewall_status() {
    echo "=== État Actuel du Pare-feu ==="
    
    # Vérifier l'état global du pare-feu
    local global_state
    global_state=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate 2>/dev/null | grep -o "enabled\|disabled")
    
    echo "État Global du Pare-feu : $global_state"
    
    # Vérifier le mode furtif
    local stealth_mode
    stealth_mode=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getstealthmode 2>/dev/null | grep -o "enabled\|disabled")
    
    echo "Mode Furtif : $stealth_mode"
    
    # Vérifier l'état de journalisation
    local logging_state
    logging_state=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getloggingmode 2>/dev/null | grep -o "enabled\|disabled")
    
    echo "Journalisation : $logging_state"
    
    # Vérifier le mode bloquer tout
    local block_all
    block_all=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getblockall 2>/dev/null | grep -o "enabled\|disabled")
    
    echo "Bloquer Toutes les Connexions Entrantes : $block_all"
    
    # Vérifier les applications autorisées
    echo -e "\nApplications Autorisées :"
    /usr/libexec/ApplicationFirewall/socketfilterfw --listapps 2>/dev/null | grep "ALF" | head -10
    
    return 0
}

# Activer le pare-feu avec paramètres d'entreprise
enterprise_firewall_enable() {
    local security_profile="${1:-$DEFAULT_SECURITY_PROFILE}"
    
    echo "=== Activation du Pare-feu Entreprise ==="
    echo "Profil de Sécurité : $security_profile"
    
    # Activer le pare-feu global
    log_action "Activation du pare-feu global"
    if sudo defaults write /Library/Preferences/com.apple.alf globalstate -int 1; then
        echo "✅ Pare-feu global activé"
        audit_log "FIREWALL_ENABLE" "SUCCESS" "Pare-feu global activé"
    else
        echo "❌ Échec de l'activation du pare-feu global"
        audit_log "FIREWALL_ENABLE" "FAILED" "Échec de l'activation du pare-feu global"
        return 1
    fi
    
    # Configurer selon le profil de sécurité
    case "$security_profile" in
        "corporate_high")
            configure_high_security_profile
            ;;
        "corporate_standard")
            configure_standard_security_profile
            ;;
        "developer")
            configure_developer_profile
            ;;
        "kiosk")
            configure_kiosk_profile
            ;;
        *)
            echo "Profil de sécurité inconnu, utilisation de la configuration standard"
            configure_standard_security_profile
            ;;
    esac
    
    # Activer le mode furtif si requis
    if [[ "$STEALTH_MODE_ENABLED" == "true" ]]; then
        enable_stealth_mode
    fi
    
    # Activer la journalisation si requise
    if [[ "$LOG_ALL_CONNECTIONS" == "true" ]]; then
        enable_firewall_logging
    fi
    
    # Appliquer les règles d'application
    configure_application_rules
    
    echo "✅ Configuration du pare-feu d'entreprise terminée"
    log_action "Pare-feu d'entreprise activé avec le profil : $security_profile"
    
    return 0
}

# Configurer le profil de haute sécurité
configure_high_security_profile() {
    echo "=== Configuration du Profil de Haute Sécurité ==="
    
    # Bloquer toutes les connexions entrantes par défaut
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall on 2>/dev/null
    
    # Activer le mode furtif
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setstealthmode on 2>/dev/null
    
    # Désactiver l'autorisation automatique pour les applications signées
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsigned off 2>/dev/null
    
    # Bloquer toutes les applications non signées
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsignedapp off 2>/dev/null
    
    echo "Profil de haute sécurité configuré"
    log_action "Profil de pare-feu haute sécurité appliqué"
}

# Configurer le profil de sécurité standard
configure_standard_security_profile() {
    echo "=== Configuration du Profil de Sécurité Standard ==="
    
    # Autoriser les connexions entrantes essentielles
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall off 2>/dev/null
    
    # Activer le mode furtif
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setstealthmode on 2>/dev/null
    
    # Autoriser les applications signées
    if [[ "$ALLOW_SIGNED_APPS" == "true" ]]; then
        sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsigned on 2>/dev/null
    fi
    
    echo "Profil de sécurité standard configuré"
    log_action "Profil de pare-feu sécurité standard appliqué"
}

# Configurer le profil développeur
configure_developer_profile() {
    echo "=== Configuration du Profil Développeur ==="
    
    # Paramètres plus permissifs pour le développement
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall off 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setstealthmode off 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsigned on 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsignedapp on 2>/dev/null
    
    # Ajouter des outils de développement courants
    local dev_apps=(
        "/Applications/Xcode.app"
        "/Applications/Visual Studio Code.app"
        "/Applications/Docker.app"
        "/usr/bin/ssh"
        "/usr/bin/python3"
    )
    
    for app in "${dev_apps[@]}"; do
        if [[ -e "$app" ]]; then
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app" 2>/dev/null
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblock "$app" 2>/dev/null
        fi
    done
    
    echo "Profil développeur configuré"
    log_action "Profil de pare-feu développeur appliqué"
}

# Configurer le profil kiosque
configure_kiosk_profile() {
    echo "=== Configuration du Profil Kiosque ==="
    
    # Sécurité maximale pour les appareils kiosque
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockall on 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setstealthmode on 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsigned off 2>/dev/null
    sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setallowsignedapp off 2>/dev/null
    
    # Autoriser seulement les applications système essentielles
    local kiosk_apps=(
        "/System/Library/CoreServices/Finder.app"
        "/Applications/Safari.app"
    )
    
    for app in "${kiosk_apps[@]}"; do
        if [[ -e "$app" ]]; then
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app" 2>/dev/null
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblock "$app" 2>/dev/null
        fi
    done
    
    echo "Profil kiosque configuré"
    log_action "Profil de pare-feu kiosque appliqué"
}

# Activer le mode furtif
enable_stealth_mode() {
    echo "=== Activation du Mode Furtif ==="
    
    if sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setstealthmode on 2>/dev/null; then
        echo "✅ Mode furtif activé"
        log_action "Mode furtif activé"
        audit_log "STEALTH_MODE" "ENABLED" "Appareil caché des scans réseau"
    else
        echo "❌ Échec de l'activation du mode furtif"
        log_action "ÉCHEC : Activation du mode furtif"
    fi
}

# Activer la journalisation du pare-feu
enable_firewall_logging() {
    echo "=== Activation de la Journalisation du Pare-feu ==="
    
    if sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setloggingmode on 2>/dev/null; then
        echo "✅ Journalisation du pare-feu activée"
        log_action "Journalisation du pare-feu activée"
        audit_log "LOGGING" "ENABLED" "Tous les événements du pare-feu seront journalisés"
    else
        echo "❌ Échec de l'activation de la journalisation du pare-feu"
        log_action "ÉCHEC : Activation de la journalisation du pare-feu"
    fi
}

# Configurer les règles d'application
configure_application_rules() {
    echo "=== Configuration des Règles d'Application ==="
    
    # Applications système essentielles
    local essential_apps=(
        "/System/Library/CoreServices/Software Update.app"
        "/usr/sbin/sshd"
        "/usr/bin/ssh"
        "/Applications/App Store.app"
    )
    
    # Ajouter et autoriser les applications essentielles
    for app in "${essential_apps[@]}"; do
        if [[ -e "$app" ]]; then
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app" 2>/dev/null
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblock "$app" 2>/dev/null
            echo "✅ Autorisé : $(basename "$app")"
        fi
    done
    
    # Bloquer les applications problématiques connues
    local blocked_apps=(
        "/Applications/BitTorrent.app"
        "/Applications/P2P Client.app"
    )
    
    for app in "${blocked_apps[@]}"; do
        if [[ -e "$app" ]]; then
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app" 2>/dev/null
            sudo /usr/libexec/ApplicationFirewall/socketfilterfw --block "$app" 2>/dev/null
            echo "🚫 Bloqué : $(basename "$app")"
        fi
    done
    
    log_action "Règles de pare-feu d'application configurées"
}

# Désactiver le pare-feu (avec vérifications de sécurité)
enterprise_firewall_disable() {
    local force="${1:-false}"
    local reason="$2"
    
    echo "=== Désactivation du Pare-feu Entreprise ==="
    
    if [[ "$force" != "true" ]]; then
        echo "⚠️  AVERTISSEMENT : Désactiver le pare-feu réduira la sécurité"
        echo "Utilisez le paramètre 'force' pour contourner cet avertissement"
        
        if [[ -z "$reason" ]]; then
            echo "❌ Raison requise pour l'opération de désactivation du pare-feu"
            return 1
        fi
    fi
    
    # Journaliser l'action de désactivation
    log_action "AVERTISSEMENT DE SÉCURITÉ : Pare-feu en cours de désactivation - Raison : ${reason:-Contournement manuel}"
    audit_log "FIREWALL_DISABLE" "INITIATED" "Raison : ${reason:-Contournement manuel}"
    
    # Désactiver le pare-feu global
    if sudo defaults write /Library/Preferences/com.apple.alf globalstate -int 0; then
        echo "✅ Pare-feu global désactivé"
        audit_log "FIREWALL_DISABLE" "SUCCESS" "Pare-feu global désactivé"
        
        # Programmer la réactivation si temporaire
        if [[ "$reason" == *"temporaire"* || "$reason" == *"maintenance"* ]]; then
            schedule_firewall_renable
        fi
        
        return 0
    else
        echo "❌ Échec de la désactivation du pare-feu global"
        audit_log "FIREWALL_DISABLE" "FAILED" "Échec de la désactivation du pare-feu global"
        return 1
    fi
}

# Programmer la réactivation du pare-feu
schedule_firewall_renable() {
    local renable_minutes="${1:-60}"  # Défaut 1 heure
    
    echo "🕒 Le pare-feu sera automatiquement réactivé dans $renable_minutes minutes"
    
    # Créer une tâche en arrière-plan pour réactiver le pare-feu
    (
        sleep $((renable_minutes * 60))
        log_action "Réactivation automatique du pare-feu après la fenêtre de maintenance"
        enterprise_firewall_enable "corporate_standard"
    ) &
    
    local job_pid=$!
    echo "$job_pid" > "/tmp/roundfleet_firewall_renable.pid"
    log_action "Réactivation du pare-feu programmée pour $renable_minutes minutes (PID : $job_pid)"
}

# Vérifier la conformité du pare-feu
check_firewall_compliance() {
    echo "=== Vérification de Conformité du Pare-feu ==="
    
    local compliance_issues=()
    local compliance_score=100
    
    # Vérifier si le pare-feu est activé
    local firewall_state
    firewall_state=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate 2>/dev/null | grep -o "enabled\|disabled")
    
    if [[ "$firewall_state" != "enabled" ]]; then
        compliance_issues+=("Pare-feu non activé")
        compliance_score=$((compliance_score - 30))
    fi
    
    # Vérifier le mode furtif
    if [[ "$STEALTH_MODE_ENABLED" == "true" ]]; then
        local stealth_state
        stealth_state=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getstealthmode 2>/dev/null | grep -o "enabled\|disabled")
        
        if [[ "$stealth_state" != "enabled" ]]; then
            compliance_issues+=("Mode furtif non activé")
            compliance_score=$((compliance_score - 15))
        fi
    fi
    
    # Vérifier la journalisation
    if [[ "$LOG_ALL_CONNECTIONS" == "true" ]]; then
        local logging_state
        logging_state=$(/usr/libexec/ApplicationFirewall/socketfilterfw --getloggingmode 2>/dev/null | grep -o "enabled\|disabled")
        
        if [[ "$logging_state" != "enabled" ]]; then
            compliance_issues+=("Journalisation du pare-feu non activée")
            compliance_score=$((compliance_score - 10))
        fi
    fi
    
    # Vérifier les applications non autorisées
    local unauthorized_apps
    unauthorized_apps=$(/usr/libexec/ApplicationFirewall/socketfilterfw --listapps 2>/dev/null | grep -i "torrent\|p2p\|limewire" | wc -l)
    
    if [[ $unauthorized_apps -gt 0 ]]; then
        compliance_issues+=("Applications non autorisées détectées : $unauthorized_apps")
        compliance_score=$((compliance_score - 20))
    fi
    
    # Rapporter l'état de conformité
    echo "Score de Conformité : $compliance_score/100"
    
    if [[ ${#compliance_issues[@]} -eq 0 ]]; then
        echo "✅ La configuration du pare-feu est conforme"
        audit_log "COMPLIANCE_CHECK" "PASSED" "Score : $compliance_score/100"
        return 0
    else
        echo "❌ Problèmes de conformité trouvés :"
        printf '  - %s\n' "${compliance_issues[@]}"
        audit_log "COMPLIANCE_CHECK" "FAILED" "Problèmes : ${#compliance_issues[@]} Score : $compliance_score/100"
        
        # Auto-remédiation si activée
        if [[ "$AUTO_ENABLE_ON_VIOLATION" == "true" ]]; then
            echo "🔧 Auto-remédiation activée, correction des problèmes..."
            enterprise_firewall_enable "$DEFAULT_SECURITY_PROFILE"
        fi
        
        return 1
    fi
}

# Surveiller les événements du pare-feu
monitor_firewall_events() {
    echo "=== Démarrage de la Surveillance des Événements du Pare-feu ==="
    
    local log_file="/var/log/appfirewall.log"
    
    if [[ ! -f "$log_file" ]]; then
        echo "⚠️  Fichier de journal du pare-feu non trouvé. Activation de la journalisation..."
        enable_firewall_logging
        sleep 2
    fi
    
    echo "Surveillance des événements du pare-feu... Appuyez sur Ctrl+C pour arrêter"
    
    # Surveiller le journal du pare-feu en temps réel
    tail -f "$log_file" 2>/dev/null | while read -r line; do
        if echo "$line" | grep -q "Deny\|Block"; then
            local app_name
            app_name=$(echo "$line" | awk '{print $8}' | cut -d'(' -f1)
            local action
            action=$(echo "$line" | awk '{print $6}')
            
            echo "🚫 $(date '+%H:%M:%S') - BLOQUÉ : $app_name ($action)"
            
            # Journaliser l'événement de sécurité
            log_action "ÉVÉNEMENT DE SÉCURITÉ : $action - Application : $app_name"
            audit_log "FIREWALL_BLOCK" "DETECTED" "App : $app_name Action : $action"
            
            # Vérifier les menaces potentielles
            if echo "$app_name" | grep -i -E "(torrent|p2p|hack|crack|keygen)"; then
                echo "🚨 ALERTE DE SÉCURITÉ : Application potentiellement malveillante bloquée : $app_name"
                log_action "ALERTE DE SÉCURITÉ : Application malveillante bloquée - $app_name"
            fi
        fi
    done
}

# Générer un rapport de sécurité du pare-feu
generate_firewall_report() {
    local report_file="$RULES_DIR/firewall_report_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Génération du Rapport de Sécurité du Pare-feu ==="
    
    # Obtenir l'état actuel du pare-feu
    local firewall_enabled="false"
    local stealth_enabled="false"
    local logging_enabled="false"
    local block_all_enabled="false"
    
    if /usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate 2>/dev/null | grep -q "enabled"; then
        firewall_enabled="true"
    fi
    
    if /usr/libexec/ApplicationFirewall/socketfilterfw --getstealthmode 2>/dev/null | grep -q "enabled"; then
        stealth_enabled="true"
    fi
    
    if /usr/libexec/ApplicationFirewall/socketfilterfw --getloggingmode 2>/dev/null | grep -q "enabled"; then
        logging_enabled="true"
    fi
    
    if /usr/libexec/ApplicationFirewall/socketfilterfw --getblockall 2>/dev/null | grep -q "enabled"; then
        block_all_enabled="true"
    fi
    
    # Compter les applications autorisées/bloquées
    local total_apps=0
    local allowed_apps=0
    local blocked_apps=0
    
    if command -v /usr/libexec/ApplicationFirewall/socketfilterfw >/dev/null; then
        total_apps=$(/usr/libexec/ApplicationFirewall/socketfilterfw --listapps 2>/dev/null | grep -c "ALF" || echo 0)
        allowed_apps=$(/usr/libexec/ApplicationFirewall/socketfilterfw --listapps 2>/dev/null | grep -c "ALLOW" || echo 0)
        blocked_apps=$(/usr/libexec/ApplicationFirewall/socketfilterfw --listapps 2>/dev/null | grep -c "BLOCK" || echo 0)
    fi
    
    # Analyser les événements de sécurité récents
    local security_events=0
    local blocked_connections=0
    
    if [[ -f "/var/log/appfirewall.log" ]]; then
        security_events=$(grep -c "$(date '+%Y-%m-%d')" "/var/log/appfirewall.log" 2>/dev/null || echo 0)
        blocked_connections=$(grep -c "Deny\|Block" "/var/log/appfirewall.log" 2>/dev/null || echo 0)
    fi
    
    # Créer le rapport JSON
    cat > "$report_file" << EOF
{
  "type_rapport": "securite_pare_feu",
  "horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "infos_appareil": {
    "nom_hote": "$(hostname)",
    "version_os": "$(sw_vers -productVersion)",
    "numero_serie": "$(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F: '{print $2}' | xargs)"
  },
  "statut_pare_feu": {
    "pare_feu_global_active": $firewall_enabled,
    "mode_furtif_active": $stealth_enabled,
    "journalisation_activee": $logging_enabled,
    "bloquer_toutes_entrees": $block_all_enabled
  },
  "regles_application": {
    "applications_totales": $total_apps,
    "applications_autorisees": $allowed_apps,
    "applications_bloquees": $blocked_apps
  },
  "evenements_securite": {
    "evenements_totaux_aujourdhui": $security_events,
    "connexions_bloquees": $blocked_connections,
    "dernier_evenement": "$(tail -1 /var/log/appfirewall.log 2>/dev/null | awk '{print $1 " " $2 " " $3}' || echo 'N/A')"
  },
  "statut_conformite": {
    "conforme_politique": $(check_firewall_compliance >/dev/null 2>&1 && echo true || echo false),
    "profil_securite": "$DEFAULT_SECURITY_PROFILE",
    "auto_remediation": $AUTO_ENABLE_ON_VIOLATION
  },
  "recommandations": [
    $([ "$firewall_enabled" != "true" ] && echo '"Activer le pare-feu global",' || echo "")
    $([ "$stealth_enabled" != "true" ] && echo '"Activer le mode furtif",' || echo "")
    $([ "$logging_enabled" != "true" ] && echo '"Activer la journalisation du pare-feu",' || echo "")
    "Révision régulière des règles de pare-feu"
  ]
}
EOF
    
    echo "Rapport de sécurité du pare-feu sauvegardé dans : $report_file"
    log_action "Rapport de sécurité du pare-feu généré : $report_file"
}

# Fonction principale avec gestion d'arguments
main() {
    log_action "=== Outil de Gestion de Pare-feu Roundfleet Démarré ==="
    
    case "${1:-status}" in
        "enable")
            enterprise_firewall_enable "$2"
            ;;
        "disable")
            enterprise_firewall_disable "$2" "$3"
            ;;
        "status")
            get_firewall_status
            ;;
        "compliance")
            check_firewall_compliance
            ;;
        "monitor")
            monitor_firewall_events
            ;;
        "report")
            generate_firewall_report
            ;;
        "stealth")
            enable_stealth_mode
            ;;
        "logging")
            enable_firewall_logging
            ;;
        "profile")
            enterprise_firewall_enable "$2"
            ;;
        *)
            echo "Outil de Gestion de Pare-feu Entreprise Roundfleet"
            echo "Usage : $0 [commande] [options]"
            echo ""
            echo "Commandes :"
            echo "  enable [profil]               - Activer le pare-feu avec profil de sécurité"
            echo "  disable [force] [raison]      - Désactiver le pare-feu (nécessite une raison)"
            echo "  status                        - Afficher l'état actuel du pare-feu"
            echo "  compliance                    - Vérifier la conformité du pare-feu"
            echo "  monitor                       - Surveiller les événements du pare-feu en temps réel"
            echo "  report                        - Générer un rapport de sécurité"
            echo "  stealth                       - Activer le mode furtif"
            echo "  logging                       - Activer la journalisation du pare-feu"
            echo "  profile [nom]                 - Appliquer un profil de sécurité spécifique"
            echo ""
            echo "Profils de Sécurité :"
            echo "  corporate_high                - Sécurité maximale pour environnements sensibles"
            echo "  corporate_standard            - Sécurité d'entreprise standard (défaut)"
            echo "  developer                     - Paramètres adaptés au développement"
            echo "  kiosk                         - Sécurité pour accès kiosque/public"
            ;;
    esac
    
    log_action "=== Opération de gestion du pare-feu terminée ==="
}

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

## Gestion Avancée du Pare-feu

### Moteur de Règles de Pare-feu Personnalisées

```bash
#!/bin/bash

# Gestion avancée des règles de pare-feu
manage_custom_rules() {
    local action="$1"
    local rule_name="$2"
    local rule_definition="$3"
    
    echo "=== Gestion des Règles de Pare-feu Personnalisées ==="
    
    local rules_file="$RULES_DIR/custom_rules.conf"
    
    case "$action" in
        "add")
            if [[ -z "$rule_name" || -z "$rule_definition" ]]; then
                echo "❌ Nom de règle et définition requis"
                return 1
            fi
            
            # Ajouter la règle à la configuration
            echo "$rule_name:$rule_definition" >> "$rules_file"
            echo "✅ Règle personnalisée '$rule_name' ajoutée"
            log_action "Règle de pare-feu personnalisée ajoutée : $rule_name"
            
            # Appliquer la règle immédiatement
            apply_custom_rule "$rule_definition"
            ;;
        "remove")
            if [[ -f "$rules_file" && -n "$rule_name" ]]; then
                grep -v "^$rule_name:" "$rules_file" > "$rules_file.tmp"
                mv "$rules_file.tmp" "$rules_file"
                echo "✅ Règle personnalisée '$rule_name' supprimée"
                log_action "Règle de pare-feu personnalisée supprimée : $rule_name"
            else
                echo "❌ Règle '$rule_name' non trouvée"
            fi
            ;;
        "list")
            if [[ -f "$rules_file" ]]; then
                echo "Règles de pare-feu personnalisées :"
                cat "$rules_file" | while IFS=':' read -r name definition; do
                    echo "  $name : $definition"
                done
            else
                echo "Aucune règle personnalisée configurée"
            fi
            ;;
        "apply")
            apply_all_custom_rules
            ;;
        *)
            echo "Usage : manage_custom_rules [add|remove|list|apply] [nom_règle] [définition]"
            ;;
    esac
}

# Appliquer une règle de pare-feu personnalisée
apply_custom_rule() {
    local rule_definition="$1"
    
    # Analyser la définition de règle et appliquer la commande de pare-feu appropriée
    if echo "$rule_definition" | grep -q "block_app:"; then
        local app_path
        app_path=$(echo "$rule_definition" | cut -d':' -f2)
        sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app_path" 2>/dev/null
        sudo /usr/libexec/ApplicationFirewall/socketfilterfw --block "$app_path" 2>/dev/null
        echo "Règle de blocage appliquée pour : $app_path"
    elif echo "$rule_definition" | grep -q "allow_app:"; then
        local app_path
        app_path=$(echo "$rule_definition" | cut -d':' -f2)
        sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add "$app_path" 2>/dev/null
        sudo /usr/libexec/ApplicationFirewall/socketfilterfw --unblock "$app_path" 2>/dev/null
        echo "Règle d'autorisation appliquée pour : $app_path"
    fi
}

# Appliquer toutes les règles personnalisées
apply_all_custom_rules() {
    local rules_file="$RULES_DIR/custom_rules.conf"
    
    if [[ -f "$rules_file" ]]; then
        echo "Application de toutes les règles de pare-feu personnalisées..."
        while IFS=':' read -r name definition; do
            if [[ -n "$name" && -n "$definition" ]]; then
                apply_custom_rule "$definition"
            fi
        done < "$rules_file"
        echo "✅ Toutes les règles personnalisées appliquées"
    else
        echo "Aucune règle personnalisée à appliquer"
    fi
}

# Exemples de règles personnalisées
create_example_rules() {
    manage_custom_rules "add" "block_bittorrent" "block_app:/Applications/BitTorrent.app"
    manage_custom_rules "add" "allow_docker" "allow_app:/Applications/Docker.app"
    manage_custom_rules "add" "allow_ssh" "allow_app:/usr/bin/ssh"
}

create_example_rules

Notes de Configuration Importantes

Architecture du Pare-feu macOS

  • Pare-feu d'Application - Contrôle les connexions entrantes par application
  • Framework de Filtre de Socket - Filtrage de paquets de bas niveau
  • Framework d'Extension Réseau - Filtrage de contenu moderne
  • Protection de l'Intégrité Système - Protège la configuration du pare-feu
  • Contrôles de Confidentialité - Consentement utilisateur pour l'accès réseau

Points d'Intégration Entreprise

  • Profils de Configuration MDM - Déployer les politiques de pare-feu de manière centralisée
  • Intégration SIEM - Transférer les journaux de sécurité vers les systèmes de surveillance
  • Cadres de Conformité - Support pour SOC 2, ISO 27001, NIST
  • Réponse aux Incidents - Détection et réponse automatisées aux menaces

Bonnes Pratiques pour l'Entreprise

  1. Approche de Sécurité en Couches

    • Combiner le pare-feu d'application avec la segmentation réseau
    • Implémenter la détection et réponse de point de terminaison (EDR)
    • Utiliser le contrôle d'accès réseau (NAC)
    • Déployer des systèmes de détection d'intrusion (IDS)

  2. Gestion des Politiques

    • Définir des lignes de base de sécurité claires
    • Examiner et mettre à jour régulièrement les règles de pare-feu
    • Implémenter des processus de gestion des changements
    • Tester régulièrement les politiques de sécurité

  3. Surveillance et Réponse

    • Activer la journalisation complète
    • Surveiller les changements de configuration
    • Implémenter la détection automatisée des menaces
    • Établir des procédures de réponse aux incidents

  4. Conformité et Audit

    • Générer régulièrement des rapports de conformité
    • Maintenir des pistes d'audit
    • Documenter les exceptions de sécurité
    • Conduire des évaluations de sécurité périodiques

Dépannage des Problèmes Courants

  • Erreurs de permissions - S'assurer des privilèges administrateur pour les modifications du pare-feu
  • Connectivité d'application - Examiner les règles de pare-feu pour les applications bloquées
  • Impact sur les performances - Surveiller l'utilisation CPU avec la journalisation extensive activée
  • Conflits de configuration - Vérifier les profils MDM conflictuels
  • Croissance des fichiers de journal - Implémenter la rotation et l'archivage des journaux

N'oubliez pas de tester minutieusement les configurations de pare-feu dans un environnement contrôlé avant le déploiement sur l'ensemble de votre Roundfleet pour assurer la continuité des activités tout en maintenant la sécurité.

Related Tutorials

Gestion des Jetons Sécurisés sur macOS

Apprenez à gérer et accorder des jetons sécurisés aux utilisateurs sur les appareils macOS en utilisant sysadminctl pour la sécurité d'entreprise, la gestion FileVault et l'authentification des opérations cryptographiques.

7 juil. 2025

Gestion Sécurisée d'Archives sur macOS

Apprenez à créer, gérer et sécuriser des archives sur les appareils macOS en utilisant des fichiers ZIP protégés par mot de passe avec sécurité de niveau entreprise, opérations par lots, suivi de conformité et capacités de gestion d'archives à l'échelle de la flotte.

7 juil. 2025

Gestion à Distance d'Entreprise et Contrôle d'Accès Sécurisé sur macOS

Configuration complète de la gestion à distance, contrôle d'accès sécurisé, support multi-protocoles et cadres de conformité d'entreprise pour les appareils macOS avec surveillance de sécurité avancée et application automatisée des politiques.

7 juil. 2025

Gestion des Mots de Passe d'Entreprise sur macOS

Gérez les mots de passe utilisateur, implémentez des politiques de mots de passe et contrôlez les mécanismes d'authentification sur les appareils macOS en utilisant dscl, sysadminctl et les frameworks de gestion de mots de passe d'entreprise pour la sécurité de flotte.

7 juil. 2025

Gestion Entreprise de Changement de Mot de Passe sur macOS

Guide complet pour les opérations sécurisées de changement de mot de passe en entreprise sur les appareils Roundfleet avec application de politiques, contrôles de sécurité et capacités d'audit complètes.

7 juil. 2025

Gestion de Sécurité et Conformité Find My Mac

Surveillez et gérez le statut Find My Mac sur les appareils d'entreprise avec des vérifications de conformité sécurisée automatisées, vérification Apple ID, et audit de sécurité de flotte complet.

7 juil. 2025

Suppression de Comptes Utilisateur et Gestion du Cycle de Vie sur macOS

Apprenez à supprimer en toute sécurité les comptes utilisateur, gérer la rétention des données, implémenter des procédures de départ sécurisées et traiter la gestion du cycle de vie des utilisateurs d'entreprise sur les appareils macOS.

7 juil. 2025

Gestion Entreprise des Fuseaux Horaires sur macOS

Guide complet pour la gestion des fuseaux horaires et des paramètres de date/heure en entreprise sur les appareils Roundfleet avec synchronisation automatisée, conformité géographique, application de politiques et contrôle centralisé.

7 juil. 2025
View all tutorials →