🎯 Objectif de la semaine
Maîtriser l'intégration DevSecOps en configurant des pipelines CI/CD automatisés avec SAST (Static Application Security Testing) et DAST (Dynamic Application Security Testing). Apprendre à "shift left" la sécurité – la déplacer le plus tôt possible dans le cycle de développement – pour prévenir les vulnérabilités avant qu'elles n'atteignent la production.
Pourquoi c'est essentiel : Dans le monde moderne du développement logiciel, la sécurité ne peut plus être une phase finale. Elle doit être intégrée, automatisée et continue. Un pipeline DevSecOps efficace peut prévenir 80% des vulnérabilités courantes avant le déploiement.
Analyse Statique] SAST -->|Fail on Critical| STOP[⛔ Bloque Pipeline] SAST -->|Pass| SCA[📦 Software Composition Analysis] SCA --> DAST[⚡ DAST
Analyse Dynamique] DAST --> IAC[🏗️ IaC Scanning] IAC --> SEC[🔒 Security Gates] SEC --> DEPLOY[🚀 Déploiement] subgraph "🔄 Feedback Loop" SAST -.->|Rapports| DEV[👨💻 Développeurs] DAST -.->|Rapports| DEV DEV -->|Corrections| C end style SAST fill:#0a0e17,stroke:#00d4ff,stroke-width:2px style DAST fill:#0a0e17,stroke:#9d4edd,stroke-width:2px style STOP fill:#11151f,stroke:#ef4444,stroke-width:3px
📚 Sujet – Théorie (1 heure)
DevSecOps : La Sécurité comme Code
DevSecOps n'est pas simplement "ajouter des outils de sécurité à DevOps". C'est une transformation culturelle et technique qui intègre la sécurité à chaque étape du cycle de vie logiciel.
Plan
Définir les exigences de sécurité dès la conception
- Threat modeling
- Security requirements
- Compliance checks
Code
SAST, secrets detection, peer review
- IDE plugins
- Pre-commit hooks
- Code review
Build
SCA, dependency scanning
- Vulnérabilités librairies
- License compliance
- SBOM generation
Deploy
DAST, IaC scanning
- Runtime testing
- Config validation
- Security gates
Les Quatre Piliers du Testing Sécurité
🔍 SAST
Static Application Security Testing
- Quand : Phase Code/Build
- Cible : Code source
- Exemples : Semgrep, SonarQube
- Avantages : Précoce, complet
- Limites : Faux positifs
⚡ DAST
Dynamic Application Security Testing
- Quand : Phase Test/Deploy
- Cible : Application running
- Exemples : OWASP ZAP, Burp Suite
- Avantages : Réaliste, runtime
- Limites : Coverage limité
📦 SCA
Software Composition Analysis
- Quand : Phase Build
- Cible : Dépendances
- Exemples : Trivy, Snyk
- Avantages : Détection libs vulnérables
- Limites : Transitive dependencies
🏗️ IaC Scan
Infrastructure as Code Scanning
- Quand : Phase Build/Deploy
- Cible : Terraform, Dockerfile
- Exemples : Checkov, Terrascan
- Avantages : Sécurité infrastructure
- Limites : Cloud-specific
Gestion des Résultats : Sécurité Intelligente
🎯 Stratégie de Gestion des Résultats
1. Classification par Sévérité :
2. Gates de Sécurité :
- Gate 1 : Bloque sur CRITIQUE > 0
- Gate 2 : Avertit sur ÉLEVÉ > 3
- Gate 3 : Log uniquement sur MOYEN/FAIBLE
3. Réduction Faux Positifs :
.semgrepignorepour règles spécifiqueszap-baseline.confpour tuning DAST- Annotations dans le code (
// nosec)
Shift Left vs Shift Right
⚠️ Comprendre les Deux Directions
Shift Left (Déplacer à Gauche) :
- Sécurité dès la conception
- SAST dans l'IDE
- Prévention avant production
- Objectif : Éviter les vulnérabilités
Shift Right (Déplacer à Droite) :
- Runtime security
- RASP (Runtime App Self-Protection)
- Monitoring production
- Objectif : Détecter et répondre
La vraie stratégie : Faire les deux ! Prévenir tôt (Left) et surveiller toujours (Right).
🔬 Mission pratique – Laboratoire (2 heures)
Architecture du Pipeline DevSecOps
⚠️ Préparation des Outils
📋 Comptes Nécessaires :
- GitLab.com : Compte gratuit (10GB CI minutes)
- Semgrep.dev : Compte gratuit pour règles avancées
- Docker Hub : Pour images officielles
Étapes Détaillées d'Implémentation
Étape 1 : Application Vulnérable de Référence
# app.py - Application Flask intentionnellement vulnérable
from flask import Flask, request, render_template_string
import os
import subprocess
import sqlite3
import pickle
app = Flask(__name__)
# Hard-coded secret (SAST devra détecter)
API_KEY = "sk_live_1234567890abcdef"
DATABASE_PASSWORD = "admin123"
@app.route('/')
def home():
# XSS via template non échappé
name = request.args.get('name', 'World')
template = f"<h1>Hello {name}!</h1>"
return render_template_string(template)
@app.route('/cmd')
def execute_command():
# Command Injection
cmd = request.args.get('cmd', 'whoami')
result = subprocess.check_output(cmd, shell=True)
return result
@app.route('/users')
def get_users():
# SQL Injection
user_id = request.args.get('id', '1')
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()
cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")
return str(cursor.fetchall())
@app.route('/deserialize')
def deserialize_data():
# Insecure Deserialization
data = request.args.get('data', '')
obj = pickle.loads(bytes.fromhex(data))
return str(obj)
@app.route('/secret')
def show_secret():
# Information Disclosure
return f"API Key: {API_KEY}<br>DB Pass: {DATABASE_PASSWORD}"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)
# requirements.txt
flask==2.3.3
Werkzeug==2.3.7
Étape 2 : Configuration GitLab CI Complète
# .gitlab-ci.yml - Pipeline DevSecOps complet
stages:
- build
- test
- security
- deploy
variables:
DOCKER_IMAGE: "registry.gitlab.com/$CI_PROJECT_PATH:$CI_COMMIT_SHA"
# Build l'application
build:
stage: build
image: docker:latest
services:
- docker:dind
script:
- docker build -t $DOCKER_IMAGE .
- docker push $DOCKER_IMAGE
only:
- main
- develop
# Tests unitaires basiques
unit_tests:
stage: test
image: python:3.11
before_script:
- pip install -r requirements.txt
script:
- python -m pytest tests/ --tb=short
artifacts:
reports:
junit: report.xml
coverage: '/TOTAL.*\s+(\d+\.\d+%)/'
# SAST avec Semgrep (Static Analysis)
sast_semgrep:
stage: security
image: returntocorp/semgrep:latest
script:
- semgrep ci --config auto --json --output semgrep-report.json
- semgrep ci --config auto --sarif --output semgrep-report.sarif
artifacts:
reports:
sast: semgrep-report.json
sast_sarif: semgrep-report.sarif
paths:
- semgrep-report.json
expire_in: 1 week
allow_failure: false
# Software Composition Analysis avec Trivy
sca_trivy:
stage: security
image: aquasec/trivy:latest
script:
- trivy filesystem --format json --output trivy-report.json .
- trivy filesystem --severity CRITICAL,HIGH .
artifacts:
reports:
dependency_scanning: trivy-report.json
allow_failure: false
# DAST avec OWASP ZAP
dast_zap:
stage: security
image: owasp/zap2docker-stable:latest
variables:
ZAP_URL: "http://web:5000"
script:
# Démarre l'application en background
- pip install -r requirements.txt
- python app.py &
- sleep 10 # Attend que l'app démarre
# Scan baseline avec règles custom
- zap-baseline.py -t $ZAP_URL -g zap-config.conf -r zap-report.html -J zap-report.json
# Scan actif (optionnel, plus long)
# - zap-full-scan.py -t $ZAP_URL -g zap-config.conf -r zap-full-report.html
artifacts:
reports:
dast: zap-report.html
paths:
- zap-report.html
- zap-report.json
expire_in: 1 week
allow_failure: true # DAST peut être bruyant
# Security Gate - Décision de déploiement
security_gate:
stage: security
image: python:3.11
needs: ["sast_semgrep", "sca_trivy"]
script:
- |
# Analyse rapport Semgrep
if [ -f semgrep-report.json ]; then
CRITICAL_COUNT=$(jq '.results[] | select(.extra.severity == "ERROR") | .check_id' semgrep-report.json | wc -l)
if [ $CRITICAL_COUNT -gt 0 ]; then
echo "❌ $CRITICAL_COUNT vulnérabilités CRITIQUES détectées"
echo "Le pipeline est bloqué"
exit 1
fi
fi
# Analyse rapport Trivy
if [ -f trivy-report.json ]; then
HIGH_VULNS=$(jq '.Results[].Vulnerabilities[] | select(.Severity == "HIGH") | .VulnerabilityID' trivy-report.json | wc -l)
if [ $HIGH_VULNS -gt 3 ]; then
echo "⚠️ $HIGH_VULNS vulnérabilités ÉLEVÉES dans les dépendances"
echo "Considérer une mise à jour des librairies"
# Continue mais avec warning
fi
fi
echo "✅ Security Gate passed"
allow_failure: false
# Déploiement conditionnel
deploy_staging:
stage: deploy
image: alpine:latest
script:
- echo "Déploiement sur staging..."
- echo "Application déployée avec succès"
only:
- main
when: manual # Déploiement manuel après validation
needs: ["security_gate"]
Étape 3 : Fichiers de Configuration Avancés
# zap-config.conf - Configuration OWASP ZAP
# Exclure certaines règles bruyantes
-rule=10010 # Incomplete Cache Control
-rule=10015 # Incomplete HTTP Headers
-rule=10016 # Server Leaks Information
# Paramètres de scan
-strength=MEDIUM
-threshold=MEDIUM
# Domains à inclure/exclure
-include=.*\.gitlab\.io.*
-exclude=.*logout.*
# .semgrep.yml - Règles custom Semgrep
rules:
- id: hardcoded-secrets
pattern: |
$KEY = "..."
message: "Secret hard-codé détecté"
severity: ERROR
languages: [python]
- id: command-injection
pattern: |
subprocess.check_output($CMD, shell=True)
message: "Appel shell non sécurisé"
severity: WARNING
languages: [python]
- id: sql-injection
pattern: |
cursor.execute(f"...{ $USER_INPUT }...")
message: "SQL Injection possible"
severity: ERROR
languages: [python]
Étape 4 : Dockerfile Sécurisé
# Dockerfile
FROM python:3.11-slim
# User non-root pour sécurité
RUN useradd -m -u 1000 appuser
WORKDIR /app
# Copie requirements d'abord pour cache Docker
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copie application
COPY --chown=appuser:appuser . .
# Switch user
USER appuser
# Port exposé
EXPOSE 5000
# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD curl -f http://localhost:5000/ || exit 1
# Commande de démarrage
CMD ["python", "app.py"]
Étape 5 : Exécution et Analyse des Résultats
📊 Analyse des Rapports
- SAST Report (Semgrep) : Détectera :
- Secrets hard-codés (API_KEY, DATABASE_PASSWORD)
- SQL Injection (f-string dans cursor.execute)
- Command Injection (subprocess avec shell=True)
- DAST Report (ZAP) : Détectera :
- XSS via paramètre name non échappé
- Information Disclosure (/secret endpoint)
- Missing Security Headers
- SCA Report (Trivy) : Analysera :
- Vulnérabilités dans Flask/Werkzeug
- Licences des dépendances
Exercice Avancé : Intégration Continue d'Amélioration
🎯 Défi DevSecOps Avancé
Améliorez le pipeline avec :
- IaC Scanning : Ajoutez Checkov pour scanner le Dockerfile
- Secrets Detection : Intégrez GitLeaks ou TruffleHog
- SBOM Generation : Générez un Software Bill of Materials
- Security Dashboard : Visualisez les métriques dans Grafana
# Ajout au .gitlab-ci.yml
iac_scan:
stage: security
image: bridgecrew/checkov:latest
script:
- checkov -d . --quiet --compact --output sarif --output-file checkov-report.sarif
secrets_detection:
stage: security
image: zricethezav/gitleaks:latest
script:
- gitleaks detect --source . --report-format sarif --report-path gitleaks-report.sarif
sbom_generation:
stage: security
image: cyclonedx/cyclonedx-cli:latest
script:
- cyclonedx-py -r -i requirements.txt -o sbom.xml
Bonnes Pratiques pour la Production
⚠️ Considérations Production
- Performance : SAST/DAST peuvent ralentir le pipeline
- Faux Positifs : Tuning nécessaire pour chaque projet
- Sécurité des Secrets : Jamais de secrets dans le code !
- Compliance : Audit trails pour les rapports
📋 Objectif de la semaine – Checklist de validation
✅ Compétences techniques acquises
- Pipeline GitLab CI avec stages Build/Test/Security/Deploy
- SAST fonctionnel avec Semgrep et rapports JSON
- DAST fonctionnel avec OWASP ZAP baseline
- Security Gate avec décision de déploiement
- Gestion des artefacts et rapports
🧠 Changement mental accompli
- Vision de la sécurité comme processus intégré, pas comme phase finale
- Compréhension du "Shift Left" et de ses bénéfices
- Habitude d'automatiser toutes les vérifications sécurité
- Conscience des compromis sécurité/vélocité
💪 Pour aller plus loin :
Explorez GitLab Ultimate (gratuit pour projets open-source) pour les fonctionnalités avancées : Security Dashboard, Vulnerability Management, Compliance Dashboard.
📚 Ressources pour Approfondir
Outils et Standards :
- OWASP DevSecOps Guideline : Guide complet des pratiques
- NIST SSDF : Secure Software Development Framework
- SLSA : Supply-chain Levels for Software Artifacts
- SPDX : Standard pour SBOM
⚠️ Pièges Courants DevSecOps
- Alert Fatigue : Trop d'alertes → tout ignoré
- Security Theater : Outils sans processus
- Tool Sprawl : Trop d'outils sans intégration
- Cultural Resistance : Développeurs vs Sécurité
🔮 Frère d'armes,
Tu viens d'intégrer la sécurité dans l'ADN du développement.
DevSecOps n'est pas une collection d'outils – c'est une philosophie de construction. C'est la reconnaissance que la sécurité n'est pas quelque chose qu'on "ajoute", mais quelque chose qu'on "tisse" dans chaque ligne de code, chaque commit, chaque déploiement.
Cette semaine, tu as vu la différence entre scanner une application et sécuriser un processus. Entre trouver des vulnérabilités et les empêcher d'exister. Tu as transformé la sécurité d'une activité réactive en une pratique proactive.
Mais voici la leçon la plus importante : l'automatisation de la sécurité n'enlève pas la nécessité de la pensée sécurité. Elle déplace cette pensée plus tôt, plus souvent, plus systématiquement. Un pipeline DevSecOps ne remplace pas un développeur conscient – il l'équipe mieux.
Tu n'es plus un simple testeur qui trouve des bugs après coup. Tu es devenu un ingénieur qui conçoit des systèmes où les bugs ont du mal à naître. Qui transforme chaque "fail" du pipeline en opportunité d'apprentissage. Qui mesure la sécurité non pas en vulnérabilités trouvées, mais en vulnérabilités prévenues.
Dans la semaine 48, nous irons plus loin dans l'automatisation. Nous apprendrons à orchestrer la réponse aux incidents, à créer des playbooks automatisés, à réduire le temps entre détection et réponse de jours à minutes.
Mais pour l'instant, perfectionne ton pipeline. Ajoute des étapes, affine les règles, mesure l'efficacité. Un bon pipeline DevSecOps est comme un bon système immunitaire : il s'améliore à chaque exposition.
Un Gardien qui maîtrise DevSecOps ne construit plus de châteaux forts – il forge des forteresses vivantes qui grandissent plus fortes à chaque ligne de code.
— Platon-Y