Cycode

officiel

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

Que pouvez-vous faire avec Cycode MCP ?

Analyser un chemin de dépôt pour détecter des secrets codés en dur — Demandez à l’assistant d’exécuter cycode_secret_scan sur un répertoire local pour détecter des identifiants exposés.
Vérifier les dépendances pour les vulnérabilités connues — Déclenchez cycode_sca_scan sur un chemin de projet pour identifier les packages open source vulnérables ou non conformes.
Auditer les fichiers Infrastructure as Code pour les mauvaises configurations — Utilisez cycode_iac_scan sur des répertoires Terraform ou CloudFormation pour révéler les paramètres à risque.
Examiner le code source pour les failles de sécurité — Exécutez cycode_sast_scan sur une base de code pour trouver les faiblesses au niveau du code et les problèmes de qualité.
Vérifier l’authentification CLI et l’état de la version — Appelez cycode_status pour confirmer la connexion à Cycode et la version active.

Documentation

Guide de l'utilisateur de Cycode CLI

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é des applications statiques.

Ce guide vous accompagne à la fois dans l'installation et l'utilisation.

Table des matières

Prérequis
Installation
1. Installer Cycode CLI
2. Installer le hook Pre-Commit
Commandes Cycode CLI
Commande MCP
Commande Platform
AI Guardrails
1. Données collectées par AI Guardrails
Commande Scan
Commande Report
1. Génération d'un rapport SBOM
Commande Import
Journaux d'analyse
Aide sur la syntaxe

Prérequis

L'application Cycode CLI nécessite Python version 3.9 ou ultérieure. La commande MCP n'est disponible que pour Python 3.10 et plus. 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
- Sinon, vous pouvez obtenir un ID client et une clé secrète Cycode en suivant les étapes détaillées dans les pages Jeton de compte de service et Jeton d'accès personnel, qui contiennent les détails pour obtenir ces valeurs.

Installation

Les étapes d'installation suivantes s'appliquent 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 à la place, selon la configuration de votre environnement Python.

Installer Cycode CLI

Pour installer l'application Cycode CLI sur votre machine locale, procédez comme suit :

Ouvrez votre application de ligne de commande ou de 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 et les informations d'identification Cycode (secret client ou jeton OIDC) :
- cycode auth (Recommandé)
- cycode configure
- Ajoutez-les à vos variables d'environnement

Utilisation de la commande Auth

[!NOTE] Il s'agit de la méthode recommandée pour configurer votre machine locale afin de vous authentifier auprès de Cycode CLI.

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) :
Saisissez vos identifiants de connexion sur cette page et connectez-vous.
Vous serez finalement redirigé vers la page ci-dessous, où vous devrez choisir le groupe d'affaires que vous souhaitez autoriser avec Cycode (si applicable) :

[!NOTE] Ce sera la méthode par défaut pour vous authentifier avec Cycode CLI.
Cliquez sur le bouton Autoriser pour autoriser Cycode CLI 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/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 et votre secret client Cycode via les variables d'environnement Linux ou Windows, ces informations d'identification prendront le pas sur cette méthode.

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

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

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

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

Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
Saisissez la valeur de votre jeton 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 constaterez 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'identification à la place (ou en plus) :

export CYCODE_ID_TOKEN={your Cycode OIDC ID token}

Sur Windows

À partir du Panneau de configuration, accédez au 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 à votre ID et à votre clé secrète, respectivement. Si vous vous authentifiez via OIDC, ajoutez également CYCODE_ID_TOKEN avec la valeur de votre jeton OIDC :
Insérez cycode.exe dans le chemin pour terminer l'installation.

Installer le hook Pre-Commit

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

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

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

Installation du hook Pre-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 pre-commit à jour :
```
pre-commit autoupdate
```
Il mettra automatiquement à jour rev dans .pre-commit-config.yaml vers la dernière version disponible de Cycode CLI.

[!NOTE] Le déclenchement se produit lors de la commande git commit. Le hook ne se déclenche que sur les fichiers qui sont en attente de validation.

Installation du hook Pre-Push

Pour installer le hook pre-push en plus ou à la place du hook pre-commit :

