cr0hn/dockerscanLe scanner de sécurité Docker le plus complet
<div align="center">
<img src="https://assets.kitploit.com/production/public/readmes/1309/3345979faae1cdabbe2912dfcaf46221df5cb53697630a8e8dcc5eebf814e949.png" alt="DockerScan Logo" width="200">
# DockerScan v2.0
### *Le scanner de sécurité Docker le plus complet*
[](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)
**Par [Daniel Garcia (cr0hn)](https://cr0hn.com)** | [GitHub](https://github.com/cr0hn/dockerscan) | [Site Web](https://cr0hn.com)
---
[Fonctionnalités](#-features) •
[Installation](#-installation) •
[Démarrage rapide](#-quick-start) •
[Documentation](#-documentation) •
[Cas d'utilisation](#-use-cases) •
[Nouveautés](#-whats-new-in-v20) •
[Contribuer](#-contributing)
</div>
---
## 📑 Table des matières
- [Aperçu](#-overview)
- [Fonctionnalités](#-features)
- [Nouveautés dans v2.0](#-whats-new-in-v20)
- [Installation](#-installation)
- [Démarrage rapide](#-quick-start)
- [Utilisation](#-usage)
- [Authentification auprès d’un registre privé](#-private-registry-authentication)
- [Scanners de sécurité](#-security-scanners)
- [Formats de sortie](#-output-formats)
- [Cas d'utilisation](#-use-cases)
- [Comparaison](#-comparison-with-other-tools)
- [Architecture](#-architecture)
- [Contribuer](#-contributing)
- [Références](#-references)
- [Licence](#-license)
- [Auteur](#-author)
---
## 🎯 Aperçu
**DockerScan v2.0** est un scanner de sécurité nouvelle génération pour les conteneurs et images Docker, entièrement réécrit en Go. Il combine plusieurs techniques de scan de sécurité basées sur les dernières recherches 2024‑2025, les normes du secteur (CIS Benchmark, NIST SP 800‑190) et des schémas d’attaque réels découverts en production.
### Pourquoi DockerScan v2.0 ?
- ✅ **Le plus complet** : combine 5+ techniques de scan de sécurité en un seul outil
- ✅ **Dernières recherches** : basé sur les attaques de la chaîne d’approvisionnement 2024‑2025 et les CVE
- ✅ **Prêt pour la production** : sortie SARIF pour CI/CD, codes de sortie pour l’automatisation
- ✅ **Ultra rapide** : écrit en Go avec scan concurrent
- ✅ **Extensible** : architecture à plugins pour des scanners personnalisés
- ✅ **Gratuit et open source** : licence BSD‑3
---
## 🌟 Fonctionnalités
### 🛡️ **Modules de scan de sécurité**
#### 1. **CIS Docker Benchmark v1.7.0**
Vérification complète de conformité avec plus de 80 contrôles automatisés :
- ✅ Sécurité de la configuration hôte (13 vérifications)
- ✅ Durcissement du démon Docker (18 vérifications)
- ✅ Permissions des fichiers et répertoires (9 vérifications)
- ✅ Bonnes pratiques pour les images conteneur (13 vérifications)
- ✅ Validation de la sécurité à l’exécution (31+ vérifications)
- ✅ Conformité des opérations de sécurité
#### 2. **Détection d’attaques sur la chaîne d’approvisionnement** 🆕
Basée sur des campagnes d’attaque réelles de 2024 :
- ✅ **Détection de conteneurs sans image** – Identifie les conteneurs malveillants sans couches réelles (plus de 4M trouvés sur Docker Hub)
- ✅ **Détection de mineurs de cryptomonnaie** – Détecte les logiciels de minage malveillants (plus de 120K pulls d’images malveillantes détectés)
- ✅ **Détection de bibliothèques piégées** – Repère les dépendances compromises (incidents xz‑utils, liblzma)
- ✅ **Vérification de signature d’image** – Valide les signatures avec Notary/Cosign
- ✅ **Détection de contenu d’hameçonnage** – Scanne la documentation pour le social engineering
- ✅ **Destinations réseau malveillantes** – Identifie les serveurs C2, les pools de minage, les nœuds Tor
#### 3. **Détection avancée de secrets** 🔑
40+ motifs de secrets incluant les API modernes (mise à jour 2024) :
- ✅ **Fournisseurs cloud** : AWS, GCP, Azure credentials
- ✅ **Contrôle de version** : jetons GitHub, GitLab, Bitbucket
- ✅ **API IA/ML** : clés OpenAI, Anthropic, Hugging Face
- ✅ **Paiement** : clés Stripe, PayPal, Square
- ✅ **Communication** : clés Slack, SendGrid, Twilio, Mailchimp
- ✅ **Authentification** : jetons JWT, jetons OAuth
- ✅ **Cryptographie** : clés privées (RSA, SSH, PGP, EC, DSA), certificats
- ✅ **Bases de données** : chaînes de connexion PostgreSQL, MySQL, MongoDB
- ✅ **Docker** : jetons d’authentification de registre
- ✅ **Analyse d’entropie** : calcul de l’entropie de Shannon pour les secrets inconnus (seuil >4.5)
#### 4. **Scan CVE et vulnérabilités** 🚨
Détection des CVE critiques 2024‑2025 :
- ✅ **CVE‑2024‑21626** – Fuite de conteneur runc (CVSS 8.6)
- ✅ **CVE‑2024‑23651** – Empoisonnement du cache BuildKit RCE (CVSS 9.1)
- ✅ **CVE‑2024‑23652** – Condition de concurrence BuildKit (CVSS 7.5)
- ✅ **CVE‑2024‑23653** – Élévation de privilèges BuildKit
- ✅ **CVE‑2024‑8695/8696** – RCE Docker Desktop (CVSS 8.8)
- ✅ **CVE‑2025‑9074** – Vulnérabilité d’accès local Docker Desktop
- ✅ Détection d’images de base en fin de vie
- ✅ Scan de paquets vulnérables connus
#### 5. **Analyse de sécurité à l’exécution** ⚙️
Vérifications de durcissement de l’exécution des conteneurs :
- ✅ **Audit des capacités Linux** – Détecte les capacités dangereuses (CAP_SYS_ADMIN, CAP_NET_ADMIN, etc.)
- ✅ **Validation du profil Seccomp** – Vérifie que le filtrage des appels système est activé
- ✅ **Vérifications AppArmor/SELinux** – Contrôle du contrôle d’accès obligatoire
- ✅ **Détection de conteneurs privilégiés** – Identifie les conteneurs avec accès complet à l’hôte
- ✅ **Isolation des espaces de noms** – Vérifications PID, IPC, réseau, espace de noms utilisateur
- ✅ **Indicateurs de fuite de conteneur** – Détecte les techniques d’évasion courantes
### 📊 **Rapports et intégration**
- **JSON** – Sortie lisible par machine pour l’automatisation
- **SARIF** – Intégration native avec :
- Onglet sécurité GitHub
- Azure DevOps
- Extensions VS Code
- Tableaux de bord de sécurité GitLab
- **CLI élégante** – Niveaux de gravité codés par couleur avec émoticônes
- **Codes de sortie** – Compatible CI/CD (0=propre, 1=avertissements, 2=critique)
### 🚀 **Performances**
- ⚡ **10x plus rapide** que les alternatives Python
- 🔄 **Scan concurrent** avec goroutines Go
- 💾 **Faible empreinte mémoire** (~50‑100 Mo)
- 📦 **Binaire unique** – Aucune dépendance
---
## 🆕 Nouveautés dans v2.0 ?
DockerScan v2.0 est une **réécriture complète** à partir de zéro. Voici ce qui a changé depuis v1.x :
### Changements majeurs
| Fonctionnalité | v1.x (Python) | v2.0 (Go) |
|---------|--------------|-----------|
| **Langage** | Python 3.5+ | Go 1.21+ |
| **Performances** | ~500 images/heure | ~5000 images/heure |
| **Utilisation mémoire** | 200‑500 Mo | 50‑100 Mo |
| **Distribution** | pip install + dépendances | Binaire unique |
| **Scanners de sécurité** | 2 modules | 5 modules |
| **CIS Benchmark** | Partiel | Complet v1.7.0 (80+ vérifications) |
| **Chaîne d’approvisionnement** | ❌ Non disponible | ✅ Basé sur les recherches 2024 |
| **Motifs de secrets** | 10 motifs | 40+ motifs |
| **Détection CVE** | Basique | CVE 2024‑2025 |
| **Sécurité à l’exécution** | ❌ Non disponible | ✅ Audit complet des capacités |
| **Sortie SARIF** | ❌ Non disponible | ✅ Support complet |
| **Intégration CI/CD** | Manuel | Natif (codes de sortie, SARIF) |
### Ce qui est conservé depuis v1.x
- ✅ **Outils offensifs** – Capacités de trojanisation d’images (à venir dans v2.1)
- ✅ **Opérations registre** – Push, pull, delete (à venir dans v2.1)
- ✅ **Scan réseau** – Découverte de registres Docker (à venir dans v2.1)
### Nouveautés dans v2.0.5 🔐
- 🔑 **Authentification auprès d’un registre privé** – Support complet pour scanner des images depuis des registres privés (corrige #24)
- 🌐 **Support multi‑registres** – Docker Hub, GHCR, ECR, GCR, ACR, GitLab, et registres auto‑hébergés
- 🔐 **Plusieurs méthodes d’authentification** – Variables d’environnement (CI/CD), flags CLI (tests), fichier de configuration Docker (transparent)
- 🎯 **Priorité d’authentification intelligente** – Flags CLI > Variables d’environnement > Configuration Docker (sélection automatique)
- 📝 **Messages d’erreur améliorés** – Indices spécifiques au registre (expiration de jeton ECR, limites de taux, certificats)
- 🧪 **Tests complets** – 64 cas de test, 91.2 % de couverture, testé avec un vrai registre privé
- 📚 **Documentation complète** – Exemples pour tous les grands registres cloud et méthodes d’authentification
### Nouveautés dans v2.0.4
- 🗄️ **Intégration de la base de données CVE** – Base SQLite locale avec les données NVD (2.5 ans de CVE)
- 🔄 **Mises à jour automatiques quotidiennes** – Action GitHub met à jour la base CVE chaque jour
- ⚡ **Téléchargements CVE parallèles** – 4 workers pour des constructions de base plus rapides (nvd2sqlite)
- 🔁 **Nouvelle tentative avec backoff** – Réessai automatique en cas de limite de taux de l’API NVD
- 📦 **Flag `--from-file`** – Installer la base CVE depuis un fichier local (hors ligne/air‑gapped)
- 🔇 **Mode silencieux (`-q`)** – Supprimer la bannière pour les pipelines CI/CD
- 🧹 **Moins de faux positifs** – Détection de secrets améliorée avec filtrage par entropie
### Pourquoi la réécriture ?
1. **Performances** – Go offre un scan 10x plus rapide avec les goroutines
2. **Menaces modernes** – Intègre les schémas d’attaque 2024‑2025
3. **Prêt pour l’entreprise** – Sortie SARIF, codes de sortie, distribution binaire unique
4. **Extensibilité** – Architecture de plugins propre pour des scanners personnalisés
5. **Maintenabilité** – Sécurité de typage, meilleure gestion des erreurs, plus facile à contribuer
---
## 📦 Installation
### Option 1 : Télécharger le binaire pré‑compilé (recommandé)
Les binaires pré‑compilés sont automatiquement construits et publiés via GitHub Actions pour chaque tag de version.
**Plateformes supportées :**
- **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"
```
#### Vérifier le téléchargement (Optionnel mais recommandé)```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: Compiler à partir des sources```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 Install```bash
go install github.com/cr0hn/dockerscan/v2/cmd/dockerscan@latest
```
---
## 🚀 Démarrage rapide
### Configuration initiale
Avant de lancer l'analyse, téléchargez la base de données CVE (mise à jour quotidiennement, ~30 Mo compressée) :```bash
# Download latest CVE database from GitHub
dockerscan update-db
```
> **Astuce** : La base de données est mise à jour quotidiennement via GitHub Actions. Exécutez `update-db` périodiquement pour obtenir les dernières données CVE.
### Analyse de 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
```
### Exemple de sortie```
╔══════════════════════════════════════════════════════════════════════════╗
║ ██████╗ ██████╗ ██████╗██╗ ██╗███████╗██████╗ ███████╗ ██████╗ █████╗ ███╗ ██╗
║ ██╔══██╗██╔═══██╗██╔════╝██║ ██╔╝██╔════╝██╔══██╗██╔════╝██╔════╝██╔══██╗████╗ ██║
║ ██║ ██║██║ ██║██║ █████╔╝ █████╗ ██████╔╝███████╗██║ ███████║██╔██╗ ██║
║ ██║ ██║██║ ██║██║ ██╔═██╗ ██╔══╝ ██╔══██╗╚════██║██║ ██╔══██║██║╚██╗██║
║ ██████╔╝╚██████╔╝╚██████╗██║ ██╗███████╗██║ ██║███████║╚██████╗██║ ██║██║ ╚████║
║ ║
║ 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
```
---
## 📖 Utilisation
### Options de ligne de commande```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
```
### Exemples```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
```
### 🔐 Authentification au registre privé
DockerScan prend en charge trois méthodes d'authentification auprès des registres privés :
#### Méthode 1 : Fichier de configuration Docker (recommandé pour une utilisation locale)
La méthode la plus pratique - utilise vos informations d'identification Docker existantes :```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 lit automatiquement les identifiants depuis `~/.docker/config.json`. Cela fonctionne avec tous les registres dans lesquels vous vous êtes connecté via `docker login`.
**Les gestionnaires d'identifiants sont entièrement pris en charge.** DockerScan résout nativement les identifiants via :
- **`credsStore`** — gestionnaire d'identifiants global (par ex. `osxkeychain` sur macOS avec Docker Desktop, `wincred` sur Windows, `pass` sur Linux)
- **`credHelpers`** — gestionnaires d'identifiants par registre (prioritaires sur `credsStore`)
- **Repli automatique** — si le binaire du gestionnaire spécifié n'est pas installé, DockerScan se rabat sur le bloc `auths` en texte clair dans `config.json`
Sur **macOS avec Docker Desktop**, cela fonctionne immédiatement sans configuration supplémentaire :```json
{
"credsStore": "osxkeychain"
}
```
DockerScan appellera `docker-credential-osxkeychain` de manière transparente pour récupérer les jetons, vous n'avez donc jamais besoin de passer explicitement des identifiants.
#### Méthode 2 : Variables d'environnement (Recommandé pour CI/CD)
Idéal pour les environnements automatisés et les pipelines 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
```
**Exemple 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 }}
```
#### Méthode 3 : Options en ligne de commande (non recommandée)
Pour tests rapides uniquement (identifiants visibles dans la liste des processus) :```bash
dockerscan --registry-user myuser --registry-password mytoken ghcr.io/myorg/app:v1
```
**Avertissement de sécurité :** Cette méthode expose les identifiants dans votre historique de shell et la liste des processus. Utilisez plutôt des variables d'environnement ou la configuration Docker.
### Exemples spécifiques au registre
#### Docker Hub (dépôts privés)```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
```
#### Registres auto-hébergés/privés```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"]
# }
```
### Dépannage de l'authentification
#### Problèmes courants
**1. Erreur « authentification requise »**```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. Erreur « unauthorized: authentication failed »**
- Vérifiez que vos identifiants sont corrects
- Vérifiez si votre jeton a expiré (surtout pour les fournisseurs cloud)
- Assurez-vous que votre compte a les permissions de tirage (pull) pour l'image
**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. Limitation de débit sur Docker Hub**
- Authentifiez-vous pour augmenter les limites de débit (200 téléchargements/6 heures pour les comptes gratuits)
- Envisagez d'utiliser un compte Docker Hub Pro pour des limites plus élevées
**5. Erreurs de certificat avec des certificats auto-signés**
- Ajoutez le certificat CA à votre magasin de confiance système
- Ou configurez Docker pour faire confiance au registre (voir la documentation Docker)
---
## 🔍 Scanners de sécurité
### CIS Docker Benchmark
Vérification automatisée de conformité par rapport au CIS Docker Benchmark v1.7.0 :```bash
dockerscan --scanners cis nginx:latest
```
Les vérifications incluent :
- L'utilisateur du conteneur n'est pas root
- Aucun paquet inutile installé
- Instruction HEALTHCHECK présente
- Tags de version spécifiques (pas `:latest`)
- Ports exposés minimaux
- Aucun conteneur privilégié
- Capacités Linux restreintes
- Profils Seccomp/AppArmor appliqués
- Système de fichiers racine en lecture seule
- Et 70+ autres vérifications...
### Sécurité de la chaîne d'approvisionnement
Détectez les attaques réelles sur la chaîne d'approvisionnement :```bash
dockerscan --scanners supplychain suspicious-image:1.0
```
Détecte :
- Conteneurs sans image (attaques basées uniquement sur la documentation)
- Mineurs de cryptomonnaies (xmrig, claymore, etc.)
- Bibliothèques piégées (cas xz-utils)
- Images non signées/non vérifiées
- Tentatives de phishing dans la documentation
- Connexions à des pools miniers, serveurs C2
### Détection des secrets
Trouver des secrets codés en dur :```bash
dockerscan --scanners secrets webapp:prod
```
Détecte :
- Identifiants cloud (AWS, GCP, Azure)
- Clés API (40+ services)
- Clés privées et certificats
- Identifiants de base de données
- Authentification de registre Docker
- Chaînes à haute entropie (secrets potentiels inconnus)
### Analyse des vulnérabilités
Détecter les CVE connues :```bash
dockerscan --scanners vulnerabilities node:16
```
Vérifie :
- CVEs Docker critiques (2024-2025)
- Vulnérabilités d'évasion de conteneur
- Vulnérabilités RCE de BuildKit
- Images de base en fin de vie
- Paquets vulnérables
### Sécurité d'exécution
Auditer les configurations d'exécution :```bash
dockerscan --scanners runtime running-container
```
Analyse :
- Capacités Linux (CAP_SYS_ADMIN, etc.)
- Profils Seccomp
- Politiques AppArmor/SELinux
- Isolation des espaces de noms
- Utilisation du mode privilégié
---
## 📁 Formats de sortie
### Sortie 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
Compatible avec 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": [...]
}
]
}
```
---
## 💼 Cas d'utilisation
### 1. **Intégration des pipelines 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. **Audits de sécurité**```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. **Validation pré-déploiement**```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. **Rapports de 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. **Workflow du développeur**```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
```
---
## 📊 Comparaison avec d'autres outils
| Fonctionnalité | DockerScan v2.0 | Trivy | Clair | Snyk | Grype |
|---------|----------------|-------|-------|------|-------|
| **CIS Benchmark v1.7** | ✅ Complet (80+ vérifications) | ❌ | ❌ | Partiel | ❌ |
| **Détection de la chaîne d'approvisionnement (2024)** | ✅ Oui | ❌ | ❌ | ❌ | ❌ |
| **Analyse des secrets** | ✅ 40+ motifs | Basique | ❌ | ✅ | ❌ |
| **Base de données CVE** | ✅ CVE 2024-2025 | ✅ | ✅ | ✅ | ✅ |
| **Sécurité runtime** | ✅ Complète | ❌ | ❌ | ❌ | ❌ |
| **Sortie SARIF** | ✅ | ✅ | ❌ | ✅ | ✅ |
| **Vitesse (Go)** | ⚡ Très rapide | ⚡ Très rapide | 🐌 Lent | ⚡ Rapide | ⚡ Très rapide |
| **Extensible** | ✅ Système de plugins | Limité | Limité | ❌ | Limité |
| **Codes de sortie** | ✅ Prêt CI/CD | ✅ | Partiel | ✅ | ✅ |
| **Coût** | 🆓 Gratuit | 🆓 Gratuit | 🆓 Gratuit | 💰 Niveaux payants | 🆓 Gratuit |
| **Mode hors ligne** | ✅ | ✅ | ❌ | ❌ | ✅ |
---
[Read more](https://github.com/cr0hn/dockerscan)