Trivy (prononcé /ˈtraɪvi/) est un scanner de sécurité complet open source développé par Aqua Security. Il compte plus de 35 000 stars sur GitHub. C'est l'un des outils de scan de sécurité open source les plus populaires du moment.

Le gros avantage de Trivy ? Sa polyvalence. Il peut scanner de nombreux types de cibles : images de conteneurs, systèmes de fichiers, dépôts Git, images de machines virtuelles, clusters Kubernetes. Et il détecte divers problèmes de sécurité : vulnérabilités CVE connues, erreurs de configuration IaC, fuites d'informations sensibles, licences logicielles, génération de SBOM. Pour les équipes DevSecOps modernes, Trivy couvre quasiment toute la chaîne de scan de sécurité. Du commit de code jusqu'au déploiement en production.

Cet article démarre avec l'installation. Puis on verra les fonctionnalités clés, les cas d'usage pratiques et comment intégrer Trivy dans vos pipelines CI/CD. Objectif : aider développeurs et ingénieurs sécurité à prendre en main rapidement cet outil puissant.

Pourquoi choisir Trivy ?

Avant Trivy, le monde du scan de sécurité était fragmenté. Il fallait des outils différents pour scanner les images de conteneurs, vérifier les configurations IaC, ou détecter les fuites de clés dans le code. Trivy rassemble tout ça dans un seul outil CLI. Voici ses points forts :

1. Support multi-cibles

Trivy peut scanner :

  • Images de conteneurs : Docker, images OCI (locales ou en remote)
  • Systèmes de fichiers : répertoires locaux, code source de projets
  • Dépôts Git : dépôts Git distants (sans clonage nécessaire)
  • Images de machines virtuelles : AWS EC2 AMI, Azure VM, etc.
  • Clusters Kubernetes : ressources configurées sur des clusters en cours d'exécution

2. Détection multi-dimensionnelle

Trivy détecte plusieurs types de problèmes de sécurité :

  • Vulnérabilités connues (CVE) : basé sur les bases de données de vulnérabilités des packages OS et des dépendances logicielles
  • Erreurs de configuration IaC : violations des bonnes pratiques sur Terraform, CloudFormation, Kubernetes YAML, etc.
  • Fuites d'informations sensibles : clés API, mots de passe, tokens en dur dans le code
  • Conformité des licences logicielles : identification des types de licences open source utilisées
  • Génération de SBOM : création de la liste des matériaux logiciels (Software Bill of Materials)

3. Facilité d'intégration

Trivy s'intègre partout :

4. Rapide et léger

Écrit en Go, Trivy démarre vite et consomme peu de mémoire. Parfait pour les exécutions fréquentes en CI/CD.

Installer Trivy

Plusieurs méthodes d'installation disponibles. Voici les plus courantes :

Méthode 1 : Homebrew (macOS/Linux)

BASH 
brew install trivy

Méthode 2 : Docker

BASH 
docker run aquasec/trivy --version

Méthode 3 : Binaire

Téléchargez le binaire depuis GitHub Releases :

BASH 
# Linux x86_64
wget https://github.com/aquasecurity/trivy/releases/download/v0.50.0/trivy_0.50.0_Linux-64bit.tar.gz
tar -xzf trivy_0.50.0_Linux-64bit.tar.gz
sudo mv trivy /usr/local/bin/

Méthode 4 : apt/yum (distributions Linux)

BASH 
# Ubuntu/Debian
sudo apt-get install wget gnupg
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
echo "deb https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy

# CentOS/RHEL
sudo yum install trivy

Vérifier l'installation

BASH 
trivy --version
# Exemple de sortie : Version: 0.50.0

Démarrage rapide : scanner votre première image de conteneur

Commençons simple. On va scanner une image Docker publique pour voir ce que Trivy trouve.

Scanner l'image officielle Python

BASH 
trivy image python:3.9-slim

Trivy affiche quelque chose comme ça :

python:3.9-slim (debian 11.7)
=====================================
Total: 123 (UNKNOWN: 0, LOW: 45, MEDIUM: 52, HIGH: 24, CRITICAL: 2)

+------------------+---------------------+----------+-------------------+---------------+---------------------------------------+
|     LIBRARY      |   VULNERABILITY ID  | SEVERITY | INSTALLED VERSION | FIXED VERSION |               TITLE                   |
+------------------+---------------------+----------+-------------------+---------------+---------------------------------------+
| libssl1.1        | CVE-2023-5678       | CRITICAL | 1.1.1w-0+deb11u1  | 1.1.1w-0+deb11u2 | OpenSSL: X.509 Email Address ...     |
| openssl          | CVE-2023-6129       | HIGH     | 1.1.1w-0+deb11u1  | 1.1.1w-0+deb11u2 | OpenSSL: POLY1305 MAC implementation... |
+------------------+---------------------+----------+-------------------+---------------+---------------------------------------+

