PHP Sessions und Cookies: session_start und setcookie

Rufe session_start() am Anfang einer Seite auf und lies und schreib dann $_SESSION['key'] wie jedes Array: PHP speichert es auf dem Server und findet es bei der nächsten Anfrage des Besuchers wieder. Für einen kleinen Wert, den der Browser behalten soll, rufst du setcookie('name', 'value', time() + 86400) auf und liest ihn bei späteren Anfragen aus $_COOKIE['name'] zurück.

<?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.";

Sessions und Cookies ergeben nur über mehrere HTTP-Anfragen eines Browsers Sinn, also sind die Beispiele, die einen brauchen, einfacher Code. Die Logik drumherum ist gewöhnliches PHP mit Arrays, und dieser Teil läuft hier: In jedem ausführbaren Block steht $session für $_SESSION, und jeder Aufruf ist eine Anfrage.

<?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";

Wie eine PHP-Session funktioniert

1. Das erste session_start() erzeugt eine zufällige ID, schickt sie in einem Cookie namens PHPSESSID an den Browser und gibt dir ein leeres $_SESSION.
2. Am Ende der Anfrage speichert PHP $_SESSION auf dem Server (standardmäßig in Dateien, oder in Redis oder einer Datenbank).
3. Bei der nächsten Anfrage schickt der Browser das Cookie zurück, session_start() liest die ID und lädt das gespeicherte Array.

Der Browser sieht nie die Daten, nur die ID. Deshalb gehört die ID des angemeldeten Nutzers in $_SESSION und nie in ein eigenes Cookie: Ein Besucher kann seine Cookies auf jeden beliebigen Wert ändern, aber $_SESSION kann er nicht ändern.

Einen Nutzer mit einer Session an- und abmelden

Anmelden heißt: das Passwort prüfen, die Session-ID neu erzeugen, die Nutzer-ID speichern. Abmelden ist das Umgekehrte und hat drei Schritte.

<?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) ist wichtiger, als es aussieht. Wenn ein Angreifer ein Opfer dazu bringen kann, eine Session-ID zu verwenden, die der Angreifer kennt (zum Beispiel über einen Link), und die ID nach dem Login gleich bleibt, ist der Angreifer ebenfalls angemeldet. Eine frische ID beim Login schließt diese Lücke. Das Prüfen des Passworts selbst behandelt die Seite zu password_hash.

Eine Session nach Inaktivität ablaufen lassen

PHPs eigene Aufräumarbeit (session.gc_maxlifetime, standardmäßig 1440 Sekunden) läuft zufällig und ist kein verlässlicher Timeout. Speichere die Zeit der letzten Anfrage und prüfe sie selbst. Der Block verwendet feste Timestamps, damit du jeden Fall siehst; ändere $timeout oder die Zeiten.

<?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');
}

Der Abstand von 09:05 bis 09:16:40 beträgt 700 Sekunden, unter der Grenze von 15 Minuten, also bleibt der Nutzer angemeldet. Der nächste Abstand beträgt 1000 Sekunden, also wird die Session geleert.

Flash-Meldungen

Eine Flash-Meldung wird bei einer Anfrage gesetzt und bei der nächsten einmal angezeigt, typischerweise „Saved.“ nach einer Weiterleitung. Speichere sie in der Session, dann liest und entfernst du sie in einem Schritt:

<?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

Ein Cookie mit setcookie setzen

setcookie() nimmt den Namen, den Wert und ein Options-Array (PHP 7.3 und neuer). Setze diese vier Optionen bei jedem Cookie, außer du hast einen Grund dagegen:

<?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';

Zwei Dinge bringen Leute zum Stolpern:

• $_COOKIE ändert sich nicht in derselben Anfrage. Es enthält, was der Browser mit dieser Anfrage gesendet hat. Ein Cookie, das du jetzt setzt, taucht bei der nächsten Anfrage in $_COOKIE auf.
• Cookies sind Header, also muss setcookie() vor jeder Ausgabe laufen, genau wie session_start() und header().

Um ein Cookie zu löschen, setzt du es erneut mit demselben Namen und path und einem Ablaufdatum in der Vergangenheit: setcookie('theme', '', ['expires' => time() - 3600, 'path' => '/']).

Ein Array in einem Cookie speichern

Ein Cookie-Wert ist ein String von höchstens etwa 4 KB, also speicherst du strukturierte Daten als JSON und behandelst, was zurückkommt, als nicht vertrauenswürdig: Der Besucher kann es ändern. Rufe nie unserialize() auf ein Cookie auf: Es kann Objekte deiner eigenen Klassen erzeugen und deren magische Methoden ausführen, während json_decode() immer nur Arrays, Strings, Zahlen, Booleans, null oder stdClass liefert.

<?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);

Die Seite zu json_encode behandelt die Flags. Für alles, was größer ist als ein paar kurze Werte, behältst du die Daten in der Session (oder einer Datenbank) und speicherst im Cookie nur einen Schlüssel.

Tokens für „angemeldet bleiben“

Ein Cookie für „angemeldet bleiben“ darf weder die Nutzer-ID noch den Passwort-Hash enthalten. Speichere ein langes zufälliges Token im Cookie und nur seinen Hash in der Datenbank, und vergleiche mit 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')));

Die Werte ändern sich bei jedem Durchlauf, weil random_bytes() zufällig ist. Wenn die Datenbank leakt, sind die Hashes ohne die Cookies nutzlos, und hash_equals() vergleicht in konstanter Zeit, sodass die Prüfung keine Zeitinformationen preisgibt.

Session oder Cookie: was du verwenden solltest

Typischer Fehler: headers already sent

session_start(), setcookie() und header() senden alle HTTP-Header, und Header lassen sich nur vor dem Body senden. Jede Ausgabe vorher, sogar eine Leerzeile vor <?php in einer eingebundenen Datei, erzeugt:

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

Die zweite Meldung sagt dir, wo die Ausgabe begonnen hat (page.php:2): Geh zu dieser Zeile und entferne die Ausgabe oder setze session_start() darüber. In Dateien, die nur PHP enthalten, verhindert das Weglassen des schließenden ?>, dass verirrter Leerraum danach zur Ausgabe wird.