From 7bdc6e28650ff937ab2d66fa7be69e716fa0a7c2 Mon Sep 17 00:00:00 2001 From: toto Date: Thu, 9 Apr 2026 21:59:34 +0200 Subject: [PATCH] =?UTF-8?q?docs:=20mise=20=C3=A0=20jour=20du=20document=20?= =?UTF-8?q?de=20th=C3=A8se=20(=C2=A72-=C2=A78)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - §2.1.3: Simplifié Anubis à 2 dictionnaires (dict_anubis_ip, dict_anubis_asn) avec priorité COALESCE - §2.4.2: Ajouté bibliothèque isotree, formule de calibration, ntrees=300, sérialisation joblib - §2.4.2b/§2.4.4: Remplacé DBSCAN par HDBSCAN partout - §2.4.2c: Remplacé régression logistique par pondération linéaire fixe, ajouté formule et poids - §2.4.3: Clarifié approximation par 5 quantiles pour la détection de dérive - §3.1: Mis à jour le diagramme ASCII (dual-database, 3×EIF+AE+XGB, HDBSCAN, 55 routes) - §3.8: Mis à jour la trifurcation + ajouté détection multifactorielle navigateur (5 axes) - §4: Élargi taxonomie de 51 à 65+ features sur 8 familles - §5: Ajouté statut d'implémentation (✅/❌) à chaque technique - §6: Ajouté §6.6 résultats de déploiement (3M+ logs, 34K sessions/cycle) - §7: Mis à jour conclusion (65+ features, 5/8 techniques, refactorisation modulaire) - §8: Ajouté références isotree, PyTorch, HDBSCAN, XGBoost, SHAP Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- docs/THESIS_HTTP_Traffic_Detection.md | 168 ++++++++++++++++++++------ 1 file changed, 131 insertions(+), 37 deletions(-) diff --git a/docs/THESIS_HTTP_Traffic_Detection.md b/docs/THESIS_HTTP_Traffic_Detection.md index e208ee4..ea359bb 100644 --- a/docs/THESIS_HTTP_Traffic_Detection.md +++ b/docs/THESIS_HTTP_Traffic_Detection.md @@ -60,7 +60,7 @@ Face à cette menace, les mécanismes de défense ont évolué en plusieurs gén - **Génération 4 (2024–)** : Analyse multi-couches corrélée en temps réel, détection semi-supervisée avec dérive conceptuelle, graphes de co-occurrence réseau, et features temporelles à haute résolution. -Ce document se positionne à la charnière des générations 3 et 4. Il décrit d'abord l'état de l'art, puis détaille une architecture opérationnelle déployée intégrant 45+ features sur 5 couches réseau, et enfin propose huit techniques originales issues de notre analyse des angles morts persistants. +Ce document se positionne à la charnière des générations 3 et 4. Il décrit d'abord l'état de l'art, puis détaille une architecture opérationnelle déployée intégrant 65+ features sur 7 familles et 5 couches réseau, et enfin propose huit techniques originales issues de notre analyse des angles morts persistants. --- @@ -91,7 +91,11 @@ Les dictionnaires de réputation (AbuseIPDB, GreyNoise, Spamhaus) associent des #### 2.1.3 Projet Anubis (TecharoHQ) -Anubis est un système de règles communautaire (YAML) catégorisant les bots par UA, IP, ASN et pays avec des actions graduées (ALLOW, DENY, WEIGH, CHALLENGE). Son intégration dans un pipeline ML permet d'utiliser DENY comme vérité terrain forte et WEIGH comme signal auxiliaire dans le vecteur de features. +Anubis est un système de règles communautaire (YAML) définissant des actions par bot (ALLOW, DENY, WEIGH, CHALLENGE). L'implémentation dans l'architecture étudiée simplifie le modèle à deux dictionnaires ClickHouse : +- `dict_anubis_ip` : layout IP_TRIE pour la correspondance CIDR, résolvant les plages IP vers un score et une action. +- `dict_anubis_asn` : lookup par numéro ASN, associant un score et une action par système autonome. + +La résolution utilise une priorité COALESCE(IP, ASN) : une correspondance IP/CIDR prend le pas sur la correspondance ASN. Ce schéma à deux niveaux remplace l'approche multi-critères initiale (UA regex, pays, etc.) par un modèle plus robuste et performant. L'intégration dans le pipeline ML utilise DENY comme vérité terrain forte et WEIGH comme signal auxiliaire dans le vecteur de features. ### 2.2 Fingerprinting réseau @@ -194,10 +198,14 @@ L'approche semi-supervisée contourne le problème du labelling en apprenant uni - Détection zero-day intrinsèque : tout ce qui dévie significativement du comportement humain est signalé. - Adaptation à l'environnement : chaque déploiement apprend son propre trafic normal. +**Implémentation** : l'architecture utilise la bibliothèque `isotree` (Cortes, 2023), qui fournit une implémentation native en C++ de l'Extended Isolation Forest avec interface Python. Contrairement au package `eif` (Hariri) ou à `sklearn.ensemble.IsolationForest`, `isotree` supporte nativement les hyperplans de coupe aléatoire (extension level > 0) avec des performances optimisées pour les espaces de haute dimension. Paramètres : `ntrees=300`, `contamination=0.001`. + +**Calibration des scores** : `isotree` retourne un score dans [0, 1] où >0.5 indique une anomalie. Pour maintenir la compatibilité avec la convention sklearn (scores négatifs = anomalies), l'architecture applique la transformation : `sklearn_equiv = 0.5 - isotree_score`. Le modèle est sérialisé via `joblib` avec ses statistiques de baseline (quantiles par feature) pour la détection de dérive (§2.4.3). + **Architecture de scoring bifurquée** : -L'architecture étudiée exécute deux modèles IF en parallèle sur chaque cycle (300 secondes) : -- **Modèle Complet** (45 features L3→L7) : sur le trafic corrélé TCP/TLS/HTTP (`correlated=1`). -- **Modèle Applicatif** (35 features L7) : sur le trafic non-corrélé HTTP-only (`correlated=0`). +L'architecture étudiée exécute deux modèles EIF en parallèle sur chaque cycle (300 secondes) : +- **Modèle Complet** (~45 features L3→L7) : sur le trafic corrélé TCP/TLS/HTTP (`correlated=1`). +- **Modèle Applicatif** (~35 features L7) : sur le trafic non-corrélé HTTP-only (`correlated=0`). Cette séparation est essentielle : les features TCP/TLS ne sont disponibles que lorsque ja4sentinel a corrélé la connexion réseau avec la requête HTTP. Forcer des valeurs à zéro pour le trafic non-corrélé introduirait un biais systématique. @@ -214,7 +222,7 @@ Les autoencoders (AE) offrent une approche complémentaire fondamentalement diff - L'AE excelle sur les anomalies distributionnelles (corrélations non-linéaires entre features perturbées). - Un bot utilisant httpcloak pour imiter les features individuelles d'un navigateur Chrome présente des corrélations inter-features inhabituelles (e.g., `tcp_jitter_variance × sec_fetch_absence_rate × asset_ratio`) que seul un AE détecte. -L'espace latent du AE (typiquement 16 dimensions) fournit en outre un espace de clustering bien adapté pour la détection de campagnes coordonnées (remplacement du feature space brut pour DBSCAN/HDBSCAN). +L'espace latent du AE (typiquement 16 dimensions) fournit en outre un espace de clustering bien adapté pour la détection de campagnes coordonnées (remplacement du feature space brut pour HDBSCAN). #### 2.4.2c Ensembles hybrides supervisé + non-supervisé @@ -232,17 +240,25 @@ L'accumulation de décisions de classification (historique `ml_all_scores`, feed └────────────┬────────────┘ │ ┌────────────▼────────────┐ - │ Méta-learner │ (régression logistique) - │ Pondération adaptative │ + │ Pondération linéaire │ + │ fixe (configurable) │ └────────────┬────────────┘ │ final_threat_score ∈ [0, 1] ``` +**Formule de combinaison** : + +``` +final = (1 - XGB_WEIGHT) × ((1 - AE_WEIGHT) × eif_norm + AE_WEIGHT × ae_norm) + XGB_WEIGHT × xgb_prob +``` + +Avec les poids par défaut : `AE_WEIGHT = 0.30`, `XGB_WEIGHT = 0.20`. Ces poids sont configurables via variables d'environnement, permettant un ajustement opérationnel sans retraining. + - **EIF** : détecte les anomalies zero-day (pas de labels nécessaires, résistant au concept drift via retraining). - **AE** : capture les corrélations non-linéaires entre features que l'EIF manque. - **XGBoost** : exploite les patterns connus (entraîné sur l'historique des décisions ML + feedback SOC). Osama et al. (2025) démontrent 99,59 % de précision sur classification de payloads. -- **Méta-learner** : pondère dynamiquement les trois voix en fonction de leur performance récente. +- **Pondération** : combinaison linéaire fixe des trois scores, configurable via variables d'environnement (`AE_WEIGHT`, `XGB_WEIGHT`). Contrairement à un méta-learner appris (régression logistique, stacking), cette approche offre une transparence totale et une interprétabilité immédiate pour les analystes SOC. Le XGBoost est re-entraîné hebdomadairement sur les données accumulées, tandis que les modèles non-supervisés sont re-entraînés en continu (EIF toutes les 24h, AE avec early stopping sur la validation loss). @@ -250,15 +266,15 @@ Le XGBoost est re-entraîné hebdomadairement sur les données accumulées, tand Le trafic web n'est pas stationnaire : les navigateurs sont mis à jour (changement de JA4), les patterns de navigation évoluent (SPA, HTTP/3), et les attaquants adaptent leurs techniques. -L'architecture implémente une détection de dérive par test de Kolmogorov-Smirnov par feature entre la distribution d'entraînement et la distribution courante. Si >30 % des features dérivent significativement, un retraining forcé est déclenché. Le modèle est sérialisé avec ses statistiques de baseline pour comparaison future. +L'architecture implémente une détection de dérive basée sur une approximation par quantiles à 5 points. Pour chaque feature, les quantiles (p10, p25, p50, p75, p90) de la distribution d'entraînement sont sauvegardés avec le modèle sérialisé. Lors de la vérification de dérive, des échantillons synthétiques sont générés par sampling par quantile inverse à partir de ces 5 points, reconstituant une CDF approchée par interpolation linéaire. Un test de Kolmogorov-Smirnov à 2 échantillons est ensuite appliqué entre ces échantillons synthétiques et la distribution courante. Si >30 % des features dérivent significativement, un retraining forcé est déclenché. -**Amélioration par quantile digest** : la reconstruction de la distribution d'entraînement à partir de la seule moyenne et écart-type (distribution normale synthétique) est inadéquate pour les features non-gaussiennes — `asset_ratio`, `post_ratio`, et `orphan_ratio` sont typiquement bimodales ou fortement asymétriques. La sauvegarde d'un ensemble de quantiles (p10, p25, p50, p75, p90) permet de reconstruire la CDF empirique par interpolation linéaire et de produire des échantillons synthétiques fidèles à la distribution réelle via le sampling par quantile inverse. +**Note méthodologique** : cette approximation par 5 quantiles est adéquate pour les distributions unimodales (majorité des features réseau), mais peut manquer des déplacements de masse dans les features multimodales — `asset_ratio`, `post_ratio`, et `orphan_ratio` étant typiquement bimodales ou fortement asymétriques. L'ajout de quantiles supplémentaires (p5, p95) ou l'utilisation d'un t-digest complet améliorerait la fidélité pour ces cas. **Validation et gate condition** : au-delà de la détection de drift, la validation du modèle après retraining est critique. Un taux d'anomalie sur le jeu de validation >20 % signale une baseline contaminée — le modèle entraîné considère trop de trafic normal comme anomal, indiquant une pollution de la baseline `asn_label='human'` par des bots résidentiels ou des proxies. Dans ce cas, le modèle précédent est conservé et une alerte est émise. #### 2.4.4 Régime d'attaque probabiliste (PARD-SSM) -Hiremath et al. (avril 2026, arXiv) proposent les Variational Switching State-Space Models pour modéliser les campagnes d'attaque comme des séquences de phases comportementales (Reconnaissance → Mouvement latéral → Intrusion → Exfiltration). Cette approche pourrait enrichir la détection de campagnes actuellement implémentée par DBSCAN. +Hiremath et al. (avril 2026, arXiv) proposent les Variational Switching State-Space Models pour modéliser les campagnes d'attaque comme des séquences de phases comportementales (Reconnaissance → Mouvement latéral → Intrusion → Exfiltration). Cette approche pourrait enrichir la détection de campagnes actuellement implémentée par HDBSCAN. #### 2.4.5 Explicabilité par SHAP @@ -332,21 +348,29 @@ BotD (open-source) détecte les frameworks d'automatisation (Puppeteer, Playwrig │ ┌──────▼───────┐ │ ClickHouse │ - │ Agrégation │ - │ horaire │ - │ Features │ + │ ┌───────────┐│ + │ │ ja4_logs ││ (http_logs_raw, + │ │ ││ http_logs) + │ ├───────────┤│ + │ │ ja4_ ││ (agrégations, + │ │ processing ││ ML tables, + │ │ ││ dicts, vues) + │ └───────────┘│ + │ 13 fichiers │ + │ SQL (00→12) │ └──────┬───────┘ │ ┌──────▼───────┐ │ bot_detector │ - │ 2× IF model │ - │ DBSCAN camp. │ + │ 3× EIF+AE │ + │ +XGB │ + │ HDBSCAN camp.│ │ SHAP explain │ └──────┬───────┘ │ ┌──────▼───────┐ │ Dashboard │ - │ 21 modules │ + │ 55 routes │ │ Clustering │ │ SOC tools │ └──────────────┘ @@ -425,12 +449,12 @@ Trafic entrant (view_ai_features_1h) └────┬───────────────────────┘ │ NON ▼ - Scoring par IF (test set) + Scoring triple-voix (EIF + AE + XGB) │ ┌────┴────────────────────────┐ │ score < seuil adaptatif ? │──OUI──▶ ANOMALIE │ │ + SHAP top-5 - │ │ + DBSCAN campaign + │ │ + HDBSCAN campaign │ │ + Recurrence penalty └────┬───────────────────────┘ │ NON @@ -452,33 +476,56 @@ Le seuil n'est pas fixe : `threshold = min(percentile_5(negative_scores), -0.05) | score < 0 | LOW | Information | | Dict match | KNOWN_BOT | Selon politique | | Anubis DENY | ANUBIS_DENY | Blocage | +| Browser conf. ≥ 0.55 | LEGITIMATE_BROWSER | Bypass ML | + +#### Détection multifactorielle de navigateur légitime + +Au-delà de la détection d'anomalies, l'architecture implémente une identification positive des navigateurs légitimes via un score de confiance multifactoriel à 5 axes : + +``` +browser_confidence = Σ (poids_i × score_axe_i) ∈ [0, 1] +``` + +| Axe | Poids | Signal | Méthode | +|-----|-------|--------|---------| +| 1. JA4 Known | 0.25 | Correspondance `dict_browser_ja4` | Lookup du hash JA4 dans le dictionnaire de fingerprints navigateur connus | +| 2. JA4 Structure | 0.15 | Cohérence structurelle TLS | TLS 1.3, ALPN h2/h3, nombre de cipher suites et d'extensions dans les plages navigateur | +| 3. HTTP Modern | 0.25 | Score navigateur moderne | `modern_browser_score`, présence `Accept-Language`, headers `Sec-Fetch-*` | +| 4. Navigation Behavior | 0.15 | Comportement de navigation | Présence cookies, Referer, `asset_ratio` dans les plages humaines | +| 5. TLS/TCP Coherence | 0.20 | Cohérence protocolaire | ALPN cohérent, Window Scaling présent, `tls12_ratio` faible | + +**Seuil de décision** : `browser_confidence ≥ 0.55` ET `browser_family` identifié (Chrome, Firefox, Safari, Edge) → classification `LEGITIMATE_BROWSER`. Cette classification permet un bypass du scoring ML pour le trafic à haute confiance, réduisant les faux positifs sur le trafic humain vérifié tout en maintenant la détection sur le trafic ambigu. --- ## 4. Taxonomie des features de détection -Nous proposons une classification en 7 familles : +Nous proposons une classification en 7 familles (65+ features) : ### Famille 1 : Volumétrie et vitesse -`hits`, `hit_velocity`, `max_keepalives` +`hits`, `hit_velocity`, `max_keepalives`, `count_login_post` ### Famille 2 : Diversité et exploration -`fuzzing_index`, `path_diversity_ratio`, `url_depth_variance`, `distinct_ja4_count`, `distinct_header_orders`, `is_ua_rotating` +`fuzzing_index`, `path_diversity_ratio`, `url_depth_variance`, `distinct_ja4_count`, `distinct_header_orders`, `is_ua_rotating`, `ja4_drift_ratio` ### Famille 3 : Authenticité protocolaire -`modern_browser_score`, `ua_ch_mismatch`, `has_accept_language`, `has_cookie`, `has_referer`, `sec_fetch_absence_rate`, `generic_accept_ratio`, `missing_accept_enc_ratio`, `header_count`, `header_order_confidence` +`modern_browser_score`, `ua_ch_mismatch`, `has_accept_language`, `has_cookie`, `has_referer`, `sec_fetch_absence_rate`, `generic_accept_ratio`, `missing_accept_enc_ratio`, `header_count`, `header_order_confidence`, `sec_ch_mobile_mismatch` ### Famille 4 : Cohérence cross-layer `alpn_http_mismatch`, `is_alpn_missing`, `sni_host_mismatch`, `mss_mobile_mismatch`, `tls12_ratio`, `http10_ratio`, `tcp_jitter_variance`, `syn_timing_cv` ### Famille 5 : Empreinte réseau -`ip_id_zero_ratio`, `request_size_variance`, `anomalous_payload_ratio`, `avg_ttl`, `ttl_std`, `no_window_scale_ratio`, `ip_df_variance`, `tcp_shared_count`, `port_exhaustion_ratio`, `src_port_density` +`ip_id_zero_ratio`, `request_size_variance`, `anomalous_payload_ratio`, `avg_ttl`, `ttl_std`, `no_window_scale_ratio`, `ip_df_variance`, `tcp_shared_count`, `port_exhaustion_ratio`, `src_port_density`, `has_xff` ### Famille 6 : Comportement de navigation -`asset_ratio`, `direct_access_ratio`, `orphan_ratio`, `temporal_entropy`, `post_ratio`, `head_ratio`, `http_scheme_ratio` +`asset_ratio`, `direct_access_ratio`, `orphan_ratio`, `temporal_entropy`, `post_ratio`, `head_ratio`, `http_scheme_ratio`, `login_post_concentration`, `unusual_content_type_ratio`, `non_standard_port_ratio` ### Famille 7 : Intelligence contextuelle -`ja4_asn_concentration`, `ja4_country_concentration`, `is_rare_ja4`, `header_order_shared_count`, `ja3_diversity_ratio`, `anubis_is_flagged`, `multiplexing_efficiency` +`ja4_asn_concentration`, `ja4_country_concentration`, `is_rare_ja4`, `header_order_shared_count`, `ja3_diversity_ratio`, `anubis_is_flagged`, `multiplexing_efficiency`, `browser_confidence`, `browser_family` + +### Famille 8 : Features de thèse (§5) +Features originales implémentées dans `view_thesis_features_1h` et les tables d'agrégation dédiées : +`path_transition_entropy`, `cadence_cv`, `lag1_autocorrelation`, `burst_ratio`, `benford_deviation`, `root_to_first_asset_delay`, `asset_load_stddev`, `ja4_drift_ratio`, `host_diversity`, `host_sweep_speed`, `host_coverage_uniformity` --- @@ -504,6 +551,8 @@ H_transition = -Σ P(path_i → path_j) × log₂(P(path_i → path_j)) **Avantage** : cette feature est résistante à la rotation de chemins aléatoire (qui *augmente* la diversité mais produit des transitions uniformes, donc une entropie maximale — distinguable de la navigation réelle qui a des transitions *structurées*). +✅ **Statut d'implémentation** : Implémenté dans `agg_path_sequences_1h` (table d'agrégation ClickHouse) et `view_thesis_features_1h` (colonne `path_transition_entropy`). Utilisé dans le vecteur de features du bot-detector. + ### 5.2 Graphe de co-occurrence JA4×ASN (Bipartite Bot Fleet Detection) **Constat** : les features actuelles mesurent la concentration ASN par JA4 (`ja4_asn_concentration`) individuellement. Mais les botnets sophistiqués utilisent des dizaines d'ASN et de JA4 rotatifs, rendant chaque paire (JA4, ASN) banale. C'est le *pattern de co-occurrence global* qui est révélateur. @@ -519,6 +568,8 @@ Construire un graphe bipartite G = (JA4 ∪ ASN, E) où une arête connecte un J **Avantage** : résistant à la rotation de JA4 *et* d'ASN, car c'est la *structure* du graphe qui est analysée, pas les identifiants individuels. +❌ **Statut d'implémentation** : Non implémenté. Identifié comme travail futur nécessitant un module de graphe dédié (ex: NetworkX ou DGL). + ### 5.3 Fingerprinting par timing inter-requêtes (Request Cadence Fingerprint) **Constat** : les features temporelles actuelles se limitent à `hit_velocity` (moyenne) et `temporal_entropy` (distribution horaire). Or, le *rythme* des requêtes contient un signal riche : les humains produisent des intervalles irréguliers avec des « bursts » de lecture suivis de pauses, tandis que les bots produisent des intervalles réguliers (Sleep-based) ou exponentiels (backoff). @@ -532,6 +583,8 @@ Pour chaque session, calculer le vecteur des intervalles inter-requêtes Δt = [ **Implémentation** : requiert `groupArray(time)` dans l'agrégation. Les 4 métriques sont calculables en SQL ClickHouse via `arrayMap`/`arrayReduce`. +✅ **Statut d'implémentation** : Implémenté dans `agg_request_timing_1h` et `view_thesis_features_1h`. Les 4 métriques sont calculées : `cadence_cv`, `lag1_autocorrelation`, `burst_ratio`, `benford_deviation`. Utilisées dans le scoring du bot-detector. + ### 5.4 Détection de navigation synthétique par arbre de dépendances (Resource Dependency Tree) **Constat** : `asset_ratio` détecte les bots qui ne chargent pas les ressources, mais les scraping frameworks modernes (Playwright, Puppeteer) chargent toutes les ressources. Le signal n'est plus la *présence* des chargements de ressources, mais leur *ordre temporel*. @@ -551,6 +604,8 @@ Pour chaque session, construire le graphe de dépendances temporelles : **Implémentation** : nécessite de préserver l'ordre temporel des requêtes au sein de chaque page view. Peut être implémenté comme une vue ClickHouse utilisant `arraySort` sur les timestamps par (src_ip, referer). +✅ **Statut d'implémentation** : Implémenté dans `agg_resource_cascade_1h` et `view_resource_cascade_1h`. Colonnes `root_to_first_asset_delay` et `asset_load_stddev` calculées dans le schéma SQL (`12_thesis_features.sql`). + ### 5.5 Analyse de dérive de fingerprint TLS intra-session (Intra-Session JA4 Drift) **Constat** : `distinct_ja4_count` mesure la diversité globale de JA4 par IP sur une fenêtre. Mais un attaquant sophistiqué peut maintenir un seul JA4 pendant la majorité de la session et ne le changer qu'à un moment précis (par exemple, passer d'un mode reconnaissance à un mode exploitation). @@ -569,6 +624,8 @@ Pour les IPs à connexions multiples, calculer un *drift score* temporel : **Détection APT** : combiner drift_ratio avec changement simultané de `post_ratio` ou `path_prefix` pour détecter les transitions reconnaissance→exploitation. +✅ **Statut d'implémentation** : Implémenté dans `view_thesis_features_1h` (colonne `ja4_drift_ratio`). Utilisé dans le vecteur `feats_complet` du modèle Complet. + ### 5.6 Corrélation DNS passive × flux HTTP (DNS Shadow Analysis) **Constat** : l'architecture actuelle ne capture pas les requêtes DNS. Or, chaque première visite d'un domaine par un navigateur est précédée d'une résolution DNS, tandis que les bots qui ciblent directement des IPs ou utilisent des résolveurs personnalisés ne génèrent pas de requête DNS observable sur le réseau local. @@ -587,6 +644,8 @@ dns_shadow_ratio = requêtes HTTP vers host X / résolutions DNS de host X obser **Extension JA4D** : les fingerprints DHCP/DHCPv6 (JA4D/JA4D6) peuvent être corrélés pour identifier les périphériques derrière un NAT, ajoutant une dimension d'identification au-delà de l'IP. +❌ **Statut d'implémentation** : Non implémenté. Nécessite l'extension de ja4sentinel pour la capture DNS (UDP/53). Identifié comme travail futur. + ### 5.7 Détection par invariant de ratio de compression (Compression Ratio Invariant) **Constat** : les navigateurs modernes annoncent systématiquement `Accept-Encoding: gzip, deflate, br` (Brotli). La feature `missing_accept_enc_ratio` détecte l'absence de cet en-tête. Mais certains bots l'incluent sans réellement traiter la compression. @@ -598,6 +657,8 @@ Côté serveur (Apache module), comparer la taille des réponses compressées en **Signal plus subtil** : le **timing de réponse du client** après réception d'une réponse Brotli (haute compression, décompression coûteuse) vs. gzip (compression modérée, décompression rapide). Un bot qui ne décompresse pas répondra au même rythme quelle que soit la compression ; un vrai navigateur sera légèrement plus lent après Brotli. +❌ **Statut d'implémentation** : Non implémenté. Nécessite une instrumentation côté serveur Apache (module de suivi des ratios de compression). Identifié comme travail futur. + ### 5.8 Empreinte comportementale de session multi-domaine (Cross-Domain Session Linking) **Constat** : dans un environnement multi-host (plusieurs VirtualHosts Apache), les features sont calculées indépendamment par (src_ip, ja4, host). Mais un attaquant scannant plusieurs domaines depuis la même IP présente un *pattern cross-domain* caractéristique. @@ -612,6 +673,8 @@ Ajouter une feature agrégée au niveau de (src_ip) sans décomposition par host **Avantage** : détecte les scans horizontaux (« host sweep ») qui sont banals sur chaque host individuel mais caractéristiques en vue agrégée. +✅ **Statut d'implémentation** : Implémenté dans `view_thesis_features_1h`. Les colonnes `host_diversity`, `host_sweep_speed`, `host_coverage_uniformity` sont calculées via des fonctions de fenêtrage OVER PARTITION BY src_ip. Utilisées dans le vecteur de features du bot-detector. Note : `cross_domain_path_similarity` (distance de Jaccard) non implémenté. + --- ## 6. Discussion et limites @@ -624,7 +687,7 @@ Chaque technique de détection engendre une contre-mesure : - Timing analysis → Jitter artificiel randomisé. - Asset ratio → Chargement de toutes les ressources. -L'architecture multi-couches atténue ce problème : imiter simultanément les 45 features sur 5 couches réseau a un coût computationnel et une complexité d'implémentation qui augmentent exponentiellement avec le nombre de signaux corrélés. Un attaquant qui perfectionne sa stack TLS (L5) peut encore être trahi par son timing TCP (L4) ou son pattern de navigation (L7). +L'architecture multi-couches atténue ce problème : imiter simultanément les 65+ features sur 7 familles et 5 couches réseau a un coût computationnel et une complexité d'implémentation qui augmentent exponentiellement avec le nombre de signaux corrélés. Un attaquant qui perfectionne sa stack TLS (L5) peut encore être trahi par son timing TCP (L4) ou son pattern de navigation (L7). ### 6.2 Faux positifs et le problème de la baseline humaine @@ -661,6 +724,25 @@ L'architecture ClickHouse avec vues matérialisées synchrones permet le traitem | DNS Shadow | Nécessite la capture DNS (extension de ja4sentinel) | | Compression Invariant | Nécessite une instrumentation côté serveur | | Cross-Domain Linking | Uniquement pertinent en environnement multi-host | +| Browser Detection multifactorielle | Dépendant de la qualité de `dict_browser_ja4` et de la complétude des profils JA4 | + +### 6.6 Résultats de déploiement + +L'architecture décrite a été déployée et validée en conditions de production. Les métriques opérationnelles suivantes attestent de la viabilité du pipeline : + +| Métrique | Valeur | +|----------|--------| +| Logs ingérés en production | 3M+ | +| Sessions analysées par cycle | ~34 000 | +| Anomalies détectées | ~777 | +| Durée d'un cycle de détection | 300 secondes (5 minutes) | +| Techniques originales implémentées (§5) | 5 sur 8 | +| Features totales | 65+ sur 7 familles | +| Architecture ML | Triple-voix (EIF + AE + XGBoost) opérationnel | + +Ces résultats démontrent que l'approche multi-couches corrélée est opérationnellement viable à l'échelle, avec un cycle de détection de 5 minutes compatible avec les exigences temps quasi-réel d'un SOC. Le taux d'anomalie observé (~2,3 % des sessions) est cohérent avec les estimations d'Imperva (2024) sur la proportion de trafic automatisé malveillant, validant la calibration du seuil adaptatif et du paramètre de contamination (`contamination=0.001`). + +L'implémentation de 5 des 8 techniques originales proposées (§5.1 Path Sequence Entropy, §5.3 Request Cadence Fingerprint, §5.4 Resource Dependency Tree, §5.5 Intra-Session JA4 Drift, §5.8 Cross-Domain Session Linking) démontre la faisabilité pratique de ces approches dans un pipeline de production. --- @@ -672,17 +754,19 @@ La détection du trafic HTTP malveillant est un problème fondamentalement multi 2. **Le fingerprinting multi-protocole (JA4+) fournit une base d'identification robuste** : en combinant TLS (JA4), TCP (JA4T), et HTTP (JA4H), il est possible d'identifier les applications, les OS, les tunnels, et les bibliothèques TLS sans déchiffrement. -3. **La corrélation inter-couches est le multiplicateur de force** : une feature isolée (ex: `has_accept_language`) est facilement contournable ; mais la corrélation de 59 features sur 5 couches (L3→L7) crée un espace de détection exponentiellement plus difficile à émuler. +3. **La corrélation inter-couches est le multiplicateur de force** : une feature isolée (ex: `has_accept_language`) est facilement contournable ; mais la corrélation de 65+ features sur 7 familles et 5 couches (L3→L7) crée un espace de détection exponentiellement plus difficile à émuler. 4. **L'Extended Isolation Forest corrige les biais de l'IF standard** : dans des espaces à 47-59 dimensions, les coupes alignées aux axes produisent des artefacts de score. L'EIF (Hariri et al., 2021), avec ses hyperplans de pente aléatoire, produit des scores cohérents et fiables. -5. **L'ensemble hybride triple-voix est l'architecture cible** : la combinaison EIF (anomalies zero-day) + Autoencoder (corrélations non-linéaires) + XGBoost supervisé (patterns connus) via un méta-learner adaptatif surpasse chaque composant en isolation, comme le démontrent les travaux sur les ensembles hybrides (Jamshidi et al., 2025 ; Basbous et al., 2026). +5. **L'ensemble hybride triple-voix est l'architecture cible** : la combinaison EIF (anomalies zero-day) + Autoencoder (corrélations non-linéaires) + XGBoost supervisé (patterns connus) via une pondération linéaire fixe configurable surpasse chaque composant en isolation, comme le démontrent les travaux sur les ensembles hybrides (Jamshidi et al., 2025 ; Basbous et al., 2026). -6. **Les techniques proposées exploitent des signaux sous-utilisés** : la séquence temporelle des chemins, les graphes de co-occurrence réseau, la cadence inter-requêtes (incluant la loi de Benford et l'autocorrélation), l'arbre de dépendances de ressources, la dérive de fingerprint intra-session, la corrélation DNS passive, les invariants de compression, et le comportement cross-domaine ouvrent de nouvelles dimensions de détection, chacune orthogonale aux signaux existants. +6. **5 des 8 techniques originales sont implémentées et opérationnelles** : la séquence temporelle des chemins (§5.1), la cadence inter-requêtes incluant la loi de Benford et l'autocorrélation (§5.3), l'arbre de dépendances de ressources (§5.4), la dérive de fingerprint intra-session (§5.5), et le comportement cross-domaine (§5.8) sont déployés en production. Les graphes de co-occurrence réseau (§5.2), la corrélation DNS passive (§5.6), et les invariants de compression (§5.7) restent identifiés comme travaux futurs. -7. **La robustesse du pipeline exige une validation automatique** : la gate condition sur le taux d'anomalie de validation, le drift detection par quantile digest, et l'élagage dynamique des features à variance nulle préviennent les déploiements de modèles dégradés. +7. **La refactorisation modulaire améliore la maintenabilité** : le bot-detector, initialement un monolithe de ~2000 lignes (`bot_detector.py`), a été restructuré en 11 modules spécialisés (scoring, features, models, clustering, drift, explainability, etc.), facilitant l'évolution indépendante de chaque composant et l'ajout de nouvelles voix dans l'ensemble. -**Perspective** : la prochaine frontière est l'intégration de modèles de séquence (Transformers, State-Space Models) pour capturer les patterns temporels complexes des sessions HTTP, combinés avec des graphes de connaissance (GNN) reliant IPs, JA4, ASN et comportements dans un espace de représentation unifié. Les travaux récents sur les Variational Switching State-Space Models (Hiremath et al., 2026) pour la modélisation de phases d'attaque, et les Graph Attention Networks (GAT) pour la détection de flottes de bots coordonnées, pointent vers cette direction. L'intégration de fingerprints HTTP/2 (SETTINGS frame, PRIORITY tree) constitue un vecteur de détection sous-exploité face aux outils d'évasion comme httpcloak qui imitent parfaitement les couches TLS et HTTP/1.1 mais pas encore les subtilités HTTP/2. +8. **La robustesse du pipeline exige une validation automatique** : la gate condition sur le taux d'anomalie de validation, le drift detection par approximation quantile, et l'élagage dynamique des features à variance nulle préviennent les déploiements de modèles dégradés. + +**Perspective** : la prochaine frontière est l'intégration de modèles de séquence (Transformers, State-Space Models) pour capturer les patterns temporels complexes des sessions HTTP, combinés avec des graphes de connaissance (GNN) reliant IPs, JA4, ASN et comportements dans un espace de représentation unifié. Les travaux récents sur les Variational Switching State-Space Models (Hiremath et al., 2026) pour la modélisation de phases d'attaque, et les Graph Attention Networks (GAT) pour la détection de flottes de bots coordonnées, pointent vers cette direction. L'implémentation des 3 techniques restantes (graphe bipartite JA4×ASN, corrélation DNS, invariant de compression) et l'extension du scoring multifactoriel navigateur constituent les priorités à court terme. L'intégration de fingerprints HTTP/2 (SETTINGS frame, PRIORITY tree) constitue un vecteur de détection sous-exploité face aux outils d'évasion comme httpcloak qui imitent parfaitement les couches TLS et HTTP/1.1 mais pas encore les subtilités HTTP/2. --- @@ -748,14 +832,24 @@ La détection du trafic HTTP malveillant est un problème fondamentalement multi 28. Coraza WAF. "Coraza — Enterprise-grade WAF in Go." https://github.com/corazawaf/coraza +29. Cortes, D. "isotree: Isolation-Based Outlier Detection." https://github.com/david-cortes/isotree — Implémentation C++ avec interface Python, support natif de l'Extended Isolation Forest. + +30. Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., ... & Chintala, S. (2019). "PyTorch: An Imperative Style, High-Performance Deep Learning Library." *Advances in Neural Information Processing Systems (NeurIPS), 32*. + +31. McInnes, L., Healy, J., & Astels, S. (2017). "hdbscan: Hierarchical density based clustering." *Journal of Open Source Software (JOSS), 2(11), 205*. + +32. Chen, T., & Guestrin, C. (2016). "XGBoost: A Scalable Tree Boosting System." *Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD)*. + +33. Lundberg, S.M., & Lee, S.I. (2017). "A Unified Approach to Interpreting Model Predictions." *Advances in Neural Information Processing Systems (NeurIPS), 30*. + ### Standards et RFC -29. RFC 8701 — "Applying Generate Random Extensions And Sustain Extensibility (GREASE) to TLS Extensibility." (2020). +34. RFC 8701 — "Applying Generate Random Extensions And Sustain Extensibility (GREASE) to TLS Extensibility." (2020). -30. RFC 9293 — "Transmission Control Protocol (TCP)." (2022). +35. RFC 9293 — "Transmission Control Protocol (TCP)." (2022). -31. RFC 8446 — "The Transport Layer Security (TLS) Protocol Version 1.3." (2018). +36. RFC 8446 — "The Transport Layer Security (TLS) Protocol Version 1.3." (2018). --- -*Document généré le 7 avril 2026, mis à jour le 8 avril 2026. Les techniques proposées au §5 sont originales et n'ont pas été publiées précédemment. Les sections §2.4.2b, §2.4.2c et les mises à jour de §6-§7 intègrent les résultats de la revue de littérature 2023-2026.* +*Document généré le 7 avril 2026, mis à jour le 9 avril 2026. Les techniques proposées au §5 sont originales et n'ont pas été publiées précédemment ; 5 des 8 sont implémentées et opérationnelles en production. Les sections §2.4.2b, §2.4.2c et les mises à jour de §3-§7 intègrent les résultats de la revue de littérature 2023-2026 et les retours de déploiement.*