Sesiones y cookies en PHP: session_start y setcookie

Llama a session_start() al principio de una página y luego lee y escribe $_SESSION['key'] como cualquier array: PHP lo guarda en el servidor y lo vuelve a encontrar en la siguiente petición del visitante. Para un valor pequeño que deba guardar el navegador, llama a setcookie('name', 'value', time() + 86400) y léelo en las peticiones posteriores desde $_COOKIE['name'].

<?php
session_start();                        // before any output
setcookie('theme', 'dark', time() + 60 * 60 * 24 * 30);   // 30 days, also before output

$_SESSION['visits'] = ($_SESSION['visits'] ?? 0) + 1;
$theme = $_COOKIE['theme'] ?? 'light';  // set on an earlier visit
echo "You have opened this page {$_SESSION['visits']} times.";

Las sesiones y las cookies solo tienen sentido a lo largo de varias peticiones HTTP de un navegador, así que los ejemplos que las necesitan son código simple. La lógica que las rodea es PHP normal sobre arrays, y esa parte sí se ejecuta aquí: en cada bloque ejecutable, $session hace el papel de $_SESSION, y cada llamada es una petición.

<?php
// $session plays the part of $_SESSION across three requests
$session = [];

function visit(array &$session, string $page): string
{
    $session['visits'] = ($session['visits'] ?? 0) + 1;
    $session['history'][] = $page;
    return "Request {$session['visits']}: $page (seen: " . implode(', ', $session['history']) . ')';
}

echo visit($session, '/home'), "\n";
echo visit($session, '/docs/php'), "\n";
echo visit($session, '/pricing'), "\n";

Cómo funciona una sesión de PHP

1. El primer session_start() crea un id aleatorio, lo envía al navegador en una cookie llamada PHPSESSID y te da un $_SESSION vacío.
2. Al final de la petición, PHP guarda $_SESSION en el servidor (en archivos por defecto, o en Redis, o en una base de datos).
3. En la siguiente petición el navegador devuelve la cookie, session_start() lee el id y carga el array guardado.

El navegador nunca ve los datos, solo el id. Por eso el id del usuario que ha iniciado sesión va en $_SESSION y nunca en una cookie propia: un visitante puede cambiar sus cookies a cualquier valor, pero no puede editar $_SESSION.

Iniciar y cerrar la sesión de un usuario

Iniciar sesión es: comprobar la contraseña, regenerar el id de sesión y guardar el id del usuario. Cerrar sesión es lo contrario, y tiene tres pasos.

<?php
// login.php
session_start();

$user = find_user_by_email($_POST['email'] ?? '');
if ($user && password_verify($_POST['password'] ?? '', $user['password_hash'])) {
    session_regenerate_id(true);        // new id after login: stops session fixation
    $_SESSION['user_id'] = $user['id'];
    header('Location: /dashboard.php');
    exit;
}
$error = 'Wrong email or password.';

<?php
// any protected page
session_start();
if (!isset($_SESSION['user_id'])) {
    header('Location: /login.php');
    exit;
}

<?php
// logout.php
session_start();
$_SESSION = [];                                     // 1. forget the data

$p = session_get_cookie_params();                   // 2. delete the cookie
setcookie(session_name(), '', time() - 3600, $p['path'], $p['domain'], $p['secure'], $p['httponly']);

session_destroy();                                  // 3. delete the stored session
header('Location: /');
exit;

session_regenerate_id(true) importa más de lo que parece. Si un atacante consigue que una víctima use un id de sesión que el atacante conoce (por ejemplo, mediante un enlace), y el id sigue siendo el mismo después de iniciar sesión, el atacante también queda dentro. Un id nuevo al iniciar sesión cierra ese agujero. La comprobación de la contraseña en sí se explica en la página de password_hash.

Expirar una sesión tras un periodo de inactividad

La limpieza propia de PHP (session.gc_maxlifetime, 1440 segundos por defecto) se ejecuta al azar y no es una expiración fiable. Guarda la hora de la última petición y compruébala tú. El bloque usa timestamps fijos para que veas cada caso; cambia $timeout o las horas.

<?php
function checkTimeout(array &$session, int $now, int $timeout = 900): bool
{
    $last = $session['last_seen'] ?? $now;
    if ($now - $last > $timeout) {
        $session = [];                  // in real code: session_unset() and a new id
        return false;
    }
    $session['last_seen'] = $now;
    return true;
}

$session = ['user_id' => 42];
$start = mktime(9, 0, 0, 3, 14, 2026);

foreach ([0, 300, 1000, 2000] as $offset) {
    $ok = checkTimeout($session, $start + $offset);
    printf("%s  %s  user_id=%s\n",
        date('H:i:s', $start + $offset),
        $ok ? 'active ' : 'expired',
        $session['user_id'] ?? 'none');
}

El intervalo de 09:05 a 09:16:40 es de 700 segundos, por debajo del límite de 15 minutos, así que el usuario sigue dentro. El siguiente intervalo es de 1000 segundos, así que la sesión se vacía.

