Aikido Safe Chain

✅ Malware auf Entwickler-Laptops und in CI/CD blockieren
✅ Unterstützt npm und PyPI weitere Paketmanager folgen
✅ Blockiert Pakete, die neuer als 48 Stunden sind, ohne deinen Build zu beeinträchtigen
✅ Tokenlos, kostenlos, keine Build-Daten werden geteilt

Brauchst du Schutz über npm & PyPI hinaus?

Aikido Device Protection baut auf Safe Chain auf und erweitert die Sicherheit von Paketen und Erweiterungen auf weitere Ökosysteme: npm, PyPI, VS Code, Open VSX – (Cursor, Windsurf, Kiro, Vs Codium, ...), Maven, NuGet, Chrome-Erweiterungen, Go, Skills.sh AI skills, Ruby, Rust und mehr.

Erhalte zentrale Richtlinienverwaltung, Anfrage- und Genehmigungs-Workflows sowie Transparenz über jede Entwickler-Workstation in deiner Organisation. Angetrieben vom selben Aikido Intel Feed. Stelle es manuell bereit oder verwalte es über dein MDM-Tool (Jamf, Fleet oder Iru).

Aikido Safe Chain unterstützt die folgenden Paketmanager:

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

Verwendung

Aikido Safe Chain demo

Installation

Die Installation von Aikido Safe Chain ist mit dem Installationsskript einfach.

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

Die oben genannten Installationsbefehle verweisen immer auf eine bestimmte Version. Um eine andere Version zu installieren, ersetzen Sie die Version durch die gewünschte Versionsnummer. Alle verfügbaren Versionen finden Sie auf der Releases-Seite.

Integrität des Downloads

Die Installationsskripte werden von einer versionierten Release-URL bereitgestellt (releases/download/1.5.20/...). GitHub-Releases sind unveränderlich — sobald ein Artefakt unter einer versionierten URL veröffentlicht wurde, kann es nicht mehr geändert oder ersetzt werden. Die heruntergeladene Datei entspricht daher garantiert genau dem, was veröffentlicht wurde.

Überprüfen der Installation

❗Terminal neu starten, um die Aikido Safe Chain zu verwenden.
- Dieser Schritt ist entscheidend, da er sicherstellt, dass die Shell-Aliase für npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx, pip, pip3, poetry, uv, uvx, pipx und pdm korrekt geladen werden. Wenn Sie das Terminal nicht neu starten, sind die Aliase nicht verfügbar.
Überprüfen Sie die Installation, indem Sie den Verifizierungsbefehl ausführen: ```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

Die Ausgabe sollte "OK: Safe-chain works!" anzeigen, was bestätigt, dass Aikido Safe Chain ordnungsgemäß installiert ist und läuft.

(Optional) Malware-Blockierung testen durch den Versuch, ein Testpaket zu installieren:

Für JavaScript/Node.js: ```shell npm install safe-chain-test

Für Python: ```shell pip3 install safe-chain-pi-test

- Die Ausgabe sollte zeigen, dass Aikido Safe Chain die Installation dieser Testpakete blockiert, da sie als Malware gekennzeichnet sind.

Wenn Sie die Befehle `npm`, `npx`, `yarn`, `pnpm`, `pnpx`, `rush`, `rushx`, `bun`, `bunx`, `pip`, `pip3`, `uv`, `uvx`, `poetry`, `pipx` und `pdm` ausführen, prüft die Aikido Safe Chain automatisch die Pakete, die Sie installieren möchten, auf Malware. Sie fängt außerdem Python-Modulaufrufe für pip ab, sofern verfügbar (z. B. `python -m pip install ...`, `python3 -m pip download ...`). Wenn Malware erkannt wird, werden Sie aufgefordert, den Befehl zu beenden.

Sie können die installierte Version überprüfen, indem Sie Folgendes ausführen:```shell
safe-chain --version

Funktionsweise

Malware-Blockierung

