Cycode MCP Server

officiel

Améliorez la sécurité de votre cycle de développement grâce à l'analyse SAST, SCA, des secrets et IaC avec Cycode.

Documentation

Guide de l'utilisateur de la CLI Cycode

L'interface en ligne de commande (CLI) Cycode est une application que vous pouvez installer localement pour analyser vos dépôts à la recherche de secrets, de mauvaises configurations d'infrastructure en tant que code, de vulnérabilités d'analyse de composition logicielle et de problèmes de test de sécurité statique des applications.

Ce guide vous accompagne à travers l'installation et l'utilisation.

Table des matières

Prérequis
Installation
1. Installer la CLI Cycode
2. Installer le hook de pré-commit
Commandes de la CLI Cycode
Commande MCP
Commande Platform
Commande Scan
Commande Report
1. Générer un rapport SBOM
Commande Import
Journaux d'analyse
Aide sur la syntaxe

Prérequis

L'application CLI Cycode nécessite Python version 3.9 ou ultérieure. La commande MCP est disponible uniquement pour Python 3.10 et supérieur. Si vous utilisez une version antérieure de Python, cette commande ne sera pas disponible.
Utilisez la commande cycode auth pour vous authentifier auprès de Cycode avec la CLI
- Vous pouvez également obtenir un ID client Cycode et une clé secrète client en suivant les étapes détaillées dans les pages Jeton de compte de service et Jeton d'accès personnel, qui contiennent des détails sur l'obtention de ces valeurs.

Installation

Les étapes d'installation suivantes sont applicables aux systèmes d'exploitation Windows et UNIX / Linux.

[!NOTE] Les étapes suivantes supposent l'utilisation de python3 et pip3 pour les commandes liées à Python ; cependant, certains systèmes peuvent utiliser les commandes python et pip, selon la configuration de votre environnement Python.

Installer la CLI Cycode

Pour installer l'application CLI Cycode sur votre machine locale, effectuez les étapes suivantes :

