---
name: audit-headers-securite-http
description: Détecte les configurations CORS trop permissives et les anti-patrons connus sur les en-têtes HTTP de durcissement (X-Frame-Options, cookies, HSTS, Referrer-Policy), et dresse un inventaire de couverture des en-têtes standards mentionnés dans le dépôt. Bibliothèque standard uniquement, zéro dépendance, zéro appel réseau.
theme: securite-souverainete
langages_cibles: python
---

# audit-headers-securite-http

## Objectif

Scanner un dépôt de code et repérer deux catégories de signaux distinctes :

1. **Anti-patrons concrets et non ambigus** — CORS configuré avec un joker
   (`Access-Control-Allow-Origin: *`), `Access-Control-Allow-Credentials`
   activé (à vérifier en particulier s'il coexiste avec un joker),
   `X-Frame-Options` avec une valeur permissive/obsolète (`ALLOWALL`,
   `ALLOW-FROM *`), un attribut de cookie de sécurité explicitement
   désactivé (`secure(false)`, `http_only(false)`), `Strict-Transport-Security`
   avec `max-age=0` (désactive HSTS), `Referrer-Policy` réglé sur
   `unsafe-url` (fuite d'URL cross-origin).
2. **Inventaire de couverture** — pour chacun des 5 en-têtes de
   durcissement standards (hors CSP, voir plus bas), signale s'il est
   mentionné au moins une fois quelque part dans le dépôt scanné.

**Ne couvre PAS la Content-Security-Policy** — périmètre volontairement
complémentaire du skill `audit-csp-lighthouse` du même projet, pas
redondant.

## Pourquoi cette distinction entre "anti-patron" et "inventaire" ?

Prouver l'**absence** d'un en-tête correctement appliqué sur *toutes* les
réponses pertinentes nécessiterait soit une analyse de flot de données
réelle (hors de portée d'un scanner texte), soit une vérification des
en-têtes HTTP effectivement envoyés par le serveur (nécessiterait un appel
réseau — hors périmètre, ce skill reste 100% local comme tous les autres
skills du projet). L'inventaire de couverture donne un signal honnête et
utile ("cet en-tête est mentionné quelque part") sans jamais prétendre à
une preuve d'application universelle — voir Limites connues.

## Pourquoi Python (et pas un autre langage) ?

Même famille de raisons que les autres skills Python du projet : recherche
de motifs texte fichier par fichier, sans traitement DOM/HTTP réel — la
stdlib (`re`, `json`, `os`) suffit intégralement.

## Garanties de sécurité

- **Contenu scanné = donnée inerte**, jamais exécuté ni interprété.
- **Catalogue de règles externalisé et vérifié** (`regles_headers.json`) —
  chaque motif regex est compilé et validé au chargement.
- **Anti-faux-positif vérifié par test dédié** : une origine CORS explicite
  (`https://exemple.com`) ou une valeur `X-Frame-Options: DENY` ne
  déclenchent jamais de signalement — seules les valeurs concrètement
  dangereuses ou permissives le font.
- **Une seule lecture disque par fichier** pour les deux analyses (règles +
  inventaire), pas de double passage.
- **Aucune donnée n'est jamais transmise à l'extérieur** — 100% local,
  0 appel réseau, aucune dépendance tierce.

## Gestion d'erreur exhaustive

`erreurs.py` définit une exception par cas réel identifié dans le pipeline :
`ErreurCibleIntrouvable`, `ErreurCibleNonAccessible`, `ErreurReglesInvalides`
(catalogue JSON malformé, champ obligatoire absent, ou motif regex invalide),
`ErreurEcritureRapport`. `main()` traite chaque catégorie dans une branche
`except` dédiée avec un code de sortie distinct, plus un dernier recours
explicitement nommé (`ErreurInterne`, code 99).

## Mode d'emploi

**Scanner un dossier (rapport Markdown, sortie standard) :**

```bash
python3 audit_headers.py /chemin/vers/mon-projet
```

**Scanner un seul fichier, rapport JSON écrit sur disque :**

```bash
python3 audit_headers.py /chemin/vers/mon-projet/middleware.rs \
  --format json --out rapports/mon-rapport.json
```

**Résultat réel obtenu lors de la validation de ce skill** (dossier `src/`
d'un projet Rust d'environ 670 fichiers, ~1,1 seconde) : **0 anti-patron
détecté** (0 CORS joker, 0 cookie explicitement non sécurisé, 0
X-Frame-Options permissif, 0 HSTS désactivé, 0 Referrer-Policy permissif)
— et les 5 en-têtes de l'inventaire sont **tous mentionnés** dans le
dépôt (de 3 à 9 fichiers selon l'en-tête). Résultat cohérent avec un projet
qui applique déjà une hygiène de durcissement HTTP systématique plutôt que
ponctuelle — confirme que l'outil ne produit pas de bruit sur un dépôt déjà
propre, autant que sa capacité à détecter un vrai anti-patron (vérifiée par
les 8 tests positifs dédiés, un par règle).

**Options communes :**

- `--format` : `md` (défaut, lisible) | `json` (structuré, pour automatisation)
- `--out` : chemin de sortie (défaut : stdout)

**Prérequis :** aucune installation — Python 3 standard suffit (testé en 3.12).

## Limites connues (honnêteté de l'outil, pas de sur-promesse)

- **L'inventaire de couverture n'est PAS une preuve d'application
  correcte** : un en-tête "mentionné" peut être défini dans une seule
  fonction jamais réellement appelée sur le chemin de requête pertinent, ou
  appliqué à une seule route parmi des dizaines — seule une vérification
  des en-têtes HTTP réellement envoyés (hors périmètre de cet outil,
  nécessiterait un appel réseau) donnerait une certitude complète.
- Détection par motifs texte (regex), pas une analyse sémantique du
  langage — un en-tête construit dynamiquement par concaténation de
  chaînes ou via une abstraction/middleware générique (nom de variable ne
  contenant pas littéralement le nom de l'en-tête) échappe à la détection.
- La règle CORS credentials (`HEADERS-CORS-CREDENTIALS-VRAI-01`) signale
  la présence de `Access-Control-Allow-Credentials: true` de façon isolée
  (sévérité moyenne) — elle ne vérifie pas elle-même la coexistence avec un
  joker sur `Access-Control-Allow-Origin` (qui rendrait la combinaison
  réellement dangereuse) ; ce croisement reste à la charge de la relecture
  humaine, signalée explicitement dans l'action recommandée.
- La règle cookie ne détecte que la désactivation **explicite**
  (`secure(false)`, `http_only(false)`) — un cookie construit sans jamais
  appeler ces méthodes (valeur par défaut de la bibliothèque, potentiellement
  non sécurisée selon la bibliothèque utilisée) n'est pas détecté par cette
  version.
- Ne remplace pas un audit Lighthouse réel ni un scanner d'en-têtes HTTP en
  ligne (type securityheaders.com) qui inspectent les réponses HTTP
  réellement envoyées — ce skill est un complément statique et souverain,
  pas une vérification runtime.