Cycode

offiziell

Steigern Sie die Sicherheit in Ihrem Entwicklungslebenszyklus durch SAST-, SCA-, Secrets- und IaC-Scans mit Cycode.

Was kann man mit Cycode MCP machen?

Repository-Pfad auf hartcodierte Geheimnisse scannen — Bitten Sie den Assistenten, cycode_secret_scan in einem lokalen Verzeichnis auszuführen, um offengelegte Anmeldedaten zu erkennen.
Abhängigkeiten auf bekannte Schwachstellen prüfen — Lösen Sie cycode_sca_scan gegen einen Projektpfad aus, um verwundbare oder nicht konforme Open-Source-Pakete zu identifizieren.
Infrastructure-as-Code-Dateien auf Fehlkonfigurationen prüfen — Verwenden Sie cycode_iac_scan für Terraform- oder CloudFormation-Verzeichnisse, um riskante Einstellungen aufzudecken.
Quellcode auf Sicherheitslücken überprüfen — Führen Sie cycode_sast_scan auf einer Codebasis aus, um Schwachstellen und Qualitätsprobleme auf Codeebene zu finden.
CLI-Authentifizierung und Versionsstatus verifizieren — Rufen Sie cycode_status auf, um die Verbindung zu Cycode zu bestätigen und zu prüfen, welche Version aktiv ist.

Dokumentation

Cycode CLI Benutzerhandbuch

Die Cycode Command Line Interface (CLI) ist eine Anwendung, die Sie lokal installieren können, um Ihre Repositorys auf Secrets, Infrastructure-as-Code-Fehlkonfigurationen, Schwachstellen in der Software-Zusammensetzungsanalyse und Probleme bei statischen Anwendungssicherheitstests zu scannen.

Dieses Handbuch führt Sie durch Installation und Verwendung.

Inhaltsverzeichnis

Voraussetzungen
Installation
1. Cycode CLI installieren
2. Pre-Commit-Hook installieren
Cycode CLI-Befehle
MCP-Befehl
Plattform-Befehl
KI-Schutzmaßnahmen
1. Von KI-Schutzmaßnahmen erfasste Daten
Scan-Befehl
Berichtsbefehl
1. Erstellen eines SBOM-Berichts
Import-Befehl
Scan-Protokolle
Syntax-Hilfe

Voraussetzungen

Die Cycode CLI-Anwendung erfordert Python Version 3.9 oder höher. Der MCP-Befehl ist nur für Python 3.10 und höher verfügbar. Wenn Sie eine ältere Python-Version verwenden, ist dieser Befehl nicht verfügbar.
Verwenden Sie den cycode auth-Befehl, um sich mit der CLI bei Cycode zu authentifizieren.
- Alternativ können Sie eine Cycode-Client-ID und einen Client-Secret-Schlüssel erhalten, indem Sie die Schritte auf den Seiten Service Account Token und Personal Access Token befolgen, die Details zum Abrufen dieser Werte enthalten.

Installation

Die folgenden Installationsschritte gelten sowohl für Windows- als auch für UNIX-/Linux-Betriebssysteme.

[!HINWEIS] Die folgenden Schritte gehen von der Verwendung von python3 und pip3 für Python-bezogene Befehle aus; einige Systeme verwenden jedoch möglicherweise stattdessen die Befehle python und pip, abhängig von der Konfiguration Ihrer Python-Umgebung.

Cycode CLI installieren

Um die Cycode CLI-Anwendung auf Ihrem lokalen Rechner zu installieren, führen Sie die folgenden Schritte aus:

Öffnen Sie Ihre Befehlszeilen- oder Terminalanwendung.
Führen Sie einen der folgenden Befehle aus:
- Zur Installation von PyPI:
```
pip3 install cycode
```
- Zur Installation von Homebrew:
```
brew install cycode
```
- Zur Installation von GitHub Releases navigieren Sie und laden Sie die ausführbare Datei für Ihr Betriebssystem und Ihre Architektur herunter, und führen Sie dann den folgenden Befehl aus:
```
cd /path/to/downloaded/cycode-cli
chmod +x cycode
./cycode
```
Authentifizieren Sie abschließend die CLI. Es gibt drei Methoden, um die Cycode-Client-ID und Anmeldeinformationen (Client-Secret oder OIDC-ID-Token) festzulegen:
- cycode auth (Empfohlen)
- cycode configure
- Fügen Sie sie zu Ihren Umgebungsvariablen hinzu

Verwendung des Auth-Befehls

[!HINWEIS] Dies ist die empfohlene Methode zum Einrichten Ihres lokalen Rechners für die Authentifizierung mit der Cycode CLI.

Geben Sie den folgenden Befehl in Ihr Terminal-/Befehlszeilenfenster ein:

cycode auth
Ein Browserfenster wird angezeigt, in dem Sie aufgefordert werden, sich bei Cycode anzumelden (wie unten zu sehen):
Geben Sie Ihre Anmeldedaten auf dieser Seite ein und melden Sie sich an.
Sie werden schließlich zur folgenden Seite weitergeleitet, auf der Sie aufgefordert werden, die Geschäftsgruppe auszuwählen, die Sie mit Cycode autorisieren möchten (falls zutreffend):

[!HINWEIS] Dies ist die Standardmethode für die Authentifizierung mit der Cycode CLI.
Klicken Sie auf die Schaltfläche Zulassen, um die Cycode CLI für die ausgewählte Geschäftsgruppe zu autorisieren.
Nach Abschluss sehen Sie den folgenden Bildschirm, wenn die Auswahl erfolgreich war:
Im Terminal-/Befehlszeilenfenster sehen Sie beim Verlassen des Browserfensters Folgendes:

Successfully logged into cycode

Verwendung des Configure-Befehls

[!HINWEIS] Wenn Sie Ihre Cycode-Client-ID und Ihr Client-Secret bereits über die Linux- oder Windows-Umgebungsvariablen eingerichtet haben, haben diese Anmeldeinformationen Vorrang vor dieser Methode.

Geben Sie den folgenden Befehl in Ihr Terminal-/Befehlszeilenfenster ein:
```
cycode configure
```
Geben Sie Ihren Cycode-API-URL-Wert ein (Sie können ihn leer lassen, um den Standardwert zu verwenden).

Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
Geben Sie Ihren Cycode-APP-URL-Wert ein (Sie können ihn leer lassen, um den Standardwert zu verwenden).

Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
Geben Sie Ihren Cycode-Client-ID-Wert ein.

Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
Geben Sie Ihren Cycode-Client-Secret-Wert ein (überspringen Sie diesen, wenn Sie ein OIDC-ID-Token verwenden möchten).

Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
Geben Sie Ihren Cycode-OIDC-ID-Token-Wert ein (optional).

Cycode ID Token []: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
Wenn die Werte erfolgreich eingegeben wurden, sehen Sie die folgende Meldung:

Successfully configured CLI credentials!

und/oder

Successfully configured Cycode URLs!

Wenn Sie in den Ordner .cycode unter Ihrem Benutzerordner gehen, finden Sie diese Anmeldeinformationen, die erstellt und in der Datei credentials.yaml in diesem Ordner abgelegt wurden. Die URLs wurden in der Datei config.yaml in diesem Ordner abgelegt.

Zu Umgebungsvariablen hinzufügen

Auf Unix/Linux:

export CYCODE_CLIENT_ID={your Cycode ID}

und

export CYCODE_CLIENT_SECRET={your Cycode Secret Key}

Wenn Ihre Organisation OIDC-Authentifizierung verwendet, können Sie stattdessen (oder zusätzlich) das ID-Token angeben:

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

Auf Windows

Navigieren Sie über die Systemsteuerung zum Systemmenü:
Klicken Sie als Nächstes auf Erweiterte Systemeinstellungen:
Klicken Sie im sich öffnenden Fenster Systemeigenschaften auf die Schaltfläche Umgebungsvariablen:
Erstellen Sie die Variablen CYCODE_CLIENT_ID und CYCODE_CLIENT_SECRET mit Werten, die Ihrer ID bzw. Ihrem Secret-Schlüssel entsprechen. Wenn Sie sich über OIDC authentifizieren, fügen Sie außerdem CYCODE_ID_TOKEN mit Ihrem OIDC-ID-Token-Wert hinzu:
Fügen Sie cycode.exe in den Pfad ein, um die Installation abzuschließen.

Pre-Commit-Hook installieren

Die Pre-Commit- und Pre-Push-Hooks von Cycode können in Ihrem lokalen Repository eingerichtet werden, damit die Cycode CLI-Anwendung Probleme mit Ihrem Code automatisch erkennt, bevor Sie ihn in Ihre Codebasis committen oder pushen.

[!HINWEIS] Pre-Commit- und Pre-Push-Hooks sind für IaC-Scans nicht verfügbar.

Führen Sie die folgenden Schritte aus, um den Pre-Commit-Hook zu installieren:

Pre-Commit-Hook installieren

Installieren Sie das Pre-Commit-Framework (Python 3.9 oder höher muss installiert sein):
```
pip3 install pre-commit
```
Navigieren Sie zum obersten Verzeichnis des lokalen Git-Repositorys, das Sie konfigurieren möchten.
Erstellen Sie eine neue YAML-Datei mit dem Namen .pre-commit-config.yaml (einschließlich des Anfangs .) im obersten Verzeichnis des Repositorys, die Folgendes enthält:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode
        stages: [pre-commit]
