DockerScan v2.0

Lo scanner di sicurezza Docker più completo

Di Daniel Garcia (cr0hn) | GitHub | Sito web

Funzionalità • Installazione • Avvio rapido • Documentazione • Casi d'uso • Novità • Contribuire

📑 Indice

Panoramica
Funzionalità
Novità in v2.0
Installazione
Avvio rapido
Utilizzo
- Autenticazione registro privato
Scanner di sicurezza
Formati di output
Casi d'uso
Confronto con altri strumenti
Architettura
Contribuire
Riferimenti
Licenza
Autore

🎯 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?

Prestazioni - Go fornisce scansione 10x più veloce con goroutine
Minacce moderne - Incorpora pattern di attacco 2024-2025
Pronto per aziende - Output SARIF, codici di uscita, distribuzione binario singolo
Estensibilità - Architettura pulita a plugin per scanner personalizzati
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

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

az acr login --name myregistry

Scan ACR image

dockerscan myregistry.azurecr.io/myapp:v1.0

Or use service principal credentials

export DOCKER_USERNAME= export DOCKER_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 │ ├── report/ # Report generators │ │ ├── json.go # JSON reporter │ │ └── sarif.go # SARIF reporter │ ├── models/ # Data models │ │ └── models.go # Findings, scan results, etc. │ └── config/ # Configuration │ └── config.go # App config & banner └── pkg/docker/ # Docker client wrapper └── client.go

### Database CVE e strumento nvd2sqlite

DockerScan utilizza un database SQLite locale per le ricerche CVE. Il database viene **aggiornato automaticamente ogni giorno** tramite GitHub Actions ed è ospitato nel repository, così hai sempre accesso agli ultimi dati CVE.

#### Caratteristiche del Database

- 🗄️ **Database pre-costruito** - Pronto all'uso, nessuna configurazione manuale richiesta
- 🔄 **Aggiornamenti giornalieri** - GitHub Action aggiorna il database ogni giorno alle 00:00 UTC
- 📅 **2,5 anni di dati CVE** - Copre CVE dalla metà del 2022 ad oggi
- ⚡ **Ricerche rapide** - SQLite con indici ottimizzati
- 🌐 **Ospitato su GitHub** - Scaricato automaticamente con il comando `update-db`

#### Aggiornamento del Database```bash
# Download latest database from GitHub (recommended)
dockerscan update-db

# Install from local file (for air-gapped/offline environments)
dockerscan update-db --from-file /path/to/cve-db.sqlite

Nota: La prima volta che esegui dockerscan, ti verrà chiesto di scaricare il database. Successivamente, puoi aggiornarlo periodicamente con update-db.

Costruire il Database Manualmente (nvd2sqlite)

Per utenti avanzati, è possibile costruire il database CVE direttamente da NVD:```bash

Build the tool

make build # Builds both dockerscan and nvd2sqlite

Download CVEs (last 2.5 years by default)

./bin/nvd2sqlite --output data/cve-db.sqlite --verbose

With NVD API key (10x faster - 50 req/30sec vs 5 req/30sec)

NVD_API_KEY=your-key ./bin/nvd2sqlite --output data/cve-db.sqlite --verbose

Custom date range

./bin/nvd2sqlite --output data/cve-db.sqlite
--start-date 2023-01-01
--end-date 2024-12-31

**Caratteristiche di nvd2sqlite:**
- ⚡ **4 worker di download paralleli** per download più veloci
- 🔄 **Ritentativi automatici con backoff esponenziale** per limitazione della velocità (HTTP 429)
- 📦 **Download in directory temporanea**, poi elaborazione sequenziale
- 🗄️ **Output SQLite** con tabelle indicizzate per ricerche rapide

---

### Estendibilità

Aggiungere un nuovo scanner è semplice:```go
package myscan

import (
    "context"
    "github.com/cr0hn/dockerscan/v2/internal/models"
    "github.com/cr0hn/dockerscan/v2/internal/scanner"
)

type MyScanner struct {
    scanner.BaseScanner
}

func NewMyScanner() *MyScanner {
    return &MyScanner{
        BaseScanner: scanner.NewBaseScanner(
            "my-scanner",
            "Description of my scanner",
            true, // enabled
        ),
    }
}

func (s *MyScanner) Scan(ctx context.Context, target models.ScanTarget) ([]models.Finding, error) {
    var findings []models.Finding

    // Your scanning logic here...

    return findings, nil
}

// Register in main.go:
// registry.Register(myscan.NewMyScanner())

🤝 Contribuire

I contributi sono benvenuti! DockerScan è progettato per essere estendibile.

