BÊTA Shoulder est en bêta — Les résultats peuvent parfois être incorrects. Vos retours façonnent ce que nous corrigeons ensuite. Donner mon avis
🗃️

SQL Injection

🛡️ 7 règles détectent ceci

Improper Neutralization of Special Elements used in an SQL Command

User input is concatenated directly into SQL queries, allowing attackers to modify the query logic and access or manipulate data. This is one of the oldest and most dangerous vulnerability classes, responsible for some of the largest data breaches in history.

Prévalence
Very Common
OWASP Top 10 since 2010
Impact
Critical
Data breach, auth bypass, RCE
Prévention
Well understood
Parameterized queries
2 Prévention
2 Prévention

Comment corriger cette vulnérabilité

Stratégies de prévention pour SQL Injection basées sur 7 règles de détection Shoulder.

SQL Injection via Database Queries CRITICAL

Use parameterized queries with $1 (PostgreSQL) or ? (MySQL/SQLite) placeholders

+1 -2 go
  func getUser(w http.ResponseWriter, r *http.Request) {
      userID := r.URL.Query().Get("id")
-     query := "SELECT * FROM users WHERE id = " + userID
-     rows, err := db.Query(query)
+     rows, err := db.Query("SELECT * FROM users WHERE id = $1", userID)
      // ...
  }
  
SQL Injection via Database Queries CRITICAL

Use parameterized queries with placeholder syntax

+2 -2 javascript
- const query = `SELECT * FROM users WHERE id = '${req.params.id}'`;
- await db.query(query);
+ const query = 'SELECT * FROM users WHERE id = $1';
+ await db.query(query, [req.params.id]);
  
Prisma Raw Query SQL Injection CRITICAL

Use Prisma.sql tagged template for parameterized raw queries instead of regular template literals

+10 -11 javascript
- import { PrismaClient } from '@prisma/client';
- const prisma = new PrismaClient();
- 
- app.get('/api/users/search', async (req, res) => {
-   const { name } = req.query;
-   const users = await prisma.$queryRaw`
-     SELECT * FROM "User" WHERE name LIKE '%${name}%'
-   `;
-   res.json(users);
- });
- // Attacker sends: name=' OR 1=1 --
+ import { PrismaClient, Prisma } from '@prisma/client';
+ const prisma = new PrismaClient();
+ 
+ app.get('/api/users/search', async (req, res) => {
+   const { name } = req.query;
+   const users = await prisma.$queryRaw(
+     Prisma.sql`SELECT * FROM "User" WHERE name LIKE ${`%${name}%`}`
+   );
+   res.json(users);
+ });
  
TypeORM SQL Injection in Raw Query CRITICAL

Use parameterized queries with positional (?) or named (:param) placeholders instead of string interpolation

+5 -5 javascript
  import { getManager } from 'typeorm';
  
  app.get('/api/users/search', async (req, res) => {
    const { name, role } = req.query;
    const manager = getManager();
    const users = await manager.query(
-     `SELECT * FROM users WHERE name = '${name}' AND role = '${role}'`
-   );
-   res.json(users);
- });
- // Attacker sends: name=' OR '1'='1' --
+     'SELECT * FROM users WHERE name = $1 AND role = $2',
+     [name, role]
+   );
+   res.json(users);
+ });
  
GraphQL Injection / Unsafe Query Construction HIGH

Use parameterized GraphQL queries with variables instead of string formatting

+3 -3 python
  from flask import request
  import graphene
  
  @app.route('/graphql', methods=['POST'])
  def graphql_endpoint():
-     user_id = request.json.get('id')
-     query = f'{{ user(id: "{user_id}") {{ name email }} }}'
-     result = schema.execute(query)
+     query = request.json.get('query')
+     variables = request.json.get('variables', {})
+     result = schema.execute(query, variables=variables)
      return jsonify(result.data)
  
3 Détection
3 Détection

Trouvez les vulnérabilités dans votre code

Utilisez Shoulder pour scanner votre code à la recherche de patterns SQL Injection. 7 règles.

terminal
# Scan with Shoulder CLI
npx @shoulderdev/cli trust --cwe=89

# Or scan entire project
npx @shoulderdev/cli trust .

Règles de Détection (7)

4 Signes d'Alerte
4 Signes d'Alerte

Ce qu'il faut surveiller lors des revues de code

Ces patterns indiquent des vulnérabilités potentielles SQL Injection. Recherchez-les lors des revues de code et des audits de sécurité.

🟠
unsafe GraphQL query construction with user input, missing query depth limiting, or disabled introsp python-graphql-injection
🔴
user input flowing to SQL queries without parameterization go-sql-injection
🔴
user input flowing into SQL queries without parameterization javascript-sql-injection
🔴
Raw SQL query uses untrusted input without proper parameterization. Use Prisma.sql`` template tag for safe parameter bin prisma-raw-query-injection
🔴
untrusted user input flowing into SQL database queries without proper parameterization python-sql-injection
🔴
Raw SQL query method uses untrusted input without parameterization. Use parameterized queries with ? or $1 placeholders. typeorm-sql-injection-raw-query
🔴
QueryBuilder clause uses string concatenation with untrusted input. Use parameter binding with :name or ? placeholders. typeorm-unsafe-query-builder
5 Audit de code
5 Audit de code

Motifs de revue manuelle

Lors de la revue manuelle du code, cherchez ces motifs dangereux.

Signaux d'alerte à rechercher
query = + concaténation de chaînes
execute(f"... or execute("..." +
raw_query, rawQuery, executeRaw
${ or #{ à l'intérieur de chaînes SQL
6 Analyse experte
6 Analyse experte

Comment pensent les experts en sécurité

Le modèle mental qu'utilisent les professionnels de la sécurité lors de la revue de cette vulnérabilité.

1

Cartographier les points d'entrée

Paramètres d'URL, corps POST, en-têtes, cookies, téléversements de fichiers.

2

Tracez le flux de données

Suivez l'entrée à travers le code. Est-elle assainie ?

3

Identifiez les puits

Where queries are executed: execute(), query()

4

Vérifier les frontières de confiance

Surveillez les données stockées utilisées dans les requêtes.

🔍

Scannez votre base de code pour SQL Injection

Shoulder CLI trouve les motifs vulnérables dans toute votre base de code.