Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
guardian-cli — Guardian è uno strumento CLI di automazione dei test di penetrazione basato sull'IA, pronto per la produzione, che sfrutta Google Gemini e LangChain per orchestrare flussi di lavoro di penetration test intelligenti e passo dopo passo, mantenendo gli standard di hacking etico. | Kitploit
Strumenti/GitHubGitHub/zakirkun/guardian-cli
OSINT (Open Source Intelligence)Frameworks per Penetration TestingScanner di VulnerabilitàFramework di ExploitSicurezza WebSicurezza di RetePenetration TestingSicurezza CloudSicurezza MobileApprendimento e FormazioneSicurezza dell'IA
1.8k3611 mese faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
GitHub
zakirkun/guardian-cli

guardian-cli

Guardian è uno strumento CLI di automazione dei test di penetrazione basato sull'IA, pronto per la produzione, che sfrutta Google Gemini e LangChain per orchestrare flussi di lavoro di penetration test intelligenti e passo dopo passo, mantenendo gli standard di hacking etico.

Vedi Repository
Guardian Logo

🔐 Guardian

Piattaforma di Automazione per Penetration Testing basata su IA

License: MIT Python 3.11+ Code style: black

Guardian è un framework di automazione per penetration testing di livello enterprise basato su IA che combina molteplici provider AI (OpenAI GPT-4, Claude, Google Gemini, OpenRouter, Requesty) con strumenti di sicurezza collaudati sul campo per fornire valutazioni di sicurezza intelligenti e adattive con acquisizione completa di prove.

Funzionalità • Installazione • Avvio rapido • Documentazione • Contribuisci


⚠️ Avviso Legale

Guardian è progettato esclusivamente per test di sicurezza autorizzati e scopi educativi.

  • ✅ Uso legale: Penetration testing autorizzato, ricerca sulla sicurezza, ambienti educativi
  • ❌ Uso illegale: Accesso non autorizzato, attività dannose, qualsiasi forma di attacco informatico

Sei pienamente responsabile di assicurarti di avere un'autorizzazione scritta esplicita prima di testare qualsiasi sistema. L'accesso non autorizzato a sistemi informatici è illegale secondo leggi come il Computer Fraud and Abuse Act (CFAA), il GDPR e la legislazione internazionale equivalente.

Utilizzando Guardian, accetti di usarlo solo su sistemi di tua proprietà o per i quali hai esplicita autorizzazione al test.


✨ Funzionalità

🤖 Intelligenza AI Multi-Provider

  • 7 Provider AI Supportati: OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini), OpenRouter, Requesty, Ollama (locale), Compatibile OpenAI (vLLM, LM Studio, Together, Groq)
  • Contratto Provider Plugin: Provider terze parti distribuiscono tramite [project.entry-points."guardian.providers"] — nessun fork richiesto
  • Architettura Multi-Agente: Agenti AI specializzati (Pianificatore, Selettore di Strumenti, Analista, Reporter) più ruoli di triage con dibattito (Avvocato Rosso, Avvocato Blu, Giudice) e Triage Visivo
  • Triage con Dibattito Multi-Agente: Dibattito a tre ruoli (rosso/blu/giudice) su risultati ambigui — F1 ≥ baseline singolo agente +5pp
  • Triage Visivo con Vision-LLM: Acquisizione di screenshot headless + arricchimento analista basato su immagini tramite gpt-4o / Claude 3.5+ / Gemini 1.5+
  • Base di Conoscenza RAG: Recupero groundato SQLite + FTS5 su feed CVE / CWE / MITRE ATT&CK — elimina riferimenti CVE allucinati
  • Routing Modello Giudice: think_deeply swap-and-restore — modello grande pensa, modello piccolo giudica, riduzione dei costi di ~10x
  • Selezione Appresa degli Strumenti: Ranker offline addestrato su telemetria di sessione; si astiene quando la fiducia è bassa e torna al selettore LLM
  • Test Adattivi: L'IA regola le tattiche in base alle vulnerabilità scoperte e ai risultati precedenti degli strumenti
  • Filtraggio Falsi Positivi: Il triage con dibattito riduce il rumore; percorso economico saltato quando fp_probability è decisivo

🛠️ Ampio Arsenale di Strumenti

50 Strumenti di Sicurezza Integrati in 10 Categorie:

📊 Acquisizione Prove Potenziata

  • Tracciabilità dell'Esecuzione: Ogni risultato collegato all'esecuzione dello strumento che lo ha generato tramite execution_id
  • Cronologia Completa dei Comandi: Output completo dello strumento preservato per ogni risultato
  • Archiviazione Prove Grezze: Frammenti di output associati ai risultati
  • Prove Visive: Screenshot catturati per ogni URL, allegati ai risultati web
  • Ricostruzione della Sessione: session_<id>.json con checkpoint atomico abilita --resume

