Résumé : cet article transforme l’OWASP Top Ten en actions que les développeurs peuvent appliquer immédiatement : définition courte de chaque risque, exemple minimal vulnérable, test rapide, correction recommandée, et règles à ajouter dans ton pipeline CI/CD (SAST/DAST / contrôle de la chaîne d’approvisionnement). Les points 2025 à connaître : SBOM & provenance des artefacts, signatures (Sigstore/cosign), renforcement des règles Semgrep (sortie 2025), et bonnes pratiques pour le code produit ou suggéré par des assistants IA. (OWASP Foundation, semgrep.dev, CISA)

Pourquoi ce guide ?

L’OWASP Top Ten (édition 2021 reste la référence de base) identifie les risques applicatifs majeurs ; en 2025 on ajoute désormais une couche opérationnelle : contrôle de la chaîne d’approvisionnement (SBOM), signature des artefacts et intégration continue de règles SAST/DAST plus complètes. Ce guide te fournit, pour chaque risque, un exemple pratique (vulnérable + correctif), une commande de test et une règle CI à activer. (OWASP Foundation, semgrep.dev)

Mode d’emploi du guide

Pour chaque risque tu trouveras :

1. Définition courte ; note 2025 si pertinente.
2. Snippet vulnérable minimal (langages courants).
3. Test rapide (curl, commande ou scan).
4. Correctif / bonne pratique (snippet).
5. Automation / CI : Semgrep / Sonar / ZAP / SBOM / signature.

A01 – Contrôles d’accès défaillants

Définition (une phrase)
Un utilisateur authentifié peut réaliser des actions au-delà de ses droits (modifier/consulter des ressources d’autrui). (OWASP)

Snippet vulnérable (Node.js / Express)

// vulnérable : pas de vérification d'autorisation
app.put('/users/:id', auth, async (req, res) => {
  await db.users.update(req.params.id, req.body);
  res.sendStatus(204);
});

Test rapide (curl)
Tenter de modifier l’ID d’un autre utilisateur avec ton token :

curl -X PUT -H "Authorization: Bearer <token-user-A>" \
  -d '{"name":"x"}' http://localhost:3000/users/1234

Si la requête aboutit → problème d’autorisation.

Correctif recommandé

if (req.user.id !== req.params.id && !req.user.roles.includes('admin')) {
  return res.status(403).json({error:'Forbidden'});
}

Conseil : centralise les politiques d’accès (middleware, Policy-as-Code comme OPA) plutôt que dupliquer des checks dans chaque handler.

Automation / CI
Activer une règle Semgrep qui détecte handlers modifiant des ressources identifiées par paramètre sans vérification d’identité/role. Semgrep fournit des règles dédiées OWASP. (Semgrep)

A02 – Mauvaise utilisation de la crypto

Définition
Usage d’algorithmes/paramètres faibles, stockage inapproprié des secrets ou TLS mal configuré. (OWASP)

Exemple vulnérable (JWT long-lived)

const token = jwt.sign({userId}, 'secret123', {expiresIn: '30d'});

Tests rapides

• Vérifier durée de vie des tokens et algorithmes utilisés (RS256/ES256 recommandés).
• Scanner TLS (sslyze/openssl) pour s’assurer TLS1.3 + PFS.

Correctifs & bonnes pratiques

• Hasher mots de passe avec Argon2 / bcrypt ; ne jamais stocker en clair.
• Utiliser TLS 1.2+ (préférer 1.3), HSTS, et vault pour secrets (HashiCorp Vault, cloud secrets).
• Faire rotation des clés et auditer accès. (NIST Computer Security Resource Center)

Automation / CI
Semgrep / Sonar détectent usages d’algos obsolètes (MD5/sha1). Ajouter checks TLS et tests de configuration dans pipeline.

A03 – Injection (SQL, NoSQL, OS, LDAP)

Définition
Concaténation de données utilisateur dans une commande/requête entraînant exécution non désirée. (OWASP)

Exemple vulnérable (PHP)

$id = $_GET['id'];
$res = $db->query("SELECT * FROM users WHERE id = $id");

Test rapide
Lancer un scan OWASP ZAP baseline sur l’appli en staging pour détecter vecteurs d’injection runtime. ZAP propose des scripts Docker pour CI. (ZAP)

Correctif
Utiliser des requêtes paramétrées / prepared statements :

$stmt = $db->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$id]);

Automation / CI
Semgrep + Sonar détectent concaténation dangereuse ; ZAP (DAST) vérifie l’exécution en runtime. (Semgrep, ZAP)

A04 – Conception non sécurisée

Définition
Absence de sécurité au niveau de l’architecture (threat modeling manquant, exigences non définies). (OWASP)

Note 2025
Appliquer threat modeling en amont et exigences SSDF (NIST) dans le SDLC. (NIST Computer Security Resource Center)

Exemple conceptuel / test
Uploader un fichier et vérifier si le système l’exécute — si oui, c’est un défaut de design (upload→exec).

Correctif
Sandboxer l’exécution, valider type/extension/contenu, stocker hors-exécution, principe du moindre privilège.

Automation / CI
Exiger revues d’architecture (ADR) et tests d’intégration qui valident contraintes de sécurité (ex. uploads refusés hors whitelist).

A05 – Mauvaise configuration

Définition
Paramètres par défaut, informations d’erreur, services inutiles exposés, permissions cloud excessives. (OWASP)

Test rapide
Scanner IaC et infra (tfsec, checkov) ; vérifier pages de debug désactivées en prod.

