Retour aux mises à jour
New releaseSep 4, 2026

safe-chain v1.5.16

Protégez-vous contre les codes malveillants installés via npm, yarn, pnpm, npx, pnpx, pip, uv et poetry avec Aikido Safe Chain. Gratuit à utiliser, aucun jeton requis.

Partager

Aikido Safe Chain

Aikido Safe Chain

NPM Version NPM Downloads

  • ✅ Bloquez les malwares sur les ordinateurs portables des développeurs et dans les pipelines CI/CD
  • ✅ Prend en charge npm et PyPI d'autres gestionnaires de paquets arrivent bientôt
  • ✅ Bloque les paquets datant de moins de 48 heures sans casser votre build
  • ✅ Sans jeton, gratuit, aucune donnée de build partagée

Besoin d'une protection au-delà de npm et PyPI ?

Aikido Device Protection s'appuie sur Safe Chain et étend la sécurité des paquets et des extensions à davantage d'écosystèmes : npm, PyPI, VS Code, Open VSX - (Cursor, Windsurf, Kiro, Vs Codium, ...), Maven, NuGet, extensions Chrome, Go, compétences IA Skills.sh, Ruby, Rust, et plus encore.

Bénéficiez d'une gestion centralisée des politiques, de workflows de demande et d'approbation, et d'une visibilité sur chaque poste de développeur de votre organisation. Propulsé par le même flux Aikido Intel. Déployez-le manuellement ou gérez-le via votre outil MDM (Jamf, Fleet ou Iru).

Aikido Safe Chain prend en charge les gestionnaires de paquets suivants :

  • 📦 npm
  • 📦 npx
  • 📦 yarn
  • 📦 pnpm
  • 📦 pnpx
  • 📦 rush
  • 📦 rushx
  • 📦 bun
  • 📦 bunx
  • 📦 pip
  • 📦 pip3
  • 📦 uv
  • 📦 poetry
  • 📦 uvx
  • 📦 pipx
  • 📦 pdm

Utilisation

Aikido Safe Chain demo

Installation

L'installation d'Aikido Safe Chain est simple grâce au script d'installation.

Unix/Linux/macOS```shell

curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
&& echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd /tmp/install-safe-chain.sh" | sha256sum -c -
&& sh /tmp/install-safe-chain.sh
&& rm /tmp/install-safe-chain.sh

### Windows (PowerShell)```powershell
$installer = Join-Path $env:TEMP "install-safe-chain.ps1"
Invoke-WebRequest "https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing
$expectedHash = "468C342C5AABB71200B0BD19950984EDD5C4B39811B653B13A5AD15E0FBA4DFA"
if ((Get-FileHash $installer -Algorithm SHA256).Hash -ne $expectedHash) {
    Remove-Item $installer -ErrorAction SilentlyContinue
    throw "Checksum verification failed for install-safe-chain.ps1"
}
& $installer
Remove-Item $installer

Les commandes d'installation ci-dessus font toujours référence à une version spécifique. Pour installer une version différente, remplacez la version par le numéro de version souhaité. Toutes les versions disponibles se trouvent sur la page des releases.

Intégrité du téléchargement

Les scripts d'installation sont servis depuis une URL de release versionnée (releases/download/1.5.20/...). Les releases GitHub sont immuables — une fois qu'un artefact est publié à une URL versionnée, il ne peut être ni modifié ni remplacé, le fichier que vous téléchargez est donc garanti d'être exactement ce qui a été publié.

Vérifier l'installation

  1. ❗Redémarrez votre terminal pour commencer à utiliser Aikido Safe Chain.

    • Cette étape est cruciale car elle garantit que les alias de shell pour npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx, pip, pip3, poetry, uv, uvx, pipx et pdm sont correctement chargés. Si vous ne redémarrez pas votre terminal, les alias ne seront pas disponibles.

  2. Vérifiez l'installation en exécutant la commande de vérification : ```shell npm safe-chain-verify pnpm safe-chain-verify pip safe-chain-verify uv safe-chain-verify

    Any other supported package manager: {packagemanager} safe-chain-verify

  • La sortie doit afficher « OK: Safe-chain works! » confirmant qu'Aikido Safe Chain est correctement installé et fonctionnel.

  1. (Facultatif) Tester le blocage de logiciels malveillants en tentant d'installer un paquet de test :

    Pour JavaScript/Node.js : ```shell npm install safe-chain-test

Pour Python : ```shell pip3 install safe-chain-pi-test

