cr0hn/dockerscanDer umfassendste Docker-Sicherheitsscanner
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/1309/3345979faae1cdabbe2912dfcaf46221df5cb53697630a8e8dcc5eebf814e949.png" alt="DockerScan Logo" width="200">
# DockerScan v2.0
### *Der umfassendste Docker-Sicherheitsscanner*
[](LICENSE)
[](https://golang.org/)
[](https://github.com/cr0hn/dockerscan/releases)
[](https://github.com/cr0hn/dockerscan/actions/workflows/dockerscan.yml)
[](https://github.com/cr0hn/dockerscan)
[](https://goreportcard.com/report/github.com/cr0hn/dockerscan)
[](https://github.com/cr0hn/dockerscan/releases)
**Von [Daniel Garcia (cr0hn)](https://cr0hn.com)** | [GitHub](https://github.com/cr0hn/dockerscan) | [Website](https://cr0hn.com)
---
[Funktionen](#-features) •
[Installation](#-installation) •
[Schnellstart](#-quick-start) •
[Dokumentation](#-documentation) •
[Anwendungsfälle](#-use-cases) •
[Neuerungen](#-whats-new-in-v20) •
[Beitragen](#-contributing)
</div>
---
## 📑 Inhaltsverzeichnis
- [Überblick](#-overview)
- [Funktionen](#-features)
- [Neuerungen in v2.0](#-whats-new-in-v20)
- [Installation](#-installation)
- [Schnellstart](#-quick-start)
- [Verwendung](#-usage)
- [Authentifizierung für private Registries](#-private-registry-authentication)
- [Sicherheitsscanner](#-security-scanners)
- [Ausgabeformate](#-output-formats)
- [Anwendungsfälle](#-use-cases)
- [Vergleich](#-comparison-with-other-tools)
- [Architektur](#-architecture)
- [Beitragen](#-contributing)
- [Referenzen](#-references)
- [Lizenz](#-license)
- [Autor](#-author)
---
## 🎯 Überblick
**DockerScan v2.0** ist ein Sicherheitsscanner der nächsten Generation für Docker-Container und -Images, vollständig in Go neu geschrieben. Es kombiniert mehrere Sicherheitsprüftechniken basierend auf der aktuellen Forschung 2024–2025, Industriestandards (CIS Benchmark, NIST SP 800-190) und realen Angriffsmustern aus Produktionsumgebungen.
### Warum DockerScan v2.0?
- ✅ **Umfassendster**: Kombiniert mehr als 5 Sicherheitsprüftechniken in einem Werkzeug
- ✅ **Aktuellste Forschung**: Basiert auf Supply-Chain-Angriffen und CVEs aus 2024–2025
- ✅ **Produktionsreif**: SARIF-Ausgabe für CI/CD, Exit-Codes für Automatisierung
- ✅ **Blitzschnell**: Geschrieben in Go mit gleichzeitiger Prüfung
- ✅ **Erweiterbar**: Plugin-Architektur für benutzerdefinierte Scanner
- ✅ **Kostenlos und Open Source**: BSD-3-Lizenz
---
## 🌟 Funktionen
### 🛡️ **Sicherheitsprüfmodule**
#### 1. **CIS Docker Benchmark v1.7.0**
Vollständige Konformitätsprüfung mit mehr als 80 automatisierten Kontrollen:
- ✅ Host-Konfigurationssicherheit (13 Prüfungen)
- ✅ Docker-Daemon-Härtung (18 Prüfungen)
- ✅ Datei- und Verzeichnisberechtigungen (9 Prüfungen)
- ✅ Best Practices für Container-Images (13 Prüfungen)
- ✅ Laufzeitsicherheitsvalidierung (31+ Prüfungen)
- ✅ Sicherheitsbetriebskonformität
#### 2. **Supply-Chain-Angriffserkennung** 🆕
Basiert auf realen Angriffskampagnen aus 2024:
- ✅ **Erkennung imageloser Container** – Identifiziert bösartige Container ohne tatsächliche Layerebenen (4M+ auf Docker Hub gefunden)
- ✅ **Erkennung von Kryptowährungs-Minern** – Erkennt Mining-Schadsoftware (120K+ schädliche Image-Pulls erkannt)
- ✅ **Erkennung von Hintertür-Bibliotheken** – Fängt kompromittierte Abhängigkeiten ein (xz-utils, liblzma-Vorfälle)
- ✅ **Überprüfung von Image-Signaturen** – Validiert Signaturen mit Notary/Cosign
- ✅ **Erkennung von Phishing-Inhalten** – Durchsucht Dokumentation nach Social Engineering
- ✅ **Schädliche Netzwerkziele** – Identifiziert C2-Server, Mining-Pools, Tor-Knoten
#### 3. **Erweiterte Geheimniserkennung** 🔑
40+ Geheimnis-Muster einschließlich moderner APIs (Update 2024):
- ✅ **Cloud-Anbieter**: AWS, GCP, Azure-Anmeldeinformationen
- ✅ **Versionskontrolle**: GitHub, GitLab, Bitbucket-Tokens
- ✅ **KI/ML-APIs**: OpenAI, Anthropic, Hugging Face-Schlüssel
- ✅ **Zahlungsdienste**: Stripe, PayPal, Square-Schlüssel
- ✅ **Kommunikation**: Slack, SendGrid, Twilio, Mailchimp
- ✅ **Authentifizierung**: JWT-Tokens, OAuth-Tokens
- ✅ **Kryptografie**: Private Schlüssel (RSA, SSH, PGP, EC, DSA), Zertifikate
- ✅ **Datenbanken**: PostgreSQL, MySQL, MongoDB-Verbindungsstrings
- ✅ **Docker**: Registry-Authentifizierungstokens
- ✅ **Entropieanalyse**: Shannon-Entropieberechnung für unbekannte Geheimnisse (>4.5 Schwelle)
#### 4. **CVE- und Schwachstellenscanning** 🚨
Erkennung kritischer CVEs aus 2024–2025:
- ✅ **CVE-2024-21626** – runc-Containerausbruch (CVSS 8.6)
- ✅ **CVE-2024-23651** – BuildKit-Cache-Vergiftung RCE (CVSS 9.1)
- ✅ **CVE-2024-23652** – BuildKit-Race-Condition (CVSS 7.5)
- ✅ **CVE-2024-23653** – BuildKit-Privilegienausweitung
- ✅ **CVE-2024-8695/8696** – Docker Desktop RCE (CVSS 8.8)
- ✅ **CVE-2025-9074** – Docker Desktop lokaler Zugriffsfehler
- ✅ Erkennung von End-of-Life-Basisimages
- ✅ Scanning bekannter verwundbarer Pakete
#### 5. **Laufzeitsicherheitsanalyse** ⚙️
Härtungsprüfungen für Container-Laufzeit:
- ✅ **Linux-Fähigkeitsaudit** – Erkennt gefährliche Fähigkeiten (CAP_SYS_ADMIN, CAP_NET_ADMIN usw.)
- ✅ **Seccomp-Profilvalidierung** – Stellt sicher, dass Systemaufruffilter aktiviert sind
- ✅ **AppArmor/SELinux-Prüfungen** – Überprüfung der obligatorischen Zugriffskontrolle
- ✅ **Erkennung privilegierter Container** – Identifiziert Container mit vollständigem Host-Zugriff
- ✅ **Namespace-Isolation** – Prüfungen von PID, IPC, Netzwerk, Benutzer-Namespace
- ✅ **Indikatoren für Containerausbrüche** – Erkennt gängige Escape-Techniken
### 📊 **Berichterstattung und Integration**
- **JSON** – Maschinenlesbare Ausgabe für Automatisierung
- **SARIF** – Native Integration mit:
- GitHub Security-Tab
- Azure DevOps
- VS Code-Erweiterungen
- GitLab-Sicherheits-Dashboards
- **Schönes CLI** – Farbcodierte Schweregrade mit Emojis
- **Exit-Codes** – CI/CD-freundlich (0=bereinigt, 1=Warnungen, 2=kritisch)
### 🚀 **Leistung**
- ⚡ **10x schneller** als Python-Alternativen
- 🔄 **Gleichzeitiges Scannen** mit Go-Goroutinen
- 💾 **Niedriger Speicherverbrauch** (~50–100 MB)
- 📦 **Einzelne Binärdatei** – Keine Abhängigkeiten
---
## 🆕 Neuerungen in v2.0?
DockerScan v2.0 ist eine **komplette Neuentwicklung** von Grund auf. Hier ist, was sich gegenüber v1.x geändert hat:
### Wichtige Änderungen
| Eigenschaft | v1.x (Python) | v2.0 (Go) |
|-------------|---------------|-----------|
| **Sprache** | Python 3.5+ | Go 1.21+ |
| **Leistung** | ~500 Images/Stunde | ~5000 Images/Stunde |
| **Speichernutzung** | 200–500 MB | 50–100 MB |
| **Verteilung** | pip install + Abhängigkeiten | Einzelne Binärdatei |
| **Sicherheitsscanner** | 2 Module | 5 Module |
| **CIS-Benchmark** | Teilweise | Vollständig v1.7.0 (80+ Prüfungen) |
| **Supply Chain** | ❌ Nicht verfügbar | ✅ Basierend auf 2024-Forschung |
| **Geheimnis-Muster** | 10 Muster | 40+ Muster |
| **CVE-Erkennung** | Basis | CVEs 2024–2025 |
| **Laufzeitsicherheit** | ❌ Nicht verfügbar | ✅ Vollständiges Fähigkeitsaudit |
| **SARIF-Ausgabe** | ❌ Nicht verfügbar | ✅ Vollständige Unterstützung |
| **CI/CD-Integration** | Manuell | Nativ (Exit-Codes, SARIF) |
### Was von v1.x beibehalten wurde
- ✅ **Offensive Werkzeuge** – Bild-Trojanisierungsfunktionen (kommen bald in v2.1)
- ✅ **Registry-Operationen** – Push, Pull, Delete-Operationen (kommen bald in v2.1)
- ✅ **Netzwerkscanning** – Docker-Registry-Erkennung (kommt bald in v2.1)
### Neu in v2.0.5 🔐
- 🔑 **Authentifizierung für private Registries** – Vollständige Unterstützung zum Scannen von Images aus privaten Registries (behebt #24)
- 🌐 **Multi-Registry-Unterstützung** – Docker Hub, GHCR, ECR, GCR, ACR, GitLab und selbstgehostete Registries
- 🔐 **Mehrere Authentifizierungsmethoden** – Umgebungsvariablen (CI/CD), CLI-Flags (Testen), Docker-Konfigurationsdatei (nahtlos)
- 🎯 **Intelligente Priorisierung** – CLI-Flags > ENV-Variablen > Docker-Konfiguration (automatische Auswahl)
- 📝 **Verbesserte Fehlermeldungen** – Registry-spezifische Hinweise (ECR-Token-Ablauf, Ratenbegrenzungen, Zertifikate)
- 🧪 **Umfassende Tests** – 64 Testfälle, 91,2% Abdeckung, getestet mit echter privater Registry
- 📚 **Vollständige Dokumentation** – Beispiele für alle großen Cloud-Registries und Authentifizierungsmethoden
### Neu in v2.0.4
- 🗄️ **CVE-Datenbankintegration** – Lokale SQLite-Datenbank mit NVD-Daten (2,5 Jahre CVEs)
- 🔄 **Tägliche automatische Updates** – GitHub Action aktualisiert die CVE-Datenbank jeden Tag
- ⚡ **Parallele CVE-Downloads** – 4 Worker für schnellere Datenbankerstellung (nvd2sqlite)
- 🔁 **Wiederholung mit Backoff** – Automatische Wiederholung bei ratenbegrenzten NVD-API-Anfragen
- 📦 **`--from-file`-Flag** – Installieren der CVE-Datenbank aus lokaler Datei (offline/air-gapped)
- 🔇 **Quiet-Modus (`-q`)** – Banner für CI/CD-Pipelines unterdrücken
- 🧹 **Weniger Fehlalarme** – Verbesserte Geheimniserkennung mit Entropiefilterung
### Warum die Neuentwicklung?
1. **Leistung** – Go bietet 10x schnelleres Scannen mit Goroutinen
2. **Moderne Bedrohungen** – Berücksichtigt Angriffsmuster aus 2024–2025
3. **Enterprise-Ready** – SARIF-Ausgabe, Exit-Codes, einzelne Binärdateien
4. **Erweiterbarkeit** – Saubere Plugin-Architektur für benutzerdefinierte Scanner
5. **Wartbarkeit** – Typsicherheit, bessere Fehlerbehandlung, einfacher beizutragen
---
## 📦 Installation
### Option 1: Vorkompilierte Binärdatei herunterladen (Empfohlen)
Vorkompilierte Binärdateien werden automatisch per GitHub Actions für jede Version erstellt und veröffentlicht.
**Unterstützte Plattformen:**
- **Linux**: amd64, arm64, 386
- **macOS**: amd64 (Intel), arm64 (Apple Silicon)
- **Windows**: amd64, arm64, 386
- **FreeBSD**: amd64
#### Linux (amd64)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/
```
#### Linux (arm64)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-arm64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/
```
#### macOS (Intel)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-darwin-amd64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/
```
#### macOS (Apple Silicon)```bash
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-darwin-arm64 -o dockerscan
chmod +x dockerscan
sudo mv dockerscan /usr/local/bin/
```
#### Windows (PowerShell)```powershell
Invoke-WebRequest -Uri "https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-windows-amd64.exe" -OutFile "dockerscan.exe"
```
#### Download überprüfen (Optional, aber empfohlen)```bash
# Download checksums
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/checksums.txt -o checksums.txt
# Verify (Linux/macOS)
sha256sum -c checksums.txt --ignore-missing
```
### Option 2: Aus dem Quellcode erstellen```bash
# Clone repository
git clone https://github.com/cr0hn/dockerscan
cd dockerscan/dockerscan-v2
# Build
make build
# Install
sudo make install
# Or build manually
go build -o bin/dockerscan ./cmd/dockerscan
```
### Option 3: Go installieren```bash
go install github.com/cr0hn/dockerscan/v2/cmd/dockerscan@latest
```
---
## 🚀 Schnellstart
### Erstmalige Einrichtung
Vor dem Scannen die CVE-Datenbank herunterladen (täglich aktualisiert, ~30 MB komprimiert):```bash
# Download latest CVE database from GitHub
dockerscan update-db
```
> **Tipp**: Die Datenbank wird täglich über GitHub Actions aktualisiert. Führen Sie `update-db` regelmäßig aus, um die neuesten CVE-Daten zu erhalten.
### Basis-Scan```bash
# Scan a Docker image
dockerscan nginx:latest
# Scan with specific scanners
dockerscan --scanners cis,secrets ubuntu:22.04
# Scan and save reports
dockerscan alpine:latest --output /tmp/reports
# Quiet mode (suppress banner)
dockerscan -q nginx:latest
```
### Beispielausgabe```
╔══════════════════════════════════════════════════════════════════════════╗
║ ██████╗ ██████╗ ██████╗██╗ ██╗███████╗██████╗ ███████╗ ██████╗ █████╗ ███╗ ██╗
║ ██╔══██╗██╔═══██╗██╔════╝██║ ██╔╝██╔════╝██╔══██╗██╔════╝██╔════╝██╔══██╗████╗ ██║
║ ██║ ██║██║ ██║██║ █████╔╝ █████╗ ██████╔╝███████╗██║ ███████║██╔██╗ ██║
║ ██║ ██║██║ ██║██║ ██╔═██╗ ██╔══╝ ██╔══██╗╚════██║██║ ██╔══██║██║╚██╗██║
║ ██████╔╝╚██████╔╝╚██████╗██║ ██╗███████╗██║ ██║███████║╚██████╗██║ ██║██║ ╚████║
║ ║
║ Advanced Docker Security Scanner v2.0.0 ║
║ ║
║ Author: Daniel Garcia (cr0hn) ║
║ Website: https://cr0hn.com ║
╚══════════════════════════════════════════════════════════════════════════════════════╝
🔍 Scanning image: nginx:latest
═══════════════════════════════════════════════════════════════════
SCAN RESULTS
═══════════════════════════════════════════════════════════════════
📊 Summary:
Total Findings: 47
Duration: 2.3s
🔴 By Severity:
Critical: 8
High: 15
Medium: 18
Low: 6
📁 By Category:
CIS-Benchmark: 12
Secrets: 8
Supply-Chain: 5
Vulnerability: 10
Runtime-Security: 12
📄 JSON report saved to: dockerscan-report.json
📄 SARIF report saved to: dockerscan-report.sarif
```
---
## 📖 Verwendung
### Befehlszeilenoptionen```bash
dockerscan [COMMAND] [OPTIONS] <IMAGE>
Commands:
scan Scan a Docker image (default)
update-db Download or update the CVE database
Options: --from-file <path> Install from local SQLite file
version Show version information
help Show help message
Options:
-h, --help Show help message
-v, --version Show version
-q, --quiet Suppress banner output (quiet mode)
--scanners SCANNERS Comma-separated list of scanners to run
(default: all)
Options: cis,secrets,supplychain,vulnerabilities,runtime
--output DIR Output directory for reports (default: .)
--only-critical Show only critical/high severity findings
--verbose, -v Show scan progress (scanner names, findings count, image pull status). Output to stderr.
--debug Show verbose output plus internal errors and technical details. Output to stderr.
Authentication (for private registries):
--registry-user <username> Registry username
--registry-password <password> Registry password (not recommended, use env vars)
--registry <url> Registry URL (optional, auto-detected from image)
--docker-config <path> Path to Docker config file (default: ~/.docker/config.json)
Environment variables (recommended for CI/CD):
DOCKER_USERNAME or REGISTRY_USERNAME Registry username
DOCKER_PASSWORD or REGISTRY_PASSWORD Registry password or token
DOCKER_REGISTRY or REGISTRY Registry URL (optional)
Exit Codes:
0 No issues found
1 HIGH severity issues found
2 CRITICAL severity found
```
### Beispiele```bash
# Scan with all scanners (default)
dockerscan myapp:latest
# Only run specific scanners
dockerscan --scanners secrets,supplychain redis:7
# Save reports to specific directory
dockerscan --output /var/reports postgres:14
# Only show critical issues
dockerscan --only-critical production-app:v1.0
# Ver progreso del scan (scanner names, findings count, image pull status)
dockerscan --verbose ubuntu:22.04
# Debug detallado (errores internos, detalles técnicos)
dockerscan --debug ubuntu:22.04
# Scan private registry images (see Authentication section below)
dockerscan ghcr.io/myorg/private-app:v1.0
```
### 🔐 Private Registry-Authentifizierung
DockerScan unterstützt drei Methoden zur Authentifizierung bei privaten Registrierungen:
#### Methode 1: Docker Config-Datei (empfohlen für die lokale Nutzung)
Die bequemste Methode – verwendet Ihre vorhandenen Docker-Anmeldeinformationen:```bash
# First, authenticate with your registry using Docker
docker login ghcr.io
# Username: your-username
# Password: ghp_your-token-here
# Now DockerScan can use these credentials automatically
dockerscan ghcr.io/myorg/private-app:latest
```
DockerScan liest automatisch Anmeldeinformationen aus `~/.docker/config.json`. Dies funktioniert mit allen Registries, bei denen Sie sich mit `docker login` angemeldet haben.
**Credential-Helper werden vollständig unterstützt.** DockerScan löst Anmeldeinformationen nativ über Folgendes auf:
- **`credsStore`** — globaler Credential-Helper (z. B. `osxkeychain` auf macOS mit Docker Desktop, `wincred` auf Windows, `pass` auf Linux)
- **`credHelpers`** — pro-Registry Credential-Helper (hat Vorrang vor `credsStore`)
- **Automatischer Fallback** — falls das angegebene Helper-Binary nicht installiert ist, greift DockerScan auf den Klartext-`auths`-Block in `config.json` zurück
Auf **macOS mit Docker Desktop** funktioniert dies ohne zusätzliche Konfiguration sofort:```json
{
"credsStore": "osxkeychain"
}
```
DockerScan ruft `docker-credential-osxkeychain` transparent auf, um Tokens abzurufen, sodass Sie nie explizit Anmeldedaten übergeben müssen.
#### Methode 2: Umgebungsvariablen (empfohlen für CI/CD)
Am besten geeignet für automatisierte Umgebungen und CI/CD-Pipelines:```bash
# Set environment variables
export DOCKER_USERNAME=myusername
export DOCKER_PASSWORD=mytoken
# Scan private image
dockerscan ghcr.io/myorg/private-app:latest
# Or use alternative variable names
export REGISTRY_USERNAME=myusername
export REGISTRY_PASSWORD=mytoken
dockerscan myregistry.example.com/app:v1.0
```
**CI/CD Beispiel (GitHub Actions):**```yaml
- name: Scan private image
env:
DOCKER_USERNAME: ${{ secrets.REGISTRY_USERNAME }}
DOCKER_PASSWORD: ${{ secrets.REGISTRY_TOKEN }}
run: dockerscan ghcr.io/${{ github.repository }}:${{ github.sha }}
```
#### Methode 3: Kommandozeilen-Flags (Nicht empfohlen)
Nur für schnelle Tests (Anmeldedaten in der Prozessliste sichtbar):```bash
dockerscan --registry-user myuser --registry-password mytoken ghcr.io/myorg/app:v1
```
**Sicherheitshinweis:** Diese Methode gibt Anmeldeinformationen in Ihrem Shell-Verlauf und der Prozessliste preis. Verwenden Sie stattdessen Umgebungsvariablen oder die Docker-Konfiguration.
### Registrierungsspezifische Beispiele
#### Docker Hub (Private Repositories)```bash
# Using Docker config
docker login docker.io
dockerscan myusername/private-repo:latest
# Using environment variables
export DOCKER_USERNAME=myusername
export DOCKER_PASSWORD=dckr_pat_XXXXXXXXXXXXX
dockerscan myusername/private-repo:latest
```
#### GitHub Container Registry (GHCR)```bash
# Using Docker config
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin
dockerscan ghcr.io/myorg/myapp:v1.0
# Using environment variables
export DOCKER_USERNAME=myusername
export DOCKER_PASSWORD=ghp_XXXXXXXXXXXXXXXXXXXX
dockerscan ghcr.io/myorg/myapp:v1.0
```
#### AWS Elastic Container Registry (ECR)```bash
# Get login credentials from AWS
aws ecr get-login-password --region us-east-1 | \
docker login --username AWS --password-stdin \
123456789012.dkr.ecr.us-east-1.amazonaws.com
# Scan ECR image
dockerscan 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest
# Or use environment variables with ECR credentials
export DOCKER_USERNAME=AWS
export DOCKER_PASSWORD=$(aws ecr get-login-password --region us-east-1)
dockerscan 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest
```
#### Google Container Registry (GCR) / Artifact Registry```bash
# Authenticate with gcloud
gcloud auth configure-docker gcr.io
# Scan GCR image
dockerscan gcr.io/my-project/myapp:latest
# For Artifact Registry
gcloud auth configure-docker us-docker.pkg.dev
dockerscan us-docker.pkg.dev/my-project/my-repo/myapp:latest
# Or use service account JSON key
export DOCKER_USERNAME=_json_key
export DOCKER_PASSWORD="$(cat service-account-key.json)"
dockerscan gcr.io/my-project/myapp:latest
```
#### Azure Container Registry (ACR)```bash
# Login with Azure CLI
az acr login --name myregistry
# Scan ACR image
dockerscan myregistry.azurecr.io/myapp:v1.0
# Or use service principal credentials
export DOCKER_USERNAME=<service-principal-id>
export DOCKER_PASSWORD=<service-principal-password>
dockerscan myregistry.azurecr.io/myapp:v1.0
```
#### GitLab Container Registry```bash
# Using Docker config
docker login registry.gitlab.com
dockerscan registry.gitlab.com/mygroup/myproject/myapp:latest
# Using environment variables with deploy token
export DOCKER_USERNAME=gitlab+deploy-token-1
export DOCKER_PASSWORD=DEPLOY_TOKEN_HERE
dockerscan registry.gitlab.com/mygroup/myproject/myapp:latest
```
#### Selbstgehostete/Private Registries```bash
# Standard authentication
docker login myregistry.example.com:5000
dockerscan myregistry.example.com:5000/myapp:latest
# With environment variables
export DOCKER_USERNAME=admin
export DOCKER_PASSWORD=secret
dockerscan myregistry.example.com:5000/myapp:latest
# Insecure registries (not recommended for production)
# Add to Docker daemon config: /etc/docker/daemon.json
# {
# "insecure-registries": ["myregistry.example.com:5000"]
# }
```
### Fehlerbehebung bei der Authentifizierung
#### Häufige Probleme
**1. Fehler "authentication required"**```bash
# Make sure you're logged in
docker login <registry>
# Or set environment variables
export DOCKER_USERNAME=your-username
export DOCKER_PASSWORD=your-token
```
**2. Fehler "unauthorized: authentication failed"**
- Überprüfen Sie, ob Ihre Anmeldedaten korrekt sind.
- Überprüfen Sie, ob Ihr Token abgelaufen ist (insbesondere bei Cloud-Anbietern).
- Stellen Sie sicher, dass Ihr Konto Pull-Berechtigungen für das Image hat.
**3. AWS ECR "authorization token has expired"**```bash
# ECR tokens expire after 12 hours - refresh them
aws ecr get-login-password --region us-east-1 | \
docker login --username AWS --password-stdin \
123456789012.dkr.ecr.us-east-1.amazonaws.com
```
**4. Ratenbegrenzung auf Docker Hub**
- Authentifizierung, um die Ratenlimits zu erhöhen (200 Pulls/6 Stunden für kostenlose Konten)
- Erwägen Sie die Nutzung eines Docker Hub Pro-Kontos für höhere Grenzen
**5. Zertifikatsfehler bei selbstsignierten Zertifikaten**
- Fügen Sie das CA-Zertifikat Ihrem System-Vertrauensspeicher hinzu
- Oder konfigurieren Sie Docker so, dass es der Registry vertraut (siehe Docker-Dokumentation)
---
## 🔍 Sicherheitsscanner
### CIS Docker Benchmark
Automatisierte Compliance-Prüfung gegen CIS Docker Benchmark v1.7.0:```bash
dockerscan --scanners cis nginx:latest
```
Checks include:
- Container-Benutzer ist nicht root
- Keine unnötigen Pakete installiert
- HEALTHCHECK-Anweisung vorhanden
- Spezifische Versionstags (nicht `:latest`)
- Minimale exponierte Ports
- Keine privilegierten Container
- Linux-Capabilities eingeschränkt
- Seccomp/AppArmor-Profile angewendet
- Schreibgeschütztes Root-Dateisystem
- Und 70+ weitere Prüfungen...
### Supply Chain Security
Erkennung realer Supply-Chain-Angriffe:```bash
dockerscan --scanners supplychain suspicious-image:1.0
```
Erkennt:
- Bilder-lose Container (dokumentationsbasierte Angriffe)
- Kryptowährungs-Miner (xmrig, claymore, etc.)
- Backdoor-Bibliotheken (xz-utils Fall)
- Nicht signierte/unverifizierte Images
- Phishing-Versuche in Dokumentationen
- Verbindungen zu Mining-Pools, C2-Servern
### Geheimniserkennung
Hartcodierte Geheimnisse finden:```bash
dockerscan --scanners secrets webapp:prod
```
Findet:
- Cloud-Anmeldeinformationen (AWS, GCP, Azure)
- API-Schlüssel (40+ Dienste)
- Private Schlüssel und Zertifikate
- Datenbank-Anmeldeinformationen
- Docker-Registry-Authentifizierung
- Zeichenketten mit hoher Entropie (potenziell unbekannte Geheimnisse)
### Schwachstellenscanning
Erkennt bekannte CVEs:```bash
dockerscan --scanners vulnerabilities node:16
```
Prüft auf:
- Kritische Docker-CVEs (2024-2025)
- Container-Ausbruch-Sicherheitslücken
- BuildKit RCE-Sicherheitslücken
- End-of-Life-Basis-Images
- Verwundbare Pakete
### Laufzeitsicherheit
Prüfung der Laufzeitkonfigurationen:```bash
dockerscan --scanners runtime running-container
```
Analysiert:
- Linux capabilities (CAP_SYS_ADMIN, etc.)
- Seccomp-Profile
- AppArmor/SELinux-Richtlinien
- Namespace-Isolation
- Nutzung des privilegierten Modus
---
## 📁 Ausgabeformate
### JSON-Ausgabe```json
{
"target": {
"image_name": "nginx:latest"
},
"start_time": "2024-11-22T10:30:00Z",
"findings": [
{
"id": "CIS-4.1",
"title": "Container should not run as root",
"severity": "HIGH",
"category": "CIS-Benchmark",
"description": "Running containers as root increases attack surface...",
"remediation": "Use USER instruction in Dockerfile..."
}
],
"summary": {
"total_findings": 47,
"by_severity": {
"CRITICAL": 8,
"HIGH": 15
}
}
}
```
### SARIF-Ausgabe
Kompatibel mit GitHub Security, Azure DevOps, VS Code:```json
{
"$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
"version": "2.1.0",
"runs": [
{
"tool": {
"driver": {
"name": "DockerScan",
"version": "2.0.0"
}
},
"results": [...]
}
]
}
```
---
## 💼 Anwendungsfälle
### 1. **CI/CD-Pipeline-Integration**
**GitHub Actions:**```yaml
name: Docker Security Scan
on: [push]
jobs:
security-scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Build Docker image
run: docker build -t myapp:${{ github.sha }} .
- name: Install DockerScan
run: |
curl -L https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -o dockerscan
chmod +x dockerscan
- name: Update CVE Database
run: ./dockerscan update-db
- name: Run Security Scan
run: ./dockerscan -q myapp:${{ github.sha }}
- name: Upload SARIF results
uses: github/codeql-action/upload-sarif@v2
with:
sarif_file: dockerscan-report.sarif
```
**GitLab CI:**```yaml
docker-security-scan:
stage: test
script:
- docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
- wget https://github.com/cr0hn/dockerscan/releases/latest/download/dockerscan-linux-amd64 -O dockerscan
- chmod +x dockerscan
- ./dockerscan update-db
- ./dockerscan -q $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
artifacts:
reports:
sast: dockerscan-report.sarif
```
### 2. **Sicherheitsaudits**```bash
# Comprehensive audit of production images
for image in $(docker images --format "{{.Repository}}:{{.Tag}}"); do
echo "Scanning $image..."
dockerscan $image --output /audit-reports/
done
# Generate summary report
cat /audit-reports/*.json | jq -s '
{
total_images: length,
total_findings: map(.summary.total_findings) | add,
critical_findings: map(.summary.by_severity.CRITICAL // 0) | add
}
'
```
### 3. **Validierung vor der Bereitstellung**```bash
# Fail deployment if critical issues found
dockerscan production-app:v2.0
exit_code=$?
if [ $exit_code -eq 2 ]; then
echo "❌ Critical vulnerabilities found. Deployment blocked."
exit 1
elif [ $exit_code -eq 1 ]; then
echo "⚠️ High severity issues found. Manual review required."
# Send notification...
else
echo "✅ No critical issues. Proceeding with deployment."
fi
```
### 4. **Compliance-Berichterstattung**```bash
# Generate CIS compliance report
dockerscan --scanners cis --only-critical all-production-images:* > cis-compliance-report.txt
# Weekly security scan for compliance
0 0 * * 0 /usr/local/bin/dockerscan --scanners cis,vulnerabilities production-images:latest --output /compliance/weekly/
```
### 5. **Entwickler-Workflow**```bash
# Pre-commit hook
#!/bin/bash
# .git/hooks/pre-commit
docker build -t local-test:latest .
dockerscan --only-critical local-test:latest
if [ $? -ne 0 ]; then
echo "❌ Docker security scan failed. Fix issues before committing."
exit 1
fi
```
---
## 📊 Vergleich mit anderen Werkzeugen
| Funktion | DockerScan v2.0 | Trivy | Clair | Snyk | Grype |
|---------|----------------|-------|-------|------|-------|
| **CIS Benchmark v1.7** | ✅ Vollständig (80+ Prüfungen) | ❌ | ❌ | Teilweise | ❌ |
| **Erkennung von Lieferkettenangriffen (2024)** | ✅ Ja | ❌ | ❌ | ❌ | ❌ |
| **Geheimnisüberprüfung** | ✅ 40+ Muster | Basis | ❌ | ✅ | ❌ |
| **CVE-Datenbank** | ✅ 2024-2025 CVEs | ✅ | ✅ | ✅ | ✅ |
| **Laufzeitsicherheit** | ✅ Vollständig | ❌ | ❌ | ❌ | ❌ |
| **SARIF-Ausgabe** | ✅ | ✅ | ❌ | ✅ | ✅ |
| **Geschwindigkeit (Go)** | ⚡ Sehr schnell | ⚡ Sehr schnell | 🐌 Langsam | ⚡ Schnell | ⚡ Sehr schnell |
| **Erweiterbar** | ✅ Plugin-System | Eingeschränkt | Eingeschränkt | ❌ | Eingeschränkt |
| **Exit-Codes** | ✅ CI/CD bereit | ✅ | Teilweise | ✅ | ✅ |
| **Kosten** | 🆓 Kostenlos | 🆓 Kostenlos | 🆓 Kostenlos | 💰 Kostenpflichtige Stufen | 🆓 Kostenlos |
| **Offline-Modus** | ✅ | ✅ | ❌ | ❌ | ✅ |
| **Lizenz** | Proprietär, Quelltext verfügbar | Apache-2.0 | Apache-2.0 | Proprietär | Apache-2.0 |
### Warum DockerScan wählen?
- **Umfassendste Lösung**: Einziges Werkzeug, das CIS + Lieferkette + Geheimnisse + CVE + Laufzeit kombiniert
- **Aktuellste Forschung**: Basiert auf realen Angriffen von 2024-2025
- **Keine Konfiguration erforderlich**: Funktioniert sofort einsatzbereit
- **Entwicklerfreundlich**: Schöne CLI-Ausgabe mit umsetzbaren Korrekturmaßnahmen
- **Unternehmensbereit**: SARIF + Exit-Codes + JSON-Ausgabe
---
## 🏗️ Architektur
### Projektstruktur```
dockerscan/
├── logo.png # Project logo
├── cmd/
│ ├── dockerscan/ # Main CLI application
│ │ └── main.go
│ └── nvd2sqlite/ # CVE database builder tool
│ └── main.go
├── data/ # CVE database (auto-updated daily)
│ ├── latest.db.gz # Compressed SQLite database
│ └── metadata.json # Database version info
├── internal/
---
[Read more](https://github.com/cr0hn/dockerscan)