Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
redcell — KI-Red-Team-Plattform. Autonome LLM-Agenten führen einen Penetrationstest Ende-zu-Ende in einem Kali-Container durch und verfassen den Bericht. LangGraph-Plan/Act-Engine, anbieterunabhängige Modelle über LiteLLM, PDF/JSON/SARIF-Ausgabe. FastAPI + React. | Kitploit
Tools/GitHubGitHub/martian56/redcell
SchwachstellenscannerCode-AnalyseExploitationWebsicherheitNetzwerksicherheitPenetrationstestsRed TeamingKI-Sicherheit
GitHubmartian56/redcell

redcell

KI-Red-Team-Plattform. Autonome LLM-Agenten führen einen Penetrationstest Ende-zu-Ende in einem Kali-Container durch und verfassen den Bericht. LangGraph-Plan/Act-Engine, anbieterunabhängige Modelle über LiteLLM, PDF/JSON/SARIF-Ausgabe. FastAPI + React.

Repository anzeigen
1573025vor 2 TagenVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

REDCELL

KI-Agenten, die einen Penetrationstest von Anfang bis Ende durchführen und den Bericht schreiben.

CI Python FastAPI React Postgres Redis LiteLLM

REDCELL-Betreiberkonsole mitten im Lauf gegen DVWA: Agentengraph, kritischer RCE-Fund, der agentengesteuerte Browser und eine abgefangene Reverse Shell

[!WARNING] REDCELL führt echte offensive Werkzeuge aus. Richte es nur auf Systeme, die dir gehören oder die du testen darfst. Im Scope und im Rahmen des Gesetzes zu bleiben, liegt bei dir.


Was es ist

REDCELL führt ein Team von LLM-Agenten durch einen Pentest. Ein Orchestrator plant den Auftrag und übergibt Ziele an Executor-Agenten, die echte Werkzeuge in einem Kali-Container ausführen und zurückmelden. Du beobachtest und steuerst den Lauf über eine Betreiberkonsole: ein Chat, der den Orchestrator steuert, ein Live-Agentengraph und Aktivitätsfeed, eine Live-Ansicht des Browsers, den der Agent steuert, ein Terminal auf jeder Reverse Shell, die der Agent abfängt, und ein Bericht zum Übergeben, wenn die Arbeit getan ist.

Modelle sind über LiteLLM austauschbar, sodass du es auf OpenAI, Anthropic, Google, GLM, DeepSeek, Kimi, ein lokales Ollama oder alles andere richten kannst, das es unterstützt. Jeder Lauf wird unterwegs gecheckpointet, sodass ein Absturz oder Neustart dort weitermacht, wo er aufgehört hat.