Mensajes flash

Un mensaje flash se fija en una petición y se muestra una sola vez en la siguiente, normalmente "Guardado." después de una redirección. Guárdalo en la sesión, y luego léelo y elimínalo en un solo paso:

<?php
function flash(array &$session, ?string $message = null): ?string
{
    if ($message !== null) {
        $session['flash'] = $message;   // set it
        return null;
    }
    $message = $session['flash'] ?? null;
    unset($session['flash']);           // read it once
    return $message;
}

$session = [];
flash($session, 'Your profile was saved.');       // request 1: POST, then redirect

echo flash($session) ?? '(no message)', "\n";     // request 2: the page after the redirect
echo flash($session) ?? '(no message)', "\n";     // request 3: a refresh

Fijar una cookie con setcookie

setcookie() recibe el nombre, el valor y un array de opciones (PHP 7.3 y posteriores). Fija estas cuatro opciones en todas las cookies salvo que tengas un motivo para no hacerlo:

<?php
setcookie('theme', 'dark', [
    'expires'  => time() + 60 * 60 * 24 * 30,   // 30 days; 0 means "until the browser closes"
    'path'     => '/',                          // send it on every page, not just this folder
    'secure'   => true,                         // only over HTTPS
    'httponly' => true,                         // JavaScript cannot read it
    'samesite' => 'Lax',                        // not sent on most cross-site requests
]);

$theme = $_COOKIE['theme'] ?? 'light';

Dos cosas confunden a la gente:

• $_COOKIE no cambia en la misma petición. Contiene lo que envió el navegador con esta petición. Una cookie que fijas ahora aparece en $_COOKIE en la siguiente.
• Las cookies son cabeceras, así que setcookie() debe ejecutarse antes de cualquier salida, igual que session_start() y header().

Para borrar una cookie, vuelve a fijarla con el mismo nombre y path y una fecha de caducidad en el pasado: setcookie('theme', '', ['expires' => time() - 3600, 'path' => '/']).

Guardar un array en una cookie

El valor de una cookie es una cadena de unos 4 KB como mucho, así que guarda los datos estructurados como JSON, y trata lo que vuelve como algo no fiable: el visitante puede cambiarlo. Nunca hagas unserialize() de una cookie: puede crear objetos de tus propias clases y ejecutar sus métodos mágicos, mientras que json_decode() solo devuelve arrays, cadenas, números, booleanos, null o stdClass.

<?php
$recent = ['php/foreach', 'php/explode', 'php/date'];

$value = json_encode($recent);          // what you would pass to setcookie()
echo $value, ' (', strlen($value), " bytes)\n";

// On the next request, $_COOKIE['recent'] holds that string. Decode and check it:
$cookie = '["php/foreach","php/explode","php/date"]';
$decoded = json_decode($cookie, true);
$list = is_array($decoded) ? array_filter($decoded, 'is_string') : [];
print_r($list);

// A tampered cookie is just bad input:
$decoded = json_decode('{"admin":true', true);
var_dump($decoded);

La página de json_encode explica las opciones. Para cualquier cosa más grande que unos pocos valores cortos, guarda los datos en la sesión (o en una base de datos) y guarda en la cookie solo una clave.

Tokens de "recordarme"

Una cookie de "recordarme" no debe contener el id del usuario ni el hash de la contraseña. Guarda en la cookie un token aleatorio largo y en la base de datos solo su hash, y compáralos con hash_equals():

<?php
// At login, with "remember me" ticked
$token = bin2hex(random_bytes(32));      // goes in the cookie
$stored = hash('sha256', $token);        // goes in the database, next to the user id

echo 'cookie:   ', $token, "\n";
echo 'database: ', $stored, "\n";

// On a later visit, the browser sends the token back
$fromCookie = $token;
var_dump(hash_equals($stored, hash('sha256', $fromCookie)));
var_dump(hash_equals($stored, hash('sha256', 'guessed-token')));

Los valores cambian en cada ejecución, porque random_bytes() es aleatorio. Si se filtra la base de datos, los hashes no sirven de nada sin las cookies, y hash_equals() compara en tiempo constante para que la comprobación no filtre información a través del tiempo que tarda.

Sesión vs cookie: cuál usar

Error frecuente: headers already sent

session_start(), setcookie() y header() envían cabeceras HTTP, y las cabeceras solo se pueden enviar antes del cuerpo. Cualquier salida previa, incluso una línea en blanco antes de <?php en un archivo incluido, produce:

Warning: session_start(): Session cannot be started after headers have already been sent in /var/www/page.php on line 3
Warning: Cannot modify header information - headers already sent by (output started at /var/www/page.php:2) in /var/www/page.php on line 4

El segundo mensaje te dice dónde empezó la salida (page.php:2): ve a esa línea y quita la salida, o mueve session_start() por encima de ella. En los archivos que solo contienen PHP, omitir el ?> de cierre evita que los espacios sueltos que haya detrás se conviertan en salida.