Dévoilez ce qui est caché avant que le monde ne le fasse

Un framework IA autonome qui enchaîne la reconnaissance, l'exploitation et la post-exploitation en un seul pipeline, puis va plus loin en triant chaque constat, en implémentant des correctifs de code et en ouvrant des pull requests sur votre dépôt. Du premier paquet au correctif fusionné, avec une supervision humaine à chaque étape critique.

AVERTISSEMENT LÉGAL : Cet outil est destiné aux tests de sécurité autorisés, à des fins éducatives et uniquement à la recherche. N'utilisez jamais ce système pour analyser, sonder ou attaquer un système que vous ne possédez pas ou pour lequel vous n'avez pas obtenu d'autorisation écrite explicite. Tout accès non autorisé est illégal et puni par la loi. En utilisant cet outil, vous acceptez l'entière responsabilité de vos actions. Lire l'avertissement complet

Trois agents IA testent en parallèle : l'un valide les politiques d'identifiants via Hydra, l'un vérifie un chemin d'exploitation CVE via une élévation de privilèges, l'un cartographie les vulnérabilités XSS sur le frontend.

Pipeline de reconnaissance parallèle multi-outils dynamique

RedAmon lance plusieurs outils de reconnaissance en parallèle, chacun alimentant un graphe de connaissances partagé en temps réel. Les outils démarrent, adaptent leur périmètre en fonction des découvertes en direct et se coordonnent sans intervention manuelle. L'ensemble de la surface d'attaque -- sous-domaines, ports, endpoints, paramètres -- se matérialise en quelques minutes, pas en heures.

La reconnaissance comme graphe de connaissances vivant

Des scanners standard du secteur enchaînés de sorte que la sortie de chaque outil alimente le suivant, puis fusionnés dans un graphe de connaissances Neo4j unique. Les constats sont dédupliqués, les relations sont explicites, et l'agent hérite d'une surface d'attaque structurée et entièrement connectée, prête à être interrogée en langage naturel.

L'offensive rencontre la défense. Un pipeline, une visibilité totale.

Reconnaissance ➜ Exploitation ➜ Post-Exploitation ➜ AI Triage ➜ CodeFix Agent ➜ GitHub PR

RedAmon ne s'arrête pas à la détection des vulnérabilités, il les corrige. Le pipeline démarre avec un moteur de reconnaissance en 6 phases qui cartographie l'ensemble de la surface d'attaque de votre cible, puis passe le relais à un agent IA autonome qui valide l'exploitabilité des CVE, teste les politiques d'identifiants et cartographie les chemins de mouvement latéral. Chaque constat est enregistré dans un graphe de connaissances Neo4j. Lorsque la phase offensive se termine, CypherFix prend le relais : un agent de tri IA corrèle des centaines de constats, les déduplique et les classe par exploitabilité. Ensuite, un agent CodeFix clone votre dépôt, parcourt le codebase avec 11 outils conscients du code, implémente des correctifs ciblés et ouvre une pull request GitHub, prête pour la revue et la fusion.

Roadmap et contributions communautaires

Nous tenons un Tableau de projet public avec les fonctionnalités à venir ouvertes aux contributions communautaires. Choisissez une tâche et soumettez une PR !

Vous voulez contribuer ? Voir CONTRIBUTING.md pour savoir comment commencer.

Mainteneurs

Samuele Giampieri: Créateur, Mainteneur et Architecte de plateforme IA Architecte de plateforme IA et responsable full-stack avec plus de 15 ans d'expérience en freelance et plus de 30 projets mis en production, y compris des systèmes agentiques IA à l'échelle entreprise. Certifié AWS (DevOps Engineer, ML Specialty) et ingénieur IA certifié IBM. Conçoit des solutions ML de bout en bout couvrant le deep learning, le NLP, la vision par ordinateur et les systèmes d'agents IA avec LangChain/LangGraph. LinkedIn · GitHub · Devergo Labs

Ritesh Gohil: Mainteneur et chercheur en sécurité principal Ingénieur en cybersécurité chez Workday avec plus de 7 ans d'expérience en test d'intrusion Web, API, Mobile, Réseau et Cloud. A publié 11 CVE dans MITRE, avec des remerciements de sécurité de Google (4×) et Apple (6×). A sécurisé plus de 200 applications web et mobiles et a contribué à l'Exploit Database, à la Google Hacking Database et à la communauté AWS. Détient les certifications AWS Security Specialty, eWPTXv2, eCPPTv2, CRTP et CEH, avec une expertise en red teaming, sécurité cloud, recherche CVE et revue d'architecture de sécurité. LinkedIn · GitHub

Démarrage rapide

Prérequis

• Docker et Docker Compose v2+
  • macOS : Docker Desktop, avec la mémoire augmentée à au moins 4 Go (8 Go avec --gvm) dans Réglages → Ressources. Clonez sous ~/ pour que le chemin soit dans la liste de partage de fichiers par défaut.
  • Windows : Docker Desktop avec le backend WSL2, exécutez depuis le système de fichiers WSL2 (~/), pas /mnt/c/.

C'est tout. Aucun Node.js, Python ni outil de sécurité n'est nécessaire sur votre hôte.

Configuration système minimale

