secubox-openwrt/.claude/EVOLUTION-PLAN.md

SecuBox — Plan d'Évolution : Intégration des patterns SysWarden

Document interne CyberMind.FR — Usage Claude Code
Auteur : Gandalf (gkerma) — Version 1.0 — Février 2026
Référence : secubox-openwrt × syswarden cross-analysis

---

Contexte et Objectif

Ce document est un plan d'implémentation actionnable pour Claude Code. Il décrit quatre évolutions techniques à apporter à secubox-openwrt, inspirées de l'analyse comparative du projet syswarden (fork gkerma/syswarden).

Objectif global : combler les surfaces de sécurité non couvertes par SecuBox en s'inspirant des patterns éprouvés de SysWarden, sans dénaturer l'architecture LuCI modulaire existante.

Périmètre : les quatre évolutions sont indépendantes et peuvent être implémentées dans l'ordre de priorité défini. Chacune est spécifiée avec suffisamment de détail pour qu'un agent Claude Code puisse l'implémenter sans intervention humaine supplémentaire.

---

ÉVOLUTION #1 — luci-app-ipblocklist (Priorité HAUTE)

Problème adressé

SecuBox s'appuie exclusivement sur CrowdSec pour le blocage IP, qui est réactif/collaboratif. Il n'existe aucune couche de défense statique pré-emptive à l'image du layer 1 de SysWarden (blocklist ~100k IPs connues dans ipset kernel).

Architecture cible

Trafic entrant
  └─► [Layer 1] ipset Data-Shield (~100k IPs)   → DROP kernel immédiat (NOUVEAU)
        └─► [Layer 2] CrowdSec bouncer          → blocage collaboratif dynamique (EXISTANT)
              └─► [Layer 3] Netifyd DPI         → détection applicative (EXISTANT)

Nouveau module à créer : luci-app-ipblocklist

Structure de fichiers à créer :

luci-app-ipblocklist/
├── Makefile
├── README.md
├── htdocs/luci-static/resources/
│   ├── view/ipblocklist/
│   │   └── dashboard.js          # Vue principale LuCI
│   └── ipblocklist/
│       ├── api.js                # Client RPC
│       └── dashboard.css         # Styles (dark cybersecurity theme, cohérent avec CrowdSec)
└── root/
    ├── etc/
    │   ├── config/ipblocklist    # UCI config (sources, schedule, whitelist)
    │   └── cron.d/ipblocklist    # Cron hourly update
    ├── usr/
    │   ├── libexec/rpcd/ipblocklist  # Backend shell RPCD
    │   └── share/
    │       ├── luci/menu.d/ipblocklist.json
    │       └── rpcd/acl.d/ipblocklist.json
    └── sbin/
        └── ipblocklist-update.sh  # Script principal de mise à jour

Spécifications ipblocklist-update.sh

Ce script s'inspire directement de install-syswarden.sh mais adapté OpenWrt :

#!/bin/sh
# ipblocklist-update.sh — SecuBox IP Blocklist Manager
# Compatible OpenWrt — utilise ipset natif + nftables/iptables selon disponibilité

IPSET_NAME="secubox_blocklist"
SOURCES_UCI="ipblocklist"
LOG_FILE="/var/log/ipblocklist.log"
WHITELIST_FILE="/etc/ipblocklist/whitelist.txt"

# Sources de blocklists (configurables via UCI)
# Défaut: Data-Shield (même source que SysWarden)
DEFAULT_SOURCES="
https://raw.githubusercontent.com/duggytuxy/Data-Shield_IPv4_Blocklist/main/data-shield-blocklist-ipv4.txt
https://raw.githubusercontent.com/firehol/blocklist-ipsets/master/firehol_level1.netset
"

# Détection automatique du backend firewall (pattern SysWarden)
detect_firewall() {
    if command -v nft >/dev/null 2>&1; then
        echo "nftables"
    elif command -v iptables >/dev/null 2>&1; then
        echo "iptables"
    else
        echo "none"
    fi
}

# Initialisation ipset
init_ipset() {
    ipset create "$IPSET_NAME" hash:net hashsize 65536 maxelem 200000 2>/dev/null || true
    ipset flush "$IPSET_NAME"
}