Ouvrez votre ligne de commande ou application terminal.
Exécutez l'une des commandes suivantes :
- Pour installer depuis PyPI :
```
pip3 install cycode
```
- Pour installer depuis Homebrew :
```
brew install cycode
```
- Pour installer depuis GitHub Releases, naviguez et téléchargez l'exécutable pour votre système d'exploitation et votre architecture, puis exécutez la commande suivante :
```
cd /path/to/downloaded/cycode-cli
chmod +x cycode
./cycode
```
Enfin, authentifiez la CLI. Il existe trois méthodes pour définir l'ID client Cycode et les informations d'identification (secret client ou jeton d'ID OIDC) :
- cycode auth (Recommandé)
- cycode configure
- Ajoutez-les à vos variables d'environnement

Utilisation de la commande Auth

[!NOTE] C'est la méthode recommandée pour configurer votre machine locale afin de vous authentifier avec la CLI Cycode.

Tapez la commande suivante dans votre fenêtre de terminal/ligne de commande :

cycode auth
Une fenêtre de navigateur apparaîtra, vous demandant de vous connecter à Cycode (comme illustré ci-dessous) :
Entrez vos identifiants de connexion sur cette page et connectez-vous.
Vous serez finalement redirigé vers la page ci-dessous, où il vous sera demandé de choisir le groupe d'affaires que vous souhaitez autoriser avec Cycode (le cas échéant) :

[!NOTE] Ce sera la méthode par défaut pour l'authentification avec la CLI Cycode.
Cliquez sur le bouton Autoriser pour autoriser la CLI Cycode sur le groupe d'affaires sélectionné.
Une fois terminé, vous verrez l'écran suivant si la sélection a réussi :
Dans l'écran du terminal/de la ligne de commande, vous verrez ce qui suit en quittant la fenêtre du navigateur :

Successfully logged into cycode

Utilisation de la commande Configure

[!NOTE] Si vous avez déjà configuré votre ID client Cycode et votre secret client via les variables d'environnement Linux ou Windows, ces informations d'identification prévaudront sur cette méthode.

Tapez la commande suivante dans votre fenêtre de terminal/ligne de commande :
```
cycode configure
```
Entrez la valeur de votre URL d'API Cycode (vous pouvez laisser vide pour utiliser la valeur par défaut).

Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
Entrez la valeur de votre URL d'application Cycode (vous pouvez laisser vide pour utiliser la valeur par défaut).

Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
Entrez la valeur de votre ID client Cycode.

Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
Entrez la valeur de votre secret client Cycode (ignorez si vous prévoyez d'utiliser un jeton d'ID OIDC).

Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
Entrez la valeur de votre jeton d'ID OIDC Cycode (facultatif).

Cycode ID Token []: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
Si les valeurs ont été saisies avec succès, vous verrez le message suivant :

Successfully configured CLI credentials!

ou/et

Successfully configured Cycode URLs!

Si vous allez dans le dossier .cycode sous votre dossier utilisateur, vous trouverez que ces informations d'identification ont été créées et placées dans le fichier credentials.yaml de ce dossier. Les URL ont été placées dans le fichier config.yaml de ce dossier.

Ajouter aux variables d'environnement

Sur Unix/Linux :

export CYCODE_CLIENT_ID={your Cycode ID}

export CYCODE_CLIENT_SECRET={your Cycode Secret Key}

Si votre organisation utilise l'authentification OIDC, vous pouvez fournir le jeton d'ID à la place (ou en plus) :

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

Sur Windows

Depuis le Panneau de configuration, naviguez vers le menu Système :
Ensuite, cliquez sur Paramètres système avancés :
Dans la fenêtre Propriétés système qui s'ouvre, cliquez sur le bouton Variables d'environnement :
Créez les variables CYCODE_CLIENT_ID et CYCODE_CLIENT_SECRET avec des valeurs correspondant respectivement à votre ID et votre clé secrète. Si vous vous authentifiez via OIDC, ajoutez également CYCODE_ID_TOKEN avec la valeur de votre jeton d'ID OIDC :
Insérez le cycode.exe dans le chemin pour terminer l'installation.

Installer le hook de pré-commit

Les hooks de pré-commit et de pré-push de Cycode peuvent être configurés dans votre dépôt local afin que l'application CLI Cycode identifie automatiquement tout problème avec votre code avant que vous ne le commitiez ou ne le poussiez vers votre base de code.

[!NOTE] Les hooks de pré-commit et de pré-push ne sont pas disponibles pour les analyses IaC.

Effectuez les étapes suivantes pour installer le hook de pré-commit :

Installation du hook de pré-commit

Installez le framework pre-commit (Python 3.9 ou supérieur doit être installé) :
```
pip3 install pre-commit
```
Naviguez vers le répertoire supérieur du dépôt Git local que vous souhaitez configurer.
Créez un nouveau fichier YAML nommé .pre-commit-config.yaml (incluez le début .) dans le répertoire supérieur du dépôt contenant ce qui suit :
```
repos:
  - repo: https://github.com/cycodehq/cycode-cli
    rev: v3.5.0
    hooks:
      - id: cycode
        stages: [pre-commit]
```
Modifiez le fichier créé selon vos besoins spécifiques. Utilisez l'ID de hook cycode pour activer l'analyse des secrets. Utilisez l'ID de hook cycode-sca pour activer l'analyse SCA. Utilisez l'ID de hook cycode-sast pour activer l'analyse SAST. Si vous souhaitez activer tous les types d'analyse, utilisez cette configuration :
```
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]
```
Installez le hook de Cycode :
```
pre-commit install
```
Une installation réussie du hook affichera le message : Pre-commit installed at .git/hooks/pre-commit.
Maintenez le hook de pré-commit à jour :
```
pre-commit autoupdate
```
Cela mettra automatiquement à jour rev dans .pre-commit-config.yaml vers la dernière version disponible de la CLI Cycode.

[!NOTE] Le déclenchement se produit lors de la commande git commit. Le hook se déclenche uniquement sur les fichiers qui sont stagés pour le commit.

Installation du hook de pré-push

Pour installer le hook de pré-push en plus ou à la place du hook de pré-commit :

Ajoutez les hooks de pré-push à votre fichier .pre-commit-config.yaml :

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

Installez le hook de pré-push :

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

Pour les hooks de pré-commit et de pré-push, utilisez :

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

[!NOTE] Les hooks de pré-push se déclenchent lors de la commande git push et analysent uniquement les commits sur le point d'être poussés.

Commandes de la CLI Cycode

Voici les options et commandes disponibles avec l'application CLI Cycode :

Option	Description
`-v`, `--verbose`	Afficher les journaux détaillés.
`--no-progress-meter`	Ne pas afficher la barre de progression.
`--no-update-notifier`	Ne pas vérifier les mises à jour de la CLI.
`-o`, `--output [rich\|text\|json\|table]`	Spécifier le type de sortie. La valeur par défaut est `rich`.
`--client-id TEXT`	Spécifier un ID client Cycode pour cette exécution d'analyse spécifique.
`--client-secret TEXT`	Spécifier un secret client Cycode pour cette exécution d'analyse spécifique.
`--id-token TEXT`	Spécifier un jeton d'ID OIDC Cycode pour cette exécution d'analyse spécifique.
`--install-completion`	Installer la complétion pour le shell actuel.
`--show-completion [bash\|zsh\|fish\|powershell\|pwsh]`	Afficher la complétion pour le shell spécifié, pour la copier ou personnaliser l'installation.
`-h`, `--help`	Afficher les options pour une commande donnée.
Commande	Description
-------------------------------------------	----------------------------------------------------------------------------------------------------------------------------------------------
auth	Authentifiez votre machine pour associer la CLI à votre compte Cycode.
configure	Commande initiale pour configurer l'authentification de votre client CLI.
ignore	Ignorez une valeur, un chemin ou un ID de règle spécifique.
mcp	Démarrez le serveur Model Context Protocol (MCP) pour permettre l'intégration de l'IA avec les capacités de scan Cycode.
scan	Scannez le contenu à la recherche de violations Secrets/IaC/SCA/SAST. Vous devrez spécifier le type de scan à effectuer : commit-history/path/repository/etc.
report	Générez un rapport. Vous devrez spécifier le type de rapport à effectuer, comme SBOM.
status	Affichez le statut de la CLI et quittez.

Commande MCP [EXPÉRIMENTAL]

[!AVERTISSEMENT] La commande MCP est disponible uniquement pour Python 3.10 et versions ultérieures. Si vous utilisez une version antérieure de Python, cette commande ne sera pas disponible.

La commande Model Context Protocol (MCP) vous permet de démarrer un serveur MCP qui expose les capacités de scan de Cycode aux systèmes et applications d'IA. Cela permet aux modèles d'IA d'interagir avec les outils CLI Cycode via un protocole standardisé.

[!ASTUCE] Pour une expérience optimale, installez Cycode CLI globalement sur votre système en utilisant pip install cycode ou brew install cycode, puis authentifiez-vous une fois avec cycode auth. Après l'installation et l'authentification globales, vous n'aurez pas besoin de configurer les variables d'environnement CYCODE_CLIENT_ID et CYCODE_CLIENT_SECRET dans vos fichiers de configuration MCP.

Démarrage du serveur MCP

Pour démarrer le serveur MCP, utilisez la commande suivante :

cycode mcp

Par défaut, cela démarre le serveur en utilisant le transport stdio, ce qui convient aux intégrations locales et aux applications d'IA qui peuvent lancer des sous-processus.

Options disponibles

Option	Description
`-t, --transport`	Type de transport pour le serveur MCP : `stdio`, `sse`, ou `streamable-http` (par défaut : `stdio`)
`-H, --host`	Adresse de l'hôte sur lequel lier le serveur (utilisé uniquement pour les transports non stdio) (par défaut : `127.0.0.1`)
`-p, --port`	Numéro de port sur lequel lier le serveur (utilisé uniquement pour les transports non stdio) (par défaut : `8000`)
`--help`	Afficher le message d'aide et les options disponibles

Outils MCP

Le serveur MCP fournit les outils suivants que les systèmes d'IA peuvent utiliser :

Nom de l'outil	Description
`cycode_secret_scan`	Scanner les secrets codés en dur
`cycode_sca_scan`	Scanner pour l'analyse de composition logicielle (SCA) - vulnérabilités et problèmes de licence
`cycode_iac_scan`	Scanner pour les mauvaises configurations de l'infrastructure en tant que code (IaC)
`cycode_sast_scan`	Scanner pour les tests de sécurité des applications statiques (SAST) - qualité du code et failles de sécurité
`cycode_status`	Obtenir la version de la CLI Cycode, le statut d'authentification et les informations de configuration

Chaque outil de scan accepte deux modes de saisie mutuellement exclusifs :

paths (préféré) — un ou plusieurs chemins de fichiers ou de répertoires existant sur le disque. Les répertoires sont scannés récursivement. Le moteur Cycode gère la découverte et le filtrage des fichiers, tout comme le fait cycode scan -t <type> path ./src depuis la CLI.
files (solution de repli) — un dictionnaire associant les chemins de fichiers à leur contenu complet sous forme de chaînes. Utilisez ceci uniquement lorsque les fichiers ne sont pas disponibles sur le disque (par exemple, des modifications en mémoire non encore sauvegardées).

[!ASTUCE] Utilisez paths chaque fois que possible. Passer des fichiers volumineux (comme package-lock.json) en tant que contenu en ligne peut dépasser les limites de jetons et ralentir le client IA. Avec paths, le moteur Cycode lit les fichiers directement depuis le disque.

Tous les outils de scan renvoient un objet JSON qui inclut un champ "summary" avec un nombre de violations lisible par l'homme (par exemple, "Cycode found 3 violations: 1 CRITICAL, 2 HIGH.") en plus du tableau complet "detections".

Exemples d'utilisation

Exemples de commandes de base

Démarrez le serveur MCP avec les paramètres par défaut (transport stdio) :

cycode mcp

Démarrez le serveur MCP avec un transport stdio explicite :

cycode mcp -t stdio

Démarrez le serveur MCP avec le transport Server-Sent Events (SSE) :

cycode mcp -t sse -p 8080

Démarrez le serveur MCP avec le transport HTTP streamable sur un hôte et un port personnalisés :

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

Apprenez-en plus sur les types de transport MCP dans la Spécification du protocole MCP – Transports.

Exemples de configuration

Utilisation de MCP avec Cursor/VS Code/Claude Desktop/etc (mcp.json)

[!REMARQUE] Pour les environnements Cycode UE, assurez-vous de définir les valeurs appropriées pour CYCODE_API_URL et CYCODE_APP_URL dans les variables d'environnement (par exemple, https://api.eu.cycode.com et https://app.eu.cycode.com).

Suivez ce guide pour configurer le serveur MCP dans votre VS Code/GitHub Copilot. Gardez à l'esprit que dans settings.json, il y a un objet mcp contenant un sous-objet servers imbriqué, plutôt qu'un objet mcpServers autonome.

Pour le transport stdio (exécution directe) :

{
  "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"
      }
    }
  }
}