Ajoutez les hooks pre-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 pre-push :

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

Pour les hooks pre-commit et pre-push, utilisez :

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

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

Commandes Cycode CLI

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

Option	Description
`-v`, `--verbose`	Afficher les journaux détaillés.
`--no-progress-meter`	Ne pas afficher l'indicateur 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 OIDC Cycode pour cette exécution d'analyse spécifique.
`--install-completion`	Installer la complétion pour le shell courant.
`--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 la 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 de Cycode.
scan	Analysez le contenu pour détecter les violations Secrets/IaC/SCA/SAST. Vous devrez spécifier le type d'analyse à 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 l'état de la CLI et quittez.

Commande MCP [EXPÉRIMENTAL]

[!WARNING] La commande MCP n'est disponible que pour Python 3.10 et supérieur. 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 de Cycode via un protocole standardisé.

[!TIP] Pour une expérience optimale, installez Cycode CLI globalement sur votre système à l'aide de pip install cycode ou brew install cycode, puis authentifiez-vous une fois avec cycode auth. Après l'installation globale et l'authentification, 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, qui convient aux intégrations locales et aux applications d'IA capables de 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 hôte à laquelle lier le serveur (utilisée uniquement pour les transports non stdio) (par défaut : `127.0.0.1`)
`-p, --port`	Numéro de port à lier au 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`	Analyser les secrets codés en dur
`cycode_sca_scan`	Analyser pour l'analyse de composition logicielle (SCA) - vulnérabilités et problèmes de licence
`cycode_iac_scan`	Analyser les erreurs de configuration de l'infrastructure en tant que code (IaC)
`cycode_sast_scan`	Analyser pour les tests statiques de sécurité des applications (SAST) - qualité du code et failles de sécurité
`cycode_status`	Obtenir la version de Cycode CLI, l'état d'authentification et les informations de configuration

Chaque outil d'analyse accepte deux modes d'entrée mutuellement exclusifs :

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

[!TIP] Utilisez paths autant que possible. Passer de gros fichiers (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 d'analyse renvoient un objet JSON qui inclut un champ "summary" avec un nombre de violations lisible par l'humain (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 un transport HTTP streamable sur un hôte et un port personnalisés :

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

En savoir 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)

[!NOTE] Pour les environnements Cycode de l'UE, assurez-vous de définir les valeurs appropriées de 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 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 transport stdio avec installation de 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 transport stdio avec installation de 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 transport SSE (Server-Sent Events) :

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

Pour transport SSE sur un port personnalisé :

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

Pour transport HTTP streamable :

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

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

Pour 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 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 à Cycode CLI (et à la pile TLS Python sous-jacente) où trouver le bundle de certificats de confiance. Vous pouvez également augmenter le délai d'attente des appels d'outils MCP si les analyses sont interrompues.

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 Cycode CLI.
`SSL_CERT_FILE`	Chemin vers un fichier de bundle CA personnalisé. Utilisé par le module `ssl` de bas niveau de Python. Définissez-le en plus de `REQUESTS_CA_BUNDLE` pour une couverture complète.
`MCP_TOOL_TIMEOUT`	Délai d'attente (en secondes) pendant lequel les clients MCP tels que Claude et GitHub Copilot attendent la fin d'un appel d'outil. Augmentez-le si des analyses de longue durée sont interrompues avant leur fin.

[!TIP] 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 bas niveau. N'en utiliser qu'un seul peut encore provoquer 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"
      }
    }
  }
}

[!NOTE] Le serveur MCP nécessite une authentification Cycode CLI appropriée pour fonctionner. Assurez-vous de vous être authentifié à l'aide de 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 analyses en parallèle), ces sous-agents ne peuvent pas afficher de invites d'autorisation interactives. Si les outils Cycode n'ont pas été pré-approuvés, les analyses é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 pas d'approbation lorsque ces outils seront appelés, et ils fonctionneront correctement dans les 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 existe deux façons d'activer la journalisation de débogage :

Utilisation de l'indicateur -v ou --verbose :

cycode -v mcp

Utilisation de 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 leurs résultats
Toute erreur ou avertissement survenu

Ces informations peuvent être utiles lorsque :

