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
redcell — Piattaforma di red-team basata su AI. Agenti LLM autonomi eseguono un penetration test end-to-end all'interno di un container Kali e scrivono il report. Motore plan/act LangGraph, modelli provider-agnostic tramite LiteLLM, output PDF/JSON/SARIF. FastAPI + React. | Kitploit
Strumenti/GitHubGitHub/martian56/redcell
Scanner di VulnerabilitàAnalisi del CodiceExploitSicurezza WebSicurezza di RetePenetration TestingRed TeamingSicurezza dell'IA
GitHubmartian56/redcell

redcell

Piattaforma di red-team basata su AI. Agenti LLM autonomi eseguono un penetration test end-to-end all'interno di un container Kali e scrivono il report. Motore plan/act LangGraph, modelli provider-agnostic tramite LiteLLM, output PDF/JSON/SARIF. FastAPI + React.

Vedi Repository
15730252 giorni 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

REDCELL

Agenti AI che eseguono un penetration test end-to-end e scrivono il report.

CI Python FastAPI React Postgres Redis LiteLLM

Console operatore di REDCELL durante un'esecuzione contro DVWA: grafo degli agenti, finding critico RCE, il browser guidato dall'agente e una reverse shell catturata

[!WARNING] REDCELL esegue strumenti offensivi reali. Puntalo solo verso sistemi che possiedi o che sei autorizzato a testare. Rimanere nello scope e nei limiti della legge è tua responsabilità.


Cos'è

REDCELL esegue una squadra di agenti LLM attraverso un pentest. Un orchestratore pianifica l'engagement e assegna obiettivi agli agenti esecutori, che eseguono strumenti reali all'interno di un container Kali e riportano i risultati. Osservi e guidi l'esecuzione da una console operatore: una chat che pilota l'orchestratore, un grafo degli agenti e un feed attività in tempo reale, una vista live del browser guidato dall'agente, un terminale su qualsiasi reverse shell catturata dall'agente e un report da consegnare al termine del lavoro.

I modelli sono intercambiabili tramite LiteLLM, quindi puoi puntarlo a OpenAI, Anthropic, Google, GLM, DeepSeek, Kimi, un Ollama locale o qualsiasi altro provider supportato. Ogni esecuzione salva checkpoint man mano, così un crash o un riavvio riprende da dove era rimasto.

Funzionalità

  • Motore multi-agente. Un ciclo plan/act basato su LangGraph. L'orchestratore delega gli obiettivi agli agenti esecutori che eseguono strumenti shell e registrano finding, loot e host mentre lavorano.
  • Strumenti strutturati. Strumenti dedicati per nmap, nuclei, discovery di directory e vhost, e ricerca ed esecuzione di Metasploit. Ognuno analizza il proprio output nella attack surface o nei finding, così una scansione registra host e vulnerabilità senza passaggi aggiuntivi. run_command copre tutto ciò che non ha uno strumento dedicato.
  • Esecuzione reale, locale o remota. Gli strumenti vengono eseguiti in un container Kali tramite docker exec. Scegli localhost o un server salvato per sessione; un server remoto esegue lo stesso container via SSH con host networking.
  • Browser dell'agente. Per flussi di login e applicazioni ricche di JavaScript che gli strumenti shell non riescono a raggiungere, un agente guida un Chromium reale nel container Kali. Lo osservi in tempo reale e puoi prendere il controllo per cliccare qualcosa tu stesso, poi restituirlo.
  • Reverse shell. Un agente apre un listener, cattura la shell e ti fornisce un terminale interattivo su di essa. Puoi anche aprire i tuoi terminali ed eseguire comandi da solo.
  • Pivoting di rete. Instrada il traffico degli strumenti attraverso una reverse shell catturata per raggiungere host visibili solo dalla macchina compromessa. Un tunnel SOCKS inverso basato su chisel lo trasporta, e nmap viene eseguito automaticamente attraverso il tunnel.
  • La chat pilota l'esecuzione. Dì alla chat cosa vuoi e questa guida l'orchestratore in tempo reale, oppure riapre un'esecuzione conclusa per affrontare nuovo lavoro. Risponde anche a domande sull'engagement.
  • Sessioni di scansione del codice. Punta una sessione verso un repository git pubblico o una cartella locale per una revisione di sicurezza del codice sorgente, con i finding mappati a file e riga.
  • Configurazione per sessione. Imposta il server di esecuzione, il modello e un proxy di uscita opzionale per sessione. Server e proxy includono un test di connessione reale così sai che funzionano prima di affidarti a loro.
  • Triage dei finding. Verifica o scarta i finding e unisci i duplicati che l'agente ha registrato due volte. Il report esclude quelli scartati e contrassegna quelli verificati.
  • Report. Esporta un PDF più JSON e SARIF. Il write-up è generato dal modello della sessione e ripulito per leggersi come se l'avesse scritto una persona, con executive summary, metodologia, finding e remediation in ordine di priorità.
  • Console live. Il feed attività, i terminali e il browser dell'agente vengono trasmessi via WebSocket; il grafo degli agenti, i finding, il loot, la attack surface, i listener e la cronologia del proxy si aggiornano con un polling breve. Tutto si aggiorna in tempo reale mentre l'esecuzione procede.
  • Notifiche. Toast in-app, più notifiche del browser quando la scheda è in background, così una domanda dell'agente o una shell catturata non restano inosservate.