Pour le transport stdio avec l'installation pipx :

{
  "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"
      }
    }
  }
}

Pour le transport stdio avec l'installation uvx :

{
  "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"
      }
    }
  }
}

Pour le transport SSE (Server-Sent Events) :

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

Pour le transport SSE sur un port personnalisé :

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

Pour le transport HTTP streamable :

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

Exécution du serveur MCP en arrière-plan

Pour le transport SSE (démarrez d'abord le serveur, puis configurez le client) :

# 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"
    }
  }
}

Pour le transport HTTP streamable :

# 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"
    }
  }
}

Configuration avancée

Certificats personnalisés et délais d'attente (environnements proxy)

Si votre organisation utilise un proxy d'entreprise ou un bundle CA personnalisé pour l'inspection HTTPS, vous devez indiquer à la CLI Cycode (et à la pile TLS Python sous-jacente) où trouver le bundle de certificats de confiance. Vous pouvez également augmenter le délai d'attente d'appel de l'outil MCP si les scans sont interrompus prématurément.

Variable d'environnement	Description
`REQUESTS_CA_BUNDLE`	Chemin vers un fichier de bundle CA personnalisé (`.pem` ou `.crt`). Utilisé par la bibliothèque `requests` pour tous les appels HTTPS effectués par la CLI Cycode.
`SSL_CERT_FILE`	Chemin vers un fichier de bundle CA personnalisé. Utilisé par le module bas niveau `ssl` de Python. Définissez-le en même temps que `REQUESTS_CA_BUNDLE` pour une couverture complète.
`MCP_TOOL_TIMEOUT`	Délai d'attente (en secondes) que les clients MCP tels que Claude et GitHub Copilot attendent pour qu'un appel d'outil se termine. Augmentez cette valeur si les scans de longue durée sont interrompus avant leur fin.

[!ASTUCE] Définissez à la fois REQUESTS_CA_BUNDLE et SSL_CERT_FILE sur le même chemin de bundle CA. REQUESTS_CA_BUNDLE couvre la couche HTTP ; SSL_CERT_FILE couvre la couche TLS de niveau inférieur. N'en utiliser qu'un seul peut encore causer des erreurs de certificat dans certains environnements.

Exemple de configuration mcp.json avec des certificats personnalisés et un délai d'attente plus long :

{
  "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"
      }
    }
  }
}

[!REMARQUE] Le serveur MCP nécessite une authentification correcte de la CLI Cycode pour fonctionner. Assurez-vous de vous être authentifié en utilisant cycode auth ou d'avoir configuré vos informations d'identification avant de démarrer le serveur MCP.

Pré-autorisation des outils pour les sous-agents (Claude Code)

Lorsque Claude Code délègue du travail à des sous-agents en arrière-plan (par exemple, pour exécuter des scans en parallèle), ces sous-agents ne peuvent pas afficher d'invites de permission interactives. Si les outils Cycode n'ont pas été pré-approuvés, les scans échoueront silencieusement dans les contextes de sous-agents.

Pour pré-autoriser les outils MCP Cycode afin qu'ils fonctionnent dans tous les contextes, y compris les sous-agents, ajoutez-les à la liste allowedTools dans vos paramètres Claude Code (~/.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"
  ]
}

Une fois ajoutés, Claude Code ne demandera plus d'approbation lorsque ces outils seront appelés, et ils fonctionneront correctement à l'intérieur des sous-agents.

Dépannage MCP

Si vous rencontrez des problèmes avec le serveur MCP, vous pouvez activer la journalisation de débogage pour obtenir des informations plus détaillées sur ce qui se passe. Il y a deux façons d'activer la journalisation de débogage :

En utilisant le drapeau -v ou --verbose :

cycode -v mcp

En utilisant la variable d'environnement CYCODE_CLI_VERBOSE :

CYCODE_CLI_VERBOSE=1 cycode mcp

Les journaux de débogage afficheront des informations détaillées sur :

Le démarrage et la configuration du serveur
Les tentatives de connexion et leur statut
L'exécution des outils et les résultats
Toute erreur ou avertissement survenant

Ces informations peuvent être utiles pour :

Diagnostiquer les problèmes de connexion
Comprendre pourquoi certains outils ne fonctionnent pas
Identifier les problèmes d'authentification
Déboguer les problèmes spécifiques au transport

Configuration MCP

Commande Platform [BÊTA]

[!AVERTISSEMENT] La commande platform est en bêta. Les commandes, arguments et formats de sortie sont générés dynamiquement à partir de la spécification de l'API Cycode et peuvent changer entre les versions sans préavis. Ne vous y fiez pas encore pour l'automatisation en production.

La commande cycode platform expose les API de lecture de la plateforme Cycode en tant que commandes CLI. Elle regroupe les points de terminaison par ressource (par exemple, projects, violations, workflows) et transforme les paramètres de chaque point de terminaison en arguments CLI typés et en drapeaux --option.

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

La spécification OpenAPI est récupérée depuis l'API Cycode lors de la première utilisation et mise en cache à ~/.cycode/openapi-spec.json pendant 24 heures. Les commandes non liées (cycode scan, cycode status, etc.) ne déclenchent pas de récupération.