Vous diagnostiquez des problèmes de connexion
Vous cherchez à comprendre pourquoi certains outils ne fonctionnent pas
Vous identifiez des problèmes d'authentification
Vous déboguez des problèmes spécifiques au transport

Configuration MCP

Commande Plateforme [BÊTA]

[!WARNING] 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 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 sous forme de 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 indicateurs --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 sans rapport (cycode scan, cycode status, etc.) ne déclenchent pas de récupération.

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

Découverte des commandes

Étant donné 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 de la plateforme

# 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 — faites-la passer par jq pour un filtrage ad hoc :

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

Remarques et limitations de la plateforme

Lecture seule pour l'instant. 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 à la prochaine actualisation du cache.
Aucune 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 h) 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.
Remplacez le TTL du cache avec CYCODE_SPEC_CACHE_TTL=<seconds>.

Garde-fous IA [BÊTA]

AI Guardrails installe des hooks dans les agents de codage IA pris en charge (Claude Code, Cursor, Copilot, Codex) afin que les invites, les fichiers lus par l'agent et les arguments d'outils MCP soient analysés pour détecter des secrets avant qu'ils n'atteignent le modèle.

Données collectées par AI Guardrails

L'analyse se fait côté serveur, donc le contenu analysé quitte la machine : le texte de l'invite, le contenu des fichiers lus par l'agent et les arguments d'outils MCP sont envoyés à votre tenant Cycode pour être vérifiés à la recherche de secrets.

Chaque événement est également rapporté avec le contexte concernant le développeur et la machine, afin qu'un résultat puisse être attribué à l'appareil et à l'utilisateur dont il provient. Une partie de ces données sont des données personnelles :

Identifiants d'appareil — le nom d'hôte de la machine et le numéro de série matériel.
Identifiants utilisateur — l'adresse e-mail de l'utilisateur connecté à l'agent de codage IA, et le nom d'utilisateur local du système d'exploitation.
Détails de l'environnement — le système d'exploitation et sa version, l'agent IA, sa version et le modèle utilisé, le contenu des fichiers de configuration MCP de l'agent, et ses plugins activés.

Le numéro de série matériel est mis en cache dans un fichier temporaire local, lisible uniquement par l'utilisateur qui a exécuté la commande, afin que les invocations répétées du hook ne re-interrogent pas le matériel.

Si la collecte de ces données n'est pas acceptable dans votre environnement, n'installez pas les hooks de garde-fous (cycode ai-guardrails uninstall supprime les hooks déjà installés).

Commande d'analyse

Exécution d'une analyse

L'application CLI Cycode propose plusieurs types d'analyses afin que vous puissiez choisir l'option la mieux adaptée à votre cas. Voici les options et commandes actuellement disponibles :

Option	Description
`-t, --scan-type [secret\|iac\|sca\|sast]`	Spécifiez l'analyse 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 l'analyse sans échouer, toujours renvoyer un code de statut non-erreur. Voir la section Échec doux 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 l'analyse SCA que vous souhaitez exécuter (`package-vulnerabilities`/`license-compliance`). La valeur par défaut est les deux.
`--monitor`	Lorsqu'elle est spécifiée, les résultats de l'analyse seront enregistrés dans Cycode.
`--cycode-report`	Afficher un lien vers le rapport d'analyse de la plateforme Cycode dans la sortie de la console.
`--no-restore`	Lorsqu'elle est spécifiée, Cycode n'exécutera pas la commande de restauration. Cela analysera UNIQUEMENT les dépendances directes !
`--stop-on-error`	Interrompre l'analyse si une erreur de collecte de fichiers ou de restauration de dépendances se produit, 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 une commande donnée.

Command	Description
commit-history	Analyser l'historique des commits ou effectuer une analyse de diff entre des commits spécifiques
path	Analyser les fichiers dans le chemin fourni dans la commande
pre-commit	Utiliser 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 de l'analyse à un seuil de sévérité spécifique, l'argument --severity-threshold peut être ajouté à la commande d'analyse.

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

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

Option de surveillance

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

Pour envoyer les résultats d'analyse liés aux politiques SCA trouvées dans une analyse de type SCA vers Cycode, ajoutez l'argument --monitor à la commande d'analyse.

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

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

