Cycode

offiziell

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

GitHub

100

Dieses MCP ausprobierenGesponsert

Was kann man mit Cycode MCP machen?

Nach hartcodierten Geheimnissen suchen — Bitten Sie den Assistenten, cycode_secret_scan für bestimmte Datei- oder Verzeichnispfade auszuführen, um offengelegte Anmeldeinformationen zu erkennen.
Softwareabhängigkeiten prüfen — Verwenden Sie cycode_sca_scan, um Schwachstellen und Lizenzprobleme in den Paketen Ihres Projekts zu identifizieren.
Infrastrukturcode auditieren — Rufen Sie cycode_iac_scan auf, um Fehlkonfigurationen in Terraform-, CloudFormation- oder anderen IaC-Dateien zu finden.
Probleme mit der Codequalität erkennen — Führen Sie cycode_sast_scan aus, um Sicherheitsschwächen und Probleme mit der Codequalität in Quelldateien aufzudecken.
CLI-Einrichtung überprüfen — Rufen Sie cycode_status auf, um die Cycode-CLI-Version, den Authentifizierungsstatus und die Konfigurationsdetails zu überprüfen.

Dokumentation

Cycode CLI Benutzerhandbuch

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

Dieses Handbuch führt Sie durch sowohl Installation als auch Verwendung.

Inhaltsverzeichnis

Voraussetzungen
Installation
1. Cycode CLI installieren
2. Pre-Commit-Hook installieren
Cycode CLI-Befehle
Zertifikate und Proxys
MCP-Befehl
Plattform-Befehl
KI-Schutzmaßnahmen
1. Von KI-Schutzmaßnahmen gesammelte Daten
Scan-Befehl
Bericht-Befehl
1. Erzeugen 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-Geheimschlü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 schließlich die CLI. Es gibt drei Methoden, um die Cycode-Client-ID und Anmeldeinformationen (Client-Geheimnis 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 Anmeldeinformationen auf dieser Seite ein und melden Sie sich an.
Sie werden schließlich zur Seite unten 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-/Befehlszeilenbildschirm sehen Sie Folgendes, wenn Sie das Browserfenster verlassen:

Successfully logged into cycode

Verwendung des Configure-Befehls

[!HINWEIS] Wenn Sie Ihre Cycode-Client-ID und Ihr Client-Geheimnis 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-Geheimniswert 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 bereitstellen:

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

Auf Windows

Navigieren Sie über die Systemsteuerung zum Menü System:
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 Geheimschlüssel entsprechen. Wenn Sie sich über OIDC authentifizieren, fügen Sie ebenfalls 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]
```
Passen Sie die erstellte Datei für Ihre spezifischen Anforderungen an. 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-Geheimnis 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 erstellt werden soll.
status	CLI-Status anzeigen und beenden.

Zertifikate und Proxys

Standardmäßig überprüft die Cycode-CLI HTTPS-Verbindungen gegen den mit der CLI gelieferten CA-Bundle.

Wenn Ihre Organisation einen Proxy verwendet, der HTTPS-Datenverkehr untersucht, oder eine lokale Installation mit eigener CA verwendet, haben Sie zwei Optionen.

Option 1 – Verwenden Sie die bereits auf dem Rechner installierten Zertifikate. Wenn sich Ihre CA im Zertifikatsspeicher des Rechners befindet (wie es bei verwalteten Geräten üblich ist), aktivieren Sie dies:

export CYCODE_CLI_ENABLE_TRUSTSTORE=1

Die CLI überprüft dann gegen den Windows-Zertifikatsspeicher, den macOS-Schlüsselbund oder das System-CA-Verzeichnis unter Linux, und es müssen keine Zertifikatspfade konfiguriert werden.

[!IMPORTANT] Dies ist bewusst eine Opt-in-Funktion. Dem Maschinenspeicher zu vertrauen bedeutet, jedem Stammzertifikat auf diesem Rechner zu vertrauen, einschließlich solcher, die ein Administrator oder schädliche Software installiert hat. Aktivieren Sie dies nur, wenn Sie wissen, dass Sie dem Zertifikatsspeicher Ihres Rechners vertrauen.

Option 2 – Weisen Sie die CLI auf eine CA-Bundle-Datei. Funktioniert ohne Opt-in:

Umgebungsvariable	Beschreibung
`REQUESTS_CA_BUNDLE`	Pfad zu einer CA-Bundle-Datei (`.pem` oder `.crt`), der vertraut werden soll.
`CURL_CA_BUNDLE`	Alias für `REQUESTS_CA_BUNDLE`, wird berücksichtigt, wenn letztere nicht gesetzt ist.

Die beiden Optionen kombinieren sich: Mit CYCODE_CLI_ENABLE_TRUSTSTORE=1 werden Zertifikate aus REQUESTS_CA_BUNDLE zusätzlich zum Maschinenspeicher vertraut, nicht stattdessen.

[!TIP] Führen Sie einen beliebigen Befehl mit -v aus, um zu sehen, welche Vertrauensquelle verwendet wird, z. B. cycode -v status.

Hinweise:

CYCODE_CLI_ENABLE_TRUSTSTORE erfordert Python 3.10 oder neuer. Unter Python 3.9 protokolliert die CLI eine Warnung und fällt auf den gebündelten CA-Bundle zurück; verwenden Sie stattdessen REQUESTS_CA_BUNDLE oder aktualisieren Sie Python. Die eigenständigen ausführbaren Dateien und das Docker-Image enthalten bereits ein unterstütztes Python.
Unter Windows ist die CLI immer auf den Systemzertifikatsspeicher zurückgefallen, wenn weder REQUESTS_CA_BUNDLE noch CURL_CA_BUNDLE gesetzt ist. Dieses Verhalten ist unverändert.
Proxys selbst werden mit den Standard-Umgebungsvariablen HTTP_PROXY, HTTPS_PROXY und NO_PROXY konfiguriert.

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.

Der Model Context Protocol (MCP)-Befehl ermöglicht es Ihnen, einen MCP-Server zu 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 einmal 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 von der CLI aus 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 menschenlesbaren Verstoß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, anstelle eines eigenständigen mcpServers-Objekts.

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

Timeouts und benutzerdefinierte Zertifikate (Proxy-Umgebungen)

Wenn langlaufende Scans von Ihrem MCP-Client abgeschnitten werden, erhöhen Sie das Tool-Call-Timeout.

Umgebungsvariable	Beschreibung
`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 abgeschnitten werden, bevor sie abgeschlossen sind.

