🧠 Machine Learning appliqué aux données textuelles de cybersécurité

Classes de classification typiques

Architecture logique d’une plateforme de classification d’attaques web

[Nginx / Apache / WAF / CDN]
        │
        ▼
[Log collector] ──► [Parser HTTP] ──► [Normalizer]
        │                              │
        │                              ▼
        │                       [Feature store]
        │                              │
        ▼                              ▼
[SIEM / Data Lake]             [ML classifier API]
        │                              │
        ▼                              ▼
[Analyst Dashboard] ◄── alerts / labels / confidence / explanation

Cette architecture permet d’avoir une boucle complète : collecte, classification, explication, feedback analyste, ré-entraînement et supervision de la dérive.

Nettoyer sans détruire les signaux d’attaque

La normalisation est délicate : trop faible, le modèle apprend des variantes inutiles ; trop forte, on efface les indices de compromission.

from urllib.parse import unquote_plus
import re

def normalize_http_text(value: str) -> str:
    value = unquote_plus(value or "")
    value = value.replace("\x00", " ")
    value = re.sub(r"\s+", " ", value)
    return value.strip()

Éviter les faux bons scores

Un modèle peut afficher un F1-score spectaculaire tout en étant inutile en production s’il a appris des artefacts de dataset plutôt que des signaux d’attaque.

Features spécialisées cyber