Option de rapport Cycode

Pour chaque analyse effectuée à 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, politiques SCA pour les analyses de dépôt) au sein de la plateforme Cycode.

Pour que l'URL directe de ce rapport Cycode soit imprimée dans votre sortie CLI après la fin de l'analyse, ajoutez l'argument --cycode-report à votre commande d'analyse.

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

Tous les résultats d'analyse 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 d'analyse.

[!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 des vulnérabilités de paquets

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

Pour analyser une vulnérabilité de paquet spécifique 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 souhaitiez exécuter uniquement une analyse SCA sur les vulnérabilités de paquets, vous pourriez exécuter la commande suivante :

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

Option de conformité de licence

[!NOTE] Cette option est uniquement disponible pour les analyses 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 souhaitiez analyser uniquement une branche nommée dev, vous pourriez exécuter la commande suivante :

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

Option de restauration de verrou

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

Lors de l'exécution d'une analyse SCA, la CLI Cycode tente automatiquement de restaurer (générer) un fichier de verrouillage de dépendances pour chaque fichier manifeste pris en charge qu'elle trouve. Cela permet d'analyser les dépendances transitives, 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`	(lecture du fichier de verrouillage existant uniquement)
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`

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 d'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 de dépendances ne peut pas être généré lors d'une analyse SCA. L'élément en échec est ignoré avec un avertissement et l'analyse se poursuit avec les fichiers restants.

Utilisez --stop-on-error pour modifier ce comportement : l'analyse s'arrête immédiatement lors de la première de ces erreurs et signale l'erreur.

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

Cela est utile dans les pipelines CI où un échec silencieux produirait un résultat d'analyse 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 d'analyse des violations de politique via les codes de sortie :

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

Analyse de dépôt

Une analyse 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 d'analyse plus globale 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 une analyse complète du dépôt, exécutez ce qui suit :

cycode scan repository {{path}}

Par exemple, si vous souhaitiez 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 cette commande :

Option	Description
`-b, --branch TEXT`	Branche à analyser, si non définie, analyse de 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.

Compte tenu de l'exemple précédent, si vous souhaitiez analyser uniquement une branche nommée dev, vous pourriez exécuter ce qui suit :

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

Analyse de chemin

Une analyse 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 une analyse de répertoire, exécutez ce qui suit :

cycode scan path {{path}}

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

cycode scan path ~/home/git/codebase

Analyse du plan Terraform

Le CLI Cycode prend en charge l'analyse des plans Terraform (prenant en charge Terraform 0.12 et versions ultérieures)

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

Si vous disposez uniquement d'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 le CLI Cycode :

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

Analyse de l'historique des commits

[!NOTE] L'analyse de l'historique des commits n'est pas disponible pour les analyses IaC.

La commande d'analyse de l'historique des commits offre deux capacités principales :

Analyse complète de l'historique : Analysez tous les commits de l'historique du dépôt
Analyse des différences : Analysez uniquement les modifications entre des commits spécifiques

L'analyse des secrets peut analyser tous les commits de l'historique du dépôt, car les secrets introduits puis supprimés peuvent toujours être divulgués ou exposés. Pour les analyses SCA et SAST, la commande d'historique des commits se concentre sur l'analyse des différences/modifications entre les commits, ce qui la rend idéale pour les revues de demandes de tirage (pull requests) et l'analyse incrémentale.

Une analyse de l'historique des commits examine l'historique des commits de votre dépôt Git et peut être utilisée à la fois pour une analyse historique complète et pour une analyse ciblée des différences de modifications spécifiques.

Pour exécuter une analyse de l'historique des commits, exécutez la commande suivante :

cycode scan commit-history {{path}}

Par exemple, considérez un scénario dans lequel vous souhaitez analyser l'historique des commits d'un dépôt stocké dans ~/home/git/codebase. Vous pourriez alors exécuter la commande suivante :

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

Les options suivantes sont disponibles pour cette commande :

Option	Description
`-r, --commit-range TEXT`	Analyse une plage de commits dans ce dépôt Git ; par défaut, Cycode analyse tout l'historique des commits (exemple : HEAD~1)

Option de plage de commits (analyse des différences)

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

Validation de demande de tirage : Analyser uniquement les modifications introduites dans une PR
Analyse incrémentale CI/CD : Se concentrer sur les modifications récentes plutôt que sur l'ensemble du code
Revue de branche de fonctionnalité : Comparer les modifications avec la branche principale (main/master)
Optimisation des performances : Analyses plus rapides en limitant le périmètre aux modifications pertinentes

Syntaxe de la plage de commits

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

Syntax	Description	Example
`commit1..commit2`	Modifications du commit1 au commit2	`abc123..def456`
`commit1...commit2`	Modifications dans commit2 absentes de commit1	`main...feature-branch`
`commit`	Modifications du commit à HEAD	`HEAD~1`
`branch1..branch2`	Modifications de la branche1 à la branche2	`main..feature-branch`

Exemples d'analyse des différences

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

[!TIP] 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 avant commit (Pre-Commit)

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

Après l'installation du hook pre-commit, vous pouvez parfois souhaiter ignorer l'analyse lors d'un commit spécifique. Pour ce faire, ajoutez ce qui suit à votre commande git pour ignorer l'analyse pour un seul commit :

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

Analyse avant push (Pre-Push)

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

[!NOTE] Le hook pre-push n'est pas disponible pour les analyses IaC.

Le hook pre-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 pre-push

Pour configurer le hook pre-push à l'aide du 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 pre-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 pre-push :
```
pre-commit install --hook-type pre-push
```
Une installation réussie aboutira au message : Pre-push installed at .git/hooks/pre-push.
Maintenez le hook pre-push à jour :
```
pre-commit autoupdate
```

Comment fonctionne l'analyse pre-push

Le hook pre-push :

Reçoit des informations sur les commits en cours de push
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 pre-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 surcharge manuelle
HEAD distant Git : Utilise git symbolic-ref refs/remotes/origin/HEAD pour détecter la branche par défaut réelle du dépôt distant
Informations distantes Git : Replie sur git remote show origin si symbolic-ref échoue
Repli codé en dur : Utilise des noms de branches 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 pre-push fonctionne correctement, que votre dépôt utilise main, master, develop ou tout autre nom de branche par défaut.

Ignorer les analyses pre-push

Pour ignorer l'analyse pre-push pour une opération de push spécifique, utilisez :

SKIP=cycode-pre-push git push

Ou pour ignorer tous les hooks pre-push :

git push --no-verify

[!TIP] Le hook pre-push est déclenché sur la commande git push et analyse uniquement les commits qui vont ê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 au CLI Cycode quels fichiers et répertoires exclure des analyses. Il fonctionne 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 cela fonctionne

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.

[!WARNING]

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

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

Analyseurs 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 avec 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 concerné pour 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.

Remarquez comment l'exemple masque la valeur réelle du secret, en remplaçant la plupart 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 complet (en supposant que la machine sur laquelle vous consultez le résultat de l'analyse est suffisamment sécurisée contre les regards indiscrets).