- La sortie doit montrer qu'Aikido Safe Chain bloque l'installation de ces paquets de test car ils sont signalés comme malveillants.

Lors de l'exécution des commandes `npm`, `npx`, `yarn`, `pnpm`, `pnpx`, `rush`, `rushx`, `bun`, `bunx`, `pip`, `pip3`, `uv`, `uvx`, `poetry`, `pipx` et `pdm`, Aikido Safe Chain vérifie automatiquement la présence de malwares dans les paquets que vous essayez d'installer. Il intercepte également les invocations de modules Python pour pip lorsqu'elles sont disponibles (par exemple, `python -m pip install ...`, `python3 -m pip download ...`). Si un malware est détecté, il vous invite à quitter la commande.

Vous pouvez vérifier la version installée en exécutant :```shell
safe-chain --version

Comment ça fonctionne

Blocage des malwares

L'Aikido Safe Chain fonctionne en exécutant un serveur proxy léger qui intercepte les téléchargements de paquets depuis le registre npm et PyPI. Lorsque vous exécutez les commandes npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx, pip, pip3, uv, uvx, poetry, pipx ou pdm, tous les téléchargements de paquets sont acheminés via ce proxy local, qui vérifie les paquets en temps réel par rapport à Aikido Intel - Open Sources Threat Intelligence. Si un malware est détecté dans un paquet (y compris les dépendances profondes), le proxy bloque le téléchargement avant que le code malveillant n'atteigne votre machine.

Âge minimum des paquets

Safe Chain applique des vérifications d'âge minimum des paquets aux écosystèmes pris en charge.

L'application actuelle diffère selon l'écosystème :

  • gestionnaires de paquets basés sur npm :
    • lors de la résolution normale des paquets, Safe Chain supprime les versions plus récentes que l'âge minimum configuré des métadonnées de paquets renvoyées par le registre
    • pour les requêtes de téléchargement direct de paquets qui contournent ce flux de métadonnées, Safe Chain peut bloquer la requête elle-même à l'aide d'une liste mise en cache des paquets récemment publiés
  • gestionnaires de paquets Python :
    • lors de la résolution des paquets, Safe Chain supprime les fichiers et versions trop récents des réponses de métadonnées PyPI
    • pour les requêtes de téléchargement direct de paquets qui contournent ce flux de métadonnées, Safe Chain peut bloquer la requête elle-même à l'aide d'une liste mise en cache des paquets récemment publiés

Par défaut, l'âge minimum des paquets est de 48 heures. Cela fournit une couche de sécurité supplémentaire pendant la période critique où les paquets nouvellement publiés sont les plus susceptibles de contenir des menaces non détectées. Vous pouvez configurer ce seuil ou contourner entièrement cette protection - consultez la section Minimum Package Age Configuration ci-dessous.

Intégration au shell

L'Aikido Safe Chain s'intègre à votre shell pour offrir une expérience transparente lors de l'utilisation de npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx et des gestionnaires de paquets Python (pip, uv, uvx, poetry, pipx, pdm). Il configure des alias pour ces commandes afin qu'elles soient encapsulées par les commandes Aikido Safe Chain, qui gèrent le serveur proxy avant d'exécuter les commandes d'origine. Nous prenons actuellement en charge :

  • ✅ Bash
  • ✅ Zsh
  • ✅ Fish
  • ✅ PowerShell
  • ✅ PowerShell Core

Plus d'informations sur l'intégration au shell sont disponibles dans la documentation d'intégration au shell.

Désinstallation

Pour désinstaller l'Aikido Safe Chain, utilisez notre désinstalleur en une ligne :

Unix/Linux/macOS```shell

curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/uninstall-safe-chain.sh | sh

### Windows (PowerShell)```powershell
iex (iwr "https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/uninstall-safe-chain.ps1" -UseBasicParsing)

❗Redémarrez votre terminal après la désinstallation pour vous assurer que tous les alias sont supprimés.

Configuration

Journalisation

Vous pouvez contrôler la sortie d'Aikido Safe Chain à l'aide du flag --safe-chain-logging ou de la variable d'environnement SAFE_CHAIN_LOGGING.

Options de configuration

