Préambule

Si vous ne savez pas ce qu’est une SBOM (Software Bill of Materials), je vous invite à lire mon article sur SBOM.

Grype - Qu’est-ce que c’est ?

Dans l’article précédant je vous ai présenté Syft pour générer ces fameuses SBOM, Grype est un outil complémentaire et développé par la même équipe, qui permet de scanner ces SBOM à la recherche de vulnérabilités connues. Il est notamment utile dans une chaine de CI/CD pour automatiser la détection de vulnérabilités dans les dépendances utilisées par votre projet.

En Local

Installation

Là encore les étapes ressemblent beaucoup à l’installation de Syft.

Sur Linux ou macOS, vous pouvez installer Syft en utilisant Homebrew :

brew tap anchore/grype
brew install grype

ou via curl :

curl -sSfL https://get.anchore.io/grype | sudo sh -s -- -b /usr/local/bin

Sur Windows j’aime utiliser Scoop :

scoop bucket add main
scoop install grype

Un petit coup de grype version pour vérifier que tout est bien installé et c’est parti !

Application:         grype
Version:             0.111.1
BuildDate:           2026-04-22T17:16:07Z
GitCommit:           89819276e8ebf63b4f607ca3a1b0faa3fc75f28d
GitDescription:      v0.111.1
Platform:            windows/amd64
GoVersion:           go1.26.2
Compiler:            gc
Syft Version:        v1.43.0
Supported DB Schema: 6

Utilisation

Le cas simple à partir d’une image docker :

Le résultat :

grype alpine:latest

 ✔ Vulnerability DB                [updated]  
 ✔ Parsed image                                                                                                                                         sha256:3cb067eab609612d81b4d82ff8ad71d73482bb3059a87b642d7e14f0ed659cde 
 ✔ Cataloged contents                                                                                                                                          4d889c14e7d5a73929ab00be2ef8ff22437e7cbc545931e52554a7b00e123d8b 
   ├── ✔ Packages                        [16 packages]  
   ├── ✔ File metadata                   [79 locations]  
   ├── ✔ Executables                     [17 executables]  
   └── ✔ File digests                    [79 files]  
 ✔ Scanned for vulnerabilities     [3 vulnerability matches]  
   ├── by severity: 0 critical, 0 high, 3 medium, 0 low, 0 negligible
   └── by status:   0 fixed, 3 not-fixed, 0 ignored 
NAME           INSTALLED   TYPE  VULNERABILITY   SEVERITY  EPSS           RISK   
busybox        1.37.0-r30  apk   CVE-2025-60876  Medium    < 0.1% (15th)  < 0.1  
busybox-binsh  1.37.0-r30  apk   CVE-2025-60876  Medium    < 0.1% (15th)  < 0.1  
ssl_client     1.37.0-r30  apk   CVE-2025-60876  Medium    < 0.1% (15th)  < 0.1

Et pour une analyse encore plus rapide, vous pouvez directement scanner une SBOM générée par Syft :

syft alpine:latest -o cyclonedx-json > sbom.json # génère une SBOM pour l'image alpine:latest
grype sbom:./sbom.json # scanne la SBOM à la recherche de vulnérabilités²

En CI (GitHub Actions)

Savoir détecté les vulnérabilités en local c’est bien mais automatiser leurs détection dans une pipeline CI/CD c’est encore mieux ! On applique ainsi les bonnes pratiques DevOps : détecter tôt les problèmes lors du cycle de développement, corriger vite et avant déploiement en production.

Voici un exemple de workflow GitHub Actions qui utilise Grype pour scanner une image Docker à la recherche de vulnérabilités et échoue si une vulnérabilité critique est détectée.

name: Build, SBOM and Grype scan

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  workflow_dispatch:

jobs:
  build-scan:
    name: Build image, generate SBOM and scan with Grype
    runs-on: ubuntu-latest

    permissions:
      contents: read

    env:
      IMAGE_NAME: demo-node-app
      IMAGE_TAG: ${{ github.sha }}

    steps:
      - name: Checkout repository
        uses: actions/checkout@v6

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4

      - name: Build Node.js Docker image (load locally)
        uses: docker/build-push-action@v7
        with:
          context: .
          file: ./Dockerfile
          push: false
          load: true
          tags: ${{ env.IMAGE_NAME }}:${{ env.IMAGE_TAG }}

      - name: Generate SBOM with Syft (SPDX JSON)
        uses: anchore/sbom-action@v0
        with:
          image: ${{ env.IMAGE_NAME }}:${{ env.IMAGE_TAG }}
          format: spdx-json
          output-file: sbom.spdx.json
          upload-artifact: false

      - name: Upload SBOM artifact
        uses: actions/upload-artifact@v4
        with:
          name: sbom
          path: sbom.spdx.json
          if-no-files-found: error

      - name: Scan SBOM with Grype (fail on critical)
        id: grype
        uses: anchore/scan-action@v7
        with:
          sbom: sbom.spdx.json
          fail-build: true
          severity-cutoff: critical
          output-format: sarif
          output-file: grype-report.sarif

      - name: Upload Grype report artifact
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: grype-report
          path: grype-report.sarif
          if-no-files-found: error

Vous pouvez retrouver un exemple fonctionnel sur mon GitHub.

Il est également possible d’arriver au même résultat en jouant les commandes présentées ci dessous mais Anchore propose des actions GitHub pré-construites pour faciliter l’intégration de Syft et Grype dans vos workflows CI/CD. Encore une fois autant privilégier la facilité et éviter de réinventer la roue.

Conclusion

Grype est un outil à la fois simple et puissant pour analyser vos SBOM à la recherche de vulnérabilités. Il s’intègre facilement en CI et peut même être configuré en tant que commit hook pour scanner vos images ou votre code avant même de pousser vos changements, réduisant ainsi la boucle de feedback.

Sources