[!REMARQUE] Vous devez être authentifié (cycode auth ou variables d'environnement CYCODE_CLIENT_ID / CYCODE_CLIENT_SECRET) pour que cycode platform puisse découvrir et exécuter des commandes. Les autres commandes CLI Cycode fonctionnent sans authentification.

Découverte des commandes

Parce que les commandes sont générées à partir de la spécification, la source de vérité pour ce qui est disponible est --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

Exemples Platform

# 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

Toute la sortie est en JSON par défaut — redirigez-la via jq pour un filtrage ad-hoc :

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

Notes et limitations de Platform

Lecture seule pour le moment. Seuls les points de terminaison GET sont exposés dans cette bêta.
Piloté par la spécification. L'ajout d'un nouveau point de terminaison à l'API le rend automatiquement disponible lors de la prochaine actualisation du cache.
Pas de spécification intégrée. La première invocation de cycode platform après l'installation (ou après l'expiration du cache de 24 heures) effectue une récupération réseau. Sur les connexions lentes, ce premier appel peut prendre quelques secondes ; les appels suivants sont quasi instantanés jusqu'à l'expiration du cache.
Remplacer la durée de vie du cache avec CYCODE_SPEC_CACHE_TTL=<seconds>.

Commande Scan

Exécution d'un scan

L'application CLI Cycode propose plusieurs types de scans afin que vous puissiez choisir l'option qui correspond le mieux à votre cas. Voici les options et commandes actuellement disponibles :

Option	Description
`-t, --scan-type [secret\|iac\|sca\|sast]`	Spécifiez le scan que vous souhaitez exécuter (`secret`/`iac`/`sca`/`sast`), la valeur par défaut est `secret`.
`--show-secret BOOLEAN`	Afficher les secrets en texte clair. Voir la section Afficher/Masquer les secrets pour plus de détails.
`--soft-fail BOOLEAN`	Exécuter le scan sans échec, toujours renvoyer un code de statut sans erreur. Voir la section Échec souple pour plus de détails.
`--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]`	Afficher uniquement les violations au niveau spécifié ou supérieur.
`--sca-scan`	Spécifiez le scan SCA que vous souhaitez exécuter (`package-vulnerabilities`/`license-compliance`). La valeur par défaut est les deux.
`--monitor`	Lorsque spécifié, les résultats du scan seront enregistrés dans Cycode.
`--cycode-report`	Afficher un lien vers le rapport de scan dans la plateforme Cycode dans la sortie console.
`--no-restore`	Lorsque spécifié, Cycode n’exécutera pas la commande de restauration. Cela analysera UNIQUEMENT les dépendances directes !
`--stop-on-error`	Abandonner le scan si une collecte de fichiers ou une restauration de dépendances échoue, au lieu d’ignorer le fichier en échec et de continuer.
`--gradle-all-sub-projects`	Exécuter la commande de restauration Gradle pour tous les sous-projets. Cela doit être exécuté depuis
`--maven-settings-file`	Pour Maven uniquement, permet d’utiliser un fichier settings.xml personnalisé lors de l’analyse des dépendances
`--help`	Afficher les options pour la commande donnée.

Commande	Description
commit-history	Analyser l’historique des commits ou effectuer un scan différentiel entre des commits spécifiques
path	Analyser les fichiers dans le chemin fourni dans la commande
pre-commit	Utilisez cette commande pour analyser le contenu qui n’a pas encore été commité
repository	Analyser le dépôt git, y compris son historique

Options

Option de sévérité

Pour limiter les résultats du scan à un seuil de sévérité spécifique, l’argument --severity-threshold peut être ajouté à la commande de scan.

Par exemple, la commande suivante analysera le dépôt à la recherche de violations de politique ayant une sévérité Moyenne ou supérieure :

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

Option de surveillance

[!NOTE] Cette option est uniquement disponible pour les scans SCA.

Pour envoyer les résultats de scan liés aux politiques SCA trouvées lors d’un scan de type SCA vers Cycode, ajoutez l’argument --monitor à la commande de scan.

Par exemple, la commande suivante analysera le dépôt à la recherche de violations de politique SCA et les enverra vers la plateforme Cycode :

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

Option de rapport Cycode

Pour chaque scan effectué à l’aide de la CLI Cycode, un rapport est automatiquement généré et ses résultats sont envoyés à Cycode. Ces résultats sont liés aux politiques pertinentes (par exemple, les politiques SCA pour les scans de dépôt) au sein de la plateforme Cycode.

Pour que l’URL directe vers ce rapport Cycode soit affichée dans votre sortie CLI une fois le scan terminé, ajoutez l’argument --cycode-report à votre commande de scan.

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

Tous les résultats de scan de la CLI apparaîtront dans la section Journaux CLI de Cycode. Si vous avez inclus le drapeau --cycode-report dans votre commande, un lien direct vers le rapport spécifique sera affiché dans votre terminal après les résultats du scan.

[!WARNING] Vous devez avoir le rôle owner ou admin dans Cycode pour voir cette page.

cli-report

La page du rapport ressemblera à ceci :

Option de vulnérabilités des paquets

[!NOTE] Cette option est uniquement disponible pour les scans SCA.

Pour analyser une vulnérabilité spécifique de paquet de votre dépôt local, ajoutez l’argument --sca-scan package-vulnerabilities après l’option -t sca ou --scan-type sca.

Dans l’exemple précédent, si vous vouliez exécuter uniquement un scan SCA sur les vulnérabilités des paquets, vous pourriez exécuter ce qui suit :

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

Option de conformité des licences

[!NOTE] Cette option est uniquement disponible pour les scans SCA.

Pour analyser une branche spécifique de votre dépôt local, ajoutez l’argument --sca-scan license-compliance suivi du nom de la branche que vous souhaitez analyser.

Dans l’exemple précédent, si vous vouliez analyser uniquement une branche nommée dev, vous pourriez exécuter ce qui suit :

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

Option de restauration du verrou

[!NOTE] Cette option est uniquement disponible pour les scans SCA.

Lors de l’exécution d’un scan SCA, la CLI Cycode tente automatiquement de restaurer (générer) un fichier de verrouillage des dépendances pour chaque fichier manifeste pris en charge qu’elle trouve. Cela permet d’analyser les dépendances transitives, et pas seulement celles listées directement dans le manifeste. Pour ignorer cette étape et analyser uniquement les dépendances directes, utilisez le drapeau --no-restore.

Les écosystèmes suivants prennent en charge la restauration automatique du fichier de verrouillage :

Écosystème	Fichier manifeste	Fichier de verrouillage généré	Outil invoqué (lorsque le fichier de verrouillage est absent)
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`	(lit uniquement le fichier de verrouillage existant)
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`
Pipenv	`Pipfile`	`Pipfile.lock`	`pipenv lock`
PHP Composer	`composer.json`	`composer.lock`	`composer update --no-cache --no-install --no-scripts --ignore-platform-reqs`

