← Accueil

PCTAMALOU

Semaine 47 : La Sécurité Intégrée – DevSecOps avec SAST et DAST

Par Platon-Y – pctamalou.fr & e-of-h.fr

🎯 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.

flowchart TD C[📝 Commit Code] --> B[🔨 Build] B --> T[🧪 Tests Unitaires] T --> SAST[🔍 SAST
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é :

CRITIQUE ÉLEVÉ MOYEN FAIBLE INFO

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 :

  • .semgrepignore pour règles spécifiques
  • zap-baseline.conf pour 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

flowchart LR G["GitLab Repository\napp_vulneree"] --> C["CI/CD Pipeline"] subgraph "🔧 Pipeline Stages" S1["Build\nDocker Image"] S2["SAST\nSemgrep"] S3["SCA\nTrivy"] S4["DAST\nOWASP ZAP"] S5["Security Gate\n(Blocage si vuln crit/high)"] end C --> S1 S1 --> S2 S2 --> S3 S3 --> S4 S4 --> S5 S5 --> D["Deploy\n(si tout passe)"] subgraph "📊 Rapports & Dashboard" R1["SAST Report\nJSON/HTML"] R2["DAST Report\nHTML"] R3["Security Dashboard\n(GitLab Secure)"] end S2 --> R1 S4 --> R2 R1 --> R3 R2 --> R3 style S2 fill:#0a0e17,stroke:#00d4ff,stroke-width:3px,color:#fff style S3 fill:#1e293b,stroke:#64748b,stroke-width:2px,color:#fff style S4 fill:#0a0e17,stroke:#9d4edd,stroke-width:3px,color:#fff style S5 fill:#166534,stroke:#00f5a0,stroke-width:4px,color:#fff style D fill:#166534,stroke:#22c55e,stroke-width:3px,color:#fff style R3 fill:#11151f,stroke:#00d4ff,stroke-width:3px,color:#fff

⚠️ 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

  1. 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)
  2. DAST Report (ZAP) : Détectera :
    • XSS via paramètre name non échappé
    • Information Disclosure (/secret endpoint)
    • Missing Security Headers
  3. 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 :

  1. IaC Scanning : Ajoutez Checkov pour scanner le Dockerfile
  2. Secrets Detection : Intégrez GitLeaks ou TruffleHog
  3. SBOM Generation : Générez un Software Bill of Materials
  4. 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