Pour désactiver l'obfuscation des secrets, ajoutez l'argument --show-secret à tout 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 tous les secrets trouvés en entier :

cycode scan --show-secret path ./cli

Le résultat ne serait alors pas obfusqué.

Échec doux (Soft Fail)

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

En ajoutant l'option --soft-fail à tout type d'analyse, le code de sortie sera forcé à 0 indépendamment du fait que des résultats soient trouvés ou non.

Exemples de résultats d'analyse

Exemple de résultat pour les 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 pas ajouté de directives 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 de secret spécifiques, des valeurs SHA512 spécifiques, des chemins spécifiques et des ID de règles Cycode secrets et IaC spécifiques. Cela empêchera l'analyse de signaler ces valeurs. Les règles d'ignorance sont écrites et enregistrées localement dans le fichier ./.cycode/config.yaml.

[!WARNING] L'ajout de valeurs à ignorer doit être fait avec une réflexion attentive sur 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 de secret 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. Vous devez 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/ID de règle IaC/ID de règle 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 package spécifique lors d'une analyse SCA. Modèle attendu - `name@version`. Voir Ignorer un package pour plus de détails.
`--by-cve TEXT`	Ignorer l'analyse d'un CVE spécifique lors d'une analyse SCA. Modèle attendu : CVE-YYYY-NNN.
`-t, --scan-type [secret\|iac\|sca\|sast]`	Spécifiez l'analyse que vous souhaitez exécuter (`secret`/`iac`/`sca`/`sast`). La valeur par défaut est `secret`.
`-g, --global`	Ajoutez une règle d'ignorance et mettez-la à jour dans le fichier de configuration global `.cycode`.

