Cuando el dato lo escribe un desconocido

Hasta aquí las consultas las escribías tú. En una aplicación de verdad, parte de la consulta la escribe quien está del otro lado 🔒

Alguien teclea un nombre en un buscador, y ese nombre entra en tu WHERE. Ahí empieza el capítulo.

Una pregunta antes: ¿qué pasa si lo que teclea esa persona lleva una comilla? Piénsalo un segundo, porque la respuesta es todo lo que hay que entender de esto 💭

La búsqueda normal

SELECT id, nombre FROM clientes WHERE nombre = 'Autoservicio Norte 007';

id  nombre
--  ----------------------
7   Autoservicio Norte 007

Un cliente. Es lo que esperas, y lo que esperas es lo que va a pasar el 99% de las veces 🙂

Pero fíjate en cómo está armada esa consulta si la escribe un programa: hay una parte fija y un trozo que vino de fuera, metido entre comillas.

SELECT id, nombre FROM clientes WHERE nombre = '   AQUÍ VA LO QUE TECLEÓ   ';

Y ahora la misma consulta, con una comilla dentro

Imagina que en vez de un nombre, la persona teclea esto:

' OR '1'='1

Métrelo en el hueco de arriba y lee despacio lo que queda, que es una consulta perfectamente válida:

SELECT COUNT(*) AS filas_devueltas FROM clientes WHERE nombre = '' OR '1'='1';

filas_devueltas
---------------
120

Los 120 clientes 😳

La comilla que tecleó cerró la que tu programa había abierto, y a partir de ahí lo que escribió dejó de ser un dato y pasó a ser consulta. El OR '1'='1' es cierto siempre, así que el WHERE deja pasar todo.

Eso es la inyección SQL entera, y no hace falta saber nada más para hacerla. Por eso importa tanto 🚨

Peor: llevarse una tabla que ni tocabas

SELECT nombre FROM clientes WHERE nombre = ''
UNION SELECT nombre FROM productos LIMIT 3;

nombre
-----------
Producto 01
Producto 02
Producto 03

Esa consulta dice FROM clientes y está devolviendo productos 🤯

El UNION del capítulo 8, que ahí era una herramienta, aquí es la puerta: quien inyecta lo usa para pegar los resultados de otra tabla a los de la tuya. Con paciencia se recorre la base entera, incluida la tabla de usuarios y contraseñas si la hay.

Y lo peor de todo: borrar

Casi todos los conectores dejan mandar varias sentencias separadas por punto y coma. Vamos a montarlo sobre una tabla de mentira, para no romper la de verdad:

CREATE TABLE promos_demo (id INTEGER PRIMARY KEY, texto TEXT);
INSERT INTO promos_demo (texto) VALUES ('2x1 en abarrotes'), ('10% en bebidas'), ('envio gratis');
SELECT COUNT(*) AS promos FROM promos_demo;

promos
------
3

Ahora, quien busca teclea esto:

'; DELETE FROM promos_demo; --

Y la consulta que queda es esta. Léela entera antes de ejecutarla:

SELECT * FROM promos_demo WHERE texto = '';
DELETE FROM promos_demo;
SELECT COUNT(*) AS quedan FROM promos_demo;

quedan
------
0

Cero 🫠

La comilla cerró el dato, el punto y coma abrió una sentencia nueva, y los dos guiones del final comentan lo que sobraba para que no dé error de sintaxis. Tres caracteres y la tabla está vacía.

El arreglo, que es una línea

La solución no es revisar lo que teclea la gente ni prohibir las comillas. Alguien se puede apellidar D'Onofrio y tiene derecho a buscarse 🙂

La solución es no pegar el texto: se manda la consulta con un hueco marcado y el dato aparte. Así la base sabe cuál es la consulta antes de ver el dato, y ese dato ya no puede convertirse en instrucciones.

import sqlite3

con = sqlite3.connect(':memory:')
con.execute('CREATE TABLE clientes (id INTEGER, nombre TEXT)')
con.executemany('INSERT INTO clientes VALUES (?, ?)',
                [(1, 'Bodega San Martin'), (2, 'Minimarket El Sol'), (3, 'Mayorista Peru')])