Vous pouvez définir le niveau de journalisation via plusieurs sources (par ordre de priorité) :

  1. Argument CLI (priorité la plus élevée) :

    • --safe-chain-logging=silent - Supprime toute sortie d'Aikido Safe Chain, sauf lorsqu'un logiciel malveillant est bloqué. La sortie du gestionnaire de paquets est écrite sur stdout normalement, et Safe Chain n'écrit qu'un court message s'il a bloqué un logiciel malveillant et provoque la fin du processus.

      npm install express --safe-chain-logging=silent

    • --safe-chain-logging=verbose - Active une sortie de diagnostic détaillée d'Aikido Safe Chain. Utile pour résoudre des problèmes ou comprendre ce que fait Safe Chain en arrière-plan.

      npm install express --safe-chain-logging=verbose

  2. Variable d'environnement : ```shell export SAFE_CHAIN_LOGGING=verbose npm install express

Valeurs valides : silent, normal, verbose

Ceci est utile pour définir un niveau de journalisation par défaut pour toutes les commandes du gestionnaire de paquets dans votre session de terminal ou votre environnement CI/CD.

Journalisation dans un fichier

Vous pouvez dupliquer la sortie d'Aikido Safe Chain vers un fichier journal à l'aide de l'option --safe-chain-log-file ou de la variable d'environnement SAFE_CHAIN_LOG_FILE. La journalisation dans un fichier est désactivée par défaut et activée lorsqu'un chemin est défini. Le format du fichier (--safe-chain-log-file-format) et la verbosité (--safe-chain-log-file-verbosity) sont contrôlés indépendamment de la sortie du terminal.

Options de configuration

Définissez-les via l'un des moyens suivants (par ordre de priorité) :

  1. Argument CLI (priorité la plus élevée) : ```shell npm install express
    --safe-chain-log-file=~/safe-chain.log
    --safe-chain-log-file-format=plain
    --safe-chain-log-file-verbosity=normal
  2. Variable d'environnement : ```shell export SAFE_CHAIN_LOG_FILE=~/safe-chain.log export SAFE_CHAIN_LOG_FILE_FORMAT=plain export SAFE_CHAIN_LOG_FILE_VERBOSITY=normal
  3. Fichier de configuration (~/.safe-chain/config.json) : ```json { "logFile": "~/safe-chain.log", "logFileFormat": "plain", "logFileVerbosity": "normal" }

logFileFormat — json (par défaut) ou plain.

logFileVerbosity — silent, normal ou verbose (par défaut). Indépendant de --safe-chain-logging.

Âge minimum des paquets

Vous pouvez configurer la durée pendant laquelle les paquets doivent exister avant que Safe Chain n'autorise leur installation. Par défaut, les paquets doivent avoir au moins 48 heures avant de pouvoir être installés.

Pour les gestionnaires de paquets basés sur npm, cette vérification dispose actuellement de deux modes d'application :

  • Safe Chain supprime les versions trop récentes des métadonnées des paquets lors de la résolution normale des dépendances.
  • Safe Chain bloque les demandes de téléchargement direct de paquets lorsqu'elles correspondent à la liste mise en cache des paquets récemment publiés.

Pour les gestionnaires de paquets Python, cette vérification dispose actuellement de deux modes d'application :

  • Safe Chain supprime les fichiers et versions trop récents des métadonnées PyPI lors de la résolution des dépendances.
  • Safe Chain bloque les demandes de téléchargement direct de paquets lorsqu'elles correspondent à la liste mise en cache des paquets récemment publiés.

Options de configuration

Vous pouvez définir l'âge minimum des paquets via plusieurs sources (par ordre de priorité) :

  1. Argument CLI (priorité la plus élevée) : ```shell npm install express --safe-chain-minimum-package-age-hours=48
  2. Variable d'environnement : ```shell export SAFE_CHAIN_MINIMUM_PACKAGE_AGE_HOURS=48 npm install express
  3. Fichier de configuration (~/.safe-chain/config.json) : ```json { "minimumPackageAgeHours": 48 }

Exclusion de paquets

Excluez les paquets de confiance du filtrage d'âge minimum via une variable d'environnement ou un fichier de configuration (les deux sont fusionnés). Utilisez @scope/* pour faire confiance à tous les paquets d'une organisation :```shell export SAFE_CHAIN_MINIMUM_PACKAGE_AGE_EXCLUSIONS="@aikidosec/*"