Ignorer une valeur de secret

Pour ignorer une valeur de secret spécifique, vous devrez utiliser l'indicateur --by-value. Cela ignorera la valeur de secret donnée lors de toutes les analyses futures. Utilisez la commande suivante pour ajouter une valeur de secret à ignorer :

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

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

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

Dans l'exemple ci-dessus, remplacez la valeur h3110w0r1d!@#$350 par votre valeur de secret non masquée. Consultez les options d'analyse Cycode pour plus de détails sur la façon de voir les valeurs de secret dans les résultats d'analyse.

Ignorer une valeur SHA de secret

Pour ignorer une valeur SHA de secret spécifique, vous devrez utiliser l'indicateur --by-sha. Cela ignorera la valeur SHA de secret donnée lors de 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 devrez utiliser l'indicateur --by-path conjointement avec l'indicateur -t, --scan-type (vous devez spécifier le type d'analyse). Cela ignorera le chemin donné lors de toutes les analyses futures pour le type d'analyse donné. 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 de secret, IaC, SCA ou SAST

Pour ignorer une règle de secret, IaC, SCA ou SAST spécifique, vous devrez utiliser l'indicateur --by-rule conjointement avec l'indicateur -t, --scan-type (vous devez spécifier le type d'analyse). Cela ignorera la valeur d'ID de règle donnée lors de 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 package

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

Pour ignorer un package spécifique dans les analyses SCA, vous devrez utiliser l'indicateur --by-package conjointement avec l'indicateur -t, --scan-type (vous devez spécifier le type d'analyse sca). Cela ignorera le package donné, en utilisant le format {{package_name}}@{{package_version}}, lors de toutes les analyses futures. Utilisez la commande suivante pour ajouter un package 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 package SCA spécifique est la suivante :

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

Dans l'exemple ci-dessus, remplacez pyyaml par le nom du package et 5.3.1 par la version du package 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é dans 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 la 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 consiste à enregistrer les règles d'ignorance dans les fichiers de configuration globaux. Le chemin de la configuration globale est ~/.cycode/config.yaml, où ~ signifie users home directory, for example, /Users/name` sur macOS.

L'enregistrement dans l'espace global peut être effectué avec l'indicateur -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 revérifier 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 temporairement copier 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 afin de 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 plutôt des hachages sha256 des valeurs. Vous devez mettre des hachages de la chaîne lors de la modification manuelle du fichier de configuration.

Exemple de config.yaml réel :

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

Commande de rapport

Génération d'un 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écifiez le format du fichier de sortie	Non	json
`--output-file PATH`	Fichier de sortie	Non	nom de fichier généré automatiquement 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 de dépôt fourni dans la commande

Dépôt

Pour créer un rapport SBOM pour une 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 de restauration du verrouillage pour plus de détails.
`--gradle-all-sub-projects`	Exécutez la commande de restauration Gradle pour tous les sous-projets (à utiliser depuis la racine d'une construction Gradle multi-projets).
`--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 d'importation

Importation d'un 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 qui sert de point de contact pour ce SBOM	Non
`-b, --business-impact [High \| Medium \| Low]`	Impact métier	Non	Moyen

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

Journaux de scan

Tous les scans CLI sont enregistrés dans Cycode. Les journaux se trouvent sous Paramètres > Journaux CLI.

Aide sur la syntaxe

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 de scan, entrez :

cycode scan --help

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

cycode scan {{option}} --help

Par exemple, pour voir les options disponibles pour un scan de chemin, vous entreriez :

cycode scan path --help

Pour voir les options disponibles pour la fonction d'ignorance de scan, 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