Sans OpenVAS exécute 7 conteneurs : webapp, postgres, neo4j, agent, kali-sandbox, recon-orchestrator et docker-broker (un proxy filtrant pour le socket Docker par lequel passent les conteneurs de scan créés par l'orchestrateur de reconnaissance, afin qu'ils ne puissent lancer que les images d'outils connues). Avec OpenVAS ajoute 4 conteneurs d'exécution supplémentaires (gvmd, ospd-openvas, gvm-postgres, gvm-redis) ainsi que ~8 conteneurs d'initialisation de données à usage unique pour les flux de vulnérabilités (~170K+ NVT). Le premier lancement prend ~30 minutes pour la synchronisation des flux GVM. Les conteneurs de reconnaissance et de scan dynamiques sont créés à la demande pendant les opérations et nécessitent des ressources supplémentaires.

Dimensionnement du disque pour un déploiement réel. Les chiffres ci-dessus sont les minimums absolus pour construire et exécuter la pile (empreinte fixe de la plateforme : ~70 Go sans OpenVAS, ~95 Go avec - mesurée par la taille réelle des images sur disque après déduplication des couches Kali de base partagées). Pour un serveur toujours actif exécutant de vrais engagements, ajoutez ~100 Go d'espace libre pour les données opérationnelles - le graphe d'attaque Neo4j, les artefacts/sorties de scan, Postgres et les journaux de conteneurs grandissent tous avec l'utilisation. Cela signifie 200 Go sans OpenVAS, 250 Go avec OpenVAS, chacun laissant bien plus de 100 Go libres pour les opérations. Voir le guide de déploiement pour la répartition complète.

1. Cloner et installer```bash

git clone https://github.com/samugit83/redamon.git cd redamon

Without GVM (lighter, faster startup):

./redamon.sh install

With GVM / OpenVAS (full stack, ~30 min first run):

./redamon.sh install --gvm

Le script construit toutes les images et démarre les services.

### 2. Créer un compte administrateur

À la fin de l'installation (et à chaque `./redamon.sh up` ou `./redamon.sh update` si aucun administrateur n'existe), vous serez invité dans le terminal :```
[WARN] No admin user found. Let's create one.

  Admin name: Your Name
  Admin email: [email protected]
  Admin password: ********
  Confirm password: ********

• Nom de l'administrateur -- nom d'affichage visible dans l'interface (par exemple Admin, votre nom, ce que vous voulez).
• E-mail de l'administrateur -- utilisé pour se connecter à http://localhost:3000/login.
• Mot de passe de l'administrateur -- 12 caractères minimum.

Après la création, ouvrez http://localhost:3000 et connectez-vous avec l'e-mail et le mot de passe que vous venez de définir.

Aucune invite affichée ? Lors d'un premier démarrage lourd (surtout avec --gvm, ou sur une petite machine virtuelle), l'application web peut mettre du temps à démarrer ; l'invite automatique peut donc être ignorée. Créez l'administrateur à tout moment avec :

root@kitploit:~

./redamon.sh create-admin

Il attend que l'application web soit prête, puis demande les mêmes informations. Il est sûr de le relancer : réutiliser l'e-mail d'un administrateur existant réinitialise ce mot de passe, un nouvel e-mail ajoute un autre administrateur.

Ce que l'administrateur peut faire :

• Basculer entre tous les utilisateurs via la liste déroulante des utilisateurs dans l'en-tête (y compris les utilisateurs sans mot de passe).
• Créer de nouveaux utilisateurs (avec ou sans mot de passe) et leur attribuer les rôles admin ou standard.
• Définir ou modifier le mot de passe de n'importe quel utilisateur.
• Supprimer des utilisateurs (sauf soi-même).
• Accéder à la page de gestion Utilisateurs depuis la navigation de l'en-tête.

Les utilisateurs standard peuvent uniquement se connecter (s'ils ont un mot de passe défini par un administrateur), modifier leur propre mot de passe et utiliser l'application dans leur propre périmètre. Ils ne peuvent pas changer d'utilisateur, créer des utilisateurs ni accéder à la gestion des utilisateurs.

Si vous oubliez le mot de passe administrateur, réinitialisez-le depuis le terminal :```bash ./redamon.sh reset-password # reset an EXISTING user's password ./redamon.sh create-admin # create the first admin, or reset an admin by re-entering its email

Use `create-admin` lorsqu'aucun administrateur n'existe encore (il effectue un upsert sur l'e-mail) ; `reset-password` ne met à jour qu'un utilisateur existant.

### 3. Configurez

Ouvrez **http://localhost:3000/settings** (icône d'engrenage dans l'en-tête) pour tout configurer. Aucun fichier `.env` n'est nécessaire.

- **Fournisseurs LLM** -- ajoutez des clés API pour OpenAI, Anthropic, OpenRouter, AWS Bedrock, ou tout endpoint compatible OpenAI (Ollama, vLLM, Groq, etc.). Chaque fournisseur peut être testé avant l'enregistrement. Le sélecteur de modèles dans les paramètres de projet **récupère dynamiquement** les modèles disponibles auprès des fournisseurs configurés.
- **Clés API** -- Tavily, Shodan, SerpAPI, NVD, Vulners, URLScan, et les clés de renseignement sur les menaces (Censys, FOFA, OTX, Netlas, VirusTotal, ZoomEye, CriminalIP) pour activer des capacités étendues des agents (recherche web, OSINT, recherche de CVE, renseignement passif sur les menaces). Les clés **Uncover multi-engine search** (Quake, Hunter, PublicWWW, HunterHow, Google, Onyphe, Driftnet) étendent la découverte de cibles sur 13 moteurs de recherche -- les clés partagées (Shodan, Censys, FOFA, etc.) sont automatiquement réutilisées. Prend en charge la **rotation des clés** -- configurez plusieurs clés par outil avec une rotation automatique round-robin pour éviter les limites de débit.
- **Tunneling** -- configurez ngrok ou chisel pour le tunneling de shell inverse. Les modifications s'appliquent immédiatement sans redémarrage des conteneurs.

Tous les paramètres sont stockés par utilisateur dans la base de données. Consultez la page wiki **[AI Model Providers](https://github.com/samugit83/redamon/wiki/AI-Model-Providers)** pour des instructions de configuration détaillées.

### 4. Ouvrez l'application web

Allez sur **http://localhost:3000** -- créez un projet, configurez votre cible et lancez l'analyse.

> Pour une présentation détaillée de chaque fonctionnalité, consultez le **[Wiki](https://github.com/samugit83/redamon/wiki)**.
>
> Des problèmes ? Consultez le guide **[Dépannage](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md)** ou la page **[Dépannage du Wiki](https://github.com/samugit83/redamon/wiki/Troubleshooting)**.

### Commandes de gestion

Toute la gestion du cycle de vie est prise en charge par un seul script :

| Commande | Description |
|---------|-------------|
| `./redamon.sh install` | Construire + démarrer en mode léger (pas de GVM, pas de base de connaissances, recherche web via Tavily uniquement) |
| `./redamon.sh install --kbase` | Construire + démarrer avec la base de connaissances locale (~4,4 Go de plus) |
| `./redamon.sh install --gvm` | Construire + démarrer avec GVM/OpenVAS |

> Les options peuvent être combinées : `./redamon.sh install --gvm --kbase`

| Commande | Description |
|---------|-------------|
| **`./redamon.sh update`** | **Récupère la dernière version, reconstruit intelligemment uniquement les services modifiés (préserve votre choix GVM/KB effectué lors de l'installation)** |
| `./redamon.sh up` | Démarre les services (détecte automatiquement le mode GVM et KB depuis l'installation) |
| `./redamon.sh up dev` | Démarre en mode développement avec rechargement à chaud (détecte automatiquement le mode GVM et KB) |
| `./redamon.sh down` | Arrête les services (conserve les données) |
| `./redamon.sh status` | Affiche les services en cours d'exécution, la version, le mode GVM, l'état de la KB |
| `./redamon.sh clean` | Supprime les conteneurs + images, conserve les données |
| `./redamon.sh create-admin` | Crée le compte administrateur (ou le réinitialise) -- à utiliser si aucune invite n'est apparue à l'installation |
| `./redamon.sh reset-password` | Réinitialise le mot de passe d'un utilisateur existant depuis le terminal |
| `./redamon.sh purge` | Supprime tout, y compris toutes les données |


### Mise à jour vers une nouvelle version

Exécutez simplement :```bash
./redamon.sh update

Le script récupère le dernier code depuis GitHub, détecte les Dockerfiles et fichiers sources modifiés, reconstruit uniquement les images concernées et redémarre les services mis à jour. Vos bases de données, résultats de scan et rapports sont conservés -- les volumes ne sont jamais supprimés.

Note ponctuelle lorsqu'une version ajoute un nouveau service en arrière-plan. update ré-exécute le script fraîchement récupéré afin que les nouvelles règles de construction/démarrage s'appliquent automatiquement -- mais uniquement pour la version du script à partir de laquelle vous effectuez la mise à jour. Lors de la mise à jour depuis une version antérieure à cette auto-réparation (c'est-à-dire votre première mise à jour vers celle-ci), exécutez ./redamon.sh up une fois juste après update pour que tout nouveau service central ajouté soit démarré :

root@kitploit:~

./redamon.sh update && ./redamon.sh up

up est idempotent -- il ne démarre que ce qui manque et laisse les conteneurs en cours d'exécution intacts. Après cette étape ponctuelle, un simple ./redamon.sh update gère tout tout seul.

La webapp vérifie également les mises à jour automatiquement et affiche une notification dans l'interface lorsqu'une nouvelle version est disponible.

Déployer sur un serveur (Production)

Le démarrage rapide ci-dessus exécute RedAmon localement sur localhost. Pour exécuter une instance partagée et accessible sur Internet sur un serveur Linux (EC2, DigitalOcean, Hetzner ou bare metal), utilisez le déploiement mono-hôte dans deploy/single-host/. Il pilote redamon.sh via SSH depuis votre ordinateur portable et enveloppe la pile dans la couche de sécurité orientée Internet que RedAmon omet par défaut : nginx + TLS (Let's Encrypt), un pare-feu hôte, le durcissement SSH et fail2ban, avec une seule origine HTTPS publique afin que seule la page de connexion soit accessible et que tout le reste reste lié à loopback.```bash cd deploy/single-host cp .env.example .env # set HOST_IP, DOMAIN, SSH_KEY_PATH, OPERATOR_ALLOW_CIDRS, # LETSENCRYPT_EMAIL, ADMIN_* ... ./deploy.sh init # first build takes 30-60 min, then log in at https:///

Procédure pas à pas complète : [Wiki : Déploiement sur un serveur](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server). Référence complète : [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/master/deploy/single-host/README.md).

### Mode développement

Pour les contributeurs et le développement actif avec **Next.js fast refresh** :```bash
./redamon.sh up dev           # auto-detects GVM mode from install

Les images des outils sont construites automatiquement au premier lancement si elles n'existent pas encore. La surcharge dev remplace l'image webapp de production par un conteneur de dev avec votre code source monté en volume. Chaque sauvegarde de fichier déclenche un hot-reload instantané dans le navigateur.

Quand reconstruire vs redémarrer

Reconstruire un seul service :```bash docker compose build # Rebuild one image docker compose up -d --no-deps # Restart only that service

**Commandes dev courantes:**```bash
docker compose ps                                 # Check service status
docker compose logs -f <service>                  # Follow logs for a service
docker compose down                               # Stop all (preserves volumes)
docker compose --profile tools down --rmi local   # Remove built images
docker compose --profile tools down --rmi local --volumes --remove-orphans  # Full cleanup

Récupérer de l'espace disque:```bash docker system df # Show Docker disk usage (add -v for per-image breakdown) docker image prune -f # Remove dangling images (auto-run by ./redamon.sh update) docker builder prune -f # Clear build cache (NOT auto-cleaned, can grow to many GB over time) docker container prune -f # Remove stopped containers

> Pour une référence complète de développement -- règles de rechargement à chaud, commandes courantes, règles importantes et directives de codage assisté par IA -- consultez le **[Guide du développeur](https://github.com/samugit83/redamon/blob/master/readmes/README.DEV.md)**.

---

### Base de connaissances (recherche Web améliorée par RAG)

L'outil `web_search` de l'agent inclut une **base de connaissances** locale -- un pipeline RAG qui recherche dans des ensembles de données de sécurité organisés (GTFOBins, LOLBAS, OWASP WSTG, NVD CVEs, ExploitDB, modèles Nuclei et documentation des compétences de l'agent) avant de recourir à la recherche Web Tavily. Lorsque la KB retourne une correspondance de haute confiance, Tavily est entièrement ignoré pour des résultats plus rapides et utilisables hors ligne.

**Comment cela fonctionne :** Lorsque la KB est activée, `install` / `up` / `update` construit un index KB léger (~1,200 fragments en 10-15 min sur CPU). Au moment de la requête, l'agent exécute un pipeline de recherche hybride (recherche vectorielle FAISS + texte intégral Neo4j), réordonne avec un cross-encoder, et vérifie un seuil de confiance. Si le score est suffisamment élevé, les résultats proviennent de la KB locale. Sinon, il recourt à Tavily ou fusionne les deux.

**Comportement par défaut :** La base de connaissances est **facultative**. `./redamon.sh install` produit une installation légère (~4,4 Go de moins, recherche Web Tavily uniquement). Pour activer la base de connaissances locale, passez `--kbase` :```bash
./redamon.sh install --kbase

Lors de la première installation avec --kbase, RedAmon détecte votre matériel (GPU / CPU / API) et propose un profil de démarrage rapide. Le choix est conservé, de sorte que les commandes update / up ultérieures le respectent sans avoir à repasser l'option.

Accélérez l'ingestion avec les embeddings API : Par défaut, les embeddings s'exécutent localement sur CPU/GPU. Sur les machines avec CPU uniquement, les grands ensembles de données (ExploitDB, NVD) peuvent prendre des heures. Vous pouvez décharger l'embedding vers une API externe en créant un fichier .env à partir du modèle :```bash cp .env.example .env

Ensuite, configurez l'API d'embedding dans `.env` :

| Variable | Défaut | Description |
|----------|---------|-------------|
| `KB_EMBEDDING_USE_API` | `false` | Définir sur `true` pour utiliser des embeddings basés sur API au lieu du modèle local |
| `KB_EMBEDDING_API_BASE_URL` | *(vide = OpenAI)* | Tout endpoint compatible OpenAI (Ollama, vLLM, LiteLLM, Together AI, Azure) |
| `KB_EMBEDDING_API_KEY` | *(vide)* | Clé API pour le fournisseur d'embedding |
| `KB_EMBEDDING_API_MODEL` | `text-embedding-3-small` | Nom du modèle (spécifique au fournisseur) |
| `NVD_API_KEY` | *(vide)* | Clé API NVD gratuite pour une ingestion de CVE 10x plus rapide |

Exemple avec Ollama (gratuit, local, sans coût de clé API) :```bash
KB_EMBEDDING_USE_API=true
KB_EMBEDDING_API_BASE_URL=http://host.docker.internal:11434/v1
KB_EMBEDDING_API_KEY=ollama
KB_EMBEDDING_API_MODEL=nomic-embed-text

Important : L'ingestion et la requête doivent utiliser le même modèle. Si vous changez de modèle, reconstruisez l'index : make -C knowledge_base kb-rebuild-lite MODE=docker

Gérer la KB :```bash ./redamon.sh kb build lite # Build with lite profile (~30-60s with API) ./redamon.sh kb build standard # Add NVD CVEs ./redamon.sh kb update nvd # Incremental NVD refresh ./redamon.sh kb stats # Show index statistics ./redamon.sh kb rebuild lite # Wipe and rebuild from scratch

> Pour la documentation technique complète — pipeline de requêtes, sources de données, profils d'ingestion, scoring, modèle de sécurité — voir la **[Référence technique de la base de connaissances](https://github.com/samugit83/redamon/blob/master/readmes/README.KBASE.md)** ou le **[Wiki : Base de connaissances et recherche web](https://github.com/samugit83/redamon/wiki/Knowledge-Base-Web-Search)**.

---

## Table des matières

- [Documentation complète du Wiki](https://github.com/samugit83/redamon/wiki)
- [Vue d'ensemble](#overview)
- [Conçu pour l'entreprise, sécurisé par conception](#built-for-enterprise-secure-by-design)
- [Modèle de sécurité et de menace](#security--threat-model)
- [Points forts](#feature-highlights)
- [Architecture système](#system-architecture)
- [Composants](#components)
- [Documentation](#documentation)
- [Dépannage](#troubleshooting)
- [RedAmon HackLab](#redamon-hacklab)
- [Vitrine communautaire](#community-showcase)
- [Mentions légales](#legal)

---

## Vue d'ensemble

RedAmon est un framework de test d'intrusion modulaire et conteneurisé qui combine reconnaissance automatisée, exploitation pilotée par IA et intelligence basée sur graphes en un seul pipeline de sécurité offensive de bout en bout. Chaque composant s'exécute dans Docker (aucun outil installé sur votre hôte) et communique via des API bien définies, ce qui permet à chaque couche d'évoluer de manière indépendante.

La plateforme repose sur six piliers :

| Pilier | Rôle |
|--------|------|
| **Pipeline de reconnaissance** | Un pipeline de scan **en éventail (fan-out / fan-in) parallélisé** qui cartographie l'ensemble de la surface d'attaque de votre cible (à partir d'un domaine **ou d'adresses IP / plages CIDR**) : découverte de sous-domaines (5 outils concurrents), scan de ports, détection de services Nmap et scripts de vulnérabilité NSE, sondage HTTP, énumération de ressources et détection de vulnérabilités. Les modules indépendants s'exécutent en parallèle via `ThreadPoolExecutor`, les mises à jour de la base de graphes se font dans un thread d'arrière-plan, et les résultats sont stockés sous forme de graphe riche et interrogeable. Complété par des modules autonomes de scan réseau GVM, de chasse aux secrets GitHub et d'analyse approfondie des secrets via TruffleHog. |
| **Orchestrateur d'agents IA** | Un agent autonome basé sur LangGraph qui raisonne sur le graphe, sélectionne les outils de sécurité via MCP, passe par les phases information / exploitation / post-exploitation et peut être piloté en temps réel via le chat. |
| **Graphe de surface d'attaque** | Un graphe de connaissances Neo4j avec 17 types de nœuds et plus de 20 types de relations, qui sert de source unique de vérité pour chaque résultat et de source de données principale que l'agent IA interroge avant chaque décision. |
| **EvoGraph** | Un graphe de chaînes d'attaque évolutif et persistant dans Neo4j qui suit chaque étape, résultat, décision et échec sur l'ensemble du cycle d'attaque, faisant le lien avec le graphe de reconnaissance et permettant l'accumulation d'intelligence inter-sessions. |
| **CypherFix** | Pipeline automatisé de remédiation des vulnérabilités : un agent de triage IA corrèle et priorise les résultats issus du graphe, puis un agent CodeFix clone le dépôt cible, implémente les correctifs via une boucle ReAct avec 11 outils de code, et ouvre une pull request GitHub. |
| **Moteur de paramètres de projet** | Plus de 500 paramètres par projet (exposés via l'interface web) qui contrôlent le comportement de chaque outil, du nombre de threads Naabu aux filtres de sévérité Nuclei, en passant par les étapes d'approbation des agents. |

---

## Conçu pour l'entreprise, sécurisé par conception

RedAmon est conçu pour s'intégrer dans une organisation de sécurité réelle, et pas seulement sur le portable d'un chercheur.

- **Sécurisé par conception, modélisé selon STRIDE.** L'ensemble de la plateforme est évalué de bout en bout selon STRIDE et durci par vagues vérifiées de manière indépendante : séparation des privilèges au niveau du code, broker Docker filtrant devant la socket hôte, authentification en échec-fermé (fail-closed), garde-fous de sortie SSRF, masquage des secrets, pistes d'audit en ajout seul, et garde-fou non désactivable qui bloque les cibles gouvernementales, militaires et intergouvernementales. Voir le [Posture de sécurité](https://github.com/samugit83/redamon/blob/master/readmes/README.SECURITY_POSTURE.md) et le [Modèle de menace](https://github.com/samugit83/redamon/blob/master/readmes/README.TM.SYSTEM_OVERVIEW.md).
- **Totalement isolé et conteneurisé.** Chaque outil, scanner et agent s'exécute dans son propre conteneur, sans exécution au niveau de l'hôte. Les tâches de scan sont lancées comme conteneurs frères éphémères avec leur propre système de fichiers et espace de noms réseau, puis supprimés à la fin, ce qui maintient l'hôte propre et contient le rayon d'explosion de toute exploitation.
- **Gouverné et multi-tenant.** Location multi-utilisateurs / multi-projets avec rôles administrateur et standard, cadrage au niveau base de données par `user_id + project_id` sur chaque nœud, application des règles d'engagement, étapes d'approbation avec intervention humaine, et plus de 500 paramètres par projet offrent aux équipes le contrôle requis pour un engagement en entreprise.

**Déployez sur un serveur en une seule commande.** Au-delà du simple `localhost`, RedAmon fournit un [déploiement mono-hôte durci](https://github.com/samugit83/redamon/blob/master/deploy/single-host) qui met en place une instance partagée accessible depuis Internet et enveloppe la pile dans nginx + TLS (Let's Encrypt), un pare-feu hôte, un durcissement SSH et fail2ban, exposant une seule origine HTTPS publique :```bash
cd deploy/single-host
cp .env.example .env      # set DOMAIN, HOST_IP, SSH_KEY_PATH, ADMIN_* ...
./deploy.sh init          # builds the full stack and brings it up over SSH

Procédure complète : Wiki : Déploiement sur un serveur.

Sécurité et modèle de menace

RedAmon est un logiciel offensif ; nous l’astreignons donc au même standard qu’il applique aux autres. Il est conçu sécurisé par conception et a été évalué de bout en bout selon la méthodologie STRIDE (usurpation d’identité, falsification, répudiation, divulgation d’informations, déni de service, élévation de privilèges), les constats ayant été corrigés par vagues séquencées et vérifiées indépendamment.

Ce n’est pas une allégation marketing. Cela repose sur une analyse publiée et fondée sur des preuves que vous pouvez consulter :

• Security Posture - le catalogue complet des contrôles de défense en profondeur : chaque couche implémentée, mappée au code.
• Threat Model - les actifs, les frontières de confiance, les flux de données, les points d’entrée et la surface réseau sur lesquels l’analyse s’appuie.

Points saillants de ce qui est implémenté :

• Séparation des privilèges au niveau du code. Le worker exposé à la cible est le composant le moins fiable et ne détient aucun secret ; un courtier Docker filtrant s’interpose entre l’orchestrateur et le socket Docker de l’hôte (liste blanche d’images, refus de --privileged, binds root de l’hôte, capacités dangereuses).
• Deux postures de déploiement, un seul modèle de confiance. Local (backends liés à la boucle locale) et un déploiement internet public durci qui ajoute nginx + TLS, un portail opérateur, un limiteur de débit sur la connexion et une seule origine publique.
• Fermeture par défaut (fail-closed). Les jetons d’authentification non définis rejettent plutôt que de servir, les identifiants de base de données par défaut sont refusés et renouvelés, les WebSockets exigent un ticket signé plus une vérification same-origin côté serveur, et chaque requête est limitée à son propriétaire authentifié (contrôle d’accès par utilisateur avec 404 anti-énumération).
• Défense en profondeur. Garde-fous de sortie SSRF, masquage des secrets dans les journaux, pistes d’audit en ajout seul, durcissement anti-évasion de conteneur, plafonds de décompression et de concurrence, et épinglage de la chaîne d’approvisionnement (sha256 + épinglage de commits).
• Une barrière de sécurité dure et non désactivable bloque les cibles gouvernementales, militaires et intergouvernementales, quelle que soit la configuration.
• Corrections vérifiées et validées à la publication. Les correctifs sont diffusés par vagues séquencées, chacune vérifiée indépendamment avec reproduction d’exploit en conditions réelles avant et après le patch. Consultez les entrées de sécurité du Changelog.

Vous avez trouvé une vulnérabilité ? Consultez notre Security Policy pour une divulgation privée.

Points forts

Pipeline de reconnaissance

Un mappeur de surface d’attaque externe entièrement automatisé, de bout en bout, s’exécutant dans un conteneur Kali Linux. Fournissez-lui une entrée (un domaine racine, une liste de sous-domaines ou des plages IP/CIDR) et le pipeline renvoie une image complète et structurée de la cible : chaque sous-domaine, chaque hôte actif, chaque port ouvert, chaque service HTTP avec sa pile technologique, chaque endpoint exploré et paramètre découvert, chaque CVE à laquelle la cible est probablement vulnérable, plus des scanners dédiés pour les API GraphQL, les détournements de sous-domaines, les hôtes virtuels cachés derrière des reverse proxies, l’empoisonnement et la supercherie du cache web, ainsi qu’une couche Adversarial AI Surface qui étiquette les runtimes IA / bases vectorielles / frontends LLM / proxies / serveurs MCP / endpoints de chat / complétion / embedding / RAG et les paramètres injectables par prompt à l’aide de signatures d’en-têtes / favicons / titres / chemins / noms de paramètres, puis les confirme activement avec un module dédié AI Surface Recon (sondes bénignes en forme de chat, handshake MCP + scan d’empoisonnement d’outils, lectures de bases vectorielles — aucun appel LLM).

Tout repose sur une architecture fan-out / fan-in : chaque phase lance autant d’outils en parallèle que le travail le permet, puis converge avant le début de la phase suivante. Plus de 40 outils du secteur s’intègrent dans un flux de travail coordonné, l’empoisonnement DNS par wildcard est filtré automatiquement avec puredns, et le mode furtif maintient l’ensemble du pipeline sur des sources passives uniquement lorsque le sondage actif est interdit. Les résultats sont diffusés dans le graphe de connaissances Neo4j sur un thread en arrière-plan, afin que l’analyse ne bloque jamais sur les écritures en base, et le JSON brut est conservé pour téléchargement. Le détail outil par outil figure dans la matrice ci-dessous.

Wiki : Exécuter une reconnaissance | Technique : README.RECON.md

Matrice d’outils du pipeline de reconnaissance

_{*Amass peut s’exécuter en mode actif s’il est configuré. Knockpy effectue un sondage DNS actif.}

Recon partielle

Exécutez n’importe quel outil du pipeline de manière indépendante sans relancer l’ensemble du scan. Jusqu’à 12 recons partielles peuvent s’exécuter en parallèle par projet, chacune avec des journaux, des contrôles d’arrêt et des badges de statut indépendants, visibles à la fois dans la barre d’outils du graphe et dans l’en-tête des paramètres du projet. Chaque section d’outil dispose d’un bouton de lecture qui ouvre une fenêtre modale où vous pouvez consulter les données existantes du graphe, ajouter des cibles personnalisées (sous-domaines, IP, ports ou URL) et lancer l’outil de manière isolée. Les résultats sont fusionnés dans le graphe Neo4j à l’aide d’opérations MERGE -- les doublons sont mis à jour, pas recréés. L’outil s’exécute avec tous les paramètres du projet (timeouts, wordlists, clés API, proxy) appliqués automatiquement. Tous les outils du pipeline prennent en charge la recon partielle.

Wiki : Workflow du pipeline de recon -- Recon partielle

IA dans le pipeline

Points de décision augmentés par LLM facultatifs intégrés au pipeline de recon là où les recherches statiques dérivent historiquement -- Nuclei réduit sa liste de tags à la pile technologique détectée, le classifieur WAF détecte Cloudflare/AWS WAF/Imperva même sans en-têtes, et bien d’autres encore dans FFuf, le filtrage des faux positifs de Nuclei et la désambiguïsation des détournements de sous-domaines. Chaque point d’accroche est un repli en cascade après le chemin statique, avec un repli sûr déterministe, de sorte qu’une panne de LLM ne peut pas interrompre un scan. Un interrupteur principal dans l’onglet Cible les régit tous.

Wiki : IA dans le pipeline

AI Gauntlet : Tests offensifs IA/LLM

Là où le pipeline de recon trouve la surface IA, AI Gauntlet l’attaque. Sélectionnez les endpoints LLM découverts (ou saisissez une URL personnalisée), choisissez un outil, confirmez les règles d’engagement et lancez : un conteneur éphémère fait passer la cible dans quatre outils red-team du secteur -- garak (scanner large à un seul essai, 40 familles de sondes), PyRIT (jailbreaks multi-tours bornés), Giskard (scan de sécurité assisté par LLM) et promptfoo (évaluation red-team par jeux de données) -- mesurant un taux de réussite d’attaque (ASR) par attaque et écrivant les faiblesses confirmées sur le graphe sous forme de résultats Vulnerability mappés OWASP-LLM / MITRE-ATLAS, avec transcriptions de preuves.

Il est déterministe (graines, bornes fixes, versions d’outils épinglées) et s’exécute avec zéro sortie externe : chaque appel de juge / correcteur / embedding est forcé vers un modèle Ollama local, de sorte qu’aucun payload ni transcript ne quitte jamais votre machine. Désactivé par défaut et conditionné par les RoE, avec progression en direct phase par phase, et résultats présentés dans le tableau AI Gauntlet Vulnerabilities de la Red Zone et dans le rapport de pentest.

Wiki : AI Gauntlet | Technique : AI_GAUNTLET_TECH_DOC.md

Scanner de vulnérabilités GVM

GVM/OpenVAS effectue une évaluation approfondie des vulnérabilités au niveau réseau avec plus de 170 000 NVT, en sondant les services au niveau protocole pour détecter les mauvaises configurations, les logiciels obsolètes, les identifiants par défaut et les CVE connues. Il complète les résultats de Nuclei au niveau web. Sept profils de scan préconfigurés, de la découverte rapide d’hôtes (~2 min) au scan profond exhaustif (~8 heures). Les résultats sont stockés comme nœuds Vulnerability dans Neo4j, aux côtés du graphe de recon.

Wiki : Scan de vulnérabilités GVM | Technique : README.GVM.md

Orchestrateur d’agents IA

Un agent autonome basé sur LangGraph implémentant le motif ReAct. Il progresse à travers trois phases : Information (collecte de renseignements, requêtes au graphe, Shodan, Google dorking), Exploitation (Metasploit, tests d’identifiants Hydra, simulation d’ingénierie sociale) et Post-exploitation (énumération, mouvement latéral). L’agent exécute 14 outils de sécurité via des serveurs MCP dans un sandbox Kali, prend en charge l’exécution parallèle d’outils via Wave Runner, et offre une interaction de chat en temps réel avec guidage, workflows d’arrêt/reprise et d’approbation. Le mode Deep Think permet une analyse stratégique structurée avant d’agir.

Wiki : Guide de l’agent IA | Technique : README.AGENTIC_SYSTEM.md

Arsenal d’outils de l’agent| Catégorie | Outil | Description | Phases | Serveur MCP |

|:-----:|-------|-------------|:------:|:----------:| | Intelligence | query_graph | Requêtes sur le graphe Neo4j -- source principale de vérité pour les données de reconnaissance | All | -- | | | web_search | Recherche sur Internet via Tavily pour les détails des CVE, les PoC d'exploits et les avis de sécurité | All | -- | | | cve_intel | ProjectDiscovery vulnx -- intelligence CVE structurée agrégeant NVD + CISA KEV + EPSS + HackerOne + PoC GitHub + disponibilité des templates Nuclei. 69 champs filtrables via Lucene. Clé PDCP optionnelle (par utilisateur, mode anonyme = 10 req/min) | All | network_recon :8000 | | | tradecraft_lookup | Catalogue organisé par l'utilisateur d'URL de références de sécurité fiables (HackTricks, PayloadsAllTheThings, dépôts de PoC CVE, blogs de fournisseurs) -- 6 types de ressources auto-détectés, sélection de section pilotée par le sitemap, cache sqlite+disque | Exploit, Post | -- | | | shodan | Collecte OSINT via Shodan -- détails des hôtes, DNS inverse, recherche d'appareils | Info, Exploit | -- | | | google_dork | Google dorking via SerpAPI -- fichiers exposés, panneaux d'administration, listes de répertoires | Info | -- | | Reconnaissance & OSINT | execute_subfinder | Énumération passive de sous-domaines via OSINT (logs CT, jeux de données DNS). Aucun trafic vers la cible | Info, Exploit | network_recon :8000 | | | execute_gau | Découverte passive d'URL depuis Wayback Machine, Common Crawl, AlienVault OTX, URLScan. Aucun trafic vers la cible | Info, Exploit | network_recon :8000 | | | execute_amass | Énumération de sous-domaines et cartographie réseau OWASP Amass (passif + actif, intelligence ASN) | Info, Exploit | network_recon :8000 | | Scan | execute_naabu | Scan de ports rapide et vérification | Info, Exploit | network_recon :8000 | | | execute_nmap | Détection approfondie des services (-sV), empreinte OS, scripts NSE | All | nmap :8004 | | | execute_nuclei | Vérification et exploitation de CVE avec plus de 9 000 templates + imports personnalisés | Info, Exploit | nuclei :8002 | | | execute_httpx | Sondage HTTP et prise d'empreintes -- codes de statut, titres, en-têtes serveur, détection de technologies | Info, Exploit | network_recon :8000 | | | execute_wpscan | Scanner de vulnérabilités WordPress -- détecte les plugins, thèmes, utilisateurs et mauvaises configurations vulnérables | Info, Exploit | network_recon :8000 | | Web & HTTP | execute_curl | Requêtes HTTP -- accessibilité, en-têtes, codes de statut, bannières | All | network_recon :8000 | | | execute_katana | Exploration web et découverte de points de terminaison avec analyse JS et énumération de fichiers connus | Info, Exploit | network_recon :8000 | | | execute_jsluice | Analyse statique JavaScript pour les points de terminaison d'API cachés, chemins d'URL et secrets | Info, Exploit | network_recon :8000 | | | execute_arjun | Découverte de paramètres HTTP par force brute d'environ 25 000 noms de paramètres courants | Info, Exploit | network_recon :8000 | | | execute_ffuf | Fuzzing web pour répertoires cachés, fichiers, hôtes virtuels et paramètres | Info, Exploit | network_recon :8000 | | | execute_playwright | Automatisation de navigateur Chromium sans tête -- extraction de contenu rendu par JS et scripting interactif pour les SPA, test de formulaires, vérification XSS | All | playwright :8005 | | Exploitation | metasploit_console | msfconsole persistant -- exécution d'exploits, gestion de sessions, post-exploitation | Exploit, Post | metasploit :8003 | | | msf_restart | Réinitialisation complète de Metasploit -- met fin à toutes les sessions, efface l'état des modules | Exploit, Post | metasploit :8003 | | | execute_hydra | Force brute THC Hydra -- plus de 50 protocoles (SSH, FTP, RDP, SMB, HTTP, MySQL, etc.) | Exploit, Post | network_recon :8000 | | Exécution de code | kali_shell | Shell Kali Linux complet -- nikto, whatweb, testssl, commix, sstimap, tplmap, ysoserial, phpggc, dnsrecon, dnsx, subzy, enum4linux-ng, netexec, kerbrute, bloodhound-python, bhgraph, certipy-ad, bloodyAD, jwt_tool, graphql-cop, graphqlmap, gitleaks, semgrep, hashcat, john, cewl, paramspider, Node.js + npm, bibliothèques Python (websockets, zeep, python3-saml, boto3, msal, azure-identity, google-auth, google-cloud-storage), boîtes à outils de post-exploitation pré-installées dans /opt/tools/{linux,windows}/ (linpeas, LinEnum, pspy64, deepce, winPEAS, PowerUp, PrivescCheck), et plus de 70 outils CLI | All | network_recon :8000 | | | execute_code | Écrire et exécuter des fichiers de code (Python, bash, Ruby, Perl, C, C++) -- aucun échappement de shell | Exploit, Post | network_recon :8000 | | Trafic (TrafficMind) | proxy_search | Historique façon Burp sur le corpus HTTP capturé -- résumés uniquement, mêmes filtres que l'interface (host, method, status, tool, source, q sous-chaîne d'URL / bodyq sous-chaîne de corps, reflected, only5xx) | All | -- (dans le processus) | | | proxy_get | Requête ou réponse complète (en-têtes + corps) pour une transaction capturée | All | -- (dans le processus) | | | proxy_sitemap | Points de terminaison distincts observés (host + chemin + méthode) avec nombre de hits et codes de statut | All | -- (dans le processus) | | | proxy_params | Paramètres de requête distincts avec exemples de valeurs et une heuristique d'injectabilité (sequential-id / uuid / jwt / base64) | All | -- (dans le processus) | | | proxy_grep | Recherche de sous-chaîne insensible à la casse dans les corps de réponses capturés, avec un extrait autour de la première correspondance | All | -- (dans le processus) | | | proxy_diff | Diff structurel de deux réponses (statut, longueur, ensemble d'en-têtes, diff unifié du corps) pour la détection de SQLi aveugle booléenne / IDOR / contournement d'authentification | All | -- (dans le processus) | | | proxy_to_curl | Transformer une requête capturée en commande curl reproductible (lecture seule, n'envoie rien) | All | -- (dans le processus) | | | proxy_query | Générateur de requêtes analytiques contraintes sur des colonnes / agrégations autorisées (spécification JSON uniquement, pas de SQL brut) | All | -- (dans le processus) | | | proxy_replay | DANGEREUX -- renvoyer une requête capturée avec des champs modifiés (method / path / query / params / headers / cookie / body) ; host, schéma et port épinglés à l'origine. Échange du contexte d'authentification pour IDOR / BOLA / privesc. Re-capturée comme transaction isReplay | Exploit, Post | network_recon :8000 | | | proxy_fuzz | DANGEREUX -- style Burp Intruder : rejouer une requête capturée en itérant un ensemble de payloads (plafonné à 50) sur un paramètre de requête, renvoie un résumé statut / longueur par payload | Exploit, Post | network_recon :8000 | | Workspace FS | fs_read | Lire un fichier de l'espace de travail avec numéros de ligne, détecte automatiquement les binaires, stocke un instantané pour fs_diff vs_last_read | All | -- (dans le processus) | | | fs_read_many | Lecture par lots de plusieurs fichiers, plafonnée à max_total_bytes (200 Ko par défaut) | All | -- (dans le processus) | | | fs_stat | Métadonnées uniquement -- taille, mtime, mode, type, SHA-256 optionnel | All | -- (dans le processus) | | | fs_write | Création / écrasement / ajout atomiques, création automatique des parents | All | -- (dans le processus) | | | fs_edit | Remplacement de chaîne exacte avec vérification d'unicité, enregistre une entrée d'annulation | All | -- (dans le processus) | | | fs_multi_edit | Plusieurs modifications ordonnées en un seul appel, transaction tout-ou-rien | All | -- (dans le processus) | | | fs_undo_edit | Annuler le dernier fs_edit / fs_multi_edit, pile d'annulation par fichier plafonnée à 20 | All | -- (dans le processus) | | | fs_delete | Supprimer un fichier ou un répertoire (indicateur récursif requis pour les répertoires) | All | -- (dans le processus) | | | fs_move | Déplacer ou renommer un chemin, création automatique des répertoires parents de destination | All | -- (dans le processus) | | | fs_copy | Copier un fichier ou une arborescence de répertoires, permissions normalisées pour que l'utilisateur hôte puisse modifier | All | -- (dans le processus) | | | fs_mkdir | Créer un répertoire, idempotent | All | -- (dans le processus) | | | fs_chmod | Modifier les bits de permission (octal 0o755 ou symbolique +x) | All | -- (dans le processus) | | | fs_symlink_create | Créer un lien symbolique, refuse les points de terminaison qui s'échapperaient de l'espace de travail | All | -- (dans le processus) | | | fs_grep | Ripgrep sur l'espace de travail avec regex, timeout de 30 s, plafond de 1 000 correspondances, fonctionne sur les journaux de tâches en cours | All | -- (dans le processus) | | | fs_glob | Recherche par motif glob triée de la plus récente à la plus ancienne, plafonnée à 500 résultats | All | -- (dans le processus) | | | fs_find | Recherche par métadonnées (filtres nom + mtime + taille + type), timeout de 30 s pour le parcours, plafond de 5 000 résultats | All | -- (dans le processus) | | | fs_list | Liste d'un seul répertoire avec type / taille / mtime, plafonnée à 200 entrées | All | -- (dans le processus) | | | fs_tree | Arborescence ASCII limitée en profondeur, ignore .git, node_modules, __pycache__ | All | -- (dans le processus) | | | fs_symbols | Plan AST Tree-sitter (noms de fonctions / classes / méthodes + plages de lignes), 15 langages (py, js, ts, tsx, jsx, java, go, rs, rb, php, c, cpp, cs, kt, swift, scala) | All | -- (dans le processus) | | | fs_symlink_read | Résoudre un lien symbolique vers sa cible brute sans le suivre | All | -- (dans le processus) | | | fs_hash | Empreinte SHA-256 ou MD5 d'un fichier, diffusée en flux par blocs de 64 Ko | All | -- (dans le processus) | | | fs_diff | Diff unifié entre deux fichiers, ou entre un fichier et son dernier instantané fs_read (détecte les écritures concurrentes dans la fireteam) | All | -- (dans le processus) | | | fs_extract | Extraction sûre des archives tar / zip / gz, rejette les chemins zip-slip et tar-slip | All | -- (dans le processus) | | | fs_archive | Regrouper les chemins de l'espace de travail en tar.gz ou zip pour un téléchargement en un clic par l'opérateur | All | -- (dans le processus) | | Tâches de fond | job_spawn | Détacher un appel d'outil en tâche de fond asyncio, sortie dupliquée en temps réel vers jobs/<id>.log, vérifications de phase / RoE au lancement | All | -- (dans le processus) | | | job_status | Requête de statut non bloquante -- statut actuel, taille du journal, 40 dernières lignes de sortie, survit au redémarrage de l'agent via <id>.meta.json | All | -- (dans le processus) | | | job_wait | Bloquer jusqu'à N secondes pour que la tâche se termine, renvoie la même structure que job_status | All | -- (dans le processus) | | | job_cancel | Annuler une tâche en cours, le statut passe à cancelled, sans effet sur les tâches dans un état terminal | All | -- (dans le processus) | | | job_list | Lister les tâches de fond du projet, filtrer par active=true / false / ou les omettre pour tout voir | All | -- (dans le processus) |

_{Tous les outils MCP s'exécutent dans un conteneur sandbox Kali Linux. Les outils Workspace FS et Tâches de fond s'exécutent dans le processus du conteneur de l'agent et opèrent exclusivement sur l'espace de travail par projet à /workspace/<projectId>/ -- la validation des chemins rejette toute tentative de traversée (injection d'identifiant de projet, échappement par lien symbolique, zip-slip, tar-slip). Voir la page wiki Agent Workspace pour la référence complète. Les outils marqués comme dangereux nécessitent une confirmation manuelle avant exécution. Le mode furtif restreint les outils actifs aux opérations passives uniquement ou à cible unique. Note : WPScan est distribué sous la WPScan Public Source License (pas MIT). Gratuit pour les tests d'intrusion et l'usage personnel ; l'utilisation commerciale peut nécessiter une licence distincte auprès de wpscan.com.}

Plugins d'outils MCP (extension de l'arsenal d'outils de l'agent)

Au-delà des 5 serveurs MCP intégrés ci-dessus, vous pouvez brancher n'importe quel serveur Model-Context-Protocol dans l'agent en tant que plugin d'outil (Shodan, GitHub, Censys, Hugging Face, mitmproxy, vos propres MCP internes) sans modifier le code, reconstruire les conteneurs ni exécuter de migrations. Ouvrez Global Settings → MCP Tool Plugins.

Deux voies : choisissez l'un des 39 presets Quick-Add préremplis (OSINT, threat-intel, cloud, scanners d'applications web, reporting, rétro-ingénierie ; des catégories sont étiquetées sur chaque carte), ou cliquez sur Add MCP pour une configuration manuelle. Trois transports pris en charge : stdio, sse, streamable_http. Le bouton orange Discover and add new tools exécute un list_tools() en direct sur le brouillon, répond en moins de 30 secondes et importe automatiquement chaque outil découvert avec son nom, sa description et un args_format dérivé du JSON-Schema (types, enums, valeurs par défaut, min/max, descriptions par propriété). Enregistrez → les outils apparaissent automatiquement dans la Tool Matrix de chaque projet et dans le prompt système de l'agent en ~1 seconde. Pas de redémarrage de l'agent, pas de prisma db push.

Manuel complet de l'opérateur (chaque champ du formulaire, les 39 presets, le flux d'authentification, le workflow de découverte en direct, les règles de validation, le dépannage et le modèle de stockage / sécurité) : page wiki MCP Tool Plugins.

Agent Workspace : Système de fichiers par projet, tâches de fond, déchargement automatique

Regardez la démo : RedAmon Agent Workspace : l'IA exécute 4 tests d'intrusion en parallèle et rédige son propre rapport (YouTube)

Chaque projet dispose d'un répertoire persistant /workspace/<projectId>/ que l'agent, la kali-sandbox et vous-même (via le FileSystem Drawer dans la Red Zone) voyez tous en même temps. Quatre dossiers spécialement conçus sont créés automatiquement et protégés contre le renommage / la suppression : notes/ pour les brouillons de travail et rapports provisoires de l'agent, tool-outputs/ pour les sorties volumineuses déchargées automatiquement, jobs/ pour les journaux des tâches de fond, et uploads/ pour les fichiers que vous y déposez afin que l'agent les lise. La disposition est communiquée à l'agent à chaque étape de réflexion via un WORKSPACE_LAYOUT_BLOCK, et lorsque vous déposez des fichiers dans uploads/, le bloc les met en évidence sous une directive CHECK THESE NOW afin que l'agent les lise avant de reprendre ce qu'il était en train de faire.

L'agent dispose de 24 outils de système de fichiers (fs_read, fs_write, fs_edit, fs_multi_edit, fs_undo_edit, fs_grep, fs_glob, fs_find, fs_diff, fs_symbols, fs_archive, fs_extract, et plus encore) et de 5 outils de tâches de fond (job_spawn, job_status, job_wait, job_cancel, job_list). Les scans longs comme nuclei ou hydra se détachent en tâches asyncio et diffusent leur sortie vers jobs/<id>.log, afin que l'agent puisse rechercher des résultats via fs_grep en cours de route sans bloquer l'étape de raisonnement suivante. Les sorties de plus de 20 Ko sont automatiquement déchargées vers tool-outputs/<utc-iso>-<tool>.txt et le LLM reçoit un extrait début/fin ainsi que le chemin du fichier, de sorte qu'un dump DOM Playwright de 5 Mo ne fait jamais dérailler la fenêtre de contexte. Le drawer présente tout cela avec une navigation en fil d'Ariane, un téléversement par glisser-déposer, un aperçu intégré, les propriétés SHA-256, un téléchargement tar.gz par dossier et un onglet Jobs avec des badges de statut en direct et une fonction d'annulation.

La validation des chemins rejette toute tentative de traversée (injection d'identifiant de projet, échappement par lien symbolique, zip-slip, tar-slip, contournement des dossiers protégés par normalisation) et elle est appliquée côté serveur. Les tâches survivent au redémarrage de l'agent grâce aux métadonnées sur disque : les tâches en cours orphelines passent à interrupted au démarrage, afin que l'interface n'affiche jamais une ligne animée en continu.

Manuel complet de l'opérateur (chaque fonctionnalité du drawer, les 29 outils d'espace de travail, la cartographie des politiques de déchargement automatique, les quatre dossiers protégés, les schémas de coordination fireteam via fs_diff vs_last_read et le modèle de sécurité de la validation des chemins) : page wiki Agent Workspace.

Fireteam : Sous-agents spécialisés en parallèle

Le mode d'exécution le plus puissant de l'agent. Lorsqu'un objectif se décompose en angles d'investigation indépendants (surface d'authentification, carte des routes, politique d'en-têtes ; ou 5 CVE candidates à trier en parallèle), l'agent racine se ramifie en N sous-agents spécialisés qui travaillent en parallèle au sein du même backend, chacun exécutant sa propre boucle ReAct multi-étapes avec une mission ciblée. C'est l'implémentation par RedAmon du schéma architectural Scatter-Gather ReAct (SG-ReAct) : un agent racine qui décide quand déployer l'essaim (fan-out), une fireteam limitée de spécialistes qui travaillent en parallèle, et une étape de convergence (fan-in) qui fusionne leurs découvertes en une vision consolidée unique.

Chaque garantie de sécurité qui s'applique à l'agent racine s'applique aussi à chaque membre : garde-fous stricts, garde-fous souples, contrôle des phases, règles d'engagement et confirmations d'outils dangereux (gérées par membre, en parallèle ; N membres peuvent chacun attendre votre approbation sur leur propre panneau simultanément, sans sérialisation). La récursion est interdite (un membre ne peut pas lui-même déployer une fireteam) et chaque vague a un plafond strict de membres, un budget d'itérations par membre et un délai maximal en temps réel (wall-clock). Le résultat est un parallélisme en temps réel sans chaos de coordination, une terminaison prévisible et une piste d'audit où chaque action est attribuable au spécialiste qui l'a produite.

Wiki : Fireteam (spécialistes en parallèle) | Technique : README.AGENTIC_SYSTEM.md

Fournisseurs de modèles IA

Prend en charge 5 fournisseurs et plus de 400 modèles : OpenAI (GPT-5.2, GPT-5, GPT-4.1), Anthropic (Claude Opus 4.6, Sonnet 4.5), OpenRouter (plus de 300 modèles), AWS Bedrock, et tout point de terminaison compatible OpenAI (Ollama, vLLM, LM Studio, Groq, etc.). Les modèles sont récupérés dynamiquement, aucune liste codée en dur.

Les paramètres des fournisseurs compatibles OpenAI incluent un contrôle d'effort de raisonnement. Activez-le pour envoyer reasoning_effort avec low, medium, high ou max ; laissez-le désactivé pour n'envoyer rien et utiliser la valeur par défaut du modèle. Activez-le uniquement pour les modèles capables de réflexion : un modèle sans capacité de réflexion rejette un niveau, et l'agent réessaie de manière transparente sans celui-ci. Les niveaux d'effort disponibles dépendent du modèle. Les fournisseurs OpenAI canoniques et les points de terminaison compatibles OpenAI non canoniques conservent leur comportement existant.

Wiki : Fournisseurs de modèles IA

Graphe de surface d'attaque

Un graphe de connaissances Neo4j avec 17 types de nœuds et plus de 20 types de relations, la source de vérité unique pour la surface d'attaque de la cible. L'agent l'interroge avant chaque décision via une traduction du langage naturel → Cypher.

Wiki : Graphe de surface d'attaque | Technique : GRAPH.SCHEMA.md

EvoGraph : Évolution de la chaîne d'attaque

Un graphe évolutif persistant qui trace tout ce que fait l'agent IA : exécutions d'outils, découvertes, échecs et décisions stratégiques. Un contexte de chaîne structuré remplace les traces d'exécution plates, ce qui améliore l'efficacité de l'agent de plus de 25 %. La mémoire inter-sessions fait que l'agent ne repart jamais de zéro.

Wiki : EvoGraph | Technique : README.AGENTIC_SYSTEM.md

Chaînes d'attaque parallèles multi-sessions

Lancez plusieurs sessions d'agent simultanées contre le même projet. Chaque session crée sa propre AttackChain dans EvoGraph. Les nouvelles sessions chargent automatiquement les découvertes et les leçons tirées des échecs de toutes les sessions précédentes, évitant ainsi le travail redondant.

Wiki : Guide de l'agent IA

TrafficMind : Capture du trafic HTTP

L'historique de proxy intégré de RedAmon, limité à l'engagement : un proxy d'interception (man-in-the-middle) sans identifiants (propulsé par mitmproxy) se place entre chaque outil offensif et sa cible, enregistre la requête/réponse complète de chaque transaction HTTP, l'étiquette avec qui l'a produite (projet / utilisateur / exécution / outil via une étiquette de contexte HMAC signée) et la stocke dans Postgres via un worker d'ingestion fiable, en INSERT uniquement. Pensez à l'historique HTTP de Burp Suite, sauf qu'il s'active avec un simple interrupteur, attribue chaque requête à sa source et est interrogeable par l'opérateur et l'agent IA.

La capture est désactivée par défaut et contrôlée à deux niveaux (un interrupteur principal global qui exécute le proxy, plus un interrupteur de routage par projet). Huit outils de reconnaissance et huit outils HTTP de l'agent (execute_curl, execute_httpx, execute_playwright, execute_nuclei, execute_katana, execute_ffuf, execute_arjun, execute_wpscan) sont routés, de sorte que le trafic de crawl/fuzz/scan du pipeline comme celui de l'agent lui-même soit capturé, interrogeable et rejouable. Le proxy ne détient aucun secret, un contrôle de sortie SSRF avec épinglage d'IP anti-DNS-rebinding l'empêche de pivoter vers l'infrastructure interne, les en-têtes sensibles sont masqués, et des signaux passifs (paramètres reflétés, en-têtes de sécurité manquants, problèmes d'attributs de cookies) sont calculés sans surcoût sur chaque réponse. Une vue TrafficMind dans la navigation supérieure expose le corpus sous forme de tableau paginé, filtrable, façon Burp, avec un panneau de détail requête/réponse, une exportation CSV/JSON et un nettoyage des corps par comptage de références.L'agent traite le corpus via dix outils proxy_* : huit outils d'analyse en lecture seule (proxy_search, proxy_get, proxy_sitemap, proxy_params, proxy_grep, proxy_diff, proxy_to_curl, proxy_query) et deux outils actifs (proxy_replay, proxy_fuzz) qui renvoient une requête capturée ou la fuzzent à la manière d'Intruder. Les dix sont strictement limités au tenant ; les outils actifs sont épinglés à leur hôte d'origine, marqués comme dangereux, soumis à un contrôle par phase et restreints en mode furtif.

Wiki : TrafficMind | Technique : README.TRAFFIC.md

Reverse Shells

Vue unifiée des sessions actives : meterpreter, reverse/bind shells et listeners. Terminal intégré avec un Command Whisperer qui traduit l'anglais courant en commandes shell.

Wiki : Reverse Shells

RedAmon Terminal

Accès shell PTY interactif complet au conteneur sandbox Kali directement depuis la page du graphe via xterm.js. Accédez à tous les outils de pentest préinstallés (Metasploit, Nmap, Nuclei, Hydra, sqlmap) sans quitter le navigateur. Dispose d'un thème de terminal sombre, d'un indicateur d'état de connexion, d'une reconnexion automatique avec backoff exponentiel, d'un mode plein écran et d'un keepalive côté navigateur.

Wiki : The Graph Dashboard

CypherFix : Remédiation automatisée des vulnérabilités

Pipeline à deux agents : un agent de triage (Triage Agent) exécute 9 requêtes Cypher codées en dur puis utilise un LLM pour corréler, dédupliquer et prioriser les constats. Un agent de correction (CodeFix Agent) clone le dépôt cible, explore la base de code avec 11 outils, implémente les correctifs et ouvre une PR GitHub, reproduisant la conception agentique de Claude Code. Comme le dépôt cloné n'est pas fiable, ses commandes de build/test s'exécutent dans un conteneur sandbox isolé et sans secrets (pas dans l'agent), et le jeton GitHub n'y entre jamais.

Wiki : CypherFix | Technique : README.CYPHERFIX_AGENTS.md

Agent Skills

Un routeur d'intentions propulsé par LLM (Intent Router) classe les demandes des utilisateurs en compétences d'agent : CVE (MSF), injection SQL, XSS, SSRF, RCE, path traversal / LFI / RFI, test d'identifiants, ingénierie sociale, test de disponibilité, ou compétences personnalisées définies par l'utilisateur et téléversées sous forme de fichiers Markdown. Des compétences communautaires prêtes à l'emploi sont fournies pour les tests d'API, XSS, SQLi, XXE, BFLA, SSTI, IDOR / BOLA, désérialisation non sécurisée, mass assignment, prise de contrôle de sous-domaine et téléversement de fichiers non sécurisé — téléchargez le fichier .md et téléversez-le via Global Settings > Agent Skills pour l'activer pour votre utilisateur. Vous pouvez aussi contribuer avec vos propres compétences en ouvrant une PR.

Wiki : Agent Skills | Compétences communautaires

Chat Skills

Injection de références à la demande via la commande /skill dans le chat de l'agent. Les Chat Skills sont des documents de référence tactiques — playbooks d'outils, guides de vulnérabilités, notes spécifiques à un framework — que vous injectez dans le contexte de l'agent exactement quand vous en avez besoin. Tapez /skill ssrf pour charger l'expertise SSRF, ou cliquez sur le bouton du sélecteur de compétences pour afficher une liste consultable. 46 compétences de référence sont fournies avec RedAmon, couvrant les vulnérabilités (JWT, OAuth/OIDC, CSRF, conditions de course, logique métier, pollution des prototypes, ReDoS, contournement 2FA, injection LDAP/XPath, empoisonnement du cache web, CORS, injection d'en-tête hôte, clickjacking, CRLF, et plus), les outils (sqlmap, nuclei, ffuf, nmap, httpx, naabu, katana, subfinder, semgrep), les protocoles (GraphQL, WebSocket, SOAP/WS-Security, SAML), les technologies (Firebase, Supabase), les frameworks (Next.js, FastAPI, NestJS), Active Directory (kill chain, Kerberoasting/ASREPRoast, AD-CS ESC1-15, chemin vers DA avec BloodHound), le cloud (AWS, Azure, GCP) et la post-exploitation (évasion Docker, élévation de privilèges Linux / Windows). Contrairement aux Agent Skills (qui pilotent la classification et les workflows sensibles à la phase), les Chat Skills sont un contexte supplémentaire qui persiste jusqu'à ce que vous les modifiiez ou les supprimiez.

Wiki : Chat Skills | Chat Skills communautaires

GitHub Secret Hunter

Analyse les dépôts GitHub, les gists et l'historique des commits à la recherche de secrets exposés à l'aide de 40+ motifs regex et d'une analyse d'entropie de Shannon.

Wiki : Chasse aux secrets GitHub

TruffleHog Deep Secret Scanner

Analyse les dépôts GitHub à la recherche d'identifiants divulgués à l'aide de 700+ détecteurs, avec vérification automatique de l'activité des secrets découverts. Propulsé par le moteur TruffleHog (trufflesecurity/trufflehog), il détecte les clés API, mots de passe, jetons, certificats et plus encore dans tout l'historique des commits. Les résultats sont stockés sous forme de nœuds TrufflehogScan → TrufflehogRepository → TrufflehogFinding dans le graphe Neo4j. GitHub Hunt et TruffleHog sont tous deux accessibles depuis la modale « Other Scans » de la barre d'outils du graphe.

Project Settings

500+ paramètres configurables répartis sur 16 onglets contrôlant le comportement de chaque outil, des modules de scan aux portes d'approbation des agents. Gérés via l'interface de la webapp.

Wiki : Référence des paramètres du projet

Rules of Engagement (RoE)

Téléversez un document RoE (PDF, TXT, MD, DOCX) pour configurer automatiquement les paramètres du projet et appliquer les contraintes de l'engagement. Application des contraintes à la fois dans le pipeline de reconnaissance (hôtes exclus, limites de débit, fenêtres de temps) et dans les couches de l'agent IA (injection de prompt, plafond de sévérité par phase, restrictions d'outils).

Wiki : Rules of Engagement

Insights Dashboard

30+ graphiques interactifs répartis en 4 sections : chaînes d'attaque et exploits, surface d'attaque, vulnérabilités et renseignement CVE, et vue d'ensemble du graphe. Toutes les données sont extraites en direct de Neo4j et PostgreSQL.

Wiki : Insights Dashboard

Target Guardrail

Garde-fou basé sur un LLM empêchant de cibler des domaines non autorisés : bloque les sites gouvernementaux, les grandes entreprises technologiques, les institutions financières et les plateformes de médias sociaux. Intervient à la fois à la création du projet et à l'initialisation de l'agent. Les domaines gouvernementaux, militaires, éducatifs et d'organisations internationales (.gov, .mil, .edu, .int) sont définitivement bloqués par un garde-fou déterministe strict qui ne peut pas être désactivé.

Wiki : Création d'un projet

Tool Confirmation

Porte de validation humaine (human-in-the-loop) par outil pour les opérations dangereuses. Lorsqu'elle est activée, l'agent fait une pause avant d'exécuter les outils à fort impact (Nmap, Nuclei, Metasploit, Hydra, shell Kali, exécution de code) et présente une invite Allow / Deny intégrée dans la chronologie du chat. Prend en charge les modes de confirmation à outil unique et à vague parallèle (plan). Les utilisateurs peuvent approuver, rejeter ou modifier les arguments de l'outil avant que l'exécution ne se poursuive. Désactivé via l'interrupteur Require Tool Confirmation dans les paramètres du projet.

Wiki : Pentest Agent (Tool Confirmation)

Pentest Reports

Des rapports HTML professionnels, prêts pour les clients, avec 11 sections. Lorsqu'un modèle IA est configuré, 6 sections reçoivent des narrations générées par LLM : résumé exécutif, analyse des risques et tri priorisé de la remédiation. Voir un exemple de rapport.

Wiki : Pentest Reports

Data Export & Import

Sauvegarde et restauration complètes du projet via l'interface web : paramètres, conversations, données du graphe, résultats de recon/GVM/GitHub hunt sous forme d'archive ZIP portable.

Wiki : Data Export & Import

Architecture du système```mermaid

flowchart TB subgraph User["👤 User Layer"] Browser[Web Browser] CLI[Terminal/CLI] end

subgraph Frontend["🖥️ Frontend Layer"]
    Webapp[Next.js Webapp<br/>:3000]
end

subgraph Backend["⚙️ Backend Layer"]
    Agent[AI Agent Orchestrator<br/>FastAPI + LangGraph<br/>:8090]
    ReconOrch[Recon Orchestrator<br/>FastAPI + Docker SDK<br/>:8010]
end

subgraph Tools["🔧 MCP Tools Layer"]
    NetworkRecon[Network Recon Server<br/>Curl + Naabu<br/>:8000]
    Nuclei[Nuclei Server<br/>:8002]
    Metasploit[Metasploit Server<br/>:8003]
    Nmap[Nmap Server<br/>:8004]
end

subgraph Scanning["🔍 Scanning Layer"]
    Recon[Recon Pipeline<br/>Docker Container]
    GVM[GVM/OpenVAS Scanner<br/>Network Vuln Assessment]
    GHHunt[GitHub Secret Hunter<br/>Credential Scanning]
    TruffleHog[TruffleHog Scanner<br/>700+ Secret Detectors]
end

subgraph Data["💾 Data Layer"]
    Neo4j[(Neo4j Graph DB<br/>:7474/:7687)]
    Postgres[(PostgreSQL<br/>Project Settings<br/>:5432)]
end

subgraph LLMProviders["🧠 LLM Providers"]
    OpenAI[OpenAI]
    Anthropic[Anthropic]
    LocalLLM[Local Models<br/>Ollama · vLLM · LM Studio]
    OpenRouter[OpenRouter<br/>300+ Models]
    Bedrock[AWS Bedrock]
end

subgraph External["🌐 External APIs"]
    GitHubAPI[GitHub API<br/>Repos & Code Search]
end

subgraph Targets["🎯 Target Layer"]
    Target[Target Systems]
    GuineaPigs[Guinea Pigs<br/>Test VMs]
end

Browser --> Webapp
CLI --> Recon
Webapp <-->|WebSocket| Agent
Webapp -->|REST + SSE| ReconOrch
Webapp --> Neo4j
Webapp --> Postgres
ReconOrch -->|Docker SDK| Recon
ReconOrch -->|Docker SDK| GVM
ReconOrch -->|Docker SDK| GHHunt
ReconOrch -->|Docker SDK| TruffleHog
Recon -->|Fetch Settings| Webapp
GHHunt -->|GitHub API| GitHubAPI
TruffleHog -->|GitHub API| GitHubAPI
TruffleHog --> Neo4j
Agent -->|API| OpenAI
Agent -->|API| Anthropic
Agent -->|API| LocalLLM
Agent -->|API| OpenRouter
Agent -->|API| Bedrock
Agent --> Neo4j
Agent -->|MCP Protocol| NetworkRecon
Agent -->|MCP Protocol| Nuclei
Agent -->|MCP Protocol| Metasploit
Agent -->|MCP Protocol| Nmap
Recon --> Neo4j
GVM -->|Reads Recon Output| Recon
GVM --> Neo4j
GVM --> Target
GVM --> GuineaPigs
NetworkRecon --> Target
Nuclei --> Target
Metasploit --> Target
Nmap --> Target
NetworkRecon --> GuineaPigs
Nuclei --> GuineaPigs
Metasploit --> GuineaPigs
Nmap --> GuineaPigs

> **Diagrammes d'architecture complets** (flux de données, conteneurs Docker, pipeline de reconnaissance, flux de travail de l'agent, intégration MCP) : **[ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/ARCHITECTURE.md)**
>
> **Pile technologique** (plus de 70 technologies couvrant le frontend, le backend, l'IA, les bases de données et les outils de sécurité) : **[TECH_STACK.md](https://github.com/samugit83/redamon/blob/master/readmes/TECH_STACK.md)**

---

## Composants

| Composant | Description | Documentation |
|-----------|-------------|---------------|
| **Pipeline de reconnaissance** | Pipeline OSINT et de scan de vulnérabilités, parallélisé en fan-out/fan-in | [README.RECON.md](https://github.com/samugit83/redamon/blob/master/readmes/README.RECON.md) |
| **Orchestrateur de reconnaissance** | Gestion du cycle de vie des conteneurs via le SDK Docker | [README.RECON_ORCHESTRATOR.md](https://github.com/samugit83/redamon/blob/master/readmes/README.RECON_ORCHESTRATOR.md) |
| **Courtier de socket Docker** | Reverse-proxy filtrant pour la socket Docker : les conteneurs de scan créés accèdent au démon via celui-ci, et ne peuvent donc créer que les images d'outils connues (liste blanche, aucun montage hôte, aucun conteneur privilégié, aucune image arbitraire) | n/a |
| **Base de données de graphes** | Cartographie de la surface d'attaque Neo4j avec prise en charge multi-tenant | [README.GRAPH_DB.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GRAPH_DB.md) · [GRAPH.SCHEMA.md](https://github.com/samugit83/redamon/blob/master/readmes/GRAPH.SCHEMA.md) |
| **Serveurs d'outils MCP** | Outils de sécurité via le protocole Model Context Protocol (sandbox Kali) | [README.MCP.md](https://github.com/samugit83/redamon/blob/master/readmes/README.MCP.md) |
| **Orchestrateur d'agents IA** | Agent autonome basé sur LangGraph avec le schéma ReAct | [README.AGENTIC_SYSTEM.md](https://github.com/samugit83/redamon/blob/master/readmes/README.AGENTIC_SYSTEM.md) |
| **Agents CypherFix** | Tri automatisé + correction de code + PR GitHub | [README.CYPHERFIX_AGENTS.md](https://github.com/samugit83/redamon/blob/master/readmes/README.CYPHERFIX_AGENTS.md) |
| **Application web** | Tableau de bord Next.js pour la visualisation et l'interaction avec l'IA | [README.WEBAPP.md](https://github.com/samugit83/redamon/blob/master/readmes/README.WEBAPP.md) |
| **Scanner GVM** | Scanner de vulnérabilités réseau Greenbone/OpenVAS (170 000+ NVTs) | [README.GVM.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GVM.md) |
| **Scanner TruffleHog** | Recherche approfondie de secrets avec plus de 700 détecteurs et vérification des identifiants | n/a |
| **Base de données PostgreSQL** | Paramètres de projet, comptes utilisateurs, données de configuration | [README.POSTGRES.md](https://github.com/samugit83/redamon/blob/master/readmes/README.POSTGRES.md) |
| **Environnements de test** | Conteneurs Docker volontairement vulnérables pour des tests en toute sécurité | [README.GPIGS.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GPIGS.md) |

---

## Documentation

| Ressource | Lien |
|----------|------|
| **Wiki complet** (guide utilisateur) | **[github.com/samugit83/redamon/wiki](https://github.com/samugit83/redamon/wiki)** |
| **Déploiement serveur (hôte unique)** | **[Wiki : Déployer sur un serveur](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server)** · [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/master/deploy/single-host/README.md) |
| **Posture de sécurité** (catalogue de défense en profondeur) | **[readmes/README.SECURITY_POSTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/README.SECURITY_POSTURE.md)** |
| Modèle de menace (STRIDE) | [readmes/README.TM.SYSTEM_OVERVIEW.md](https://github.com/samugit83/redamon/blob/master/readmes/README.TM.SYSTEM_OVERVIEW.md) |
| Politique de sécurité | [SECURITY.md](https://github.com/samugit83/redamon/blob/master/SECURITY.md) |
| Développement assisté par IA | **[Wiki : Livrez des PR parfaites avec l'IA](https://github.com/samugit83/redamon/wiki/AI-Assisted-Development)** |
| Guide du développeur | [readmes/README.DEV.md](https://github.com/samugit83/redamon/blob/master/readmes/README.DEV.md) |
| Diagrammes d'architecture | [readmes/ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/ARCHITECTURE.md) |
| Stack technologique | [readmes/TECH_STACK.md](https://github.com/samugit83/redamon/blob/master/readmes/TECH_STACK.md) |
| Dépannage | [readmes/TROUBLESHOOTING.md](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md) |
| Journal des modifications | [CHANGELOG.md](https://github.com/samugit83/redamon/blob/master/CHANGELOG.md) |
| Avis de non-responsabilité complet | [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/master/DISCLAIMER.md) |
| Licences tierces | [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md) |
| Licence | [LICENSE](https://github.com/samugit83/redamon/blob/master/LICENSE) |

---

## Dépannage

RedAmon est entièrement dockerisé et fonctionne sur n'importe quel OS avec Docker Compose v2+. Pour des correctifs spécifiques à un OS (Linux, Windows, macOS), consultez le **[Guide de dépannage](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md)** ou le **[Wiki](https://github.com/samugit83/redamon/wiki/Troubleshooting)**.

---

## RedAmon HackLab

<table>
<tr>
<td width="280" align="center">
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab">
    <img src="https://raw.githubusercontent.com/samugit83/redamon/HEAD/assets/hacklab.png" alt="RedAmon HackLab" width="260"/>
  </a>
</td>
<td>
  <h3>Envie de voir RedAmon réfléchir comme un vrai pentester ?</h3>
  <p>Explorez des sessions d'attaque en direct -- chaque étape, chaque pivot, chaque exploit -- couvrant 15 catégories de vulnérabilités sur une cible réelle. Journaux de session complets, guides pas à pas décodés et enregistrements vidéo montrant l'agent compromettre de manière autonome un serveur multi-services à partir de zéro.</p>
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab"><b>Explorez le HackLab &rarr;</b></a>
  &nbsp;&nbsp;|&nbsp;&nbsp;
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab#community-sessions"><b>Soumettez votre propre session &rarr;</b></a>
  <br/><sub>Vous avez une session d'agent impressionnante sur votre propre cible ? Partagez-la avec la communauté -- journal de session + vidéo YouTube.</sub>
</td>
</tr>
</table>

---

## Vitrine communautaire

Vidéos, analyses et expériences réelles de professionnels de la sécurité utilisant RedAmon sur le terrain. Envie d'être mis en avant ? Consultez le parcours [Content Creator](https://github.com/samugit83/redamon/blob/master/CONTRIBUTING.md#content-creator) dans CONTRIBUTING.md.

### Vidéos

| Titre | Lien |
|-------|------|
| RedAmon v2.2.0, Test d'ingénierie sociale : livraison d'une charge utile menant à un accès shell | [Regarder](https://youtu.be/kVjV9K_eks4) |
| Validation de CVE par agent IA : au-delà des outils standard | [Regarder](https://youtu.be/rypmP1SJon8) |
| RedAmon 2.0, De 0 à 1000 étoiles GitHub en 10 jours : attaques parallèles multi-agents | [Regarder](https://youtu.be/afViJUit0xE) |
| Construisez un agent IA de red team autonome à partir de zéro : tutoriel complet LangGraph + Metasploit + Neo4j | [Regarder](https://youtu.be/mO5CCkYlY94) |

### Études de cas réelles

| Qui | Quoi | Lien |
|-----|------|------|
| Nipun Dinudaya | A déployé RedAmon sur le site web d'une entreprise et identifié une vulnérabilité critique d'injection SQL qui aurait pu entraîner une exposition importante de données | [Lire sur LinkedIn](https://www.linkedin.com/posts/nipun-dinudaya-6159b32bb_redamon-cybersecurity-penetrationtesting-ugcPost-7431233870253166592-aLvb) |
| Venkata Bhargav CH S | A utilisé RedAmon pendant un stage chez Ascent e-Digit Solutions : reconnaissance pratique, analyse DNS et cartographie de la surface d'attaque | [Lire sur LinkedIn](https://www.linkedin.com/posts/venkata-bhargav-cybersecurity_cybersecurity-ethicalhacking-redteam-share-7434940660803182592-e9En) |

### Guides communautaires

| Qui | Quoi | Lien |
|-----|------|------|
| MrGood | Maîtriser RedAmon : un guide complet d'installation sur Kali Linux, traitant des défis Docker spécifiques à Kali et de la posture de sécurité | [Lire sur Medium](https://cyberaccoon.medium.com/mastering-redamon-a-comprehensive-guide-to-installation-on-kali-linux-ea544e6f5b9f) |
| Bogdan Caraman | Comment installer RedAmon sur Debian 13 (Trixie) avec OpenRouter : guide pas à pas avec configuration Docker, IP statique et automatisation via systemd | [Lire sur le blog](https://blog.bogdancaraman.com/install-redamon-debian-13-openrouter/) |

---

## Contribution

Les contributions sont les bienvenues ! Veuillez lire [CONTRIBUTING.md](https://github.com/samugit83/redamon/blob/master/CONTRIBUTING.md) pour les directives de démarrage, les conventions de style de code et le processus de pull request.

---

## Mainteneurs

**Samuele Giampieri** : créateur, mainteneur et architecte de la plateforme IA · [LinkedIn](https://www.linkedin.com/in/samuele-giampieri-b1b67597/) · [GitHub](https://github.com/samugit83) · [Devergo Labs](https://www.devergolabs.com/)

**Ritesh Gohil** : mainteneur et chercheur principal en sécurité · [LinkedIn](https://www.linkedin.com/in/riteshgohil25/) · [GitHub](https://github.com/L4stPL4Y3R)

---

## Contact

Pour toute question, retour ou demande de collaboration : **[email protected]**

---

## Mentions légales

> **Local par défaut ; le déploiement serveur dispose d'un parcours renforcé pris en charge.** Par défaut, RedAmon est conçu pour fonctionner sur une **machine locale** et n'inclut pas en soi de contrôles de sécurité orientés Internet. Pour l'exécuter sur un serveur public accessible depuis Internet, utilisez le **déploiement mono-hôte renforcé** dans [`deploy/single-host/`](https://github.com/samugit83/redamon/blob/master/deploy/single-host), qui place toute la pile derrière nginx + TLS, un pare-feu hôte, un durcissement SSH et une origine HTTPS publique unique, chaque service interne étant lié à loopback. Exécuter la pile **brute** (sans ce déploiement) sur une IP publique exposerait des services internes non authentifiés ; toute utilisation en dehors d'un réseau local de confiance sans le déploiement renforcé est donc entièrement à vos risques et périls.

Ce projet est distribué sous la [licence MIT](https://github.com/samugit83/redamon/blob/master/LICENSE).

RedAmon intègre plusieurs outils tiers sous leurs propres licences (MIT, Apache-2.0, BSD, GPL-2.0/3.0, AGPL-3.0, LGPL et la WPScan Public Source License). Le code source de tous les composants sous licence AGPL est disponible dans leurs dépôts en amont. L'inventaire complet et les obligations de licence sont documentés dans [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md).

> **Remarque sur l'utilisation commerciale** : l'image sandbox Kali inclut **WPScan**, qui est régi par la WPScan Public Source License. WPScan restreint l'utilisation commerciale (SaaS, offres de produits payants, services à valeur ajoutée) sans licence distincte de l'équipe WPScan. Les missions de pentest et l'utilisation personnelle sont autorisées. Si vous avez l'intention d'utiliser RedAmon dans un produit ou service commercial, examinez [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md) avant toute distribution.

Consultez [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/master/DISCLAIMER.md) pour les conditions d'utilisation complètes, la politique d'utilisation acceptable et les exigences de conformité légale.

---

<p align="center">
  <strong>Utilisez de manière responsable. Testez de manière éthique. Défendez mieux.</strong>
</p>