Funktionen

  • Multi-Agenten-Engine. Eine LangGraph-Plan/Act-Schleife. Der Orchestrator delegiert Ziele an Executor-Agenten, die Shell-Werkzeuge ausführen und Funde, Loot und Hosts während der Arbeit erfassen.
  • Strukturierte Werkzeuge. Dedizierte Werkzeuge für nmap, nuclei, Verzeichnis- und Vhost-Discovery sowie Metasploit-Suche und -Ausführung. Jedes parst seine eigene Ausgabe in die Angriffsfläche oder Funde, sodass ein Scan Hosts und Schwachstellen ohne Folgeschritt erfasst. run_command deckt alles ab, wofür es kein dediziertes Werkzeug gibt.
  • Echte Ausführung, lokal oder remote. Werkzeuge laufen in einem Kali-Container über docker exec. Wähle pro Sitzung localhost oder einen gespeicherten Server; ein Remote-Server führt denselben Container über SSH mit Host-Netzwerk aus.
  • Agenten-Browser. Für Login-Flows und JavaScript-lastige Apps, die Shell-Werkzeuge nicht erreichen, steuert ein Agent ein echtes Chromium im Kali-Container. Du siehst live zu und kannst die Kontrolle übernehmen, um selbst etwas durchzuklicken, und sie dann zurückgeben.
  • Reverse Shells. Ein Agent öffnet einen Listener, fängt die Shell ab und gibt dir ein interaktives Terminal darauf. Du kannst auch eigene Terminals öffnen und selbst Befehle ausführen.
  • Netzwerk-Pivoting. Leite Werkzeugverkehr durch eine abgefangene Reverse Shell, um Hosts zu erreichen, die nur von der kompromittierten Maschine aus sichtbar sind. Ein Chisel-Reverse-SOCKS-Tunnel trägt ihn, und nmap läuft automatisch durch den Tunnel.
  • Chat steuert den Lauf. Sag dem Chat, was du willst, und er steuert den laufenden Orchestrator, oder öffnet einen abgeschlossenen Lauf erneut, um neue Arbeit aufzunehmen. Er beantwortet auch Fragen zum Auftrag.
  • Code-Scan-Sitzungen. Richte eine Sitzung auf ein öffentliches Git-Repo oder einen lokalen Ordner für eine Quellcode-Sicherheitsüberprüfung, mit Funden, die auf Datei und Zeile zurückgeführt werden.
  • Konfiguration pro Sitzung. Lege den Ausführungsserver, das Modell und einen optionalen Egress-Proxy pro Sitzung fest. Server und Proxys kommen mit einem echten Verbindungstest, damit du weißt, dass sie funktionieren, bevor du dich auf sie verlässt.
  • Fund-Triage. Verifiziere oder verwerfe Funde und führe Duplikate zusammen, die der Agent zweimal erfasst hat. Der Bericht lässt die verworfenen weg und markiert die verifizierten.
  • Berichte. Exportiere ein PDF plus JSON und SARIF. Der Write-up wird vom Modell der Sitzung generiert und so aufbereitet, dass er sich liest, als hätte ihn ein Mensch geschrieben, mit Executive Summary, Methodik, Funden und Behebung in Prioritätsreihenfolge.
  • Live-Konsole. Der Aktivitätsfeed, Terminals und der Browser des Agenten streamen über WebSockets; Agentengraph, Funde, Loot, Angriffsfläche, Listener und Proxy-Verlauf aktualisieren sich über einen kurzen Poll. Alles aktualisiert sich live, während der Lauf arbeitet.
  • Benachrichtigungen. In-App-Toasts plus Browser-Benachrichtigungen, wenn der Tab im Hintergrund ist, damit eine Frage des Agenten oder eine abgefangene Shell nicht ungesehen bleibt.

Architektur

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

Die API führt keine Agenten aus. Sie reiht einen Lauf in die Warteschlange ein, der Worker führt ihn aus, und der Worker veröffentlicht Ausgaben auf Redis-Kanälen, die die API über WebSockets an den Browser weiterleitet.

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 für Python, bun für das Frontend.

Schnellstart

Du brauchst Docker, uv und 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

Oder starte alle drei auf einmal mit einem Prozessmanager (sie sind in der Procfile deklariert): pipx install honcho, dann honcho start.

Öffne http://localhost:5183 und melde dich mit admin / admin an.

Läufe führen standardmäßig echte Werkzeuge aus. Füge einen Provider-API-Schlüssel in den Einstellungen hinzu und stelle sicher, dass Docker das Kali-Image ziehen kann (martian56/kali:latest). Um stattdessen einen Trockenlauf gegen vorgefertigte Ausgabe zu machen, setze REDCELL_RUN_MODE=sim in .env.

Übungsziele

Absichtlich verwundbare Apps, auf die du REDCELL richten kannst, alle lokal:

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

Deployment (Self-Host)

Betreibe REDCELL auf einem Server mit den veröffentlichten Images hinter einem Caddy-Reverse-Proxy, sodass Web-App und API einen Origin teilen (kein CORS) und HTTPS für dich erledigt wird. Auf einem frischen Server:

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

