SAST - Static Application Security Testing en 2026

Le SAST (Static Application Security Testing) est l'analyse statique du code source ou bytecode d'une application pour détecter les vulnérabilités sans exécuter le programme. Il identifie les classes de défaut OWASP Top 10 2021 : injection SQL/CWE-89, XSS/CWE-79, command injection/CWE-78, deserialization/CWE-502, hardcoded secrets/CWE-798, path traversal/CWE-22, LDAP injection/CWE-90, weak cryptography/CWE-327. Le concept émerge fin années 1990, devient mature avec Fortify (HP, ~2003) et Coverity (Synopsys, ~2003), et explose en 2020-2026 avec Semgrep (r2c, OSS + commercial), GitHub CodeQL (acquisition Semmle 2019), Snyk Code (acquisition DeepCode 2020), SonarQube/SonarCloud, Checkmarx One, Veracode. La rupture 2024-2026 est l'AI-augmented SAST : GitHub Copilot Autofix (mars 2024) génère automatiquement des patches sur les findings CodeQL, réduisant le temps moyen de remédiation de 9-12 semaines à 28 jours selon GitHub. La couche reachability analysis (Endor Labs lancé 2022, IPO 2024) réduit les faux positifs SCA de 60-80 % en filtrant les vulns dans le code non-appelé. Comprendre la distinction SAST/DAST/IAST/RASP, les leaders 2026, l'intégration CI/CD shift-left, le piège des faux positifs, et l'émergence de l'AI autofix est non-négociable pour tout architecte AppSec ou ingénieur DevSecOps en 2026.

Pour le contexte adjacent : voir CWE - Common Weakness Enumeration pour la taxonomie des classes de défaut détectées par SAST, et WAF - Web Application Firewall pour la couche runtime complémentaire au SAST.

1. Définition et méthodologie SAST

Le SAST analyse le code à plusieurs niveaux d'abstraction :

Taint analysis = la technique cœur du SAST moderne. On marque les sources (entrées non-fiables : HTTP params, query strings, headers, file uploads) puis on suit leur propagation à travers le code jusqu'à des sinks sensibles (SQL query, command exec, eval, deserialize). Si la donnée tainted atteint un sink sans sanitizer (validation, encoding, parametrization), c'est une vulnérabilité.

Méthodologie SAST classique :

[Source code]
    │
    ▼
[Parsing] → AST
    │
    ▼
[Build CFG / Call Graph]
    │
    ▼
[Build Data Flow Graph (DFG)]
    │
    ▼
[Run rules / queries]
    ├─► Pattern matching (Semgrep)
    ├─► Symbolic execution (CodeQL)
    └─► Taint analysis multi-step (Checkmarx, Veracode)
    │
    ▼
[Filter false positives]
    │
    ▼
[Findings + remediation suggestions]

2. Catégories SAST en 2026

Cette taxonomie est nouvelle en 2024-2026 : avant, « SAST » signifiait uniquement application code. La convergence DevSecOps a élargi le terme à toute analyse statique pré-build. Beaucoup d'outils modernes (Semgrep, Snyk, GitHub Advanced Security) couvrent désormais plusieurs catégories dans un seul produit.

3. Leaders du marché SAST 2026

3.1 SAST application code

3.2 SAST open-source spécialisés

Position tranchée 2026 : pour stack GitHub/Microsoft, GitHub Advanced Security + Copilot Autofix (49 $/contributor/mois) est rarement contestable, couverture CodeQL excellente, autofix mature, intégration native. Pour stack hétérogène ou multi-cloud, Semgrep AppSec Platform + langages spécialisés open-source (Bandit, gosec, Brakeman, govulncheck) couvre 80-90 % à coût raisonnable. Snyk Code intéressant si IDE-first culture. Eviter Checkmarx/Veracode sauf compliance forte (banque, défense, gov) ou langages legacy non-couverts.

4. Reachability Analysis - rupture 2024-2026

Endor Labs (lancé 2022, IPO Q4 2024) a popularisé la reachability analysis : ne signaler que les vulnérabilités dans le code réellement appelé par l'application, pas les dépendances transitives dormantes. Réduit les faux positifs SCA (Software Composition Analysis) de 60-80 %.

Exemple typique : un projet npm dépend de lodash (transitivement via 50+ packages). Une CVE dans lodash ne concerne votre code que si vous appelez réellement lodash.merge() quelque part. Reachability analysis fait ce filtrage automatiquement.

Vendors 2026 avec reachability analysis :

Position tranchée : adopter un SAST/SCA avec reachability analysis en 2026 réduit de 70 % le volume d'alertes sur un projet typique 100k LoC + 500 dépendances. C'est l'évolution la plus impactante depuis 2020 sur le ratio signal/bruit. Sans reachability, les équipes dev passent 30-60 % de leur temps AppSec sur des FP, avec reachability, c'est < 10 %.