🔄 Sistema di Workflow Intelligente (DSL v2)

  • Scheduler DAG: Passaggi con depends_on eseguiti in parallelo fino a max_parallel_tools
  • Template Jinja2 (in sandbox): parameters: {key: "{{ <id>.parsed.alive_hosts }}"} risolve sui risultati dei passaggi precedenti
  • Passaggi Condizionali: Clausole when: bloccano l'esecuzione in base all'output precedente
  • Ripresa: --resume riprende dall'ultimo passaggio completato
  • Priorità dei Parametri: YAML del workflow > blocco di configurazione > impostazioni predefinite dello strumento
  • Agenti Personalizzati: agent: debate | visual | analyst sui passaggi di analisi
  • Formati Report Multipli: Markdown, HTML, JSON

📤 Integrazioni di Output (B14)

  • SARIF v2.1.0: Compatibile con GitHub, include security-severity, deduplicazione fingerprints da execution_id
  • DefectDojo: Caricamento REST diretto
  • Slack: Webhook con codifica a colori della gravità
  • Attivato tramite: guardian report --export sarif --export defectdojo --export slack

🔒 Sicurezza e Conformità

  • Convalida dell'ambito tramite risoluzione DNS: Blocca bypass di tipo SSRF; intervalli privati RFC1918 in blacklist
  • Difesa da Iniezione di Prompt: Tutto l'output degli strumenti racchiuso da delimitatori <UNTRUSTED_TOOL_OUTPUT> + rimozione ANSI
  • Offuscamento Chiavi API: Log e report oscurano i segreti al momento della scrittura
  • Cancello di Conferma: Strumenti Active+ (intrusivi/distruttivi) richiedono approvazione esplicita dell'utente
  • Registrazione Audit: Log rotanti di ogni decisione e azione dell'IA
  • Modalità Sicura: Impedisce azioni distruttive per impostazione predefinita

📋 Reportistica Professionale

  • Ricalcolo CVSS v3.1: Convalida i punteggi dichiarati rispetto alla matematica vettoriale; segnala derive
  • Sommari Esecutivi: Panoramiche non tecniche
  • Approfondimenti Tecnici: Risultati con prove, CVSS, CWE, CVE, tecnica MITRE
  • Tracce delle Decisioni AI: Utilizzo token, costo, registro della catena di pensiero per agente
  • Sezioni di Triage Visivo: Arricchimento basato su immagini integrato nelle descrizioni

⚡ Prestazioni ed Efficienza

  • Asincrono Ovunque: Esecuzione degli strumenti tramite sottoprocesso asyncio; agenti asincroni
  • Caricamento Pigro degli Strumenti: 50 strumenti registrati, nessuno importato fino al bisogno — --help rimane sotto 500ms
  • Esecuzione DAG Parallela: Passaggi indipendenti eseguiti concurrentemente per generazione
  • Automazione dei Workflow: 13+ workflow forniti (recon, web, rete, AD, mobile, red-team LLM, SAST, API)

📋 Prerequisiti

Requisiti

  • Python 3.11 o superiore (Scarica)
  • Chiave API del Provider AI (Scegline uno):
    • Chiave API OpenAI (Ottienila qui)
    • Chiave API Anthropic (Ottienila qui)
    • Chiave API Google AI Studio (Ottienila qui)
    • Chiave API OpenRouter (Ottienila qui)
    • Chiave API Requesty (Ottienila qui)
  • Git (per clonare il repository)

Strumenti Opzionali (per funzionalità completa)

Guardian può utilizzare intelligentemente questi strumenti se installati:

Nota: Guardian funziona senza strumenti esterni ma con capacità di scansione limitate. L'IA si adatterà in base agli strumenti disponibili.


🚀 Installazione

Passo 1: Clona il Repository```bash

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

root@kitploit:~
### Step 2: Configurare l'ambiente 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:~
### Passaggio 3: Configurare il Provider AI

Guardian supporta diversi provider AI. Configura il tuo provider preferito in `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

Oppure usa le variabili d'ambiente:```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:~
### Step 4: Inizializza configurazione```bash
# Verify installation
python -m cli.main --help

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

🎯 Avvio rapido

Comandi di 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:~
### Esempi di Scenari di Utilizzo