Si un fichier de verrouillage existe déjà à côté du manifeste, Cycode le lit directement sans exécuter de commande d’installation.

Prérequis SBT : Le plugin sbt-dependency-lock doit être installé. Ajoutez la ligne suivante à project/plugins.sbt :

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

Option Arrêt en cas d’erreur

Par défaut, Cycode continue l’analyse même si un fichier ne peut pas être lu (par exemple, en raison d’une erreur de permission) ou si un fichier de verrouillage des dépendances ne peut pas être généré lors d’un scan SCA. L’élément en échec est ignoré avec un avertissement et le scan se poursuit avec les fichiers restants.

Utilisez --stop-on-error pour modifier ce comportement : le scan s’interrompt immédiatement au premier échec de ce type et signale l’erreur.

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

Ceci est utile dans les pipelines CI où un échec silencieux produirait un résultat de scan incomplet. Lorsque --stop-on-error est déclenché, vous pouvez soit corriger le problème sous-jacent, soit, pour les échecs de restauration SCA spécifiquement, ajouter --no-restore pour ignorer la génération du fichier de verrouillage et analyser uniquement les dépendances directes.

Lorsque --stop-on-error est utilisé, la CLI distingue les erreurs de scan des violations de politique via les codes de sortie :

Code de sortie	Signification
`0`	Scan terminé sans violations
`1`	Scan terminé et des violations ont été trouvées
`2`	Scan interrompu en raison d’une erreur (uniquement lorsque `--stop-on-error` est défini)

Scan de dépôt

Un scan de dépôt examine l’intégralité d’un dépôt local à la recherche de secrets exposés ou de mauvaises configurations non sécurisées. Ce type de scan plus holistique examine tout : l’état actuel de votre dépôt et son historique de commits. Il recherchera non seulement les secrets actuellement exposés dans le dépôt, mais aussi les secrets précédemment supprimés.

Pour exécuter un scan complet du dépôt, exécutez ce qui suit :

cycode scan repository {{path}}

Par exemple, si vous vouliez analyser un dépôt stocké dans ~/home/git/codebase, vous pourriez exécuter ce qui suit :

cycode scan repository ~/home/git/codebase

L’option suivante est disponible pour une utilisation avec cette commande :

Option	Description
`-b, --branch TEXT`	Branche à analyser, si non définie, analyse la branche par défaut

Option de branche

Pour analyser une branche spécifique de votre dépôt local, ajoutez l’argument -b (alternativement, --branch) suivi du nom de la branche que vous souhaitez analyser.

Étant donné l’exemple précédent, si vous vouliez analyser uniquement une branche nommée dev, vous pourriez exécuter ce qui suit :

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

Scan de chemin

Un scan de chemin examine un répertoire local spécifique et tout son contenu, au lieu de se concentrer uniquement sur un dépôt GIT.

Pour exécuter un scan de répertoire, exécutez ce qui suit :

cycode scan path {{path}}

Par exemple, considérons un scénario dans lequel vous voulez analyser le répertoire situé à ~/home/git/codebase. Vous pourriez alors exécuter ce qui suit :

cycode scan path ~/home/git/codebase

Scan de plan Terraform

La CLI Cycode prend en charge l’analyse de plan Terraform (prise en charge de Terraform 0.12 et versions ultérieures)

Le fichier de plan Terraform doit être au format JSON (ayant l’extension .json)

Si vous avez juste un fichier de configuration, vous pouvez générer un plan en procédant comme suit :

Initialisez un répertoire de travail contenant le fichier de configuration Terraform :

terraform init
Créez le plan d’exécution Terraform et enregistrez la sortie binaire :

terraform plan -out={tfplan_output}
Convertissez le fichier de sortie binaire en JSON lisible :

terraform show -json {tfplan_output} > {tfplan}.json
Analysez votre {tfplan}.json avec la CLI Cycode :

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

Scan de l’historique des commits

[!NOTE] Le scan de l’historique des commits n’est pas disponible pour les scans IaC.

La commande de scan de l’historique des commits offre deux capacités principales :

Analyse complète de l’historique : Analyser tous les commits dans l’historique du dépôt
Scan différentiel : Analyser uniquement les changements entre des commits spécifiques

L’analyse des secrets peut analyser tous les commits dans l’historique du dépôt car les secrets introduits puis supprimés peuvent toujours être divulgués ou exposés. Pour les scans SCA et SAST, la commande d’historique des commits se concentre sur l’analyse des différences/changements entre les commits, ce qui la rend parfaite pour les revues de pull request et l’analyse incrémentielle.

Un scan de l’historique des commits examine l’historique des commits de votre dépôt Git et peut être utilisé à la fois pour une analyse historique complète et un scan différentiel ciblé de changements spécifiques.

Pour exécuter un scan de l’historique des commits, exécutez ce qui suit :

cycode scan commit-history {{path}}

Par exemple, considérons un scénario dans lequel vous voulez analyser l’historique des commits d’un dépôt stocké dans ~/home/git/codebase. Vous pourriez alors exécuter ce qui suit :

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

Les options suivantes sont disponibles pour une utilisation avec cette commande :

Option	Description
`-r, --commit-range TEXT`	Analyser une plage de commits dans ce dépôt git. Par défaut, Cycode analyse tout l’historique des commits (exemple : HEAD~1)

Option Plage de commits (Analyse différentielle)

L’option de plage de commits active l’analyse différentielle – analyser uniquement les modifications entre des commits spécifiques au lieu de tout l’historique du dépôt. C’est particulièrement utile pour :

Validation de pull request : Analyser uniquement les modifications introduites dans une PR
Analyse CI/CD incrémentale : Se concentrer sur les changements récents plutôt que sur l’ensemble du code source
Revue de branche de fonctionnalité : Comparer les modifications par rapport à la branche main/master
Optimisation des performances : Analyses plus rapides en limitant la portée aux changements pertinents

Syntaxe de la plage de commits

L’option --commit-range (-r) prend en charge la syntaxe standard de révision Git :

Syntaxe	Description	Exemple
`commit1..commit2`	Modifications de commit1 à commit2	`abc123..def456`
`commit1...commit2`	Modifications dans commit2 absentes de commit1	`main...feature-branch`
`commit`	Modifications du commit jusqu’à HEAD	`HEAD~1`
`branch1..branch2`	Modifications de branche1 à branche2	`main..feature-branch`

Exemples d’analyse différentielle

Analyser les modifications du dernier commit :

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

Analyser les modifications entre deux commits spécifiques :

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

Analyser les modifications de votre branche de fonctionnalité par rapport à main :

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