[No input content provided to translate.]```json
{
  "npm": {
    "minimumPackageAgeExclusions": ["@aikidosec/*"]
  },
  "pip": {
    "minimumPackageAgeExclusions": ["requests"]
  }
}

Registres personnalisés

Configurez Safe Chain pour analyser les paquets provenant de registres personnalisés ou privés.

Écosystèmes pris en charge :

  • Node.js
  • Python

Options de configuration

Vous pouvez définir des registres personnalisés via une variable d'environnement ou un fichier de configuration. Les deux sources sont fusionnées.

  1. Variable d'environnement (séparée par des virgules) : ```shell export SAFE_CHAIN_NPM_CUSTOM_REGISTRIES="npm.company.com,registry.internal.net" export SAFE_CHAIN_PIP_CUSTOM_REGISTRIES="pip.company.com,registry.internal.net"
  2. Fichier de configuration (~/.safe-chain/config.json) : ```json { "npm": { "customRegistries": ["npm.company.com", "registry.internal.net"] }, "pip": { "customRegistries": ["pip.company.com", "registry.internal.net"] } }

Fichier de configuration PYPI

Si vous vous appuyez sur un fichier pip.conf pour la configuration de pip, vous devez pointer pip vers celui-ci explicitement via la variable d'environnement PIP_CONFIG_FILE afin que Safe Chain puisse le fusionner.

Safe Chain exécute pip derrière son proxy MITM et écrit un fichier de configuration pip temporaire pour injecter son certificat et ses paramètres de proxy. Lorsque PIP_CONFIG_FILE est défini, Safe Chain fusionne ses paramètres dans une copie de votre fichier (votre fichier original n'est jamais modifié) afin que votre index-url, vos identifiants et vos autres options soient préservés. Lorsque PIP_CONFIG_FILE n'est pas défini, la configuration au niveau utilisateur de pip (par exemple ~/.config/pip/pip.conf) peut être écrasée par le fichier temporaire de Safe Chain et vos paramètres ne seront pas pris en compte.

URL de base de la liste de logiciels malveillants

Configurez Safe Chain pour récupérer les bases de données de logiciels malveillants et les listes de nouveaux paquets depuis une URL de miroir personnalisée. Cela vous permet d'héberger votre propre copie de la base de données de logiciels malveillants Aikido.

Options de configuration

Vous pouvez définir l'URL de base de la liste de logiciels malveillants via plusieurs sources (par ordre de priorité) :

  1. Argument CLI (priorité la plus élevée) : ```shell npm install express --safe-chain-malware-list-base-url=https://your-mirror.com
  2. Variable d'environnement : ```shell export SAFE_CHAIN_MALWARE_LIST_BASE_URL=https://your-mirror.com npm install express
  3. Fichier de configuration (~/.safe-chain/config.json) : ```json { "malwareListBaseUrl": "https://your-mirror.com" }

L'URL de base doit pointer vers un serveur qui reproduit la structure de https://malware-list.aikido.dev/, incluant les chemins suivants :

  • /malware_predictions.json (base de données de malwares de l'écosystème JavaScript)
  • /malware_pypi.json (base de données de malwares de l'écosystème Python)
  • /releases/npm.json (liste des nouveaux paquets JavaScript)
  • /releases/pypi.json (liste des nouveaux paquets Python)

Fichier de configuration de projet

En plus du fichier de configuration du répertoire personnel (~/.safe-chain/config.json), Safe Chain prend en charge un fichier de configuration de projet afin que les paramètres puissent être versionnés dans un dépôt et partagés au sein d'une équipe, plutôt que d'être configurés machine par machine.

Ajoutez une section safe-chain: au fichier .aikido à la racine de votre dépôt (le même fichier utilisé par les autres outils Aikido ; Safe Chain ne lit que sa propre section safe-chain: et ignore le reste). Lorsqu'elle est trouvée, ses paramètres sont fusionnés par-dessus votre fichier de configuration du répertoire personnel : les valeurs définies dans la configuration de projet sont prioritaires, et les tableaux (tels que customRegistries) sont combinés à partir des deux fichiers plutôt que l'un remplaçant l'autre.

Seuls les paramètres suivants peuvent être définis depuis un fichier de configuration de projet :```yaml safe-chain: minimumPackageAgeHours: 48 npm: customRegistries: - npm.company.com minimumPackageAgeExclusions: - "@aikidosec/*" pip: customRegistries: - pip.company.com minimumPackageAgeExclusions: - requests