# Téléchargement et chargement avec TCP latency check (pattern SysWarden smart mirror)
load_blocklist() {
    local sources
    sources=$(uci get "${SOURCES_UCI}.global.sources" 2>/dev/null || echo "$DEFAULT_SOURCES")
    local count=0
    for url in $sources; do
        local tmp
        tmp=$(mktemp)
        if wget -q -T 15 -O "$tmp" "$url" 2>/dev/null; then
            while IFS= read -r line; do
                [ -z "$line" ] && continue
                echo "${line%%#*}" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]' || continue
                # Vérification whitelist
                grep -qF "$line" "$WHITELIST_FILE" 2>/dev/null && continue
                ipset add "$IPSET_NAME" "$line" 2>/dev/null && count=$((count + 1))
            done < "$tmp"
        fi
        rm -f "$tmp"
    done
    echo "$(date): Loaded $count IPs into $IPSET_NAME" >> "$LOG_FILE"
}

# Application des règles firewall
apply_rules() {
    local fw
    fw=$(detect_firewall)
    case "$fw" in
        nftables)
            # Intégration nftables OpenWrt (table fw4)
            nft add set inet fw4 "$IPSET_NAME" { type ipv4_addr \; flags interval \; } 2>/dev/null || true
            nft add rule inet fw4 forward ip saddr @"$IPSET_NAME" drop 2>/dev/null || true
            nft add rule inet fw4 input ip saddr @"$IPSET_NAME" drop 2>/dev/null || true
            ;;
        iptables)
            iptables -I INPUT -m set --match-set "$IPSET_NAME" src -j DROP 2>/dev/null || true
            iptables -I FORWARD -m set --match-set "$IPSET_NAME" src -j DROP 2>/dev/null || true
            ;;
    esac
}

# Persistance via hotplug OpenWrt
save_persistence() {
    local save_dir="/etc/ipblocklist"
    mkdir -p "$save_dir"
    ipset save "$IPSET_NAME" > "${save_dir}/ipset.save"
}

main() {
    init_ipset
    load_blocklist
    apply_rules
    save_persistence
}

main "$@"

Spécifications UCI (/etc/config/ipblocklist)

config global 'global'
    option enabled '1'
    option update_interval '3600'
    list sources 'https://raw.githubusercontent.com/duggytuxy/Data-Shield_IPv4_Blocklist/main/data-shield-blocklist-ipv4.txt'
    list sources 'https://raw.githubusercontent.com/firehol/blocklist-ipsets/master/firehol_level1.netset'
    option log_drops '1'
    option whitelist_file '/etc/ipblocklist/whitelist.txt'

Interface LuCI (dashboard.js) — Fonctionnalités requises

1. Status Card : nombre d'IPs en blocklist, dernière mise à jour, taille ipset
2. Sources Manager : liste des sources URL, ajout/suppression, activation par source
3. Whitelist Manager : IPs/CIDRs à exclure, import depuis fichier
4. Logs Viewer : journal des blocages avec pagination (10/20/50 entrées)
5. Manual Actions : bouton "Update Now", bouton "Flush", bouton "Test IP"
6. Statistics : graphe hits par heure (sparkline, réutiliser le style Netdata dashboard)

Dépendances Makefile

PKG_NAME:=luci-app-ipblocklist
PKG_VERSION:=1.0.0
LUCI_DEPENDS:=+ipset +kmod-ipt-ipset +iptables-mod-ipset
LUCI_TITLE:=SecuBox IP Blocklist — Static threat defense layer

Tests de validation

• ipset list secubox_blocklist retourne > 50000 entrées après update
• Une IP connue malveillante (ex: 1.1.1.1 dans whitelist = exclue, IP Firehol level1 = bloquée)
• Reboot : l'ipset est rechargé depuis /etc/ipblocklist/ipset.save via hotplug
• UCI toggle enabled=0 désactive le cron et vide l'ipset
• Interface LuCI : toutes les sections s'affichent sans erreur JS console

---

ÉVOLUTION #2 — Reporting AbuseIPDB dans luci-app-crowdsec-dashboard (Priorité HAUTE)

Problème adressé

SecuBox n'a aucun mécanisme de reporting sortant vers les bases communautaires. SysWarden implémente syswarden_reporter.py qui soumet automatiquement les IPs bloquées à AbuseIPDB. Intégrer ce pattern dans le CrowdSec dashboard renforce la posture communautaire et constitue un argument favorable pour la certification ANSSI.