L'output contient ces infos clés :

  • Total des vulnérabilités : classées par gravité (UNKNOWN, LOW, MEDIUM, HIGH, CRITICAL)
  • Tableau des détails : nom de la librairie, ID CVE, gravité, version actuelle, version corrigée, description

N'afficher que les vulnérabilités HIGH et CRITICAL

En pratique, on se concentre sur les vulnérabilités graves. Filtrez avec --severity :

BASH 
trivy image --severity HIGH,CRITICAL python:3.9-slim

Sortie au format JSON (pour l'automatisation)

BASH 
trivy image --format json python:3.9-slim > results.json

Fonctionnalités clés en détail

1. Scan du système de fichiers

En plus des images de conteneurs, Trivy scanne les systèmes de fichiers locaux. Ça permet de détecter les vulnérabilités dans les dépendances du projet dès le développement.

BASH 
# Scanner le répertoire courant
trivy fs .

# Scanner un répertoire spécifique
trivy fs /path/to/project

# Scanner uniquement certaines langues
trivy fs --scanners vuln --language python /path/to/project

Trivy supporte : Python, Node.js, Java, Go, Ruby, PHP, .NET, Rust et les autres langages majeurs.

2. Scan des dépôts Git

Trivy scanne directement les dépôts Git distants. Pas besoin de cloner :

BASH 
# Scanner un dépôt GitHub public
trivy repo https://github.com/aquasecurity/trivy

# Scanner une branche spécifique
trivy repo https://github.com/aquasecurity/trivy@main

Très pratique pour auditer la sécurité de projets open source tiers.

3. Scan des configurations Kubernetes

Les erreurs de configuration Kubernetes sont une cause majeure d'incidents de sécurité. Trivy vérifie si vos fichiers YAML respectent les bonnes pratiques :

BASH 
# Scanner un fichier YAML
trivy config deployment.yaml

# Scanner tous les fichiers d'un répertoire
trivy config ./k8s-manifests/

Trivy détecte :

  • Les conteneurs qui tournent en root
  • L'absence de limites de ressources (CPU/mémoire)
  • L'utilisation du tag latest
  • Le mode privilégié activé
  • Les informations sensibles codées en dur dans les variables d'environnement

Exemple de sortie :

k8s-manifests/deployment.yaml
=============================
Tests: 15 (SUCCESSES: 12, FAILURES: 3, EXCEPTIONS: 0)
Failures: 3 (UNKNOWN: 0, LOW: 1, MEDIUM: 1, HIGH: 1, CRITICAL: 0)

+-----------+------------+-----------------+----------+---------------------------------------+
| TYPE      | MISCONF ID |    CHECK        | SEVERITY |              MESSAGE                  |
+-----------+------------+-----------------+----------+---------------------------------------+
| Kubernetes| KSV012     | Image Tag       | MEDIUM   | Container 'app' uses 'latest' tag     |
| Kubernetes| KSV001     | Privileged      | HIGH     | Container 'app' runs in privileged mode|
+-----------+------------+-----------------+----------+---------------------------------------+

4. Génération de SBOM (Software Bill of Materials)

Le SBOM est essentiel pour la sécurité de la chaîne d'approvisionnement logicielle. Trivy génère des SBOM aux formats standards :

BASH 
# Générer un SBOM au format SPDX
trivy image --format spdx-json python:3.9-slim > sbom.spdx.json

# Générer un SBOM au format CycloneDX
trivy image --format cyclonedx python:3.9-slim > sbom.cyclonedx.xml

Les SBOM générés servent pour les audits de conformité et l'analyse d'impact des vulnérabilités.

5. Détection des fuites d'informations sensibles

Trivy scanne le code pour détecter les informations sensibles codées en dur (clés API, mots de passe, tokens) :

BASH 
trivy fs --scanners secret ./my-project

Règles de détection intégrées :

  • AWS Access Key
  • GitHub Token
  • Slack Webhook URL
  • Clé privée
  • Chaîne de connexion base de données

Intégration CI/CD en pratique

Intégrer Trivy dans vos pipelines CI/CD est la clé du "shift left" en sécurité. Voici des exemples pour les plateformes courantes.

GitHub Actions

Créez .github/workflows/trivy.yml à la racine du projet :

YAML 
name: Trivy Security Scan

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

jobs:
  trivy-scan:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'python:3.9-slim'
          format: 'table'
          severity: 'CRITICAL,HIGH'
          exit-code: '1'  # Échec si vulnérabilités graves détectées

Ce workflow scanne automatiquement l'image de conteneur à chaque push ou PR. Si des vulnérabilités HIGH ou CRITICAL sont trouvées, le CI échoue.

GitLab CI

Ajoutez dans .gitlab-ci.yml :

YAML 
trivy-scan:
  image:
    name: aquasec/trivy:latest
    entrypoint: [""]
  script:
    - trivy fs --exit-code 1 --severity HIGH,CRITICAL .
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

Jenkins Pipeline

GROOVY 
pipeline {
    agent any

    stages {
        stage('Security Scan') {
            steps {
                sh '''
                    docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
                        aquasec/trivy image --exit-code 1 --severity HIGH,CRITICAL \
                        my-app:latest
                '''
            }
        }
    }
}

Fonctionnalités avancées

1. Ignorer certaines vulnérabilités

Certaines vulnérabilités peuvent être inexploitables dans votre contexte. Créez un fichier .trivyignore :

# .trivyignore
CVE-2023-1234
CVE-2023-5678

Ou utilisez --ignorefile pour un fichier personnalisé :

BASH 
trivy image --ignorefile .trivyignore python:3.9-slim

2. Mettre en cache la base de données des vulnérabilités

Par défaut, Trivy met à jour la base de données à chaque scan. En CI/CD, ça crée du surcoût réseau. Utilisez le cache :

BASH 
# Télécharger la base de données
trivy image --download-db-only

# Scans suivants avec cache local
trivy image --skip-db-update python:3.9-slim

Dans GitHub Actions, utilisez actions/cache :

YAML 
- name: Cache Trivy DB
  uses: actions/cache@v3
  with:
    path: ~/.cache/trivy
    key: trivy-db-${{ hashFiles('~/.cache/trivy/db/trivy.db') }}
    restore-keys: trivy-db-

3. Templates de rapports personnalisés

Trivy supporte les templates Go pour personnaliser l'output :

BASH 
trivy image --format template --template "@contrib/html.tpl" python:3.9-slim > report.html

Templates intégrés :

  • @contrib/html.tpl : rapport HTML
  • @contrib/junit.tpl : format JUnit XML (pour CI/CD)
  • @contrib/sarif.tpl : format SARIF (pour GitHub Code Scanning)

4. Intégration avec Trivy Operator (Kubernetes)

Pour les clusters Kubernetes en production, déployez Trivy Operator pour une surveillance continue :

BASH 
helm repo add aqua https://aquasecurity.github.io/helm-charts/
helm install trivy-operator aqua/trivy-operator --namespace trivy-system --create-namespace

Trivy Operator scanne automatiquement les workloads du cluster. Les résultats sont stockés en tant que CRD Kubernetes. Vous pouvez les consulter dans un Dashboard ou via l'API.

Dépannage des problèmes courants

Problème 1 : Scan trop lent

Cause : Le premier scan télécharge la base de données de vulnérabilités (environ 100-200 Mo).

Solution : Utilisez --skip-db-update ou téléchargez la base à l'avance :

BASH 
trivy image --download-db-only
trivy image --skip-db-update python:3.9-slim

Problème 2 : Trop de faux positifs

Cause : La base de données peut contenir des vulnérabilités inexploitables dans votre contexte.

Solution : Utilisez .trivyignore pour ignorer les faux positifs connus, ou ajustez --severity pour ne voir que les vulnérabilités graves.

Problème 3 : Échec du scan d'images privées

Cause : Trivy ne peut pas accéder aux registries privées nécessitant une authentification.

Solution : Définissez les variables d'environnement ou utilisez --registry-token :

BASH 
export TRIVY_USERNAME=myuser
export TRIVY_PASSWORD=mypassword
trivy image registry.example.com/my-private-image:latest

Problème 4 : Manque de mémoire

Cause : Le scan d'images ou systèmes de fichiers volumineux peut consommer beaucoup de mémoire.

Solution : Augmentez la limite mémoire du conteneur, ou utilisez le mode --light :

BASH 
trivy image --light python:3.9-slim

Résumé

Trivy est un outil de scan de sécurité puissant et facile à utiliser. Sa valeur réside dans :

  1. La complétude : support de multiples cibles et types de détection, couvrant toute la chaîne de sécurité du code à la production
  2. La simplicité : interface CLI simple, documentation riche et communauté active
  3. L'intégration facile : support natif des plateformes CI/CD et Kubernetes majeures
  4. Les performances : implémenté en Go, démarrage rapide et faible consommation mémoire

Pour toute équipe de développement qui prend la sécurité au sérieux, intégrer Trivy dans le workflow quotidien est un choix judicieux. Il permet de détecter et corriger les problèmes de sécurité en amont, réduisant ainsi les risques en production.

Prochaines étapes recommandées :

  1. Installez Trivy en local et testez-le sur quelques images de conteneurs courantes
  2. Intégrez Trivy dans vos pipelines CI/CD avec des seuils de sécurité adaptés
  3. Passez en revue régulièrement les résultats de scan et établissez un processus de correction
  4. Explorez Trivy Operator pour ajouter une surveillance continue à vos clusters Kubernetes

La documentation officielle de Trivy est sur https://trivy.dev. Le dépôt GitHub est https://github.com/aquasecurity/trivy. En cas de problème, vous trouverez de l'aide détaillée et du support communautaire à ces adresses.

Lectures connexes :