Come Contribuire

Forka il repository
Crea un branch feature (git checkout -b feature/amazing-scanner)
Aggiungi il tuo scanner in internal/scanner/
Scrivi i test (manteniamo una copertura del 90%+)
Esegui il commit delle tue modifiche (git commit -am 'Add amazing scanner')
Esegui il push sul branch (git push origin feature/amazing-scanner)
Apri una Pull Request

Sviluppo```bash

Clone and setup

git clone https://github.com/cr0hn/dockerscan cd dockerscan/dockerscan-v2

Install dependencies

make deps

Run tests

make test

Run with coverage

make coverage

Build

make build

Format code

make fmt

Lint

make lint

### Aggiunta di Nuovi Scanner

Accogliamo con favore in particolare:
- Integrazione con database di vulnerabilità (NVD, GitHub Security Advisories)
- Scansione della sicurezza Kubernetes
- Sicurezza dei registry di container
- Analisi della sicurezza di Docker Compose
- Scansione IaC (Dockerfiles)

---

## 📚 Riferimenti

### Standard & Benchmark

- [CIS Docker Benchmark v1.7.0](https://www.cisecurity.org/benchmark/docker) - Center for Internet Security
- [NIST SP 800-190](https://csrc.nist.gov/publications/detail/sp/800-190/final) - Guida alla sicurezza dei container per applicazioni
- [OWASP Docker Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html)

### Ricerca e CVE

- [4 Milioni di Container Maligni Senza Immagine](https://thehackernews.com/2024/04/millions-of-malicious-imageless.html) - The Hacker News, Aprile 2024
- [Attacchi alla Supply Chain Tramite Immagini di Container](https://www.aquasec.com/blog/supply-chain-threats-using-container-images/) - Aqua Security
- [CVE-2024-21626: Fuga dal Container runc](https://nvd.nist.gov/vuln/detail/CVE-2024-21626) - NIST NVD
- [CVE-2024-23651: Esecuzione di Codice Remoto in BuildKit](https://nvd.nist.gov/vuln/detail/CVE-2024-23651) - NIST NVD
- [Backdoor xz-utils (Marzo 2024)](https://www.openwall.com/lists/oss-security/2024/03/29/4) - OpenWall

### Strumenti e Progetti

- [Trivy](https://github.com/aquasecurity/trivy) - Scanner di vulnerabilità
- [Docker Bench Security](https://github.com/docker/docker-bench-security) - Script benchmark CIS
- [Cosign](https://github.com/sigstore/cosign) - Firma e verifica dei container
- [Specifica SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) - Formato dei risultati di analisi statica

---

## 📄 Licenza

Questo progetto è concesso in licenza secondo la **DockerScan Proprietary Source-Available License**.

### Cosa Significa

✅ **PUOI (Gratuitamente):**
- Usare DockerScan **gratuitamente** per scansioni di sicurezza interne
- Utilizzarlo nelle tue **pipeline CI/CD** e nei flussi di lavoro di sicurezza
- **Modificare, fare fork e contribuire** alla comunità
- Utilizzarlo per scopi **educativi e di ricerca**
- Usarlo come **strumento in servizi professionali** (consulenza, audit di sicurezza, penetration testing)
- **Integrarlo** in altri prodotti come componente accessorio

❌ **NON PUOI (senza espressa autorizzazione scritta o licenza commerciale):**
- Offrire **scansione Docker come SaaS commerciale**
- **Vendere istanze ospitate** di DockerScan
- Realizzare una **piattaforma commerciale** basata principalmente su DockerScan
- Creare un **servizio gestito a pagamento** in cui DockerScan sia l’offerta principale

### Perché Questa Licenza?

Questa licenza protegge la sostenibilità del progetto:
- ✅ Concedendo **libertà** di utilizzare il software per scopi legittimi
- ❌ Impedendo **parassitismo dannoso** da parte di aziende che ne traggono profitto offrendolo come servizio senza contribuire
- 💰 Assicurando che il progetto rimanga **sostenibile** attraverso licenze commerciali per usi concorrenziali
- 🔓 Mantenendo il **codice sorgente disponibile** per trasparenza e contributi della comunità

**Questa NON è open source** - è **source-available** con restrizioni sull'uso commerciale concorrenziale.

### Licenze Commerciali

**Richiesto per:**
- Offerte SaaS o ospitate
- Piattaforme commerciali che usano DockerScan come funzionalità principale
- Rivendita o ridistribuzione come prodotto commerciale
- Servizi gestiti in cui DockerScan è l'offerta principale

**Contatti per licenze commerciali:**

📧 Email: cr0hn [at] cr0hn.com
🌐 Sito web: https://cr0hn.com
💼 Termini di licenza flessibili disponibili per aziende e startup

Vedere il file [LICENSE](https://github.com/cr0hn/dockerscan/blob/HEAD/LICENSE) per i termini legali completi.

---

## 👤 Autore

<div align="center">

### **Daniel Garcia (cr0hn)**

[![Website](https://img.shields.io/badge/Website-cr0hn.com-blue?style=for-the-badge&logo=google-chrome)](https://cr0hn.com)
[![GitHub](https://img.shields.io/badge/GitHub-cr0hn-black?style=for-the-badge&logo=github)](https://github.com/cr0hn)
[![Twitter](https://img.shields.io/badge/Twitter-@ggdaniel-1DA1F2?style=for-the-badge&logo=twitter)](https://twitter.com/ggdaniel)

**Ricercatore di Sicurezza | Sviluppatore Open Source | Esperto di Sicurezza Docker**

</div>

---

## 🙏 Ringraziamenti

Un ringraziamento speciale a:
- La comunità sulla sicurezza Docker
- CIS per il Docker Benchmark
- NIST per SP 800-190
- I ricercatori di sicurezza che hanno scoperto gli attacchi alla supply chain del 2024
- Tutti i contributori e gli utenti di DockerScan

---

## 📞 Supporto

- **Problemi**: [GitHub Issues](https://github.com/cr0hn/dockerscan/issues)
- **Discussioni**: [GitHub Discussions](https://github.com/cr0hn/dockerscan/discussions)
- **Sicurezza**: Segnala vulnerabilità a [email protected]

---

<div align="center">

**⭐ Se trovi DockerScan utile, lascia una stella al repository! ⭐**

*Rendere la Sicurezza Docker Accessibile a Tutti*

[⬆ Torna su](#-dockerscan-v20)

</div>

dockerscan v2.1.0

Categorie

dockerscan v2.1.0

DockerScan v2.0

Lo scanner di sicurezza Docker più completo

📑 Indice

🎯 Panoramica

Perché DockerScan v2.0?

🌟 Funzionalità

🛡️ Moduli di scansione di sicurezza

1. CIS Docker Benchmark v1.7.0

2. Rilevamento attacchi alla supply chain 🆕

3. Rilevamento avanzato di segreti 🔑

4. Scansione CVE e vulnerabilità 🚨

5. Analisi della sicurezza in esecuzione ⚙️

📊 Reporting e integrazione

🚀 Prestazioni

🆕 Novità in v2.0?

Modifiche principali

Cosa è stato conservato dalla v1.x

Novità in v2.0.5 🔐

Novità in v2.0.4

Perché la riscrittura?

📦 Installazione

Opzione 1: Scarica il binario precompilato (consigliato)

Linux (amd64)```bash