Modifications à apporter au module existant

Fichier cible : luci-app-crowdsec-dashboard/

Nouveaux fichiers à créer :

luci-app-crowdsec-dashboard/
└── root/
    ├── etc/config/crowdsec_abuseipdb    # UCI config clé API + seuils
    └── usr/
        ├── libexec/rpcd/crowdsec_abuseipdb  # Backend RPCD
        └── sbin/
            └── crowdsec-reporter.sh     # Script de reporting (version shell de syswarden_reporter.py)

Modifications à apporter au dashboard JS existant :

• Ajouter un onglet "AbuseIPDB Reporter" dans luci-app-crowdsec-dashboard/htdocs/luci-static/resources/view/crowdsec/
• Nouveau fichier : reporter.js

Spécifications crowdsec-reporter.sh

#!/bin/sh
# crowdsec-reporter.sh — SecuBox AbuseIPDB Reporter
# Inspired by syswarden_reporter.py — shell version for OpenWrt

ABUSEIPDB_API_URL="https://api.abuseipdb.com/api/v2/report"
UCI_CONFIG="crowdsec_abuseipdb"
LOG_FILE="/var/log/crowdsec-reporter.log"
STATE_FILE="/var/lib/crowdsec-reporter/reported.txt"

get_api_key() {
    uci get "${UCI_CONFIG}.global.api_key" 2>/dev/null
}

get_confidence_threshold() {
    uci get "${UCI_CONFIG}.global.confidence_threshold" 2>/dev/null || echo "80"
}

# Récupère les décisions CrowdSec récentes (dernière heure)
get_recent_decisions() {
    if command -v cscli >/dev/null 2>&1; then
        cscli decisions list --output json 2>/dev/null | \
            jsonfilter -e '@[*].value' 2>/dev/null
    else
        # Fallback: lecture des logs CrowdSec
        grep -h "ban" /var/log/crowdsec/*.log 2>/dev/null | \
            grep -oE '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | sort -u
    fi
}

# Reporting vers AbuseIPDB (pattern SysWarden)
report_ip() {
    local ip="$1"
    local api_key="$2"
    local categories="18,21"  # Brute-Force, Web App Attack

    # Éviter les doublons (anti-spam AbuseIPDB 15min cooldown)
    mkdir -p "$(dirname "$STATE_FILE")"
    grep -qF "$ip" "$STATE_FILE" 2>/dev/null && return 0

    local response
    response=$(wget -q -O- \
        --header="Key: ${api_key}" \
        --header="Accept: application/json" \
        --post-data="ip=${ip}&categories=${categories}&comment=Blocked+by+SecuBox+CrowdSec+on+OpenWrt" \
        "$ABUSEIPDB_API_URL" 2>/dev/null)

    if echo "$response" | grep -q '"abuseConfidenceScore"'; then
        echo "$ip" >> "$STATE_FILE"
        echo "$(date): Reported $ip to AbuseIPDB" >> "$LOG_FILE"
        return 0
    fi
    return 1
}

main() {
    local api_key
    api_key=$(get_api_key)
    [ -z "$api_key" ] && echo "No API key configured" && exit 1

    # Rotation du fichier d'état (garder 7 jours = pattern SysWarden logrotate)
    find "$(dirname "$STATE_FILE")" -name "reported.txt.*" -mtime +7 -delete 2>/dev/null

    local decisions
    decisions=$(get_recent_decisions)
    local reported=0
    for ip in $decisions; do
        report_ip "$ip" "$api_key" && reported=$((reported + 1))
    done
    echo "$(date): Reported $reported IPs to AbuseIPDB" >> "$LOG_FILE"
}

main "$@"

Interface LuCI — Onglet "AbuseIPDB Reporter" (reporter.js)

Sections requises :

1. Configuration : champ API Key (masqué), seuil de confiance (slider 0-100), toggle enabled
2. Statistics : IPs reportées aujourd'hui / cette semaine / total, score AbuseIPDB du routeur
3. History : tableau des derniers reportings (IP, date, catégories, score retourné)
4. Cron Status : fréquence de reporting, dernier run, prochain run

Cron à configurer

# /etc/cron.d/crowdsec-reporter
*/15 * * * * root /usr/sbin/crowdsec-reporter.sh >/dev/null 2>&1

Tests de validation

• Avec clé API valide : au moins un reporting réussi visible dans l'historique
• Cooldown : même IP non re-reportée avant 15 minutes
• Sans clé API : interface affiche un état "non configuré" sans erreur
• Toggle disabled : cron supprimé, script ne s'exécute pas

---

ÉVOLUTION #3 — Log Denoising dans luci-app-system-hub (Priorité MOYENNE)

Problème adressé

luci-app-system-hub agrège les logs de tous les composants SecuBox mais affiche le bruit brut : scans automatisés, bruteforce repetitif depuis des IPs déjà dans la blocklist. SysWarden vante comme bénéfice principal la "réduction du bruit" pour ne voir que les "vrais signaux". Appliquer cette philosophie à la vue logs de System Hub.

Modifications à apporter au module existant

Fichier cible principal : luci-app-system-hub/htdocs/luci-static/resources/view/system_hub/logs.js (ou équivalent selon structure existante)

Nouveau backend à créer : luci-app-system-hub/root/usr/libexec/rpcd/system_hub_denoiser

Spécifications du backend system_hub_denoiser

#!/bin/sh
# system_hub_denoiser — Filtre les logs en excluant les IPs déjà dans ipblocklist
# et les événements répétitifs sans valeur opérationnelle

IPSET_NAME="secubox_blocklist"
MAX_LINES="${1:-200}"

# Récupère les IPs de la blocklist pour filtrage rapide
get_blocklist_ips() {
    ipset list "$IPSET_NAME" 2>/dev/null | grep -E '^[0-9]+\.' | head -1000
}

# Filtre un flux de logs
filter_logs() {
    local input="$1"
    local mode="${2:-smart}"  # smart | raw | signal_only

    case "$mode" in
        raw)
            # Aucun filtrage, logs bruts
            cat "$input"
            ;;
        smart)
            # Supprime les entrées provenant d'IPs en blocklist statique
            # Supprime les patterns repetitifs sans valeur (scans SYN purs)
            grep -v -f /tmp/denoiser_iplist.txt "$input" 2>/dev/null | \
            grep -vE "(SYN_RECV|SYN_SENT)" | \
            grep -vE "kernel: \[.*\] DROP" | \
            tail -n "$MAX_LINES"
            ;;
        signal_only)
            # Mode le plus agressif : uniquement les événements CrowdSec, auth failures, erreurs
            grep -E "(crowdsec|ALERT|ERROR|WARN|authentication failure|Failed password|CRITICAL)" "$input" | \
            tail -n "$MAX_LINES"
            ;;
    esac
}

