L'angle mort de sécurité dans le code généré par l'IA

Du code rapide n'est pas du code sécuritaire

Les outils de coding IA vous permettent de construire des fonctionnalités en minutes qui prenaient des heures auparavant. Cette vitesse est réelle et précieuse. Mais elle vient avec un compromis que la plupart des équipes découvrent trop tard : l'IA ne pense pas à la sécurité comme un ingénieur senior le fait.

Les modèles de langage génèrent du code basé sur des patterns de données d'entraînement. Beaucoup de ces données contiennent des patterns non sécuritaires. Des réponses Stack Overflow avec des vulnérabilités d'injection SQL. Du code de tutoriel qui ignore la validation des entrées. Des projets open source qui codent en dur des clés API. L'IA a appris de tout ça, et elle reproduira volontiers ces patterns dans votre codebase si vous ne les attrapez pas.

Ce n'est pas un risque théorique. Ça se passe en ce moment dans des codebases en production chez des entreprises qui ont avancé vite et fait confiance au résultat.

Où le code généré par l'IA dérape

Injection SQL et construction de requêtes

L'IA adore l'interpolation de chaînes. Demandez-lui d'écrire une requête de base de données et il y a une chance significative qu'elle concatène l'input utilisateur directement dans la chaîne SQL au lieu d'utiliser des requêtes paramétrées. Ça fonctionne en développement. Ça passe les tests de base. Et ça ouvre une ligne directe de votre barre d'URL à votre base de données.

// Ce que l'IA pourrait écrire
const query = `SELECT * FROM users WHERE email = '${email}'`;

// Ce qu'elle devrait écrire
const query = `SELECT * FROM users WHERE email = $1`;
const result = await db.query(query, [email]);

Secrets exposés et identifiants codés en dur

Les modèles IA génèrent parfois du code avec des clés API placeholder, des chaînes de connexion de base de données, ou des secrets JWT qui ont l'air assez réalistes pour passer inaperçus lors de la revue. Pire, quand vous demandez à l'IA d'aider avec la configuration d'environnement, elle peut écrire des valeurs .env directement dans des fichiers source ou de la configuration qui sera commitée dans git.

Validation d'entrées manquante

L'IA construit le chemin normal en premier et s'arrête là. L'input utilisateur traverse le système sans sanitisation, vérification de longueur, ou validation de type. Les données de formulaire atteignent la base de données exactement telles que soumises. Les uploads de fichiers sont acceptés sans vérifier le type, la taille, ou le contenu. Les corps de requêtes sont acceptés sans validation de schéma.

Cross-Site Scripting (XSS)

En générant du code frontend, l'IA rend fréquemment du contenu fourni par l'utilisateur sans l'échapper. Le JSX de React protège contre le XSS de base par défaut, mais dès que vous utilisez dangerouslySetInnerHTML, rendez du markdown en HTML, ou construisez des templates en dehors de React, l'IA ne se souviendra pas toujours de sanitiser la sortie.

Lacunes d'authentification et d'autorisation

Demandez à l'IA d'ajouter un endpoint API et elle construira le handler, la route et la réponse. Ce qu'elle oublie souvent, c'est le middleware. La vérification d'auth. La vérification des rôles. L'endpoint fonctionne parfaitement pour les admins authentifiés et les attaquants non authentifiés.

CORS trop permissif

L'IA va au plus simple. Quand CORS bloque une requête en développement, l'instinct du modèle est de mettre Access-Control-Allow-Origin: * et de passer à autre chose. Ce correctif arrive en production et maintenant n'importe quel domaine peut faire des requêtes authentifiées à votre API.

Comment auditer le code généré par l'IA

Chaque morceau de code généré par l'IA devrait passer par le même processus de revue que le code écrit par un humain. Mais parce que l'IA produit du code rapidement et en volume, les équipes ont besoin d'une approche systématique pour suivre le rythme.

Exécuter l'analyse statique sur chaque changement

Des outils comme Semgrep, les plugins de sécurité ESLint et Snyk peuvent détecter automatiquement les vulnérabilités courantes. Configurez-les dans votre pipeline CI pour que rien n'atteigne la production sans un scan. L'IA ne sera pas vexée par un rejet automatisé.

Vérifier chaque requête de base de données

