Comment mener une revue de sécurité du code que votre agent de codage IA écrit

Les agents de codage IA sont rapides, et cette rapidité est à double tranchant. Ils généreront volontiers une fonctionnalité opérationnelle en quelques minutes — et tout aussi volontiers monteront une requête SQL par concaténation de chaînes, journaliseront un secret ou sauteront une vérification d'autorisation. Le code tourne, les tests passent, et la vulnérabilité part en production. La revue de sécurité n'est pas optionnelle quand c'est un agent qui tape ; c'est la partie dont vous restez responsable.

Voici un flux de travail concret et indépendant de l'outil pour relire le code généré par IA avant qu'il n'atteigne la production.

Savoir quoi chercher

La plupart des vulnérabilités du monde réel se regroupent en une poignée de schémas. Lorsque vous (ou un outil) relisez la sortie de l'agent, repérez d'abord celles-ci :

• Injection — entrées SQL, shell ou template construites par concaténation de chaînes au lieu de requêtes paramétrées.
• Cross-site scripting (XSS) — entrée utilisateur rendue dans du HTML sans échappement.
• Authentification/autorisation défaillante — points d'accès qui vérifient qui vous êtes mais pas si vous y avez droit ; absence de vérification de propriété sur les enregistrements.
• Traitement non sécurisé des données — secrets dans le code, identifiants dans les logs, données sensibles dans les messages d'erreur.
• Dépendances vulnérables — un paquet ajouté par l'agent comportant des CVE connues.

Celles-ci correspondent étroitement au Top 10 de l'OWASP, et ce sont exactement les catégories que, selon Anthropic, sa revue de sécurité automatisée recherche. Garder cette courte liste en tête rend la revue manuelle bien plus efficace.

Faites relire l'agent par lui-même — dans un contexte neuf

Le même modèle qui a écrit le code peut le relire, mais pas dans la foulée. Un agent qui vient de passer 20 tours à faire fonctionner une fonctionnalité est enclin à la défendre. Démarrez une nouvelle session et confiez-lui une seule tâche : trouver les failles.

Un prompt qui fonctionne bien :

Review the diff on this branch for security vulnerabilities only.
For each finding, give me: the file and line, the vulnerability class
(e.g. SQL injection), a concrete exploit scenario, and the fix.
If you find nothing, say so — do not invent issues.

La clause « concrete exploit scenario » est la partie importante. Elle force le modèle à prouver que le problème est réel plutôt qu'à énumérer de vagues formules toutes faites du type « pensez à valider les entrées ».

Servez-vous des outils intégrés

Si vous utilisez Claude Code, il existe une commande dédiée /security-review qui analyse vos modifications à la recherche de schémas de vulnérabilité courants et, après votre approbation, applique les correctifs directement. Elle est disponible sur les offres payantes Pro et Max ainsi que sur les comptes API à l'usage.

Pour une couverture continue, Anthropic publie également une GitHub Action open source qui s'exécute à chaque pull request et poste des commentaires en ligne exactement sur les lignes qui l'inquiètent. L'intégrer à un dépôt ressemble à peu près à ceci :

# .github/workflows/security.yml
name: Security Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-security-review@main
        with:
          claude-api-key: ${{ secrets.ANTHROPIC_API_KEY }}

Désormais chaque PR — qu'elle soit ouverte par un humain ou un agent — passe un contrôle de sécurité avant que quiconque ne clique sur merge. Cursor, Copilot et d'autres assistants proposent des intégrations de revue comparables ; le principe est le même quel que soit l'outil.

Ne sautez pas les contrôles déterministes

La revue par IA est un puissant complément, pas un remplacement de l'outillage ennuyeux qui ne se fatigue jamais :

• Analyse des dépendances — npm audit, pip-audit ou Dependabot attrapent les paquets à vulnérabilité connue qu'un LLM ne reconnaîtra pas au nom.
• Analyse des secrets — des outils comme gitleaks ou la protection de push de GitHub empêchent une clé divulguée d'atterrir un jour dans l'historique.
• Analyse statique (SAST) — les linters et des outils comme Semgrep appliquent les règles de manière cohérente sur toute la base de code.

Utilisez l'IA pour raisonner sur la logique et le contexte — « un utilisateur authentifié peut-il lire ici les enregistrements d'un autre utilisateur ? » — et utilisez les scanners déterministes pour ce qui est mécanique et détectable par motif. Ils couvrent mutuellement leurs angles morts.

Un exemple concret

Supposons que votre agent génère ce point d'accès :

@app.get("/invoices/{invoice_id}")
def get_invoice(invoice_id: str, user=Depends(current_user)):
    return db.query(f"SELECT * FROM invoices WHERE id = '{invoice_id}'")

Un contrôle de sécurité devrait signaler deux problèmes : la requête est une injection SQL qui ne demande qu'à survenir (invoice_id interpolé), et il n'y a aucune vérification que la facture appartient réellement à user — n'importe quel compte connecté peut lire n'importe quelle facture en devinant les identifiants. Le correctif consiste en une requête paramétrée assortie d'un filtre de propriété :

@app.get("/invoices/{invoice_id}")
def get_invoice(invoice_id: str, user=Depends(current_user)):
    return db.query(
        "SELECT * FROM invoices WHERE id = %s AND owner_id = %s",
        [invoice_id, user.id],
    )

L'injection est le genre de chose qu'un scanner attrape. La vérification d'autorisation manquante est le genre de chose qui nécessite quelqu'un — ou un relecteur IA doté du bon prompt — pour comprendre à quoi le code sert. C'est la répartition à garder à l'esprit.

À retenir

Traitez chaque diff que produit votre agent comme non fiable jusqu'à ce qu'il ait été relu — la même exigence que vous appliqueriez à la première pull request d'un nouveau coéquipier. Combinez une revue par IA en contexte neuf, un contrôle de PR automatisé et des scanners déterministes, et vous obtiendrez l'essentiel de la vitesse du développement assisté par IA sans hériter de ses pires travers.