aikidosec/safe-chainProté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.
Aikido Device Protection s'appuie sur Safe Chain, étendant la sécurité des paquets et 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 flux de demande et approbation, et d'une visibilité sur chaque poste de travail de développeur dans votre organisation. Propulsé par le même flux d'intelligence Aikido. 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 :
L'installation d'Aikido Safe Chain est simple grâce au script d'installation.
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
&& echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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.15/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing
$expectedHash = "5FC22EEF74814BEF6828AA07C0EAEC79598F343F98B94A4ACAB823769AD56DA1"
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 référencent toujours une version spécifique. Pour installer une autre version, remplacez la version par le numéro de version souhaité. Toutes les versions disponibles sont sur la page des versions.
Les scripts d'installation sont servis depuis une URL de version publiée (releases/download/1.5.15/...). Les versions GitHub sont immuables — une fois qu'un artefact est publié à une URL versionnée, il ne peut pas être modifié ni remplacé, donc le fichier que vous téléchargez est garanti d'être exactement celui qui a été publié.
❗Redémarrez votre terminal pour commencer à utiliser Aikido Safe Chain.
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
(Facultatif) Testez le blocage des malwares 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 de 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 logiciels malveillants dans les paquets que vous essayez d'installer. Il intercepte également les invocations de modules Python pour pip lorsque cela est disponible (par exemple, `python -m pip install ...`, `python3 -m pip download ...`). Si un logiciel malveillant est détecté, il vous invite à quitter la commande.
Vous pouvez vérifier la version installée en exécutant :```shell
safe-chain --version
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 des 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 routés via ce proxy local, qui vérifie les paquets en temps réel contre Aikido Intel - Renseignements sur les menaces open source. 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.
Safe Chain applique des contrôles d'âge minimum des paquets pour les écosystèmes pris en charge.
Les règles actuelles diffèrent selon l'écosystème :
Par défaut, l'âge minimum des paquets est de 48 heures. Cela offre 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 — voir la section Configuration de l'âge minimum des paquets ci-dessous.
Aikido Safe Chain s'intègre à votre interpréteur de commandes pour offrir une expérience fluide 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 enveloppées par les commandes Aikido Safe Chain, qui gèrent le serveur proxy avant d'exécuter les commandes d'origine. Nous prenons en charge actuellement :
Plus d'informations sur l'intégration à l'interpréteur de commandes sont disponibles dans la documentation sur l'intégration à l'interpréteur de commandes.
Pour désinstaller Aikido Safe Chain, utilisez notre désinstalleur en une ligne :
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/uninstall-safe-chain.sh | sh
### Windows (PowerShell)```powershell
iex (iwr "https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/uninstall-safe-chain.ps1" -UseBasicParsing)
❗Redémarrez votre terminal après la désinstallation pour vous assurer que tous les alias sont supprimés.
Vous pouvez contrôler la sortie d'Aikido Safe Chain à l'aide du drapeau --safe-chain-logging ou de la variable d'environnement SAFE_CHAIN_LOGGING.
Vous pouvez définir le niveau de journalisation via plusieurs sources (par ordre de priorité) :
Argument CLI (priorité la plus élevée) :
--safe-chain-logging=silent - Supprime toute la sortie d'Aikido Safe Chain, sauf lorsqu'un malware est bloqué. La sortie du gestionnaire de paquets est écrite sur stdout comme d'habitude, et Safe Chain écrit uniquement un court message s'il a bloqué un malware et provoque la sortie du processus.
npm install express --safe-chain-logging=silent
--safe-chain-logging=verbose - Active la sortie de diagnostic détaillée d'Aikido Safe Chain. Utile pour résoudre les problèmes ou comprendre ce que Safe Chain fait en arrière-plan.
npm install express --safe-chain-logging=verbose
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 terminal ou votre environnement CI/CD.
Vous pouvez refléter la sortie d'Aikido Safe Chain vers un fichier journal à l'aide de l'indicateur --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.
Définies via l'un des éléments suivants (par ordre de priorité) :
~/.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.
Vous pouvez configurer la durée minimale d'existence des paquets 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, ce contrôle dispose actuellement de deux modes d'application :
Pour les gestionnaires de paquets Python, ce contrôle dispose actuellement de deux modes d'application :
Vous pouvez définir l'âge minimal des paquets via plusieurs sources (par ordre de priorité) :
~/.safe-chain/config.json): ```json
{
"minimumPackageAgeHours": 48
}
Excluez les paquets de confiance du filtrage par â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 was provided to translate.```json
{
"npm": {
"minimumPackageAgeExclusions": ["@aikidosec/*"]
},
"pip": {
"minimumPackageAgeExclusions": ["requests"]
}
}
Configurez Safe Chain pour analyser les packages provenant de registres personnalisés ou privés.
Écosystèmes pris en charge :
Vous pouvez définir des registres personnalisés via une variable d'environnement ou un fichier de configuration. Les deux sources sont fusionnées.
~/.safe-chain/config.json): ```json
{
"npm": {
"customRegistries": ["npm.company.com", "registry.internal.net"]
},
"pip": {
"customRegistries": ["pip.company.com", "registry.internal.net"]
}
}
Si vous dépendez d'un fichier pip.conf pour la configuration de pip, vous devez y pointer explicitement pip 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 ses paramètres de certificat et de proxy. Lorsque PIP_CONFIG_FILE est défini, Safe Chain fusionne ses paramètres dans une copie de votre fichier (votre fichier d'origine n'est jamais modifié), préservant ainsi votre index-url, vos identifiants et autres options. Lorsque PIP_CONFIG_FILE n'est pas défini, la configuration au niveau utilisateur de pip (par ex. ~/.config/pip/pip.conf) peut être remplacée par le fichier temporaire de Safe Chain et vos paramètres ne seront pas pris en compte.
Configurez Safe Chain pour récupérer les bases de données de malwares et les listes de nouveaux paquets depuis une URL miroir personnalisée. Cela vous permet d'héberger votre propre copie de la base de données de malwares Aikido.
Vous pouvez définir l'URL de base de la liste des malwares via plusieurs sources (par ordre de priorité) :
~/.safe-chain/config.json): ```json
{
"malwareListBaseUrl": "https://your-mirror.com"
}
L'URL de base doit pointer vers un serveur qui reflète la structure de https://malware-list.aikido.dev/, incluant les chemins suivants :
/malware_predictions.json (base de données de logiciels malveillants de l'écosystème JavaScript)/malware_pypi.json (base de données de logiciels malveillants de l'écosystème Python)/releases/npm.json (liste des nouveaux packages JavaScript)/releases/pypi.json (liste des nouveaux packages Python)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 commités dans un dépôt et partagés au sein d'une équipe, au lieu 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 du projet ont priorité, et les tableaux (comme customRegistries) sont combinés à partir des deux fichiers plutôt que l'un remplace l'autre.
Seuls les paramètres suivants peuvent être définis à partir d'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
Settings like `scanTimeout`, `malwareListBaseUrl`, and the `logFile*` options cannot be set from a project config file - they can only come from your home-directory config, CLI arguments, or environment variables.
## Custom Install Directory
By default, Safe Chain installs itself into `~/.safe-chain`. You can change this by passing an explicit install directory to the installer. This is useful for system-wide installations (e.g. inside a Docker image) or when you need to avoid conflicts with other tools.
When set, all Safe Chain data (binary, shims, scripts, config) is placed under the custom directory instead of `~/.safe-chain`.
### Unix/Linux/macOS```shell
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh \
&& echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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
$installer = Join-Path $env:TEMP "install-safe-chain.ps1" Invoke-WebRequest "https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing $expectedHash = "5FC22EEF74814BEF6828AA07C0EAEC79598F343F98B94A4ACAB823769AD56DA1" 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 dans CI/CD
Vous pouvez protéger vos pipelines CI/CD contre les paquets malveillants en intégrant Aikido Safe Chain à votre processus de build. Cela garantit que tous les paquets installés lors de vos builds automatisés sont vérifiés pour détecter les logiciels malveillants avant l'installation.
## Installation pour CI/CD
Utilisez l'option `--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 de shell.
### Unix/Linux/macOS (GitHub Actions, Azure Pipelines, etc.)```shell
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh \
&& echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /tmp/install-safe-chain.sh" | sha256sum -c - \
&& sh /tmp/install-safe-chain.sh --ci \
&& rm /tmp/install-safe-chain.sh
$installer = Join-Path $env:TEMP "install-safe-chain.ps1" Invoke-WebRequest "https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.ps1" -OutFile $installer -UseBasicParsing $expectedHash = "5FC22EEF74814BEF6828AA07C0EAEC79598F343F98B94A4ACAB823769AD56DA1" 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.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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
task: NodeTool@0 inputs: versionSpec: "22.x" displayName: "Install Node.js"
script: | curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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
Remarque : Ceci 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.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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 Bitbucket Pipelines```yaml
image: node:22
steps:
- step:
name: Install
script:
- |
curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /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 de gestionnaire de paquets ultérieures dans votre pipeline CI seront automatiquement protégées par la détection de logiciels malveillants d'Aikido Safe Chain.
Pour ajouter safe-chain dans les pipelines GitLab, vous devez l'installer dans l'image exécutant le pipeline. Cela peut être fait en :
Définissez un dockerfile pour exécuter votre build ```dockerfile FROM node:lts
RUN curl -fsSL https://github.com/AikidoSec/safe-chain/releases/download/1.5.15/install-safe-chain.sh -o /tmp/install-safe-chain.sh
&& echo "de0565e3d6346407a604e84e639e95fea8758748063da2216bbfdca5feda5dd2 /tmp/install-safe-chain.sh" | sha256sum -c -
&& sh /tmp/install-safe-chain.sh --ci
&& rm /tmp/install-safe-chain.sh
ENV PATH="/root/.safe-chain/shims:/root/.safe-chain/bin:${PATH}"
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
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: 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/HEAD/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 :
* Système d'exploitation et version
* Type de shell et version
* Sortie de `safe-chain --version`
* Sortie des commandes de vérification
* Journaux verbeux de la commande en échec (ajoutez l'argument `--safe-chain-logging=verbose`)