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
Tools/GitHubGitHub/cspf-founder/red-clippy
Penetrationstest-FrameworksAufklärungSchwachstellenscannerSchwachstellenanalyseExploitationInformationsbeschaffungPenetrationstestsRed TeamingKI-Sicherheit
GitHubcspf-founder/red-clippy

red-clippy

Open-Source-Pentest-Management, das für den Betrieb durch einen KI-Agenten entwickelt wurde.

178vor 2 TagenNoch nicht geprüft
Repository anzeigenWebseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

Red Clippy

Deine Agent-Tests. Red Clippy führt die Aufzeichnung.

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.

Ein Engagement in Red Clippy: Abdeckungsfortschritt, Findings nach Schweregrad, ausstehende Phasen, aktuelle Findings und der Scope aus dem Engagement-Schreiben

Vollständige Dokumentation: https://cspf-founder.github.io/red-clippy/


Inhalt

  • Warum
  • Schnellstart
  • Wie die Daten organisiert sind
  • Erster Start
  • Verwendung
  • Verbinden eines KI-Agenten (MCP)
  • Funktionen
  • Konfiguration
  • CLI-Referenz
  • Aus dem Quellcode bauen
  • Entwicklung
  • Mitwirken
  • Lizenz

  • Warum

    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.


    Schnellstart

    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

    root@kitploit:~
    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:

    root@kitploit:~
    .\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.


    Wie die Daten organisiert sind

    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.


    Erster Start

    Beim ersten Start ist die Datenbank leer, sodass der Browser einen Setup-Assistenten statt eines Anmeldeformulars zeigt. Er fragt nach:

    • einem Slug und Anzeigenamen für deine erste Organisation
    • einem Benutzernamen und optional einer E-Mail
    • einem Passwort (mindestens 8 Zeichen)

    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:

    root@kitploit:~
    red-clippy reset-password --username alice --password 'new-one'
    

    Verwendung

    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:

    1. Erstelle einen Pentest. Code, Scope, Daten. Die Methodik-Checkliste wird automatisch befüllt.
    2. Definiere den Scope. Füge die Domains, Hosts und IP-Bereiche hinzu, die du autorisiert bist zu testen, und markiere alles, was ausdrücklich außerhalb des Scopes liegt. Du kannst diese selbst eingeben oder die Scope-Liste des Kunden an den Agenten weitergeben und ihn sie für dich eingeben lassen.
    3. Verbinde den Agenten über MCP, an dieses Engagement gebunden (siehe unten).

    Der Agent arbeitet dann und zeichnet auf, während er vorgeht:

    • Führt Recon- und Testtools aus seiner eigenen Shell aus, so wie er es normalerweise tun würde.
    • Übergibt rohe Scanner-Ausgaben mit ingest_tool_output oder schreibt Assets und Beobachtungen direkt.
    • Befördert echte Scope-Einheiten zu Assets, lässt den Rest als Beobachtungen.
    • Markiert Methodik-Checks, während er sie abarbeitet.
    • Legt Findings mit CVSS, PoC und angehängten Beweisen ab.

    Du beaufsichtigst:

    • Beobachte, wie es in Echtzeit im Browser landet.
    • Korrigiere alles: Jede Zeile, die der Agent geschrieben hat, ist ein gewöhnlicher Datensatz, den du bearbeiten, neu klassifizieren oder löschen kannst.
    • Prüfe die Abdeckungsansicht auf das, was noch unberührt ist.
    • Überprüfe auf dem engagementsübergreifenden Dashboard, das jedes Finding in der Organisation zusammen mit dem Pentest zeigt, aus dem es stammt.

    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.


    Verbinden eines KI-Agenten (MCP)

    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.

    Einen API-Schlüssel erstellen

    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:

    root@kitploit:~
    red-clippy create-api-key --username alice --org acme --name laptop
    # -> rcl_<prefix>_<secret>   (nur einmal angezeigt, speichere ihn jetzt)
    

    Claude Code

    root@kitploit:~
    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 GLM

    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.

    root@kitploit:~
    {
      "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.

    OpenAI Codex CLI

    Gemäß der Codex-CLI-Konfiguration in ~/.codex/config.toml:

    root@kitploit:~
    [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" }
    

    Jeder andere MCP-Client

    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:

    root@kitploit:~
    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 serve laufen auf derselben Maschine, weshalb RED_CLIPPY_URL auf 127.0.0.1 zeigt.


    Funktionen

    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.

    Der Methodik-Arbeitsbereich für ein Asset: Checks nach Kategorie gruppiert auf der linken Seite, der ausgewählte Check mit seinen Referenzen, Status und Beweisbox auf der rechten Seite

    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.


    Konfiguration

    Einstellungen stammen aus einer TOML-Datei. red-clippy serve liest standardmäßig ./red-clippy.toml. Kopiere das Beispiel und bearbeite es:

    root@kitploit:~
    cp red-clippy.toml.example red-clippy.toml
    
    root@kitploit:~
    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.

    EinstellungCLI-FlagUmgebungsvariable
    bind--bindRED_CLIPPY_BIND
    database_url--database-urlRED_CLIPPY_DATABASE_URL
    storage_root--storage-rootRED_CLIPPY_STORAGE_ROOT
    max_upload_bytes--max-upload-bytesRED_CLIPPY_MAX_UPLOAD_BYTES
    frontend_dist--
    local_open--
    Konfigurationsdateipfad-c, --configRED_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.1 und 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.


    CLI-Referenz

    root@kitploit:~
    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.


    Aus dem Quellcode bauen

    Version
    Ruststable (1.85+), 2024-Edition
    Node.js20.19+ oder 22.13+ (zum Bauen der Web-UI)

    Linux und macOS

    root@kitploit:~
    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 --release allein funktioniert, aber wenn die UI nie gebaut wurde, liefert die Binärdatei eine Platzhalterseite (cargo gibt eine Warnung aus). Führe zuerst make frontend aus oder verwende einfach make all.

    Windows

    Nativ bauen mit rustup, den MSVC-Build-Tools und installiertem Node:

    root@kitploit:~
    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):

    root@kitploit:~
    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.


    Entwicklung

    root@kitploit:~
    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.

    Ein Release schneiden

    Erhöhe version in Cargo.toml und pushe dann ein passendes Tag:

    root@kitploit:~
    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.


    Mitwirken

    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.


    Lizenz

    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.

    Tool herunterladen