```
Ändern Sie die erstellte Datei entsprechend Ihren spezifischen Anforderungen. Verwenden Sie die Hook-ID cycode, um den Scan für Secrets zu aktivieren. Verwenden Sie die Hook-ID cycode-sca, um den SCA-Scan zu aktivieren. Verwenden Sie die Hook-ID cycode-sast, um den SAST-Scan zu aktivieren. Wenn Sie alle Scan-Typen aktivieren möchten, verwenden Sie diese Konfiguration:
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode
        stages: [pre-commit]
      - id: cycode-sca
        stages: [pre-commit]
      - id: cycode-sast
        stages: [pre-commit]
```
Installieren Sie den Hook von Cycode:
```
pre-commit install
```
Eine erfolgreiche Hook-Installation führt zur Meldung: Pre-commit installed at .git/hooks/pre-commit.
Halten Sie den Pre-Commit-Hook auf dem neuesten Stand:
```
pre-commit autoupdate
```
Es wird automatisch rev in .pre-commit-config.yaml auf die neueste verfügbare Version der Cycode CLI aktualisiert.

[!HINWEIS] Der Auslöser erfolgt beim Befehl git commit. Der Hook wird nur für die Dateien ausgelöst, die für den Commit bereitgestellt (gestaged) sind.

Pre-Push-Hook installieren

Um den Pre-Push-Hook zusätzlich oder anstelle des Pre-Commit-Hooks zu installieren:

Fügen Sie die Pre-Push-Hooks zu Ihrer Datei .pre-commit-config.yaml hinzu:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

Installieren Sie den Pre-Push-Hook:

pre-commit install --hook-type pre-push

Verwenden Sie für sowohl Pre-Commit- als auch Pre-Push-Hooks:
```
pre-commit install
pre-commit install --hook-type pre-push
```

[!HINWEIS] Pre-Push-Hooks werden beim Befehl git push ausgelöst und scannen nur die Commits, die gepusht werden sollen.

Cycode CLI-Befehle

Die folgenden Optionen und Befehle sind mit der Cycode CLI-Anwendung verfügbar:

Option	Beschreibung
`-v`, `--verbose`	Detaillierte Protokolle anzeigen.
`--no-progress-meter`	Fortschrittsanzeige nicht anzeigen.
`--no-update-notifier`	CLI nicht auf Updates prüfen.
`-o`, `--output [rich\|text\|json\|table]`	Ausgabetyp angeben. Der Standardwert ist `rich`.
`--client-id TEXT`	Eine Cycode-Client-ID für diese spezifische Scan-Ausführung angeben.
`--client-secret TEXT`	Ein Cycode-Client-Secret für diese spezifische Scan-Ausführung angeben.
`--id-token TEXT`	Ein Cycode-OIDC-ID-Token für diese spezifische Scan-Ausführung angeben.
`--install-completion`	Vervollständigung für die aktuelle Shell installieren.
`--show-completion [bash\|zsh\|fish\|powershell\|pwsh]`	Vervollständigung für die angegebene Shell anzeigen, um sie zu kopieren oder die Installation anzupassen.
`-h`, `--help`	Optionen für den angegebenen Befehl anzeigen.
Befehl	Beschreibung
-------------------------------------------	----------------------------------------------------------------------------------------------------------------------------------------------
auth	Authentifizieren Sie Ihren Rechner, um die CLI mit Ihrem Cycode-Konto zu verknüpfen.
configure	Erster Befehl zum Konfigurieren der Client-Authentifizierung Ihrer CLI.
ignore	Ignorieren Sie einen bestimmten Wert, Pfad oder eine Regel-ID.
mcp	Starten Sie den Model Context Protocol (MCP)-Server, um die KI-Integration mit den Cycode-Scanfunktionen zu ermöglichen.
scan	Scannen Sie den Inhalt auf Secrets/IaC/SCA/SAST-Verstöße. Sie müssen angeben, welche Scan-Art durchgeführt werden soll: commit-history/path/repository/etc.
report	Bericht erstellen. Sie müssen angeben, welcher Berichtstyp als SBOM durchgeführt werden soll.
status	CLI-Status anzeigen und beenden.

MCP-Befehl [EXPERIMENT]

[!WARNING] Der MCP-Befehl ist nur für Python 3.10 und höher verfügbar. Wenn Sie eine ältere Python-Version verwenden, ist dieser Befehl nicht verfügbar.

Mit dem Model Context Protocol (MCP)-Befehl können Sie einen MCP-Server starten, der die Scanfunktionen von Cycode für KI-Systeme und Anwendungen bereitstellt. Dies ermöglicht KI-Modellen, über ein standardisiertes Protokoll mit den Cycode-CLI-Tools zu interagieren.

[!TIP] Für die beste Erfahrung installieren Sie die Cycode-CLI global auf Ihrem System mit pip install cycode oder brew install cycode und authentifizieren Sie sich dann einmalig mit cycode auth. Nach der globalen Installation und Authentifizierung müssen Sie die Umgebungsvariablen CYCODE_CLIENT_ID und CYCODE_CLIENT_SECRET nicht in Ihren MCP-Konfigurationsdateien konfigurieren.

Starten des MCP-Servers

Um den MCP-Server zu starten, verwenden Sie den folgenden Befehl:

cycode mcp

Standardmäßig startet dies den Server mit dem stdio-Transport, der für lokale Integrationen und KI-Anwendungen geeignet ist, die Unterprozesse erzeugen können.

Verfügbare Optionen

Option	Beschreibung
`-t, --transport`	Transporttyp für den MCP-Server: `stdio`, `sse` oder `streamable-http` (Standard: `stdio`)
`-H, --host`	Host-Adresse, an die der Server gebunden wird (nur für Nicht-stdio-Transport verwendet) (Standard: `127.0.0.1`)
`-p, --port`	Portnummer, an die der Server gebunden wird (nur für Nicht-stdio-Transport verwendet) (Standard: `8000`)
`--help`	Hilfemeldung und verfügbare Optionen anzeigen

MCP-Tools

Der MCP-Server stellt die folgenden Tools bereit, die KI-Systeme verwenden können:

Tool-Name	Beschreibung
`cycode_secret_scan`	Scan auf hartcodierte Secrets
`cycode_sca_scan`	Scan auf Software Composition Analysis (SCA) – Schwachstellen und Lizenzprobleme
`cycode_iac_scan`	Scan auf Infrastructure as Code (IaC)-Fehlkonfigurationen
`cycode_sast_scan`	Scan auf Static Application Security Testing (SAST) – Codequalität und Sicherheitsfehler
`cycode_status`	Cycode-CLI-Version, Authentifizierungsstatus und Konfigurationsinformationen abrufen

Jedes Scan-Tool akzeptiert zwei sich gegenseitig ausschließende Eingabemodi:

paths (bevorzugt) — ein oder mehrere Datei- oder Verzeichnispfade, die auf der Festplatte vorhanden sind. Verzeichnisse werden rekursiv gescannt. Die Cycode-Engine übernimmt die Dateierkennung und -filterung, genau wie cycode scan -t <type> path ./src es über die CLI tut.
files (Fallback) — ein Wörterbuch, das Dateipfade auf ihren vollständigen Inhalt als Zeichenfolgen abbildet. Verwenden Sie dies nur, wenn die Dateien nicht auf der Festplatte verfügbar sind (z. B. In-Memory-Bearbeitungen, die noch nicht gespeichert wurden).

[!TIP] Verwenden Sie paths wann immer möglich. Das Übergeben großer Dateien (wie package-lock.json) als Inline-Inhalt kann Token-Limits überschreiten und den KI-Client verlangsamen. Mit paths liest die Cycode-Engine Dateien direkt von der Festplatte.

Alle Scan-Tools geben ein JSON-Objekt zurück, das ein "summary"-Feld mit einer für Menschen lesbaren Verstöße-Anzahl (z. B. "Cycode found 3 violations: 1 CRITICAL, 2 HIGH.") zusätzlich zum vollständigen "detections"-Array enthält.

Verwendungsbeispiele

Grundlegende Befehlsbeispiele

Starten Sie den MCP-Server mit Standardeinstellungen (stdio-Transport):

cycode mcp

Starten Sie den MCP-Server mit explizitem stdio-Transport:

cycode mcp -t stdio

Starten Sie den MCP-Server mit Server-Sent Events (SSE)-Transport:

cycode mcp -t sse -p 8080

Starten Sie den MCP-Server mit streamable HTTP-Transport auf benutzerdefiniertem Host und Port:

cycode mcp -t streamable-http -H 0.0.0.0 -p 9000

Erfahren Sie mehr über MCP-Transporttypen in der MCP-Protokollspezifikation – Transports.

Konfigurationsbeispiele

Verwenden von MCP mit Cursor/VS Code/Claude Desktop/etc (mcp.json)

[!NOTE] Für EU-Cycode-Umgebungen stellen Sie sicher, dass Sie die entsprechenden CYCODE_API_URL- und CYCODE_APP_URL-Werte in den Umgebungsvariablen festlegen (z. B. https://api.eu.cycode.com und https://app.eu.cycode.com).

Folgen Sie dieser Anleitung, um den MCP-Server in Ihrem VS Code/GitHub Copilot zu konfigurieren. Beachten Sie, dass es in settings.json ein mcp-Objekt gibt, das ein verschachteltes servers-Unterobjekt enthält, und nicht ein eigenständiges mcpServers-Objekt.

Für stdio-Transport (direkte Ausführung):

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Für stdio-Transport mit pipx-Installation:

{
  "mcpServers": {
    "cycode": {
      "command": "pipx",
      "args": ["run", "cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Für stdio-Transport mit uvx-Installation:

{
  "mcpServers": {
    "cycode": {
      "command": "uvx",
      "args": ["cycode", "mcp"],
      "env": {
        "CYCODE_CLIENT_ID": "your-cycode-id",
        "CYCODE_CLIENT_SECRET": "your-cycode-secret-key",
        "CYCODE_API_URL": "https://api.cycode.com",
        "CYCODE_APP_URL": "https://app.cycode.com"
      }
    }
  }
}

Für SSE-Transport (Server-Sent Events):

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

Für SSE-Transport auf benutzerdefiniertem Port:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8080/sse"
    }
  }
}

Für streamable HTTP-Transport:

{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

Ausführen des MCP-Servers im Hintergrund

Für SSE-Transport (zuerst Server starten, dann Client konfigurieren):

# Start the MCP server in the background
cycode mcp -t sse -p 8000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.1:8000/sse"
    }
  }
}