Hinter einem Unternehmensproxy setzen Sie die Zertifikatsvariablen im env-Block des MCP-Servers. Siehe Zertifikate und Proxys für die Optionen: entweder CYCODE_CLI_ENABLE_TRUSTSTORE=1, um die bereits auf dem Rechner vorhandenen Zertifikate zu verwenden, oder REQUESTS_CA_BUNDLE, das auf eine CA-Bundle-Datei verweist.

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

{
  "mcpServers": {
    "cycode": {
      "command": "cycode",
      "args": ["mcp"],
      "env": {
        "REQUESTS_CA_BUNDLE": "/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 Berechtigungsabfragen 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 hinzu (~/.claude/settings.json):

{
  "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 in Unteragenten.

Fehlerbehebung bei MCP

Wenn Sie Probleme mit dem MCP-Server haben, können Sie 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 über:

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 noch nicht in der Produktionsautomatisierung darauf.

Der Befehl cycode platform stellt die Lese-APIs der Cycode-Plattform als CLI-Befehle bereit. Er gruppiert Endpunkte nach Ressourcen (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.

Befehle entdecken

Da Befehle aus der Spezifikation generiert werden, ist die maßgebliche Quelle für die Verfügbarkeit --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 lesen. In dieser Beta werden nur GET-Endpunkte bereitgestellt.
Spezifikationsgesteuert. Das Hinzufügen eines neuen Endpunkts zur API macht ihn automatisch beim nächsten Cache-Refresh 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>.

AI Guardrails [BETA]

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

Von AI Guardrails gesammelte Daten

Die Überprüfung erfolgt serverseitig, daher verlässt der gescannte Inhalt die Maschine: Der Prompt-Text, der Inhalt von Dateien, die der Agent liest, und MCP-Tool-Argumente werden an Ihren Cycode-Tenant gesendet, um auf Geheimnisse überprü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 Agenten 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 das Sammeln 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`	Geheimnisse im Klartext anzeigen. 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`/`unmaintained-packages`). Der Standardwert ist alle.
`--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 von ausgeführt werden
`--maven-settings-file`	Nur für Maven: Ermöglicht die Verwendung einer benutzerdefinierten settings.xml-Datei beim Scannen nach Abhängigkeiten
`--help`	Optionen für den angegebenen Befehl anzeigen.

Befehl	Beschreibung
commit-history	Commit-Verlauf scannen oder Diff-Scanning zwischen bestimmten Commits durchführen
path	Die Dateien im Pfad scannen, 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 eine bestimmte Schweregrad-Schwelle 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 --cycode-report-Flag in Ihren Befehl aufgenommen haben, wird nach den Scan-Ergebnissen ein direkter Link zum spezifischen Bericht 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:

Option für Paket-Schwachstellen

[!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

Option für nicht gewartete Pakete

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

Um nur nach nicht gewarteten Paketen zu scannen (Pakete, deren OpenSSF-Scorecard Maintained-Prüfung niedrig ist, was wenig oder keine aktuelle Commit- und Issue-Aktivität bedeutet), fügen Sie das Argument --sca-scan unmaintained-packages nach der Option -t sca oder --scan-type sca hinzu.

[!NOTE] Ob nicht gewartete Pakete überhaupt gemeldet werden, wird durch die Richtlinie Ihrer Organisation gesteuert. Diese Option schränkt ein, was ein Scan meldet; sie kann keine Richtlinie aktivieren, die für Ihren Tenant deaktiviert ist.

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

cycode scan -t sca --sca-scan unmaintained-packages repository ~/home/git/codebase

Option für Sperrwiederherstellung

[!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-Sperrdatei 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 --no-restore-Flag.

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

Ökosystem	Manifestdatei	Generierte Sperrdatei	Aufgerufenes Tool (wenn Sperrdatei 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 Sperrdatei 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 Sperrdatei neben der Manifestdatei vorhanden ist, liest Cycode sie direkt, ohne einen Installationsbefehl auszuführen.

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

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

Option zum Stoppen bei Fehler

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

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 nützlich in CI-Pipelines, 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 bei SCA-Wiederherstellungsfehlern, --no-restore hinzufügen, um die Lockfile-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 wurden 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 dessen 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 Branch; wenn nicht gesetzt, wird der Standard-Branch gescannt

Branch-Option

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

Bezogen auf das vorherige Beispiel: Wenn Sie nur einen Branch namens dev scannen möchten, 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 alle darin enthaltenen Inhalte, 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-Verlauf-Scan

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

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

Vollständige Verlaufsprüfung: Analysiert alle Commits im Repository-Verlauf
Diff-Scan: 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. Für 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-Verlauf-Scan 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-Verlauf-Scan 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-Bereichs-Option (Diff-Scanning)

Die Commit-Bereichs-Option 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 Ihr Repository committen. Es ist nicht erforderlich, diesen Scan manuell auszuführen; konfigurieren Sie den Pre-Commit-Hook wie im Abschnitt Installation dieses Leitfadens 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 zur 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 in 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
Hardcodierte Fallbacks: Verwendet gängige Standard-Branch-Namen (origin/main, origin/master, main, master)

Festlegen eines benutzerdefinierten Standard-Branches:

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 bei .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 Pfad-Scan gegen das Unterverzeichnis cli mit aktivierter Option ausgeführt, 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 ein 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.                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Vom Unternehmen festgelegte Richtlinien zur Behebung

Wenn Ihr Unternehmen im Cycode-Portal über die entsprechende Richtlinie eigene Richtlinien zur Behebung festgelegt hat, sehen Sie ein Feld für „Company Guidelines“, das die von Ihnen hinzugefügten Richtlinien zur Behebung 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 Secret-Werte, bestimmte SHA512-Werte, bestimmte Pfade und bestimmte Cycode-Secret- und IaC-Regel-IDs zu ignorieren. Dadurch werden diese Werte beim Scan nicht mehr gemeldet. Die Ignorierregeln werden lokal in der Datei ./.cycode/config.yaml geschrieben und gespeichert.

[!WARNING] Das Hinzufügen von Werten, die ignoriert werden sollen, sollte sorgfältig im Hinblick auf 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`	Ignoriert einen bestimmten Wert beim Scannen auf Secrets. Weitere Details finden Sie unter Ignorieren eines Secret-Werts.
`--by-sha TEXT`	Ignoriert eine bestimmte SHA512-Darstellung einer Zeichenfolge beim Scannen auf Secrets. Weitere Details finden Sie unter Ignorieren eines Secret-SHA-Werts.
`--by-path TEXT`	Vermeidet das Scannen eines bestimmten Pfads. Der Scan-Typ muss angegeben werden. Weitere Details finden Sie unter Ignorieren eines Pfads.
`--by-rule TEXT`	Ignoriert das Scannen einer bestimmten Secret-Regel-ID/IaC-Regel-ID/SCA-Regel-ID. Weitere Details finden Sie unter Ignorieren einer Secret- oder IaC-Regel.
`--by-package TEXT`	Ignoriert das Scannen einer bestimmten Paketversion bei einem SCA-Scan. Erwartetes Muster: `name@version`. Weitere Details finden Sie unter Ignorieren eines Pakets.
`--by-cve TEXT`	Ignoriert das Scannen einer bestimmten CVE bei einem SCA-Scan. Erwartetes Muster: CVE-YYYY-NNN.
`-t, --scan-type [secret\|iac\|sca\|sast]`	Gibt den Scan an, der ausgeführt werden soll (`secret`/`iac`/`sca`/`sast`). Der Standardwert ist `secret`.
`-g, --global`	Fügt eine Ignorierregel hinzu und aktualisiert sie in der globalen Konfigurationsdatei `.cycode`.

Ignorieren eines Secret-Werts

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

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

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

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

Ersetzen Sie im obigen Beispiel den Wert h3110w0r1d!@#$350 durch Ihren nicht maskierten Secret-Wert. Informationen dazu, wie Sie Secret-Werte in den Scan-Ergebnissen anzeigen können, finden Sie in den Cycode-Scan-Optionen.

Ignorieren eines Secret-SHA-Werts

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

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

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

cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0

Ersetzen Sie im obigen Beispiel den Wert a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0 durch Ihren Secret-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 zusammen 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 Secret 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 zusammen 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 zusammen 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 Ignorierregeln 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 Ignorierregel im aktuellen Verzeichnis, von dem aus die CLI ausgeführt wurde.

Beispiel: Das Ausführen des CLI-Ignorierbefehls 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, Ignorierregeln in den globalen Konfigurationsdateien zu speichern. Der Pfad der globalen Konfiguration ist ~/.cycode/config.yaml, wobei ~ „users 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 am selben Ort zu platzieren und die CLI von dort 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 committen. 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 von diesem Ordner aus einen CLI-Scan durchführen.

Struktur der Ignorierregeln 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 für scanTypeName: iac, sca, sast, secret.

Mögliche Werte für 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 Zeichenfolge 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 enthaltenen Komponenten 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 diesen 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]`	Gibt das Ausgabedateiformat an	Nein	json
`--output-file PATH`	Ausgabedatei	Nein	Automatisch generierter Dateiname, gespeichert im aktuellen Verzeichnis
`--include-vulnerabilities`	Schwachstellen einbeziehen	Nein	False
`--include-dev-dependencies`	Dev-Abhängigkeiten einbeziehen	Nein	False

Die folgenden Befehle stehen für diesen Befehl zur Verfügung:

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

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	Description
`--no-restore`	Überspringen Sie die Wiederherstellung der Sperrdatei und scannen Sie nur direkte Abhängigkeiten. Siehe Lock Restore Option für Details.
`--gradle-all-sub-projects`	Führen Sie den Gradle-Restore-Befehl für alle Unterprojekte aus (verwenden Sie ihn vom Stammverzeichnis eines Multi-Projekt-Gradle-Builds).
`--maven-settings-file`	Nur für Maven: Ermöglicht die Verwendung einer benutzerdefinierten settings.xml-Datei beim Erstellen des Abhängigkeitsbaums.

Import-Befehl

Importieren einer SBOM

Eine Software-Stückliste (SBOM) ist ein Inventar aller enthaltenen Komponenten 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.

Syntax-Hilfe

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

Um 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

Zum Beispiel, um 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