Das Skript installiert Docker, falls es fehlt, und fragt dann, wie REDCELL erreicht wird:

  1. Dieser Server direkt, keine Domain — einfaches HTTP auf der Server-IP. Gut für einen schnellen Test oder ein privates Netzwerk.
  2. Eine Domain, die direkt auf diesen Server zeigt — Caddy stellt automatisch ein Let's-Encrypt-Zertifikat bereit (richte zuerst einen A- oder AAAA-Record auf den Server) und bedient https://your-domain.
  3. Eine Domain hinter Cloudflare, Coolify oder einem anderen Proxy oder CDN — der Proxy stellt das öffentliche HTTPS-Zertifikat bereit und leitet an diesen Server weiter. Der Origin bedient sowohl einfaches HTTP (:80) als auch ein selbstsigniertes HTTPS (:443), sodass es mit einem Proxy funktioniert, der über HTTP verbindet, oder einem, der das Zertifikat des Origins akzeptiert (für Cloudflare SSL-Modus Full; Full (strict) benötigt ein Cloudflare Origin Certificate).

Es schreibt deine Antworten in .env, zieht die Images und startet den Stack. Lies das generierte Admin-Passwort mit docker compose logs init-secrets und melde dich dann als admin an und ändere es. Um später zu ändern, wie es erreicht wird, führe einfach ./deploy.sh erneut aus und wähle eine andere Option.

Nur die Ports 80 und 443 werden veröffentlicht; Postgres, Redis, MinIO, die API und die Web-App bleiben im internen Netzwerk. Gespeicherte Dateien werden durch die API gestreamt, sodass Objektspeicher nie exponiert wird. Siehe docs/DEPLOY.md für die Details der einzelnen Modi.

Konfiguration

Die Backend-Konfiguration ist eine Root-.env (siehe .env.example), gelesen von sowohl der API als auch dem Worker. Die, die man kennen sollte:

  • REDCELL_RUN_MODE: live (Standard) oder sim.
  • REDCELL_DATABASE_URL, REDCELL_REDIS_URL, REDCELL_S3_*: Infrastruktur.
  • REDCELL_SECRET_KEY: Fernet-Schlüssel zum Verschlüsseln gespeicherter Anmeldedaten. Setze einen echten, bevor du in die Produktion gehst.

Provider-API-Schlüssel, das Ausführungs-Image, Scope-Guardrails und Report-Branding leben auf der Einstellungsseite und werden in der Datenbank gespeichert, verschlüsselt, wo es nötig ist.

Projektstruktur

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

Dokumentation

  • Architektur — die Komponenten, wie ein Lauf abläuft, prozessübergreifende Koordination.
  • Härtung & Bedrohungsmodell — sicher deployen, Secrets, Scope und Datenaufbewahrung. Lies dies, bevor du REDCELL irgendwo außer auf deiner eigenen Maschine ausführst.
  • Pre-Authentication-Oberfläche — was ein nicht authentifizierter Client beobachten kann und wie du das minimal hältst.
  • Kosten- & Token-Abrechnung — wie die Ausgaben eines Laufs gemessen werden, die Preistabelle und die echten Kosten von OpenRouter.
  • Befehlspalette & Tastenkürzel — Cmd/Ctrl+K zum Suchen von Sitzungen, Servern und Proxys sowie Tastaturnavigation.
  • Aktualisieren — der In-App-Update-Button und Aktualisieren aus der Shell.
  • Konsolen-Shell — die Seitenleiste, Menüs und Dropdown-Positionierungsregeln.
  • Formularsteuerelemente — die durchsuchbare Combobox und wann man sie statt eines nativen Selects verwendet.

Mitwirken

Beiträge sind willkommen. Siehe CONTRIBUTING.md für Setup, Tests und Konventionen sowie den Code of Conduct. Melde Sicherheitsprobleme privat über SECURITY.md, nicht über öffentliche Issues.

Verantwortungsvolle Nutzung

Dies ist defensives und autorisiert-offensives Tooling für Sicherheitsfachleute, CTFs und deine eigenen Labs. Verwende es nicht gegen Systeme, für deren Test du keine schriftliche Erlaubnis hast. Die Maintainer sind nicht für Missbrauch verantwortlich.

Tool herunterladen