
Open-Source-Pentest-Management, das für den Betrieb durch einen KI-Agenten entwickelt wurde.
Open-Source-Pentest-Management, das dafür gebaut wurde, von einem KI-Agenten betrieben zu werden. Verbinde es über MCP mit Claude Code und es führt das Engagement neben dir aus: Scope und Assets, Recon-Beobachtungen, Methodik-Abdeckung und Findings mit CVSS und Beweisen.
Gebaut für Tester, die die Geschwindigkeit eines Agenten wollen, ohne die Disziplin eines echten Engagements aufzugeben. Arbeit wird nicht wiederholt, Findings verdunsten nicht zwischen Sitzungen, und nichts erreicht den Bericht, das nie bewiesen wurde.

Vollständige Dokumentation: https://cspf-founder.github.io/red-clippy/
Coding-Agenten sind zu wirklich nützlichen Testern geworden. Sie haben eine Shell, sie führen dieselben Tools aus wie du, und sie decken viel Boden schnell ab. Richte einen auf ein Ziel aus und er wird Dinge finden.
Dann füllt sich der Kontextfenster, und das Engagement ist weg. Die nächste Sitzung scannt Hosts erneut, die es bereits abgearbeitet hat, testet erneut, was es bereits ausgeschlossen hat, und kann dir nicht sagen, welche Teile des Scopes jemals berührt wurden. Irgendwo im Transkript befindet sich eine bestätigte SQL-Injection, die niemand aufgeschrieben hat.
Red Clippy behebt das, indem es dem Agenten zwei Dinge gibt, die er von sich aus nicht hat.
Einen Ort, um die Arbeit abzulegen. Jedes Asset, jede Beobachtung, jeder Check und jedes Finding landet während des Testens in einer Datenbank, nicht in einem Scrollback-Puffer. Abdeckung wird zu einer Abfrage statt zu einer Erinnerung: welche Assets existieren, welche Checks auf jedem abgearbeitet sind, was bereits gemeldet wurde. Die Sitzung von morgen nimmt genau dort auf, wo die letzte aufgehört hat.
Regeln, nach denen gearbeitet wird. Ein Red-Team-Instructions-Dokument erreicht den Agenten im MCP-Handshake, bevor es irgendetwas tut: verifizieren vor dem Melden, beweisen jede Behauptung, nur den minimalen Zugriff nehmen, der nötig ist, um Auswirkungen zu demonstrieren, Systeme Dritter in Ruhe lassen. Überschreibe es pro Organisation und pro Engagement, weil Hausregeln zwischen Teams und Kunden unterschiedlich sind.
Du bleibst die ganze Zeit im Loop. Alles, was der Agent schreibt, ist eine gewöhnliche Zeile in der Web-UI, die du überprüfen, korrigieren, neu klassifizieren oder verwerfen kannst.
[!CAUTION] Nur autorisierte Tests. Red Clippy ist für Penetrationstester gedacht, die unter einem Engagement arbeiten. Teste nur Systeme, die du besitzt oder für die du eine ausdrückliche schriftliche Genehmigung zur Bewertung hast. Scope-Markierung und die Red Team Instructions existieren, um einen Agenten innerhalb der Regeln des Engagements zu halten, aber sie sind Leitplanken, keine Autorisierung. Ein Agent handelt in deinem Auftrag, und du bleibst verantwortlich für alles, was er tut.
Lade eine Binärdatei vom
neuesten Release herunter und führe
sie aus. Sie richtet die Datenbank ein und bedient das Panel auf 127.0.0.1:7337.
Linux
tar xzf red-clippy-*-x86_64-unknown-linux-musl.tar.gz
cd red-clippy-*-x86_64-unknown-linux-musl
./red-clippy serve
Windows
Entpacke das Archiv, dann aus diesem Ordner:
.\red-clippy.exe serve
Öffne http://127.0.0.1:7337 und der Setup-Assistent übernimmt von dort.
Die Datenbank wird in dem Verzeichnis erstellt, in dem du die Binärdatei ausführst. Hochgeladene
Beweise werden dort ebenfalls gespeichert, in red-clippy-storage. Beide Pfade können
in der Konfigurationsdatei geändert werden, siehe Konfiguration.
Ziehst du es vor, es selbst zu kompilieren? Siehe Aus dem Quellcode bauen.
Red Clippy gruppiert Arbeit in Organisationen. Eine Organisation enthält deine Pentests, und jeder Pentest enthält die Assets, Findings und Beweise für dieses Engagement. Wenn du für ein Unternehmen testest, ist eine einzelne Organisation alles, was du brauchst. Wenn du für mehrere Kunden berätst, gib jedem Kunden seine eigene: Eine Organisation sieht nichts, was einer anderen gehört, sodass sich ihre Engagements nie vermischen.
Eine Organisation hat zwei Namen. Der Anzeigename („Acme Corp") ist das, was du
im Panel siehst und später ändern kannst. Der Slug (acme) ist eine kurze
Kleinbuchstaben-Kennung, die im Beweisordner auf der Festplatte verwendet wird
(red-clippy-storage/org_acme/pentest_PT-2026-08-27/), sodass er nach der Festlegung fixiert ist.
Du kannst zu mehreren Organisationen gehören und über das Avatar-Menü zwischen ihnen wechseln. In jeder bist du entweder ein Owner, der Personen hinzufügen und entfernen und die Organisation umbenennen oder löschen kann, oder ein Member, der die Engagements bearbeitet.
Beim ersten Start ist die Datenbank leer, sodass der Browser einen Setup-Assistenten statt eines Anmeldeformulars zeigt. Er fragt nach:
Das Konto, das er erstellt, ist der Owner dieser Organisation. Der Assistent erscheint nur, solange die Datenbank keine Benutzer hat; sobald das erste Konto existiert, ist er dauerhaft deaktiviert, sodass er nicht verwendet werden kann, um später zusätzliche Konten zu erstellen.
Nach dem Setup verwalte Organisationen und Teammitglieder in der App unter Avatar-Menü > Organisationen.
Wenn sich niemand anmelden kann, ist die CLI der Weg zurück:
red-clippy reset-password --username alice --password 'new-one'
Der vorgesehene Ablauf ist agentengesteuert. Du richtest das Engagement ein und arbeitest dann mit Claude Code durch das Ziel, während es die Aufzeichnung führt.
Du richtest ein:
Der Agent arbeitet dann und zeichnet auf, während er vorgeht:
ingest_tool_output oder schreibt Assets
und Beobachtungen direkt.Du beaufsichtigst:
Der Agent ist optional. Er arbeitet über dieselbe API wie das Panel, sodass alles, was er aufzeichnet, du auch selbst im Browser eingeben, korrigieren oder löschen kannst. Führe ein Engagement vollständig von Hand, vollständig über den Agenten aus oder wechsle zwischen beiden, während du vorgehst.
Dies ist die Hauptart, wie Red Clippy verwendet werden soll.
red-clippy mcp deckt die gesamte Anwendung ab: Scope und Assets,
Beobachtungen, Methodik-Abdeckung, Findings, Beweise, den Angriffsgraphen und
Tool-Ausgabe-Erfassung. Ein verbundener Agent arbeitet das Engagement ab, statt nur Fragen
darüber zu beantworten.
Beim Verbinden übergibt der Server dem Client das Red-Team-Instructions-Dokument,
die Betriebsdoktrin für das Verhalten während des Testens, im MCP-Handshake,
sodass es im Kontext des Agenten ist, bevor der erste Tool-Aufruf erfolgt. Es wird
am spezifischsten zuerst aufgelöst, von einer pro-Engagement-Überschreibung über einen Organisationsstandard
bis zum eingebauten Dokument. Bearbeite den Organisationsstandard unter
Einstellungen > Red Team Instructions oder lege eine pro-Engagement-Überschreibung von der
Einstellungsseite des Pentests fest. get_instructions liest es bei Bedarf erneut.
Stelle einen unter Einstellungen > API-Schlüssel aus. Der Abschnitt MCP verbinden darunter gibt dir dann bereit-zum-Einfügen-Konfigurationen für jeden Client, mit diesem Schlüssel, der URL dieses Servers und dem Pfad der Binärdatei selbst bereits ausgefüllt. Es gibt nichts, was von Hand ersetzt werden muss.
Um den Schlüssel stattdessen über die CLI zu erstellen und ihn selbst in die Snippets einzufügen:
red-clippy create-api-key --username alice --org acme --name laptop
# -> rcl_<prefix>_<secret> (nur einmal angezeigt, speichere ihn jetzt)
claude mcp add red-clippy \
--env RED_CLIPPY_URL=http://127.0.0.1:7337 \
--env RED_CLIPPY_API_KEY=rcl_xxxx_yyyy \
-- /path/to/red-clippy mcp
Der Name nach add ist nur ein Label, das Claude Code anzeigt. Der Befehl nach --
ist das, was tatsächlich gestartet wird, verwende also den vollständigen Pfad der Binärdatei: Claude Code wird
red-clippy nicht unbedingt in seinem PATH finden. Wenn du den Befehl aus
MCP verbinden im Panel kopierst, ist der richtige Pfad bereits ausgefüllt.
z.ai bietet einen Anthropic-kompatiblen Endpunkt, sodass Claude Code Red Clippy mit GLM statt mit einem Anthropic-Modell steuern kann.
Füge dies zu den Einstellungen von Claude Code hinzu: .claude/settings.local.json in deinem
Arbeitsordner, um es auf ein Engagement zu beschränken, oder ~/.claude/settings.json, um es
überall anzuwenden.
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
"ANTHROPIC_AUTH_TOKEN": "your-z-ai-api-key",
"ANTHROPIC_API_KEY": "",
"API_TIMEOUT_MS": "3000000",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5.3",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-5.3",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-5.3",
"ANTHROPIC_SMALL_FAST_MODEL": "glm-5.3",
"CLAUDE_CODE_SUBAGENT_MODEL": "glm-5.3"
}
}
Zwei Dinge zu ersetzen:
your-z-ai-api-key mit deinem eigenen Schlüssel. Bevorzuge die projektlokale
.claude/settings.local.json, die Claude Code aus git heraushält, sodass der
Schlüssel nicht committet wird.glm-5.3 mit dem Modell, das z.ai derzeit anbietet. Modellnamen ändern sich,
überprüfe also
z.ais Claude-Code-Anleitung
für das aktuelle und setze jeden Eintrag darauf.Füge dann den MCP-Server genau wie oben hinzu. Red Clippy ist von der Wahl des Modells unbeeinflusst: MCP läuft clientseitig, sodass sich die Tools identisch verhalten, welches Modell auch immer hinter dem Agenten steht.
Gemäß der Codex-CLI-Konfiguration in ~/.codex/config.toml:
[mcp_servers.red-clippy]
command = "/path/to/red-clippy"
args = ["mcp"]
env = { RED_CLIPPY_URL = "http://127.0.0.1:7337", RED_CLIPPY_API_KEY = "rcl_xxxx_yyyy" }
red-clippy mcp ist ein einfacher JSON-RPC-2.0-Studio-Server. Er benötigt zwei Dinge in
seiner Umgebung und akzeptiert eine optionale Engagement-Bindung:
RED_CLIPPY_URL=http://127.0.0.1:7337 \
RED_CLIPPY_API_KEY=rcl_xxxx_yyyy \
/path/to/red-clippy mcp --pentest PT-2026-Q2-ACME
--pentest bindet die Sitzung an ein Engagement, sodass der Agent es nicht bei
jedem Aufruf benennen muss. Führe einen MCP-Eintrag pro aktivem Engagement aus und wechsle
Engagements, indem du Server wechselst.
Sobald verbunden, kannst du einfach fragen: „Füge ein Finding zu PT-2026-Q2-ACME hinzu: reflektiertes XSS in /search, hoher Schweregrad, hier ist der PoC".
[!NOTE] Dein Agent und
red-clippy servelaufen auf derselben Maschine, weshalbRED_CLIPPY_URLauf127.0.0.1zeigt.
Eine vollständige MCP-Tool-Oberfläche. Nahezu vollständige Parität mit der Web-UI, nicht eine Token-Teilmenge. Ein Agent kann Assets erstellen und scopen, Beobachtungen anhängen, Methodik-Checks markieren, Findings anlegen und aktualisieren, Beweise hochladen, Graph-Kanten bauen und organisationsweit suchen.
Scope, der sauber bleibt. Assets sind die Einheiten, die du tatsächlich testest: Domains, Hosts, URLs, APIs, mobile Pakete, IP-Bereiche. Jedes trägt seine eigene Checkliste, Erreichbarkeitsmarkierung und In/Out-of-Scope-Flag. Recon-Rauschen (entdeckte Pfade, Tech-Fingerabdrücke, Zertifikate, Wayback-URLs) wird an ein Asset als Beobachtung angehängt, statt in die Scope-Liste zu gelangen, und wird nur dann zu einem Asset befördert, wenn es eines rechtfertigt. Ohne diese Trennung würde ein einziger Content-Discovery-Lauf die Asset-Liste unbrauchbar machen.
Findings bis zur Berichterstattung. Schweregrad, CVSS 3.1 mit einem in das Formular eingebauten Rechner, CWE/CVE, PoC, Behebung und Dateibeweise. Ein engagementsübergreifendes Dashboard listet jedes Finding in der Organisation gegen seinen Quell-Pentest auf, was die Ansicht ist, die ein Retest benötigt.
Abdeckung, die du abfragen kannst. 135 eingebaute Checks, die auf OWASP WSTG abgebildet sind, plus Recon-, Netzwerk-, Cloud- und OSINT-Checks. Zusammenfassungen berichten, was pro Asset und pro Engagement getestet wurde, sodass abgearbeitetes Terrain nicht erneut getestet wird.