Für streamable HTTP-Transport:

# Start the MCP server in the background
cycode mcp -t streamable-http -H 127.0.0.2 -p 9000 &

# Configure in mcp.json
{
  "mcpServers": {
    "cycode": {
      "url": "http://127.0.0.2:9000/mcp"
    }
  }
}

Erweiterte Konfiguration

Benutzerdefinierte Zertifikate und Timeouts (Proxy-Umgebungen)

Wenn Ihre Organisation einen Unternehmens-Proxy oder ein benutzerdefiniertes CA-Bündel für die HTTPS-Inspektion verwendet, müssen Sie der Cycode-CLI (und dem zugrunde liegenden Python-TLS-Stack) mitteilen, wo das vertrauenswürdige Zertifikatsbündel zu finden ist. Sie können auch das MCP-Tool-Aufruf-Timeout erhöhen, wenn Scans vorzeitig abgebrochen werden.

Umgebungsvariable	Beschreibung
`REQUESTS_CA_BUNDLE`	Pfad zu einer benutzerdefinierten CA-Bündeldatei (`.pem` oder `.crt`). Wird von der `requests`-Bibliothek für alle HTTPS-Aufrufe der Cycode-CLI verwendet.
`SSL_CERT_FILE`	Pfad zu einer benutzerdefinierten CA-Bündeldatei. Wird vom Low-Level-`ssl`-Modul von Python verwendet. Setzen Sie dies zusammen mit `REQUESTS_CA_BUNDLE` für vollständige Abdeckung.
`MCP_TOOL_TIMEOUT`	Timeout (in Sekunden), das MCP-Clients wie Claude und GitHub Copilot auf den Abschluss eines Tool-Aufrufs warten. Erhöhen Sie dies, wenn langlaufende Scans vor ihrem Abschluss abgebrochen werden.

[!TIP] Setzen Sie sowohl REQUESTS_CA_BUNDLE als auch SSL_CERT_FILE auf denselben CA-Bündelpfad. REQUESTS_CA_BUNDLE deckt die HTTP-Ebene ab; SSL_CERT_FILE deckt die niedrigere TLS-Ebene ab. Die Verwendung nur eines davon kann in einigen Umgebungen weiterhin Zertifikatsfehler verursachen.

Beispiel für eine mcp.json-Konfiguration mit benutzerdefinierten Zertifikaten und einem längeren Timeout:

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "REQUESTS_CA_BUNDLE": "/path/to/your/corporate-ca-bundle.pem",
        "SSL_CERT_FILE": "/path/to/your/corporate-ca-bundle.pem",
        "MCP_TOOL_TIMEOUT": "1800"
      }
    }
  }
}

[!NOTE] Der MCP-Server erfordert eine ordnungsgemäße Cycode-CLI-Authentifizierung, um zu funktionieren. Stellen Sie sicher, dass Sie sich mit cycode auth authentifiziert oder Ihre Anmeldeinformationen konfiguriert haben, bevor Sie den MCP-Server starten.

Vorautorisieren von Tools für Unteragenten (Claude Code)

Wenn Claude Code Arbeiten an Hintergrund-Unteragenten delegiert (z. B. um Scans parallel auszuführen), können diese Unteragenten keine interaktiven Berechtigungsaufforderungen anzeigen. Wenn die Cycode-Tools nicht vorab genehmigt wurden, schlagen Scans in Unteragenten-Kontexten still fehl.

Um die Cycode-MCP-Tools vorab zu autorisieren, damit sie in allen Kontexten einschließlich Unteragenten funktionieren, fügen Sie sie zur allowedTools-Liste in Ihren Claude-Code-Einstellungen (~/.claude/settings.json) hinzu:

{
  "allowedTools": [
    "mcp__cycode__cycode_secret_scan",
    "mcp__cycode__cycode_sca_scan",
    "mcp__cycode__cycode_iac_scan",
    "mcp__cycode__cycode_sast_scan",
    "mcp__cycode__cycode_status"
  ]
}

Nach dem Hinzufügen fordert Claude Code keine Genehmigung an, wenn diese Tools aufgerufen werden, und sie funktionieren korrekt innerhalb von Unteragenten.

Fehlerbehebung bei MCP

Wenn Sie Probleme mit dem MCP-Server haben, können Sie die Debug-Protokollierung aktivieren, um detailliertere Informationen darüber zu erhalten, was passiert. Es gibt zwei Möglichkeiten, die Debug-Protokollierung zu aktivieren:

Verwenden des -v- oder --verbose-Flags:

cycode -v mcp

Verwenden der CYCODE_CLI_VERBOSE-Umgebungsvariable:

CYCODE_CLI_VERBOSE=1 cycode mcp

Die Debug-Protokolle zeigen detaillierte Informationen zu:

Serverstart und -konfiguration
Verbindungsversuche und -status
Tool-Ausführung und -ergebnisse
Alle auftretenden Fehler oder Warnungen

Diese Informationen können hilfreich sein, wenn:

Verbindungsprobleme diagnostiziert werden
Verstanden werden soll, warum bestimmte Tools nicht funktionieren
Authentifizierungsprobleme identifiziert werden
Transportspezifische Probleme debuggt werden

MCP-Konfiguration

Plattform-Befehl [BETA]

[!WARNING] Der platform-Befehl befindet sich in der Beta-Phase. Befehle, Argumente und Ausgabeformate werden dynamisch aus der Cycode-API-Spezifikation generiert und können sich zwischen Versionen ohne Vorankündigung ändern. Verlassen Sie sich in der Produktionsautomatisierung noch nicht darauf.

Der cycode platform-Befehl stellt die Lese-APIs der Cycode-Plattform als CLI-Befehle bereit. Er gruppiert Endpunkte nach Ressource (z. B. projects, violations, workflows) und wandelt die Parameter jedes Endpunkts in typisierte CLI-Argumente und --option-Flags um.

cycode platform projects list --page-size 50
cycode platform violations count
cycode platform workflows view <workflow-id>

Die OpenAPI-Spezifikation wird bei der ersten Verwendung von der Cycode-API abgerufen und für 24 Stunden unter ~/.cycode/openapi-spec.json zwischengespeichert. Nicht verwandte Befehle (cycode scan, cycode status usw.) lösen keinen Abruf aus.

[!NOTE] Sie müssen authentifiziert sein (cycode auth oder CYCODE_CLIENT_ID / CYCODE_CLIENT_SECRET-Umgebungsvariablen), damit cycode platform Befehle erkennen und ausführen kann. Andere Cycode-CLI-Befehle funktionieren ohne Authentifizierung.

Erkennen von Befehlen

Da Befehle aus der Spezifikation generiert werden, ist die Quelle der Wahrheit für das, was verfügbar ist, --help:

cycode platform --help                  # list all resource groups
cycode platform projects --help         # list actions on a resource
cycode platform projects list --help    # list options/arguments for an action

Plattform-Beispiele

# List projects with pagination
cycode platform projects list --page-size 25

# View a single project by ID
cycode platform projects view <project-id>

# Count violations across the tenant
cycode platform violations count

# Filter using query parameters (see `--help` for what each endpoint supports)
cycode platform violations list --severity CRITICAL

Die gesamte Ausgabe ist standardmäßig JSON – leiten Sie sie für Ad-hoc-Filterung durch jq:

cycode platform projects list --page-size 100 | jq '.items[].name'

Plattform-Hinweise und Einschränkungen

Nur lesend heute. In dieser Beta werden nur GET-Endpunkte bereitgestellt.
Spezifikationsgesteuert. Das Hinzufügen eines neuen Endpunkts zur API macht ihn automatisch beim nächsten Aktualisieren des Caches verfügbar.
Keine gebündelte Spezifikation. Der erste cycode platform-Aufruf nach der Installation (oder nach Ablauf des 24-Stunden-Caches) führt einen Netzwerkabruf durch. Bei langsamen Verbindungen kann dieser erste Aufruf einige Sekunden dauern; nachfolgende Aufrufe sind nahezu sofort, bis der Cache abläuft.
Cache-TTL überschreiben mit CYCODE_SPEC_CACHE_TTL=<seconds>.

KI-Schutzmaßnahmen [BETA]

AI Guardrails installt Hooks in unterstützte KI-Codierungsagenten (Claude Code, Cursor, Copilot, Codex) ein, sodass Prompts, Dateien, die der Agent liest, und MCP-Tool-Argumente auf Geheimnisse überprüft werden, bevor sie das Modell erreichen.

Von AI Guardrails erfasste Daten

Die Überprüfung erfolgt serverseitig, sodass der gescannte Inhalt die Maschine verlässt: der Prompt-Text, der Inhalt von Dateien, die der Agent liest, und MCP-Tool-Argumente werden an Ihren Cycode-Tenant gesendet, um auf Geheimnisse geprüft zu werden.

Jedes Ereignis wird auch mit Kontext über den Entwickler und die Maschine gemeldet, sodass ein Befund dem Gerät und Benutzer zugeordnet werden kann, von dem er stammt. Einige davon sind personenbezogene Daten:

Gerätekennungen — der Hostname der Maschine und die Hardware-Seriennummer.
Benutzerkennungen — die E-Mail-Adresse des Benutzers, der beim KI-Codierungsagenten angemeldet ist, sowie der lokale Betriebssystem-Benutzername.
Umgebungsdetails — Betriebssystem und Version, der KI-Agent, seine Version und das verwendete Modell, der Inhalt der MCP-Konfigurationsdateien des Agents und seine aktivierten Plugins.

