aikidosec/safe-chainProteggiti dal codice malevolo installato tramite npm, yarn, pnpm, npx, pnpx, pip, uv e poetry con Aikido Safe Chain. Gratuito, nessun token richiesto.
Aikido Device Protection si basa su Safe Chain, estendendo la sicurezza di pacchetti ed estensioni a più ecosistemi: npm, PyPI, VS Code, Open VSX - (Cursor, Windsurf, Kiro, Vs Codium, ...), Maven, NuGet, estensioni Chrome, Go, Skills.sh AI skills, Ruby, Rust e altro ancora.
Ottieni gestione centralizzata delle policy, flussi di lavoro richiesta-e-approvazione e visibilità su ogni workstation di sviluppo della tua organizzazione. Alimentato dallo stesso feed Intel di Aikido. Puoi distribuirlo manualmente o gestirlo tramite il tuo strumento MDM (Jamf, Fleet o Iru).
Aikido Safe Chain supporta i seguenti package manager:
Installare Aikido Safe Chain è semplice con lo script di installazione.
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
I comandi di installazione sopra fanno sempre riferimento a una release specifica. Per installare una versione diversa, sostituisci la versione con il numero di versione desiderato. Tutte le versioni disponibili sono nella pagina delle release.
Gli script di installazione vengono serviti da un URL di release versionato (releases/download/1.5.15/...). Le release di GitHub sono immutabili — una volta che un artefatto viene pubblicato su un URL versionato, non può essere modificato o sostituito, quindi il file che scarichi è garantito essere esattamente quello che è stato rilasciato.
❗Riavvia il terminale per iniziare a usare Aikido Safe Chain.
Verifica l'installazione eseguendo il comando di verifica: ```shell npm safe-chain-verify pnpm safe-chain-verify pip safe-chain-verify uv safe-chain-verify
(Facoltativo) Test del blocco malware provando a installare un pacchetto di test:
Per JavaScript/Node.js: ```shell npm install safe-chain-test
Per Python: ```shell pip3 install safe-chain-pi-test
- Il risultato dovrebbe mostrare che Aikido Safe Chain blocca l'installazione di questi pacchetti di test poiché vengono segnalati come malware.
Quando si eseguono i comandi `npm`, `npx`, `yarn`, `pnpm`, `pnpx`, `rush`, `rushx`, `bun`, `bunx`, `pip`, `pip3`, `uv`, `uvx`, `poetry`, `pipx` e `pdm`, la Aikido Safe Chain controllerà automaticamente la presenza di malware nei pacchetti che si sta tentando di installare. Intercetta anche le invocazioni dei moduli Python per pip quando disponibili (ad es., `python -m pip install ...`, `python3 -m pip download ...`). Se viene rilevato un malware, ti chiederà di uscire dal comando.
Puoi controllare la versione installata eseguendo:```shell
safe-chain --version
L'Aikido Safe Chain funziona eseguendo un server proxy leggero che intercetta i download dei pacchetti dal registro npm e da PyPI. Quando esegui comandi npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx, pip, pip3, uv, uvx, poetry, pipx o pdm, tutti i download dei pacchetti vengono instradati attraverso questo proxy locale, che verifica i pacchetti in tempo reale rispetto a Aikido Intel - Open Sources Threat Intelligence. Se viene rilevato malware in qualsiasi pacchetto (incluse le dipendenze profonde), il proxy blocca il download prima che il codice dannoso raggiunga la tua macchina.
Safe Chain applica controlli sull'età minima dei pacchetti per gli ecosistemi supportati.
L'applicazione attuale varia in base all'ecosistema:
Per impostazione predefinita, l'età minima del pacchetto è di 48 ore. Questo fornisce un ulteriore livello di sicurezza durante il periodo critico in cui i pacchetti appena pubblicati sono più vulnerabili a contenere minacce non rilevate. Puoi configurare questa soglia o bypassare completamente questa protezione - consulta la sezione Configurazione dell'età minima del pacchetto qui sotto.
L'Aikido Safe Chain si integra con la tua shell per offrire un'esperienza fluida quando usi npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx e i gestori di pacchetti Python (pip, uv, uvx, poetry, pipx, pdm). Configura alias per questi comandi in modo che vengano avvolti dai comandi Aikido Safe Chain, che gestiscono il server proxy prima di eseguire i comandi originali. Attualmente supportiamo:
Maggiori informazioni sull'integrazione con la shell sono disponibili nella documentazione sull'integrazione con la shell.
Per disinstallare l'Aikido Safe Chain, usa il nostro disinstallatore a una riga:
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)
❗Riavvia il terminale dopo la disinstallazione per assicurarti che tutti gli alias vengano rimossi.
Puoi controllare l'output di Aikido Safe Chain utilizzando il flag --safe-chain-logging o la variabile d'ambiente SAFE_CHAIN_LOGGING.
Puoi impostare il livello di registrazione tramite più fonti (in ordine di priorità):
Argomento CLI (priorità massima):
--safe-chain-logging=silent - Sopprime tutto l'output di Aikido Safe Chain tranne quando il malware viene bloccato. L'output del gestore di pacchetti viene scritto su stdout come di consueto, e Safe Chain scrive solo un breve messaggio se ha bloccato malware e fa terminare il processo.
npm install express --safe-chain-logging=silent
--safe-chain-logging=verbose - Abilita l'output diagnostico dettagliato di Aikido Safe Chain. Utile per risolvere problemi o capire cosa Safe Chain sta facendo dietro le quinte.
npm install express --safe-chain-logging=verbose
Variabile d'ambiente: ```shell export SAFE_CHAIN_LOGGING=verbose npm install express
Valori validi: silent, normal, verbose
Ciò è utile per impostare un livello di logging predefinito per tutti i comandi del gestore pacchetti nella sessione di terminale o nell'ambiente CI/CD.
È possibile inviare l'output di Aikido Safe Chain a un file di log utilizzando il flag --safe-chain-log-file o la variabile d'ambiente SAFE_CHAIN_LOG_FILE. La registrazione su file è disattivata per impostazione predefinita e viene attivata quando è impostato un percorso. Il formato del file (--safe-chain-log-file-format) e la verbosità (--safe-chain-log-file-verbosity) sono controllati indipendentemente dall'output del terminale.
Impostabili tramite uno di questi (in ordine di priorità):
~/.safe-chain/config.json): ```json
{
"logFile": "~/safe-chain.log",
"logFileFormat": "plain",
"logFileVerbosity": "normal"
}
logFileFormat — json (predefinito) o plain.
logFileVerbosity — silent, normal o verbose (predefinito). Indipendente da --safe-chain-logging.
Puoi configurare per quanto tempo i pacchetti devono esistere prima che Safe Chain ne permetta l'installazione. Per impostazione predefinita, i pacchetti devono avere almeno 48 ore prima di poter essere installati.
Per i gestori di pacchetti basati su npm, questo controllo ha attualmente due modalità di applicazione:
Per i gestori di pacchetti Python, questo controllo ha attualmente due modalità di applicazione:
Puoi impostare l'età minima del pacchetto tramite più sorgenti (in ordine di priorità):
~/.safe-chain/config.json): ```json
{
"minimumPackageAgeHours": 48
}
Escludi i pacchetti attendibili dal filtro dell'età minima tramite variabile d'ambiente o file di configurazione (entrambi vengono uniti). Usa @scope/* per considerare attendibili tutti i pacchetti di un'organizzazione:```shell
export SAFE_CHAIN_MINIMUM_PACKAGE_AGE_EXCLUSIONS="@aikidosec/*"
Please provide the Markdown content to translate.```json
{
"npm": {
"minimumPackageAgeExclusions": ["@aikidosec/*"]
},
"pip": {
"minimumPackageAgeExclusions": ["requests"]
}
}
Configura Safe Chain per scansionare pacchetti da registri personalizzati o privati.
Ecosistemi supportati:
Puoi impostare registri personalizzati tramite variabile d'ambiente o file di configurazione. Entrambe le fonti vengono unite insieme.
~/.safe-chain/config.json): ```json
{
"npm": {
"customRegistries": ["npm.company.com", "registry.internal.net"]
},
"pip": {
"customRegistries": ["pip.company.com", "registry.internal.net"]
}
}
Se fai affidamento su un file pip.conf per la configurazione di pip, devi indicare esplicitamente il file a pip tramite la variabile d'ambiente PIP_CONFIG_FILE in modo che Safe Chain possa unirlo.
Safe Chain esegue pip dietro il suo proxy MITM e scrive un file di configurazione pip temporaneo per iniettare le sue impostazioni di certificato e proxy. Quando PIP_CONFIG_FILE è impostata, Safe Chain unisce le sue impostazioni in una copia del tuo file (il file originale non viene mai modificato), così la tua index-url, le credenziali e le altre opzioni vengono preservate. Quando PIP_CONFIG_FILE non è impostata, la configurazione a livello utente di pip (es. ~/.config/pip/pip.conf) potrebbe essere sovrascritta dal file temporaneo di Safe Chain e le tue impostazioni non verranno rilevate.
Configura Safe Chain per recuperare i database malware e gli elenchi di nuovi pacchetti da un URL mirror personalizzato. Questo ti consente di ospitare una tua copia del database malware di Aikido.
Puoi impostare l'URL di base dell'elenco malware tramite più fonti (in ordine di priorità):
~/.safe-chain/config.json): ```json
{
"malwareListBaseUrl": "https://your-mirror.com"
}
L'URL di base deve puntare a un server che rispecchi la struttura di https://malware-list.aikido.dev/, incluse i seguenti percorsi:
/malware_predictions.json (database di malware per l'ecosistema JavaScript)/malware_pypi.json (database di malware per l'ecosistema Python)/releases/npm.json (elenco dei nuovi pacchetti JavaScript)/releases/pypi.json (elenco dei nuovi pacchetti Python)Oltre al file di configurazione nella home directory (~/.safe-chain/config.json), Safe Chain supporta un file di configurazione del progetto, così che le impostazioni possano essere versionate nel repository e condivise tra il team, invece di essere configurate macchina per macchina.
Aggiungi una sezione safe-chain: al file .aikido nella root del repository (lo stesso file usato dagli altri strumenti Aikido; Safe Chain legge solo la propria sezione safe-chain: e ignora il resto). Quando viene rilevato, le sue impostazioni vengono sovrapposte a quelle del file di configurazione nella home directory: i valori impostati nella configurazione del progetto hanno priorità, e gli array (come customRegistries) vengono combinati da entrambi i file anziché essere sostituiti da uno solo.
Solo le seguenti impostazioni possono essere definite da un file di configurazione del progetto:```yaml safe-chain: minimumPackageAgeHours: 48 npm: customRegistries: - npm.company.com minimumPackageAgeExclusions: - "@aikidosec/*" pip: customRegistries: - pip.company.com minimumPackageAgeExclusions: - requests
Impostazioni come `scanTimeout`, `malwareListBaseUrl` e le opzioni `logFile*` non possono essere impostate da un file di configurazione del progetto - possono provenire solo dalla configurazione nella tua directory home, dagli argomenti della CLI o dalle variabili d'ambiente.
## Directory di installazione personalizzata
Di default, Safe Chain si installa in `~/.safe-chain`. Puoi modificare questa posizione passando una directory di installazione esplicita all'installer. Questo è utile per installazioni a livello di sistema (ad esempio all'interno di un'immagine Docker) o quando devi evitare conflitti con altri strumenti.
Quando impostata, tutti i dati di Safe Chain (binario, shim, script, configurazione) vengono collocati nella directory personalizzata invece che in `~/.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
# Utilizzo in CI/CD
Puoi proteggere le pipeline CI/CD da pacchetti dannosi integrando Aikido Safe Chain nel tuo processo di build. Questo garantisce che tutti i pacchetti installati durante le build automatizzate vengano controllati per malware prima dell'installazione.
## Installazione per CI/CD
Usa il flag `--ci` per configurare automaticamente Aikido Safe Chain per ambienti CI/CD. Questo crea shim eseguibili nel PATH invece di alias di shell.
### Unix/Linux/macOS (GitHub Actions, Azure Pipelines, ecc.)```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
## Piattaforme supportate
- ✅ **GitHub Actions**
- ✅ **Azure Pipelines**
- ✅ **CircleCI**
- ✅ **Jenkins**
- ✅ **Bitbucket Pipelines**
- ✅ **GitLab Pipelines**
## Esempio 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"
## Esempio 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
Nota: si presuppone che Node.js e npm siano installati sull'agente 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
'''
}
}
} }
## Esempio di 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
Dopo la configurazione, tutti i successivi comandi del gestore pacchetti nella tua pipeline CI saranno automaticamente protetti dal rilevamento di malware di Aikido Safe Chain.
Per aggiungere safe-chain nelle pipeline GitLab, devi installarlo nell'immagine che esegue la pipeline. Questo può essere fatto:
Definisci un dockerfile per eseguire la tua 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}"
Crea l'immagine Docker nella tua 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
Usa l'immagine nella tua pipeline: ```yaml npm-ci: stage: install image: $CI_REGISTRY_IMAGE:latest script: - npm ci
Il pipeline completo per questo esempio si presenta così:```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
# Risoluzione dei problemi
Hai problemi? Consulta la [Guida alla risoluzione dei problemi](https://github.com/aikidosec/safe-chain/blob/HEAD/docs/troubleshooting.md) per assistenza con i problemi comuni.
# Segnala problemi
Se riscontri problemi:
1. Visita [GitHub Issues](https://github.com/AikidoSec/safe-chain/issues)
2. Includi:
* Sistema operativo e versione
* Tipo di shell e versione
* Output di `safe-chain --version`
* Output dei comandi di verifica
* Log dettagliati del comando che non funziona (aggiungi l'argomento `--safe-chain-logging=verbose`)