Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
guardian-cli — Guardian est un outil CLI d'automatisation de tests d'intrusion prêt pour la production, alimenté par l'IA, qui exploite Google Gemini et LangChain pour orchestrer des workflows de tests d'intrusion intelligents et étape par étape, tout en maintenant les normes de hacking éthique. | Kitploit
Outils/GitHubGitHub/zakirkun/guardian-cli
OSINT (Renseignement de Sources Ouvertes)Frameworks de Tests d'IntrusionScanners de VulnérabilitésFrameworks d'ExploitationSécurité WebSécurité RéseauTests d'IntrusionSécurité CloudSécurité MobileApprentissage et ÉducationSécurité de l'IA
1.8k361il y a 1 moisVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
GitHub
zakirkun/guardian-cli

guardian-cli

Voir le dépôt

À propos

Guardian est un outil CLI d'automatisation de tests d'intrusion prêt pour la production, alimenté par l'IA, qui exploite Google Gemini et LangChain pour orchestrer des workflows de tests d'intrusion intelligents et étape par étape, tout en maintenant les normes de hacking éthique.

Partager
Guardian Logo

🔐 Guardian

Plateforme d'automatisation de tests d'intrusion pilotée par IA

Licence: MIT Python 3.11+ Style de code: black

Guardian est un framework d'automatisation de tests d'intrusion de niveau entreprise piloté par IA qui combine plusieurs fournisseurs d'IA (OpenAI GPT-4, Claude, Google Gemini, OpenRouter, Requesty) avec des outils de sécurité éprouvés pour fournir des évaluations de sécurité intelligentes et adaptatives avec une collecte complète de preuves.

Fonctionnalités • Installation • Démarrage rapide • Documentation • Contribuer


⚠️ Avertissement légal

Guardian est conçu exclusivement pour des tests de sécurité autorisés et à des fins éducatives.

  • ✅ Utilisation légale : Tests d'intrusion autorisés, recherche en sécurité, environnements éducatifs
  • ❌ Utilisation illégale : Accès non autorisé, activités malveillantes, toute forme de cyberattaque

Vous êtes entièrement responsable de vous assurer d'avoir une autorisation écrite explicite avant de tester tout système. L'accès non autorisé à des systèmes informatiques est illégal en vertu de lois telles que le Computer Fraud and Abuse Act (CFAA), le RGPD, et les législations internationales équivalentes.

En utilisant Guardian, vous acceptez de ne l'utiliser que sur des systèmes dont vous êtes propriétaire ou pour lesquels vous avez une autorisation explicite de test.


✨ Fonctionnalités