Die Hardware-Seriennummer wird in einer lokalen temporären Datei zwischengespeichert, die nur für den Benutzer lesbar ist, der den Befehl ausgeführt hat, sodass wiederholte Hook-Aufrufe die Hardware nicht erneut abfragen.

Wenn die Erfassung dieser Daten in Ihrer Umgebung nicht akzeptabel ist, installieren Sie die Guardrails-Hooks nicht (cycode ai-guardrails uninstall entfernt bereits installierte Hooks).

Scan-Befehl

Ausführen eines Scans

Die Cycode-CLI-Anwendung bietet verschiedene Arten von Scans an, damit Sie die Option wählen können, die am besten zu Ihrem Fall passt. Die folgenden Optionen und Befehle sind derzeit verfügbar:

Option	Beschreibung
`-t, --scan-type [secret\|iac\|sca\|sast]`	Geben Sie den Scan an, den Sie ausführen möchten (`secret`/`iac`/`sca`/`sast`), der Standardwert ist `secret`.
`--show-secret BOOLEAN`	Zeigt Geheimnisse im Klartext an. Weitere Details finden Sie im Abschnitt Geheimnisse anzeigen/ausblenden.
`--soft-fail BOOLEAN`	Scan ohne Fehlschlag ausführen, immer einen Nicht-Fehler-Statuscode zurückgeben. Weitere Details finden Sie im Abschnitt Soft Fail.
`--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]`	Nur Verstöße auf der angegebenen Ebene oder höher anzeigen.
`--sca-scan`	Geben Sie den SCA-Scan an, den Sie ausführen möchten (`package-vulnerabilities`/`license-compliance`). Der Standardwert ist beides.
`--monitor`	Wenn angegeben, werden die Scan-Ergebnisse in Cycode aufgezeichnet.
`--cycode-report`	Zeigt einen Link zum Scan-Bericht in der Cycode-Plattform in der Konsolenausgabe an.
`--no-restore`	Wenn angegeben, führt Cycode den Wiederherstellungsbefehl nicht aus. Dies scannt NUR direkte Abhängigkeiten!
`--stop-on-error`	Bricht den Scan ab, wenn ein Dateisammlungs- oder Abhängigkeitswiederherstellungsfehler auftritt, anstatt die fehlgeschlagene Datei zu überspringen und fortzufahren.
`--gradle-all-sub-projects`	Führen Sie den Gradle-Wiederherstellungsbefehl für alle Unterprojekte aus. Dies sollte ausgeführt werden von
`--maven-settings-file`	Nur für Maven: Ermöglicht die Verwendung einer benutzerdefinierten settings.xml-Datei beim Scannen nach Abhängigkeiten
`--help`	Zeigt Optionen für den angegebenen Befehl an.

Befehl	Beschreibung
commit-history	Commit-Verlauf scannen oder Diff-Scanning zwischen bestimmten Commits durchführen
path	Scannt die Dateien im Pfad, der im Befehl angegeben ist
pre-commit	Verwenden Sie diesen Befehl, um den Inhalt zu scannen, der noch nicht committet wurde
repository	Git-Repository einschließlich seines Verlaufs scannen

Optionen

Schweregrad-Option

Um die Ergebnisse des Scans auf einen bestimmten Schweregrad-Schwellenwert zu begrenzen, kann das Argument --severity-threshold zum Scan-Befehl hinzugefügt werden.

Der folgende Befehl scannt beispielsweise das Repository auf Richtlinienverstöße mit einem Schweregrad von Mittel oder höher:

cycode scan --severity-threshold MEDIUM repository ~/home/git/codebase

Monitor-Option

[!NOTE] Diese Option ist nur für SCA-Scans verfügbar.

Um Scan-Ergebnisse, die mit den SCA-Richtlinien verknüpft sind, die in einem SCA-Typ-Scan gefunden wurden, an Cycode zu senden, fügen Sie das Argument --monitor zum Scan-Befehl hinzu.

Der folgende Befehl scannt beispielsweise das Repository auf SCA-Richtlinienverstöße und sendet sie an die Cycode-Plattform:

cycode scan -t sca --monitor repository ~/home/git/codebase

Cycode-Berichtsoption

Für jeden Scan, der mit der Cycode-CLI durchgeführt wird, wird automatisch ein Bericht generiert und seine Ergebnisse an Cycode gesendet. Diese Ergebnisse sind mit den relevanten Richtlinien (z. B. SCA-Richtlinien für Repository-Scans) innerhalb der Cycode-Plattform verknüpft.

Um die direkte URL zu diesem Cycode-Bericht nach Abschluss des Scans in Ihrer CLI-Ausgabe gedruckt zu erhalten, fügen Sie das Argument --cycode-report zu Ihrem Scan-Befehl hinzu.

cycode scan --cycode-report repository ~/home/git/codebase

Alle Scan-Ergebnisse der CLI erscheinen im Abschnitt CLI-Protokolle von Cycode. Wenn Sie das Flag --cycode-report in Ihren Befehl aufgenommen haben, wird ein direkter Link zum spezifischen Bericht nach den Scan-Ergebnissen in Ihrem Terminal angezeigt.

[!WARNING] Sie müssen die Rolle owner oder admin in Cycode haben, um diese Seite anzuzeigen.

cli-report

Die Berichtsseite sieht ungefähr wie folgt aus:

Paket-Schwachstellen-Option

[!NOTE] Diese Option ist nur für SCA-Scans verfügbar.

Um eine bestimmte Paket-Schwachstelle Ihres lokalen Repositorys zu scannen, fügen Sie das Argument --sca-scan package-vulnerabilities nach der Option -t sca oder --scan-type sca hinzu.

Wenn Sie im vorherigen Beispiel nur einen SCA-Scan für Paket-Schwachstellen ausführen wollten, könnten Sie Folgendes ausführen:

cycode scan -t sca --sca-scan package-vulnerabilities repository ~/home/git/codebase

Lizenz-Compliance-Option

[!NOTE] Diese Option ist nur für SCA-Scans verfügbar.

Um einen bestimmten Zweig Ihres lokalen Repositorys zu scannen, fügen Sie das Argument --sca-scan license-compliance gefolgt vom Namen des Zweigs hinzu, den Sie scannen möchten.

Wenn Sie im vorherigen Beispiel nur einen Zweig namens dev scannen wollten, könnten Sie Folgendes ausführen:

cycode scan -t sca --sca-scan license-compliance repository ~/home/git/codebase -b dev

Lock-Wiederherstellungsoption

[!NOTE] Diese Option ist nur für SCA-Scans verfügbar.

Beim Ausführen eines SCA-Scans versucht die Cycode-CLI automatisch, eine Abhängigkeits-Lockdatei für jede unterstützte Manifestdatei, die sie findet, wiederherzustellen (zu generieren). Dies ermöglicht das Scannen transitiver Abhängigkeiten, nicht nur der direkt im Manifest aufgeführten. Um diesen Schritt zu überspringen und nur direkte Abhängigkeiten zu scannen, verwenden Sie das Flag --no-restore.

Die folgenden Ökosysteme unterstützen die automatische Lockdatei-Wiederherstellung:

Ökosystem	Manifestdatei	Generierte Lockdatei	Aufgerufenes Tool (wenn Lockdatei fehlt)
npm	`package.json`	`package-lock.json`	`npm install --package-lock-only --ignore-scripts --no-audit`
Yarn	`package.json`	`yarn.lock`	`yarn install --ignore-scripts`
pnpm	`package.json`	`pnpm-lock.yaml`	`pnpm install --ignore-scripts`
Deno	`deno.json` / `deno.jsonc`	`deno.lock`	(nur vorhandene Lockdatei lesen)
Go	`go.mod`	`go.mod.graph`	`go list -m -json all` + `go mod graph`
Maven	`pom.xml`	`bcde.mvndeps`	`mvn dependency:tree`
Gradle	`build.gradle` / `build.gradle.kts`	`gradle-dependencies-generated.txt`	`gradle dependencies -q --console plain`
SBT	`build.sbt`	`build.sbt.lock`	`sbt dependencyLockWrite`
NuGet	`*.csproj`	`packages.lock.json`	`dotnet restore --use-lock-file`
Ruby	`Gemfile`	`Gemfile.lock`	`bundle --quiet`
Poetry	`pyproject.toml`	`poetry.lock`	`poetry lock`
pip	`pyproject.toml` / `requirements.txt`	`pylock.toml`	`pip lock .` / `pip lock -r requirements.txt -o pylock.toml`
Pipenv	`Pipfile`	`Pipfile.lock`	`pipenv lock`
PHP Composer	`composer.json`	`composer.lock`	`composer update --no-cache --no-install --no-scripts --ignore-platform-reqs`

Wenn bereits eine Lockdatei neben der Manifestdatei vorhanden ist, liest Cycode sie direkt, ohne einen Installationsbefehl auszuführen.

SBT-Voraussetzung: Das Plugin sbt-dependency-lock muss installiert sein. Fügen Sie die folgende Zeile zu project/plugins.sbt hinzu:

addSbtPlugin("software.purpledragon" % "sbt-dependency-lock" % "1.5.1")

Stopp-bei-Fehler-Option

Standardmäßig scannt Cycode weiter, auch wenn eine Datei nicht gelesen werden kann (z. B. aufgrund eines Berechtigungsfehlers) oder eine Abhängigkeits-Lockdatei während eines SCA-Scans nicht generiert werden kann. Das fehlgeschlagene Element wird mit einer Warnung übersprungen und der Scan fährt mit den verbleibenden Dateien fort.