Analyser les modifications entre main et une branche de fonctionnalité :

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

Analyser toutes les modifications des 3 derniers commits :

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

[!ASTUCE] Pour les pipelines CI/CD, vous pouvez utiliser des variables d’environnement comme ${{ github.event.pull_request.base.sha }}..${{ github.sha }} (GitHub Actions) ou $CI_MERGE_REQUEST_TARGET_BRANCH_SHA..$CI_COMMIT_SHA (GitLab CI) pour analyser uniquement les modifications de PR/MR.

Analyse pré-commit

Une analyse pré-commit identifie automatiquement les problèmes avant que vous ne validiez les modifications dans votre dépôt. Il n’est pas nécessaire d’exécuter cette analyse manuellement ; configurez le hook de pré-commit comme détaillé dans la section Installation de ce guide.

Après avoir installé le hook de pré-commit, vous pouvez occasionnellement souhaiter ignorer l’analyse lors d’un commit spécifique. Pour ce faire, ajoutez ce qui suit à votre commande git afin d’ignorer l’analyse pour un seul commit :

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

Analyse pré-push

Une analyse pré-push identifie automatiquement les problèmes avant que vous ne poussiez les modifications vers le dépôt distant. Ce hook s’exécute côté client et analyse uniquement les commits sur le point d’être poussés, ce qui le rend efficace pour détecter les problèmes avant qu’ils n’atteignent le dépôt distant.

[!REMARQUE] Le hook pré-push n’est pas disponible pour les analyses IaC.

Le hook pré-push s’intègre au framework pre-commit et peut être configuré pour s’exécuter avant toute opération git push.

Installation du hook pré-push

Pour configurer le hook pré-push avec le framework pre-commit :

Installez le framework pre-commit (s’il n’est pas déjà installé) :
```
pip3 install pre-commit
```

Créez ou mettez à jour votre fichier .pre-commit-config.yaml pour inclure les hooks pré-push :

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

Pour plusieurs types d’analyse, utilisez cette configuration :

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]

Installez le hook pré-push :
```
pre-commit install --hook-type pre-push
```
Une installation réussie produira le message : Pre-push installed at .git/hooks/pre-push.
Maintenez le hook pré-push à jour :
```
pre-commit autoupdate
```

Fonctionnement de l’analyse pré-push

Le hook pré-push :

Reçoit des informations sur les commits en cours de poussée
Calcule la plage de commits appropriée à analyser
Pour les nouvelles branches : analyse tous les commits depuis la base de fusion avec la branche par défaut
Pour les branches existantes : analyse uniquement les nouveaux commits depuis le dernier push
Exécute la même analyse complète que les autres modes d’analyse Cycode

Détection intelligente de la branche par défaut

Le hook pré-push détecte intelligemment la branche par défaut pour le calcul de la base de fusion en utilisant cet ordre de priorité :

Variable d’environnement : CYCODE_DEFAULT_BRANCH - permet une substitution manuelle
HEAD distant Git : Utilise git symbolic-ref refs/remotes/origin/HEAD pour détecter la branche par défaut distante réelle
Info distante Git : Se replie sur git remote show origin si symbolic-ref échoue
Solutions de repli codées en dur : Utilise les noms de branche par défaut courants (origin/main, origin/master, main, master)

Définition d’une branche par défaut personnalisée :

export CYCODE_DEFAULT_BRANCH=origin/develop

Cette détection intelligente garantit que le hook pré-push fonctionne correctement, que votre dépôt utilise main, master, develop ou tout autre nom de branche par défaut.

Ignorer les analyses pré-push

Pour ignorer l’analyse pré-push pour une opération push spécifique, utilisez :

SKIP=cycode-pre-push git push

Ou pour ignorer tous les hooks pré-push :

git push --no-verify

[!ASTUCE] Le hook pré-push est déclenché par la commande git push et analyse uniquement les commits sur le point d’être poussés, ce qui le rend plus efficace que l’analyse de l’ensemble du dépôt.

Exclure des chemins des analyses

Vous pouvez utiliser un fichier .cycodeignore pour indiquer à la CLI Cycode quels fichiers et répertoires exclure des analyses. Il fonctionne exactement comme un fichier .gitignore. Cela vous aide à concentrer les analyses sur votre code pertinent et à empêcher certains chemins de déclencher des violations localement.

Comment ça marche

Créez un fichier nommé .cycodeignore dans votre dossier de travail.
Listez les fichiers et répertoires que vous souhaitez exclure, en utilisant les mêmes motifs que .gitignore.
Placez ce fichier dans le répertoire où vous prévoyez d’exécuter la commande d’analyse Cycode.

[!AVERTISSEMENT]

Fichiers invalides : Si le fichier .cycodeignore contient une erreur de syntaxe, l’analyse CLI échouera et retournera une erreur.

Ignorer des chemins vs violations : Ce fichier sert à exclure des chemins. Il est différent de la capacité de la CLI à ignorer des violations spécifiques (par exemple, en utilisant le drapeau --ignore-violation).

Scanners pris en charge

SAST
IaC (bientôt disponible)
SCA (bientôt disponible)

Résultats d’analyse

Chaque analyse se termine par un message indiquant si des problèmes ont été trouvés ou non.

Si aucun problème n’est trouvé, l’analyse se termine par le message de succès suivant :

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

Si un problème est trouvé, une carte de violation apparaît à la place à la fin. Dans ce cas, vous devez examiner le fichier en question à la ligne spécifique mise en évidence par le message de résultat. Implémentez les modifications nécessaires pour résoudre le problème, puis exécutez à nouveau l’analyse.

Afficher/Masquer les secrets

Dans les exemples ci-dessous, un secret a été trouvé dans le fichier secret_test, situé dans le sous-dossier cli. La deuxième partie du message montre la ligne spécifique où le secret apparaît, qui dans ce cas est une valeur assignée à googleApiKey.

Notez comment l’exemple masque la valeur réelle du secret, en remplaçant la majeure partie du secret par des astérisques. Les analyses masquent les secrets par défaut, mais vous pouvez éventuellement désactiver cette fonctionnalité pour voir le secret en entier (en supposant que la machine sur laquelle vous consultez le résultat de l’analyse soit suffisamment protégée des regards indiscrets).

Pour désactiver l’obscurcissement des secrets, ajoutez l’argument --show-secret à n’importe quel type d’analyse.

Dans l’exemple suivant, une analyse de chemin est exécutée sur le sous-répertoire cli avec l’option activée pour afficher les secrets trouvés en entier :

cycode scan --show-secret path ./cli

Le résultat ne serait alors pas obscurci.

Échec modéré (Soft Fail)

