PhantomRecon

PhantomRecon est un outil d'automatisation Red Team modulaire, piloté par agents et basé sur CLI, conçu pour démontrer des workflows offensifs de sécurité autonomes propulsés par l'IA (Gemini de Google via Agent Development Kit - ADK).

Démarrage rapide (CLI)

• Lancez la console interactive (style Metasploit) :
  root@kitploit:~

  python -m phantomrecon
  

• Exécution one-shot non interactive :
  root@kitploit:~

  python -m phantomrecon --target example.com --auto \
    --nmap-timeout 30 --nmap-top-ports 100 --nmap-args "-sV -Pn"
  

Options CLI

• --target <domain|ip> : Cible à évaluer
• --auto : Exécute recon → plan → routage → rapport
• --nmap-timeout <seconds> : Remplace NMAP_TIMEOUT
• --nmap-top-ports <N> : Remplace NMAP_TOP_PORTS
• --nmap-args "..." : Ajoute aux arguments Nmap (NMAP_ARGS)
• --nmap-disable : Désactive Nmap (définit NMAP_DISABLE=1)

Les variables d'environnement sont également prises en charge directement : NMAP_TIMEOUT, NMAP_TOP_PORTS, NMAP_ARGS, NMAP_DISABLE.

Hygiène opérationnelle

