Seguridad en PHP: XSS, CSRF y sesiones en PHP 8.5
XSS en cuatro contextos, un chequeo CSRF que aceptaba un token vacío, session fixation con Set-Cookie, bcrypt vs argon2id medidos y uploads inseguros.
Serie: curso de PHP 5/6 (avanzado). Esta clase es para quien ya sabe armar un formulario en PHP y una consulta con PDO, y ahora tiene que publicarlo en internet de verdad: el freelancer que entrega un sitio con login y panel de administración, el equipo de una startup que va a abrir el registro de usuarios la semana que viene, o el estudiante cuyo proyecto final va a quedar en un hosting público. Al terminar vas a poder escapar la salida según el contexto correcto, escribir un chequeo CSRF sin agujeros, blindar las sesiones contra fixation, elegir el cost de un hash de contraseñas a partir de una medición y aceptar subidas de archivos sin ejecutar código ajeno.
Si mantienes un sitio PHP con login, una caja de comentarios o un botón de subir archivos, esta es la lista de errores que de verdad se explotan. Cada uno se muestra en el servidor integrado de PHP enlazado a 127.0.0.1, atacado con curl, conservando la respuesta tal cual. Uno de los bugs fue nuestro: la primera versión del chequeo CSRF que escribimos para esta clase aceptaba un token vacío, y dejamos la salida a la vista.
Entorno: PHP 8.5.6 CLI y servidor integrado (php -S 127.0.0.1:8851), curl 8.7.1, Mac con Apple Silicon (M1 Pro), macOS. Todos los ejemplos son genéricos; ninguno viene de una aplicación real. Las rutas en la salida se acortaron a ~/demo/.
La clase 4 (PDO, SQLite e inyección SQL) cubrió el lado de la base de datos. Para ver cómo se ve esto en un código de diez años, lee nuestra auditoría: corregir SQLi y XSS en PHP heredado sin cambiar la salida.
XSS: una entrada, cuatro contextos de salida
Cross-site scripting (XSS) significa que un atacante logra meter su HTML o JavaScript en una página que ejecuta el navegador de otro usuario. El XSS reflejado vuelve directo desde la petición (un buscador); el XSS almacenado se guarda primero (un comentario) y se sirve a todo el mundo. La solución es la misma para ambos: escapar en la salida, según el contexto donde cae el valor. Esta página imprime un parámetro en cinco lugares:
<?php
// xss.php — one input, five output contexts. Run: php -S 127.0.0.1:8851 -t www
declare(strict_types=1);
$q = $_GET['q'] ?? '';
function e(string $s): string { return htmlspecialchars($s, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'); }
header('Content-Type: text/html; charset=UTF-8');
?>
<p>1 raw: <?= $q ?></p>
<p>2 escaped: <?= e($q) ?></p>
<a href="<?= e($q) ?>">3 href, escaped</a>
<input value=<?= e($q) ?>>
<script>
var a = "<?= e($q) ?>"; // 5a htmlspecialchars in JS
var b = <?= json_encode($q, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE) ?>; // 5b "pretty" flags
var c = <?= json_encode($q, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_THROW_ON_ERROR) ?>; // 5c safe
</script>
curl -G --data-urlencode 'q=</script><script>alert(1)</script>' devolvió:
<p>1 raw: </script><script>alert(1)</script></p>
<p>2 escaped: </script><script>alert(1)</script></p>
...
var a = "</script><script>alert(1)</script>";
var b = "</script><script>alert(1)</script>";
var c = "<\/script><script>alert(1)<\/script>";
La línea 1 es el agujero clásico. La línea b es la sorpresa: json_encode escapa / por defecto ("<\/script>"), y eso es justo lo que impide que </script> cierre el bloque. Los equipos agregan JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE para que el JSON se lea mejor (muy común en código que imprime texto con tildes, eñes, japonés o coreano), y eso elimina la protección. El parser de HTML termina el script en el primer </script>, piense lo que piense JavaScript sobre dónde termina un string.
Dos payloads más muestran dónde htmlspecialchars no es la herramienta correcta aunque se haya aplicado:
q=javascript:alert(1)
<a href="javascript:alert(1)">3 href, escaped</a>
q=x onfocus=alert(1) autofocus
<input value=x onfocus=alert(1) autofocus>
Nada en javascript:alert(1) necesita escaparse, así que el enlace ejecuta script al hacer clic. Para URLs, comprueba el esquema contra una allow-list (http, https) antes de escapar. El atributo sin comillas no necesita ninguna comilla para escaparse: un espacio empieza un atributo nuevo. Pon siempre los atributos entre comillas; entonces htmlspecialchars con ENT_QUOTES alcanza.
La línea a falla de otra manera. Con la entrada Tom "the cat" O'Neil:
var a = "Tom "the cat" O'Neil";
var b = "Tom \"the cat\" O'Neil";
var c = "Tom "the cat" O'Neil";
Dentro de <script> el navegador no decodifica entidades, así que el nombre del usuario se convierte en el texto literal ". Eso es un bug de datos más que un XSS, pero en un contexto sin comillas, como var id = <?= e($id) ?>;, la entrada 1;alert(1) no contiene ningún carácter especial y se ejecuta. json_encode con los cuatro flags JSON_HEX_* produce un literal JavaScript válido y del tipo correcto, y nunca emite <, >, &, ' ni ".
UTF-8 inválido: dos fallas distintas
Enviar el byte Latin-1 \xE9 (q=caf%E9) mostró la última trampa, y es la que te encuentras cuando un formulario viejo en ISO-8859-1 envía "café". Con JSON_THROW_ON_ERROR, la página murió a mitad de la salida:
Fatal error: Uncaught JsonException: Malformed UTF-8 characters, possibly incorrectly encoded in ~/demo/www/xss.php:15
Stack trace:
#0 ~/demo/www/xss.php(15): json_encode('caf\xE9', 4194319)
Sin el flag, json_encode devuelve false y var c = ; es un error de sintaxis. Fíjate además en que esta página de error le mostró la ruta del archivo al visitante: display_errors tiene que estar apagado en producción. Y un detalle sobre los flags de htmlspecialchars que confirmamos con php -r:
htmlspecialchars("caf\xe9") → string(6) "caf�" (default flags include ENT_SUBSTITUTE)
htmlspecialchars("caf\xe9", ENT_QUOTES) → string(0) ""
Pasar solo ENT_QUOTES reemplaza los flags por defecto, se pierde ENT_SUBSTITUTE y la entrada inválida se convierte en un string vacío. Pasa siempre ENT_QUOTES | ENT_SUBSTITUTE.
XSS almacenado en un tablero de comentarios
Un tablero mínimo guarda comentarios con una prepared statement (así que no hay inyección SQL) y los vuelve a imprimir. ?raw=1 se salta el escape:
$ curl -b j1 -d 'body=<script>alert(document.cookie)</script>' '.../board.php?nocsrf=1'
saved
$ curl -b j1 '.../board.php?raw=1'
<li><script>alert(document.cookie)</script></li>
$ curl -b j1 '.../board.php'
<li><script>alert(document.cookie)</script></li>
Las prepared statements protegen la consulta, no la página. Guarda el texto tal como lo escribió el usuario y escápalo al imprimir. Escapar antes de guardar rompe los datos para las APIs JSON y termina en doble escape (&lt;).
CSRF: random_bytes, hash_equals y el agujero del token vacío
Cross-site request forgery (CSRF) hace que el navegador de la víctima envíe una petición a tu sitio, con las cookies de la víctima, desde una página que controla el atacante. La defensa habitual es un token secreto en la sesión que todo formulario que cambia estado debe devolver:
function csrf_token(): string {
return $_SESSION['csrf'] ??= bin2hex(random_bytes(32)); // 64 hex chars, 256 bits
}
random_bytes usa la fuente aleatoria criptográfica del sistema operativo. mt_rand, rand y uniqid son predecibles y nunca deben usarse para tokens. Más detalles en tokens aleatorios seguros y secretos.
Error típico: un chequeo CSRF que acepta la nada
El error. Nuestra primera versión:
function csrf_check(): void {
$sent = $_POST['csrf'] ?? '';
if (!is_string($sent) || !hash_equals($_SESSION['csrf'] ?? '', $sent)) {
http_response_code(403);
exit("403 bad CSRF token\n");
}
}
Rechazaba con 403 un token ausente, un token incorrecto y csrf[]=x (un array), y aceptaba el correcto con 200. Lo que pasó en realidad con una víctima que inició sesión pero nunca abrió una página que llamara a csrf_token():
$ curl -c v1 -b v1 -d user=alice .../login.php
id=9dd562e445a4cb40820d8ec11a1b560f user=alice
$ curl -i -b v1 -d "body=attack&csrf=" .../board.php
HTTP/1.1 200 OK
saved
La sesión no tiene token, así que $_SESSION['csrf'] ?? '' es '', el atacante envía '' y hash_equals('', '') es true. La solución: tratar como fallo la ausencia del token guardado.
function csrf_check(): void {
$expected = $_SESSION['csrf'] ?? null;
$sent = $_POST['csrf'] ?? null;
if (!is_string($expected) || $expected === '' || !is_string($sent)
|| !hash_equals($expected, $sent)) {
http_response_code(403);
exit("403 bad CSRF token\n");
}
}
La misma petición después de la corrección: HTTP/1.1 403 Forbidden. Los chequeos is_string también importan: sin ellos, hash_equals lanza una excepción en vez de devolver false:
PHP Fatal error: Uncaught TypeError: hash_equals(): Argument #2 ($user_string) must be of type string, null given
#0 Command line code(1): hash_equals(Object(SensitiveParameterValue), Object(SensitiveParameterValue))
(El SensitiveParameterValue del trace es PHP ocultando ambos argumentos para que el secreto no termine en los logs.)
Por qué hash_equals y no ===
=== se detiene en el primer byte distinto; hash_equals siempre mira todos los bytes. Medimos 5 millones de comparaciones por caso, tercera de tres rondas:
| Comparación | Strings de 4096 bytes | Strings de 64 bytes |
|---|---|---|
===, difiere en el byte 0 |
26.8 ns | 26.5 ns |
===, difiere en el último byte |
154.8 ns | 28.1 ns |
hash_equals, primer byte |
2122.9 ns | 73.1 ns |
hash_equals, último byte |
2113.8 ns | 72.7 ns |
Con strings largos la fuga es evidente (27 contra 155 ns). Para un token de 64 caracteres la diferencia es de menos de 2 ns y sería difícil de medir a través de la red, pero hash_equals no cuesta nada que valga la pena ahorrar, así que úsalo (lo desarrollamos en timing attacks y comparación en tiempo constante). Nunca uses ==: var_dump("0e1234" == "0e9999") imprime bool(true) en PHP 8.5, porque ambos strings parecen el número 0 en notación científica, y md5("240610708") == md5("QNKCDZO") también es true.
Sesiones: fixation, session_regenerate_id y flags de la cookie
Session fixation significa que el atacante elige el id de sesión antes de que la víctima inicie sesión, y después lo reutiliza. El script de login:
<?php
require __DIR__ . '/common.php'; // session_start() lives here
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
// pretend the password was checked here
if (($_GET['fix'] ?? '') === '1') {
session_regenerate_id(true); // new id, delete the old session file
}
$_SESSION['user'] = $_POST['user'] ?? 'nobody';
}
echo 'id=', session_id(), ' user=', $_SESSION['user'] ?? '-', "\n";
Con los valores por defecto de PHP (session.use_strict_mode=0):
$ curl -i -b 'PHPSESSID=attacker1234567890' .../login.php
id=attacker1234567890 user=-
$ curl -i -b 'PHPSESSID=attacker1234567890' -d user=alice .../login.php
id=attacker1234567890 user=alice
# later, the attacker with the same cookie:
$ curl -b 'PHPSESSID=attacker1234567890' .../login.php
id=attacker1234567890 user=alice
El servidor aceptó un id que nunca había emitido, no envió ningún Set-Cookie y, después del login, el atacante era alice. Con ?fix=1, session_regenerate_id(true) emitió un id nuevo y el id plantado quedó vacío:
Set-Cookie: PHPSESSID=cd27da816f4f065991013f1f3357da6e; path=/
id=cd27da816f4f065991013f1f3357da6e user=alice
$ curl -b 'PHPSESSID=attacker2234567890' .../login.php
id=attacker2234567890 user=-
El Set-Cookie y los headers por defecto, con el php.ini sin tocar:
X-Powered-By: PHP/8.5.6
Set-Cookie: PHPSESSID=cbe551da3f65b2298e9aafd66cf69633; path=/
Sin HttpOnly (JavaScript puede leer la cookie, lo que convierte cualquier XSS en robo de cuentas), sin Secure, sin SameSite, y anunciando la versión de PHP. Reiniciamos el servidor con cinco opciones:
php -d session.use_strict_mode=1 -d session.cookie_httponly=1 -d session.cookie_secure=1 \
-d session.cookie_samesite=Lax -d expose_php=0 -S 127.0.0.1:8852 -t www
$ curl -i -b 'PHPSESSID=attacker3234567890' .../login.php
Set-Cookie: PHPSESSID=c820dbbc39f17601dd73818788753c12; path=/; secure; HttpOnly; SameSite=Lax
id=c820dbbc39f17601dd73818788753c12 user=-
El modo estricto rechazó el id plantado y emitió uno nuevo de inmediato, y X-Powered-By desapareció. Usa tanto el modo estricto como session_regenerate_id(true) en el login y en cada cambio de privilegios. SameSite=Lax además bloquea la mayoría de los POST entre sitios: es una segunda línea de defensa detrás del token CSRF, no un reemplazo. Si quieres repasar cómo viajan las cookies, mira headers, cookies y sesiones en HTTP.
Una trampa al testear: la cookie tiene Secure, y aun así curl la devolvió por http://127.0.0.1 (y http://localhost) en texto plano en la siguiente petición. curl, igual que los navegadores modernos, trata a localhost como un origen seguro. En un hosting real con HTTP plano la cookie no volvería, así que prueba el comportamiento de Secure en el dominio real.
Dos deprecaciones que aparecieron al probar las viejas perillas de configuración en 8.5:
PHP Deprecated: PHP Startup: session.sid_length INI setting is deprecated in Unknown on line 0
PHP Deprecated: ini_set(): Enabling session.use_trans_sid INI setting is deprecated
El id por defecto tiene 32 caracteres hexadecimales (128 bits) y no necesita ajustes; los ids en la URL (use_trans_sid) se filtran por los logs y por el header Referer.
Hash de contraseñas: password_hash, password_verify y el cost medido
Nunca guardes contraseñas con md5, sha1 ni hash('sha256'). Son rápidos, y rápido es justo lo que quiere un atacante con una tabla robada. password_hash elige una sal y un algoritmo lento; password_verify compara en tiempo constante. En 8.5, PASSWORD_DEFAULT es bcrypt con cost 12:
PASSWORD_DEFAULT: $2y$12$pSB6GmFI8jk.DSQgPsxnmezkJ5yMuJWMIolLGojMotf9ecXex0.KO
argon2id available: yes
bcrypt cost 10 hash median 58.7 ms (min 58.6, max 60.3) verify 58.8 ms
bcrypt cost 12 hash median 235.3 ms (min 234.1, max 246.3) verify 241.4 ms
argon2id default hash median 156.0 ms (min 151.9, max 167.7) verify 156.3 ms $argon2id$v=19$m=65536,t=4,p=1
Mediana de 9 llamadas cada uno. Cada paso de cost en bcrypt duplica el tiempo (58.7 → 235.3 ms con +2). argon2id además necesita memoria: el tamaño residente máximo del proceso pasó de 25.5 MB a 89.6 MB durante un hash, más o menos los 64 MiB de m=65536, que memory_get_peak_usage() no muestra porque libargon2 los reserva fuera del allocator de PHP. En un hosting compartido pequeño, 20 logins simultáneos necesitarían más de un gigabyte. La comparación completa entre algoritmos está en hash de contraseñas: bcrypt y Argon2.
Dos límites de bcrypt que confirmamos en 8.5: una contraseña con un byte NUL lanza ValueError: Bcrypt password must not contain null character, y solo cuentan los primeros 72 bytes, así que password_verify(str_repeat('a', 72) . 'TOTALLY DIFFERENT', $hash) devolvió true para un hash de 72 a. Una contraseña de 73 bytes no generó ningún error. Si permites frases de contraseña muy largas, argon2id no tiene ese límite.
Cómo elegir: apunta a unos 100–300 ms por login en tu hardware de producción, y usa password_needs_rehash() para actualizar los hashes viejos cuando los usuarios inician sesión (ejercicio 2).
Subida de archivos: lo que te dice el navegador es mentira
Todo lo que hay en $_FILES, salvo tmp_name y size, viene del cliente. Este endpoint confía en type y en name:
<?php
// upload_bad.php — DO NOT COPY. Trusts the browser's name and type.
$f = $_FILES['f'] ?? null;
if (!$f || $f['error'] !== UPLOAD_ERR_OK) { http_response_code(400); exit('error code ' . ($f['error'] ?? 'none') . "\n"); }
echo "client says type=", $f['type'], " name=", $f['name'], "\n";
if (!str_starts_with($f['type'], 'image/')) { http_response_code(415); exit("images only\n"); }
move_uploaded_file($f['tmp_name'], __DIR__ . '/uploads/' . $f['name']); // name chosen by the client!
echo "stored at /uploads/", $f['name'], "\n";
Un hello.php de una línea que imprime PHP_OS_FAMILY, etiquetado como PNG por curl:
$ curl -F 'f=@hello.php;type=image/png' .../upload_bad.php
client says type=image/png name=hello.php
stored at /uploads/hello.php
$ curl .../uploads/hello.php
this ran on the server: Darwin
Eso es ejecución remota de código con un payload inofensivo. Dos cosas que PHP ya hace por ti: quita los directorios de name (filename=../escaped.php llegó como escaped.php), aunque la ruta original del cliente sigue disponible en $_FILES['f']['full_path'] ("../../etc/escaped.php"), así que nunca uses esa clave para armar una ruta de archivo. Y finfo, que lee los bytes, es necesario pero no suficiente: un PNG real de 1×1 con la línea PHP agregada al final se detectó como image/png, y al guardarlo como poly.php con el endpoint malo igual se ejecutó.
La versión que sobrevivió a todas las pruebas decide ella misma el nombre, la extensión y la ubicación:
<?php
// upload_good.php — decide everything on the server.
declare(strict_types=1);
const ALLOWED = ['image/png' => 'png', 'image/jpeg' => 'jpg', 'image/webp' => 'webp'];
$f = $_FILES['f'] ?? null;
if (!is_array($f) || !is_int($f['error']) || $f['error'] !== UPLOAD_ERR_OK) {
http_response_code(400); exit('upload error ' . ($f['error'] ?? 'none') . "\n");
}
if ($f['size'] > 1_000_000) { http_response_code(413); exit("too large\n"); }
$mime = (new finfo(FILEINFO_MIME_TYPE))->file($f['tmp_name']); // look at the bytes
if (!isset(ALLOWED[$mime])) { http_response_code(415); exit("rejected: content is $mime\n"); }
$name = bin2hex(random_bytes(16)) . '.' . ALLOWED[$mime]; // our name, our extension
$dir = dirname(__DIR__) . '/safe_uploads'; // outside the document root
if (!move_uploaded_file($f['tmp_name'], "$dir/$name")) { http_response_code(500); exit("move failed\n"); }
echo "stored as $name ($mime)\n";
hello.php sent as cat.png → rejected: content is text/x-php
dot.png sent as x.php → stored as 730012bfe318b504c45210f535042d0b.png (image/png)
300 KB file (limit 200K) → upload error 1 (UPLOAD_ERR_INI_SIZE)
1.2 MB file (post max 1M) → HTTP/1.1 400, upload error none
La última fila es una confusión frecuente. Si se supera post_max_size, PHP descarta el cuerpo completo, así que $_FILES y $_POST quedan vacíos, y registra en el log PHP Warning: PHP Request Startup: POST Content-Length of 1200209 bytes exceeds the limit of 1048576 bytes. Maneja "no llegó nada" como un error propio. El PNG políglota se guardó como .png fuera del document root, donde el servidor web nunca lo va a ejecutar.
Headers de seguridad y la trampa de "headers already sent"
Los headers tienen que salir antes que el cuerpo:
$nonce = base64_encode(random_bytes(16));
header_remove('X-Powered-By');
header("Content-Security-Policy: default-src 'self'; script-src 'nonce-$nonce'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'");
header('X-Content-Type-Options: nosniff');
header('Referrer-Policy: strict-origin-when-cross-origin');
header('Permissions-Policy: camera=(), microphone=(), geolocation=()');
if (($_SERVER['HTTPS'] ?? '') === 'on') {
header('Strict-Transport-Security: max-age=31536000; includeSubDomains'); // only over HTTPS
}
curl mostró la CSP con un nonce nuevo en cada petición y sin X-Powered-By. Una Content-Security-Policy con nonce significa que solo se ejecutan los bloques <script nonce="...">, así que un <script> inyectado queda bloqueado aunque el escape falle en algún lugar. El bloqueo en sí no lo probamos: eso ocurre en un navegador, y esta clase solo usó curl. frame-ancestors 'none' reemplaza a X-Frame-Options: DENY, y HSTS solo debe enviarse por HTTPS.
Un archivo que empezaba con un espacio antes de <?php y después llamaba a header(...) funcionó en el servidor integrado. ini_get('output_buffering') devolvió "4096" ahí: el espacio quedó en un buffer de 4 KB. Después de un flush() apareció el warning real:
Warning: Cannot modify header information - headers already sent in ~/demo/www/late2.php on line 4
Un código así funciona en tu computadora y falla en un hosting con output_buffering=0, o en cuanto una página imprime más de 4 KB antes del header. Omite el ?> de cierre en los archivos que solo tienen PHP y vigila que no haya un BOM al principio del archivo.
Tabla de decisión
| Situación | Haz esto | Lo vimos arriba |
|---|---|---|
| Valor en texto HTML o en un atributo entre comillas | htmlspecialchars($s, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') |
<img …> impreso como texto |
Valor en href/src |
permite solo http/https y luego escapa |
javascript: pasó el escape |
Valor dentro de <script> |
json_encode con los cuatro flags JSON_HEX_* |
JSON_UNESCAPED_SLASHES se escapó del bloque |
| POST que cambia estado | token en la sesión, hash_equals, rechazar vacío |
el token vacío recibió 200 |
| Login | use_strict_mode=1 + session_regenerate_id(true) |
el id plantado terminó siendo alice |
| Cookie de sesión | HttpOnly; Secure; SameSite=Lax |
por defecto no tenía ninguno |
| Guardar contraseñas | PASSWORD_DEFAULT, password_needs_rehash |
235 ms con cost 12 |
| Subidas | finfo + allow-list + nombre aleatorio + fuera del docroot |
se ejecutó un .php subido |
Límites honestos y notas de versión
- Todo se ejecutó solo en PHP 8.5.6. Estos datos de versión vienen de los changelogs de PHP, y no ejecutamos versiones anteriores para confirmarlos: los valores por defecto de
htmlspecialcharspasaron aENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401en 8.1 (antes, las comillas simples no se escapaban por defecto);$_FILES[...]['full_path']se agregó en 8.1;SensitiveParameterValueen los traces en 8.2; el cost por defecto de bcrypt subió de 10 a 12, ysession.sid_length/use_trans_sidse deprecaron en 8.4. - El servidor integrado tiene un solo hilo y es solo para desarrollo. Apache, nginx con PHP-FPM o LiteSpeed deciden qué directorios ejecutan archivos
.php, y por eso "fuera del document root" importa más que cualquier chequeo de la subida. - El XSS se verificó leyendo el HTML que recibió curl, no ejecutando un navegador. El bloqueo por CSP y el comportamiento de
SameSiteson funciones del navegador que describimos pero no probamos. - La tabla de tiempos midió las funciones de comparación de PHP dentro de un proceso. No muestra si un atacante remoto podría medir una diferencia de 2 ns a través de la red; lo importante es que
hash_equalselimina la pregunta.
Ejercicios
1. Este botón registra un clic con el nombre del usuario. Se aplica htmlspecialchars. ¿Por qué sigue siendo explotable con el nombre x');alert(1);//, y cuál es la solución?
<button onclick="track('<?= e($name) ?>')">Like</button>
2. Los hashes de tus usuarios se crearon hace años con bcrypt cost 10. Actualízalos al valor por defecto actual sin obligar a nadie a restablecer su contraseña.
Respuestas
1. El navegador decodifica las entidades de un atributo antes de que se ejecute el JavaScript. Nuestra salida fue track('x');alert(1);//'), y después de decodificarla el motor de JS ve track('x');alert(1);//'). Codifica primero para JavaScript y después para el atributo HTML:
<button onclick="track(<?= e(json_encode($name, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_THROW_ON_ERROR)) ?>)">Like</button>
Salida: track("x');alert(1);\/\/"), que el navegador decodifica como un único argumento string. Mejor todavía: pon el valor en un atributo data- y engancha el manejador desde un archivo de script.
2.
function login(string $password, string &$storedHash): bool {
if (!password_verify($password, $storedHash)) return false;
if (password_needs_rehash($storedHash, PASSWORD_DEFAULT)) {
$storedHash = password_hash($password, PASSWORD_DEFAULT); // save this to the DB
}
return true;
}
Ejecutado contra un hash con cost 10, imprimió $2y$10$ -> true -> $2y$12$. La contraseña en texto plano solo está disponible durante el login, así que ese es el único momento en que puedes volver a generar el hash.
Lo que sigue
Preguntas frecuentes
¿Alcanza con htmlspecialchars para un valor dentro de una etiqueta script?
No. Dentro de <script> el navegador no decodifica entidades, así que una comilla escapada aparece como el texto literal ", y un contexto numérico sin comillas no necesita ningún carácter especial. Usa json_encode con JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS y JSON_HEX_QUOT. Agregar JSON_UNESCAPED_SLASHES para que la salida se vea más linda permitió que </script> se escapara en nuestra prueba.
¿Por qué mi chequeo CSRF con hash_equals acepta un token vacío?
Si la sesión nunca recibió un token, $_SESSION['csrf'] ?? '' es un string vacío, y hash_equals('', '') es true. Una víctima que inició sesión pero nunca abrió una página con formulario era atacable en nuestra prueba. Rechaza la petición cuando el token guardado no existe o está vacío.
¿Qué tan lento es password_hash en PHP 8.5?
En un M1 Pro, bcrypt con cost 10 tardó 58.7 ms, cost 12 (el valor por defecto desde PHP 8.4) tardó 235.3 ms, y argon2id con los valores por defecto (64 MiB, 4 pasadas) tardó 156.0 ms, mediana de 9 llamadas. password_verify cuesta lo mismo que generar el hash.