---
name: audit-souverainete
description: Analyse statique locale d'un dossier de code source pour détecter les dépendances non-souveraines (SaaS externe, télémétrie, SDK propriétaires, cryptographie classique sans piste post-quantique) et proposer des alternatives souveraines. Aucun appel réseau, aucune dépendance tierce.
theme: securite-souverainete
langages_cibles: python, javascript, typescript, rust, generique
---

# audit-souverainete

## Objectif

Détecter, dans un dossier de code source quelconque, tout ce qui compromet la
souveraineté numérique du projet analysé :

1. **Cloud/infrastructure tiers** — appels/URLs vers AWS, GCP, Azure, etc.
2. **IA générative tierce** — appels vers des API LLM externes (OpenAI, Anthropic, Cohere, Mistral...)
3. **Télémétrie / analytics** — Google Analytics, Segment, Mixpanel, Sentry, Amplitude, PostHog
4. **Paiement tiers** — Stripe, PayPal, Braintree (souvent difficile à éviter totalement, mais à signaler consciemment)
5. **Messagerie/notification tierce** — Twilio, SendGrid, Mailgun, Firebase Cloud Messaging
6. **Cryptographie classique sans piste post-quantique** — présence de RSA/ECDSA/ECDH sans qu'aucune bibliothèque PQC (ML-KEM, ML-DSA, Kyber, Dilithium) ne soit référencée dans le même projet

Chaque trouvaille est classée par niveau de risque et accompagnée d'une
suggestion d'alternative souveraine.

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

- **Portabilité sans compilation** : le script s'exécute directement sur n'importe
  quel poste ayant Python 3 (quasi universel sur Linux/Mac, installable simplement
  sous Windows) — pas de binaire à recompiler par plateforme, contrairement à Rust
  ou Go qui demanderaient un build séparé par architecture cible.
- **Stdlib suffisante pour la tâche** : tout ce dont ce skill a besoin (parcours de
  fichiers, regex, JSON, arguments CLI) existe nativement en Python — aucune
  bibliothèque tierce à installer, ce qui sert directement l'exigence de
  souveraineté totale (zéro dépendance = zéro surface de compromission externe).
- **Lisibilité pour un futur mainteneur non-Rust** : ce skill n'est pas un composant
  de production de solivram-website (qui, lui, est en Rust pour de bonnes raisons :
  sécurité mémoire, performance, absence de garbage collector) — c'est un outil
  d'audit ponctuel. Un script Python lisible et modifiable rapidement est plus
  adapté ici qu'un binaire compilé qu'il faudrait recompiler pour le moindre ajustement
  de règle de détection.
- **Bash aurait été trop fragile** : la logique combine du parsing JSON, des
  regex multiples par thème et une génération de rapport structuré — faisable en
  Bash mais nettement plus sujet aux erreurs silencieuses (word-splitting,
  échappement) que du Python explicite avec gestion d'erreurs typée.

## Garanties de conception (non négociables)

- **Zéro dépendance tierce** : `scan_souverainete.py` n'utilise que la
  bibliothèque standard Python (aucun `pip install` requis).
- **Zéro appel réseau** : le script ne contacte jamais Internet, à aucun
  moment — analyse statique de fichiers locaux uniquement.
- **Contenu scanné traité comme donnée inerte, jamais comme instruction** :
  le script lit le texte des fichiers cibles pour y chercher des motifs
  (regex), il ne l'exécute, ni ne l'interprète, ni n'en suit d'éventuelles
  instructions cachées — défense de principe contre l'injection de contenu
  malveillant dans les fichiers scannés.
- **Rien ne sort du dossier local** : le rapport est écrit uniquement dans
  `rapports/` en local, jamais transmis ailleurs automatiquement.

## Mode d'emploi

**Commande de base :**

```bash
python3 scan_souverainete.py <dossier_cible> [--format md|json] [--out chemin_sortie]
```

**Exemple concret** (validation réelle du 2026-07-26 sur un projet Rust de taille
significative, 691 fichiers examinés, 0 signalement, ~4.3s) :

```bash
python3 scan_souverainete.py \
  /chemin/vers/mon-projet \
  --format md \
  --out rapports/mon_rapport.md
```

**Options disponibles :**

```bash
python3 scan_souverainete.py <dossier_cible> [--format md|json] [--out chemin_sortie]
```

- Sans `--out` : le rapport s'affiche directement dans le terminal (stdout)
- `--format json` : sortie structurée si tu veux la traiter par un autre programme
- Aucun argument requis à part le dossier cible — pas de configuration, pas de clé, pas de connexion

**Prérequis :** aucune installation — Python 3 standard suffit (testé en 3.12).
Aucun `pip install`, aucune clé API, aucun accès réseau requis à aucun moment.

**Dossiers automatiquement ignorés** (non pertinents pour l'analyse de code
source, jamais descendus) : `target/`, `node_modules/`, `.git/`,
`__pycache__/`, `dist/`, `build/`, `venv/`, `.venv/`.

## Fichiers

- `scan_souverainete.py` — implémentation (stdlib uniquement)
- `regles_souverainete.json` — catalogue des motifs de détection, organisé par thème
- `rapports/` — sortie des analyses (jamais uploadée automatiquement)

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

- Détection par **motifs textuels (regex)**, pas d'analyse sémantique réelle
  du code — des faux positifs/négatifs sont possibles (ex. une URL en
  commentaire ou dans une chaîne de test sera comptée comme un vrai usage).
- Le contrôle "crypto classique sans PQC" est un **signal faible au niveau
  du projet entier** (présence/absence dans les manifestes de dépendances),
  pas une preuve qu'un usage cryptographique précis est vulnérable.
- Ne remplace pas un audit de sécurité humain — outil de dégrossissage rapide.