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
Diagrama de flujo. La entrada nobody@example.com' OR '1'='1 va o bien a una concatenación de strings o bien a prepare más execute. La concatenación produce WHERE email = 'nobody@example.com' OR '1'='1', que la base de datos parsea como una condición siempre verdadera, así que vuelven las 3 filas. Con prepare, el texto SQL queda fijo como WHERE email = ? y la entrada se envía aparte como un único valor, así que ningún email coincide y vuelven 0 filas.
La misma entrada toma dos caminos. Concatenada, pasa a ser parte del texto SQL. Enlazada, sigue siendo un valor y se compara como un string completo.

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.com rompió 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 de query() devolvió 0 filas y la tabla sobrevivió: el query() de PDO con SQLite ejecuta solo la primera sentencia. No te apoyes en eso. El mismo estilo de payload a través de exec() sí ejecutó ambas sentencias; nuestro UPDATE users SET name = '…' con x' WHERE 1=0; DROP TABLE posts; -- borró la tabla posts. 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:

  1. Juego de caracteres. Escapar solo es seguro si PHP conoce el charset real de la conexión. Pon charset=utf8mb4 en el DSN. Ejecutar SET NAMES después cambia el charset del servidor sin avisarle a PDO, que es la condición previa de los viejos ataques de escape multibyte.
  2. 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.
  3. Varias sentencias están permitidas por defecto con emulación (mira Pdo\Mysql::ATTR_MULTI_STATEMENTS).
  4. Los errores llegan más tarde. Un error de sintaxis aparece en execute(), no en prepare().

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 int 14 para el error de conexión. Usa $e->errorInfo[0] === '23000' (o el código del driver errorInfo[1] === 19) para detectar "el email ya está registrado", no getCode() === 23000.
  • Pasar menos parámetros no lanzó excepción en SQLite. El ? faltante se enlazó como NULL; lo confirmamos con SELECT ?, ? y un solo valor, que devolvió "1" y NULL. La consulta simplemente no coincidió con nada. MySQL lanza SQLSTATE[HY093]: Invalid parameter number en este caso, así que el código probado solo con SQLite puede fallar en producción.
  • Un parámetro con nombre mal escrito (uid en lugar de :id) dio el poco útil column 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
Gráfico de barras. Sin transacción, cada INSERT hizo su propio commit y 10.000 filas tardaron 2601 ms. Con modo WAL y synchronous NORMAL, pero todavía sin transacción, tardaron 84,6 ms. Dentro de una sola transacción con la configuración por defecto, tardaron 4,9 ms, unas 530 veces más rápido que el autocommit.
10.000 INSERT preparados en un archivo SQLite con PHP 8.5.6 CLI (SQLite 3.53.4), Mac con Apple Silicon (M1 Pro), SSD interno. Mediana de 3 ejecuciones.

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_EXCEPTION como valor por defecto viene de PHP 8.0, las subclases por driver (Pdo\Sqlite, PDO::connect) de 8.4, y la deprecación de PDO::MYSQL_ATTR_* de 8.5 (vimos el mensaje Deprecated).
  • El comportamiento de MySQL (prepares emuladas, HY093, errores con IN (), conversión de strings en IN) 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_FULLFSYNC por 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

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.

  • #php
  • #intermedio
  • #pdo
  • #sqlite
  • #inyeccion-sql
  • #seguridad
  • #php85

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