En fonctionnement normal, la CLI retournera un code de sortie 1 lorsque des problèmes sont trouvés dans les résultats d’analyse. Selon votre configuration CI/CD, cela entraînera généralement un échec global. Si vous ne voulez pas que cela se produise, vous pouvez utiliser la fonctionnalité d’échec modéré.

En ajoutant l’option --soft-fail à n’importe quel type d’analyse, le code de sortie sera forcé à 0 indépendamment de la découverte de résultats.

Exemples de résultats d’analyse

Exemple de résultat Secrets

╭─────────────────────────────────────────────────────────────── 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.                     │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Exemple de résultat IaC

╭──────────── 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.                                                                                                          │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Exemple de résultat SCA

╭─────────────────────────────────────────────────────── [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.                                                                                                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Exemple de résultat SAST

╭───────────────────────────────────────────── [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.                                                         │ │
│ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Directives de remédiation personnalisées de l’entreprise

Si votre entreprise a défini des directives de remédiation personnalisées dans la politique concernée via le portail Cycode, vous verrez un champ « Directives de l’entreprise » contenant les directives de remédiation que vous avez ajoutées. Notez que si vous n’avez ajouté aucune directive d’entreprise, ce champ n’apparaîtra pas dans l’outil CLI.

Ignorer les résultats d’analyse

Des règles d’ignorance peuvent être ajoutées pour ignorer des valeurs secrètes spécifiques, des valeurs SHA512 spécifiques, des chemins spécifiques et des identifiants de règles Cycode de secrets et IaC spécifiques. Cela empêchera l’analyse de signaler ces valeurs. Les règles d’ignorance sont écrites et sauvegardées localement dans le fichier ./.cycode/config.yaml.

[!AVERTISSEMENT] L’ajout de valeurs à ignorer doit être fait en considérant attentivement les valeurs, les chemins et les politiques pour garantir que les analyses détecteront les vrais positifs.

Voici les options disponibles pour la commande cycode ignore :

Option	Description
`--by-value TEXT`	Ignorer une valeur spécifique lors de l’analyse des secrets. Voir Ignorer une valeur secrète pour plus de détails.
`--by-sha TEXT`	Ignorer une représentation SHA512 spécifique d’une chaîne lors de l’analyse des secrets. Voir Ignorer une valeur SHA de secret pour plus de détails.
`--by-path TEXT`	Éviter d’analyser un chemin spécifique. Nécessite de spécifier le type d’analyse. Voir Ignorer un chemin pour plus de détails.
`--by-rule TEXT`	Ignorer l’analyse d’un ID de règle de secret/IaC/SCA spécifique. Voir Ignorer une règle de secret ou IaC pour plus de détails.
`--by-package TEXT`	Ignorer l’analyse d’une version de paquet spécifique lors d’une analyse SCA. Motif attendu - `name@version`. Voir Ignorer un paquet pour plus de détails.
`--by-cve TEXT`	Ignorer l’analyse d’un CVE spécifique lors d’une analyse SCA. Motif attendu : CVE-YYYY-NNN.
`-t, --scan-type [secret\|iac\|sca\|sast]`	Spécifier l’analyse que vous souhaitez exécuter (`secret`/`iac`/`sca`/`sast`). La valeur par défaut est `secret`.
`-g, --global`	Ajouter une règle d’ignorance et la mettre à jour dans le fichier de configuration global `.cycode`.

Ignorer une valeur secrète

Pour ignorer une valeur secrète spécifique, vous devrez utiliser le drapeau --by-value. Cela ignorera la valeur secrète donnée dans toutes les analyses futures. Utilisez la commande suivante pour ajouter une valeur secrète à ignorer :

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

Dans l’exemple en haut de cette section, la commande pour ignorer une valeur secrète spécifique est la suivante :

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

Dans l’exemple ci-dessus, remplacez la valeur h3110w0r1d!@#$350 par votre valeur secrète non masquée. Consultez les options d’analyse Cycode pour savoir comment voir les valeurs secrètes dans les résultats d’analyse.

Ignorer une valeur SHA de secret

Pour ignorer une valeur SHA de secret spécifique, vous devrez utiliser le drapeau --by-sha. Cela ignorera la valeur SHA de secret donnée dans toutes les analyses futures. Utilisez la commande suivante pour ajouter une valeur SHA de secret à ignorer :

cycode ignore --by-sha {{secret-sha-value}} Dans l'exemple en haut de cette section, la commande pour ignorer une valeur SHA de secret spécifique est la suivante :

cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0

Dans l'exemple ci-dessus, remplacez la valeur a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0 par votre valeur SHA de secret.

Ignorer un chemin

Pour ignorer un chemin spécifique pour les analyses de secrets, IaC ou SCA, vous devez utiliser le drapeau --by-path en conjonction avec le drapeau -t, --scan-type (vous devez spécifier le type d'analyse). Cela ignorera le chemin donné pour toutes les analyses futures du type d'analyse spécifié. Utilisez la commande suivante pour ajouter un chemin à ignorer :

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

Dans l'exemple en haut de cette section, la commande pour ignorer un chemin spécifique pour un secret est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur ~/home/my-repo/config par votre valeur de chemin.

Dans l'exemple en haut de cette section, la commande pour ignorer un chemin spécifique des analyses IaC est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur ~/home/my-repo/config par votre valeur de chemin.

Dans l'exemple en haut de cette section, la commande pour ignorer un chemin spécifique des analyses SCA est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur ~/home/my-repo/config par votre valeur de chemin.

Ignorer une règle Secret, IaC, SCA ou SAST

Pour ignorer une règle spécifique de secret, IaC, SCA ou SAST, vous devez utiliser le drapeau --by-rule en conjonction avec le drapeau -t, --scan-type (vous devez spécifier le type d'analyse). Cela ignorera la valeur d'ID de règle donnée pour toutes les analyses futures. Utilisez la commande suivante pour ajouter une valeur d'ID de règle à ignorer :

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

Dans l'exemple en haut de cette section, la commande pour ignorer l'ID de règle de secret spécifique est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur ce3a4de0-9dfc-448b-a004-c538cf8b4710 par l'ID de règle que vous souhaitez ignorer.

Dans l'exemple en haut de cette section, la commande pour ignorer l'ID de règle IaC spécifique est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur bdaa88e2-5e7c-46ff-ac2a-29721418c59c par l'ID de règle que vous souhaitez ignorer.

Dans l'exemple en haut de cette section, la commande pour ignorer l'ID de règle SCA spécifique est la suivante :

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

Dans l'exemple ci-dessus, remplacez la valeur dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b par l'ID de règle que vous souhaitez ignorer.

Ignorer un paquet

[!NOTE] Cette option est uniquement disponible pour les analyses SCA.

Pour ignorer un paquet spécifique dans les analyses SCA, vous devez utiliser le drapeau --by-package en conjonction avec le drapeau -t, --scan-type (vous devez spécifier le type d'analyse sca). Cela ignorera le paquet donné, en utilisant le formatage {{package_name}}@{{package_version}}, pour toutes les analyses futures. Utilisez la commande suivante pour ajouter un paquet et une version à ignorer :

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

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

Dans l'exemple ci-dessous, la commande pour ignorer un paquet SCA spécifique est la suivante :

cycode ignore --scan-type sca --by-package [email protected]

Dans l'exemple ci-dessus, remplacez pyyaml par le nom du paquet et 5.3.1 par la version du paquet que vous souhaitez ignorer.

Ignorer via un fichier de configuration

Les règles d'ignorance appliquées sont stockées dans le fichier de configuration appelé config.yaml. Ce fichier peut être facilement partagé entre développeurs ou même commité sur un dépôt Git distant. Ces fichiers sont toujours situés dans le dossier .cycode. Le dossier commence par un point (.), et vous devez activer l'affichage des fichiers cachés pour le voir.

Chemin des fichiers de configuration

Par défaut, toutes les commandes cycode ignore enregistrent la règle d'ignorance dans le répertoire courant à partir duquel la CLI a été exécutée.

Exemple : exécuter une commande CLI d'ignorance depuis /Users/name/projects/backend créera config.yaml dans /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

La deuxième option est d'enregistrer les règles d'ignorance dans les fichiers de configuration globaux. Le chemin de la configuration globale est ~/.cycode/config.yaml, où ~ signifie utilisateurs home directory, for example, /Users/nom` sur macOS.

L'enregistrement dans l'espace global peut être effectué avec le drapeau -g de la commande cycode ignore. Par exemple : cycode ignore -g --by-value test-value.

Répertoire de travail approprié

Il est extrêmement important de placer le dossier .cycode et d'exécuter la CLI depuis le même endroit. Vous devez le vérifier attentivement lorsque vous travaillez avec différents environnements comme CI/CD (GitHub Actions, Jenkins, etc.).

Vous pouvez commiter le dossier .cycode à la racine de votre dépôt. Dans ce scénario, vous devez exécuter les analyses CLI depuis la racine du dépôt. Si cela ne correspond pas à vos besoins, vous pouvez copier temporairement le dossier .cycode où vous le souhaitez et effectuer une analyse CLI depuis ce dossier.

Structure des règles d'ignorance dans la configuration

Il est important de comprendre comment la CLI stocke les règles ignorées pour pouvoir lire ces fichiers de configuration ou même les modifier sans la CLI.

La structure YAML abstraite :

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

Valeurs possibles de scanTypeName : iac, sca, sast, secret.

Valeurs possibles de ignoringType : paths, values, rules, packages, shas, cves.

[!WARNING] Les valeurs pour "ignorer par valeur" ne sont pas stockées en texte brut ! La CLI stocke à la place des hachages sha256 des valeurs. Vous devez mettre les hachages de la chaîne lorsque vous modifiez le fichier de configuration à la main.

Exemple de config.yaml réel :

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

Commande Report

Génération de rapport SBOM

Une nomenclature logicielle (SBOM) est un inventaire de tous les composants constitutifs et dépendances logicielles impliqués dans le développement et la livraison d'une application. En utilisant cette commande, vous pouvez créer un rapport SBOM pour votre projet local ou pour l'URI de votre dépôt.

Les options suivantes sont disponibles pour cette commande :

Option	Description	Requis	Défaut
`-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]`	Format SBOM	Oui
`-o, --output-format [JSON]`	Spécifier le format du fichier de sortie	Non	json
`--output-file PATH`	Fichier de sortie	Non	nom de fichier autogénéré enregistré dans le répertoire courant
`--include-vulnerabilities`	Inclure les vulnérabilités	Non	False
`--include-dev-dependencies`	Inclure les dépendances de développement	Non	False

Les commandes suivantes sont disponibles pour cette commande :

Commande	Description
`path`	Générer un rapport SBOM pour le chemin fourni dans la commande
`repository-url`	Générer un rapport SBOM pour l'URI du dépôt fourni dans la commande

Dépôt

Pour créer un rapport SBOM pour un URI de dépôt :
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>

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

Projet local

Pour créer un rapport SBOM pour un chemin :
cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>

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

La sous-commande path prend en charge les options supplémentaires suivantes :

Option	Description
`--no-restore`	Ignorer la restauration du fichier de verrouillage et analyser uniquement les dépendances directes. Voir Option Lock Restore pour plus de détails.
`--gradle-all-sub-projects`	Exécuter la commande de restauration Gradle pour tous les sous-projets (à utiliser depuis la racine d'un build Gradle multi-projet).
`--maven-settings-file`	Pour Maven uniquement, permet d'utiliser un fichier settings.xml personnalisé lors de la construction de l'arbre de dépendances.

Commande Import

Importation de SBOM

Une nomenclature logicielle (SBOM) est un inventaire de tous les composants constitutifs et dépendances logicielles impliqués dans le développement et la livraison d'une application. En utilisant cette commande, vous pouvez importer un fichier SBOM depuis votre système de fichiers dans Cycode.

Les options suivantes sont disponibles pour cette commande :

Option	Description	Requis	Défaut
`-n, --name TEXT`	Nom d'affichage du SBOM	Oui
`-v, --vendor TEXT`	Nom de l'entité qui a fourni le SBOM	Oui
`-l, --label TEXT`	Attacher une étiquette au SBOM	Non
`-o, --owner TEXT`	Adresse e-mail de l'utilisateur Cycode servant de point de contact pour ce SBOM	Non
`-b, --business-impact [High \| Medium \| Low]`	Impact métier	Non	Medium

Par exemple :
cycode import sbom --name example-sbom --vendor cycode -label tag1 -label tag2 --owner [email protected] /path/to/local/project

Journaux d'analyse

Toutes les analyses CLI sont journalisées dans Cycode. Les journaux sont accessibles sous Paramètres > Journaux CLI.

Aide syntaxique

Vous pouvez ajouter l'argument --help à n'importe quelle commande à tout moment pour voir un message d'aide qui affichera les options disponibles et leur syntaxe.

Pour voir l'aide générale, entrez simplement la commande :

cycode --help

Pour voir les options d'analyse, entrez :

cycode scan --help

Pour voir les options disponibles pour un type d'analyse spécifique, entrez :

cycode scan {{option}} --help

Par exemple, pour voir les options disponibles pour une analyse de chemin, vous entreriez :

cycode scan path --help

Pour voir les options disponibles pour la fonction d'ignorance d'analyse, utilisez cette commande :

cycode ignore --help

Pour voir les options disponibles pour un rapport, utilisez cette commande :

cycode report --help

Pour voir les options disponibles pour un type de rapport spécifique, entrez :

cycode scan {{option}} --help