def pegando(nombre):
    sql = f"SELECT nombre FROM clientes WHERE nombre = '{nombre}'"
    return sql, con.execute(sql).fetchall()

def parametrizada(nombre):
    return con.execute('SELECT nombre FROM clientes WHERE nombre = ?', (nombre,)).fetchall()

ATAQUE = "' OR '1'='1"
sql, filas = pegando(ATAQUE)
print('la consulta que se arma:', sql)
print('devuelve             :', len(filas), 'de 3 clientes')
print('parametrizada devuelve:', len(parametrizada(ATAQUE)))

la consulta que se arma: SELECT nombre FROM clientes WHERE nombre = '' OR '1'='1'
devuelve             : 3 de 3 clientes
parametrizada devuelve: 0

La diferencia entre las dos funciones son las comillas 🎯

La de arriba las pone ella con una f-string. La de abajo escribe un ? y le pasa el dato en una tupla aparte, así que el motor lo trata como texto pase lo que pase. Con el mismo ataque devuelve 0, que es lo correcto: ningún cliente se llama así.

Y no, no es más lento. Al contrario: muchos motores guardan el plan de la consulta con su hueco y lo reutilizan, que es justo lo que el capítulo 14 quiere que pase.

El error que sale sin que nadie ataque

Y antes de los ejercicios, la versión inocente del mismo fallo. Un cliente que se apellida así:

SELECT nombre FROM clientes WHERE nombre = 'D'Onofrio';

OperationalError: near "Onofrio": syntax error

Ni ataque ni nada: un apellido normal. La comilla del apellido cierra la del programa y lo que sigue deja de tener sentido.

Esto es lo que más veces vas a ver en la práctica, y es la misma grieta por la que entra lo demás. Si tu sistema se rompe con un apellido, el agujero ya está abierto: solo falta que alguien escriba algo peor que un apellido 🚩

Lo que NO sirve

Lo único que sirve es el hueco. Todo lo demás son parches encima de la grieta 🩹

# la ciudad viene de un desplegable y va parametrizada, correcto
sql = "SELECT ciudad, SUM(monto) AS total FROM pedidos p "
sql += "JOIN clientes c ON c.id = p.id_cliente WHERE c.ciudad = ? "
sql += "GROUP BY ciudad ORDER BY " + columna + " " + sentido

cur.execute(sql, (ciudad,))

Ejercicios

Siete sobre tienda.db. El 4 es el que más enseña 💛

SELECT COUNT(*) AS normal FROM clientes WHERE nombre = 'Mayorista Peru 019';
SELECT COUNT(*) AS inyectada FROM clientes WHERE nombre = '' OR 1=1 --';

SELECT nombre FROM clientes WHERE nombre = ''
UNION SELECT name FROM sqlite_master WHERE type = 'table';

import sqlite3
con = sqlite3.connect(':memory:')
con.execute('CREATE TABLE clientes (nombre TEXT)')
con.execute("INSERT INTO clientes VALUES (\"D'Onofrio\")")
print(con.execute('SELECT nombre FROM clientes WHERE nombre = ?', ("D'Onofrio",)).fetchall())

SELECT * FROM usuarios WHERE correo = '{correo}' AND clave = '{clave}'

CREATE TABLE promos_demo2 (texto TEXT);
INSERT INTO promos_demo2 VALUES ('una'), ('dos');
BEGIN;
DELETE FROM promos_demo2;
ROLLBACK;
SELECT COUNT(*) AS quedan FROM promos_demo2;

Lo que te llevas

• 🔓 Toda inyección sale de lo mismo: pegar texto de fuera dentro de la consulta.
• 💥 Una comilla convirtió una búsqueda de un cliente en las 120 filas, y un UNION se llevó nombres de otra tabla.
• 🔒 Se arregla con el hueco: ? o %s según el motor, y el dato en el segundo argumento.
• 📋 El hueco vale para datos. Nombres de columna y sentidos de orden se validan contra una lista tuya.
• 🩹 Prohibir comillas, buscar palabras raras y confiar en que la red es interna no sirven.
• 🛡️ Y si además el usuario de la aplicación no puede borrar tablas, el daño es mucho menor.

Si esto lo vas a escribir desde Python, el conector y las tuplas están en el libro de Python desde cero 🐍

Que tengas lindo día! 🌸