5. AI-augmented SAST - GitHub Copilot Autofix et concurrents

GitHub Copilot Autofix lancé en mars 2024 dans GitHub Advanced Security est l'évolution structurante 2024-2026. Capacités :

1. Génération automatique de patch sur les findings CodeQL.
2. Suggestion de fix avec contexte (vulnérabilité + code complet du fichier + pattern utilisé).
3. PR proposal automatique avec le fix testé.

Statistiques publiées par GitHub (2024) :

• ~67 % des findings critiques peuvent recevoir un autofix.
• Temps moyen remédiation passe de 9-12 semaines à 28 jours sur les organisations testeuses.
• Adoption interne : Microsoft engineers fixent 50 % de plus de vulns avec Copilot Autofix.

Concurrents 2026 :

Limites 2026 :

1. Refactoring d'architecture non-supporté : Autofix marche sur fix locaux, pas sur restructuration de modules.
2. Mono-repos géants = qualité moindre (contexte trop large pour le LLM).
3. Coût LLM significatif sur grosse échelle (50+ devs).
4. Toujours valider la suggestion : l'AI peut introduire de nouvelles vulns ou casser des tests.

6. Intégration SAST en CI/CD - shift-left

Pipeline DevSecOps mature 2026 avec SAST shift-left :

# .github/workflows/sast.yml
name: SAST + Reachability + Autofix
on:
  pull_request:
  push:
    branches: [main, develop]
 
permissions:
  contents: read
  security-events: write
  pull-requests: write
 
jobs:
  sast-semgrep:
    name: Semgrep SAST
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: returntocorp/semgrep-action@v1
        with:
          config: |
            p/security-audit
            p/secrets
            p/owasp-top-ten
            p/r2c-best-practices
        env:
          SEMGREP_APP_TOKEN: ${{ secrets.SEMGREP_APP_TOKEN }}
 
  sast-codeql:
    name: GitHub CodeQL
    runs-on: ubuntu-latest
    strategy:
      matrix:
        language: ['python', 'javascript', 'typescript']
    steps:
      - uses: actions/checkout@v4
      - uses: github/codeql-action/init@v3
        with:
          languages: ${{ matrix.language }}
          queries: security-and-quality, security-extended
      - uses: github/codeql-action/analyze@v3
        with:
          category: "/language:${{ matrix.language }}"
      # Copilot Autofix runs automatically on findings (GHAS)
 
  sca-reachability:
    name: Snyk SCA + Reachability
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: snyk/actions/python@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
        with:
          args: --severity-threshold=high --org=my-org --reachability
 
  iac-checkov:
    name: IaC Checkov
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bridgecrewio/checkov-action@master
        with:
          directory: terraform/
          framework: terraform,kubernetes,dockerfile
          output_format: sarif
          output_file_path: checkov-results.sarif
      - uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: checkov-results.sarif
 
  secrets-scan:
    name: Gitleaks Secrets Scan
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
  gate-decision:
    name: Security Gate Decision
    needs: [sast-semgrep, sast-codeql, sca-reachability, iac-checkov, secrets-scan]
    runs-on: ubuntu-latest
    steps:
      - name: Aggregate results and decide
        run: |
          # Bloquer si :
          # - Semgrep ERROR severity
          # - CodeQL critical/high avec reachability TRUE
          # - SCA critical avec reachability TRUE
          # - Hardcoded secrets détectés
          ./scripts/security-gate.sh

Ce pipeline shift-left combine 5 outils avec gating intelligent : seuls les findings reachable (Endor/Snyk) et critical/high bloquent la PR. Le reste = ticket SLA-bound mais ne bloque pas. C'est la pratique mature 2026, ni gate trop strict (devs en burnout), ni gate trop laxe (FP ignorés massivement).

7. SAST vs DAST vs IAST vs RASP - matrice de décision

Position tranchée 2026 : pour 80 % des organisations, SAST en CI/CD + DAST sur staging avant release = couverture suffisante. IAST justifié pour apps haute valeur et tests profonds (banking, healthcare, defense). RASP justifié uniquement quand : (1) latence acceptable < 5 ms p95, (2) budget permet 200-500 $/server/mois, (3) apps legacy non-modifiables avec exposition forte. Stack idéale 2026 : SAST shift-left + DAST CI nightly + WAF en prod + EDR endpoint + monitoring SIEM/XDR, RASP n'est jamais une couche obligatoire.

8. Erreurs fréquentes SAST et anti-patterns

9. ROI mesurable et tarification 2026

Métriques SAST mature 2026 :