Die Aikido Safe Chain funktioniert, indem sie einen leichtgewichtigen Proxy-Server ausführt, der Paket-Downloads aus der npm-Registry und von PyPI abfängt. Wenn Sie die Befehle npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx, pip, pip3, uv, uvx, poetry, pipx oder pdm ausführen, werden alle Paket-Downloads über diesen lokalen Proxy geleitet, der Pakete in Echtzeit gegen Aikido Intel - Open Sources Threat Intelligence verifiziert. Wenn in einem Paket Malware erkannt wird (einschließlich tiefer Abhängigkeiten), blockiert der Proxy den Download, bevor der schädliche Code Ihren Rechner erreicht.

Mindestalter von Paketen

Safe Chain wendet Prüfungen des Mindestalters von Paketen auf unterstützte Ökosysteme an.

Die aktuelle Durchsetzung unterscheidet sich je nach Ökosystem:

npm-basierte Paketmanager:
- während der normalen Paketauflösung unterdrückt Safe Chain Versionen, die neuer sind als das konfigurierte Mindestalter, aus den von der Registry zurückgegebenen Paketmetadaten
- bei direkten Paket-Download-Anfragen, die diesen Metadatenfluss umgehen, kann Safe Chain die Anfrage selbst mithilfe einer zwischengespeicherten Liste neu veröffentlichter Pakete blockieren
Python-Paketmanager:
- während der Paketauflösung unterdrückt Safe Chain zu junge Dateien und Releases aus PyPI-Metadatenantworten
- bei direkten Paket-Download-Anfragen, die diesen Metadatenfluss umgehen, kann Safe Chain die Anfrage selbst mithilfe einer zwischengespeicherten Liste neu veröffentlichter Pakete blockieren

Standardmäßig beträgt das Mindestalter von Paketen 48 Stunden. Dies bietet eine zusätzliche Sicherheitsschicht während des kritischen Zeitraums, in dem neu veröffentlichte Pakete am anfälligsten dafür sind, unentdeckte Bedrohungen zu enthalten. Sie können diesen Schwellenwert konfigurieren oder diesen Schutz vollständig umgehen - siehe den Abschnitt Minimum Package Age Configuration unten.

Shell-Integration

Die Aikido Safe Chain integriert sich in Ihre Shell, um eine nahtlose Erfahrung bei der Verwendung von npm, npx, yarn, pnpm, pnpx, rush, rushx, bun, bunx und Python-Paketmanagern (pip, uv, uvx, poetry, pipx, pdm) zu bieten. Sie richtet Aliase für diese Befehle ein, sodass sie von den Aikido Safe Chain-Befehlen umschlossen werden, die den Proxy-Server verwalten, bevor die ursprünglichen Befehle ausgeführt werden. Derzeit unterstützen wir:

✅ Bash
✅ Zsh
✅ Fish
✅ PowerShell
✅ PowerShell Core

Weitere Informationen zur Shell-Integration finden Sie in der Shell-Integrationsdokumentation.

Deinstallation

Um die Aikido Safe Chain zu deinstallieren, verwenden Sie unseren Einzeiler-Deinstaller:

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)

❗Starten Sie Ihr Terminal neu, nachdem Sie die Deinstallation durchgeführt haben, um sicherzustellen, dass alle Aliase entfernt wurden.

Konfiguration

Protokollierung

Sie können die Ausgabe von Aikido Safe Chain über das Flag --safe-chain-logging oder die Umgebungsvariable SAFE_CHAIN_LOGGING steuern.

Konfigurationsoptionen

Sie können die Protokollierungsstufe über mehrere Quellen festlegen (in der Reihenfolge ihrer Priorität):