🤖 Intelligence IA multi-fournisseurs

  • 7 fournisseurs d'IA supportés : OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini), OpenRouter, Requesty, Ollama (local), compatible OpenAI (vLLM, LM Studio, Together, Groq)
  • Contrat de fournisseur via plugins : Les fournisseurs tiers sont livrés via [project.entry-points."guardian.providers"] — pas besoin de fork
  • Architecture multi-agents : Agents IA spécialisés (Planificateur, Sélecteur d'outils, Analyste, Rapporteur) plus des rôles de triage par débat (Avocat rouge, Avocat bleu, Juge) et Triage visuel
  • Triage par débat multi-agents : Débat à trois rôles (rouge/bleu/juge) sur des résultats ambigus — F1 ≥ seuil de référence mono-agent +5pp
  • Triage visuel avec LLM vision : Capture d'écran sans tête + enrichissement analytique basé sur les images via gpt-4o / Claude 3.5+ / Gemini 1.5+
  • Base de connaissances RAG : SQLite + FTS5 pour une recherche contextuelle sur les flux CVE / CWE / MITRE ATT&CK — élimine les références CVE hallucinées
  • Routage du modèle Juge : think_deeply swap-and-restore — le grand modèle pense, le petit modèle juge, ~10x de réduction de coût
  • Sélection d'outils apprise : Classeur hors ligne entraîné sur la télémétrie des sessions ; s'abstient en cas de faible confiance et revient au sélecteur LLM
  • Tests adaptatifs : L'IA ajuste les tactiques en fonction des vulnérabilités découvertes et des rendements d'outils antérieurs
  • Filtrage des faux positifs : Le triage par débat réduit le bruit ; chemin bon marché ignoré lorsque fp_probability est décisif

🛠️ Arsenal d'outils étendu

50 outils de sécurité intégrés dans 10 catégories :

📊 Collecte de preuves améliorée

  • Traçabilité d'exécution : Chaque résultat lié à l'exécution de son outil source via execution_id
  • Historique complet des commandes : Sortie complète de l'outil conservée avec chaque résultat
  • Stockage des preuves brutes : Extraits de sortie liés aux résultats
  • Preuves visuelles : Captures d'écran par URL, attachées aux résultats web
  • Reconstruction de session : session_<id>.json sauvegardé par points de contrôle atomiques, permet la reprise avec --resume

🔄 Système de workflow intelligent (DSL v2)

  • Ordonnanceur DAG : Les étapes avec depends_on s'exécutent en parallèle jusqu'à max_parallel_tools
  • Modèles Jinja2 (bac à sable) : parameters: {key: "{{ <id>.parsed.alive_hosts }}"} résout les résultats des étapes précédentes
  • Étapes conditionnelles : Les clauses when: conditionnent l'exécution en fonction de la sortie précédente
  • Reprise : --resume reprend après la dernière étape terminée
  • Priorité des paramètres : YAML du workflow > bloc de configuration > valeurs par défaut des outils
  • Agents personnalisés : agent: debate | visual | analyst sur les étapes d'analyse
  • Plusieurs formats de rapport : Markdown, HTML, JSON

📤 Intégrations de sortie (B14)

  • SARIF v2.1.0 : Compatible GitHub, inclut security-severity, déduplication fingerprints depuis execution_id
  • DefectDojo : Téléversement REST direct
  • Slack : Webhook avec code couleur basé sur la sévérité
  • Déclenché via : guardian report --export sarif --export defectdojo --export slack

🔒 Sécurité et conformité

  • Validation de périmètre par résolution DNS : Contourne les contournements de type SSRF ; les plages privées RFC1918 sont bloquées
  • Défense contre l'injection de prompt : Toute sortie d'outil encapsulée dans des délimiteurs <UNTRUSTED_TOOL_OUTPUT> + suppression des séquences ANSI
  • Nettoyage des clés API : Les journaux et rapports masquent les secrets à l'écriture
  • Porte de confirmation : Les outils Actifs+ (intrusifs/destructeurs) nécessitent une approbation explicite de l'utilisateur
  • Journalisation d'audit : Journaux tournants de chaque décision et action de l'IA
  • Mode sécurisé : Empêche les actions destructrices par défaut

📋 Rapports professionnels

  • Recalcul CVSS v3.1 : Valide les scores déclarés par rapport au calcul vectoriel ; signale les écarts
  • Résumés exécutifs : Aperçus non techniques
  • Analyses techniques approfondies : Résultats avec preuves, CVSS, CWE, CVE, technique MITRE
  • Traces de décision de l'IA : Utilisation de jetons, coût, chaîne de pensée par agent
  • Sections de triage visuel : Enrichissement basé sur les images intégré dans les descriptions

⚡ Performance et efficacité

  • Asynchrone partout : Exécution des outils via sous-processus asyncio ; agents asynchrones
  • Chargement paresseux des outils : 50 outils enregistrés, aucun importé avant utilisation — --help reste sous 500ms
  • Exécution parallèle en DAG : Les étapes indépendantes s'exécutent simultanément par génération
  • Automatisation des workflows : 13+ workflows fournis (reconnaissance, web, réseau, AD, mobile, red-team LLM, SAST, API)

📋 Prérequis

Requis

  • Python 3.11 ou supérieur (Télécharger)
  • Clé API d'un fournisseur d'IA (choisissez-en une) :
    • Clé API OpenAI (Obtenir ici)
    • Clé API Anthropic (Obtenir ici)
    • Clé API Google AI Studio (Obtenir ici)
    • Clé API OpenRouter (Obtenir ici)
    • Clé API Requesty (Obtenir ici)
  • Git (pour cloner le dépôt)

Outils optionnels (pour toutes les fonctionnalités)

Guardian peut utiliser intelligemment ces outils s'ils sont installés :

Remarque : Guardian fonctionne sans outils externes mais avec des capacités de scan limitées. L'IA s'adaptera en fonction des outils disponibles.


🚀 Installation

Étape 1 : Cloner le dépôt```bash

git clone https://github.com/zakirkun/guardian-cli.git cd guardian-cli

root@kitploit:~
### Étape 2: Configurer l'environnement Python

**Linux/macOS:**```bash
python3 -m venv venv
source venv/bin/activate
pip install -e .

Windows:```powershell python -m venv venv .\venv\Scripts\activate pip install -e .

root@kitploit:~
### Étape 3 : Configurer le fournisseur d'IA

Guardian prend en charge plusieurs fournisseurs d'IA. Configurez votre fournisseur préféré dans `config/guardian.yaml` :```yaml
# config/guardian.yaml
ai:
  # Choose your provider: openai, claude, gemini, openrouter, or requesty
  provider: openai
  
  # OpenAI Configuration (recommended)
  openai:
    model: gpt-4o
    api_key: sk-your-api-key-here  # Or set OPENAI_API_KEY env var
  
  # Claude Configuration
  claude:
    model: claude-3-5-sonnet-20241022
    api_key: null  # Or set ANTHROPIC_API_KEY env var
  
  # Gemini Configuration
  gemini:
    model: gemini-2.5-pro
    api_key: null  # Or set GOOGLE_API_KEY env var
  
  # OpenRouter Configuration
  openrouter:
    model: anthropic/claude-3.5-sonnet
    api_key: null  # Or set OPENROUTER_API_KEY env var

  # Requesty Configuration (OpenAI-compatible gateway)
  requesty:
    model: openai/gpt-4o-mini
    api_key: null  # Or set REQUESTY_API_KEY env var

Ou utilisez des variables d'environnement :```bash

Linux/macOS

export OPENAI_API_KEY="sk-your-key-here" export ANTHROPIC_API_KEY="sk-ant-your-key-here" export GOOGLE_API_KEY="your-gemini-key" export OPENROUTER_API_KEY="your-router-key" export REQUESTY_API_KEY="your-requesty-key"

Windows PowerShell

$env:OPENAI_API_KEY="sk-your-key-here" $env:ANTHROPIC_API_KEY="sk-ant-your-key-here"

root@kitploit:~
### Étape 4 : Initialiser la configuration```bash
# Verify installation
python -m cli.main --help

# Check AI provider status
python -m cli.main models

🎯 Démarrage rapide

Commandes de base```bash

List available workflows

python -m cli.main workflow list

View AI providers and models

python -m cli.main models

Run with specific provider

python -m cli.main workflow run --name web_pentest --target example.com --provider openai

root@kitploit:~
### Exemples de scénarios d'utilisation

#### 1. Test d'intrusion rapide d'application web```bash
# Fast security check with evidence capture
python -m cli.main workflow run --name web_pentest --target https://dvwa.csalab.app

Résultat attendu :

  • ✅ Découverte HTTP avec httpx
  • ✅ Scan de vulnérabilités avec nuclei
  • ✅ Liens complets des preuves (commandes + sorties)
  • ✅ Rapport Markdown avec les résultats

2. Évaluation complète du réseau```bash

Full network penetration test

python -m cli.main workflow run --name network --target 192.168.1.0/24

root@kitploit:~
#### 3. Workflow personnalisé avec paramètres```bash
# Run with workflow-specific parameters
# Parameters in workflow YAML override config defaults
python -m cli.main workflow run --name web_pentest --target example.com

Priorité des paramètres du workflow :

  1. Paramètres YAML du workflow (priorité la plus élevée)
  2. Paramètres du fichier de configuration
  3. Valeurs par défaut de l'outil (priorité la plus basse)

4. Générer un rapport à partir de la session```bash

Create HTML report with evidence

python -m cli.main report --session 20260203_175905 --format html

root@kitploit:~
#### 5. Changer de fournisseurs d'IA```bash
# Use OpenAI GPT-4
python -m cli.main workflow run --name web_pentest --target example.com --provider openai

# Use Claude
python -m cli.main workflow run --name web_pentest --target example.com --provider claude

# Use Gemini
python -m cli.main workflow run --name web_pentest --target example.com --provider gemini

# Local Ollama (no cloud)
OLLAMA_HOST=http://localhost:11434 python -m cli.main workflow run --name recon --target scanme.nmap.org --provider ollama

# Any OpenAI-compatible endpoint (vLLM, LM Studio, Together, Groq)
python -m cli.main workflow run --name web_pentest --target example.com --provider openai_compatible

6. Base de connaissances (ancrage RAG)```bash

Seed bundled offline corpus

python -m cli.main kb seed

Show corpus stats

python -m cli.main kb status

Ad-hoc retrieval

python -m cli.main kb query "log4j JNDI" --top 5

Ingest external feed (NVD JSON / MITRE STIX / nuclei metadata)

python -m cli.main kb update --kind cve --file ./nvd-2025.json

root@kitploit:~
Activer l'ancrage de l'analyste dans `config/guardian.yaml` :```yaml
rag:
  enabled: true
  top_k: 5

7. Tri de débat multi-agents```bash

Workflow YAML uses agent: debate on an analysis step

python -m cli.main workflow run --name web_pentest_with_debate --target https://example.com

root@kitploit:~
Trois rôles (avocat rouge, avocat bleu, juge) débattent uniquement des résultats ambigus — les verdicts confiants évitent le débat pour limiter le coût en tokens.

#### 8. Triage visuel (vision-LLM)```bash
# Captures full-page screenshots and feeds them to a vision-capable provider
python -m cli.main workflow run --name web_visual_pentest --target https://example.com --provider openai

Nécessite playwright: pip install playwright && python -m playwright install chromium. Ignoré silencieusement lorsque le fournisseur actif n'a pas de support visuel.

9. Exportateurs de sortie (SARIF / DefectDojo / Slack)```bash

SARIF (GitHub code-scanning friendly)

python -m cli.main report --session 20260203_175905 --export sarif

Multiple sinks at once

python -m cli.main report --session 20260203_175905 --export sarif --export defectdojo --export slack
--slack-webhook https://hooks.slack.com/services/...

root@kitploit:~
#### 10. Telemetry + Learned Ranker (offline)```bash
# Anonymise sessions into JSONL (no raw targets, no commands, no secrets)
python -m cli.main telemetry export ./reports --out telemetry.jsonl

# Train the offline tool ranker
python -m cli.main telemetry train telemetry.jsonl

# Inspect what the ranker learned
python -m cli.main telemetry status

Activer dans la configuration :```yaml ai: use_learned_ranker: true # ToolAgent calls ranker before LLM selector

root@kitploit:~
> **Utilisateurs Windows** : Utilisez `python -m cli.main` au lieu de `guardian`

---

## 🔧 Configuration

### Référence complète de configuration

Modifiez `config/guardian.yaml` pour personnaliser le comportement de Guardian :```yaml
# AI Configuration
ai:
  provider: openai  # openai, claude, gemini, openrouter, requesty
  
  openai:
    model: gpt-4o
    api_key: sk-your-key  # Or use OPENAI_API_KEY env var
  
  claude:
    model: claude-3-5-sonnet-20241022
    api_key: null
  
  gemini:
    model: gemini-2.5-pro
    api_key: null
  
  temperature: 0.2
  max_tokens: 8000

# Penetration Testing Settings
pentest:
  safe_mode: true              # Prevent destructive actions
  require_confirmation: true   # Confirm before each step
  max_parallel_tools: 3        # Concurrent tool execution
  max_depth: 3                 # Maximum scan depth
  tool_timeout: 300            # Tool timeout in seconds

# Output Configuration
output:
  format: markdown             # markdown, html, json
  save_path: ./reports
  include_reasoning: true
  verbosity: normal            # quiet, normal, verbose, debug

# Scope Validation
scope:
  blacklist:                   # Never scan these
    - 127.0.0.0/8
    - 10.0.0.0/8
    - 172.16.0.0/12
    - 192.168.0.0/16
  require_scope_file: false
  max_targets: 100

# Tool Configuration (defaults)
tools:
  httpx:
    threads: 50
    timeout: 10
    tech_detect: true
  
  nuclei:
    severity: ["critical", "high", "medium"]
    templates_path: ~/nuclei-templates
  
  nmap:
    default_args: "-sV -sC"
    timing: T4

Paramètres de workflow

Créez des workflows personnalisés dans le répertoire workflows/ :```yaml

workflows/custom_web.yaml

name: custom_web_assessment description: Custom web security testing

steps:

  • name: http_discovery type: tool tool: httpx parameters: threads: 100 # Override config default (50) timeout: 15 # Override config default (10) tech_detect: true

  • name: vulnerability_scan type: tool tool: nuclei parameters: severity: ["critical", "high"] # Override config templates_path: ".shared/nuclei/templates/"

  • name: generate_report type: report

    Format will use config default (markdown)

root@kitploit:~
**Priorité des paramètres :**
- Les paramètres de workflow **remplacent** les paramètres de configuration
- Les paramètres de configuration **remplacent** les valeurs par défaut de l'outil
- Workflows autonomes et réutilisables

---

## 📖 Documentation

### Guides utilisateur
- **[Guide de démarrage rapide](https://github.com/zakirkun/guardian-cli/blob/HEAD/QUICKSTART.md)** - Mettez-vous en route en 5 minutes
- **[Référence des commandes](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/)** - Documentation détaillée pour toutes les commandes
- **[Guide de configuration](https://github.com/zakirkun/guardian-cli/blob/HEAD/config/guardian.yaml)** - Référence complète de la configuration
- **[Guide des workflows](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/WORKFLOW_GUIDE.md)** - Créer des workflows personnalisés
- **[Guide d'évaluation](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/EVAL_GUIDE.md)** - Exécuter et étendre le harnais d'évaluation
- **[Guide des plugins](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/PLUGIN_GUIDE.md)** - Distribution de fournisseurs et outils tiers
- **[Journal des modifications](https://github.com/zakirkun/guardian-cli/blob/HEAD/CHANGELOG.md)** - Historique des versions et notes de migration

### Guides développeur
- **[Création d'outils personnalisés](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/TOOLS_DEVELOPMENT_GUIDE.md)** - Créez vos propres intégrations d'outils
- **[Développement de workflows](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/WORKFLOW_GUIDE.md)** - Créez des workflows de test personnalisés
- **[Outils disponibles](https://github.com/zakirkun/guardian-cli/blob/HEAD/tools/README.md)** - Aperçu des outils intégrés

### Vue d'ensemble de l'architecture```
Guardian Architecture:
┌─────────────────────────────────────────┐
│         AI Provider Layer               │
│  (OpenAI, Claude, Gemini, OpenRouter,   │
│   Requesty)                             │
└─────────────────────────────────────────┘
                 │
┌─────────────────────────────────────────┐
│       Multi-Agent System                │
│  Planner → Tool Agent → Analyst →      │
│            Reporter                      │
└─────────────────────────────────────────┘
                 │
┌─────────────────────────────────────────┐
│      Workflow Engine                    │
│  - Parameter Priority                   │
│  - Evidence Capture                     │
│  - Session Management                   │
└─────────────────────────────────────────┘
                 │
┌─────────────────────────────────────────┐
│      Tool Integration Layer             │
│  (19 Security Tools)                    │
└─────────────────────────────────────────┘

🏗️ Structure du projet```

guardian-cli/ ├── ai/ # AI integration │ └── providers/ # Multi-provider support │ ├── base_provider.py │ ├── openai_provider.py │ ├── claude_provider.py │ ├── gemini_provider.py │ ├── openrouter_provider.py │ └── requesty_provider.py ├── cli/ # Command-line interface │ └── commands/ # CLI commands (init, scan, recon, etc.) ├── core/ # Core agent system │ ├── agent.py # Base agent │ ├── planner.py # Planner agent │ ├── tool_agent.py # Tool selection agent │ ├── analyst_agent.py # Analysis agent │ ├── reporter_agent.py # Reporting agent │ ├── memory.py # State management │ └── workflow.py # Workflow orchestration ├── tools/ # Pentesting tool wrappers │ ├── nmap.py # Nmap integration │ ├── masscan.py # Masscan integration │ ├── httpx.py # httpx integration │ ├── subfinder.py # Subfinder integration │ ├── amass.py # Amass integration │ ├── nuclei.py # Nuclei integration │ ├── sqlmap.py # SQLMap integration │ ├── wpscan.py # WPScan integration │ ├── whatweb.py # WhatWeb integration │ ├── wafw00f.py # Wafw00f integration │ ├── nikto.py # Nikto integration │ ├── testssl.py # TestSSL integration │ ├── sslyze.py # SSLyze integration │ ├── gobuster.py # Gobuster integration │ ├── ffuf.py # FFuf integration │ └── ... # 15 tools total ├── workflows/ # Workflow definitions (YAML) ├── utils/ # Utilities (logging, validation) ├── config/ # Configuration files ├── docs/ # Documentation └── reports/ # Generated reports

root@kitploit:~
## 🆕 Dernières mises à jour

### Version 4.0.0 — Nouvelle R&D + Expansion de couverture

**Piste A — R&D IA/Agent (7 éléments)**

| ID | Élément | Points forts |
|---|---|---|
| A1 | Base de connaissances RAG | `core/knowledge_base.py` SQLite + FTS5 + embeddings optionnels ; ancrage analyste via slot `kb_references` ; `guardian kb {seed,update,query,status}` |
| A2 | Tri par débat multi-agent | Rouge/Bleu/Juge sur les résultats MEDIUM-fp uniquement ; nouveau type d'étape d'analyse `agent: debate` |
| A3 | Analyse de captures d'écran Vision-LLM | `tools/playwright_screenshot.py` + `core/agents/visual_triage.py` ; OpenAI + Claude `generate_with_images` |
| A4 | Contrat de plugin + fournisseurs locaux | Découverte de points d'entrée pour les fournisseurs ET les outils ; fournisseurs **Ollama** + **compatibles OpenAI** fournis |
| A5 | Sélection d'outils apprise (hors ligne) | `core/learners/tool_ranker.py` + `core/telemetry.py` ; activation via `ai.use_learned_ranker: true` |
| A6 | Harness d'évaluation | `evals/{__init__,scoring,fixtures_loader,test_*}.py` + fixtures dorées ; 3 niveaux (parser, workflow, ancrage agent) |
| A7 | Mise à niveau du modèle juge | `BaseAgent.think_deeply(judge_model=...)` échange et restauration ; jugement par transcription pour une réduction de coût d'environ 10x |

**Piste B — Expansion de couverture d'outils (7 éléments)**

| ID | Catégorie | Outils ajoutés |
|---|---|---|
| B8 | Active Directory | crackmapexec, bloodhound, kerbrute, impacket-secretsdump |
| B9 | Mobile Android | mobsf, apkleaks, objection |
| B10 | Fuzzers API | schemathesis, restler, cariddi |
| B11 | SAST + secrets | semgrep, trufflehog, dependency-check |
| B12 | Red-team LLM | garak, pyrit, prompt_fuzz |
| B13 | Pont Burp/ZAP | zap, burp |
| B14 | Exportateurs de sortie | SARIF v2.1.0, DefectDojo, Slack |

**Barre de qualité :**
- 296 tests réussis (+93 % par rapport à la base v3 de 153)
- Tout le durcissement v3 préservé : délimiteurs d'injection de prompt, nettoyage de clés, portée de résolution DNS, points de contrôle atomiques, rotation des logs, chargement paresseux des outils
- Le temps de démarrage `guardian --help` reste inférieur à 500 ms malgré 50 outils
- Nouvelles surfaces CLI : `guardian kb`, `guardian telemetry`
- 8 nouveaux workflows livrés : `web_pentest_with_debate`, `web_visual_pentest`, `ad_assessment`, `mobile_android`, `llm_redteam`, `sast_review`, `api_pentest_v2`, plus les workflows v3 existants

### Version 3.0.0 — Durcissement + Moteur v2

- Délimiteurs d'injection de prompt (`<UNTRUSTED_TOOL_OUTPUT>`) sur toutes les sorties d'outils
- Planificateur DAG, schémas Pydantic, points de contrôle atomiques, `--resume`
- 11 nouveaux wrappers (cloud/container/SBOM/GraphQL/JWT/OSINT)
- Recomputaison CVSS v3.1 + détection de dérive
- Rotation des logs, nettoyage de clés à l'écriture
- Porte de confirmation câblée pour les outils actifs+

### Version 2.0.0

- IA multi-fournisseurs (OpenAI, Claude, Gemini, OpenRouter, Requesty)
- Liaison de preuves via `execution_id`
- Système de priorité des paramètres de workflow

---

## 🤝 Contribuer

Nous accueillons volontiers les contributions ! Voici comment :

### Configuration de l'environnement de développement```bash
# Fork and clone
git clone https://github.com/zakirkun/guardian-cli.git
cd guardian-cli

# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest tests/

# Format code
black .

Domaines de contribution

  • 🤖 Intégrations de fournisseurs d'IA - Ajouter plus de modèles d'IA
  • 🛠️ Intégrations de nouveaux outils - Ajouter plus d'outils de sécurité
  • 🔄 Workflows personnalisés - Partagez vos modèles de workflow
  • 🐛 Corrections de bugs - Signalez et corrigez les problèmes
  • 📚 Documentation - Améliorez les guides et les exemples
  • 🧪 Tests - Développez la couverture de tests

Voir CONTRIBUTING.md pour des directives détaillées.


📊 Feuille de route

Livré dans v4.0.0 :

  • IA multi-fournisseurs (OpenAI, Claude, Gemini, OpenRouter, Requesty, Ollama, compatible OpenAI)
  • Contrat de point d'entrée de plugin pour fournisseurs ET outils
  • Base de connaissances RAG (CVE/CWE/MITRE)
  • Triage par débat multi-agent (rouge/bleu/juge)
  • Triage visuel Vision-LLM avec captures d'écran
  • Sélection d'outils apprise (classificateur hors ligne)
  • Routage du modèle juge pour réduire les coûts
  • Harnais d'évaluation (fixtures de parseur, intégration de workflow, ancrage d'agent)
  • Pistes d'outils AD / Mobile / API-fuzz / SAST / LLM red-team / Burp-ZAP / Vision
  • Exportateurs SARIF + DefectDojo + Slack
  • Recalcul CVSS v3.1
  • Moteur de workflow DAG avec --resume