# Point d'entrée RPCD
case "$1" in
    get_filtered_logs)
        get_blocklist_ips > /tmp/denoiser_iplist.txt 2>/dev/null
        # Collecte logs de toutes les sources SecuBox
        {
            tail -n 500 /var/log/crowdsec/crowdsec.log 2>/dev/null
            tail -n 500 /var/log/ipblocklist.log 2>/dev/null
            logread 2>/dev/null | tail -n 500
        } | filter_logs /dev/stdin "$2"
        rm -f /tmp/denoiser_iplist.txt
        ;;
    get_stats)
        # Retourne les statistiques de débruitage
        local total raw filtered
        raw=$(logread 2>/dev/null | wc -l)
        filtered=$(logread 2>/dev/null | grep -c -E "(crowdsec|ALERT|ERROR|WARN|authentication failure)" 2>/dev/null || echo 0)
        printf '{"total":%d,"signals":%d,"noise_ratio":%d}\n' \
            "$raw" "$filtered" \
            "$(( (raw - filtered) * 100 / (raw + 1) ))"
        ;;
esac

Modifications UI dans System Hub

Ajouter dans la vue logs existante :

1. Sélecteur de mode (toggle 3 positions) :

   • RAW — logs bruts complets
   • SMART (défaut) — filtré : supprime IPs blocklist + scans répétitifs
   • SIGNAL ONLY — uniquement alertes et événements CrowdSec

2. Indicateur de débruitage : badge "X% noise filtered" calculé en temps réel

3. Option "Show suppressed" : accordéon permettant de voir les entrées filtrées en gris/opacité réduite

Tests de validation