Cherchez la concaténation de chaînes ou les template literals dans tout fichier qui touche la base de données. Chaque requête qui inclut de l'input utilisateur devrait utiliser des requêtes paramétrées ou un query builder qui gère l'échappement. Sans exception.

Auditer l'authentification sur chaque endpoint

Pour chaque nouvelle route ou endpoint API que l'IA génère, vérifiez que le middleware d'authentification est appliqué. Vérifiez que la logique d'autorisation correspond au niveau d'accès prévu. Un endpoint sans auth est un endpoint que n'importe qui peut appeler.

Valider toutes les entrées aux frontières du système

Input utilisateur des formulaires, paramètres d'URL, corps de requêtes, uploads de fichiers. Tout ça nécessite une validation avant d'entrer dans votre système. Définissez des schémas avec des outils comme Zod, Joi ou le validator de Go et rejetez tout ce qui ne se conforme pas. L'IA générera du code plus propre quand ces schémas existent déjà dans votre codebase.

Réviser les secrets et variables d'environnement

Cherchez des chaînes codées en dur qui ressemblent à des clés, tokens, mots de passe ou chaînes de connexion. Vérifiez que les fichiers .env sont dans .gitignore. Vérifiez que les secrets sont chargés depuis des variables d'environnement, pas importés depuis des fichiers source.

Tester les chemins malheureux

L'IA écrit du code qui fonctionne quand tout va bien. Vos tests devraient vérifier ce qui se passe quand les choses tournent mal. Input malformé. Champs manquants. Payloads surdimensionnés. Tokens expirés. Requêtes concurrentes. Ce sont les chemins où les vulnérabilités se cachent.

PII et vie privée

La sécurité ne concerne pas seulement la prévention des attaques. C'est aussi protéger les personnes dont les données traversent vos systèmes.

Le code généré par l'IA est particulièrement négligent avec les informations personnellement identifiables. Il log les corps de requêtes qui contiennent des adresses email. Il stocke les numéros de carte de crédit complets quand il devrait stocker seulement les quatre derniers chiffres. Il envoie des données utilisateur à des analytics tiers sans vérifier le consentement. Il crée des schémas de base de données qui stockent plus que nécessaire parce que l'IA garde tout par défaut.

La minimisation des données, le chiffrement au repos, les contrôles d'accès et les politiques de rétention ne sont pas des fonctionnalités que l'IA suggérera d'elle-même. Ils nécessitent des décisions d'architecture délibérées prises par des ingénieurs qui comprennent à la fois les exigences techniques et les obligations légales.

Si votre produit traite des données utilisateur au Canada, dans l'UE, ou de plus en plus n'importe où ailleurs, la vie privée n'est pas optionnelle et l'IA ne connaît pas les réglementations qui s'appliquent à votre situation spécifique.

Construire une culture de sécurité autour des outils IA

La réponse n'est pas d'arrêter d'utiliser les outils de coding IA. La réponse est de construire des garde-fous qui correspondent à la vitesse de génération.

Établissez une checklist de sécurité que chaque PR générée par l'IA doit passer. Automatisez ce que vous pouvez avec l'analyse statique et les vérifications CI. Faites de la revue de sécurité une partie non négociable du processus de développement, pas quelque chose qui arrive après le sprint.

Formez votre équipe à traiter le code de l'IA comme elle traiterait du code d'un développeur junior très rapide et très confiant. Ça fonctionne probablement. Il y a probablement quelques angles morts. Révisez en conséquence.

Comment Deadly aborde la sécurité

Chez Deadly, la sécurité et la vie privée ne sont pas des pensées après coup. Elles font partie de chaque décision d'architecture dès le premier jour. Quand nous construisons des solutions IA pour nos clients, nous traitons les données personnelles avec le sérieux qu'elles méritent. Nous appliquons la validation des entrées à chaque frontière. Nous exécutons l'analyse statique sur chaque changement. Nous concevons des flux de données qui minimisent l'exposition et respectent les réglementations de vie privée.

Nous avons vu ce qui arrive quand des équipes livrent du code généré par l'IA sans revue appropriée. Corriger ces vulnérabilités après coup coûte bien plus que de construire de manière sécuritaire dès le départ. Chaque projet que nous livrons est construit avec l'hypothèse qu'il sera audité, parce que c'est le standard auquel nous nous tenons.