Futur :

  • Tableau de bord Web pour la visualisation
  • Backend PostgreSQL pour l'analyse multi-session
  • Collaboration multi-opérateur en temps réel
  • Pipeline de réglage fin LLM personnalisé une fois le corpus de télémétrie mature
  • Place de marché de plugins / interface de hub

🐛 Dépannage

Problèmes courants

Erreurs d'importation```bash

Reinstall dependencies

pip install -e . --force-reinstall

root@kitploit:~
**Erreurs du fournisseur d'IA**```bash
# Verify API key is set
python -m cli.main models

# Check provider configuration
cat config/guardian.yaml | grep -A 5 "ai:"

Outil non trouvé```bash

Check tool availability

which nmap which httpx

Install missing tools (see Prerequisites)

root@kitploit:~
**Workflow ne se charge pas**```bash
# Check workflow file exists
ls workflows/web_pentest.yaml

# Verify YAML syntax
python -c "import yaml; yaml.safe_load(open('workflows/web_pentest.yaml'))"

Commande Windows introuvable```powershell

Use full command

python -m cli.main --help

root@kitploit:~
Pour plus d'aide, [ouvrez un ticket](https://github.com/zakirkun/guardian-cli/issues).

---

## 📄 Licence

Ce projet est sous licence MIT - voir le fichier [LICENSE](https://github.com/zakirkun/guardian-cli/blob/HEAD/LICENSE) pour plus de détails.

---

## 🙏 Remerciements

- **OpenAI** - Capacités GPT-4
- **Anthropic** - IA Claude
- **Google** - IA Gemini
- **LangChain** - Cadre d'orchestration IA
- **ProjectDiscovery** - Outils de sécurité open-source (httpx, subfinder, nuclei)
- **Nmap** - Exploration réseau et audit de sécurité
- **La communauté de la sécurité** - Développeurs d'outils et chercheurs

---

## 📞 Support et Contact

- **GitHub Issues** : [Signalez des bugs ou demandez des fonctionnalités](https://github.com/zakirkun/guardian-cli/issues)
- **Discussions** : [Participez aux discussions communautaires](https://github.com/zakirkun/guardian-cli/discussions)
- **Documentation** : [Lisez la documentation](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/)
- **Sécurité** : Signalez les vulnérabilités en privé à [email protected]

---

## 🌟 Historique des étoiles

<a href="https://github.com/zakirkun/guardian-cli/stargazers">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=zakirkun/guardian-cli&type=Date&theme=dark" />
    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=zakirkun/guardian-cli&type=Date" />
    Graphique de l
  </picture>
</a>

---
---

<div align="center">

**Guardian** - Test de pénétration intelligent, éthique et automatisé

Réalisé avec ❤️ par la communauté de la sécurité

[⬆ Retour en haut](#-guardian)

</div>
Télécharger l’outil
CatégorieOutils
Réseaunmap, masscan
Reconnaissance Webhttpx, whatweb, wafw00f, cmseek
Sous-domaines / DNSsubfinder, amass, dnsrecon
Analyse de vulnérabilitésnuclei, nikto, sqlmap, wpscan
Test SSL/TLStestssl, sslyze
Découverte de contenugobuster, ffuf, arjun
Analyse de sécuritéxsstrike, gitleaks
Cloud / Conteneur / SBOMtrivy, grype, syft, scoutsuite, prowler, kube-bench
Web moderne + OSINTgraphw00f, clairvoyance, jwt_tool, shodan, theharvester
SAST + Secrets (B11)semgrep, trufflehog, dependency-check
Fuzzers d'API (B10)schemathesis, cariddi, restler
Passerelle Burp/ZAP (B13)zap, burp
Red-Team LLM (B12)garak, pyrit, prompt_fuzz
Mobile Android (B9)mobsf, apkleaks, objection
Active Directory (B8)crackmapexec, bloodhound, kerbrute, impacket-secretsdump
Preuve visuelle (A3)playwright_screenshot
OutilObjectifInstallation
nmapScan de portsapt install nmap / choco install nmap
masscanScan ultra-rapideapt install masscan / Compilation depuis les sources
httpxSondage HTTPgo install github.com/projectdiscovery/httpx/cmd/httpx@latest
subfinderÉnumération de sous-domainesgo install github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
amassCartographie réseaugo install github.com/owasp-amass/amass/v4/...@master
nucleiScan de vulnérabilitésgo install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
whatwebEmpreinte technologiquegem install whatweb / apt install whatweb
wafw00fDétection WAFpip install wafw00f
niktoScan de vulnérabilités webapt install nikto
sqlmapInjection SQLpip install sqlmap / apt install sqlmap
wpscanScan WordPressgem install wpscan
testsslTest SSL/TLSTélécharger depuis testssl.sh
sslyzeAnalyse SSL/TLSpip install sslyze
gobusterForce brute de répertoiresgo install github.com/OJ/gobuster/v3@latest
ffufFuzzing webgo install github.com/ffuf/ffuf/v2@latest
arjunDécouverte de paramètrespip install arjun
xsstrikeXSS avancégit clone https://github.com/s0md3v/XSStrike
gitleaksScan de secretsgo install github.com/zricethezav/gitleaks/v8@latest
cmseekDétection CMSpip install cmseek
dnsreconÉnumération DNSpip install dnsrecon