CLI-Argument (höchste Priorität):
- --safe-chain-logging=silent – Unterdrückt die gesamte Ausgabe von Aikido Safe Chain, außer wenn Malware blockiert wird. Die Ausgabe des Paketmanagers wird wie gewohnt nach stdout geschrieben, und Safe Chain gibt nur eine kurze Meldung aus, wenn Malware blockiert wurde und den Prozess beendet.
```
npm install express --safe-chain-logging=silent
```
- --safe-chain-logging=verbose – Aktiviert eine detaillierte Diagnoseausgabe von Aikido Safe Chain. Nützlich zur Fehlerbehebung oder um zu verstehen, was Safe Chain im Hintergrund tut.
```
npm install express --safe-chain-logging=verbose
```
Umgebungsvariable: ```shell export SAFE_CHAIN_LOGGING=verbose npm install express

Gültige Werte: silent, normal, verbose

Dies ist nützlich, um eine Standardprotokollierungsstufe für alle Paketmanager-Befehle in Ihrer Terminalsitzung oder CI/CD-Umgebung festzulegen.

Dateiprotokollierung

Sie können die Ausgabe von Aikido Safe Chain mithilfe des Flags --safe-chain-log-file oder der Umgebungsvariable SAFE_CHAIN_LOG_FILE in eine Protokolldatei spiegeln. Die Dateiprotokollierung ist standardmäßig deaktiviert und wird aktiviert, wenn ein Pfad festgelegt wird. Das Dateiformat (--safe-chain-log-file-format) und die Ausführlichkeit (--safe-chain-log-file-verbosity) werden unabhängig von der Terminalausgabe gesteuert.

Konfigurationsoptionen

Legen Sie diese über eine der folgenden Optionen fest (in der Reihenfolge ihrer Priorität):

CLI-Argument (höchste Priorität): ```shell npm install express
--safe-chain-log-file=~/safe-chain.log
--safe-chain-log-file-format=plain
--safe-chain-log-file-verbosity=normal
Umgebungsvariable: ```shell export SAFE_CHAIN_LOG_FILE=~/safe-chain.log export SAFE_CHAIN_LOG_FILE_FORMAT=plain export SAFE_CHAIN_LOG_FILE_VERBOSITY=normal
Konfigurationsdatei (~/.safe-chain/config.json): ```json { "logFile": "~/safe-chain.log", "logFileFormat": "plain", "logFileVerbosity": "normal" }

logFileFormat — json (Standard) oder plain.

logFileVerbosity — silent, normal oder verbose (Standard). Unabhängig von --safe-chain-logging.

Mindestalter für Pakete

Du kannst konfigurieren, wie lange Pakete existieren müssen, bevor Safe Chain ihre Installation zulässt. Standardmäßig müssen Pakete mindestens 48 Stunden alt sein, bevor sie installiert werden können.

Für npm-basierte Paketmanager hat diese Prüfung derzeit zwei Durchsetzungsmodi:

Safe Chain unterdrückt zu junge Versionen aus den Paketmetadaten während der normalen Abhängigkeitsauflösung.
Safe Chain blockiert direkte Paket-Download-Anfragen, wenn sie mit der zwischengespeicherten Liste neu veröffentlichter Pakete übereinstimmen.

Für Python-Paketmanager hat diese Prüfung derzeit zwei Durchsetzungsmodi:

Safe Chain unterdrückt zu junge Dateien und Releases aus den PyPI-Metadaten während der Abhängigkeitsauflösung.
Safe Chain blockiert direkte Paket-Download-Anfragen, wenn sie mit der zwischengespeicherten Liste neu veröffentlichter Pakete übereinstimmen.

Konfigurationsoptionen

Du kannst das Mindestalter für Pakete über mehrere Quellen festlegen (in der Reihenfolge ihrer Priorität):

CLI-Argument (höchste Priorität): ```shell npm install express --safe-chain-minimum-package-age-hours=48
Umgebungsvariable: ```shell export SAFE_CHAIN_MINIMUM_PACKAGE_AGE_HOURS=48 npm install express
Konfigurationsdatei (~/.safe-chain/config.json): ```json { "minimumPackageAgeHours": 48 }

Pakete ausschließen

Vertrauenswürdige Pakete von der Mindestalter-Filterung über eine Umgebungsvariable oder Konfigurationsdatei ausschließen (beide werden zusammengeführt). Verwende @scope/*, um allen Paketen einer Organisation zu vertrauen:```shell export SAFE_CHAIN_MINIMUM_PACKAGE_AGE_EXCLUSIONS="@aikidosec/*"