Verwenden Sie --stop-on-error, um dieses Verhalten zu ändern: Der Scan bricht sofort beim ersten solchen Fehler ab und meldet den Fehler.

cycode scan -t sca --stop-on-error path ~/home/git/codebase

Dies ist in CI-Pipelines nützlich, wo ein stiller Fehler ein unvollständiges Scan-Ergebnis erzeugen würde. Wenn --stop-on-error ausgelöst wird, können Sie entweder das zugrunde liegende Problem beheben oder, speziell für SCA-Wiederherstellungsfehler, --no-restore hinzufügen, um die Lockdatei-Generierung zu überspringen und nur direkte Abhängigkeiten zu scannen.

Wenn --stop-on-error verwendet wird, unterscheidet die CLI zwischen Scan-Fehlern und Richtlinienverstößen über Exit-Codes:

Exit-Code	Bedeutung
`0`	Scan abgeschlossen ohne Verstöße
`1`	Scan abgeschlossen und Verstöße gefunden
`2`	Scan wegen eines Fehlers abgebrochen (nur wenn `--stop-on-error` gesetzt ist)

Repository-Scan

Ein Repository-Scan untersucht ein gesamtes lokales Repository auf offengelegte Geheimnisse oder unsichere Fehlkonfigurationen. Dieser ganzheitlichere Scan-Typ betrachtet alles: den aktuellen Zustand Ihres Repositorys und seinen Commit-Verlauf. Er sucht nicht nur nach Geheimnissen, die derzeit im Repository offengelegt sind, sondern auch nach zuvor gelöschten Geheimnissen.

Um einen vollständigen Repository-Scan auszuführen, führen Sie Folgendes aus:

cycode scan repository {{path}}

Wenn Sie beispielsweise ein Repository scannen möchten, das in ~/home/git/codebase gespeichert ist, könnten Sie Folgendes ausführen:

cycode scan repository ~/home/git/codebase

Die folgende Option ist für die Verwendung mit diesem Befehl verfügbar:

Option	Beschreibung
`-b, --branch TEXT`	Zu scannender Zweig, wenn nicht gesetzt, wird der Standardzweig gescannt

Zweig-Option

Um einen bestimmten Zweig Ihres lokalen Repositorys zu scannen, fügen Sie das Argument -b (alternativ --branch) gefolgt vom Namen des Zweigs hinzu, den Sie scannen möchten.

Angesichts des vorherigen Beispiels, wenn Sie nur einen Zweig namens dev scannen wollten, könnten Sie Folgendes ausführen:

cycode scan repository ~/home/git/codebase -b dev

Pfad-Scan

Ein Pfad-Scan untersucht ein bestimmtes lokales Verzeichnis und den gesamten Inhalt darin, anstatt sich ausschließlich auf ein GIT-Repository zu konzentrieren.

Um einen Verzeichnis-Scan auszuführen, führen Sie Folgendes aus:

cycode scan path {{path}}

Betrachten Sie beispielsweise ein Szenario, in dem Sie das Verzeichnis unter ~/home/git/codebase scannen möchten. Sie könnten dann Folgendes ausführen:

cycode scan path ~/home/git/codebase

Terraform-Plan-Scan

Die Cycode-CLI unterstützt das Scannen von Terraform-Plänen (unterstützt Terraform 0.12 und höher).

Die Terraform-Plan-Datei muss im JSON-Format vorliegen (mit der Erweiterung .json).

Wenn Sie nur eine Konfigurationsdatei haben, können Sie einen Plan wie folgt generieren:

Initialisieren Sie ein Arbeitsverzeichnis, das die Terraform-Konfigurationsdatei enthält:

terraform init
Erstellen Sie einen Terraform-Ausführungsplan und speichern Sie die Binärausgabe:

terraform plan -out={tfplan_output}
Konvertieren Sie die Binärausgabedatei in lesbares JSON:

terraform show -json {tfplan_output} > {tfplan}.json
Scannen Sie Ihre {tfplan}.json mit der Cycode-CLI:

cycode scan -t iac path ~/PATH/TO/YOUR/{tfplan}.json

Commit-Verlaufsscan

[!NOTE] Der Commit-Verlaufsscan ist für IaC-Scans nicht verfügbar.

Der Befehl zum Scannen des Commit-Verlaufs bietet zwei Hauptfunktionen:

Vollständige Verlaufsscanning: Analysiert alle Commits im Repository-Verlauf
Diff-Scanning: Scannt nur die Änderungen zwischen bestimmten Commits

Das Scannen von Geheimnissen kann alle Commits im Repository-Verlauf analysieren, da Geheimnisse, die eingeführt und später entfernt wurden, dennoch durchsickern oder offengelegt werden können. Bei SCA- und SAST-Scans konzentriert sich der Commit-Verlaufsbefehl auf das Scannen der Unterschiede/Änderungen zwischen Commits, was ihn ideal für Pull-Request-Überprüfungen und inkrementelles Scannen macht.

Ein Commit-Verlaufsscan untersucht den Commit-Verlauf Ihres Git-Repositorys und kann sowohl für eine umfassende historische Analyse als auch für gezieltes Diff-Scannen bestimmter Änderungen verwendet werden.

Um einen Commit-Verlaufsscan auszuführen, führen Sie Folgendes aus:

cycode scan commit-history {{path}}

Betrachten Sie beispielsweise ein Szenario, in dem Sie den Commit-Verlauf für ein Repository scannen möchten, das in ~/home/git/codebase gespeichert ist. Sie könnten dann Folgendes ausführen:

cycode scan commit-history ~/home/git/codebase

Die folgenden Optionen sind für die Verwendung mit diesem Befehl verfügbar:

Option	Beschreibung
`-r, --commit-range TEXT`	Scannt einen Commit-Bereich in diesem Git-Repository, standardmäßig scannt Cycode den gesamten Commit-Verlauf (Beispiel: HEAD~1)

Commit-Bereichsoption (Diff-Scanning)

Die Commit-Bereichsoption ermöglicht Diff-Scanning – das Scannen nur der Änderungen zwischen bestimmten Commits anstelle des gesamten Repository-Verlaufs. Dies ist besonders nützlich für:

Pull-Request-Validierung: Scannt nur die in einem PR eingeführten Änderungen
Inkrementelles CI/CD-Scannen: Konzentriert sich auf aktuelle Änderungen anstelle des gesamten Codebestands
Feature-Branch-Überprüfung: Vergleicht Änderungen mit dem Haupt-/Master-Branch
Leistungsoptimierung: Schnellere Scans durch Begrenzung des Umfangs auf relevante Änderungen

Commit-Bereichs-Syntax

Die Option --commit-range (-r) unterstützt die standardmäßige Git-Revisionssyntax:

Syntax	Beschreibung	Beispiel
`commit1..commit2`	Änderungen von Commit1 zu Commit2	`abc123..def456`
`commit1...commit2`	Änderungen in Commit2, die nicht in Commit1 sind	`main...feature-branch`
`commit`	Änderungen von Commit zu HEAD	`HEAD~1`
`branch1..branch2`	Änderungen von Branch1 zu Branch2	`main..feature-branch`

Diff-Scanning-Beispiele

Änderungen im letzten Commit scannen:

cycode scan commit-history -r HEAD~1 ~/home/git/codebase

Änderungen zwischen zwei bestimmten Commits scannen:

cycode scan commit-history -r abc123..def456 ~/home/git/codebase

Änderungen in Ihrem Feature-Branch im Vergleich zu Main scannen:

cycode scan commit-history -r main..HEAD ~/home/git/codebase

Änderungen zwischen Main und einem Feature-Branch scannen:

cycode scan commit-history -r main..feature-branch ~/home/git/codebase

Alle Änderungen in den letzten 3 Commits scannen:

cycode scan commit-history -r HEAD~3..HEAD ~/home/git/codebase

[!TIP] Für CI/CD-Pipelines können Sie Umgebungsvariablen wie ${{ github.event.pull_request.base.sha }}..${{ github.sha }} (GitHub Actions) oder $CI_MERGE_REQUEST_TARGET_BRANCH_SHA..$CI_COMMIT_SHA (GitLab CI) verwenden, um nur PR/MR-Änderungen zu scannen.

Pre-Commit-Scan

Ein Pre-Commit-Scan identifiziert automatisch alle Probleme, bevor Sie Änderungen an Ihrem Repository committen. Es ist nicht erforderlich, diesen Scan manuell auszuführen; konfigurieren Sie den Pre-Commit-Hook wie im Abschnitt Installation dieses Handbuchs beschrieben.

Nach der Installation des Pre-Commit-Hooks möchten Sie möglicherweise gelegentlich das Scannen während eines bestimmten Commits überspringen. Fügen Sie dazu Folgendes zu Ihrem git-Befehl hinzu, um das Scannen für einen einzelnen Commit zu überspringen:

SKIP=cycode git commit -m <your commit message>`

Pre-Push-Scan

Ein Pre-Push-Scan identifiziert automatisch alle Probleme, bevor Sie Änderungen an das Remote-Repository pushen. Dieser Hook läuft auf der Client-Seite und scannt nur die Commits, die gepusht werden sollen, was ihn effizient macht, um Probleme zu erkennen, bevor sie das Remote-Repository erreichen.

[!NOTE] Der Pre-Push-Hook ist für IaC-Scans nicht verfügbar.

Der Pre-Push-Hook integriert sich in das Pre-Commit-Framework und kann so konfiguriert werden, dass er vor jeder git push-Operation ausgeführt wird.

Installation des Pre-Push-Hooks

Um den Pre-Push-Hook mit dem Pre-Commit-Framework einzurichten:

Installieren Sie das Pre-Commit-Framework (falls nicht bereits installiert):
```
pip3 install pre-commit
```

Erstellen oder aktualisieren Sie Ihre .pre-commit-config.yaml-Datei, um die Pre-Push-Hooks einzuschließen:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push
        stages: [pre-push]

Verwenden Sie für mehrere Scan-Typen diese Konfiguration:

repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode-pre-push          # Secrets scan
        stages: [pre-push]
      - id: cycode-sca-pre-push      # SCA scan
        stages: [pre-push]
      - id: cycode-sast-pre-push     # SAST scan
        stages: [pre-push]

Installieren Sie den Pre-Push-Hook:
```
pre-commit install --hook-type pre-push
```
Eine erfolgreiche Installation führt zu der Meldung: Pre-push installed at .git/hooks/pre-push.
Halten Sie den Pre-Push-Hook auf dem neuesten Stand:
```
pre-commit autoupdate
```

So funktioniert das Pre-Push-Scannen

Der Pre-Push-Hook:

Empfängt Informationen darüber, welche Commits gepusht werden
Berechnet den geeigneten Commit-Bereich zum Scannen
Für neue Branches: Scannt alle Commits von der Merge-Basis mit dem Standard-Branch
Für bestehende Branches: Scannt nur die neuen Commits seit dem letzten Push
Führt dasselbe umfassende Scannen wie andere Cycode-Scanmodi aus

Intelligente Standard-Branch-Erkennung

Der Pre-Push-Hook erkennt intelligent den Standard-Branch für die Merge-Basis-Berechnung unter Verwendung dieser Prioritätsreihenfolge:

Umgebungsvariable: CYCODE_DEFAULT_BRANCH – ermöglicht manuelle Überschreibung
Git Remote HEAD: Verwendet git symbolic-ref refs/remotes/origin/HEAD, um den tatsächlichen Remote-Standard-Branch zu erkennen
Git Remote-Informationen: Fällt auf git remote show origin zurück, wenn symbolic-ref fehlschlägt
Hartcodierte Fallbacks: Verwendet gängige Standard-Branch-Namen (origin/main, origin/master, main, master)

Festlegen eines benutzerdefinierten Standard-Branchs:

export CYCODE_DEFAULT_BRANCH=origin/develop

Diese intelligente Erkennung stellt sicher, dass der Pre-Push-Hook unabhängig davon korrekt funktioniert, ob Ihr Repository main, master, develop oder einen anderen Standard-Branch-Namen verwendet.

Überspringen von Pre-Push-Scans

Um den Pre-Push-Scan für einen bestimmten Push-Vorgang zu überspringen, verwenden Sie:

SKIP=cycode-pre-push git push

Oder um alle Pre-Push-Hooks zu überspringen:

git push --no-verify

[!TIP] Der Pre-Push-Hook wird beim git push-Befehl ausgelöst und scannt nur die Commits, die gepusht werden sollen, was ihn effizienter macht als das Scannen des gesamten Repositorys.

Pfade von Scans ausschließen

Sie können eine .cycodeignore-Datei verwenden, um der Cycode-CLI mitzuteilen, welche Dateien und Verzeichnisse von Scans ausgeschlossen werden sollen. Sie funktioniert genau wie eine .gitignore-Datei. Dies hilft Ihnen, Scans auf Ihren relevanten Code zu fokussieren und zu verhindern, dass bestimmte Pfade lokal Verstöße auslösen.

So funktioniert es

Erstellen Sie eine Datei mit dem Namen .cycodeignore in Ihrem Arbeitsordner.
Listen Sie die Dateien und Verzeichnisse auf, die Sie ausschließen möchten, unter Verwendung derselben Muster wie .gitignore.
Platzieren Sie diese Datei in dem Verzeichnis, in dem Sie den Cycode-Scan-Befehl ausführen möchten.

[!WARNING]

Ungültige Dateien: Wenn die .cycodeignore-Datei einen Syntaxfehler enthält, schlägt der CLI-Scan fehl und gibt einen Fehler zurück.

Pfade vs. Verstöße ignorieren: Diese Datei dient zum Ausschließen von Pfaden. Sie unterscheidet sich von der CLI-Fähigkeit, bestimmte Verstöße zu ignorieren (z. B. durch Verwendung des Flags --ignore-violation).

Unterstützte Scanner

SAST
IaC (bald verfügbar)
SCA (bald verfügbar)

Scan-Ergebnisse

Jeder Scan wird mit einer Meldung abgeschlossen, die angibt, ob Probleme gefunden wurden oder nicht.

Wenn keine Probleme gefunden werden, endet der Scan mit der folgenden Erfolgsmeldung:

Good job! No issues were found!!! 👏👏👏

Wenn ein Problem gefunden wird, erscheint stattdessen beim Abschluss eine Verstoßkarte. In diesem Fall sollten Sie die betreffende Datei auf die spezifische Zeile überprüfen, die in der Ergebnismeldung hervorgehoben wird. Implementieren Sie alle erforderlichen Änderungen, um das Problem zu beheben, und führen Sie den Scan dann erneut aus.

Geheimnisse anzeigen/ausblenden

In den Beispielen unten wurde ein Geheimnis in der Datei secret_test gefunden, die sich im Unterordner cli befindet. Der zweite Teil der Meldung zeigt die spezifische Zeile, in der das Geheimnis erscheint, was in diesem Fall ein Wert ist, der googleApiKey zugewiesen ist.

Beachten Sie, wie das Beispiel den tatsächlichen Geheimniswert verschleiert und den größten Teil des Geheimnisses durch Sternchen ersetzt. Scans verschleiern Geheimnisse standardmäßig, aber Sie können diese Funktion optional deaktivieren, um das vollständige Geheimnis anzuzeigen (vorausgesetzt, die Maschine, auf der Sie das Scan-Ergebnis anzeigen, ist ausreichend vor neugierigen Blicken geschützt).

Um die Geheimnisverschleierung zu deaktivieren, fügen Sie das Argument --show-secret zu jeder Art von Scan hinzu.

Im folgenden Beispiel wird ein Pfadscan gegen das Unterverzeichnis cli ausgeführt, wobei die Option aktiviert ist, um alle gefundenen Geheimnisse vollständig anzuzeigen:

cycode scan --show-secret path ./cli

Das Ergebnis wäre dann nicht verschleiert.

Soft Fail

Im normalen Betrieb gibt die CLI einen Exit-Code von 1 zurück, wenn Probleme in den Scan-Ergebnissen gefunden werden. Abhängig von Ihrer CI/CD-Einrichtung führt dies normalerweise zu einem Gesamtfehler. Wenn Sie dies nicht möchten, können Sie die Soft-Fail-Funktion verwenden.

Durch Hinzufügen der Option --soft-fail zu jeder Art von Scan wird der Exit-Code unabhängig davon, ob Ergebnisse gefunden werden, auf 0 erzwungen.

Beispiel-Scan-Ergebnisse

Beispiel für Geheimnis-Ergebnis

╭─────────────────────────────────────────────────────────────── Hardcoded generic-password is used ───────────────────────────────────────────────────────────────╮
│                                                                                                                                               Violation 12 of 12 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity    🟠 MEDIUM                             │ │   34 };                                                                                               │ │
│ │  In file     /Users/cycodemacuser/NodeGoat/test/s  │ │   35                                                                                                  │ │
│ │              ecurity/profile-test.js               │ │   36 var sutUserName = "user1";                                                                       │ │
│ │  Secret SHA  b4ea3116d868b7c982ee6812cce61727856b  │ │ ❱ 37 var sutUserPassword = "Us*****23";                                                               │ │
│ │              802b3063cd5aebe7d796988552e0          │ │   38                                                                                                  │ │
│ │  Rule ID     68b6a876-4890-4e62-9531-0e687223579f  │ │   39 chrome.setDefaultService(service);                                                               │ │
│ ╰────────────────────────────────────────────────────╯ │   40                                                                                                  │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ A generic secret or password is an authentication token used to access a computer or application and is assigned to a password variable.                     │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Beispiel für IaC-Ergebnis

╭──────────── Enable Content Encoding through the attribute 'MinimumCompressionSize'. This value should be greater than -1 and smaller than 10485760. ─────────────╮
│                                                                                                                                              Violation 45 of 110 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity      🟠 MEDIUM                           │ │   20 BinaryMediaTypes:                                                                                │ │
│ │  In file       ...ads-copy/iac/cft/api-gateway/ap  │ │   21   - !Ref binaryMediaType1                                                                        │ │
│ │                i-gateway-rest-api/deploy.yml       │ │   22   - !Ref binaryMediaType2                                                                        │ │
│ │  IaC Provider  CloudFormation                      │ │ ❱ 23 MinimumCompressionSize: -1                                                                       │ │
│ │  Rule ID       33c4b90c-3270-4337-a075-d3109c141b  │ │   24 EndpointConfiguration:                                                                           │ │
│ │                53                                  │ │   25   Types:                                                                                         │ │
│ ╰────────────────────────────────────────────────────╯ │   26     - EDGE                                                                                       │ │
│                                                        ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ This policy validates the proper configuration of content encoding in AWS API Gateway. Specifically, the policy checks for the attribute                     │ │
│ │ 'minimum_compression_size' in API Gateway REST APIs. Correct configuration of this attribute is important for enabling content encoding of API responses for │ │
│ │ improved API performance and reduced payload sizes.                                                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Beispiel für SCA-Ergebnis

╭─────────────────────────────────────────────────────── [CVE-2019-10795] Prototype Pollution in undefsafe ────────────────────────────────────────────────────────╮
│                                                                                                                                             Violation 172 of 195 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity               🟠 MEDIUM                  │ │   26758   "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=",                                           │ │
│ │  In file                /Users/cycodemacuser/Node  │ │   26759   "dev": true                                                                                 │ │
│ │                         Goat/package-lock.json     │ │   26760 },                                                                                            │ │
│ │  CVEs                   CVE-2019-10795             │ │ ❱ 26761 "undefsafe": {                                                                                │ │
│ │  Package                undefsafe                  │ │   26762   "version": "2.0.2",                                                                         │ │
│ │  Version                2.0.2                      │ │   26763   "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.2.tgz",                   │ │
│ │  First patched version  Not fixed                  │ │   26764   "integrity": "sha1-Il9rngM3Zj4Njnz9aG/Cg2zKznY=",                                           │ │
│ │  Dependency path        nodemon 1.19.1 ->          │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                         undefsafe 2.0.2            │                                                                                                           │
│ │  Rule ID                9c6a8911-e071-4616-86db-4  │                                                                                                           │
│ │                         943f2e1df81                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ undefsafe before 2.0.3 is vulnerable to Prototype Pollution. The 'a' function could be tricked into adding or modifying properties of Object.prototype using │ │
│ │ a __proto__ payload.                                                                                                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Beispiel für SAST-Ergebnis

╭───────────────────────────────────────────── [CWE-208: Observable Timing Discrepancy] Observable Timing Discrepancy ─────────────────────────────────────────────╮
│                                                                                                                                               Violation 24 of 49 │
│ ╭─ 🔍 Details ───────────────────────────────────────╮ ╭─ 💻 Code Snippet ─────────────────────────────────────────────────────────────────────────────────────╮ │
│ │  Severity       🟠 MEDIUM                          │ │   173         " including numbers, lowercase and uppercase letters.";                                 │ │
│ │  In file        /Users/cycodemacuser/NodeGoat/app  │ │   174     return false;                                                                               │ │
│ │                 /routes/session.js                 │ │   175 }                                                                                               │ │
│ │  CWE            CWE-208                            │ │ ❱ 176 if (password !== verify) {                                                                      │ │
│ │  Subcategory    Security                           │ │   177     errors.verifyError = "Password must match";                                                 │ │
│ │  Language       js                                 │ │   178     return false;                                                                               │ │
│ │  Security Tool  Bearer (Powered by Cycode)         │ │   179 }                                                                                               │ │
│ │  Rule ID        19fbca07-a8e7-4fa6-92ac-a36d15509  │ ╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
│ │                 fa9                                │                                                                                                           │
│ ╰────────────────────────────────────────────────────╯                                                                                                           │
│ ╭─ 📝 Summary ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │
│ │ Observable Timing Discrepancy occurs when the time it takes for certain operations to complete can be measured and observed by attackers. This vulnerability │ │
│ │ is particularly concerning when operations involve sensitive information, such as password checks or secret comparisons. If attackers can analyze how long   │ │
│ │ these operations take, they might be able to deduce confidential details, putting your data at risk.                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Unternehmensspezifische benutzerdefinierte Behebungsrichtlinien

Wenn Ihr Unternehmen benutzerdefinierte Behebungsrichtlinien in der relevanten Richtlinie über das Cycode-Portal festgelegt hat, sehen Sie ein Feld für „Unternehmensrichtlinien“, das die von Ihnen hinzugefügten Behebungsrichtlinien enthält. Beachten Sie, dass dieses Feld im CLI-Tool nicht angezeigt wird, wenn Sie keine Unternehmensrichtlinien hinzugefügt haben.

Ignorieren von Scan-Ergebnissen

Ignorierregeln können hinzugefügt werden, um bestimmte Geheimniswerte, bestimmte SHA512-Werte, bestimmte Pfade und bestimmte Cycode-Geheimnis- und IaC-Regel-IDs zu ignorieren. Dadurch werden diese Werte vom Scan nicht gemeldet. Die Ignorierregeln werden lokal in der Datei ./.cycode/config.yaml geschrieben und gespeichert.

[!WARNING] Das Hinzufügen von zu ignorierenden Werten sollte sorgfältig im Hinblick auf die Werte, Pfade und Richtlinien erfolgen, um sicherzustellen, dass die Scans echte Positivbefunde erkennen.

Die folgenden Optionen sind für den Befehl cycode ignore verfügbar:

Option	Beschreibung
`--by-value TEXT`	Einen bestimmten Wert beim Scannen nach Geheimnissen ignorieren. Weitere Details finden Sie unter Ignorieren eines Geheimniswerts.
`--by-sha TEXT`	Eine bestimmte SHA512-Darstellung einer Zeichenkette beim Scannen nach Geheimnissen ignorieren. Weitere Details finden Sie unter Ignorieren eines Geheimnis-SHA-Werts.
`--by-path TEXT`	Das Scannen eines bestimmten Pfads vermeiden. Der Scan-Typ muss angegeben werden. Weitere Details finden Sie unter Ignorieren eines Pfads.
`--by-rule TEXT`	Das Scannen einer bestimmten Secret-Regel-ID/IaC-Regel-ID/SCA-Regel-ID ignorieren. Weitere Details finden Sie unter Ignorieren einer Secret- oder IaC-Regel.
`--by-package TEXT`	Das Scannen einer bestimmten Paketversion beim Ausführen eines SCA-Scans ignorieren. Erwartetes Muster - `name@version`. Weitere Details finden Sie unter Ignorieren eines Pakets.
`--by-cve TEXT`	Das Scannen einer bestimmten CVE beim Ausführen eines SCA-Scans ignorieren. Erwartetes Muster: CVE-YYYY-NNN.
`-t, --scan-type [secret\|iac\|sca\|sast]`	Den Scan angeben, den Sie ausführen möchten (`secret`/`iac`/`sca`/`sast`). Der Standardwert ist `secret`.
`-g, --global`	Eine Ignorier-Regel hinzufügen und in der globalen `.cycode`-Konfigurationsdatei aktualisieren.

Ignorieren eines Geheimniswerts

Um einen bestimmten Geheimniswert zu ignorieren, müssen Sie das Flag --by-value verwenden. Dadurch wird der angegebene Geheimniswert bei allen zukünftigen Scans ignoriert. Verwenden Sie den folgenden Befehl, um einen zu ignorierenden Geheimniswert hinzuzufügen:

cycode ignore --by-value {{secret-value}}

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren eines bestimmten Geheimniswerts wie folgt:

cycode ignore --by-value h3110w0r1d!@#$350

Ersetzen Sie im obigen Beispiel den Wert h3110w0r1d!@#$350 durch Ihren nicht maskierten Geheimniswert. Details zum Anzeigen von Geheimniswerten in den Scan-Ergebnissen finden Sie in den Cycode-Scanoptionen.

Ignorieren eines Geheimnis-SHA-Werts

Um einen bestimmten Geheimnis-SHA-Wert zu ignorieren, müssen Sie das Flag --by-sha verwenden. Dadurch wird der angegebene Geheimnis-SHA-Wert bei allen zukünftigen Scans ignoriert. Verwenden Sie den folgenden Befehl, um einen zu ignorierenden Geheimnis-SHA-Wert hinzuzufügen:

cycode ignore --by-sha {{secret-sha-value}}

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren eines bestimmten Geheimnis-SHA-Werts wie folgt:

cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0

Ersetzen Sie im obigen Beispiel den Wert a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0 durch Ihren Geheimnis-SHA-Wert.

Ignorieren eines Pfads

Um einen bestimmten Pfad für Secret-, IaC- oder SCA-Scans zu ignorieren, müssen Sie das Flag --by-path in Verbindung mit dem Flag -t, --scan-type verwenden (Sie müssen den Scan-Typ angeben). Dadurch wird der angegebene Pfad bei allen zukünftigen Scans für den angegebenen Scan-Typ ignoriert. Verwenden Sie den folgenden Befehl, um einen zu ignorierenden Pfad hinzuzufügen:

cycode ignore -t {{scan-type}} --by-path {{path}}

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren eines bestimmten Pfads für ein Geheimnis wie folgt:

cycode ignore -t secret --by-path ~/home/my-repo/config

Ersetzen Sie im obigen Beispiel den Wert ~/home/my-repo/config durch Ihren Pfadwert.

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren eines bestimmten Pfads aus IaC-Scans wie folgt:

cycode ignore -t iac --by-path ~/home/my-repo/config

Ersetzen Sie im obigen Beispiel den Wert ~/home/my-repo/config durch Ihren Pfadwert.

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren eines bestimmten Pfads aus SCA-Scans wie folgt:

cycode ignore -t sca --by-path ~/home/my-repo/config

Ersetzen Sie im obigen Beispiel den Wert ~/home/my-repo/config durch Ihren Pfadwert.

Ignorieren einer Secret-, IaC-, SCA- oder SAST-Regel

Um eine bestimmte Secret-, IaC-, SCA- oder SAST-Regel zu ignorieren, müssen Sie das Flag --by-rule in Verbindung mit dem Flag -t, --scan-type verwenden (Sie müssen den Scan-Typ angeben). Dadurch wird der angegebene Regel-ID-Wert bei allen zukünftigen Scans ignoriert. Verwenden Sie den folgenden Befehl, um einen zu ignorierenden Regel-ID-Wert hinzuzufügen:

cycode ignore -t {{scan-type}} --by-rule {{rule-ID}}

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren der bestimmten Secret-Regel-ID wie folgt:

cycode ignore -t secret --by-rule ce3a4de0-9dfc-448b-a004-c538cf8b4710

Ersetzen Sie im obigen Beispiel den Wert ce3a4de0-9dfc-448b-a004-c538cf8b4710 durch die Regel-ID, die Sie ignorieren möchten.

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren der bestimmten IaC-Regel-ID wie folgt:

cycode ignore -t iac --by-rule bdaa88e2-5e7c-46ff-ac2a-29721418c59c

Ersetzen Sie im obigen Beispiel den Wert bdaa88e2-5e7c-46ff-ac2a-29721418c59c durch die Regel-ID, die Sie ignorieren möchten.

Im Beispiel am Anfang dieses Abschnitts lautet der Befehl zum Ignorieren der bestimmten SCA-Regel-ID wie folgt:

cycode ignore -t sca --by-rule dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b

Ersetzen Sie im obigen Beispiel den Wert dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b durch die Regel-ID, die Sie ignorieren möchten.

Ignorieren eines Pakets

[!NOTE] Diese Option ist nur für SCA-Scans verfügbar.

Um ein bestimmtes Paket in den SCA-Scans zu ignorieren, müssen Sie das Flag --by-package in Verbindung mit dem Flag -t, --scan-type verwenden (Sie müssen den Scan-Typ sca angeben). Dadurch wird das angegebene Paket unter Verwendung der Formatierung {{package_name}}@{{package_version}} bei allen zukünftigen Scans ignoriert. Verwenden Sie den folgenden Befehl, um ein zu ignorierendes Paket und eine Version hinzuzufügen:

cycode ignore --scan-type sca --by-package {{package_name}}@{{package_version}}

ODER

cycode ignore -t sca --by-package {{package_name}}@{{package_version}}

Im folgenden Beispiel lautet der Befehl zum Ignorieren eines bestimmten SCA-Pakets wie folgt:

cycode ignore --scan-type sca --by-package pyyaml@5.3.1

Ersetzen Sie im obigen Beispiel pyyaml durch den Paketnamen und 5.3.1 durch die Paketversion, die Sie ignorieren möchten.

Ignorieren über eine Konfigurationsdatei

Die angewendeten Ignorier-Regeln werden in der Konfigurationsdatei namens config.yaml gespeichert. Diese Datei kann problemlos zwischen Entwicklern geteilt oder sogar in ein entferntes Git-Repository übertragen werden. Diese Dateien befinden sich immer im Ordner .cycode. Der Ordner beginnt mit einem Punkt (.) und Sie sollten die Anzeige versteckter Dateien aktivieren, um ihn zu sehen.

Pfad der Konfigurationsdateien

Standardmäßig speichern alle cycode ignore-Befehle die Ignorier-Regel im aktuellen Verzeichnis, von dem aus die CLI ausgeführt wurde.

Beispiel: Das Ausführen des CLI-Ignorier-Befehls von /Users/name/projects/backend erstellt config.yaml in /Users/name/projects/backend/.cycode

➜  backend  pwd
/Users/name/projects/backend
➜  backend  cycode ignore --by-value test-value
➜  backend  tree -a
.
└── .cycode
    └── config.yaml

2 directories, 1 file

Die zweite Option besteht darin, Ignorier-Regeln in den globalen Konfigurationsdateien zu speichern. Der Pfad der globalen Konfiguration ist ~/.cycode/config.yaml, wobei ~ Benutzers home directory, for example, /Users/name` auf macOS bedeutet.