#### 1. Test Rapido di Penetrazione di Applicazioni Web```bash
# Fast security check with evidence capture
python -m cli.main workflow run --name web_pentest --target https://dvwa.csalab.app

Output Previsto:

  • ✅ Scoperta HTTP con httpx
  • ✅ Scansione di vulnerabilità con nuclei
  • ✅ Collegamento completo delle prove (comandi + output)
  • ✅ Report Markdown con risultati

2. Valutazione Completa della Rete```bash

Full network penetration test

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

root@kitploit:~
#### 3. Flusso di lavoro personalizzato con parametri```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à dei parametri del flusso di lavoro:

  1. Parametri YAML del flusso di lavoro (priorità più alta)
  2. Parametri del file di configurazione
  3. Valori predefiniti dello strumento (priorità più bassa)

4. Genera report dalla sessione```bash

Create HTML report with evidence

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

root@kitploit:~
#### 5. Cambia fornitori AI```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 di conoscenza (ancoraggio 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:~
Abilita il grounding dell'analista in `config/guardian.yaml`:```yaml
rag:
  enabled: true
  top_k: 5

7. Triage del dibattito multi-agente```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:~
Tre ruoli (avvocato rosso, avvocato blu, giudice) dibattono solo risultati ambigui — i verdetti sicuri saltano il dibattito per limitare il costo dei token.

#### 8. Triage visivo (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

Richiede playwright: pip install playwright && python -m playwright install chromium. Saltato silenziosamente quando il provider attivo non ha supporto per la visione.

9. Esportatori di Output (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. Telemetria + 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

Abilita in config:```yaml ai: use_learned_ranker: true # ToolAgent calls ranker before LLM selector

root@kitploit:~
> **Utenti Windows**: Usa `python -m cli.main` invece di `guardian`

---

## 🔧 Configurazione

### Riferimento Completo alla Configurazione

Modifica `config/guardian.yaml` per personalizzare il comportamento di 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

Parametri del flusso di lavoro

Crea flussi di lavoro personalizzati nella directory 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à dei parametri:**
- I parametri del workflow **sostituiscono** i parametri di configurazione
- I parametri di configurazione **sostituiscono** le impostazioni predefinite degli strumenti
- Workflow autonomi e riutilizzabili

---

## 📖 Documentazione

### Guide per l'utente
- **[Guida rapida](https://github.com/zakirkun/guardian-cli/blob/HEAD/QUICKSTART.md)** - Inizia in 5 minuti
- **[Riferimento comandi](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/)** - Documentazione dettagliata per tutti i comandi
- **[Guida alla configurazione](https://github.com/zakirkun/guardian-cli/blob/HEAD/config/guardian.yaml)** - Riferimento completo alla configurazione
- **[Guida ai workflow](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/WORKFLOW_GUIDE.md)** - Creazione di workflow personalizzati
- **[Guida alla valutazione](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/EVAL_GUIDE.md)** - Esecuzione e estensione del sistema di valutazione
- **[Guida ai plugin](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/PLUGIN_GUIDE.md)** - Distribuzione di provider e strumenti di terze parti
- **[Registro modifiche](https://github.com/zakirkun/guardian-cli/blob/HEAD/CHANGELOG.md)** - Cronologia versioni e note di migrazione

### Guide per sviluppatori
- **[Creazione di strumenti personalizzati](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/TOOLS_DEVELOPMENT_GUIDE.md)** - Crea le tue integrazioni di strumenti
- **[Sviluppo di workflow](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/WORKFLOW_GUIDE.md)** - Crea workflow di test personalizzati
- **[Strumenti disponibili](https://github.com/zakirkun/guardian-cli/blob/HEAD/tools/README.md)** - Panoramica degli strumenti integrati

### Panoramica dell'architettura```
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)                    │
└─────────────────────────────────────────┘

🏗️ Struttura del Progetto```

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:~
---

## 🆕 Ultimi aggiornamenti

### Versione 4.0.0 — Nuova R&D + Espansione della Copertura

**Track A — R&D AI/Agenti (7 elementi)**

| ID | Elemento | Punti salienti |
|---|---|---|
| A1 | Base di conoscenza RAG | `core/knowledge_base.py` SQLite + FTS5 + embeddings opzionali; grounding dell'analista tramite slot `kb_references`; `guardian kb {seed,update,query,status}` |
| A2 | Triage del dibattito multi-agente | Solo su risultati MEDIUM-fp; nuovo tipo di passo di analisi `agent: debate` |
| A3 | Analisi di screenshot con Vision-LLM | `tools/playwright_screenshot.py` + `core/agents/visual_triage.py`; OpenAI + Claude `generate_with_images` |
| A4 | Contratto plugin + provider locali | Scoperta di entry-point per provider E strumenti; provider **Ollama** + **compatibili con OpenAI** forniti |
| A5 | Selezione appresa degli strumenti (offline) | `core/learners/tool_ranker.py` + `core/telemetry.py`; opt-in tramite `ai.use_learned_ranker: true` |
| A6 | Harness di valutazione | `evals/{__init__,scoring,fixtures_loader,test_*}.py` + golden fixtures; 3 livelli (parser, workflow, grounding dell'agente) |
| A7 | Aggiornamento modello giudice | `BaseAgent.think_deeply(judge_model=...)` swap-and-restore; giudizio basato su trascritto per una riduzione dei costi di circa 10x |

**Track B — Espansione della Copertura degli Strumenti (7 elementi)**

| ID | Categoria | Strumenti aggiunti |
|---|---|---|
| B8 | Active Directory | crackmapexec, bloodhound, kerbrute, impacket-secretsdump |
| B9 | Mobile Android | mobsf, apkleaks, objection |
| B10 | API fuzzers | schemathesis, restler, cariddi |
| B11 | SAST + segreti | semgrep, trufflehog, dependency-check |
| B12 | Red-team LLM | garak, pyrit, prompt_fuzz |
| B13 | Bridge Burp/ZAP | zap, burp |
| B14 | Esportatori di output | SARIF v2.1.0, DefectDojo, Slack |

**Standard di qualità:**
- 296 test superati (+93% rispetto alla baseline v3 di 153)
- Tutto l'hardening v3 preservato: delimitatori di prompt-injection, key scrub, ambito DNS-resolve, checkpoint atomici, rotazione dei log, caricamento lazy degli strumenti
- Il tempo di avvio di `guardian --help` rimane <500ms nonostante 50 strumenti
- Nuove superfici CLI: `guardian kb`, `guardian telemetry`
- 8 nuovi workflow forniti: `web_pentest_with_debate`, `web_visual_pentest`, `ad_assessment`, `mobile_android`, `llm_redteam`, `sast_review`, `api_pentest_v2`, più i workflow v3 esistenti

### Versione 3.0.0 — Hardening + Engine v2

- Delimitatori di prompt-injection (`<UNTRUSTED_TOOL_OUTPUT>`) su tutto l'output degli strumenti
- DAG scheduler, schemi Pydantic, checkpoint atomici, `--resume`
- 11 nuovi wrapper (cloud/container/SBOM/GraphQL/JWT/OSINT)
- Ricalcolo CVSS v3.1 + rilevamento drift
- Rotazione log, key scrub al momento della scrittura
- Gate di conferma collegato per strumenti active+

### Versione 2.0.0

- AI multi-provider (OpenAI, Claude, Gemini, OpenRouter, Requesty)
- Collegamento delle prove tramite `execution_id`
- Sistema di priorità dei parametri del workflow

---

## 🤝 Contribuisci

Accogliamo con favore i contributi! Ecco come:

### Configurazione dell'ambiente di sviluppo```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 .

Aree di Contribuzione

  • 🤖 Integrazioni di Provider AI - Aggiungi più modelli AI
  • 🛠️ Nuove Integrazioni di Strumenti - Aggiungi più strumenti di sicurezza
  • 🔄 Workflow Personalizzati - Condividi i tuoi modelli di workflow
  • 🐛 Correzioni di Bug - Segnala e risolvi problemi
  • 📚 Documentazione - Migliora guide ed esempi
  • 🧪 Test - Espandi la copertura dei test

Vedi CONTRIBUTING.md per linee guida dettagliate.


📊 Roadmap

Rilasciato in v4.0.0:

  • AI multi-provider (OpenAI, Claude, Gemini, OpenRouter, Requesty, Ollama, OpenAI-compatible)
  • Contratto entry-point per plugin per provider E strumenti
  • Base di conoscenza RAG (CVE/CWE/MITRE)
  • Triage multi-agente con dibattito (red/blue/judge)
  • Triage visivo Vision-LLM con screenshot
  • Selezione appresa degli strumenti (classificatore offline)
  • Routing del modello giudice per riduzione dei costi
  • Harness di valutazione (fixture del parser, integrazione workflow, grounding dell'agente)
  • Track AD / Mobile / API-fuzz / SAST / LLM red-team / Burp-ZAP / Vision
  • Esportatori SARIF + DefectDojo + Slack
  • Ricompilazione CVSS v3.1
  • Motore workflow DAG con --resume

Futuro:

  • Dashboard Web per visualizzazione
  • Backend PostgreSQL per analisi multi-sessione
  • Collaborazione multi-operatore in tempo reale
  • Pipeline di fine-tuning LLM personalizzato una volta che il corpus di telemetria matura
  • Marketplace di plugin / interfaccia hub

🐛 Risoluzione dei Problemi

Problemi Comuni

Errori di Importazione```bash

Reinstall dependencies

pip install -e . --force-reinstall

root@kitploit:~
**Errori del provider AI**```bash
# Verify API key is set
python -m cli.main models

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

Strumento non trovato```bash

Check tool availability

which nmap which httpx

Install missing tools (see Prerequisites)

root@kitploit:~
**Workflow non caricato**```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'))"

Windows Comando non trovato```powershell

Use full command

python -m cli.main --help

root@kitploit:~
Per ulteriore aiuto, [apri un issue](https://github.com/zakirkun/guardian-cli/issues).

---

## 📄 Licenza

Questo progetto è concesso in licenza MIT - vedi il file [LICENSE](https://github.com/zakirkun/guardian-cli/blob/HEAD/LICENSE) per i dettagli.

---

## 🙏 Riconoscimenti

- **OpenAI** - Capacità GPT-4
- **Anthropic** - Claude AI
- **Google** - Gemini AI
- **LangChain** - Framework di orchestrazione AI
- **ProjectDiscovery** - Strumenti di sicurezza open source (httpx, subfinder, nuclei)
- **Nmap** - Esplorazione di rete e audit di sicurezza
- **The Security Community** - Sviluppatori e ricercatori di strumenti

---

## 📞 Supporto e Contatti

- **GitHub Issues**: [Segnala bug o richiedi funzionalità](https://github.com/zakirkun/guardian-cli/issues)
- **Discussions**: [Partecipa alle discussioni della community](https://github.com/zakirkun/guardian-cli/discussions)
- **Documentazione**: [Leggi la documentazione](https://github.com/zakirkun/guardian-cli/blob/HEAD/docs/)
- **Sicurezza**: Segnala vulnerabilità privatamente a [email protected]

---

## 🌟 Star History

<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" />
    Star History Chart
  </picture>
</a>

---
---

<div align="center">

**Guardian** - Penetration Testing Intelligente, Etico e Automatizzato

Realizzato con ❤️ dalla Security Community

[⬆ Torna su](#-guardian)

</div>
Scarica lo strumento
CategoriaStrumenti
Retenmap, masscan
Ricognizione Webhttpx, whatweb, wafw00f, cmseek
Sottodominio / DNSsubfinder, amass, dnsrecon
Scansione Vulnerabilitànuclei, nikto, sqlmap, wpscan
Test SSL/TLStestssl, sslyze
Scoperta Contenutigobuster, ffuf, arjun
Analisi Sicurezzaxsstrike, gitleaks
Cloud / Container / SBOMtrivy, grype, syft, scoutsuite, prowler, kube-bench
Web Moderno + OSINTgraphw00f, clairvoyance, jwt_tool, shodan, theharvester
SAST + Segreti (B11)semgrep, trufflehog, dependency-check
Fuzzer API (B10)schemathesis, cariddi, restler
Ponte 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
Prove Visive (A3)playwright_screenshot
StrumentoScopoInstallazione
nmapScansione porteapt install nmap / choco install nmap
masscanScansione ultra-veloceapt install masscan / Costruisci da sorgente
httpxSondaggio HTTPgo install github.com/projectdiscovery/httpx/cmd/httpx@latest
subfinderEnumerazione sottodominigo install github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
amassMappatura retego install github.com/owasp-amass/amass/v4/...@master
nucleiScansione vulnerabilitàgo install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
whatwebImpronta tecnologicagem install whatweb / apt install whatweb
wafw00fRilevamento WAFpip install wafw00f
niktoScansione vulnerabilità webapt install nikto
sqlmapSQL injectionpip install sqlmap / apt install sqlmap
wpscanScansione WordPressgem install wpscan
testsslTest SSL/TLSScarica da testssl.sh
sslyzeAnalisi SSL/TLSpip install sslyze
gobusterForza bruta directorygo install github.com/OJ/gobuster/v3@latest
ffufFuzzing webgo install github.com/ffuf/ffuf/v2@latest
arjunScoperta parametripip install arjun
xsstrikeXSS avanzatogit clone https://github.com/s0md3v/XSStrike
gitleaksScansione segretigo install github.com/zricethezav/gitleaks/v8@latest
cmseekRilevamento CMSpip install cmseek
dnsreconEnumerazione DNSpip install dnsrecon