Architettura

root@kitploit:~
flowchart LR
  UI["Operator console<br/>React + Vite"] -->|REST + WebSocket| API["FastAPI"]
  API --> PG[(PostgreSQL)]
  API --> RS[(Redis<br/>pub/sub + queue)]
  API --> S3[(MinIO<br/>files & reports)]
  RS --> W["Worker (arq)"]
  W --> ENG["Engine<br/>LangGraph + LiteLLM"]
  ENG -->|docker exec| KALI["Kali container<br/>local or remote over SSH"]
  KALI --> TGT["Targets"]
  W -->|events / chat / shell| RS
  RS -->|stream| API

L'API non esegue gli agenti. Accoda un'esecuzione, il worker la esegue e il worker pubblica l'output sui canali Redis che l'API inoltra al browser tramite WebSocket.

Stack

Python 3.12, FastAPI, async SQLAlchemy + asyncpg, Alembic, arq, LangGraph, LiteLLM, ReportLab, PostgreSQL, Redis, MinIO, asyncssh. Frontend: React 18, Vite, TypeScript, Tailwind, TanStack Query, xterm. Tooling: uv per Python, bun per il frontend.

Quickstart

Ti servono Docker, uv e bun.

root@kitploit:~
# 1. infrastructure (Postgres, Redis, MinIO)
docker compose -f docker-compose.dev.yml up -d

# 2. Python deps, database, and seed data
uv sync --group live
uv run rc db upgrade
uv run rc seed              # admin user, provider catalog, buckets

# 3. copy the env template
cp .env.example .env

# 4. run the three processes (separate terminals)
cd apps/api    && uv run uvicorn app.main:app --host 127.0.0.1 --port 8080
cd apps/worker && uv run arq worker.settings.WorkerSettings
cd apps/web    && bun install && bun run dev

Oppure avvia tutti e tre insieme con un process manager (sono dichiarati nel Procfile): pipx install honcho poi honcho start.

Apri http://localhost:5183 e accedi con admin / admin.

Le esecuzioni usano strumenti reali per impostazione predefinita. Aggiungi una API key di un provider in Settings e assicurati che Docker possa scaricare l'immagine Kali (martian56/kali:latest). Per fare un dry-run su output predefiniti, imposta REDCELL_RUN_MODE=sim in .env.

Target di pratica

Applicazioni intenzionalmente vulnerabili su cui puntare REDCELL, tutte locali:

root@kitploit:~
docker compose -f docker-compose.targets.yml up -d
# DVWA http://localhost:8081 · Juice Shop http://localhost:3000 · WebGoat http://localhost:8082

Deploy (self-host)

Esegui REDCELL su un server con le immagini pubblicate dietro un reverse proxy Caddy, così l'app web e l'API condividono una sola origine (niente CORS) e HTTPS è gestito per te. Su un server nuovo:

root@kitploit:~
git clone https://github.com/martian56/redcell.git
cd redcell
./deploy.sh