• Les rapports ne sont pas versionnés. .gitignore exclut reports/* sauf reports/sample_report.md.
• Les rapports générés en HTML/MD se trouvent localement sous reports/ uniquement.
• Supprimez ou archivez les rapports selon les besoins ; ils ne sont jamais inclus dans les commits.

Conçu comme une preuve de concept, il simule l'identification d'une cible, l'exécution d'une reconnaissance étendue (Nmap, DNS, recherche web), la planification d'une stratégie d'attaque à l'aide d'un LLM, l'exécution conditionnelle d'exploits simulés et la génération d'un rapport.

Structure du projet

phantomrecon/
├── phantomrecon/             # Main package (exported orchestrator agent)
│   ├── __init__.py
│   ├── __main__.py           # CLI entrypoint (interactive and non-interactive)
│   └── agent/                # Agent graph and tools
├── agents/                   # Python modules containing agent/tool logic
│   ├── recon_logic.py        # Nmap, DNS (dig), seeded web analysis; ADK search enabled
│   ├── routing_logic.py      # Logic for the Exploit Router agent
│   ├── exploit_web_logic.py  # Functions for web exploits (currently simulated)
│   ├── exploit_sql_logic.py  # Functions for SQL exploits (currently simulated)
│   └── report_logic.py       # Functions for report generation using session state
├── configs/
│   └── targets.json          # (Optional) Target configuration
├── data/
│   └── dummy_scan_output.json # Example Nmap data if no target specified
├── demos/
│   └── walkthrough.md        # Demo steps
├── prompts/                  # Prompt templates for LLM agents
├── reports/
│   └── sample_report.md      # Example output report
├── requirements.txt          # Python dependencies (includes google-adk)
├── .gitignore                # Files excluded from version control
└── LICENSE                   # MIT License

Workflow actuel

1. Reconnaissance parallèle (recon_workflow - Agent parallèle) :
   • Exécute un scan Nmap (nmap_tool)
   • Exécute des interrogations DNS/WHOIS (dns_tool)
   • Simule une recherche web (web_search_tool)
   • État : chaque outil écrit ses résultats dans l'état de session.
2. Agrégation (aggregation_tool) :
   • Combine les résultats du workflow parallèle.
   • État : écrit aggregated_recon_data dans l'état de session.
3. Planification LLM (planning_agent - LlmAgent) :
   • Reçoit les données agrégées.
   • Utilise Gemini et attack_planner_prompt.txt pour générer un plan d'attaque JSON.
   • État : écrit attack_plan dans l'état de session.
4. Routage des exploits (exploit_router - RouterAgent) :

Installation

1. Clonez le dépôt.
2. Assurez-vous que les prérequis sont installés : python3, pip, nmap, dig, whois, sqlmap, wapiti, wpscan, searchsploit.
3. Créez un environnement virtuel :
   root@kitploit:~

   python3 -m venv venv
   source venv/bin/activate  # On Windows use `venv\Scripts\activate`
   

4. Installez les dépendances :
   root@kitploit:~

   pip install -r requirements.txt
   

5. Configurez les clés API (env) :
   • Copiez .env.example vers .env (si l'exemple existe) ou modifiez .

Avis de sécurité

Cet outil est destiné uniquement aux tests de sécurité autorisés et à des fins éducatives. Ne l'utilisez pas contre des systèmes sans autorisation explicite.

Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

Prérequis

• Python 3.9+
• pip (installateur de paquets Python)
• Nmap (sudo apt install nmap ou brew install nmap)
• dig (sudo apt install dnsutils ou brew install bind)
• whois (sudo apt install whois ou brew install whois)
• sqlmap (sudo apt install sqlmap ou brew install sqlmap)
• wapiti (sudo apt install wapiti ou brew install wapiti)
• wpscan (sudo apt install ruby-full puis gem install wpscan ou brew install wpscan)

Fonctionnalités clés

• Workflow basé sur des agents : utilise l'Agent Development Kit (ADK) de Google pour une structure modulaire.
• Saisie interactive de la cible : utilise l'interface adk web pour demander à l'utilisateur l'IP/le domaine cible.
• Évaluation multi-étapes :
  • Reconnaissance :
    • Scan de ports Nmap (Réel)
    • Interrogations DNS/WHOIS avancées (Réel : dig, nslookup, dig +trace, tentative AXFR, whois)
    • Recherche web (Réelle, via Google Search)
    • Analyse avancée du contenu web (Réelle : liens, formulaires, commentaires, scripts, en-têtes, e-mails, détection technologique de base)
    • Agrégation des données
  • Planification : le LLM (Gemini) analyse les données de reconnaissance pour générer un plan d'attaque priorisé (avec validation).
  • Exploitation (routage conditionnel) : exécute les tests en fonction du plan :
    • Web : fichiers par défaut, mauvaises configurations (listage de répertoire), injection SQL (via sqlmap avec des options affinées), scan Wapiti (résultats analysés), WPScan (résultats analysés, conditionnel), XSS réfléchie de base, injection de commande de base - (Vérifications réelles)
    • SQL : identifiants par défaut (MySQL/PostgreSQL), vulnérabilités de version (via searchsploit avec une requête affinée), énumération post-authentification (via connexion directe sqlmap) - (Vérifications réelles)

Architecture (Système multi-agents autonome)

PhantomRecon utilise une architecture multi-agents entièrement autonome propulsée par l'Agent Development Kit (ADK) de Google.

Composants principaux

Agent orchestrateur senior (gemini-1.5-pro-latest)

• Prise de décision autonome et planification stratégique
• Sélectionne dynamiquement les agents spécialisés à invoquer
• Itère en fonction des résultats (aucune séquence fixe)
• Effectue des audits de sécurité complets en toute autonomie

Agents de sécurité spécialisés

• Agent de reconnaissance : scan de ports, énumération DNS, détection de services
• Spécialiste de la sécurité web : XSS, CSRF, SSRF, Path Traversal, Open Redirect
• Spécialiste des injections SQL : toutes les techniques d'injection SQL sur les principales bases de données
• Spécialiste SSH/réseau : audit de sécurité SSH, test des services réseau
• Spécialiste de l'authentification : contournement d'authentification, sécurité des sessions, élévation de privilèges
• Agent de planification : planification stratégique des attaques en fonction des résultats
• Agent de reporting : génération de rapports de sécurité complets

Fonctionnement autonome

L'orchestrateur agit comme un testeur d'intrusion senior :

1. Accepte un domaine/IP cible
2. Planifie la stratégie de reconnaissance
3. Analyse les résultats et identifie les surfaces d'attaque
4. Invoque dynamiquement les agents spécialisés en fonction des découvertes
5. Itère et adapte l'approche à mesure que de nouvelles informations émergent
6. Génère un rapport d'audit de sécurité complet

Fonctionnalités clés :

• Aucun workflow fixe - l'orchestrateur décide de la stratégie
• Exécution parallèle des agents pour plus d'efficacité
• Analyse itérative approfondie des vulnérabilités découvertes
• Approche adaptative basée sur les caractéristiques de la cible
• Autonomie complète de la saisie de la cible au rapport final

Détails techniques

• Gestion d'état via context.session.state (sessions ADK)
• Reconnaissance parallèle avec visualisation de la progression en temps réel (bibliothèque Rich)
• Exécution asynchrone de commandes avec délais d'attente (executor_fix.py)
• Paramètres de scan configurables (variables d'environnement pour Nmap, etc.)

Utilisation

Exécution via CLI (recommandé) :

python -m phantomrecon --target <domain|ip> --auto

Console interactive :

python -m phantomrecon

Exécuteur ADK optionnel :

adk run phantomrecon -- --target <domain|ip> --auto