Les paramètres tels que `scanTimeout`, `malwareListBaseUrl` et les options `logFile*` ne peuvent pas être définis depuis un fichier de configuration de projet - ils ne peuvent provenir que de votre configuration dans le répertoire personnel, des arguments CLI ou des variables d'environnement.

## Répertoire d'installation personnalisé

Par défaut, Safe Chain s'installe dans `~/.safe-chain`. Vous pouvez modifier cela en passant un répertoire d'installation explicite à l'installateur. Cela est utile pour les installations à l'échelle du système (par exemple, dans une image Docker) ou lorsque vous devez éviter les conflits avec d'autres outils.

Lorsqu'il est défini, toutes les données de Safe Chain (binaire, shims, scripts, configuration) sont placées sous le répertoire personnalisé au lieu de `~/.safe-chain`.

### Unix/Linux/macOS```shell
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh \
  && echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c - \
  && sh /tmp/install-safe-chain.sh --install-dir /usr/local/.safe-chain \
  && rm /tmp/install-safe-chain.sh

Windows```powershell

$installer = Join-Path $env:TEMP "install-safe-chain.ps1" Invoke-WebRequest "https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing $expectedHash = "468C342C5AABB71200B0BD19950984EDD5C4B39811B653B13A5AD15E0FBA4DFA" if ((Get-FileHash $installer -Algorithm SHA256).Hash -ne $expectedHash) { Remove-Item $installer -ErrorAction SilentlyContinue throw "Checksum verification failed for install-safe-chain.ps1" } & $installer -InstallDir 'C:\ProgramData\safe-chain' Remove-Item $installer

# Utilisation en CI/CD

Vous pouvez protéger vos pipelines CI/CD contre les paquets malveillants en intégrant Aikido Safe Chain dans votre processus de build. Cela garantit que tous les paquets installés lors de vos builds automatisés sont vérifiés à la recherche de malwares avant l'installation.

## Installation pour CI/CD

Utilisez le flag `--ci` pour configurer automatiquement Aikido Safe Chain pour les environnements CI/CD. Cela met en place des shims exécutables dans le PATH au lieu d'alias shell.

### Unix/Linux/macOS (GitHub Actions, Azure Pipelines, etc.)```shell
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh \
  && echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c - \
  && sh /tmp/install-safe-chain.sh --ci \
  && rm /tmp/install-safe-chain.sh

Windows (Azure Pipelines, etc.)```powershell

$installer = Join-Path $env:TEMP "install-safe-chain.ps1" Invoke-WebRequest "https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing $expectedHash = "468C342C5AABB71200B0BD19950984EDD5C4B39811B653B13A5AD15E0FBA4DFA" if ((Get-FileHash $installer -Algorithm SHA256).Hash -ne $expectedHash) { Remove-Item $installer -ErrorAction SilentlyContinue throw "Checksum verification failed for install-safe-chain.ps1" } & $installer -ci Remove-Item $installer

## Plateformes prises en charge

- ✅ **GitHub Actions**
- ✅ **Azure Pipelines**
- ✅ **CircleCI**
- ✅ **Jenkins**
- ✅ **Bitbucket Pipelines**
- ✅ **GitLab Pipelines**

## Exemple GitHub Actions```yaml
- name: Setup Node.js
  uses: actions/setup-node@v4
  with:
    node-version: "22"
    cache: "npm"

- name: Install safe-chain
  run: |
    curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
    echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c -
    sh /tmp/install-safe-chain.sh --ci
    rm /tmp/install-safe-chain.sh

- name: Install dependencies
  run: npm ci

Exemple Azure DevOps```yaml

  • task: NodeTool@0 inputs: versionSpec: "22.x" displayName: "Install Node.js"

  • script: | curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd /tmp/install-safe-chain.sh" | sha256sum -c - sh /tmp/install-safe-chain.sh --ci rm /tmp/install-safe-chain.sh displayName: "Install safe-chain"

  • script: npm ci displayName: "Install dependencies"

## Exemple CircleCI```yaml
version: 2.1
jobs:
  build:
    docker:
      - image: cimg/node:lts
    steps:
      - checkout
      - run: |
          curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
          echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c -
          sh /tmp/install-safe-chain.sh --ci
          rm /tmp/install-safe-chain.sh
      - run: npm ci