Betriebsdoktrin. Das Red-Team-Instructions-Dokument, über MCP bereitgestellt und pro-Engagement aufgelöst, dann pro-Organisation, dann eingebauter Standard.
Tool-Ausgabe-Erfassung. Rohe Scanner-Ausgaben werden in einem einzigen Aufruf übermittelt,
was die Art ist, wie ein Agent Ergebnisse aus seiner eigenen Shell in die Aufzeichnung bewegt.
Parser für nmap, burp, nessus, openvas, masscan, naabu und
subfinder, mit automatischer Formaterkennung. Findings, Recon und rohe Ausgaben landen
zusammen in einer Transaktion.
Ein Angriffsgraph. Verbinde zwei beliebige Knoten mit einer freiformigen Beziehung und durchquere dann Nachbarn oder berechne kürzeste Angriffspfade zwischen ihnen.
Multi-Tenant. Jeder Datensatz gehört zu einer Organisation. Ein Benutzer kann zu vielen gehören und wechseln, ohne sich abzumelden, sodass Kundendaten getrennt bleiben.
REST-API. Organisationsbezogene Bearer-Schlüssel, dieselbe Oberfläche wie alles oben.
Optional: ein eingebauter Scan-Runner. Eine Annehmlichkeit zum Steuern von subfinder,
nmap, masscan und naabu von der Scan-Seite, mit fortsetzbarer
pro-Ziel-Abdeckung. Er existiert für die manuelle Bedienung und ist nicht Teil des
normalen agentengesteuerten Workflows, bei dem der Agent seine eigene Tooling ausführt und die
Ausgabe erfasst.
Die Dokumentation deckt all dies Bildschirm für Bildschirm ab, mit der MCP-Tool-Referenz, der REST-API und dem Datenmodell. Dieses README deckt das Einrichten und Ausführen ab.
Einstellungen stammen aus einer TOML-Datei. red-clippy serve liest standardmäßig ./red-clippy.toml.
Kopiere das Beispiel und bearbeite es:
cp red-clippy.toml.example red-clippy.toml
bind = "127.0.0.1:7337"
database_url = "sqlite://red-clippy.db?mode=rwc"
storage_root = "./red-clippy-storage" # hochgeladene Beweise leben hier
max_upload_bytes = 26_214_400 # 25 MiB
Jedes Feld kann auch per CLI-Flag oder Umgebungsvariable gesetzt werden. Die Rangfolge ist CLI-Flag > Umgebungsvariable > TOML > eingebauter Standard, pro Feld.
| Einstellung | CLI-Flag | Umgebungsvariable |
|---|---|---|
bind | --bind | RED_CLIPPY_BIND |
database_url | --database-url | RED_CLIPPY_DATABASE_URL |
storage_root | --storage-root | RED_CLIPPY_STORAGE_ROOT |
max_upload_bytes | --max-upload-bytes | RED_CLIPPY_MAX_UPLOAD_BYTES |
frontend_dist | - | - |
local_open | - | - |
| Konfigurationsdateipfad | -c, --config | RED_CLIPPY_CONFIG |
Zwei Einstellungen sind nur dateibasiert:
frontend_dist überschreibt die gebaute SPA. Release-Binärdateien betten sie ein, sodass dies
normalerweise nicht gesetzt ist; zeige auf ein Verzeichnis, um ein gepatchtes Bundle zu bedienen, ohne
neu zu kompilieren.local_open lässt die Schaltfläche „Im Dateimanager anzeigen" der Dateien-Seite zu xdg-open / open / explorer.exe auf der Maschine, die den Server ausführt, auslagern.
Es ist standardmäßig ausgeschaltet. Aktiviere es nur, wenn der Server dein eigener Desktop in einer
angemeldeten grafischen Sitzung ist, niemals unter systemd oder beim Fernbedienen.Ein Schlüssel, den es nicht erkennt, stoppt den Start mit einem Fehler, statt ignoriert zu werden, sodass ein Tippfehler dich nicht stillschweigend auf einem Standard zurücklassen kann.
Die Protokollfilterung verwendet RUST_LOG (Standard info,sqlx=warn).
Führe red-clippy serve --help für die vollständige Liste aus.
[!WARNING] Führe es lokal aus. Red Clippy bindet an
127.0.0.1und ist dafür gedacht, auf deiner eigenen Maschine zu laufen, neben dem Agenten, der es steuert. Es ist nicht dafür gebaut, einem Netzwerk oder dem Internet ausgesetzt zu werden.
red-clippy serve Web-UI und REST-API ausführen
red-clippy mcp MCP-Studio-Server ausführen
red-clippy init-db Migrationen anwenden
red-clippy create-org Eine Organisation erstellen
red-clippy create-user Einen Benutzer erstellen
red-clippy add-member Einen Benutzer zu einer Organisation hinzufügen
red-clippy reset-password Break-Glass-Passwort-Reset
red-clippy create-api-key Einen API-Schlüssel ausstellen
Füge --help zu jedem Unterbefehl hinzu, um seine Flags zu sehen.
Die REST-API lebt unter /api/v1 und authentifiziert mit
Authorization: Bearer rcl_<prefix>_<secret>. Schlüssel sind organisationsbezogen, sodass kein
Endpunkt eine Organisation in seiner URL benötigt. Die In-App-Hilfe-Seite dokumentiert
die Endpunkte.
git clone https://github.com/CSPF-Founder/red-clippy.git
cd red-clippy
make all
./target/release/red-clippy serve
make all baut zuerst die Web-UI und kompiliert dann die Binärdatei mit diesem Bundle
eingebettet.
[!NOTE] Build-Reihenfolge. Das React-Bundle wird zur Kompilierzeit eingebettet.
cargo build --releaseallein funktioniert, aber wenn die UI nie gebaut wurde, liefert die Binärdatei eine Platzhalterseite (cargo gibt eine Warnung aus). Führe zuerstmake frontendaus oder verwende einfachmake all.
Nativ bauen mit rustup, den MSVC-Build-Tools und installiertem Node:
npm --prefix frontend ci
npm --prefix frontend run build
cargo build --release
.\target\release\red-clippy.exe serve
Oder von Linux aus kreuzkompilieren mit der mingw-w64-Toolchain
(apt install gcc-mingw-w64-x86-64):
rustup target add x86_64-pc-windows-gnu
make frontend
cargo build --release --target x86_64-pc-windows-gnu
# -> target/x86_64-pc-windows-gnu/release/red-clippy.exe
Kopiere diese einzelne .exe auf den Windows-Host und führe sie aus. Nichts anderes zu
installieren.
make help # jedes Ziel auflisten
make dev # Vite-Dev-Server, proxied /api zu einem laufenden Backend
make backend-dev # cargo build (debug)
make test # Rust-Testsuite
make clippy # Lint mit Warnungen als Fehler
make install-hooks # den Pre-Commit-Clippy-Gate aktivieren (einmal pro Klon)
Debug-Builds lesen frontend/dist zur Laufzeit von der Festplatte, statt es einzubetten,
sodass du die UI neu bauen kannst, ohne Rust neu zu kompilieren.
Bevor du einen Pull-Request öffnest, führe aus, was CI ausführt: cargo fmt --all --check,
make clippy, make test, make lint und make frontend.
make install-hooks verdrahtet die Formatierungs- und Lint-Gates in einen Pre-Commit-
Hook. Siehe CONTRIBUTING.md für die ausführlichere Version, einschließlich
wie man einen Parser hinzufügt.
Erhöhe version in Cargo.toml und pushe dann ein passendes Tag:
git tag -a v0.2.0 -m "v0.2.0"
git push origin v0.2.0
CI baut eine statische Linux-Binärdatei und eine Windows-Ausführbare und veröffentlicht dann beide als GitHub-Release mit Prüfsummen. Das Tag muss mit der Crate-Version übereinstimmen, sonst schlägt der Build fehl. Zum Proben ohne Veröffentlichung führe den Release-Workflow manuell über den Actions-Tab aus: Er baut und lädt die Archive als Workflow-Artefakte hoch und überspringt den Release-Schritt.
Fehlerberichte, Parser für neue Tools und MCP-Abdeckung sind willkommen – siehe CONTRIBUTING.md.
Ein Sicherheitsproblem gefunden? Bitte melde es privat über SECURITY.md, statt ein Issue zu eröffnen.
Copyright (C) 2026 Cyber Security & Privacy Foundation
Veröffentlicht unter der GNU General Public License v3.0. Dieses Programm wird mit ABSOLUT OHNE GEWÄHRLEISTUNG geliefert; siehe die Lizenz für Details.