| `-s` | `--server` | Server URL (default: `http://localhost:8080`) |
| `-t` | `--token` | API token for authentication |
| `-o` | `--output` | Output file path |
| `-f` | `--format` | Output format: `json`, `yaml`, `table` |
| `-v` | `--verbose` | Enable verbose output |
| `-q` | `--quiet` | Suppress non-essential output |
| `-h` | `--help` | Show help message |
| `-V` | `--version` | Show version information |

### Examples

```bash
# Basic usage
scanner scan --target example.com

# With authentication
scanner scan --target example.com --token YOUR_API_TOKEN

# Output to JSON file
scanner scan --target example.com --format json --output results.json

# Verbose mode
scanner scan --target example.com --verbose

Configuration

The scanner can be configured using a configuration file or environment variables.

Configuration File

Create a file named scanner.yaml in the current directory:

server:
  url: "http://localhost:8080"
  token: "YOUR_API_TOKEN"
  timeout: 30

scan:
  target: "example.com"
  format: "json"
  output: "results.json"

logging:
  level: "info"
  file: "scanner.log"

Environment Variables

Variable	Description
`SCANNER_SERVER_URL`	Server URL
`SCANNER_API_TOKEN`	API token for authentication
`SCANNER_TIMEOUT`	Request timeout in seconds
`SCANNER_LOG_LEVEL`	Logging level: `debug`, `info`, `warn`, `error`

Exit Codes

Code	Description
`0`	Success
`1`	General error
`2`	Invalid arguments
`3`	Authentication failed
`4`	Network error
`5`	Scan failed

Troubleshooting

Connection Refused

If you encounter a "connection refused" error, ensure the server is running:

# Check if server is running
curl http://localhost:8080/health

# Start the server
scanner server start

Authentication Failed

Verify your API token is correct:

# Test authentication
scanner auth test --token YOUR_API_TOKEN

Timeout Errors

Increase the timeout value if you experience timeout errors:

scanner scan --target example.com --timeout 60

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details.

Development Setup

# Clone the repository
git clone https://github.com/example/scanner.git
cd scanner

# Install dependencies
make install

# Run tests
make test

# Build the project
make build

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Thanks to all contributors who have helped with this project
Special thanks to the security community for their feedback and support

Support

Documentation
Issue Tracker
Discussions```json { "npm": { "minimumPackageAgeExclusions": ["@aikidosec/*"] }, "pip": { "minimumPackageAgeExclusions": ["requests"] } }

## Benutzerdefinierte Registries

Konfigurieren Sie Safe Chain, um Pakete aus benutzerdefinierten oder privaten Registries zu scannen.

Unterstützte Ökosysteme:

- Node.js
- Python

### Konfigurationsoptionen

Sie können benutzerdefinierte Registries über eine Umgebungsvariable oder eine Konfigurationsdatei festlegen. Beide Quellen werden zusammengeführt.

1. **Umgebungsvariable** (kommagetrennt):   ```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"

Konfigurationsdatei (~/.safe-chain/config.json): ```json { "npm": { "customRegistries": ["npm.company.com", "registry.internal.net"] }, "pip": { "customRegistries": ["pip.company.com", "registry.internal.net"] } }

PYPI-Konfigurationsdatei

Wenn Sie sich für die pip-Konfiguration auf eine pip.conf-Datei verlassen, müssen Sie pip explizit über die Umgebungsvariable PIP_CONFIG_FILE darauf verweisen, damit Safe Chain sie zusammenführen kann.