• Mode SMART : les logs ne contiennent plus d'entrées provenant d'IPs dans secubox_blocklist
• Indicateur de débruitage affiche un pourcentage cohérent (> 0% si blocklist active)
• Mode RAW : tous les logs originaux visibles
• Mode SIGNAL ONLY : uniquement les entrées contenant les keywords définis
• Performance : filtrage < 500ms pour 10000 entrées de logs

---

ÉVOLUTION #4 — Module SIEM Connector pour cibles x86 (Priorité BASSE/CONDITIONNELLE)

Problème adressé

SecuBox supporte officiellement x86-64 (PC, VM, Proxmox). Sur ces cibles, Wazuh XDR Agent est déployable — SysWarden l'automatise complètement. SecuBox n'a aucun équivalent.

Condition d'activation

Ce module est conditionnel : activable uniquement sur cibles x86-64 et x86-generic. Les Makefiles des autres architectures doivent exclure ce paquet via DEPENDS += @TARGET_x86.

Nouveau module à créer : luci-app-siem-connector

Structure :

luci-app-siem-connector/
├── Makefile                    # DEPENDS += @TARGET_x86 || @TARGET_x86_64
├── README.md
├── htdocs/luci-static/resources/
│   ├── view/siem/
│   │   ├── setup.js           # Wizard de déploiement Wazuh Agent
│   │   └── status.js          # Status et métriques de l'agent
│   └── siem/
│       └── dashboard.css
└── root/
    ├── etc/config/siem_connector
    └── usr/
        ├── libexec/rpcd/siem_connector
        └── sbin/
            └── wazuh-deploy.sh  # Pattern SysWarden : déploiement automatisé agent

Spécifications wazuh-deploy.sh

Portage du module Wazuh de SysWarden pour OpenWrt x86 :

#!/bin/sh
# wazuh-deploy.sh — SecuBox SIEM Connector
# Déploiement automatisé Wazuh Agent (pattern SysWarden)
# Cible: OpenWrt x86 uniquement

MANAGER_IP=""
AGENT_NAME=""
AGENT_GROUP="secubox"

install_wazuh_agent() {
    # Détection OS (OpenWrt = Linux, paquet via opkg si disponible en feed)
    if command -v opkg >/dev/null 2>&1; then
        # Installation depuis feed optionnel ou package manuel
        opkg update
        opkg install wazuh-agent 2>/dev/null || {
            # Fallback: téléchargement direct (pattern SysWarden repo detection)
            local arch
            arch=$(uname -m)
            local pkg_url="https://packages.wazuh.com/4.x/apt/pool/main/w/wazuh-agent/"
            # ... logique de téléchargement selon architecture
        }
    fi
}

configure_agent() {
    local ossec_conf="/var/ossec/etc/ossec.conf"
    cat > "$ossec_conf" << EOF
<ossec_config>
  <client>
    <server>
      <address>${MANAGER_IP}</address>
      <port>1514</port>
      <protocol>tcp</protocol>
    </server>
    <config-profile>${AGENT_GROUP}</config-profile>
  </client>
</ossec_config>
EOF
}

whitelist_wazuh_in_secubox() {
    # Pattern SysWarden : whitelister les ports Wazuh dans ipblocklist
    echo "$MANAGER_IP" >> /etc/ipblocklist/whitelist.txt
    # Règle firewall pour permettre 1514/1515 vers le manager
    uci add firewall rule
    uci set firewall.@rule[-1].name='Allow-Wazuh-Manager'
    uci set firewall.@rule[-1].dest_ip="$MANAGER_IP"
    uci set firewall.@rule[-1].dest_port='1514 1515'
    uci set firewall.@rule[-1].target='ACCEPT'
    uci commit firewall
    /etc/init.d/firewall restart
}

Interface LuCI — Wizard de déploiement

