Scanner les vulnérabilités de conteneurs avec grype

Mise à jour : 23/12/2025

Grype est un scanner de vulnérabilités open source développé par Anchore. Il analyse vos images de conteneurs et répertoires pour identifier les vulnérabilités connues (CVE). Ce qui le distingue : sa rapidité (scan complet en quelques secondes), sa simplicité d’usage (une seule commande), et son intégration native dans les pipelines CI/CD.

Dans l’écosystème de la sécurité applicative, Grype joue un rôle complémentaire avec d’autres outils :

Syft génère le SBOM (inventaire des composants)
Grype scanne ce SBOM pour détecter les CVE
VEX filtre les faux positifs selon votre contexte

En pratique, Grype détecte une douzaine de CVE en 2 secondes sur une image Alpine Python typique, avec des scores EPSS pour prioriser les corrections selon le risque réel d’exploitation.

Installation de Grype

Linux

curl -sSfL https://raw.githubusercontent.com/anchore/grype/main/install.sh | sh -s -- -b /usr/local/bin
grype version
# grype 0.104.2

macOS

brew tap anchore/grype
brew install grype

Autres options

asdf-vm : asdf plugin add grype && asdf install grype latest
Docker : docker run --rm anchore/grype:latest <image>

Utilisation Grype

Grype analyse deux types de sources :

Images de conteneurs : scan de tous les packages installés (APK, DEB, RPM, binaires Go, dépendances Python/Node/Java…)
Répertoires source : scan des fichiers de dépendances (requirements.txt, package.json, go.mod, pom.xml…)

Écosystèmes supportés :

Alpine (apk)
C (conan)
C++ (conan)
Dart (pubs)
Debian (dpkg)
Dotnet (deps.json)
Objective-C (cocoapods)
Go (go.mod, Go binaries)
Haskell (cabal, stack)
Java (jar, ear, war, par, sar)
JavaScript (npm, yarn)
Jenkins Plugins (jpi, hpi)
PHP (composer)
Python (wheel, egg, poetry, requirements.txt)
Red Hat (rpm)
Ruby (gem)
Rust (cargo.lock)
Swift (cocoapods)

Scanner une image conteneur

Scan d’une image Docker locale avec digest SHA256 :

grype devops-status-api@sha256:0c4d2ee8...
# ✔ Scanned for vulnerabilities [12 vulnerability matches]
#    ├── by severity: 1 critical, 2 high, 7 medium, 2 low
NAME         INSTALLED  VULNERABILITY        SEVERITY  EPSS
python-jose  3.3.0      GHSA-6c5p-j8vq-pqhj  Critical  0.7% (71st)
ecdsa        0.19.1     GHSA-wj6h-64fc-37mp  High      0.6% (69th)
python       3.12.12    CVE-2025-12084       Medium    <0.1% (25th)
... 9 autres

Détail du processus :

Chargement : Grype extrait les métadonnées de l’image Docker (layers, packages installés)
Inventaire : Il identifie tous les packages : APK Alpine (musl, libssl), Python (fastapi, uvicorn, python-jose), binaires compilés
Comparaison : Chaque package est comparé à la base de vulnérabilités (NVD, GitHub Advisory, Alpine Security)
Scoring : Les CVE sont enrichies avec scores CVSS (gravité) et EPSS (probabilité d’exploitation)
Affichage : Résultats triés par sévérité avec percentile EPSS

12 CVE détectées : typique pour une image Python Alpine. Les CVE proviennent du système de base Alpine (2 CVE), de l’interpréteur Python (1 CVE), et des dépendances Python (9 CVE). Le score EPSS indique que python-jose (Critical, 0.7%) a 71% des CVE moins exploitées qu’elle.

Scanner un répertoire source

Scan du code source (avant construction de l’image) :

grype dir:. -o table
# ✔ Scanned for vulnerabilities [4 vulnerability matches]
#    ├── by severity: 0 critical, 1 high, 2 medium, 1 low
NAME         INSTALLED  VULNERABILITY        SEVERITY  EPSS
starlette    0.41.3     GHSA-2jv5-9r88-3w3p  High      0.6% (70th)
requests     2.32.3     GHSA-9wx4-h78v-vm56  Medium    0.1% (27th)
... 2 autres

Différence image vs source :

Image : 12 CVE (packages système Alpine + Python)
Source : 4 CVE (uniquement dépendances Python)

Pourquoi scanner le source ? Détecter les CVE Python avant le build Docker, dans votre IDE ou pre-commit Git.

Grype prend en argument les sources suivantes :