Correctif
Durcir images, désactiver services inutiles, appliquer least-privilege sur cloud IAM.

CI
Ajouter scans IaC (tfsec/checkov) et tests smoke de configuration.

A06 – Composants vulnérables

Définition
Utilisation de dépendances ou conteneurs obsolètes/avec CVE connues. (OWASP)

Test rapide
SCA (Snyk / Dependabot / OSS-scan) ; génération et revue du SBOM. (NIST Publications, cyclonedx.org)

Correctif
Politique de mises à jour, triage CVE, remplacer libs non maintenues.

CI
Job SCA qui bloque build si dependances critiques non corrigées ; générer SBOM CycloneDX/SPDX à chaque build. (cyclonedx.org, GitHub)

A07 – Identification & Authentication Failures

Définition
Mécanismes d’authentification faibles : MFA absent, sessions mal gérées, tokens non révoqués. (ZAP)

Correctifs
Activer MFA, tokens short-lived + refresh token rotation, gestion de revocation, stockage sécurisé des secrets.

CI
Tests d’intégration pour flows d’auth (reset, expiry, rotation) ; Semgrep pour secrets codés en dur.

A08 – Intégrité

Définition
Absence de vérification d’intégrité des artefacts et dépendances (attaque chaîne d’approvisionnement). (Semgrep, Sigstore)

2025 pratiques fortes

• Générer SBOMs (CycloneDX / SPDX) par build. (cyclonedx.org, GitHub)
• Signer artefacts / images (cosign / Sigstore) et vérifier Rekor lors du déploiement. (Sigstore, GitHub)

CI
Étape de vérification de signature + SBOM avant release ; refuser release si signature/SBOM manquants. (CISA, Sigstore)

A09 – Security Logging & Monitoring Failures

Définition
Insuffisance de logs et d’alerting empêchant la détection et l’investigation d’incidents. (NIST Computer Security Resource Center)

Bonnes pratiques
Logs structurés, centralisation (ELK / OpenSearch / SIEM), alerting et playbooks d’incident ; ne pas logguer secrets.

CI
Tests d’acceptation qui vérifient que les événements audités sont bien enregistrés et que l’alerte est déclenchée.

A10 – Server-Side Request Forgery (SSRF)

Définition
Le serveur effectue des requêtes arbitraires (souvent vers des métadonnées cloud) à partir d’une URL fournie par l’utilisateur. (CISA, ZAP)

Test rapide
Fournir http://169.254.169.254/latest/meta-data/ (AWS IMDS) en paramètre et vérifier si la réponse contient des données sensibles.

Correctif
Whitelisting strict, blocage des IP privées/loopback, résolveur qui vérifie IP finale, egress control.

Intégration CI/CD – recette pratique (exemple GitHub Actions)

Voici un squelette prêt à adapter : Semgrep (pré-merge), build (SBOM), signature (cosign), ZAP baseline (staging).

name: security-pipeline
on: [pull_request]
jobs:
  semgrep:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Semgrep (OWASP)
        run: semgrep --config p/owasp-top-ten ./src

  build_and_sbom:
    runs-on: ubuntu-latest
    needs: semgrep
    steps:
      - uses: actions/checkout@v4
      - name: Build image
        run: ./scripts/build-image.sh
      - name: Generate SBOM (CycloneDX)
        run: cyclonedx-bom -o sbom.json ./build
      - name: Sign image with cosign
        env:
          COSIGN_PASSWORD: ${{ secrets.COSIGN_PASSWORD }}
        run: |
          cosign sign --key ${COSIGN_KEY} myrepo/myimage:${{ github.sha }}

  zap:
    runs-on: ubuntu-latest
    needs: build_and_sbom
    steps:
      - name: Start staging
        run: ./scripts/start-staging.sh
      - name: ZAP baseline scan
        run: docker run --rm -v ${{ github.workspace }}/zap-reports:/zap/reports owasp/zap2docker-stable zap-baseline.py -t http://staging.local -r zap_report.html

Références pratiques : Semgrep (rules OWASP), ZAP Docker baseline scan, CycloneDX spec et cosign (Sigstore). (Semgrep, ZAP, cyclonedx.org, Sigstore)

Ressources utiles

• OWASP Top Ten (page projet, Top 10:2021 et statut 2025). (OWASP)
• OWASP Cheat Sheet Series (guides pratiques). (OWASP Cheat Sheet Series)
• Semgrep — pack OWASP / release notes (règles JS/TS 2025). (Semgrep)
• OWASP ZAP — Docker & baseline scan docs (automation). (ZAP)
• NIST SP 800-218 (SSDF) — pour intégration sécurité dans le SDLC. (NIST Computer Security Resource Center, NIST Publications)
• CISA — 2025 Minimum Elements for a Software Bill of Materials (SBOM). (CISA)
• Sigstore / cosign (signature & transparency). (Sigstore, GitHub)
• CycloneDX (SBOM specification). (cyclonedx.org, GitHub)

Conclusion – actions prioritaires (prête à exécuter)

1. Active Semgrep (pack OWASP) en pré-merge et refuse PRs avec findings critiques. (Semgrep)
2. Génère une SBOM à chaque build (CycloneDX/SPDX) et signe tes artefacts (cosign). (cyclonedx.org, Sigstore)
3. Ajoute un job ZAP baseline en staging pour détecter problèmes runtime. (ZAP)
4. Formalise threat modeling et intègre NIST SSDF dans ton SDLC. (NIST Computer Security Resource Center)