Comment corriger les requêtes SQL non sécurisées écrites par l'IA

Les agents IA construisent des requêtes SQL avec interpolation de chaînes au lieu d'instructions paramétrées, introduisant des vulnérabilités d'injection SQL dans le code de base de données en production.

L’agent utilise des template literals pour construire des requêtes SQL, créant des vecteurs d’injection SQL classiques qui semblent fonctionner correctement lors des tests mais sont exploitables en production.

Le symptôme

Les valeurs contrôlées par l’utilisateur sont interpolées directement dans une chaîne SQL.

// WRONG — SQL injection vulnerability
async function getUserByEmail(email: string) {
  const result = await db.query(
    `SELECT * FROM users WHERE email = '${email}'`
    //                                  ^^^^^^^ attacker-controlled
  );
  return result.rows[0];
}

// Attacker input: ' OR '1'='1
// Resulting query: SELECT * FROM users WHERE email = '' OR '1'='1'
// Returns every row in the table.

Pourquoi cela se produit

Les template literals sont l’outil de construction de chaînes le plus naturel en JavaScript, et de nombreux exemples de tutoriels sur lesquels le modèle a été entraîné les utilisent pour SQL sans paramétrage. L’agent ne modélise pas non plus les entrées adverses — il imagine des données bien formées passant à travers.

Comment le repérer

Les chaînes SQL qui contiennent des interpolations ${...}.
Les fonctions de requête qui acceptent une entrée utilisateur et la passent à un helper de requête brute sans un tableau de paramètres séparé.
db.query(sql) appelé avec un seul argument au lieu de db.query(sql, [params]).
Les motifs LIKE '%${term}%'.

Comment le corriger

Utilisez toujours des requêtes paramétrées. Le pilote de base de données gère l’échappement ; votre code ne touche jamais aux guillemets.

// CORRECT — parameterized query (node-postgres / pg)
async function getUserByEmail(email: string) {
  const result = await db.query(
    "SELECT id, name, email FROM users WHERE email = $1",
    [email]  // second argument: params array
  );
  return result.rows[0] ?? null;
}

// CORRECT — with Postgres.js (template tag)
async function searchUsers(term: string) {
  return sql`SELECT id, name FROM users WHERE name ILIKE ${"%" + term + "%"}`;
  // postgres.js automatically parameterizes template expressions
}

[ ] No ${...} inside raw SQL strings — use $1/$2 placeholders instead
[ ] Every db.query() call passes user input via the params array, not the SQL string
[ ] Use an ORM (Prisma, Drizzle) or query builder for complex queries
[ ] LIKE wildcards are appended in the param value, not concatenated into the SQL
[ ] Run sqlfluff or a SQL linter in CI to catch interpolated strings

Prompt de correction

This SQL query uses string interpolation with user-supplied values, which is a
SQL injection vulnerability. Rewrite every raw query to use parameterized
statements ($1, $2 placeholders for pg, or the tagged template literal form for
postgres.js). Never interpolate variables directly into SQL strings. If the
query is complex, migrate it to Prisma or Drizzle ORM instead.

Test

# Detect template literal interpolation inside SQL-looking strings
grep -rn 'query(`\|sql`\|execute(`' --include="*.ts" --include="*.tsx" . \
  | grep '\${' \
  | grep -v "node_modules" \
  && echo "FAIL: interpolated SQL found" || echo "OK"