Das Speichern im globalen Bereich kann mit dem Flag -g des Befehls cycode ignore durchgeführt werden. Zum Beispiel: cycode ignore -g --by-value test-value.

Richtiges Arbeitsverzeichnis

Es ist äußerst wichtig, den Ordner .cycode zu platzieren und die CLI von derselben Stelle aus auszuführen. Sie sollten dies doppelt überprüfen, wenn Sie mit verschiedenen Umgebungen wie CI/CD (GitHub Actions, Jenkins usw.) arbeiten.

Sie können den Ordner .cycode im Stammverzeichnis Ihres Repositorys festschreiben. In diesem Szenario müssen Sie CLI-Scans vom Repository-Stammverzeichnis aus ausführen. Wenn das nicht Ihren Anforderungen entspricht, können Sie den Ordner .cycode vorübergehend an einen beliebigen Ort kopieren und einen CLI-Scan von diesem Ordner aus durchführen.

Struktur der Ignorier-Regeln in der Konfiguration

Es ist wichtig zu verstehen, wie die CLI ignorierte Regeln speichert, um diese Konfigurationsdateien lesen oder sogar ohne CLI ändern zu können.

Die abstrakte YAML-Struktur:

exclusions:
  {scanTypeName}:
    {ignoringType}:
    - someIgnoringValue1
    - someIgnoringValue2