def security_features(text: str) -> dict:
    lower = text.lower()
    return {
        "len": len(text),
        "special_ratio": sum(not c.isalnum() for c in text) / max(len(text), 1),
        "url_encoding_count": lower.count("%"),
        "sql_keywords": sum(k in lower for k in ["select", "union", "where", "sleep"]),
        "xss_markers": sum(k in lower for k in ["
            

Combiner texte vectorisé et features numériques

Le meilleur compromis industriel est souvent hybride : TF-IDF char n-grams pour le signal textuel + features numériques de sécurité pour stabiliser la décision.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC

features = ColumnTransformer([
    ("text", TfidfVectorizer(analyzer="char", ngram_range=(3, 5)), "normalized_text"),
    ("num", StandardScaler(), ["len", "special_ratio", "url_encoding_count"]),
])

model = Pipeline([
    ("features", features),
    ("clf", LinearSVC(class_weight="balanced"))
])

Pièges fréquents

• Tokenisation NLP standard : souvent mauvaise pour des payloads où la ponctuation est le signal principal.
• Suppression de caractères spéciaux : détruit la différence entre requête légitime et injection.
• Stemming / lemmatisation : peu utile et parfois destructeur sur logs techniques.
• Features uniquement lexicales : insuffisant contre la mutation, l’encodage et le bruit applicatif.
• Features trop expertes : peuvent surapprendre des signatures connues et rater des variantes.

Architecture ensemble robuste

Un ensemble permet de combiner la précision des règles fortes, la robustesse des n-grams, l’expressivité des features expertes et la compréhension contextuelle d’un modèle profond.

Recommandation pragmatique

Signaux Cross-Site Scripting

Le plus difficile : reconnaître le normal

La classe LEGITIMATE n’est pas une poubelle. Elle doit couvrir les vrais usages métier : recherche, formulaires, back-office, APIs JSON, éditeurs HTML, exports, filtres avancés, contenu utilisateur.

Pourquoi le split aléatoire ne suffit pas

En cybersécurité, les campagnes d’attaque arrivent par vagues. Un split aléatoire peut mettre le même payload ou la même campagne dans train et test, ce qui gonfle artificiellement les scores.

Versionner tout ce qui influence le résultat

• Code de normalisation.
• Vectorizer TF-IDF / tokenizer.
• Modèle entraîné.
• Mapping labels.
• Seuils de décision.
• Dataset hash, date, source, distribution des classes.
• Rapport métriques et matrice de confusion.

model_artifact/
  model.joblib
  vectorizer.joblib
  label_mapping.json
  thresholds.json
  metrics.json
  train_manifest.json
  normalization_version.txt

Lire une matrice de confusion en sécurité

La matrice ne sert pas seulement à vérifier un score global. Elle révèle les confusions dangereuses : SQLi classée légitime, XSS classé contenu HTML normal, scanner classé trafic humain.

from sklearn.metrics import classification_report, confusion_matrix

pred = model.predict(X_test)
print(classification_report(y_test, pred, digits=3))
print(confusion_matrix(y_test, pred, labels=[
    "LEGITIMATE", "SQL_INJECTION", "XSS", "COMMAND_INJECTION"
]))

Coût des erreurs

Validation par jeux de tests adversariaux contrôlés

• Payloads encodés URL une ou deux fois.
• Variations de casse, espaces, commentaires, caractères Unicode.
• Longue query string contenant un signal malveillant faible.
• Trafic légitime contenant HTML/SQL/shell dans un contexte documentaire.
• Requêtes multi-paramètres où seul un champ est suspect.

Explication simple avec modèle linéaire

Avec TF-IDF + Logistic Regression, les poids du modèle permettent d’identifier les n-grams associés à chaque classe.

def top_class_terms(vectorizer, classifier, class_name, n=20):
    class_id = list(classifier.classes_).index(class_name)
    weights = classifier.coef_[class_id]
    names = vectorizer.get_feature_names_out()
    top = weights.argsort()[-n:][::-1]
    return [(names[i], float(weights[i])) for i in top]

Format d’alerte SOC recommandé

{
  "prediction": "SQL_INJECTION",
  "confidence": 0.992,
  "action": "alert_high",
  "evidence": ["union", "select", "--", "%27"],
  "field": "query_string",
  "route": "/search",
  "source_ip_risk": "medium",
  "waf_rule": "crs-942100",
  "model_version": "webattack-clf-2026.07.1"
}

Boucle de feedback

• L’analyste confirme ou corrige la classe.
• Le système stocke l’échantillon, l’explication et la version du modèle.
• Les corrections alimentent un buffer de ré-entraînement.
• Les faux positifs critiques déclenchent une revue de seuil ou de feature.

feedback = {
  "request_id": "req_20260706_001",
  "model_prediction": "XSS",
  "analyst_label": "LEGITIMATE",
  "reason": "CMS editor allows HTML for admin role",
  "priority": "high"
}

Stratégies de robustesse

• Normalization ensemble : prédire sur version brute, décodée, nettoyée et segmentée.
• Data augmentation défensive : variantes contrôlées sur données d’entraînement.
• Hybridation règles + ML : les règles fortes capturent certains invariants.
• Détection de faible confiance : orienter vers revue humaine.
• Monitoring de drift : observer l’apparition de nouveaux tokens et patterns.

def predict_robust(model, raw_text):
    variants = [
        raw_text,
        normalize_http_text(raw_text),
        normalize_http_text(normalize_http_text(raw_text)),
        suspicious_window(raw_text)
    ]
    scores = [model.predict_proba([v])[0] for v in variants]
    return aggregate_scores(scores)

Surveiller la dérive

La dérive peut venir du trafic légitime qui change, de nouvelles routes applicatives, d’une campagne de scan, d’un nouveau framework JS ou de techniques d’attaque émergentes.

Garde-fous production

• Mode shadow avant blocage réel.
• Blocage seulement si modèle + règle forte + seuil haut.
• Allow-list contextuelle pour routes métier connues.
• Rollback rapide du modèle si faux positifs massifs.
• Journaliser version modèle, seuils et explication à chaque décision.

Budget de latence

Intégration dans un dashboard Django

# views.py - exemple simplifié
from django.http import JsonResponse

@require_POST
def classify_payload(request):
    raw = request.POST.get("payload", "")
    result = cyber_ml_classifier.predict(raw)
    return JsonResponse({
        "label": result.label,
        "confidence": result.confidence,
        "evidence": result.evidence,
        "action": result.action,
    })

Le résultat peut alimenter une modale d’explication, un tableau de logs, un score de risque ou une action de quarantaine.

Tracer chaque décision

Pipeline CI/CD modèle

• Tests sur payloads connus et faux positifs historiques.
• Validation des métriques minimales par classe.
• Comparaison nouveau modèle vs modèle production.
• Déploiement shadow avant activation.

Monitoring production

Plan de rollback

• Conserver les deux dernières versions stables en mémoire ou stockage local.
• Séparer version modèle et seuils de décision.
• Activer un kill-switch pour repasser en mode alerte seule.
• Tracer la cause : métrique, incident, faux positif, erreur API.

if incident.fp_rate_high or api_error_rate > 0.02:
    deployment.set_mode("shadow")
    deployment.activate_model("previous_stable")
    notify_soc("ML classifier rollback executed")

Complémentarité WAF + ML

Dashboard analyste

• Liste des requêtes classées avec filtre par classe et confiance.
• Vue détail : payload, champ, route, tokens importants.
• Historique IP/session : nombre de hits, pays, ASN, user-agent.
• Boutons feedback : correct / incorrect / classe réelle.
• Export CSV/JSON pour investigation.

Actions recommandées par classe

Rétention et minimisation

• Stocker le payload brut uniquement si nécessaire à l’investigation.
• Préférer hash + fragments explicatifs lorsque possible.
• Définir une durée de conservation par type de donnée.
• Séparer logs opérationnels, dataset d’entraînement et preuves incident.
• Documenter les bases légales et les finalités.

Protéger le modèle

• Limiter l’accès à l’API de prédiction.
• Rate-limit pour éviter l’extraction comportementale du modèle.
• Journaliser les requêtes de classification.
• Ne pas exposer les poids ou les features complètes à des utilisateurs non autorisés.
• Signer les artifacts modèle et contrôler leur intégrité.

Auditabilité

audit_record = {
  "decision_id": "mlsec-20260706-0001",
  "timestamp": "2026-07-06T10:15:00Z",
  "input_hash": "sha256:...",
  "model_version": "2026.07.1",
  "threshold_policy": "prod-high-sensitivity-v3",
  "prediction": "SQL_INJECTION",
  "confidence": 0.992,
  "action": "alert_high"
}

Modules à prévoir

Dashboard attendu

• Carte globale : nombre de requêtes analysées, attaques détectées, taux de confiance moyen.
• Répartition par classe : SQLi, XSS, Command Injection, Legitimate.
• Table des événements avec filtres par classe/seuil/IP/route.
• Modale détail : texte brut, normalisé, prédiction, évidence, action.
• Bouton feedback pour corriger le label.

Ce qu’il faut documenter

• Problème traité et contexte cybersécurité.
• Classes de menace et exemples de signaux.
• Pipeline ML : normalisation, features, modèle, métriques.
• Résultats : matrice de confusion, faux positifs, limites.
• Architecture : API, dashboard, intégration SIEM/WAF possible.
• Gouvernance : anonymisation, versioning, monitoring.

Formulations CV

• Conception d’un pipeline de classification ML/NLP pour détecter les attaques web dans des logs HTTP et WAF.
• Feature engineering avancé sur payloads textuels : char n-grams, TF-IDF, signaux d’encodage, tokens SQL/JS/shell et métriques de suspicion.
• Classification multi-classes : trafic légitime, SQL Injection, XSS, Command Injection, path traversal et scans automatisés.
• Évaluation orientée cybersécurité : recall par classe critique, faux positifs métier, matrice de confusion et tests adversariaux.
• Industrialisation MLOps : versioning modèle, API d’inférence, monitoring de drift, feedback analyste et intégration SIEM/WAF.

Questions possibles en entretien

Positionnement senior

• Ne pas vendre seulement un modèle, mais une capacité complète de détection exploitable.
• Insister sur le compromis sécurité / faux positifs / latence / explicabilité.
• Relier ML à SOC, SIEM, WAF, dashboard et remédiation.
• Montrer une compréhension des attaques, pas uniquement des algorithmes.
• Parler de monitoring et de dérive : un modèle cyber n’est jamais fini.