grype podman:yourrepo/yourimage@sha256:...    Podman daemon
grype docker:yourrepo/yourimage@sha256:...    Docker daemon
grype docker-archive:path/to/image.tar        tarball Docker
grype oci-archive:path/to/image.tar           tarball OCI
grype oci-dir:path/to/yourimage               OCI layout directory
grype singularity:path/to/yourimage.sif       Singularity Image Format
grype dir:path/to/yourproject                 répertoire source
grype sbom:path/to/syft.json                  fichier SBOM
grype registry:yourrepo/yourimage@sha256:...  registre distant
grype purl:path/to/purl/file                  fichier PURL

Obtenir des informations sur les vulnérabilités

La commande explain approfondit la compréhension d’une CVE spécifique :

grype devops-status-api@sha256:0c4d2ee8... -o json | grype explain --id GHSA-6c5p-j8vq-pqhj

Sortie (condensée) :

GHSA-6c5p-j8vq-pqhj from github:language:python (Critical)
Algorithmic Complexity in github.com/... python-jose
Related: CVE-2024-33664 (Critical)
Matched packages:
  - Package: python-jose, version: 3.3.0
    PURL: pkg:pypi/python-jose@3.3.0
    Locations: /usr/local/lib/python3.12/site-packages/...
URLs:
  - https://github.com/advisories/GHSA-6c5p-j8vq-pqhj
  - https://nvd.nist.gov/vuln/detail/CVE-2024-33664

Informations clés :

Package vulnérable : python-jose 3.3.0
Sévérité : Critical (EPSS 0.7%)
Type : Complexité algorithmique (déni de service)
Localisation : Dépendance Python dans /usr/local/lib
Correction : Mettre à jour python-jose → 3.3.1+

Choix du format de sortie

Grype produit plusieurs formats selon votre usage :

Pour l’humain :

table (défaut) : Tableau lisible avec colonnes NAME, INSTALLED, VULNERABILITY, SEVERITY, EPSS

Pour l’automatisation :

json : Toutes les métadonnées CVE (description, CVSS, EPSS, URLs, fix disponible, chemins de fichiers)
cyclonedx / cyclonedx-json : Standard CycloneDX 1.4 pour intégration Dependency Track

Pour la personnalisation :

template : Template Go personnalisé (exemple : générer un rapport Markdown)

Exemple JSON pour automatisation :

grype devops-status-api@sha256:0c4d2ee8... -o json -q > vulnerabilities.json
jq '{total, critical, high}' vulnerabilities.json
# {"total": 12, "critical": 1, "high": 2}

Le format JSON est essentiel pour :

Filtrer les CVE avec jq ou scripts Python
Stocker les résultats historiques
Intégrer avec des plateformes comme Dependency Track

Fixer le niveau pour produire une erreur

Option --fail-on pour faire échouer le pipeline CI/CD si des vulnérabilités dépassent un seuil de sévérité :

grype devops-status-api@sha256:0c4d2ee8... --fail-on medium
# ✔ Scanned for vulnerabilities [12 vulnerability matches]
#    ├── by severity: 1 critical, 2 high, 7 medium, 2 low
#    └── by status: 0 fixed, 12 not-fixed, 0 ignored
# 1 error occurred:
#     * discovered vulnerabilities at or above the severity threshold

Résultat : code retour 1 (échec). Utile en CI/CD pour bloquer un déploiement avec CVE critiques/high/medium.

Configuration de Grype

Grype se configure via un fichier .grype.yaml pour personnaliser le comportement du scanner selon vos besoins. C’est utile pour standardiser les scans dans une équipe ou un projet.

Principaux réglages :

# Format de sortie par défaut
output: table  # ou json, cyclonedx-json

# Échouer selon sévérité (utile en CI/CD)
fail-on-severity: high  # options: negligible, low, medium, high, critical

# Filtrer uniquement les CVE corrigées (ignorer les not-fixed)
only-fixed: false

# Scope du scan pour les images
search:
  scope: squashed  # analyse l'image finale compressée
  # scope: all-layers  # analyse toutes les layers (plus lent, plus exhaustif)

# Base de données de vulnérabilités
db:
  auto-update: true  # mise à jour auto au lancement
  cache-dir: ~/.cache/grype/db
  max-allowed-built-age: 120h  # alerte si DB > 5 jours

# Intégration VEX pour filtrer les faux positifs
vex-documents:
  - ./vex/devops-status-api.vex.json
  - ./vex/global.vex.json

# Ignorer certains chemins (exemple : tests, vendor)
exclude:
  - "**/test/**"
  - "**/vendor/**"

Chemins de recherche (ordre de priorité) :

.grype.yaml (racine du projet)
.grype/config.yaml
~/.grype.yaml (configuration utilisateur)
~/.config/grype/config.yaml

Exemple d’usage : créer .grype.yaml à la racine de votre projet pour que tous les développeurs utilisent les mêmes seuils de sévérité et les mêmes documents VEX.

Gestion de la DB