ROI typique d'un programme SAST mature 2026 sur 100 développeurs :

• Investissement : 60-100 k€/an (licences) + 1-2 ETP AppSec.
• Économies : 200-500 k€/an (vulns prévenues × coût pentest + breach risk).
• Prévention breach : 1 incident moyen évité = 1-10 M€ (Verizon DBIR 2024 cost = 4.45 M$ médiane).
• Compliance : conformité PCI-DSS Req 6.4.1, SOC 2 CC8.1, NIS2 article 21 simplifiée.

Position : un programme SAST avec AI autofix + reachability se rentabilise typiquement en 6-12 mois sur une organisation 50+ développeurs.

10. Pour aller plus loin

• CWE - Common Weakness Enumeration, la taxonomie des classes de défaut détectées par SAST.
• WAF - Web Application Firewall, la couche runtime complémentaire au SAST shift-left.
• CVE - Définition, format, processus, vulnérabilités identifiées par SCA + reachability.
• CVSS - Scoring vulnérabilités v3.1 vs v4.0, métrique de sévérité utilisée par SAST findings.
• RBAC - Role-Based Access Control, modèle d'autorisation testé en SAST custom rules.
• Bootcamp DevSecOps, formation 12 semaines couvrant SAST, DAST, secure coding.
• Hub catégorie Glossaire cyber, autres définitions de référence Zeroday.
• Semgrep Registry : https://semgrep.dev/explore.
• GitHub Advanced Security + CodeQL : https://github.com/features/security.
• GitHub Copilot Autofix announcement (mars 2024) : https://github.blog/2024-03-20-found-means-fixed-introducing-code-scanning-autofix-powered-by-github-copilot-and-codeql/.
• Snyk Code documentation : https://docs.snyk.io/scan-with-snyk/snyk-code.
• OWASP SAMM (Software Assurance Maturity Model) : https://owaspsamm.org/.
• OWASP ASVS v4.0.3 : https://owasp.org/www-project-application-security-verification-standard/.

11. Points clés à retenir

• SAST = analyse statique de code source/bytecode sans exécution. Détecte CWE-79 XSS, CWE-89 SQLi, CWE-78 command injection, CWE-502 deserialization, CWE-798 hardcoded secrets, etc.
• Méthodologie cœur : taint analysis (source → sink) sur AST/CFG/DFA/SSA. Pattern matching (Semgrep) ou symbolic execution (CodeQL).
• 5 catégories SAST 2026 : AppSec code, IaC (Terraform/CFN/K8s), Secrets, Container, SBOM. Convergence DevSecOps a élargi le terme.
• Leaders 2026 : Semgrep AppSec Platform, SonarQube/SonarCloud, Snyk Code (ex-DeepCode), GitHub Advanced Security CodeQL (acquisition Semmle 2019), Checkmarx One, Veracode, GitLab Ultimate SAST, Endor Labs (reachability, IPO 2024), Aikido (consolidation 2024), Fortify, Coverity.
• Open-source spécialisés : Bandit (Python), Brakeman (Rails), gosec (Go), ESLint security plugins, govulncheck (Go reachability).
• Reachability analysis (Endor Labs 2022, Snyk 2023, Mend, govulncheck) réduit faux positifs SCA de 60-80 %. Évolution structurante 2024-2026.
• GitHub Copilot Autofix (mars 2024) : ~67 % findings critiques auto-fixables, MTTR passe de 9-12 semaines à 28 jours. Concurrents Snyk DeepCode AI, Aikido, Pixee, Mobb (Snyk fin 2024).
• Tarification 2026 : Semgrep 30-100 $/dev/mois ; Snyk Code 50-200 $ ; SonarCloud 15 $ ; GitHub Advanced Security 49 $/contributor ; Checkmarx 150-400 $ ; Veracode 200-500 $.
• SAST vs DAST vs IAST vs RASP : SAST en CI shift-left + DAST staging pre-release = couverture 80 % des cas. IAST/RASP réservés apps haute valeur.
• Anti-pattern n°1 : tout activer sans tuning → FP > 50 % → dashboards rouges ignorés. Mieux vaut scope restreint avec FP < 10 %.
• Anti-pattern n°2 : pas de reachability analysis en 2026 → 60-80 % du temps perdu sur FP non-exploitables.
• ROI typique : programme SAST mature avec AI autofix + reachability se rentabilise en 6-12 mois sur 50+ développeurs.
• Compliance : SAST mappe directement OWASP ASVS V1-V14, OWASP Top 10 2021, PCI-DSS v4.0 Req 6.4.1, SOC 2 CC8.1, NIS2 article 21, DORA article 9, ISO 27001:2022 A.8.25/A.8.28.