Safe Chain führt pip hinter seinem MITM-Proxy aus und schreibt eine temporäre pip-Konfigurationsdatei, um sein Zertifikat und seine Proxy-Einstellungen einzufügen. Wenn PIP_CONFIG_FILE gesetzt ist, führt Safe Chain seine Einstellungen in eine Kopie Ihrer Datei zusammen (Ihre Originaldatei wird niemals geändert), sodass Ihre index-url, Anmeldedaten und andere Optionen erhalten bleiben. Wenn PIP_CONFIG_FILE nicht gesetzt ist, könnte die benutzerspezifische Konfiguration von pip (z. B. ~/.config/pip/pip.conf) durch die temporäre Datei von Safe Chain überschrieben werden und Ihre Einstellungen werden nicht übernommen.

Basis-URL der Malware-Liste

Konfigurieren Sie Safe Chain so, dass Malware-Datenbanken und Listen neuer Pakete von einer benutzerdefinierten Mirror-URL abgerufen werden. Dadurch können Sie Ihre eigene Kopie der Aikido-Malware-Datenbank hosten.

Konfigurationsoptionen

Sie können die Basis-URL der Malware-Liste über mehrere Quellen festlegen (in der Reihenfolge ihrer Priorität):

CLI-Argument (höchste Priorität): ```shell npm install express --safe-chain-malware-list-base-url=https://your-mirror.com
Umgebungsvariable: ```shell export SAFE_CHAIN_MALWARE_LIST_BASE_URL=https://your-mirror.com npm install express
Konfigurationsdatei (~/.safe-chain/config.json): ```json { "malwareListBaseUrl": "https://your-mirror.com" }

Die Basis-URL sollte auf einen Server verweisen, der die Struktur von https://malware-list.aikido.dev/ spiegelt, einschließlich der folgenden Pfade:

/malware_predictions.json (Malware-Datenbank für das JavaScript-Ökosystem)
/malware_pypi.json (Malware-Datenbank für das Python-Ökosystem)
/releases/npm.json (Liste neuer JavaScript-Pakete)
/releases/pypi.json (Liste neuer Python-Pakete)

Projekt-Konfigurationsdatei

Zusätzlich zur Konfigurationsdatei im Home-Verzeichnis (~/.safe-chain/config.json) unterstützt Safe Chain eine Projekt-Konfigurationsdatei, damit Einstellungen in ein Repository eingecheckt und teamweit geteilt werden können, anstatt pro Maschine konfiguriert zu werden.

Fügen Sie einen Abschnitt safe-chain: zur Datei .aikido im Stammverzeichnis Ihres Repositorys hinzu (dieselbe Datei, die auch von anderen Aikido-Tools verwendet wird; Safe Chain liest nur den eigenen Abschnitt safe-chain: und ignoriert den Rest). Wenn sie gefunden wird, werden ihre Einstellungen über Ihre Konfigurationsdatei im Home-Verzeichnis gelegt: In der Projektkonfiguration festgelegte Werte haben Vorrang, und Arrays (wie customRegistries) werden aus beiden Dateien zusammengeführt, anstatt dass eine die andere ersetzt.

Nur die folgenden Einstellungen können aus einer Projekt-Konfigurationsdatei festgelegt werden:```yaml safe-chain: minimumPackageAgeHours: 48 npm: customRegistries: - npm.company.com minimumPackageAgeExclusions: - "@aikidosec/*" pip: customRegistries: - pip.company.com minimumPackageAgeExclusions: - requests

Einstellungen wie `scanTimeout`, `malwareListBaseUrl` und die `logFile*`-Optionen können nicht aus einer Projektkonfigurationsdatei festgelegt werden – sie können nur aus deiner Konfiguration im Home-Verzeichnis, aus CLI-Argumenten oder aus Umgebungsvariablen stammen.

## Benutzerdefiniertes Installationsverzeichnis

Standardmäßig installiert sich Safe Chain in `~/.safe-chain`. Du kannst dies ändern, indem du dem Installer ein explizites Installationsverzeichnis übergibst. Dies ist nützlich für systemweite Installationen (z. B. innerhalb eines Docker-Images) oder wenn du Konflikte mit anderen Tools vermeiden musst.