La base de vulnérabilités de Grype est cruciale : elle contient toutes les CVE connues provenant de NVD, GitHub Advisory Database, Alpine Security, etc. Elle est mise à jour quotidiennement par Anchore.

Vérifier l’état de la base :

grype db status
# Built:     2024-01-03 01:26:16 +0000 UTC
# Schema:    5
# Checksum:  sha256:29fb5bb2796844c92e21ed1753d9b2c4c11cf1a0a905c3e3de4e5b4aad3c71db
# Status:    valid

Informations clés :

Built : Date de génération de la DB (vérifiez qu’elle est récente)
Schema : Version du format DB (change lors des upgrades Grype)
Checksum : Empreinte SHA256 pour vérifier l’intégrité
Status : valid si tout est OK

Mise à jour manuelle :

grype db update
# ✔ Vulnerability DB [no update available]

Par défaut, Grype met à jour la DB automatiquement au lancement si elle date de plus de 24h. Pour forcer une vérification :

grype db update --force

En CI/CD : la mise à jour auto peut ralentir les builds. Deux stratégies :

Cache avec expiration : cache la DB pendant 7 jours, puis régénère
Mise à jour manuelle : grype db update dans un job séparé quotidien

Taille de la DB : environ 200-300 Mo compressée, 1-2 Go décompressée. Elle est stockée dans ~/.cache/grype/db/.

Intégration Outils CI/CD

Intégrer Grype dans votre pipeline automatise la détection des vulnérabilités avant le déploiement en production. L’objectif : détecter tôt, corriger vite.

Exemple GitHub Actions :

- name: Build and get digest
  run: |
    docker build -t myapp .
    echo "DIGEST=$(docker inspect myapp --format='{{.Id}}')" >> $GITHUB_ENV

- name: Scan image
  run: |
    grype myapp@${{ env.DIGEST }} \
      --fail-on critical \
      -o json > grype-report.json

- name: Upload report
  if: always()
  uses: actions/upload-artifact@v4
  with:
    name: grype-report
    path: grype-report.json

Stratégie de seuil :

--fail-on critical : Bloque uniquement les CVE critiques (CVSS ≥ 9.0)
--fail-on high : Bloque critical + high (CVSS ≥ 7.0)
--fail-on medium : Plus strict, peut générer beaucoup de faux positifs

Workflow recommandé :

Scan de répertoire (grype dir:.) lors du commit (pré-commit hook)
Scan d’image lors du build CI/CD
Fail-on critical pour bloquer les déploiements à risque
Upload JSON pour traçabilité et analyse historique
Intégration VEX pour filtrer les faux positifs validés

Optimisation cache :

- name: Cache Grype DB
  uses: actions/cache@v4
  with:
    path: ~/.cache/grype
    key: grype-db-${{ hashFiles('**/Dockerfile') }}
    restore-keys: grype-db-

:::caution Fraîcheur de la DB

La base CVE de Grype est mise à jour quotidiennement. En CI/CD avec cache, régénérez le cache hebdomadairement pour détecter les nouvelles CVE. Sinon, vous risquez de manquer des vulnérabilités récemment publiées.

:::

Conclusion

Grype s’impose comme un outil essentiel dans l’écosystème de la sécurité des conteneurs. Sa force réside dans sa simplicité d’usage (une commande unique) combinée à une richesse d’informations (scores EPSS, métadonnées CVE).

Points forts :

Rapidité : 12 CVE détectées en 2 secondes sur une image Alpine Python
Précision : Scores EPSS pour prioriser selon le risque réel d’exploitation
Polyvalence : Scan d’images, SBOM, répertoires source
Intégration : Pipeline CI/CD avec --fail-on, formats JSON/CycloneDX

Workflow complet recommandé :

Développement : Scan de répertoire (grype dir:.) en pré-commit pour détecter tôt les CVE dans requirements.txt
CI/CD : Scan d’image avec --fail-on critical pour bloquer les déploiements à risque
Production : Scan régulier des images déployées + VEX pour documenter les faux positifs
Monitoring : Intégration avec Dependency Track via format CycloneDX

Grype fonctionne en synergie avec d’autres outils :

Syft génère le SBOM (inventaire des composants)
Grype détecte les CVE dans ce SBOM
VEX filtre les faux positifs selon votre contexte d’usage
Dependency Track centralise et suit les vulnérabilités dans le temps

En pratique, l’adoption de Grype dans vos pipelines vous permet de détecter tôt les vulnérabilités (shift-left security), de prioriser les corrections selon EPSS, et de bloquer automatiquement les déploiements critiques. C’est un investissement minimal (une commande) pour un gain de sécurité maximal.

Plus d’infos

Site Officiel : https://anchore.com/grype/ ↗
Projet Grype : https://github.com/anchore/grype ↗