workflows:
  build_and_test:
    jobs:
      - build

Exemple Jenkins

Remarque : Cela suppose que Node.js et npm sont installés sur l'agent Jenkins.```groovy pipeline { agent any

environment { // Jenkins does not automatically persist PATH updates from setup-ci, // so add the shims + binary directory explicitly for all stages. // If you installed into a custom directory, replace ~/.safe-chain with that path here. PATH = "${env.HOME}/.safe-chain/shims:${env.HOME}/.safe-chain/bin:${env.PATH}" }

stages { stage('Install safe-chain') { steps { sh ''' set -euo pipefail

      # Install Safe Chain for CI
      curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
      echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c -
      sh /tmp/install-safe-chain.sh --ci
      rm /tmp/install-safe-chain.sh
    '''
  }
}

stage('Install project dependencies etc...') {
  steps {
    sh '''
      set -euo pipefail
      npm ci
    '''
  }
}

} }

## Exemple de pipelines Bitbucket```yaml
image: node:22

steps:
  - step:
      name: Install
      script:
        - |
          curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
          echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd  /tmp/install-safe-chain.sh" | sha256sum -c -
          sh /tmp/install-safe-chain.sh --ci
          rm /tmp/install-safe-chain.sh
        - export PATH=~/.safe-chain/shims:~/.safe-chain/bin:$PATH
        - npm ci

Après la configuration, toutes les commandes suivantes du gestionnaire de paquets dans votre pipeline CI seront automatiquement protégées par la détection de logiciels malveillants d'Aikido Safe Chain.

Exemple de pipelines GitLab

Pour ajouter safe-chain dans les pipelines GitLab, vous devez l'installer dans l'image exécutant le pipeline. Cela peut être fait en :

  1. Définissant un dockerfile pour exécuter votre build ```dockerfile FROM node:lts

    Install safe-chain

    RUN curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.20/install-safe-chain.sh -o /tmp/install-safe-chain.sh
    && echo "0ad25efe15d1fa56105157a454d647223e78eb0c53d1f85e3d10afcd722e7bfd /tmp/install-safe-chain.sh" | sha256sum -c -
    && sh /tmp/install-safe-chain.sh --ci
    && rm /tmp/install-safe-chain.sh

    Add safe-chain to PATH (update paths if you used a custom install dir)

    ENV PATH="/root/.safe-chain/shims:/root/.safe-chain/bin:${PATH}"

  2. Construisez l'image Docker dans votre pipeline CI ```yaml build-image: stage: build-image image: docker:latest services: - docker:dind script: - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY - docker build -t $CI_REGISTRY_IMAGE:latest . - docker push $CI_REGISTRY_IMAGE:latest

  3. Utilisez l'image dans votre pipeline : ```yaml npm-ci: stage: install image: $CI_REGISTRY_IMAGE:latest script: - npm ci

Le pipeline complet pour cet exemple ressemble à ceci :```yaml stages:

  • build-image
  • install

build-image: stage: build-image image: docker:latest services: - docker:dind script: - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY - docker build -t $CI_REGISTRY_IMAGE:latest . - docker push $CI_REGISTRY_IMAGE:latest

npm-ci: stage: install image: $CI_REGISTRY_IMAGE:latest script: - npm ci

# Dépannage

Vous rencontrez des problèmes ? Consultez le [Guide de dépannage](https://github.com/aikidosec/safe-chain/blob/main/docs/troubleshooting.md) pour obtenir de l'aide sur les problèmes courants.

# Signaler des problèmes

Si vous rencontrez des problèmes :

1. Rendez-vous sur [GitHub Issues](https://github.com/AikidoSec/safe-chain/issues)
2. Incluez :
   * Le système d'exploitation et sa version
   * Le type de shell et sa version
   * La sortie de `safe-chain --version`
   * La sortie des commandes de vérification
   * Les journaux détaillés de la commande en échec (ajoutez l'argument `--safe-chain-logging=verbose`)
Lire plus

Catégories

Outils DéfensifsScanners de VulnérabilitésAnalyse de MalwareDevSecOpsRenseignement sur les MenacesSécurité de la Chaîne Logistique