Mögliche Werte von scanTypeName: iac, sca, sast, secret.

Mögliche Werte von ignoringType: paths, values, rules, packages, shas, cves.

[!WARNING] Werte für "nach Wert ignorieren" werden nicht als Klartext gespeichert! Die CLI speichert stattdessen SHA256-Hashes der Werte. Sie sollten Hashes der Zeichenkette einfügen, wenn Sie die Konfigurationsdatei von Hand ändern.

Beispiel für eine echte config.yaml:

exclusions:
  iac:
    rules:
    - bdaa88e2-5e7c-46ff-ac2a-29721418c59c
  sca:
    packages:
    - pyyaml@5.3.1
  secret:
    paths:
    - /Users/name/projects/build
    rules:
    - ce3a4de0-9dfc-448b-a004-c538cf8b4710
    shas:
    - a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0
    values:
    - a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
    - 60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752

Report-Befehl

Generieren eines SBOM-Berichts

Eine Software-Stückliste (SBOM) ist ein Inventar aller Bestandteile und Softwareabhängigkeiten, die an der Entwicklung und Bereitstellung einer Anwendung beteiligt sind. Mit diesem Befehl können Sie einen SBOM-Bericht für Ihr lokales Projekt oder für Ihre Repository-URI erstellen.

Die folgenden Optionen stehen für die Verwendung mit diesem Befehl zur Verfügung:

Option	Beschreibung	Erforderlich	Standard
`-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]`	SBOM-Format	Ja
`-o, --output-format [JSON]`	Das Ausgabedateiformat angeben	Nein	json
`--output-file PATH`	Ausgabedatei	Nein	Automatisch generierter Dateiname, der im aktuellen Verzeichnis gespeichert wird
`--include-vulnerabilities`	Schwachstellen einschließen	Nein	False
`--include-dev-dependencies`	Entwicklungsabhängigkeiten einschließen	Nein	False

Die folgenden Befehle stehen für die Verwendung mit diesem Befehl zur Verfügung:

Befehl	Beschreibung
`path`	SBOM-Bericht für den im Befehl angegebenen Pfad generieren
`repository-url`	SBOM-Bericht für die im Befehl angegebene Repository-URI generieren

Repository

So erstellen Sie einen SBOM-Bericht für eine Repository-URI:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>

Zum Beispiel:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies repository_url https://github.com/cycodehq/cycode-cli.git

Lokales Projekt

So erstellen Sie einen SBOM-Bericht für einen Pfad:
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>

Zum Beispiel:
cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies path /path/to/local/project

Der Unterbefehl path unterstützt die folgenden zusätzlichen Optionen:

Option	Beschreibung
`--no-restore`	Lockfile-Wiederherstellung überspringen und nur direkte Abhängigkeiten scannen. Details finden Sie unter Lock-Restore-Option.
`--gradle-all-sub-projects`	Den Gradle-Restore-Befehl für alle Unterprojekte ausführen (vom Stammverzeichnis eines Multi-Projekt-Gradle-Builds verwenden).
`--maven-settings-file`	Nur für Maven, ermöglicht die Verwendung einer benutzerdefinierten settings.xml-Datei beim Erstellen des Abhängigkeitsbaums.

Import-Befehl

Importieren von SBOM

Eine Software-Stückliste (SBOM) ist ein Inventar aller Bestandteile und Softwareabhängigkeiten, die an der Entwicklung und Bereitstellung einer Anwendung beteiligt sind. Mit diesem Befehl können Sie eine SBOM-Datei von Ihrem Dateisystem in Cycode importieren.

Die folgenden Optionen stehen für die Verwendung mit diesem Befehl zur Verfügung:

Option	Beschreibung	Erforderlich	Standard
`-n, --name TEXT`	Anzeigename der SBOM	Ja
`-v, --vendor TEXT`	Name der Entität, die die SBOM bereitgestellt hat	Ja
`-l, --label TEXT`	Label an die SBOM anhängen	Nein
`-o, --owner TEXT`	E-Mail-Adresse des Cycode-Benutzers, der als Ansprechpartner für diese SBOM dient	Nein
`-b, --business-impact [High \| Medium \| Low]`	Geschäftsauswirkung	Nein	Mittel

Zum Beispiel:
cycode import sbom --name example-sbom --vendor cycode -label tag1 -label tag2 --owner example@cycode.com /path/to/local/project

Scan-Protokolle

Alle CLI-Scans werden in Cycode protokolliert. Die Protokolle finden Sie unter Einstellungen > CLI-Protokolle.

Syntaxhilfe

Sie können das Argument --help jederzeit zu einem beliebigen Befehl hinzufügen, um eine Hilfemeldung anzuzeigen, die verfügbare Optionen und deren Syntax anzeigt.

Um die allgemeine Hilfe anzuzeigen, geben Sie einfach den Befehl ein:

cycode --help

Um Scan-Optionen anzuzeigen, geben Sie ein:

cycode scan --help

Um die Optionen für einen bestimmten Scan-Typ anzuzeigen, geben Sie ein:

cycode scan {{option}} --help

Um beispielsweise die Optionen für einen Pfad-Scan anzuzeigen, würden Sie eingeben:

cycode scan path --help

Um die Optionen für die Ignore-Scan-Funktion anzuzeigen, verwenden Sie diesen Befehl:

cycode ignore --help

Um die Optionen für einen Bericht anzuzeigen, verwenden Sie diesen Befehl:

cycode report --help

Um die Optionen für einen bestimmten Berichtstyp anzuzeigen, geben Sie ein:

cycode scan {{option}} --help