cr0hn/dockerscanIl più completo scanner di sicurezza per Docker
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/1309/3345979faae1cdabbe2912dfcaf46221df5cb53697630a8e8dcc5eebf814e949.png" alt="DockerScan Logo" width="200">
# DockerScan v2.0
### *Lo scanner di sicurezza Docker più completo*
[](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)
**Di [Daniel Garcia (cr0hn)](https://cr0hn.com)** | [GitHub](https://github.com/cr0hn/dockerscan) | [Sito web](https://cr0hn.com)
---
[Funzionalità](#-features) •
[Installazione](#-installation) •
[Avvio rapido](#-quick-start) •
[Documentazione](#-documentation) •
[Casi d'uso](#-use-cases) •
[Novità](#-whats-new-in-v20) •
[Contribuire](#-contributing)
</div>
---
## 📑 Indice
- [Panoramica](#-overview)
- [Funzionalità](#-features)
- [Novità in v2.0](#-whats-new-in-v20)
- [Installazione](#-installation)
- [Avvio rapido](#-quick-start)
- [Utilizzo](#-usage)
- [Autenticazione registro privato](#-private-registry-authentication)
- [Scanner di sicurezza](#-security-scanners)
- [Formati di output](#-output-formats)
- [Casi d'uso](#-use-cases)
- [Confronto con altri strumenti](#-comparison-with-other-tools)
- [Architettura](#-architecture)
- [Contribuire](#-contributing)
- [Riferimenti](#-references)
- [Licenza](#-license)
- [Autore](#-author)
---
## 🎯 Panoramica
**DockerScan v2.0** è uno scanner di sicurezza di nuova generazione per container e immagini Docker, completamente riscritto in Go. Combina molteplici tecniche di scansione di sicurezza basate sulle ultime ricerche 2024-2025, standard di settore (CIS Benchmark, NIST SP 800-190) e pattern di attacco reali scoperti in ambienti di produzione.
### Perché DockerScan v2.0?
- ✅ **Più completo**: Combina 5+ tecniche di scansione di sicurezza in un unico strumento
- ✅ **Ricerca più recente**: Basato su attacchi alla supply chain e CVE del 2024-2025
- ✅ **Pronto per la produzione**: Output SARIF per CI/CD, codici di uscita per automazione
- ✅ **Veloce**: Scritto in Go con scansione concorrente
- ✅ **Estensibile**: Architettura a plugin per scanner personalizzati
- ✅ **Gratuito e open source**: Licenza BSD-3
---
## 🌟 Funzionalità
### 🛡️ **Moduli di scansione di sicurezza**
#### 1. **CIS Docker Benchmark v1.7.0**
Controllo completo della conformità con oltre 80 verifiche automatizzate:
- ✅ Sicurezza della configurazione host (13 controlli)
- ✅ Hardening del demone Docker (18 controlli)
- ✅ Permessi di file e directory (9 controlli)
- ✅ Best practice per immagini container (13 controlli)
- ✅ Validazione della sicurezza runtime (31+ controlli)
- ✅ Conformità delle operazioni di sicurezza
#### 2. **Rilevamento attacchi alla supply chain** 🆕
Basato su campagne di attacco reali del 2024:
- ✅ **Rilevamento container senza immagine** - Identifica container malintenzionati senza layer reali (4M+ trovati su Docker Hub)
- ✅ **Rilevamento miner di criptovalute** - Individua malware miner (120K+ pull di immagini dannose rilevati)
- ✅ **Rilevamento librerie backdoorate** - Cattura dipendenze compromesse (incidenti xz-utils, liblzma)
- ✅ **Verifica firma immagine** - Convalida firme tramite Notary/Cosign
- ✅ **Rilevamento contenuti phishing** - Scansiona documentazione per ingegneria sociale
- ✅ **Destinazioni di rete dannose** - Identifica server C2, pool di mining, nodi Tor
#### 3. **Rilevamento avanzato di segreti** 🔑
Oltre 40 pattern di segreti inclusi API moderni (aggiornamento 2024):
- ✅ **Provider cloud**: Credenziali AWS, GCP, Azure
- ✅ **Controllo versione**: Token GitHub, GitLab, Bitbucket
- ✅ **API AI/ML**: Chiavi OpenAI, Anthropic, Hugging Face
- ✅ **Pagamenti**: Chiavi Stripe, PayPal, Square
- ✅ **Comunicazione**: Chiavi Slack, SendGrid, Twilio, Mailchimp
- ✅ **Autenticazione**: Token JWT, token OAuth
- ✅ **Crypto**: Chiavi private (RSA, SSH, PGP, EC, DSA), certificati
- ✅ **Database**: Stringhe di connessione PostgreSQL, MySQL, MongoDB
- ✅ **Docker**: Token di autenticazione registry
- ✅ **Analisi entropia**: Calcolo entropia Shannon per segreti sconosciuti (soglia >4.5)
#### 4. **Scansione CVE e vulnerabilità** 🚨
Rilevamento di CVE critici 2024-2025:
- ✅ **CVE-2024-21626** - Escape container runc (CVSS 8.6)
- ✅ **CVE-2024-23651** - Avvelenamento cache BuildKit RCE (CVSS 9.1)
- ✅ **CVE-2024-23652** - Condizione di competizione BuildKit (CVSS 7.5)
- ✅ **CVE-2024-23653** - Escalation privilegi BuildKit
- ✅ **CVE-2024-8695/8696** - RCE Docker Desktop (CVSS 8.8)
- ✅ **CVE-2025-9074** - Vulnerabilità accesso locale Docker Desktop
- ✅ Rilevamento immagini base fine vita
- ✅ Scansione pacchetti vulnerabili noti
#### 5. **Analisi della sicurezza in esecuzione** ⚙️
Controlli di hardening runtime container:
- ✅ **Audit capacità Linux** - Rileva capacità pericolose (CAP_SYS_ADMIN, CAP_NET_ADMIN, ecc.)
- ✅ **Validazione profilo Seccomp** - Assicura che il filtraggio delle syscall sia abilitato
- ✅ **Controlli AppArmor/SELinux** - Verifica controllo accessi obbligatorio
- ✅ **Rilevamento container privilegiati** - Identifica container con accesso completo all'host
- ✅ **Isolamento namespace** - Controlli namespace PID, IPC, rete, utente
- ✅ **Indicatori di escape container** - Rileva tecniche di escape comuni
### 📊 **Reporting e integrazione**
- **JSON** - Output leggibile da macchina per automazione
- **SARIF** - Integrazione nativa con:
- Scheda Sicurezza GitHub
- Azure DevOps
- Estensioni VS Code
- Dashboard di sicurezza GitLab
- **CLI accattivante** - Livelli di gravità colorati con emoji
- **Codici di uscita** - Adatto per CI/CD (0=pulito, 1=avvisi, 2=critico)
### 🚀 **Prestazioni**
- ⚡ **10x più veloce** rispetto ad alternative Python
- 🔄 **Scansione concorrente** con goroutine Go
- 💾 **Bassa memoria** (~50-100 MB)
- 📦 **Singolo binario** - Nessuna dipendenza
---
## 🆕 Novità in v2.0?
DockerScan v2.0 è una **riscrittura completa** da zero. Ecco cosa è cambiato rispetto a v1.x:
### Modifiche principali
| Caratteristica | v1.x (Python) | v2.0 (Go) |
|---------------|---------------|-----------|
| **Linguaggio** | Python 3.5+ | Go 1.21+ |
| **Prestazioni** | ~500 immagini/ora | ~5000 immagini/ora |
| **Utilizzo memoria** | 200-500 MB | 50-100 MB |
| **Distribuzione** | pip install + dipendenze | Singolo binario |
| **Scanner di sicurezza** | 2 moduli | 5 moduli |
| **CIS Benchmark** | Parziale | Completo v1.7.0 (80+ controlli) |
| **Supply chain** | ❌ Non disponibile | ✅ Basato su ricerca 2024 |
| **Pattern segreti** | 10 pattern | 40+ pattern |
| **Rilevamento CVE** | Base | CVE 2024-2025 |
| **Sicurezza runtime** | ❌ Non disponibile | ✅ Audit completo capacità |
| **Output SARIF** | ❌ Non disponibile | ✅ Supporto completo |
| **Integrazione CI/CD** | Manuale | Nativo (codici di uscita, SARIF) |
### Cosa è stato conservato dalla v1.x
- ✅ **Strumenti offensivi** - Capacità di trojanizzazione delle immagini (disponibili in v2.1)
- ✅ **Operazioni registry** - Operazioni push, pull, delete (disponibili in v2.1)
- ✅ **Scansione rete** - Scoperta registry Docker (disponibile in v2.1)
### Novità in v2.0.5 🔐
- 🔑 **Autenticazione registro privato** - Supporto completo per la scansione di immagini da registry privati (corregge #24)
- 🌐 **Supporto multi-registry** - Docker Hub, GHCR, ECR, GCR, ACR, GitLab e registry self-hosted
- 🔐 **Metodi di autenticazione multipli** - Variabili d'ambiente (CI/CD), flag CLI (test), file di configurazione Docker (senza soluzione di continuità)
- 🎯 **Priorità autenticazione intelligente** - Flag CLI > Variabili d'ambiente > Config Docker (selezione automatica)
- 📝 **Messaggi di errore migliorati** - Suggerimenti specifici per registry (scadenza token ECR, limiti di frequenza, certificati)
- 🧪 **Test completi** - 64 casi di test, copertura 91.2%, testato con vero registry privato
- 📚 **Documentazione completa** - Esempi per tutti i principali registry cloud e metodi di autenticazione
### Novità in v2.0.4
- 🗄️ **Integrazione database CVE** - Database SQLite locale con dati NVD (2.5 anni di CVE)
- 🔄 **Aggiornamenti automatici giornalieri** - GitHub Action aggiorna il database CVE ogni giorno
- ⚡ **Download CVE paralleli** - 4 worker per build più veloce del database (nvd2sqlite)
- 🔁 **Retry con backoff** - Riprova automatica per richieste NVD limitate in frequenza
- 📦 **Flag `--from-file`** - Installa database CVE da file locale (offline/air-gapped)
- 🔇 **Modalità silenziosa (`-q`)** - Sopprime banner per pipeline CI/CD
- 🧹 **Falsi positivi ridotti** - Miglioramento rilevamento segreti con filtro entropia
### Perché la riscrittura?
1. **Prestazioni** - Go fornisce scansione 10x più veloce con goroutine
2. **Minacce moderne** - Incorpora pattern di attacco 2024-2025
3. **Pronto per aziende** - Output SARIF, codici di uscita, distribuzione binario singolo
4. **Estensibilità** - Architettura pulita a plugin per scanner personalizzati
5. **Manutenibilità** - Sicurezza dei tipi, migliore gestione errori, più facile contribuire
---
## 📦 Installazione
### Opzione 1: Scarica il binario precompilato (consigliato)
I binari precompilati vengono automaticamente costruiti e rilasciati tramite GitHub Actions per ogni tag di versione.
**Piattaforme supportate:**
- **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"
```
#### Verifica Download (Opzionale ma Raccomandata)```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
```
### Opzione 2: Compila dal sorgente```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
```
### Opzione 3: Installazione con Go```bash
go install github.com/cr0hn/dockerscan/v2/cmd/dockerscan@latest
```
---
## 🚀 Avvio Rapido
### Configurazione Iniziale
Prima di eseguire la scansione, scarica il database CVE (aggiornato quotidianamente, ~30MB compresso):```bash
# Download latest CVE database from GitHub
dockerscan update-db
```
> **Suggerimento**: Il database viene aggiornato quotidianamente tramite GitHub Actions. Esegui `update-db` periodicamente per ottenere gli ultimi dati CVE.
### Scansione di Base```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
```
### Output di esempio```
╔══════════════════════════════════════════════════════════════════════════╗
║ ██████╗ ██████╗ ██████╗██╗ ██╗███████╗██████╗ ███████╗ ██████╗ █████╗ ███╗ ██╗
║ ██╔══██╗██╔═══██╗██╔════╝██║ ██╔╝██╔════╝██╔══██╗██╔════╝██╔════╝██╔══██╗████╗ ██║
║ ██║ ██║██║ ██║██║ █████╔╝ █████╗ ██████╔╝███████╗██║ ███████║██╔██╗ ██║
║ ██║ ██║██║ ██║██║ ██╔═██╗ ██╔══╝ ██╔══██╗╚════██║██║ ██╔══██║██║╚██╗██║
║ ██████╔╝╚██████╔╝╚██████╗██║ ██╗███████╗██║ ██║███████║╚██████╗██║ ██║██║ ╚████║
║ ║
║ 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
```
---
## 📖 Utilizzo
### Opzioni da riga di comando```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
```
### Esempi```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
```
### 🔐 Autenticazione del Registry Privato
DockerScan supporta tre metodi per l'autenticazione con registry privati:
#### Metodo 1: File di Configurazione Docker (Consigliato per Uso Locale)
Il metodo più conveniente: utilizza le tue credenziali Docker esistenti:```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 legge automaticamente le credenziali da `~/.docker/config.json`. Questo funziona con tutti i registri a cui hai effettuato l'accesso tramite `docker login`.
**I credential helper sono pienamente supportati.** DockerScan risolve nativamente le credenziali tramite:
- **`credsStore`** — helper globale per le credenziali (es. `osxkeychain` su macOS con Docker Desktop, `wincred` su Windows, `pass` su Linux)
- **`credHelpers`** — helper per credenziali per registro specifico (ha precedenza su `credsStore`)
- **Fallback automatico** — se il binario helper specificato non è installato, DockerScan torna al blocco `auths` in chiaro in `config.json`
Su **macOS con Docker Desktop**, questo funziona senza ulteriore configurazione:```json
{
"credsStore": "osxkeychain"
}
```
DockerScan chiama `docker-credential-osxkeychain` in modo trasparente per recuperare i token, quindi non è mai necessario passare le credenziali esplicitamente.
#### Metodo 2: Variabili d'Ambiente (Consigliato per CI/CD)
Ideale per ambienti automatizzati e pipeline CI/CD:```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
```
**Esempio CI/CD (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 }}
```
#### Metodo 3: Flag da Riga di Comando (Non Raccomandato)
Solo per test rapidi (credenziali visibili nell'elenco dei processi):```bash
dockerscan --registry-user myuser --registry-password mytoken ghcr.io/myorg/app:v1
```
**Avviso di sicurezza:** Questo metodo espone le credenziali nella cronologia della shell e nell'elenco dei processi. Utilizza invece variabili d'ambiente o la configurazione Docker.
### Esempi Specifici per Registry
#### Docker Hub (Repository Privati)```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
```
#### Registro Container di GitHub (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
```
#### Registri Auto-ospitati/Privati```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"]
# }
```
### Risoluzione dei problemi di autenticazione
#### Problemi comuni
**1. "authentication required" errore**```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. Errore "unauthorized: authentication failed"**
- Verifica che le tue credenziali siano corrette
- Controlla se il tuo token è scaduto (soprattutto per i provider cloud)
- Assicurati che il tuo account abbia i permessi di pull per l'immagine
**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. Limitazione della frequenza su Docker Hub**
- Autenticati per aumentare i limiti di download (200 pull/6 ore per account gratuiti)
- Considera l'uso di un account Docker Hub Pro per limiti più alti
**5. Errori di certificato con certificati autofirmati**
- Aggiungi il certificato CA al trust store di sistema
- Oppure configura Docker per fidarsi del registry (consulta la documentazione di Docker)
---
## 🔍 Scanner di sicurezza
### CIS Docker Benchmark
Verifica automatizzata della conformità rispetto a CIS Docker Benchmark v1.7.0:```bash
dockerscan --scanners cis nginx:latest
```
I controlli includono:
- L'utente del container non è root
- Nessun pacchetto superfluo installato
- Istruzione HEALTHCHECK presente
- Tag di versione specifici (non `:latest`)
- Porte esposte minime
- Nessun container privilegiato
- Linux capabilities limitate
- Profili Seccomp/AppArmor applicati
- Filesystem root in sola lettura
- E altri 70+ controlli...
### Sicurezza della catena di fornitura
Rileva attacchi reali alla catena di fornitura:```bash
dockerscan --scanners supplychain suspicious-image:1.0
```
Detects:
- Contenitori senza immagine (attacchi basati solo su documentazione)
- Minatori di criptovalute (xmrig, claymore, ecc.)
- Librerie backdoorate (caso xz-utils)
- Immagini non firmate/non verificate
- Tentativi di phishing nei documenti
- Connessioni a pool di mining, server C2
### Rilevamento di segreti
Trova segreti hardcoded:```bash
dockerscan --scanners secrets webapp:prod
```
Trova:
- Credenziali cloud (AWS, GCP, Azure)
- Chiavi API (40+ servizi)
- Chiavi private e certificati
- Credenziali database
- Autenticazione registro Docker
- Stringhe ad alta entropia (potenziali segreti sconosciuti)
### Scansione delle vulnerabilità
Rileva CVE note:```bash
dockerscan --scanners vulnerabilities node:16
```
Verifica:
- Vulnerabilità Docker critiche (2024-2025)
- Vulnerabilità di fuga dal container
- Vulnerabilità RCE di BuildKit
- Immagini base giunte a fine vita
- Pacchetti vulnerabili
### Sicurezza Runtime
Controlla le configurazioni runtime:```bash
dockerscan --scanners runtime running-container
```
Analizza:
- Linux capabilities (CAP_SYS_ADMIN, etc.)
- Seccomp profiles
- AppArmor/SELinux policies
- Namespace isolation
- Privileged mode usage
---
## 📁 Formati di Output
### Output JSON```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 Output
Compatibile con 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": [...]
}
]
}
```
## 💼 Casi d'uso
### 1. **Integrazione pipeline CI/CD**
**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. **Audit di sicurezza**```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. **Validazione pre-deploy**```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. **Report di conformità**```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. **Flusso di lavoro dello sviluppatore**```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
```
---
## 📊 Confronto con Altri Strumenti
| Caratteristica | DockerScan v2.0 | Trivy | Clair | Snyk | Grype |
|---------|----------------|-------|-------|------|-------|
| **CIS Benchmark v1.7** | ✅ Completo (80+ controlli) | ❌ | ❌ | Parziale | ❌ |
| **Rilevamento Supply Chain (2024)** | ✅ Sì | ❌ | ❌ | ❌ | ❌ |
| **Scansione Segreti** | ✅ 40+ pattern | Base | ❌ | ✅ | ❌ |
| **Database CVE** | ✅ CVE 2024-2025 | ✅ | ✅ | ✅ | ✅ |
| **Sicurezza Runtime** | ✅ Completa | ❌ | ❌ | ❌ | ❌ |
| **Output SARIF** | ✅ | ✅ | ❌ | ✅ | ✅ |
| **Velocità (Go)** | ⚡ Molto Veloce | ⚡ Molto Veloce | 🐌 Lento | ⚡ Veloce | ⚡ Molto Veloce |
| **Estendibile** | ✅ Sistema di plugin | Limitato | Limitato | ❌ | Limitato |
| **Codici di Uscita** | ✅ Pronto per CI/CD | ✅ | Parziale | ✅ | ✅ |
| **Costo** | 🆓 Gratuito | 🆓 Gratuito | 🆓 Gratuito | 💰 Piani a pagamento | 🆓 Gratuito |
| **Modalità Offline** | ✅ | ✅ | ❌ | ❌ | ✅ |
| **Licenza** | Proprietario, sorgente disponibile | Apache-2.0 | Apache-2.0 | Proprietario | Apache-2.0 |
### Perché Scegliere DockerScan?
- **Il più Completo**: Unico strumento che combina CIS + Supply Chain + Segreti + CVE + Runtime
- **Ricerca più Recente**: Basato su attacchi reali del 2024-2025
- **Configurazione Zero**: Funziona subito
- **Amichevole per Sviluppatori**: Bellissimo output CLI con remediation attuabile
- **Pronto per l'Azienda**: Output SARIF + codici di uscita + JSON
---
## 🏗️ Architettura
### Struttura del Progetto```
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/
│ ├── scanner/ # Extensible scanner framework
│ │ ├── scanner.go # Scanner interface & registry
│ │ ├── cis/ # CIS Benchmark implementation
│ │ ├── secrets/ # Secrets detection
│ │ ├── supplychain/ # Supply chain attacks
│ │ ├── vulnerabilities/ # CVE scanning
│ │ └── runtime/ # Runtime security
---
[Read more](https://github.com/cr0hn/dockerscan)