Wizard en 4 étapes (inspiré de l'interactivité de SysWarden) :

1. Prérequis : vérification architecture x86, connexion réseau vers manager IP
2. Configuration : champs Manager IP, Agent Name, Group
3. Déploiement : progress bar, log en temps réel
4. Vérification : statut agent (actif/inactif), test de connexion vers manager

Tests de validation

• Le Makefile exclut correctement le paquet sur architectures non-x86 (DEPENDS += @TARGET_x86)
• Wizard étape 1 : détecte et bloque l'installation si architecture incompatible
• Post-déploiement : wazuh-agent en statut active dans System Hub
• Whitelisting automatique : l'IP manager présente dans /etc/ipblocklist/whitelist.txt
• Port 1514/1515 : règle UCI firewall créée et visible dans LuCI

---

Plan de Séquencement et Interdépendances

Semaine 1-2 : ÉVOLUTION #1 (luci-app-ipblocklist)
  ↓ fournit ipset "secubox_blocklist" utilisé par #3
  
Semaine 2-3 : ÉVOLUTION #2 (AbuseIPDB dans crowdsec-dashboard)
  ↓ indépendant, peut être parallélisé avec #1
  
Semaine 3-4 : ÉVOLUTION #3 (Log Denoising dans system-hub)
  ↓ dépend de #1 pour le filtrage par ipset
  
Semaine 5+  : ÉVOLUTION #4 (SIEM Connector x86)
  ↓ conditionnel, dépend de #1 pour le whitelisting

---

Conventions de Développement SecuBox à Respecter

Toutes les évolutions doivent respecter les conventions identifiées dans CLAUDE.md du repo secubox-openwrt :

Style Shell (RPCD backends)

• POSIX sh uniquement (pas bash), compatible BusyBox OpenWrt
• Toutes les fonctions documentées avec commentaire d'en-tête
• Gestion d'erreurs via || true pour les commandes non-critiques
• Log systématique dans /var/log/<module>.log
• Usage de uci pour toute configuration persistante

Style JavaScript (LuCI views)

• Réutiliser les classes CSS existantes de luci-app-crowdsec-dashboard pour la cohérence visuelle (dark cybersecurity theme)
• Utiliser L.ui.showModal() pour les confirmations destructives
• Auto-refresh via setInterval avec intervalle configurable (défaut 30s)
• Gestion des erreurs : afficher message d'erreur inline, pas d'alert() natif

Structure Makefile

include $(TOPDIR)/rules.mk
PKG_NAME:=luci-app-XXXX
PKG_VERSION:=1.0.0
PKG_RELEASE:=1
PKG_MAINTAINER:=Gandalf <gandalf@cybermind.fr>
PKG_LICENSE:=Apache-2.0
include $(INCLUDE_DIR)/package.mk
include $(TOPDIR)/feeds/luci/luci.mk
LUCI_TITLE:=SecuBox XXXX — Description courte
LUCI_DEPENDS:=+dep1 +dep2
$(eval $(call BuildPackage,$(PKG_NAME)))

ACL JSON (permissions RPCD)

{
  "luci-app-XXXX": {
    "description": "Grant access to SecuBox XXXX",
    "read": { "uci": ["XXXX"], "file": {"/var/log/XXXX.log": ["read"]} },
    "write": { "uci": ["XXXX"] }
  }
}

---

Critères de Validation Globaux (pour CI/CD)

Les GitHub Actions existantes (build-openwrt-packages.yml, test-validate.yml) doivent passer pour chaque évolution :

# Lint shell
shellcheck luci-app-*/root/usr/libexec/rpcd/*
shellcheck luci-app-*/root/usr/sbin/*.sh

# Lint JSON
for f in luci-app-*/root/usr/share/luci/menu.d/*.json; do
    jsonlint "$f" && echo "OK: $f" || echo "FAIL: $f"
done
for f in luci-app-*/root/usr/share/rpcd/acl.d/*.json; do
    jsonlint "$f" && echo "OK: $f" || echo "FAIL: $f"
done

# Validation Makefiles
for pkg in luci-app-ipblocklist luci-app-siem-connector; do
    make package/${pkg}/compile V=s ARCH=x86_64 OPENWRT_VERSION=23.05.5
done

# Tests fonctionnels (nécessitent environnement OpenWrt)
./secubox-tools/secubox-debug.sh luci-app-ipblocklist
./secubox-tools/secubox-debug.sh luci-app-siem-connector

---

Référentiel ANSSI CSPN — Mapping des Évolutions

Évolution	Critère CSPN adressé
#1 ipblocklist	Contrôle d'accès réseau / Filtrage préventif
#2 AbuseIPDB reporter	Journalisation / Partage d'information sur incidents
#3 Log denoising	Journalisation / Détection d'événements pertinents
#4 SIEM connector	Supervision / Remontée d'alertes vers SIEM

---

Document généré par analyse croisée gkerma/syswarden × gkerma/secubox-openwrt
CyberMind.FR — Usage interne — Style OPORD confidentiel