Wenn festgelegt, werden alle Safe-Chain-Daten (Binary, Shims, Skripte, Konfiguration) unter dem benutzerdefinierten Verzeichnis statt unter `~/.safe-chain` abgelegt.

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

# Verwendung in CI/CD

Sie können Ihre CI/CD-Pipelines vor schädlichen Paketen schützen, indem Sie Aikido Safe Chain in Ihren Build-Prozess integrieren. Dadurch wird sichergestellt, dass alle während Ihrer automatisierten Builds installierten Pakete vor der Installation auf Malware überprüft werden.

## Installation für CI/CD

Verwenden Sie das Flag `--ci`, um Aikido Safe Chain automatisch für CI/CD-Umgebungen zu konfigurieren. Dadurch werden ausführbare Shims im PATH anstelle von Shell-Aliassen eingerichtet.

### Unix/Linux/macOS (GitHub Actions, Azure Pipelines, usw.)```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 usw.)```powershell

## Unterstützte Plattformen

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

## GitHub Actions Beispiel```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

Azure DevOps-Beispiel```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"

## CircleCI-Beispiel```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

Jenkins-Beispiel

Hinweis: Dies setzt voraus, dass Node.js und npm auf dem Jenkins-Agent installiert sind.```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
    '''
  }
}

} }

## Bitbucket Pipelines Beispiel```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

Nach dem Setup werden alle nachfolgenden Paketmanager-Befehle in Ihrer CI-Pipeline automatisch durch die Malware-Erkennung von Aikido Safe Chain geschützt.

GitLab Pipelines Beispiel

Um safe-chain in GitLab-Pipelines hinzuzufügen, müssen Sie es im Image installieren, das die Pipeline ausführt. Dies kann folgendermaßen erfolgen:

Definieren Sie ein Dockerfile, um Ihren Build auszuführen ```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}"
Erstellen Sie das Docker-Image in Ihrer CI-Pipeline ```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
Verwenden Sie das Image in Ihrer Pipeline: ```yaml npm-ci: stage: install image: $CI_REGISTRY_IMAGE:latest script: - npm ci

Die vollständige Pipeline für dieses Beispiel sieht so aus:```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

# Fehlerbehebung

Probleme? Im [Troubleshooting Guide](https://github.com/aikidosec/safe-chain/blob/main/docs/troubleshooting.md) findest du Hilfe bei häufigen Problemen.

# Probleme melden

Wenn du auf Probleme stößt:

1. Besuche [GitHub Issues](https://github.com/AikidoSec/safe-chain/issues)
2. Gib Folgendes an:
   * Betriebssystem und Version
   * Shell-Typ und Version
   * Ausgabe von `safe-chain --version`
   * Ausgabe der Verifikationsbefehle
   * Ausführliche Logs des fehlgeschlagenen Befehls (füge das Argument `--safe-chain-logging=verbose` hinzu)

safe-chain v1.5.16

Kategorien

safe-chain v1.5.16

Aikido Safe Chain

Brauchst du Schutz über npm & PyPI hinaus?

Verwendung

Installation

Unix/Linux/macOS```shell

Integrität des Downloads

Überprüfen der Installation

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

Funktionsweise

Malware-Blockierung

Mindestalter von Paketen

Shell-Integration

Deinstallation

Unix/Linux/macOS```shell

Konfiguration

Protokollierung

Konfigurationsoptionen

Dateiprotokollierung

Konfigurationsoptionen

Mindestalter für Pakete

Konfigurationsoptionen

Pakete ausschließen

Configuration

Configuration File

Environment Variables

Exit Codes

Troubleshooting

Connection Refused

Authentication Failed

Timeout Errors

Contributing

Development Setup

License

Acknowledgments

Support

PYPI-Konfigurationsdatei

Basis-URL der Malware-Liste

Konfigurationsoptionen

Projekt-Konfigurationsdatei

Windows```powershell

Windows (Azure Pipelines usw.)```powershell

Azure DevOps-Beispiel```yaml

Jenkins-Beispiel

GitLab Pipelines Beispiel

Install safe-chain

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

Kategorien