macOS (Intel)```bash

Windows (PowerShell)```powershell

Opzione 2: Compila dal sorgente```bash

Clone repository

Build

Install

Or build manually

🚀 Avvio Rapido

Configurazione Iniziale

Download latest CVE database from GitHub

Output di esempio```

Esempi```bash

Scan with all scanners (default)

Only run specific scanners

Save reports to specific directory

Only show critical issues

Ver progreso del scan (scanner names, findings count, image pull status)

Debug detallado (errores internos, detalles técnicos)

Scan private registry images (see Authentication section below)

Esempi Specifici per Registry

Docker Hub (Repository Privati)```bash

Using Docker config

Using environment variables

AWS Elastic Container Registry (ECR)```bash

Get login credentials from AWS

Scan ECR image

Or use environment variables with ECR credentials

Azure Container Registry (ACR)```bash

Login with Azure CLI

Scan ACR image

Or use service principal credentials

Registri Auto-ospitati/Privati```bash

Standard authentication

With environment variables

Insecure registries (not recommended for production)

Add to Docker daemon config: /etc/docker/daemon.json

{

"insecure-registries": ["myregistry.example.com:5000"]

}

ECR tokens expire after 12 hours - refresh them

Sicurezza della catena di fornitura

Scansione delle vulnerabilità

📁 Formati di Output

Output JSON```json

💼 Casi d'uso

1. Integrazione pipeline CI/CD

2. Audit di sicurezza```bash

Comprehensive audit of production images

Generate summary report

4. Report di conformità```bash

Generate CIS compliance report

Weekly security scan for compliance

📊 Confronto con Altri Strumenti

Perché Scegliere DockerScan?

🏗️ Architettura

Struttura del Progetto```