Lo script installa Docker se manca, poi chiede come REDCELL sarà raggiunto:

  1. Questo server direttamente, senza dominio — HTTP semplice sull'IP del server. Buono per una prova rapida o una rete privata.
  2. Un dominio puntato direttamente a questo server — Caddy ottiene automaticamente un certificato Let's Encrypt (punta prima un record A o AAAA al server) e serve https://tuo-dominio.
  3. Un dominio dietro Cloudflare, Coolify o un altro proxy o CDN — il proxy fornisce il certificato HTTPS pubblico e inoltra a questo server. L'origine serve sia HTTP semplice (:80) sia HTTPS con certificato self-signed (:443), quindi funziona con un proxy che si connette via HTTP o con uno che accetta il certificato dell'origine (per Cloudflare, modalità SSL Full; Full (strict) richiede un Cloudflare Origin Certificate).

Scrive le tue risposte in .env, scarica le immagini e avvia lo stack. Leggi la password admin generata con docker compose logs init-secrets, poi accedi come admin e cambiala. Per cambiare in seguito come viene raggiunto, riesegui semplicemente ./deploy.sh e scegli un'opzione diversa.

Solo le porte 80 e 443 sono pubblicate; Postgres, Redis, MinIO, l'API e l'app web restano sulla rete interna. I file memorizzati vengono trasmessi attraverso l'API, quindi l'object storage non è mai esposto. Vedi docs/DEPLOY.md per i dettagli di ciascuna modalità.

Configurazione

La configurazione del backend è un unico .env alla radice (vedi .env.example), letto sia dall'API sia dal worker. Quelle che vale la pena conoscere:

  • REDCELL_RUN_MODE: live (predefinito) o sim.
  • REDCELL_DATABASE_URL, REDCELL_REDIS_URL, REDCELL_S3_*: infrastruttura.
  • REDCELL_SECRET_KEY: chiave Fernet per cifrare le credenziali memorizzate. Impostane una reale prima di andare in produzione.

Le API key dei provider, l'immagine di esecuzione, i guardrail di scope e il branding del report si trovano nella pagina Settings e sono memorizzati nel database, cifrati dove necessario.

Struttura del progetto

root@kitploit:~
apps/
  api/                 FastAPI: routers, WebSocket streams, auth
  worker/              arq worker: runs engagements and report generation
  web/                 React operator console
packages/
  core/redcell_core/   engine, models, repositories, storage, bus, reporting
  api-client/          the single typed client the UI talks to (mock + HTTP)
docker/                Kali execution image, web/api images, Caddy config
docker-compose.yml           full stack behind a Caddy reverse proxy (self-host)
docker-compose.dev.yml       Postgres + Redis + MinIO
docker-compose.targets.yml   local vulnerable targets
deploy.sh                    interactive self-host deploy

Documentazione

  • Architecture — i componenti, come fluisce un'esecuzione, la coordinazione tra processi.
  • Hardening & threat model — fai il deploy in sicurezza, segreti, scope e conservazione dei dati. Leggilo prima di eseguire REDCELL ovunque al di fuori della tua macchina.
  • Pre-authentication surface — cosa può osservare un client non autenticato e come mantenerlo minimo.
  • Cost & token accounting — come viene misurata la spesa di un'esecuzione, la tabella dei prezzi e il costo reale di OpenRouter.
  • Command palette & shortcuts — Cmd/Ctrl+K per cercare sessioni, server e proxy, e la navigazione da tastiera.
  • Updating — il pulsante Update in-app e l'aggiornamento da shell.
  • Console shell — la sidebar, i menu e le regole di posizionamento dei dropdown.
  • Form controls — la combobox ricercabile e quando usarla al posto di un select nativo.

Contribuire

I contributi sono benvenuti. Vedi CONTRIBUTING.md per setup, test e convenzioni, e il Code of Conduct. Segnala i problemi di sicurezza in privato tramite SECURITY.md, non con issue pubbliche.

Uso responsabile

Questo è tooling difensivo e offensivo autorizzato per professionisti della sicurezza, CTF e i tuoi laboratori. Non usarlo contro sistemi per cui non hai il permesso scritto di testare. I maintainer non sono responsabili per usi impropri.

Scarica lo strumento