PHP PDO y SQLite: inyección SQL, explotada y corregida
Un payload real que devuelve todas las filas y su corrección con prepared statements. Fetch modes, IN, LIKE y 10,000 inserts medidos en PHP 8.5.
Serie: curso de PHP 4/6 (intermedio). Esta clase es para quien ya escribe clases en PHP y ahora necesita una base de datos: el freelancer que mantiene el sistema de reservas de un cliente, quien entra a una startup y encuentra consultas armadas con el operador ., o el estudiante al que el profesor le pidió "que el login no se pueda saltar". Al terminar vas a poder abrir una base de datos con PDO, consultarla con prepared statements, mostrarle a un compañero una inyección SQL que funciona sobre su propio código y corregirla.
Si escribes o revisas código PHP que habla con una base de datos, sobre todo código que concatena SQL, esto te sirve directamente. Usamos SQLite, que viene incluido con PHP, así que no necesitas ningún servidor: cada ejemplo se ejecutó en PHP 8.5.6 CLI con SQLite 3.53.4 en una Mac con Apple Silicon (M1 Pro). La inyección es real: el payload de abajo devolvió todas las filas de una tabla que un chequeo de login debía proteger.
Si quieres una historia de producción (90 correcciones de inyección y de salida en un backend PHP de diez años, con la respuesta demostrada byte a byte idéntica), lee nuestra auditoría de SQLi/XSS en PHP heredado. Esta clase es la base que hay debajo. Todas las tablas de aquí son genéricas: users y posts.
Conectarse con PDO y ERRMODE_EXCEPTION
<?php
declare(strict_types=1);
$file = __DIR__ . '/app.sqlite';
$pdo = new PDO('sqlite:' . $file, options: [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$pdo->exec(<<<SQL
CREATE TABLE users (
id INTEGER PRIMARY KEY,
email TEXT NOT NULL UNIQUE,
name TEXT NOT NULL,
role TEXT NOT NULL DEFAULT 'member'
);
CREATE TABLE posts (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users(id),
title TEXT NOT NULL,
body TEXT NOT NULL
);
SQL);
$ins = $pdo->prepare('INSERT INTO users (email, name, role) VALUES (:email, :name, :role)');
foreach ([
['alice@example.com', 'Alice', 'admin'],
['bob@example.com', 'Bob', 'member'],
['carol@example.com', 'Carol', 'member'],
] as [$email, $name, $role]) {
$ins->execute(['email' => $email, 'name' => $name, 'role' => $role]);
}
$p = $pdo->prepare('INSERT INTO posts (user_id, title, body) VALUES (?, ?, ?)');
$p->execute([1, '100% sure', 'Discount 50% off_today']);
$p->execute([1, 'Hello', 'first post']);
$p->execute([2, 'under_score', 'a_b']);
$p->execute([3, 'Points', 'you have 500 points']);
echo "users: ", $pdo->query('SELECT COUNT(*) FROM users')->fetchColumn(), PHP_EOL; // users: 3
ERRMODE_EXCEPTION es el valor por defecto desde PHP 8.0 (confirmamos que getAttribute(PDO::ATTR_ERRMODE) lo devuelve en 8.5.6), pero igual configúralo de forma explícita: el código se copia a servidores viejos, y el valor por defecto anterior era silencioso. Así se ve el modo silencioso:
ERRMODE_SILENT: $pdo->query('SELECT * FROM nope') returns bool(false)
errorInfo() = [HY000, 1, no such table: nope]
then: Fatal error: Uncaught Error: Call to a member function fetchAll() on false
La causa real (no such table) está en errorInfo(), y el error que ves de verdad aparece una línea más abajo y habla de false. Con excepciones, la causa va en el mensaje.
PHP 8.4 además agregó subclases por driver: PDO::connect('sqlite::memory:') devuelve un objeto Pdo\Sqlite. En 8.5 las constantes específicas de cada driver en PDO están deprecadas, y lo vas a ver en cuanto toques la configuración de MySQL:
Deprecated: Constant PDO::MYSQL_ATTR_INIT_COMMAND is deprecated since 8.5, use Pdo\Mysql::ATTR_INIT_COMMAND instead in ~/demo/b8_misc.php on line 4
Inyección SQL sobre una consulta real
Este es el patrón de incontables tutoriales: tomar la entrada y pegarla dentro del SQL.
$input = $argv[1] ?? "nobody@example.com' OR '1'='1"; // pretend: $_GET['email']
// VULNERABLE
$sql = "SELECT id, email, role FROM users WHERE email = '" . $input . "'";
echo "SQL: $sql\n";
$rows = $pdo->query($sql)->fetchAll();
echo "concat -> ", count($rows), " rows\n";
foreach ($rows as $r) echo " ", implode(' | ', $r), "\n";
// FIX
$st = $pdo->prepare('SELECT id, email, role FROM users WHERE email = ?');
$st->execute([$input]);
echo "prepared -> ", count($st->fetchAll()), " rows\n";
SQL: SELECT id, email, role FROM users WHERE email = 'nobody@example.com' OR '1'='1'
concat -> 3 rows
1 | alice@example.com | admin
2 | bob@example.com | member
3 | carol@example.com | member
prepared -> 0 rows
La comilla de la entrada cerró el literal de string, y OR '1'='1' pasó a formar parte de la condición. Una consulta que debía devolver un usuario devolvió los tres, admin incluido. Un payload con UNION va más allá y lee columnas que la consulta nunca seleccionó:
SQL: SELECT id, email, role FROM users WHERE email = 'x' UNION SELECT id, name || ':' || email, role FROM users --'
concat -> 3 rows
1 | Alice:alice@example.com | admin
...
prepared -> 0 rows
Con prepare(), el texto SQL se envía y se parsea antes de que exista el valor. Después el valor se enlaza como dato y se compara como un string entero, así que la comilla es solo un carácter más en un email que nadie tiene.
Dos observaciones más de la misma ejecución:
- Un nombre inocente como
O'Brien@example.comrompió la consulta concatenada:PDOException: SQLSTATE[HY000]: General error: 1 near "Brien": syntax error. Si los usuarios con apóstrofo reciben errores, casi seguro tienes un agujero de inyección. x'; DROP TABLE users; --a través dequery()devolvió 0 filas y la tabla sobrevivió: elquery()de PDO con SQLite ejecuta solo la primera sentencia. No te apoyes en eso. El mismo estilo de payload a través deexec()sí ejecutó ambas sentencias; nuestroUPDATE users SET name = '…'conx' WHERE 1=0; DROP TABLE posts; --borró la tablaposts. Y MySQL con PDO permite varias sentencias por defecto cuando las prepares se emulan.
Error típico: qué pasa en realidad y cómo arreglarlo
Error: "Lo escapé con addslashes, así que es seguro". addslashes no conoce el juego de caracteres de la conexión ni las reglas de comillas de la base de datos. SQLite ni siquiera usa la barra invertida para escapar: la forma correcta de citar O'Brien es 'O''Brien', que es exactamente lo que devolvió $pdo->quote("O'Brien"). Pasamos el payload x' OR 1=1 -- por addslashes:
SELECT id FROM users WHERE email = 'x\' OR 1=1 --'
rows: 3
Para SQLite, 'x\' es un string completo que contiene una barra invertida. La comilla que addslashes "escapó" cerró el literal, y volvieron las tres filas. Solución: placeholders para los valores. quote() existe, pero úsalo solo como último recurso en código que no puedes reestructurar, que es justo la situación de la auditoría enlazada arriba.
Error: enlazar nombres de tablas o columnas. Los placeholders solo contienen valores. ORDER BY ? enlaza una constante, así que las filas no se ordenan por esa columna: ORDER BY ? DESC con 'id' devolvió [1,2,3], sin error. Solución: una lista permitida (allow-list): $col = in_array($_GET['sort'], ['id', 'email'], true) ? $_GET['sort'] : 'id';.
Por qué importan las prepares emuladas en MySQL (descrito, no ejecutado)
Para esta clase no teníamos un servidor MySQL, así que esta sección sale de la documentación de PDO y de nuestro trabajo previo en producción, no de una ejecución aquí. En SQLite, setAttribute(PDO::ATTR_EMULATE_PREPARES, true) simplemente devolvió false: el driver siempre prepara de forma nativa.
PDO_MySQL emula las prepares por defecto. El propio PHP sustituye los valores escapados en el texto SQL y envía al servidor un único string terminado. Consecuencias:
- Juego de caracteres. Escapar solo es seguro si PHP conoce el charset real de la conexión. Pon
charset=utf8mb4en el DSN. EjecutarSET NAMESdespués cambia el charset del servidor sin avisarle a PDO, que es la condición previa de los viejos ataques de escape multibyte. - Tipos. Con emulación, los números suelen volver como strings; con prepares nativas, las columnas INT vuelven como ints de PHP. Eso cambia tu JSON: mira las prepared statements pueden cambiar los tipos de tu JSON (en inglés) para la versión con mysqli.
- Varias sentencias están permitidas por defecto con emulación (mira
Pdo\Mysql::ATTR_MULTI_STATEMENTS). - Los errores llegan más tarde. Un error de sintaxis aparece en
execute(), no enprepare().
Para código MySQL nuevo: charset=utf8mb4 en el DSN, ATTR_EMULATE_PREPARES => false y Pdo\Mysql::ATTR_MULTI_STATEMENTS => false. Vuelve a probar tu salida JSON después del cambio.
Fetch modes
El fetch mode por defecto es FETCH_BOTH, que devuelve cada columna dos veces:
FETCH_BOTH: ["id"=>1, 0=>1, "email"=>"alice@example.com", 1=>"alice@example.com", "role"=>"admin", 2=>"admin"]
Eso es el doble de memoria y claves duplicadas en json_encode. Configura FETCH_ASSOC como valor por defecto y elige un modo especializado cuando encaje:
| Modo | Resultado de ejemplo | Para qué |
|---|---|---|
FETCH_ASSOC |
[id => 1, email => alice@…, role => admin] |
la mayoría de las consultas, JSON |
FETCH_NUM |
[0 => 1, 1 => alice@…, 2 => admin] |
[$a, $b] = $row |
FETCH_COLUMN |
[alice@…, bob@…, carol@…] |
una columna como lista |
FETCH_KEY_PAIR |
[1 => alice@…, 2 => bob@…, 3 => carol@…] |
opciones de un <select>, búsquedas por clave |
FETCH_GROUP | FETCH_COLUMN |
[admin => [alice@…], member => [bob@…, carol@…]] |
agrupar sin bucle |
FETCH_UNIQUE | FETCH_ASSOC |
[1 => [email, role], 2 => …] |
indexar filas por id |
FETCH_CLASS, UserRow::class |
UserRow {id: 1, email: …, role: …} |
objetos tipados (clase 3) |
Con FETCH_CLASS hacia una clase con propiedades tipadas, id llegó como int(1): PDO SQLite devuelve las columnas enteras como ints de PHP. Cuando no hay fila, tanto fetch() como fetchColumn() devuelven false, así que compara con === false. Un valor real de 0 o un string vacío no debe confundirse con "no hay fila".
Listas IN y escape en LIKE
El error del placeholder único:
$ids = [3, 1, 999];
$st = $pdo->prepare('SELECT id FROM users WHERE id IN (?)');
$st->execute([implode(',', $ids)]); // -> []
No devolvió filas ni error, porque la base comparó cada id con el único string '3,1,999'. (MySQL convertiría ese string en 3 y devolvería una fila: otra respuesta incorrecta.) La solución es un placeholder por valor:
function inList(PDO $pdo, string $sqlWithIn, array $values): PDOStatement
{
if ($values === []) {
throw new InvalidArgumentException('empty IN list: return early (IN () is a syntax error in MySQL)');
}
$marks = implode(',', array_fill(0, count($values), '?'));
$st = $pdo->prepare(str_replace('(:in)', "($marks)", $sqlWithIn));
$st->execute(array_values($values));
return $st;
}
$st = inList($pdo, 'SELECT id, email FROM users WHERE id IN (:in) ORDER BY id', $ids); // -> [1, 3]
array_values() importa: después de array_filter() las claves pueden ser [0, 2], y execute([0 => 1, 2 => 3]) sobre IN (?,?) falló con General error: 25 column index out of range. SQLite aceptó un IN () vacío en nuestra prueba y no devolvió filas, pero MySQL lo rechaza, así que maneja [] en PHP.
Las prepared statements frenan la inyección en LIKE, pero % y _ en el texto del usuario siguen siendo comodines:
function likeEscape(string $s, string $esc = '\\'): string
{
return str_replace([$esc, '%', '_'], [$esc . $esc, $esc . '%', $esc . '_'], $s);
}
$safe = $pdo->prepare("SELECT title FROM posts WHERE body LIKE ? ESCAPE '\\'");
$safe->execute(['%' . likeEscape($q) . '%']);
search 50% naive=["100% sure","Points"] escaped=["100% sure"]
search _ naive=["100% sure","Hello","under_score","Points"] escaped=["100% sure","under_score"]
search % naive=["100% sure","Hello","under_score","Points"] escaped=["100% sure"]
Una búsqueda de _ coincidió con todos los posts. En una tabla grande, un usuario que escribe % fuerza un recorrido completo de todas las filas, que es una denegación de servicio barata. Escapa primero el carácter de escape (los arrays de str_replace se aplican de izquierda a derecha).
Mensajes reales de PDOException
Todos de un mismo script contra la base de arriba:
[typo in table] SQLSTATE[HY000]: General error: 1 no such table: user
[typo in column] SQLSTATE[HY000]: General error: 1 no such column: mail
[UNIQUE violation] SQLSTATE[23000]: Integrity constraint violation: 19 UNIQUE constraint failed: users.email
[NOT NULL] SQLSTATE[23000]: Integrity constraint violation: 19 NOT NULL constraint failed: users.name
[too many params] SQLSTATE[HY000]: General error: 25 column index out of range
[missing :name] SQLSTATE[HY000]: General error: 25 column index out of range
[bad file path] SQLSTATE[HY000] [14] unable to open database file
[too few params] no exception
Lo que conviene notar:
getCode()devolvió el string'23000'para la violación de UNIQUE pero el int14para el error de conexión. Usa$e->errorInfo[0] === '23000'(o el código del drivererrorInfo[1] === 19) para detectar "el email ya está registrado", nogetCode() === 23000.- Pasar menos parámetros no lanzó excepción en SQLite. El
?faltante se enlazó comoNULL; lo confirmamos conSELECT ?, ?y un solo valor, que devolvió"1"yNULL. La consulta simplemente no coincidió con nada. MySQL lanzaSQLSTATE[HY093]: Invalid parameter numberen este caso, así que el código probado solo con SQLite puede fallar en producción. - Un parámetro con nombre mal escrito (
uiden lugar de:id) dio el poco útilcolumn index out of range, no "falta un parámetro". Cuando veas ese mensaje, compara las claves de tu array con los placeholders.
Transacciones: 10,000 inserts medidos
Cada INSERT fuera de una transacción es su propia transacción: SQLite escribe un journal y lo vuelca al disco antes de volver. Dentro de una sola transacción, eso ocurre una vez.
$st = $pdo->prepare('INSERT INTO posts (user_id, title) VALUES (?, ?)');
$t = hrtime(true);
if ($mode === 'tx') $pdo->beginTransaction();
for ($i = 0; $i < 10_000; $i++) {
$st->execute([$i % 100, "title $i"]);
}
if ($mode === 'tx') $pdo->commit();
$ms = (hrtime(true) - $t) / 1e6;
Archivo de base de datos nuevo en cada ejecución, PHP 8.5.6 CLI, SQLite 3.53.4 (valores por defecto: journal_mode=delete, synchronous=2/FULL), Mac con Apple Silicon (M1 Pro), SSD interno, tres ejecuciones:
| Modo | Ejecución 1 | Ejecución 2 | Ejecución 3 | Filas/s (mediana) |
|---|---|---|---|---|
| Autocommit (por defecto) | 2601.2 ms | 2604.6 ms | 2568.5 ms | ~3840 |
Autocommit, journal_mode=WAL, synchronous=NORMAL |
79.1 ms | 85.3 ms | 84.6 ms | ~118,000 |
| Una transacción | 4.8 ms | 5.1 ms | 4.9 ms | ~2,000,000 |
Unas 530 veces más rápido con una sola transacción. El modo WAL ayuda mucho cuando no puedes agrupar escrituras (una app web donde cada petición escribe una fila), pero no reemplaza una transacción para trabajo masivo. Una transacción también es una cuestión de corrección, todo o nada:
function transfer(PDO $pdo, callable $work): void
{
$pdo->beginTransaction();
try {
$work($pdo);
$pdo->commit();
} catch (Throwable $e) {
$pdo->rollBack();
throw $e;
}
}
before: 4
rolled back: SQLSTATE[23000]: Integrity constraint violation: 19 NOT NULL constraint failed: posts.title
after: 4
PDOException: There is already an active transaction
PDOException: There is no active transaction
El primer INSERT funcionó, el segundo falló y el rollback eliminó ambos. Las dos últimas líneas muestran que PDO no tiene transacciones anidadas: un segundo beginTransaction() lanza una excepción, y lo mismo hace commit() después de un rollback. Si un helper puede ejecutarse dentro de una transacción exterior, revisa $pdo->inTransaction() o usa SAVEPOINT.
Tabla de decisión
| Situación | Haz esto |
|---|---|
| Cualquier valor de afuera (GET, POST, JSON, archivos, headers) | placeholder ? o :name |
| Nombre de tabla/columna, dirección de orden | allow-list en PHP |
IN (...) con un array |
un ? por valor, array_values, maneja [] |
Búsqueda con LIKE |
placeholder + likeEscape() + ESCAPE '\' |
| Más que un puñado de escrituras | una transacción |
| Una escritura por petición web en SQLite | modo WAL |
| Código MySQL nuevo | charset=utf8mb4, emulación apagada, multi-statements apagado |
| Código heredado que hoy no puedes reestructurar | escapar con el charset correcto y planificar la migración (mira la auditoría) |
Límites honestos y notas de versión
- Ejecutado solo en PHP 8.5.6 CLI con SQLite 3.53.4.
ERRMODE_EXCEPTIONcomo valor por defecto viene de PHP 8.0, las subclases por driver (Pdo\Sqlite,PDO::connect) de 8.4, y la deprecación dePDO::MYSQL_ATTR_*de 8.5 (vimos el mensaje Deprecated). - El comportamiento de MySQL (prepares emuladas,
HY093, errores conIN (), conversión de strings enIN) se describe a partir de la documentación y de trabajo previo en producción, no se ejecutó aquí. - Los tiempos de transacción corresponden a macOS en un SSD interno. SQLite en macOS no usa
F_FULLFSYNCpor defecto, así que aquí el autocommit es más rápido de lo que sería con durabilidad completa. En el almacenamiento en red de un hosting compartido, espera un autocommit todavía más lento.
Ejercicio
Escribe findPosts(PDO $pdo, array $userIds, string $q): array, que devuelva id, title de los posts cuyo autor esté en $userIds y cuyo cuerpo contenga $q de forma literal (es decir, _ significa un guion bajo). Devuelve [] para un $userIds vacío sin tocar la base de datos.
Respuestas
function findPosts(PDO $pdo, array $userIds, string $q): array
{
$userIds = array_values(array_map('intval', $userIds));
if ($userIds === []) {
return [];
}
$marks = implode(',', array_fill(0, count($userIds), '?'));
$like = '%' . str_replace(['\\', '%', '_'], ['\\\\', '\\%', '\\_'], $q) . '%';
$st = $pdo->prepare(
"SELECT id, title FROM posts WHERE user_id IN ($marks) AND body LIKE ? ESCAPE '\\' ORDER BY id"
);
$st->execute([...$userIds, $like]);
return $st->fetchAll(PDO::FETCH_ASSOC);
}
echo json_encode(findPosts($pdo, [1, 2], '_')), PHP_EOL;
echo json_encode(findPosts($pdo, [], '_')), PHP_EOL;
echo json_encode(findPosts($pdo, [2, 3], '50')), PHP_EOL;
[{"id":1,"title":"100% sure"},{"id":3,"title":"under_score"}]
[]
[{"id":4,"title":"Points"}]
Los valores de IN van primero en el array porque sus ? van primero en el SQL. Confundir ese orden es un bug silencioso clásico.
Lo que sigue
- Anterior: curso de PHP 3/6: clases, interfaces y enums
- Siguiente: curso de PHP 5/6: XSS, CSRF y sesiones
- Para practicar el SQL de fondo: SQL desde cero: SELECT, WHERE y ORDER BY y transacciones, aislamiento y bloqueos
Preguntas frecuentes
¿Cuánto más rápidos son los INSERT dentro de una transacción en PHP?
En nuestra prueba, 10,000 INSERT preparados en un archivo SQLite tardaron 2601 ms en modo autocommit y 4.9 ms dentro de una sola transacción, unas 530 veces más rápido (PHP 8.5.6, SQLite 3.53.4, Apple M1 Pro, SSD interno, mediana de 3 ejecuciones).
¿Cómo paso un array a una cláusula IN (...) con PDO?
Genera un ? por cada valor con implode(',', array_fill(0, count($ids), '?')) y pasa array_values($ids) a execute(). Un solo ? enlazado a '3,1,999' se compara como un único string y en SQLite no devolvió ninguna fila. Maneja el array vacío antes de armar el SQL.
¿Las prepared statements protegen las búsquedas con LIKE?
Frenan la inyección, pero % y _ en el texto del usuario siguen funcionando como comodines. Una búsqueda de '_' coincidió con todas las filas hasta que escapamos %, _ y el propio carácter de escape y agregamos ESCAPE '\' a la consulta.