BETA Shoulder está en beta — Los hallazgos a veces pueden ser incorrectos. Tu feedback da forma a lo que arreglamos a continuación. Compartir comentarios
🗃️

SQL Injection

🛡️ 7 reglas detectan esto

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.

Prevalencia
Very Common
OWASP Top 10 since 2010
Impacto
Critical
Data breach, auth bypass, RCE
Prevención
Well understood
Parameterized queries
2 Prevención
2 Prevención

Cómo corregir esta vulnerabilidad

Estrategias de prevención para SQL Injection basadas en 7 reglas de detección de 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 Detección
3 Detección

Encuentra vulnerabilidades en tu código

Usa Shoulder para escanear tu código en busca de patrones SQL Injection. 7 reglas.

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

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

Reglas de Detección (7)

4 Señales de Alerta
4 Señales de Alerta

Qué buscar en las revisiones de código

Estos patrones indican vulnerabilidades potenciales de SQL Injection. Búscalos durante las revisiones de código y auditorías de seguridad.

🟠
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 Auditoría de código
5 Auditoría de código

Patrones de revisión manual

Al revisar código manualmente, busca estos patrones peligrosos.

Señales de alerta a buscar
query = + concatenación de cadenas
execute(f"... or execute("..." +
raw_query, rawQuery, executeRaw
${ or #{ dentro de cadenas SQL
6 Análisis experto
6 Análisis experto

Cómo piensan los expertos en seguridad

El modelo mental que usan los profesionales de seguridad al revisar esta vulnerabilidad.

1

Mapea los puntos de entrada

Parámetros de URL, cuerpos POST, encabezados, cookies, subidas de archivos.

2

Rastrea el flujo de datos

Sigue la entrada a través del código. ¿Se sanea?

3

Identifica los sumideros

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

4

Verifica los límites de confianza

Vigila los datos almacenados que se usan en consultas.

🔍

Escanea tu base de código para SQL Injection

Shoulder CLI encuentra patrones vulnerables en toda tu base de código.