samugit83/redamonUn framework red team agentico basato sull'IA che automatizza le operazioni di sicurezza offensiva, dalla ricognizione allo sfruttamento fino alla post-exploitation, senza alcun intervento umano.
Smaschera l'occulto prima che il mondo lo scopra
Un framework AI autonomo che concatena ricognizione, sfruttamento e post-sfruttamento in un'unica pipeline, per poi andare oltre: effettua il triage di ogni rilevamento, implementa correzioni di codice e apre pull request sul tuo repository. Dal primo pacchetto alla patch mergiata, con supervisione umana in ogni passaggio critico.
DICHIARAZIONE LEGALE: Questo strumento è destinato esclusivamente a test di sicurezza autorizzati, scopi educativi e ricerca. Non usare mai questo sistema per scansionare, sondare o attaccare sistemi di cui non sei proprietario o per i quali non hai un'autorizzazione scritta esplicita. L'accesso non autorizzato è illegale e punibile per legge. Usando questo strumento, accetti piena responsabilità per le tue azioni. Leggi la dichiarazione completa
Tre agenti AI testano in parallelo: uno valida le policy sulle credenziali tramite Hydra, uno verifica un percorso di exploit di una CVE attraverso l'escalation dei privilegi, uno mappa le vulnerabilità XSS nel frontend.
RedAmon lancia più strumenti di ricognizione in parallelo, ciascuno dei quali alimenta un knowledge graph condiviso in tempo reale. Gli strumenti si avviano, adattano il proprio ambito in base alle scoperte live e si coordinano senza intervento manuale. L'intera superficie d'attacco -- sottodomini, porte, endpoint, parametri -- si materializza in minuti, non in ore.
Scanner standard di settore concatenati in modo che l'output di ogni strumento alimenti il successivo, poi unificati in un unico knowledge graph Neo4j. I rilevamenti vengono deduplicati, le relazioni sono esplicite e l'agente eredita una superficie d'attacco strutturata e completamente connessa, pronta per essere interrogata in linguaggio naturale.
Ricognizione ➜ Sfruttamento ➜ Post-sfruttamento ➜ Triage AI ➜ CodeFix Agent ➜ PR GitHub
RedAmon non si ferma alla scoperta delle vulnerabilità: le corregge. La pipeline inizia con un motore di ricognizione in 6 fasi che mappa l'intera superficie d'attacco del tuo target, poi passa il controllo a un agente AI autonomo che valida la sfruttabilità delle CVE, testa le policy sulle credenziali e mappa i percorsi di movimento laterale. Ogni rilevamento viene registrato in un knowledge graph Neo4j. Al termine della fase offensiva, interviene CypherFix: un agente di triage AI correla centinaia di rilevamenti, li deduplica e li classifica in base alla sfruttabilità. Poi un agente CodeFix clona il tuo repository, naviga nel codebase con 11 strumenti code-aware, implementa correzioni mirate e apre una pull request GitHub, pronta per la revisione e il merge.
Manteniamo una Project Board pubblica con le funzionalità in arrivo, aperta ai contributi della community. Scegli un'attività e invia una PR!
Vuoi contribuire? Consulta CONTRIBUTING.md per sapere come iniziare.
--gvm) in Impostazioni → Risorse. Clona in ~/ in modo che il percorso sia nell'elenco predefinito di File Sharing.~/), non da /mnt/c/.Tutto qui. Nessun Node.js, Python o strumento di sicurezza necessario sul tuo host.
| Risorsa | Senza OpenVAS | Con OpenVAS (stack completo) |
|---|---|---|
| CPU | 2 core | 4 core |
Senza OpenVAS vengono eseguiti 7 container: webapp, postgres, neo4j, agent, kali-sandbox, recon-orchestrator e docker-broker (un proxy filtrante del socket Docker attraverso cui passano i container di scansione generati dall'orchestratore di ricognizione, così possono lanciare solo le immagini degli strumenti noti). Con OpenVAS si aggiungono altri 4 container runtime (gvmd, ospd-openvas, gvm-postgres, gvm-redis) più ~8 container one-shot di inizializzazione dei dati per i feed delle vulnerabilità (~170K+ NVT). Il primo avvio richiede ~30 minuti per la sincronizzazione dei feed GVM. I container dinamici di ricognizione e scansione vengono creati on-demand durante le operazioni e richiedono risorse aggiuntive.
Dimensionamento del disco per una distribuzione reale. Le cifre sopra riportate sono i minimi assoluti per compilare ed eseguire lo stack (footprint fissa della piattaforma: ~70 GB senza OpenVAS, ~95 GB con - misurata in base alla dimensione reale delle immagini su disco dopo la deduplicazione dei layer di base Kali condivisi). Per un server sempre attivo che esegue engagement reali, aggiungi ~100 GB di spazio libero per i dati operativi - il grafo d'attacco Neo4j, gli artefatti/output delle scansioni, Postgres e i log dei container crescono tutti con l'uso. Ciò significa 200 GB senza OpenVAS, 250 GB con OpenVAS, lasciando in entrambi i casi ben oltre 100 GB liberi per le operazioni. Consulta la guida alla distribuzione per la ripartizione completa.
git clone https://github.com/samugit83/redamon.git cd redamon
./redamon.sh install
./redamon.sh install --gvm
Lo script crea tutte le immagini e avvia i servizi.
### 2. Crea un account amministratore
Al termine dell'installazione (e ad ogni `./redamon.sh up` o `./redamon.sh update` se non esiste un admin), ti verrà chiesto nel terminale:```
[WARN] No admin user found. Let's create one.
Admin name: Your Name
Admin email: [email protected]
Admin password: ********
Confirm password: ********
Admin, il tuo nome, qualsiasi cosa tu voglia).http://localhost:3000/login.Dopo la creazione, apri http://localhost:3000 e accedi con l'email e la password appena impostate.
Nessun prompt apparso? In un primo avvio pesante (specialmente con
--gvm, o su una VM piccola) l'app web può richiedere del tempo per avviarsi, quindi il prompt automatico potrebbe essere saltato. Crea l'admin in qualsiasi momento con:./redamon.sh create-adminAttende che l'app web sia pronta, quindi richiede gli stessi dati. È sicuro rieseguirlo: riutilizzare l'email di un admin esistente reimposta quella password, una nuova email aggiunge un altro admin.
Cosa può fare l'admin:
admin o standard.Utenti standard possono solo accedere (se dispongono di una password impostata da un admin), modificare la propria password e utilizzare l'app nel proprio ambito. Non possono passare da un utente all'altro, creare utenti o accedere alla gestione utenti.
Se dimentichi la password dell'admin, reimpostala dal terminale:```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
Usa `create-admin` quando non esiste ancora un admin (esegue un upsert sull'email); `reset-password` aggiorna solo un utente già esistente.
### 3. Configura
Apri **http://localhost:3000/settings** (icona ingranaggio nell'intestazione) per configurare tutto. Non è necessario alcun file `.env`.
- **Provider LLM** -- aggiungi chiavi API per OpenAI, Anthropic, OpenRouter, AWS Bedrock o qualsiasi endpoint compatibile con OpenAI (Ollama, vLLM, Groq, ecc.). Ogni provider può essere testato prima del salvataggio. Il selettore dei modelli nelle impostazioni di progetto **recupera dinamicamente** i modelli disponibili dai provider configurati.
- **Chiavi API** -- chiavi per Tavily, Shodan, SerpAPI, NVD, Vulners, URLScan e chiavi di threat intelligence (Censys, FOFA, OTX, Netlas, VirusTotal, ZoomEye, CriminalIP) per abilitare funzionalità estese degli agenti (ricerca web, OSINT, lookup CVE, threat intelligence passiva). Le chiavi di **ricerca multi-motore Uncover** (Quake, Hunter, PublicWWW, HunterHow, Google, Onyphe, Driftnet) ampliano la scoperta dei target su 13 motori di ricerca -- le chiavi condivise (Shodan, Censys, FOFA, ecc.) vengono riutilizzate automaticamente. Supporta la **rotazione delle chiavi** -- configura più chiavi per strumento con rotazione automatica round-robin per evitare i rate limit.
- **Tunneling** -- configura ngrok o chisel per il tunneling di reverse shell. Le modifiche vengono applicate immediatamente senza riavviare i container.
Tutte le impostazioni vengono salvate per utente nel database. Consulta la pagina wiki **[Provider di modelli AI](https://github.com/samugit83/redamon/wiki/AI-Model-Providers)** per istruzioni di configurazione dettagliate.
### 4. Apri la Webapp
Vai su **http://localhost:3000** -- crea un progetto, configura il target e inizia la scansione.
> Per una guida dettagliata a ogni funzionalità, consulta la **[Wiki](https://github.com/samugit83/redamon/wiki)**.
>
> Hai problemi? Consulta la guida **[Risoluzione dei problemi](https://github.com/samugit83/redamon/blob/HEAD/readmes/TROUBLESHOOTING.md)** o la pagina **[Troubleshooting della Wiki](https://github.com/samugit83/redamon/wiki/Troubleshooting)**.
### Comandi di Gestione
L'intera gestione del ciclo di vita è affidata a un singolo script:
| Command | Description |
|---------|-------------|
| `./redamon.sh install` | Compila + avvia in modalità leggera (no GVM, no Knowledge Base, ricerca web solo Tavily) |
| `./redamon.sh install --kbase` | Compila + avvia con la Knowledge Base locale (~4,4 GB in più) |
| `./redamon.sh install --gvm` | Compila + avvia con GVM/OpenVAS |
> I flag possono essere combinati: `./redamon.sh install --gvm --kbase`
| Command | Description |
|---------|-------------|
| **`./redamon.sh update`** | **Recupera l'ultima versione, ricompila in modo intelligente solo i servizi modificati (preserva la scelta GVM/KB fatta in fase di installazione)** |
| `./redamon.sh up` | Avvia i servizi (rileva automaticamente la modalità GVM e KB dall'installazione) |
| `./redamon.sh up dev` | Avvia in modalità sviluppo con hot-reload (rileva automaticamente la modalità GVM e KB) |
| `./redamon.sh down` | Ferma i servizi (preserva i dati) |
| `./redamon.sh status` | Mostra i servizi in esecuzione, la versione, la modalità GVM, lo stato della KB |
| `./redamon.sh clean` | Rimuove container e immagini, mantiene i dati |
| `./redamon.sh create-admin` | Crea il login admin (oppure reimpostalo) -- usalo se non è apparso alcun prompt durante l'installazione |
| `./redamon.sh reset-password` | Reimposta la password di un utente esistente dal terminale |
| `./redamon.sh purge` | Rimuove tutto, inclusi tutti i dati |
### Aggiornamento a una Nuova Versione
Basta eseguire:```bash
./redamon.sh update
Lo script scarica il codice più recente da GitHub, rileva quali Dockerfile e file sorgente sono cambiati, ricostruisce solo le immagini interessate e riavvia i servizi aggiornati. I tuoi database, i risultati delle scansioni e i report vengono conservati: i volumi non vengono mai eliminati.
Nota una tantum quando una release aggiunge un nuovo servizio in background.
updateriesegue lo script appena scaricato così le nuove regole di build/avvio si applicano automaticamente — ma solo per la versione dello script da cui stai effettuando l'aggiornamento da. Quando aggiorni da una versione precedente a questo auto-ripristino (cioè al primo aggiornamento su di esso), esegui./redamon.sh upuna volta subito dopoupdateper avviare eventuali nuovi servizi core aggiunti:./redamon.sh update && ./redamon.sh up
upè idempotente: avvia solo ciò che manca e lascia invariati i container in esecuzione. Dopo questo passaggio una tantum, il semplice./redamon.sh updategestisce tutto da solo.
Anche la webapp controlla automaticamente gli aggiornamenti e mostra una notifica nella UI quando è disponibile una nuova versione.
La Guida rapida qui sopra esegue RedAmon localmente su localhost. Per eseguire un'istanza condivisa e raggiungibile da Internet su un server Linux (EC2, DigitalOcean, Hetzner o bare metal), usa la distribuzione su host singolo in deploy/single-host/. Esegue redamon.sh via SSH dal tuo laptop e avvolge lo stack nel livello di sicurezza esposto a Internet che RedAmon omette per impostazione predefinita: nginx + TLS (Let's Encrypt), un firewall host, hardening SSH e fail2ban, con un'unica origine HTTPS pubblica in modo che solo la pagina di login sia raggiungibile e tutto il resto resti vincolato al 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:///
Procedura completa: [Wiki: Deploying to a Server](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server). Riferimento completo: [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/HEAD/deploy/single-host/README.md).
### Modalità di sviluppo
Per contributori e sviluppo attivo con **Next.js fast refresh**:```bash
./redamon.sh up dev # auto-detects GVM mode from install
Le immagini degli strumenti vengono create automaticamente al primo avvio se non esistono ancora. L'override di sviluppo sostituisce l'immagine webapp di produzione con un container di sviluppo con il codice sorgente montato come volume. Ogni salvataggio di file attiva un hot-reload immediato nel browser.
Ricostruisci un singolo servizio:```bash docker compose build # Rebuild one image docker compose up -d --no-deps # Restart only that service
**Comandi di sviluppo comuni:**```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
Recupera spazio su disco:```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
> Per un riferimento completo allo sviluppo -- regole di hot-reload, comandi comuni, regole importanti e linee guida per la codifica assistita da IA -- consulta la **[Developer Guide](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.DEV.md)**.
---
### Knowledge Base (Ricerca Web potenziata da RAG)
Lo strumento `web_search` dell'agente include una **Knowledge Base** locale -- una pipeline RAG che cerca in dataset di sicurezza curati (GTFOBins, LOLBAS, OWASP WSTG, NVD CVEs, ExploitDB, template Nuclei e documentazione delle skill dell'agente) prima di ripiegare sulla ricerca web di Tavily. Quando la KB restituisce una corrispondenza ad alta confidenza, Tavily viene completamente saltata per ottenere risultati più rapidi e utilizzabili offline.
**Come funziona:** Quando la KB è abilitata, `install` / `up` / `update` costruisce un indice KB leggero (~1.200 chunk in 10-15 minuti su CPU). Al momento della query, l'agente esegue una pipeline di recupero ibrida (ricerca vettoriale FAISS + fulltext Neo4j), riordina con un cross-encoder e controlla una soglia di confidenza. Se il punteggio è sufficientemente alto, i risultati provengono dalla KB locale. Altrimenti, ripiega su Tavily o combina entrambi.
**Comportamento predefinito:** La KB è **opt-in**. `./redamon.sh install` produce un'installazione leggera (~4,4 GB in meno, ricerca web solo Tavily). Per abilitare la KB locale, passa `--kbase`:```bash
./redamon.sh install --kbase
Al primo avvio con --kbase, RedAmon rileva l'hardware (GPU / CPU / API) e offre un profilo di avvio rapido. La scelta viene salvata, quindi i successivi comandi update / up la rispettano senza dover ripetere il flag.
Accelera l'acquisizione con embedding API: Di default, gli embedding vengono eseguiti localmente su CPU/GPU. Su macchine con sola CPU, dataset di grandi dimensioni (ExploitDB, NVD) possono richiedere ore. Puoi delegare l'embedding a un'API esterna creando un file .env dal template:```bash
cp .env.example .env
Quindi configura l'API di embedding in `.env`:
| Variable | Default | Description |
|----------|---------|-------------|
| `KB_EMBEDDING_USE_API` | `false` | Imposta a `true` per usare embedding basati su API invece del modello locale |
| `KB_EMBEDDING_API_BASE_URL` | *(vuoto = OpenAI)* | Qualsiasi endpoint compatibile con OpenAI (Ollama, vLLM, LiteLLM, Together AI, Azure) |
| `KB_EMBEDDING_API_KEY` | *(vuoto)* | Chiave API per il provider di embedding |
| `KB_EMBEDDING_API_MODEL` | `text-embedding-3-small` | Nome del modello (specifico del provider) |
| `NVD_API_KEY` | *(vuoto)* | Chiave API NVD gratuita per un'ingestione CVE 10 volte più veloce |
Esempio con Ollama (gratuito, locale, nessun costo di chiave 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
Importante: L'inserimento e la query devono utilizzare lo stesso modello. Se cambi modello, ricostruisci l'indice:
make -C knowledge_base kb-rebuild-lite MODE=docker
Gestisci 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
> Per la documentazione tecnica completa -- query pipeline, fonti di dati, profili di ingestione, scoring, modello di sicurezza -- consulta il **[Knowledge Base Technical Reference](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.KBASE.md)** o la **[Wiki: Knowledge Base & Web Search](https://github.com/samugit83/redamon/wiki/Knowledge-Base-Web-Search)**.
---
## Indice
- [Documentazione Wiki Completa](https://github.com/samugit83/redamon/wiki)
- [Panoramica](#overview)
- [Progettato per l'Enterprise, Sicuro by Design](#built-for-enterprise-secure-by-design)
- [Modello di Sicurezza e Minacce](#security--threat-model)
- [Caratteristiche Principali](#feature-highlights)
- [Architettura del Sistema](#system-architecture)
- [Componenti](#components)
- [Documentazione](#documentation)
- [Risoluzione dei Problemi](#troubleshooting)
- [RedAmon HackLab](#redamon-hacklab)
- [Vetrina della Community](#community-showcase)
- [Note Legali](#legal)
---
## Panoramica
RedAmon è un framework di penetration testing modulare e containerizzato che unisce ricognizione automatizzata, exploitation guidata dall'IA e intelligence basata su grafi in un'unica pipeline offensiva end-to-end. Ogni componente viene eseguito all'interno di Docker (nessuno strumento installato sul tuo host) e comunica tramite API ben definite, così ogni livello può evolversi in modo indipendente.
La piattaforma è costruita attorno a sei pilastri:
| Pilastro | Cosa fa |
|--------|-------------|
| **Reconnaissance Pipeline** | Una pipeline di scansione **fan-out / fan-in parallelizzata** che mappa l'intera superficie d'attacco del tuo target (partendo da un dominio **o da indirizzi IP / intervalli CIDR**) dalla scoperta dei sottodomini (5 strumenti concorrenti) fino alla scansione delle porte, al rilevamento dei servizi Nmap e agli script di vulnerabilità NSE, al probing HTTP, all'enumerazione delle risorse e al rilevamento delle vulnerabilità. I moduli indipendenti vengono eseguiti in concorrenza tramite `ThreadPoolExecutor`, gli aggiornamenti del database a grafo avvengono in un thread in background e i risultati vengono salvati come un grafo ricco e interrogabile. Completata da moduli di scansione di rete GVM standalone, di caccia ai segreti su GitHub e di scansione profonda dei segreti con TruffleHog. |
| **AI Agent Orchestrator** | Un agente autonomo basato su LangGraph che ragiona sul grafo, seleziona gli strumenti di sicurezza tramite MCP, attraversa le fasi informative / di exploitation / post-exploitation e può essere guidato in tempo reale tramite chat. |
| **Attack Surface Graph** | Un knowledge graph Neo4j con 17 tipi di nodi e oltre 20 tipi di relazioni che funge da unica fonte di verità per ogni rilevamento e da fonte dati primaria che l'agente IA interroga prima di ogni decisione. |
| **EvoGraph** | Un grafo persistente ed evolutivo della catena di attacco in Neo4j che traccia ogni passaggio, rilevamento, decisione e fallimento lungo l'intero ciclo di vita dell'attacco, collegando il grafo di ricognizione e consentendo l'accumulo di intelligence tra sessioni diverse. |
| **CypherFix** | Pipeline automatizzata di remediation delle vulnerabilità: un agente di triage IA correla e prioritizza i rilevamenti dal grafo, poi un agente CodeFix clona il repository target, implementa le correzioni utilizzando un loop ReAct con 11 strumenti di codice e apre una pull request su GitHub. |
| **Project Settings Engine** | 500+ parametri per progetto (esposti tramite l'interfaccia webapp) che controllano il comportamento di ogni strumento, dal numero di thread di Naabu ai filtri di severità di Nuclei fino ai gate di approvazione dell'agente. |
---
## Progettato per l'Enterprise, Sicuro by Design
RedAmon è progettato per inserirsi in una vera organizzazione di sicurezza, non solo nel laptop di un ricercatore.
- **Sicuro by design, modellato sulle minacce STRIDE.** L'intera piattaforma viene valutata end-to-end sotto STRIDE e indurita in ondate verificate in modo indipendente: separazione dei privilegi a livello di codice, un broker Docker filtrante davanti al socket dell'host, autenticazione fail-closed, guardie di egress SSRF, redazione dei segreti, audit trail append-only e un guardrail non disattivabile che blocca bersagli governativi, militari e intergovernativi. Vedi la [Security Posture](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.SECURITY_POSTURE.md) e il [Threat Model](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.TM.SYSTEM_OVERVIEW.md).
- **Completamente isolato e containerizzato.** Ogni strumento, scanner e agente viene eseguito nel proprio container senza alcuna esecuzione a livello di host. I job di scansione vengono generati come container fratelli effimeri con il proprio filesystem e namespace di rete, poi rimossi al termine, mantenendo pulito l'host e contenendo il blast radius di qualsiasi exploit.
- **Governato e multi-tenant.** Locazione multi-utente / multi-progetto con ruoli admin e standard, scoping a livello di database `user_id + project_id` su ogni nodo, applicazione delle regole di ingaggio, gate di approvazione human-in-the-loop e oltre 500 impostazioni per progetto offrono ai team il controllo richiesto da un engagement enterprise.
**Distribuisci su un server con un solo comando.** Oltre a `localhost`, RedAmon include una [single-host deploy](https://github.com/samugit83/redamon/blob/HEAD/deploy/single-host/) indurita che avvia un'istanza condivisa e raggiungibile da Internet e avvolge lo stack in nginx + TLS (Let's Encrypt), un firewall host, hardening SSH e fail2ban, esponendo una singola origine HTTPS pubblica:```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
Full walkthrough: Wiki: Deploying to a Server.
RedAmon è software offensivo, quindi lo sottoponiamo allo stesso standard con cui testa gli altri. È progettato sicuro by design ed è stato valutato end-to-end secondo la metodologia STRIDE (Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege), con i problemi risolti in ondate sequenziali e verificate in modo indipendente.
Non è un'affermazione di marketing. Si basa su un'analisi pubblicata e basata su prove che puoi leggere:
Punti salienti di ciò che è implementato:
--privileged, bind host-root, capability pericolose).Trovata una vulnerabilità? Vedi la nostra Security Policy per la divulgazione privata.
Un mapper della superficie d'attacco esterna completamente automatizzato e end-to-end che gira all'interno di un container Kali Linux. Fornisci un singolo input (un dominio radice, un elenco di sottodomini o intervalli IP/CIDR) e la pipeline restituisce un quadro completo e strutturato del target: ogni sottodominio, ogni host attivo, ogni porta aperta, ogni servizio HTTP con il suo stack tecnologico, ogni endpoint esplorato e parametro scoperto, ogni CVE a cui il target è probabilmente vulnerabile, più scanner dedicati per API GraphQL, subdomain takeover, virtual host nascosti dietro reverse proxy, web cache poisoning & deception, e un livello Adversarial AI Surface che etichetta runtime AI / vector DB / frontend LLM / proxy / server MCP / endpoint chat / completion / embedding / RAG e parametri prompt-injectable usando firme di header / favicon / titolo / percorso / nome-parametro, quindi li conferma attivamente con un modulo dedicato AI Surface Recon (sonde benigne a forma di chat, handshake MCP + scansione tool-poisoning, letture vector-DB — nessuna chiamata LLM).
Tutto gira su un'architettura fan-out / fan-in: ogni fase lancia tanti strumenti in parallelo quanto il lavoro consente, poi converge prima che inizi la fase successiva. Oltre 40 strumenti di settore si integrano in un unico workflow coordinato, l'avvelenamento DNS wildcard viene filtrato automaticamente con puredns, e la modalità stealth mantiene l'intera pipeline in esecuzione solo su fonti passive quando il probing attivo è fuori discussione. I risultati confluiscono nel knowledge graph Neo4j su un thread in background, così la scansione non si blocca mai sulle scritture del database, e il JSON grezzo viene conservato per il download. La suddivisione dettagliata strumento per strumento è nella matrice qui sotto.
*Amass può essere eseguito in modalità attiva quando configurato. Knockpy esegue probing DNS attivo.
Esegui qualsiasi singolo strumento della pipeline in modo indipendente senza rilanciare l'intera scansione. Fino a 12 recon parziali possono girare in parallelo per progetto, ciascuno con log indipendenti, controlli di stop e badge di stato visibili sia nella toolbar del grafo sia nell'intestazione delle Impostazioni di Progetto. Ogni sezione di strumento ha un pulsante di riproduzione che apre una modale dove puoi rivedere i dati del grafo esistenti, aggiungere target personalizzati (sottodomini, IP, porte o URL) e lanciare lo strumento in isolamento. I risultati vengono riuniti nel grafo Neo4j usando operazioni MERGE -- i duplicati vengono aggiornati, non ricreati. Lo strumento gira con tutte le impostazioni di progetto (timeout, wordlist, chiavi API, proxy) applicate automaticamente. Tutti gli strumenti della pipeline supportano la recon parziale.
Punti decisionali opzionali potenziati con LLM integrati nella pipeline di recon dove le ricerche statiche storicamente divergono -- Nuclei riduce la sua lista di tag allo stack tecnologico rilevato, il classificatore WAF intercetta Cloudflare/AWS WAF/Imperva con header rimossi, e molti altri tra FFuf, filtraggio dei falsi positivi di Nuclei e disambiguazione dei subdomain takeover. Ogni hook è un fallback a cascata dopo il percorso statico con un fallback sicuro deterministico, quindi un'interruzione dell'LLM non può rompere una scansione. Un unico interruttore principale nella scheda Target li governa tutti.
Dove la pipeline di recon trova la superficie AI, l'AI Gauntlet la attacca. Scegli gli endpoint LLM scoperti (o digita un URL personalizzato), seleziona uno strumento, conferma le Rules of Engagement e lancia: un container a breve durata fa passare il target attraverso quattro strumenti red-team di settore -- garak (scanner ampio single-shot, 40 famiglie di probe), PyRIT (jailbreak multi-turn delimitati), Giskard (scansione di sicurezza assistita da LLM) e promptfoo (valutazione red-team su dataset) -- misurando un Attack Success Rate per attacco e scrivendo le debolezze confermate sul grafo come risultati Vulnerability mappati OWASP-LLM / MITRE-ATLAS con trascrizioni delle prove.
È deterministico (seed, limiti fissi, versioni degli strumenti bloccate) e gira con zero egress esterni: ogni chiamata di giudizio / valutazione / embedding è forzata su un modello Ollama locale, quindi nessun payload o trascrizione lascia mai la tua macchina. Disattivato per impostazione predefinita e vincolato alle RoE, con avanzamento live fase per fase, e i risultati emergono nella tabella AI Gauntlet Vulnerabilities della Red Zone e nel report di pentest.
GVM/OpenVAS esegue una valutazione approfondita delle vulnerabilità a livello di rete con oltre 170.000 NVT, sondando i servizi a livello di protocollo per misconfigurazioni, software obsoleto, credenziali predefinite e CVE noti. Completa i risultati di Nuclei a livello web. Sette profili di scansione preconfigurati, dalla rapida scoperta degli host (~2 min) alla scansione profonda esaustiva (~8 ore). I risultati vengono memorizzati come nodi Vulnerability in Neo4j accanto al grafo della recon.
Un agente autonomo basato su LangGraph che implementa il pattern ReAct. Procede attraverso tre fasi: Informational (raccolta di intelligence, query sul grafo, Shodan, Google dorking), Exploitation (Metasploit, test delle credenziali con Hydra, simulazione di social engineering) e Post-Exploitation (enumerazione, movimento laterale). L'agente esegue 14 strumenti di sicurezza tramite server MCP all'interno di una sandbox Kali, supporta l'esecuzione parallela degli strumenti tramite Wave Runner e fornisce interazione chat in tempo reale con indicazioni, workflow di stop/resume e approvazione. La modalità Deep Think consente un'analisi strategica strutturata prima di agire.
|:-----:|-------|-------------|:------:|:----------:|
| Intelligence | query_graph | Query sul grafo Neo4j -- fonte primaria di verità per i dati di ricognizione | All | -- |
| | web_search | Ricerca su Internet tramite Tavily per dettagli CVE, PoC di exploit e advisory | All | -- |
| | cve_intel | ProjectDiscovery vulnx -- intelligence strutturata sulle CVE che aggrega NVD + CISA KEV + EPSS + HackerOne + PoC GitHub + disponibilità di template Nuclei. 69 campi filtrabili con Lucene. Chiave PDCP opzionale (per utente, modalità anonima = 10 req/min) | All | network_recon :8000 |
| | tradecraft_lookup | Catalogo curato dall'utente di URL di conoscenza sulla sicurezza affidabili (HackTricks, PayloadsAllTheThings, repository di PoC CVE, blog dei vendor) -- 6 tipi di risorse rilevati automaticamente, selezione delle sezioni basata su sitemap, cache sqlite+disco | Exploit, Post | -- |
| | shodan | OSINT su Shodan -- dettagli dell'host, reverse DNS, ricerca di dispositivi | Info, Exploit | -- |
| | google_dork | Google dorking via SerpAPI -- file esposti, pannelli di amministrazione, elenchi di directory | Info | -- |
| Recon & OSINT | execute_subfinder | Enumerazione passiva dei sottodomini tramite OSINT (log CT, dataset DNS). Nessun traffico verso il target | Info, Exploit | network_recon :8000 |
| | execute_gau | Scoperta passiva di URL da Wayback Machine, Common Crawl, AlienVault OTX, URLScan. Nessun traffico verso il target | Info, Exploit | network_recon :8000 |
| | execute_amass | Enumerazione dei sottodomini e mappatura di rete con OWASP Amass (passiva + attiva, intel ASN) | Info, Exploit | network_recon :8000 |
| Scanning | execute_naabu | Scansione rapida delle porte e verifica | Info, Exploit | network_recon :8000 |
| | execute_nmap | Rilevamento approfondito dei servizi (-sV), fingerprint del sistema operativo, script NSE | All | nmap :8004 |
| | execute_nuclei | Verifica e sfruttamento delle CVE con oltre 9.000 template + caricamenti personalizzati | Info, Exploit | nuclei :8002 |
| | execute_httpx | Sondaggio HTTP e fingerprinting -- codici di stato, titoli, header del server, rilevamento delle tecnologie | Info, Exploit | network_recon :8000 |
| | execute_wpscan | Scanner di vulnerabilità WordPress -- rileva plugin, temi, utenti e configurazioni errate vulnerabili | Info, Exploit | network_recon :8000 |
| Web & HTTP | execute_curl | Richieste HTTP -- raggiungibilità, header, codici di stato, banner | All | network_recon :8000 |
| | | Crawling web e scoperta di endpoint con parsing JavaScript ed enumerazione di file noti | Info, Exploit | network_recon :8000 |
| | | Analisi statica di JavaScript per endpoint API nascosti, percorsi URL e segreti | Info, Exploit | network_recon :8000 |
| | | Scoperta di parametri HTTP tramite brute force su ~25.000 nomi di parametri comuni | Info, Exploit | network_recon :8000 |
| | | Fuzzing web per directory nascoste, file, virtual host e parametri | Info, Exploit | network_recon :8000 |
| | | Automazione del browser Chromium headless -- estrazione di contenuti renderizzati in JS e scripting interattivo per SPA, test dei moduli, verifica XSS | All | playwright :8005 |
| | | msfconsole persistente -- esecuzione di exploit, gestione delle sessioni, post-exploitation | Exploit, Post | metasploit :8003 |
| | | Reset completo di Metasploit -- termina tutte le sessioni, azzera lo stato dei moduli | Exploit, Post | metasploit :8003 |
| | | Brute force con THC Hydra -- oltre 50 protocolli (SSH, FTP, RDP, SMB, HTTP, MySQL, ecc.) | Exploit, Post | network_recon :8000 |
| | | Shell Kali Linux completa -- 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, librerie Python (websockets, zeep, python3-saml, boto3, msal, azure-identity, google-auth, google-cloud-storage), toolkit post-exploit preconfigurati in /opt/tools/{linux,windows}/ (linpeas, LinEnum, pspy64, deepce, winPEAS, PowerUp, PrivescCheck) e oltre 70 strumenti CLI | All | network_recon :8000 |
| | | Scrive ed esegue file di codice (Python, bash, Ruby, Perl, C, C++) -- nessun escaping della shell | Exploit, Post | network_recon :8000 |
| | | Cronologia in stile Burp sul corpus HTTP catturato -- solo riepiloghi, stessi filtri dell'interfaccia (host, metodo, stato, strumento, sorgente, sottostringa URL / sottostringa del body, reflected, only5xx) | All | -- (in-process) |
| | | Richiesta o risposta completa (header + body) per una singola transazione catturata | All | -- (in-process) |
| | | Endpoint distinti osservati (host + percorso + metodo) con conteggio delle occorrenze e codici di stato | All | -- (in-process) |
| | | Parametri di richiesta distinti con valori di esempio e un'euristica di iniettabilità (sequential-id / uuid / jwt / base64) | All | -- (in-process) |
| | | Ricerca di sottostringhe senza distinzione tra maiuscole e minuscole nei body delle risposte catturate, con uno snippet attorno alla prima corrispondenza | All | -- (in-process) |
| | | Diff strutturale di due risposte (stato, lunghezza, insieme di header, unified-diff del body) per il rilevamento di SQLi boolean-blind / IDOR / bypass dell'autenticazione | All | -- (in-process) |
| | | Rappresenta una richiesta catturata come comando riproducibile (sola lettura, non invia nulla) | All | -- (in-process) |
| | | Costruttore di query analitiche vincolate su colonne / aggregazioni in allowlist (solo specifica JSON, niente SQL grezzo) | All | -- (in-process) |
| | | -- reinvia una richiesta catturata con campi modificati (metodo / percorso / query / parametri / header / cookie / body); host, schema e porta ancorati all'origine. Scambio del contesto di autenticazione per IDOR / BOLA / privesc. Ricatturata come transazione | Exploit, Post | network_recon :8000 |
| | | -- in stile Burp Intruder: riproduci una richiesta catturata iterando un set di payload (massimo 50) su un parametro della query, restituisce un riepilogo stato / lunghezza per payload | Exploit, Post | network_recon :8000 |
| | | Legge un file del workspace con numeri di riga, rileva automaticamente i binari, memorizza uno snapshot per | All | -- (in-process) |
| | | Lettura in batch di più file, con limite (default 200 KB) | All | -- (in-process) |
| | | Solo metadati -- dimensione, mtime, modalità, tipo, SHA-256 opzionale | All | -- (in-process) |
| | | Creazione/sovrascrittura/append atomica, crea automaticamente le directory padre | All | -- (in-process) |
| | | Sostituzione di stringhe esatte con controllo di unicità, registra una voce di undo | All | -- (in-process) |
| | | Più modifiche ordinate in una sola chiamata, transazione tutto-o-niente | All | -- (in-process) |
| | | Annulla l'ultimo / , stack di undo per file con limite di 20 | All | -- (in-process) |
| | | Elimina file o directory (flag ricorsivo richiesto per le directory) | All | -- (in-process) |
| | | Sposta o rinomina un percorso, crea automaticamente le directory padre di destinazione | All | -- (in-process) |
| | | Copia file o albero di directory, permessi normalizzati affinché l'utente host possa modificarli | All | -- (in-process) |
| | | Crea una directory, idempotente | All | -- (in-process) |
| | | Modifica i bit dei permessi (ottale o simbolico ) | All | -- (in-process) |
| | | Crea un symlink, rifiuta endpoint che uscirebbero dal workspace | All | -- (in-process) |
| | | Ripgrep sul workspace con regex, timeout di 30 s, limite di 1000 corrispondenze, funziona sui log dei job in esecuzione | All | -- (in-process) |
| | | Ricerca con pattern glob ordinata dal più recente al più vecchio, limite di 500 risultati | All | -- (in-process) |
| | | Ricerca per metadati (filtri su nome + mtime + dimensione + tipo), timeout di 30 s per l'attraversamento, tetto di 5000 risultati | All | -- (in-process) |
| | | Elencazione di una singola directory con tipo / dimensione / mtime, limite di 200 voci | All | -- (in-process) |
| | | Albero ASCII con limite di profondità, salta , , | All | -- (in-process) |
| | | Schema AST con Tree-sitter (nomi di funzioni / classi / metodi + intervalli di righe), 15 linguaggi (py, js, ts, tsx, jsx, java, go, rs, rb, php, c, cpp, cs, kt, swift, scala) | All | -- (in-process) |
| | | Risolve il symlink verso il suo target grezzo senza seguirlo | All | -- (in-process) |
| | | Hash SHA-256 o MD5 di un file, trasmesso in blocchi da 64 KB | All | -- (in-process) |
| | | Diff unificato tra due file, o tra un file e il suo ultimo snapshot (rileva scritture concorrenti nel fireteam) | All | -- (in-process) |
| | | Estrazione sicura di archivi tar / zip / gz, rifiuta i percorsi zip-slip e tar-slip | All | -- (in-process) |
| | | Raggruppa i percorsi del workspace in tar.gz o zip per il download in un clic da parte dell'operatore | All | -- (in-process) |
| | | Stacca la chiamata dello strumento come attività asyncio in background, output riversato in tempo reale su , controlli di fase / RoE all'avvio | All | -- (in-process) |
| | | Query di stato non bloccante -- stato corrente, dimensione del log, ultime 40 righe di output, sopravvive al riavvio dell'agente tramite | All | -- (in-process) |
| | | Blocca fino a N secondi in attesa che il job termini, restituisce la stessa struttura di | All | -- (in-process) |
| | | Annulla un job in esecuzione, lo stato passa a , nessuna operazione sui job terminali | All | -- (in-process) |
| | | Elenca i job in background del progetto, filtro con / / ometti per tutti | All | -- (in-process) |
Tutti gli strumenti MCP vengono eseguiti all'interno di un container sandbox Kali Linux. Gli strumenti Workspace FS e Background Jobs vengono eseguiti in-process nel container dell'agente e operano esclusivamente sul workspace del singolo progetto in /workspace/<projectId>/ -- la validazione dei percorsi rifiuta ogni tentativo di traversal (iniezione di project-id, fuga tramite symlink, zip-slip, tar-slip). Consulta la pagina wiki Agent Workspace per il riferimento completo. Gli strumenti contrassegnati come pericolosi richiedono conferma manuale prima dell'esecuzione. La modalità stealth limita gli strumenti attivi a operazioni solo passive o a bersaglio singolo. Nota: WPScan è concesso in licenza WPScan Public Source License (non MIT). Gratuito per test di penetrazione e uso personale; l'uso commerciale può richiedere una licenza separata da wpscan.com.
Oltre ai 5 server MCP integrati sopra, puoi collegare qualsiasi server Model-Context-Protocol all'agente come plugin di strumenti (Shodan, GitHub, Censys, Hugging Face, mitmproxy, i tuoi MCP interni) senza modificare il codice, ricostruire i container o eseguire migrazioni. Apri Global Settings → MCP Tool Plugins.
Due percorsi: scegli uno dei 39 preset Quick-Add precompilati (OSINT, threat-intel, cloud, scanner per applicazioni web, reporting, reverse engineering; le categorie sono etichettate su ogni scheda), oppure clicca Add MCP per una configurazione manuale. Tre trasporti supportati: stdio, sse, streamable_http. Il pulsante arancione Discover and add new tools esegue una list_tools() live sulla bozza, restituisce il risultato entro 30 secondi e importa automaticamente ogni strumento scoperto con il suo nome, la descrizione e un args_format derivato da JSON-Schema (tipi, enum, default, min/max, descrizioni per proprietà). Salva → gli strumenti compaiono automaticamente nella Tool Matrix di ogni progetto e nel system prompt dell'agente entro ~1 secondo. Nessun riavvio dell'agente, nessun prisma db push.
Manuale operatore completo (ogni campo del modulo, tutti i 39 preset, il flusso di autenticazione, il workflow di discovery live, le regole di validazione, la risoluzione dei problemi e il modello di archiviazione / sicurezza): pagina wiki MCP Tool Plugins.
Guarda la demo: RedAmon Agent Workspace: l'IA esegue 4 pentest in parallelo e scrive il proprio report (YouTube)
Ogni progetto dispone di una directory persistente /workspace/<projectId>/ che l'agente, la kali-sandbox e tu (tramite il FileSystem Drawer nella Red Zone) vedono tutti contemporaneamente. Quattro cartelle dedicate vengono create automaticamente e protette da rinomina/eliminazione: notes/ per gli appunti provvisori dell'agente e le bozze dei report, tool-outputs/ per l'auto-offload degli output di grandi dimensioni, jobs/ per i log dei processi in background e uploads/ per i file che inserisci affinché l'agente li legga. L'agente apprende la struttura a ogni passo di pensiero tramite un WORKSPACE_LAYOUT_BLOCK e, quando inserisci file in uploads/, il blocco li evidenzia sotto una direttiva CHECK THESE NOW così l'agente li legge prima di continuare qualsiasi altra attività in corso.
L'agente riceve 24 strumenti filesystem (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 e altri) più 5 strumenti per i processi in background (job_spawn, job_status, job_wait, , ). Le scansioni lunghe come o si staccano come attività asyncio e trasmettono l'output su , così l'agente può eseguire alla ricerca di risultati al volo senza bloccare il passo di ragionamento successivo. Gli output oltre 20 KB vengono automaticamente scaricati su e l'LLM riceve uno stub di testa/coda più il percorso del file, così un dump DOM di 5 MB da Playwright non fa mai deragliare la finestra di contesto. Il drawer presenta tutto questo con navigazione a briciole di pane, upload drag-and-drop, anteprima inline, proprietà SHA-256, download tar.gz per cartella e una scheda Jobs con badge di stato live e annullamento.
La validazione dei percorsi rifiuta ogni tentativo di traversal (iniezione di project-id, fuga tramite symlink, zip-slip, tar-slip, bypass delle cartelle protette tramite normalizzazione) ed è applicata lato server. I processi sopravvivono al riavvio dell'agente tramite metadati su disco: i processi orfani in esecuzione passano a interrupted all'avvio, così l'interfaccia non mostra mai una riga che gira all'infinito.
Manuale operatore completo (ogni funzionalità del drawer, tutti i 29 strumenti del workspace, la mappa delle policy di auto-offload, le quattro cartelle protette, i pattern di coordinamento del fireteam tramite
fs_diff vs_last_reade il modello di sicurezza della validazione dei percorsi): pagina wiki Agent Workspace.
La modalità di esecuzione più potente dell'agente. Quando un obiettivo si scompone in angoli di indagine indipendenti (superficie di autenticazione, mappa delle rotte, policy degli header; oppure 5 CVE candidate da triage in parallelo), l'agente radice si ramifica in N sotto-agenti specializzati che lavorano in contemporanea nello stesso backend, ciascuno con il proprio loop ReAct multi-step e una missione mirata. Questa è l'implementazione di RedAmon del pattern architetturale Scatter-Gather ReAct (SG-ReAct): un agente radice che decide quando ramificarsi, un fireteam limitato di specialisti che lavorano in parallelo e un passo di fan-in che fonde i loro risultati in un'unica visione consolidata.
Ogni garanzia di sicurezza che vale per l'agente radice vale anche per ogni membro: guardrail rigidi, guardrail flessibili, gating delle fasi, regole di ingaggio e conferme per gli strumenti pericolosi (gestite per membro, in parallelo; N membri possono attendere ciascuno la tua approvazione nel proprio pannello simultaneamente, senza serializzazione). La ricorsione è vietata (un membro non può a sua volta distribuire un fireteam) e ogni ondata ha un tetto massimo di membri, un budget di iterazioni per membro e un timeout wall-clock. Il risultato è parallelismo wall-clock senza caos di coordinamento, terminazione prevedibile e una traccia di audit in cui ogni azione è attribuibile allo specialista che l'ha prodotta.
Wiki: Fireteam (specialisti in parallelo) | Tecnico: README.AGENTIC_SYSTEM.md
Supporta 5 provider e oltre 400 modelli: OpenAI (GPT-5.2, GPT-5, GPT-4.1), Anthropic (Claude Opus 4.6, Sonnet 4.5), OpenRouter (oltre 300 modelli), AWS Bedrock e qualsiasi endpoint compatibile con OpenAI (Ollama, vLLM, LM Studio, Groq, ecc.). I modelli vengono recuperati dinamicamente, nessuna lista hardcoded.
Le impostazioni dei provider compatibili con OpenAI includono un controllo reasoning effort. Abilitalo per inviare reasoning_effort con low, medium, high o max; lascialo disabilitato per non inviare nulla e usare il default del modello. Abilitalo solo per modelli con capacità di pensiero: un modello privo di capacità di pensiero rifiuta un livello e l'agente riprova in modo trasparente senza di esso. I livelli di effort disponibili dipendono dal modello. I provider OpenAI canonici e gli endpoint OpenAI-compatibili non correlati conservano il comportamento esistente.
Un grafo di conoscenza Neo4j con 17 tipi di nodi e oltre 20 tipi di relazioni, la fonte unica di verità per la superficie d'attacco del target. L'agente lo interroga prima di ogni decisione tramite traduzione dal linguaggio naturale → Cypher.
Wiki: Grafo della superficie d'attacco | Tecnico: GRAPH.SCHEMA.md
Un grafo evolutivo e persistente che tiene traccia di tutto ciò che fa l'agente AI: esecuzioni di strumenti, scoperte, fallimenti e decisioni strategiche. Il contesto strutturato della catena sostituisce le tracce di esecuzione piatte, migliorando l'efficienza dell'agente di oltre il 25%. La memoria tra sessioni significa che l'agente non riparte mai da zero.
Avvia più sessioni agente concorrenti contro lo stesso progetto. Ogni sessione crea la propria AttackChain in EvoGraph. Le nuove sessioni caricano automaticamente i risultati e le lezioni apprese dagli errori di tutte le sessioni precedenti, evitando lavoro ridondante.
La cronologia proxy integrata di RedAmon, circoscritta all'engagement: un proxy man-in-the-middle senza credenziali (basato su mitmproxy) si posiziona tra ogni strumento offensivo e il suo target, registra la richiesta/risposta completa di ogni transazione HTTP, la etichetta con chi l'ha prodotta (progetto / utente / esecuzione / strumento tramite un tag di contesto HMAC firmato) e la memorizza in Postgres attraverso un worker di acquisizione affidabile, solo-INSERT. Immagina la cronologia HTTP di Burp Suite, con la differenza che si attiva con un interruttore, attribuisce ogni richiesta alla sua origine ed è interrogabile sia dall'operatore sia dall'agente AI.
La cattura è disattivata di default e controllata su due livelli (un interruttore principale globale che avvia il proxy, più un interruttore di routing per progetto). Otto strumenti di ricognizione e otto strumenti HTTP dell'agente (execute_curl, execute_httpx, execute_playwright, execute_nuclei, execute_katana, execute_ffuf, execute_arjun, execute_wpscan) vengono instradati, così sia il traffico di crawl/fuzz/scan della pipeline sia quello dell'agente viene catturato, reso ricercabile e riproducibile. Il proxy non contiene segreti, una protezione egress SSRF con pin dell'IP anti DNS-rebinding gli impedisce di fare pivot verso l'infrastruttura interna, gli header sensibili vengono oscurati e i segnali passivi (parametri riflessi, header di sicurezza mancanti, problemi di flag dei cookie) vengono calcolati gratuitamente su ogni risposta. Una vista TrafficMind nella navigazione superiore espone il corpus come una tabella in stile Burp, impaginata e filtrabile, con un drawer di dettaglio richiesta/risposta, esportazione CSV/JSON e pulizia dei body con conteggio dei riferimenti.L'agente processa il corpus tramite dieci strumenti proxy_*: otto strumenti di analisi in sola lettura (proxy_search, , , , , , , ) e due strumenti attivi (, ) che reinviano una richiesta catturata o la sottopongono a fuzzing in stile Intruder. Tutti e dieci sono strettamente limitati al tenant; gli strumenti attivi sono vincolati all'host di origine, contrassegnati come pericolosi, soggetti a gate di fase e a restrizioni stealth.
Vista unificata delle sessioni attive: meterpreter, reverse/bind shell e listener. Terminale integrato con un Command Whisperer che traduce l'inglese semplice in comandi shell.
Accesso shell PTY interattivo completo al container sandbox Kali direttamente dalla pagina del grafo tramite xterm.js. Accedi a tutti gli strumenti di pentesting preinstallati (Metasploit, Nmap, Nuclei, Hydra, sqlmap) senza uscire dal browser. Offre tema scuro del terminale, indicatore di stato della connessione, riconnessione automatica con backoff esponenziale, modalità a schermo intero e keepalive lato browser.
Pipeline a due agenti: un Triage Agent esegue 9 query Cypher hardcoded e poi usa un LLM per correlare, deduplicare e prioritizzare i risultati. Un CodeFix Agent clona il repository target, esplora il codebase con 11 strumenti, implementa le correzioni e apre una PR su GitHub, replicando il design agentico di Claude Code. Poiché il repository clonato non è attendibile, i suoi comandi di build/test vengono eseguiti in un container sandbox isolato e privo di segreti (non nell'agente) e il token GitHub non vi entra mai.
Un Intent Router basato su LLM classifica le richieste degli utenti nelle skill dell'agente: CVE (MSF), SQL Injection, XSS, SSRF, RCE, Path Traversal / LFI / RFI, Credential Testing, Social Engineering, Availability Testing o skill personalizzate definite dall'utente caricate come file Markdown. Le community skills pronte all'uso sono incluse per API testing, XSS, SQLi, XXE, BFLA, SSTI, IDOR / BOLA, deserializzazione non sicura, mass assignment, subdomain takeover e upload di file non sicuri -- scarica il file .md e caricalo tramite Global Settings > Agent Skills per attivarla per il tuo utente. Puoi anche contribuire con le tue aprendo una PR.
Iniezione di riferimenti su richiesta tramite il comando /skill nella chat dell'agente. Le Chat Skills sono documenti di riferimento tattici -- playbook di strumenti, guide alle vulnerabilità, note specifiche per framework -- che inietti nel contesto dell'agente esattamente quando ti servono. Digita /skill ssrf per caricare le competenze SSRF oppure clicca il pulsante del selettore delle skill per una lista sfogliabile. 46 skill di riferimento sono incluse con RedAmon e coprono vulnerabilità (JWT, OAuth/OIDC, CSRF, race conditions, business logic, prototype pollution, ReDoS, bypass 2FA, injection LDAP/XPath, web cache poisoning, CORS, host header injection, clickjacking, CRLF e altro), strumenti (sqlmap, nuclei, ffuf, nmap, httpx, naabu, katana, subfinder, semgrep), protocolli (GraphQL, WebSocket, SOAP/WS-Security, SAML), tecnologie (Firebase, Supabase), framework (Next.js, FastAPI, NestJS), Active Directory (kill chain, Kerberoasting/ASREPRoast, AD-CS ESC1-15, BloodHound path-to-DA), cloud (AWS, Azure, GCP) e post-exploitation (Docker escape, privesc Linux / Windows). A differenza delle Agent Skills (che guidano la classificazione e i workflow sensibili alla fase), le Chat Skills sono contesto supplementare che persiste finché non le modifichi o le rimuovi.
Scansiona repository GitHub, gist e cronologia dei commit alla ricerca di segreti esposti utilizzando oltre 40 pattern regex e analisi dell'entropia di Shannon.
Scansiona i repository GitHub alla ricerca di credenziali trapelate utilizzando oltre 700 rilevatori con verifica automatica se i segreti scoperti sono ancora attivi. Alimentato dal motore TruffleHog (trufflesecurity/trufflehog), rileva API key, password, token, certificati e altro nell'intera cronologia dei commit. I risultati vengono memorizzati come nodi TrufflehogScan → TrufflehogRepository → TrufflehogFinding nel grafo Neo4j. Sia GitHub Hunt che TruffleHog sono accessibili dalla modale "Other Scans" nella toolbar del grafo.
Oltre 500 parametri configurabili su 16 schede che controllano il comportamento di ogni strumento, dai moduli di scansione ai gate di approvazione degli agenti. Gestiti tramite l'interfaccia webapp.
Carica un documento RoE (PDF, TXT, MD, DOCX) per configurare automaticamente le impostazioni del progetto e applicare i vincoli dell'engagement. Applicazione sia a livello della pipeline di ricognizione (host esclusi, limiti di frequenza, finestre temporali) sia a livello dell'agente AI (iniezione di prompt, tetto massimo di severità per fase, restrizioni sugli strumenti).
Oltre 30 grafici interattivi in 4 sezioni: catene di attacco ed exploit, superficie d'attacco, vulnerabilità e intelligence CVE, e panoramica del grafo. Tutti i dati vengono recuperati in tempo reale da Neo4j e PostgreSQL.
Guardrail basato su LLM che impedisce di prendere di mira domini non autorizzati: blocca siti governativi, grandi aziende tecnologiche, istituzioni finanziarie e piattaforme di social media. Opera sia alla creazione del progetto sia all'inizializzazione dell'agente. I domini governativi, militari, educativi e delle organizzazioni internazionali (.gov, .mil, .edu, .int) sono bloccati permanentemente da un guardrail deterministico rigido che non può essere disabilitato.
Gate human-in-the-loop per singolo strumento per le operazioni pericolose. Quando è abilitato, l'agente si mette in pausa prima di eseguire strumenti ad alto impatto (Nmap, Nuclei, Metasploit, Hydra, shell Kali, esecuzione di codice) e presenta un prompt inline Allow / Deny nella timeline della chat. Supporta sia la modalità di conferma per singolo strumento sia quella a ondate parallele (plan). Gli utenti possono approvare, rifiutare o modificare gli argomenti degli strumenti prima che l'esecuzione proceda. Si disattiva tramite l'interruttore Require Tool Confirmation nelle Project Settings.
Report HTML professionali, pronti per il cliente, con 11 sezioni. Quando è configurato un modello AI, 6 sezioni ricevono narrazioni generate da LLM, tra cui sintesi esecutiva, analisi dei rischi e triage di remediation prioritizzato. Visualizza report di esempio.
Backup e ripristino completi del progetto tramite l'interfaccia web: impostazioni, conversazioni, dati del grafo, risultati di ricognizione/GVM/GitHub hunt come archivio ZIP portabile.
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
> **Diagrammi completi dell'architettura** (flusso dei dati, container Docker, pipeline di riconoscimento, flusso di lavoro dell'agente, integrazione MCP): **[ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/ARCHITECTURE.md)**
>
> **Stack tecnologico** (70+ tecnologie tra frontend, backend, IA, database, strumenti di sicurezza): **[TECH_STACK.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/TECH_STACK.md)**
---
## Componenti
| Componente | Descrizione | Documentazione |
|-----------|-------------|---------------|
| **Reconnaissance Pipeline** | Pipeline OSINT e di scansione delle vulnerabilità con fan-out/fan-in parallelizzati | [README.RECON.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.RECON.md) |
| **Recon Orchestrator** | Gestione del ciclo di vita dei container tramite Docker SDK | [README.RECON_ORCHESTRATOR.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.RECON_ORCHESTRATOR.md) |
| **Docker Socket Broker** | Reverse-proxy filtrante per il socket Docker: i container di scansione generati raggiungono il daemon tramite esso, così possono creare solo le immagini degli strumenti note (in allowlist, niente mount host / container privilegiati / immagini arbitrarie) | n/a |
| **Graph Database** | Mappatura della superficie d'attacco Neo4j con supporto multi-tenant | [README.GRAPH_DB.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.GRAPH_DB.md) · [GRAPH.SCHEMA.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/GRAPH.SCHEMA.md) |
| **MCP Tool Servers** | Strumenti di sicurezza tramite Model Context Protocol (sandbox Kali) | [README.MCP.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.MCP.md) |
| **AI Agent Orchestrator** | Agente autonomo basato su LangGraph con pattern ReAct | [README.AGENTIC_SYSTEM.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.AGENTIC_SYSTEM.md) |
| **CypherFix Agents** | Triage automatizzato + correzione del codice + PR GitHub | [README.CYPHERFIX_AGENTS.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.CYPHERFIX_AGENTS.md) |
| **Web Application** | Dashboard Next.js per visualizzazione e interazione con l'IA | [README.WEBAPP.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.WEBAPP.md) |
| **GVM Scanner** | Scanner di vulnerabilità di rete Greenbone/OpenVAS (170K+ NVT) | [README.GVM.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.GVM.md) |
| **TruffleHog Scanner** | Scansione approfondita dei segreti con oltre 700 rilevatori e verifica delle credenziali | n/a |
| **PostgreSQL Database** | Impostazioni del progetto, account utente, dati di configurazione | [README.POSTGRES.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.POSTGRES.md) |
| **Test Environments** | Container Docker volutamente vulnerabili per test sicuri | [README.GPIGS.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.GPIGS.md) |
---
## Documentazione
| Risorsa | Collegamento |
|----------|------|
| **Wiki completo** (guida utente) | **[github.com/samugit83/redamon/wiki](https://github.com/samugit83/redamon/wiki)** |
| Distribuzione su server (single-host) | **[Wiki: Deploying to a Server](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server)** · [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/HEAD/deploy/single-host/README.md) |
| **Postura di sicurezza** (catalogo difesa in profondità) | **[readmes/README.SECURITY_POSTURE.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.SECURITY_POSTURE.md)** |
| Modello di minaccia (STRIDE) | [readmes/README.TM.SYSTEM_OVERVIEW.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.TM.SYSTEM_OVERVIEW.md) |
| Politica di sicurezza | [SECURITY.md](https://github.com/samugit83/redamon/blob/HEAD/SECURITY.md) |
| Sviluppo assistito dall'IA | **[Wiki: Ship Perfect PRs with AI](https://github.com/samugit83/redamon/wiki/AI-Assisted-Development)** |
| Guida per sviluppatori | [readmes/README.DEV.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/README.DEV.md) |
| Diagrammi di architettura | [readmes/ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/ARCHITECTURE.md) |
| Stack tecnologico | [readmes/TECH_STACK.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/TECH_STACK.md) |
| Risoluzione dei problemi | [readmes/TROUBLESHOOTING.md](https://github.com/samugit83/redamon/blob/HEAD/readmes/TROUBLESHOOTING.md) |
| Changelog | [CHANGELOG.md](https://github.com/samugit83/redamon/blob/HEAD/CHANGELOG.md) |
| Disclaimer completo | [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/HEAD/DISCLAIMER.md) |
| Licenze di terze parti | [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/HEAD/THIRD-PARTY-LICENSES.md) |
| Licenza | [LICENSE](https://github.com/samugit83/redamon/blob/HEAD/LICENSE) |
---
## Risoluzione dei problemi
RedAmon è completamente dockerizzato e funziona su qualsiasi sistema operativo con Docker Compose v2+. Per soluzioni specifiche del sistema operativo (Linux, Windows, macOS), consulta la **[Guida alla risoluzione dei problemi](https://github.com/samugit83/redamon/blob/HEAD/readmes/TROUBLESHOOTING.md)** o la **[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>Vuoi vedere RedAmon ragionare come un vero pentester?</h3>
<p>Esplora sessioni di attacco live in tempo reale -- ogni passo, ogni pivot, ogni exploit -- su 15 categorie di vulnerabilità contro un target live. Log di sessione completi, walkthrough decodificati e registrazioni video che mostrano l'agente compromettere autonomamente da zero un server multi-servizio.</p>
<a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab"><b>Esplora l'HackLab →</b></a>
|
<a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab#community-sessions"><b>Invia la tua sessione →</b></a>
<br/><sub>Hai ottenuto una sessione dell'agente incredibile sul tuo target? Condividila con la community -- log della sessione + video YouTube.</sub>
</td>
</tr>
</table>
---
## Vetrina della community
Video, writeup ed esperienze reali di professionisti della sicurezza che utilizzano RedAmon sul campo. Vuoi essere incluso? Consulta il percorso [Content Creator](https://github.com/samugit83/redamon/blob/HEAD/CONTRIBUTING.md#content-creator) in CONTRIBUTING.md.
### Video
| Titolo | Collegamento |
|-------|------|
| RedAmon v2.2.0, Test di ingegneria sociale: consegna del payload fino all'accesso alla shell | [Guarda](https://youtu.be/kVjV9K_eks4) |
| Validazione CVE con agente IA: oltre gli strumenti standard | [Guarda](https://youtu.be/rypmP1SJon8) |
| RedAmon 2.0, Da 0 a 1000 stelle GitHub in 10 giorni: attacchi paralleli multi-agente | [Guarda](https://youtu.be/afViJUit0xE) |
| Costruire da zero un agente IA autonomo per il red team: tutorial completo LangGraph + Metasploit + Neo4j | [Guarda](https://youtu.be/mO5CCkYlY94) |
### Casi di studio reali
| Chi | Cosa | Collegamento |
|-----|------|------|
| Nipun Dinudaya | Ha distribuito RedAmon sul sito web di un'azienda e ha individuato una vulnerabilità critica di SQL injection che avrebbe potuto causare un'esposizione significativa dei dati | [Leggi su LinkedIn](https://www.linkedin.com/posts/nipun-dinudaya-6159b32bb_redamon-cybersecurity-penetrationtesting-ugcPost-7431233870253166592-aLvb) |
| Venkata Bhargav CH S | Ha usato RedAmon durante uno stage presso Ascent e-Digit Solutions: riconoscimento pratico, analisi DNS e mappatura della superficie d'attacco | [Leggi su LinkedIn](https://www.linkedin.com/posts/venkata-bhargav-cybersecurity_cybersecurity-ethicalhacking-redteam-share-7434940660803182592-e9En) |
### Guide della community
| Chi | Cosa | Collegamento |
|-----|------|------|
| MrGood | Padroneggiare RedAmon: una guida completa all'installazione su Kali Linux, che affronta le sfide Docker specifiche di Kali e la postura di sicurezza | [Leggi su Medium](https://cyberaccoon.medium.com/mastering-redamon-a-comprehensive-guide-to-installation-on-kali-linux-ea544e6f5b9f) |
| Bogdan Caraman | Come installare RedAmon su Debian 13 (Trixie) con OpenRouter, guida passo passo con configurazione Docker, IP statico e automazione systemd | [Leggi sul blog](https://blog.bogdancaraman.com/install-redamon-debian-13-openrouter/) |
---
## Contributi
I contributi sono i benvenuti! Leggi [CONTRIBUTING.md](https://github.com/samugit83/redamon/blob/HEAD/CONTRIBUTING.md) per le linee guida su come iniziare, le convenzioni di stile del codice e il processo delle pull request.
---
## Manutentori
**Samuele Giampieri**: creatore, maintainer e architetto della piattaforma IA · [LinkedIn](https://www.linkedin.com/in/samuele-giampieri-b1b67597/) · [GitHub](https://github.com/samugit83) · [Devergo Labs](https://www.devergolabs.com/)
**Ritesh Gohil**: maintainer e ricercatore di sicurezza principale · [LinkedIn](https://www.linkedin.com/in/riteshgohil25/) · [GitHub](https://github.com/L4stPL4Y3R)
---
## Contatti
Per domande, feedback o richieste di collaborazione: **[email protected]**
---
## Note legali
> **Locale per impostazione predefinita; la distribuzione su server ha un percorso irrobustito supportato.** Così com'è, RedAmon è pensato per essere eseguito su una **macchina locale** e non include di per sé controlli di sicurezza esposti a internet. Per eseguirlo su un server pubblico raggiungibile da internet, usa la **distribuzione single-host irrobustita** in [`deploy/single-host/`](https://github.com/samugit83/redamon/blob/HEAD/deploy/single-host/), che pone l'intero stack dietro nginx + TLS, un firewall host, l'hardening di SSH e un'unica origine HTTPS pubblica, con ogni servizio interno vincolato al loopback. Eseguire lo stack **grezzo** (senza quella distribuzione) su un IP pubblico esporrebbe servizi interni non autenticati, quindi qualsiasi utilizzo al di fuori di una rete locale attendibile senza la distribuzione irrobustita è interamente a proprio rischio.
Questo progetto è rilasciato sotto la [licenza MIT](https://github.com/samugit83/redamon/blob/HEAD/LICENSE).
RedAmon integra diversi strumenti di terze parti con le rispettive licenze (MIT, Apache-2.0, BSD, GPL-2.0/3.0, AGPL-3.0, LGPL e WPScan Public Source License). Il codice sorgente di tutti i componenti con licenza AGPL è disponibile nei rispettivi repository upstream. L'inventario completo e gli obblighi di licenza sono documentati in [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/HEAD/THIRD-PARTY-LICENSES.md).
> **Nota sull'uso commerciale**: l'immagine sandbox Kali include **WPScan**, governato dalla WPScan Public Source License. WPScan limita l'uso commerciale (SaaS, offerte di prodotti a pagamento, servizi a valore aggiunto) senza una licenza separata dal team di WPScan. Gli impegni di penetration testing e l'uso personale sono consentiti. Se intendi usare RedAmon in un prodotto o servizio commerciale, consulta [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/HEAD/THIRD-PARTY-LICENSES.md) prima della distribuzione.
Consulta [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/HEAD/DISCLAIMER.md) per i termini d'uso completi, la politica di utilizzo accettabile e i requisiti di conformità legale.
---
<p align="center">
<strong>Usa in modo responsabile. Testa eticamente. Difendi meglio.</strong>
</p>
 Samuele Giampieri: Creatore, Maintainer e Architetto della Piattaforma AI Architetto della Piattaforma AI e Lead Full-Stack con oltre 15 anni di esperienza da freelance e più di 30 progetti portati in produzione, inclusi sistemi agentici AI su scala enterprise. Certificato AWS (DevOps Engineer, ML Specialty) e AI Engineer certificato IBM. Progetta soluzioni ML end-to-end che spaziano da deep learning, NLP e Computer Vision a sistemi di AI Agent con LangChain/LangGraph. LinkedIn · GitHub · Devergo Labs |
 Ritesh Gohil: Maintainer e Lead Security Researcher Cyber Security Engineer presso Workday con oltre 7 anni di esperienza nel penetration testing di Web, API, Mobile, Network e Cloud. Ha pubblicato 11 CVE in MITRE, con riconoscimenti di sicurezza da Google (4×) e Apple (6×). Ha messo in sicurezza oltre 200 applicazioni web e mobile e ha contribuito a Exploit Database, Google Hacking Database e alla community AWS. Possiede le certificazioni AWS Security Specialty, eWPTXv2, eCPPTv2, CRTP e CEH, con competenze in red teaming, sicurezza cloud, ricerca CVE e revisione delle architetture di sicurezza. LinkedIn · GitHub |
| RAM |
| 4 GB |
| 8 GB (16 GB consigliati) |
| Disco | 80 GB liberi | 110 GB liberi |
| Cosa è cambiato | Azione necessaria |
|---|
webapp/src/ (codice frontend) | Niente -- l'hot-reload di Next.js lo gestisce in modalità dev |
agentic/*.py (codice Python dell'agente) | docker compose build agent && docker compose up -d agent (il sorgente è incorporato nell'immagine, quindi restart da solo non applica le modifiche ai .py) |
recon_orchestrator/*.py | docker compose restart recon-orchestrator |
mcp/servers/*.py (server MCP) | docker compose restart kali-sandbox |
agentic/Dockerfile o agentic/requirements.txt | docker compose build agent && docker compose up -d agent |
recon_orchestrator/Dockerfile o il suo requirements.txt | docker compose build recon-orchestrator && docker compose up -d recon-orchestrator |
mcp/kali-sandbox/Dockerfile | docker compose build kali-sandbox && docker compose up -d kali-sandbox |
webapp/Dockerfile o webapp/package.json | docker compose build webapp && docker compose up -d webapp |
recon/Dockerfile | docker compose --profile tools build recon |
gvm_scan/Dockerfile | docker compose --profile tools build vuln-scanner |
github_secret_hunt/Dockerfile | docker compose --profile tools build github-secret-hunter |
trufflehog_scan/Dockerfile | docker compose --profile tools build trufflehog-scanner |
baddns_scan/Dockerfile o baddns_scan/entrypoint.sh | docker compose --profile tools build baddns-scanner |
wcvs/Dockerfile (motore per il web cache poisoning) | docker compose --profile tools build wcvs |
docker-compose.yml | docker compose up -d (ricrea i container interessati) |
prisma/schema.prisma | docker compose exec webapp npx prisma db push |
| Settings Tab | Phase | Tools | Type | Execution |
|---|
| Discovery & OSINT | Scoperta Sottodomini | crt.sh, HackerTarget, Subfinder, Amass, Knockpy | Passivo* | 5 strumenti in parallelo |
| Filtro Wildcard | Puredns | Attivo | Sequenziale | |
| WHOIS + URLScan | python-whois, URLScan.io API | Passivo | In parallelo | |
| Risoluzione DNS | dnspython | Passivo | 20 worker in parallelo | |
| Arricchimento OSINT | Shodan / InternetDB | Passivo | In parallelo con la scansione delle porte | |
| Espansione Uncover | ProjectDiscovery Uncover (13 motori: Shodan, Censys, FOFA, ZoomEye, Netlas, CriminalIP, Quake, Hunter, PublicWWW, HunterHow, Google, Onyphe, Driftnet) | Passivo | Prima della scansione delle porte (GROUP 2b) | |
| Arricchimento Threat Intel | Censys, FOFA, OTX (AlienVault), Netlas, VirusTotal, ZoomEye, CriminalIP | Passivo | 7 strumenti in parallelo (GROUP 3b) | |
| Scansione Porte | Scansione Porte | Masscan, Naabu | Attivo / Passivo | Entrambi in parallelo (Naabu supporta la modalità passiva InternetDB) |
| Rilevamento Servizi Nmap | Rilevamento Versione Servizi | Nmap (-sV, --script vuln) | Attivo | Sequenziale per target |
| Probing HTTP | Probing HTTP | httpx | Attivo | Parallelo interno |
| Rilevamento Tecnologie | Wappalyzer | Passivo | Sequenziale (post-probe) | |
| Banner Grabbing | Personalizzato (socket Python: SSH, FTP, SMTP, MySQL, ecc.) | Attivo | Worker in parallelo | |
| Enum Risorse | Web Crawling | Katana, Hakrawler | Attivo | In parallelo |
| Scoperta Archivi | GAU (Wayback, CommonCrawl, OTX) | Passivo | In parallelo con i crawler | |
| Mining dei Parametri | ParamSpider (Wayback CDX) | Passivo | In parallelo con i crawler | |
| Analisi JS | jsluice | Attivo | Sequenziale (post-crawl) | |
| Fuzzing delle Directory | FFuf | Attivo | Sequenziale (post-jsluice) | |
| Crawling con Browser | ZAP Ajax Spider | Attivo | Sequenziale (post-FFuf), container Docker per-seed in parallelo | |
| Scoperta dei Parametri | Arjun | Attivo / Passivo | Metodi in parallelo (GET/POST/JSON/XML) | |
| Scoperta API | Kiterunner | Attivo | Sequenziale per wordlist | |
| Classificatore Endpoint AI | Classificatore di percorso + parametri — etichetta Endpoint.ai_interface_type (llm-chat, llm-completion, llm-embedding, llm-tool-call, sse-stream, mcp, llm-graphql), is_ai_rag_ingest, Parameter.is_ai_prompt_injectable rispetto alle firme AI catalogate | Passivo | Sequenziale (post-crawl) | |
| Recon JS | Rilevamento Segreti JS | 100 pattern regex + upload personalizzati | Passivo | In parallelo per file |
| Validazione delle Chiavi | 21 validatori di servizi (AWS, GitHub, Stripe, ecc.) | Attivo | Rate-limited (1/sec/svc) | |
| Scoperta Source Map | Sondaggio di commenti, header, percorsi | Attivo | Per file JS | |
| Dependency Confusion | Controllo registro npm | Passivo | Per pacchetto scoped | |
| Estrazione Endpoint | Pattern REST, GraphQL, WebSocket, router | Passivo | Per file JS | |
| Fingerprinting del Framework | 12 firme integrate + personalizzate | Passivo | Per file JS | |
| Rilevamento Sink DOM | 17 pattern di XSS/prototype pollution | Passivo | Per file JS | |
| AI Surface Recon | Fingerprinting AI/LLM/MCP/Vector-DB | Conferma attiva delle superfici segnalate dal classificatore — sonde a forma di chat (dialetto/streaming/latenza), handshake MCP + tools/list + scansione tool-poisoning con YARA di Cisco, scoperta OpenAPI/elenco modelli, motore di probe-pack YAML Julius, letture di conferma vector-DB (qdrant/chroma/weaviate/milvus). Scrive Endpoint.ai_* / ai_mcp_*, Parameter.is_ai_prompt_injectable, nodi Technology(ai-*) confermati e nodi Vulnerability per tool-poisoning MCP | Attivo (benigno, nessuna chiamata LLM) | Host in parallelo, workload sequenziali (GROUP 5c / Phase 4.5) |
| AI Gauntlet | Scansione LLM Ampia | garak — 40 famiglie di probe (prompt injection, jailbreak DAN, bypass di encoding, replay di data-leak, estrazione del system prompt, tossicità, generazione di malware / exploit, allucinazione di pacchetti) | Attivo (offensivo) | Follow-up offensivo alla recon; one-shot per probe, ASR per famiglia, valutato da giudice locale |
| Jailbreak Multi-Turn | PyRIT — attacchi conversazionali delimitati (crescendo, skeleton-key, TAP, many-shot) | Attivo (offensivo) | Escalation multi-turn, modello attaccante / giudice locale | |
| Scansione Qualità + Sicurezza | Giskard — rilevatori su misura per l'app (prompt injection, divulgazione di informazioni, allucinazione, dannosità, stereotipi, sicofanzia, formattazione dell'output) | Attivo (offensivo) | Set di test generato dallo scopo dell'app, giudice locale | |
| Valutazione Red-Team | promptfoo — dataset di attacco pubblici (Pliny, BeaverTails, HarmBench) + strategie di encoding (base64, rot13, leetspeak, morse, pig latin) | Attivo (offensivo) | Valutazione su dataset, ASR per plugin, giudice locale | |
| Scansione Vulnerabilità | Scansione Vulnerabilità | Nuclei (oltre 9.000 template + DAST + upload di template personalizzati) | Attivo | In parallelo con GraphQL Scan + Subdomain Takeover + VHost & SNI + Web Cache Poisoning (GROUP 6 Phase A) |
| Sicurezza GraphQL | Test di Sicurezza GraphQL | Scoperta endpoint, test di introspezione, estrazione dello schema, rilevamento di campi sensibili, graphql-cop (12 controlli di misconfigurazione: DoS alias/batch/directive, GraphiQL, modalità trace, CSRF GET/POST, suggerimenti di campi) | Attivo / Passivo | In parallelo con Nuclei + Subdomain Takeover + VHost & SNI + Web Cache Poisoning (GROUP 6 Phase A) |
| Subdomain Takeover | Rilevamento Subdomain Takeover | Subjack (fingerprint DNS-first Apache-2.0) + template takeover di Nuclei (http/takeovers/ + dns/) + BadDNS (sidecar isolato AGPL-3.0: CNAME, NS, MX, TXT, SPF, DMARC, wildcard, NSEC, referenze, zonetransfer). Dedup tra strumenti, oltre 12 provider auto-sfruttabili, verdetti confirmed / likely / manual_review con punteggio di confidenza | Attivo / Passivo | In parallelo con Nuclei + GraphQL Scan + VHost & SNI + Web Cache Poisoning (GROUP 6 Phase A) |
| Enumerazione VHost & SNI | Scoperta di Virtual Host Nascosti | Probing dual-layer solo curl: override dell'header Host L7 + swap SNI TLS L4 tramite --resolve, rilevamento di anomalie tramite confronto con la baseline, scala di gravità a 4 livelli (high per incoerenza di routing L7/L4, medium per corrispondenze di keyword interne, low/info per delta di stato/dimensione), wordlist predefinita di 2.471 voci + candidati personalizzati e derivati dal grafo, ciclo di feedback di scoperta verso httpx | Attivo | In parallelo con Nuclei + GraphQL Scan + Subdomain Takeover + Web Cache Poisoning (GROUP 6 Phase A) |
| Web Cache Poisoning | Web Cache Poisoning & Deception | Rilevamento a due motori: sweep ampia di WCVS (Hackmanit, Docker-in-Docker) su oltre 10 classi di tecniche (unkeyed-header poisoning, parameter cloaking, normalizzazione percorso/cache-key, iniezione della cache-key, web cache deception) quindi una conferma nativa RedAmon in 5 fasi (cache oracle con fallback silent-cache frozen-Date, cache-buster isolato, pacchetti framework con gate di fingerprint per Next.js/Nuxt/Remix, controllo di persistenza baseline→poison→clean, rilevamento differenziale riflesso + non riflesso). Livelli Confirmed/Strong/Tentative con punteggio di confidenza, gate di confidenza minima; canary benigni .invalid + bucket di cache isolati, così la cache reale non viene mai avvelenata. Disabilitato per impostazione predefinita | Attivo | In parallelo con Nuclei + GraphQL Scan + Subdomain Takeover + VHost & SNI (GROUP 6 Phase A) |
| Controlli di Sicurezza | Controlli di Sicurezza | Bypass WAF, accesso IP diretto, scadenza TLS, header mancanti, cache-control | Attivo | Worker in parallelo |
| CVE & MITRE | Arricchimento CVE | NVD API, Vulners API | Passivo | Sequenziale |
| Arricchimento MITRE | Mappatura CWE / CAPEC | Passivo | Sequenziale |
qbodyqcurlisReplayfs_diff vs_last_readmax_total_bytesfs_editfs_multi_edit0o755+x.gitnode_modules__pycache__fs_readjobs/<id>.log<id>.meta.jsonjob_statuscancelledactive=truefalsejob_canceljob_listnucleihydrajobs/<id>.logfs_greptool-outputs/<utc-iso>-<tool>.txtproxy_getproxy_sitemapproxy_paramsproxy_grepproxy_diffproxy_to_curlproxy_queryproxy_replayproxy_fuzz