Работа с сессиями в PHP

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВВ РАЗРАБОТКЕ

Разработчику Архитектору

Работа с сессиями в PHP

Сессия — это механизм, позволяющий сохранять данные между последовательными HTTP-запросами от одного и того же клиента. Веб по своей природе является безсостоятельной средой: каждый запрос к серверу не содержит информации о предыдущих взаимодействиях. Сессии решают эту проблему, обеспечивая контекст для пользовательского взаимодействия с веб-приложением.

Основы HTTP и необходимость сессий

HTTP (HyperText Transfer Protocol) — это протокол прикладного уровня, используемый для передачи гипертекста в интернете. Он работает по принципу «запрос — ответ»: клиент (обычно браузер) отправляет запрос на сервер, а сервер возвращает ответ. Каждый такой цикл независим от предыдущего.

Эта особенность делает невозможным автоматическое распознавание пользователя при переходе с одной страницы сайта на другую. Без дополнительных механизмов сервер не может понять, что два запроса пришли от одного и того же человека.

Сессии позволяют создать устойчивый контекст, связывающий несколько HTTP-запросов в одну логическую сессию взаимодействия. Это основа для реализации таких функций, как:

аутентификация пользователей;
корзина покупок;
персонализированные настройки;
отслеживание действий пользователя;
управление правами доступа.

Как работает сессия в PHP

PHP предоставляет встроенную поддержку сессий через набор функций и суперглобальный массив $_SESSION.

Жизненный цикл сессии

Старт сессии: вызывается функция session_start(). Эта функция пытается найти существующую сессию по идентификатору, переданному клиентом.
Идентификация клиента: если сессия уже существует, PHP считывает её данные из хранилища (по умолчанию — файловой системы). Если сессия новая, создаётся уникальный идентификатор (session_id).
Хранение данных: все данные, помещённые в $_SESSION, автоматически сериализуются и сохраняются на сервере после завершения скрипта.
Передача идентификатора клиенту: PHP устанавливает cookie с именем PHPSESSID, содержащее значение session_id.
Последующие запросы: браузер автоматически отправляет cookie PHPSESSID с каждым запросом к тому же домену. Сервер использует этот идентификатор для загрузки соответствующих данных сессии.
Завершение сессии: сессия может быть завершена явно (session_destroy()) или автоматически по истечении времени жизни (настраивается через session.gc_maxlifetime).

Пример базового использования

<?php
// Запуск сессии
session_start();

// Сохранение данных в сессии
$_SESSION['username'] = 'alice';
$_SESSION['login_time'] = time();

// Чтение данных из сессии
echo "Привет, " . $_SESSION['username'] . "! Вы вошли в " . date('H:i', $_SESSION['login_time']);
?>

Хранение данных сессии

По умолчанию PHP хранит данные сессий в виде сериализованных файлов на диске сервера. Путь к этим файлам определяется параметром session.save_path в конфигурации PHP (php.ini).

Файл сессии имеет имя вида sess_<session_id>, где <session_id> — это строка из 32–128 символов (в зависимости от настроек), состоящая из букв и цифр. Внутри файла хранится сериализованное представление массива $_SESSION.

Например, если в сессию записано:

$_SESSION['user_id'] = 123;
$_SESSION['role'] = 'admin';

То содержимое файла будет примерно таким:

user_id|i:123;role|s:5:"admin";

Это формат сериализации PHP, который позволяет точно восстановить типы данных при чтении.

Альтернативные хранилища

PHP поддерживает замену механизма хранения сессий. Можно использовать:

базы данных (MySQL, PostgreSQL);
in-memory хранилища (Redis, Memcached);
распределённые файловые системы.

Для этого реализуется интерфейс SessionHandlerInterface и регистрируется через session_set_save_handler().

Безопасность сессий

Сессии — мощный инструмент, но их неправильное использование создаёт серьёзные уязвимости.

Утечка session_id

Главная угроза — перехват идентификатора сессии злоумышленником. Если он получит PHPSESSID, то сможет подменить пользователя (session fixation или session hijacking).

Защитные меры:

Использование HTTPS: шифрует весь трафик, включая cookie.
Флаг HttpOnly: предотвращает доступ к cookie через JavaScript (document.cookie), защищая от XSS-атак.
Флаг Secure: гарантирует, что cookie передаётся только по HTTPS.
Флаг SameSite: защищает от CSRF-атак. Рекомендуется значение Lax или Strict.

Настройка в PHP:

ini_set('session.cookie_httponly', 1);
ini_set('session.cookie_secure', 1); // только если используется HTTPS
ini_set('session.cookie_samesite', 'Lax');

Или в php.ini:

session.cookie_httponly = 1
session.cookie_secure = 1
session.cookie_samesite = "Lax"

Регенерация идентификатора

После успешной аутентификации обязательно нужно сгенерировать новый идентификатор сессии:

session_regenerate_id(true); // true — удаляет старый файл сессии

Это предотвращает атаку session fixation, когда злоумышленник заранее даёт жертве ссылку с известным PHPSESSID.

Время жизни сессии

Сессии не должны жить вечно. Настройки:

session.gc_maxlifetime — время в секундах, после которого неактивная сессия считается «мёртвой» и может быть удалена сборщиком мусора.
Рекомендуется устанавливать значение от 1800 (30 минут) до 7200 (2 часа) для обычных приложений.

Также можно реализовать собственную логику проверки активности:

if (isset($_SESSION['last_activity']) && (time() - $_SESSION['last_activity'] > 1800)) {
    session_unset();
    session_destroy();
    // Перенаправление на страницу входа
}
$_SESSION['last_activity'] = time();

Аутентификация и авторизация через сессии

Сессии являются основой для реализации систем входа и управления ролями.

Страница регистрации

Регистрация — это процесс создания нового аккаунта. Она включает:

Приём данных формы (логин, email, пароль).
Валидацию данных (формат email, сложность пароля).
Хеширование пароля.
Сохранение в базу данных.

Никогда не храните пароли в открытом виде!

PHP предоставляет надёжные функции для хеширования:

$password_hash = password_hash($password, PASSWORD_ARGON2ID);
// или
$password_hash = password_hash($password, PASSWORD_DEFAULT);

Пример обработчика регистрации:

<?php
if ($_POST) {
    $username = trim($_POST['username']);
    $email = filter_var($_POST['email'], FILTER_SANITIZE_EMAIL);
    $password = $_POST['password'];

    // Валидация
    if (strlen($password) < 8) {
        die("Пароль должен быть не менее 8 символов");
    }

    // Хеширование
    $hash = password_hash($password, PASSWORD_ARGON2ID);

    // Сохранение в БД (пример с PDO)
    $stmt = $pdo->prepare("INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)");
    $stmt->execute([$username, $email, $hash]);

    // Перенаправление на страницу входа
    header("Location: login.php");
    exit;
}
?>
<form method="post">
    <input name="username" placeholder="Логин" required>
    <input name="email" type="email" placeholder="Email" required>
    <input name="password" type="password" placeholder="Пароль" required>
    <button>Зарегистрироваться</button>
</form>

Страница входа

Вход — это проверка учётных данных и установка сессии.

<?php
session_start();

if ($_POST) {
    $username = $_POST['username'];
    $password = $_POST['password'];

    // Поиск пользователя в БД
    $stmt = $pdo->prepare("SELECT id, username, password_hash, role FROM users WHERE username = ?");
    $stmt->execute([$username]);
    $user = $stmt->fetch();

    if ($user && password_verify($password, $user['password_hash'])) {
        // Успешная аутентификация
        session_regenerate_id(true);
        $_SESSION['user_id'] = $user['id'];
        $_SESSION['username'] = $user['username'];
        $_SESSION['role'] = $user['role'];
        $_SESSION['logged_in'] = true;

        header("Location: dashboard.php");
        exit;
    } else {
        $error = "Неверный логин или пароль";
    }
}
?>

<form method="post">
    <?php if (!empty($error)): ?>
        <div style="color:red"><?= htmlspecialchars($error) ?></div>
    <?php endif; ?>
    <input name="username" placeholder="Логин" required>
    <input name="password" type="password" placeholder="Пароль" required>
    <button>Войти</button>
</form>

Обратите внимание:

Используется password_verify() для сравнения пароля с хешем.
После успешного входа вызывается session_regenerate_id(true).
В сессию записываются только необходимые данные: user_id, username, role.

Проверка авторизации на защищённых страницах

Любая страница, требующая входа, должна начинаться с проверки сессии:

<?php
session_start();

if (!isset($_SESSION['logged_in']) || $_SESSION['logged_in'] !== true) {
    header("Location: login.php");
    exit;
}

// Теперь можно работать с данными пользователя
echo "Добро пожаловать, " . htmlspecialchars($_SESSION['username']);
?>

Для защиты от XSS всегда используйте htmlspecialchars() при выводе данных, полученных от пользователя.

Реализация системы ролей

Роли позволяют ограничивать доступ к функционалу в зависимости от привилегий пользователя.

Простая модель ролей

Предположим, есть три роли:

guest — неавторизованный пользователь;
user — обычный пользователь;
admin — администратор.

В сессии хранится поле role.

Проверка прав:

function requireRole($requiredRole) {
    session_start();
    if (!isset($_SESSION['logged_in']) || $_SESSION['logged_in'] !== true) {
        header("Location: login.php");
        exit;
    }

    $userRole = $_SESSION['role'] ?? 'guest';

    // Простая иерархия: admin > user > guest
    $roleHierarchy = ['guest' => 0, 'user' => 1, 'admin' => 2];
    if (($roleHierarchy[$userRole] ?? -1) < ($roleHierarchy[$requiredRole] ?? -1)) {
        http_response_code(403);
        die("Доступ запрещён");
    }
}

Использование:

<?php
requireRole('admin');
// Только администраторы могут видеть эту страницу
?>
<h1>Панель администратора</h1>

Отображение контента в зависимости от роли

<?php
session_start();
$role = $_SESSION['role'] ?? 'guest';
?>

<nav>
    <a href="/">Главная</a>
    <?php if ($role === 'user' || $role === 'admin'): ?>
        <a href="/profile">Профиль</a>
    <?php endif; ?>
    <?php if ($role === 'admin'): ?>
        <a href="/admin">Админка</a>
    <?php endif; ?>
</nav>

Под капотом: как PHP управляет сессиями

Когда вызывается session_start():

PHP проверяет наличие cookie PHPSESSID в запросе.
Если cookie есть, извлекается session_id.
Выполняется валидация session_id (только буквенно-цифровые символы, длина соответствует настройкам).
PHP обращается к хранилищу (файл, Redis и т.д.) по этому идентификатору.
Если данные найдены, они десериализуются в $_SESSION.
Если cookie нет или сессия не найдена, создаётся новый session_id.
В ответе устанавливается заголовок Set-Cookie: PHPSESSID=....

Важно: session_start() должен вызываться до любого вывода на экран, так как он отправляет HTTP-заголовки.

Распространённые ошибки

Забыли вызвать session_start() — данные сессии недоступны.
Хранение паролей в сессии — никогда не делайте этого. Даже хеши.
Отсутствие регенерации ID после входа — уязвимость к session fixation.
Отсутствие HTTPS — session_id передаётся в открытом виде.
Хранение слишком много данных в сессии — увеличивает нагрузку на сервер и замедляет работу.
Использование == вместо === при проверке флагов — может привести к логическим ошибкам ("1" == true, но "1" !== true).

Продвинутые практики

Автоматический выход по неактивности

// В начале каждого скрипта
session_start();
$timeout = 1800; // 30 минут

if (isset($_SESSION['last_activity']) && (time() - $_SESSION['last_activity'] > $timeout)) {
    session_unset();
    session_destroy();
    header("Location: logout.php?timeout=1");
    exit;
}
$_SESSION['last_activity'] = time();

Защита от одновременного входа с разных устройств

Можно хранить хеш от отпечатка устройства (user-agent + IP) и проверять его при каждом запросе:

$fingerprint = hash('sha256', $_SERVER['HTTP_USER_AGENT'] . $_SERVER['REMOTE_ADDR']);
if (!isset($_SESSION['fingerprint'])) {
    $_SESSION['fingerprint'] = $fingerprint;
} elseif ($_SESSION['fingerprint'] !== $fingerprint) {
    // Возможна кража сессии
    session_destroy();
    die("Подозрительная активность");
}

⚠️ Внимание: IP может меняться у мобильных пользователей, поэтому такой метод подходит не для всех случаев.

Расширенные сценарии: регистрация, вход и управление ролями

Структура проекта для системы аутентификации

Для реализации полноценной системы аутентификации рекомендуется следующая структура файлов:

/auth/
  ├── register.php        # Страница регистрации
  ├── login.php           # Страница входа
  ├── logout.php          # Выход из системы
  ├── dashboard.php       # Защищённая страница после входа
/includes/
  ├── db.php              # Подключение к базе данных
  ├── auth.php            # Вспомогательные функции аутентификации
  └── helpers.php         # Общие утилиты (htmlspecialchars, редиректы и т.п.)
/assets/
  └── style.css           # Стили (опционально)
index.php                 # Главная страница

Такая структура обеспечивает чёткое разделение ответственности и упрощает поддержку кода.

Подключение к базе данных

Файл /includes/db.php:

<?php
$host = 'localhost';
$dbname = 'my_app';
$username = 'db_user';
$password = 'secure_password';

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8mb4", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Ошибка подключения к БД: " . htmlspecialchars($e->getMessage()));
}
?>

Использование utf8mb4 гарантирует поддержку эмодзи и всех символов Unicode.

Вспомогательные функции аутентификации

Файл /includes/auth.php:

<?php
function isLoggedIn(): bool {
    return isset($_SESSION['logged_in']) && $_SESSION['logged_in'] === true;
}

function requireLogin() {
    if (!isLoggedIn()) {
        header("Location: /auth/login.php");
        exit;
    }
}

function getUserRole(): string {
    return $_SESSION['role'] ?? 'guest';
}

function hasRole(string $requiredRole): bool {
    $userRole = getUserRole();
    $roles = ['guest' => 0, 'user' => 1, 'moderator' => 2, 'admin' => 3];
    return ($roles[$userRole] ?? -1) >= ($roles[$requiredRole] ?? -1);
}

function requireRole(string $role) {
    if (!hasRole($role)) {
        http_response_code(403);
        die("Доступ запрещён");
    }
}
?>

Эти функции позволяют централизованно управлять проверками доступа.

Страница регистрации — подробный разбор

Файл /auth/register.php:

<?php
session_start();
require_once '../includes/db.php';

$errors = [];

if ($_POST) {
    $username = trim($_POST['username'] ?? '');
    $email = filter_var($_POST['email'] ?? '', FILTER_SANITIZE_EMAIL);
    $password = $_POST['password'] ?? '';

    // Валидация
    if (strlen($username) < 3) {
        $errors[] = "Логин должен быть не короче 3 символов";
    }
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $errors[] = "Некорректный email";
    }
    if (strlen($password) < 8) {
        $errors[] = "Пароль должен содержать минимум 8 символов";
    }

    // Проверка уникальности логина и email
    if (empty($errors)) {
        $stmt = $pdo->prepare("SELECT id FROM users WHERE username = ? OR email = ?");
        $stmt->execute([$username, $email]);
        if ($stmt->fetch()) {
            $errors[] = "Пользователь с таким логином или email уже существует";
        }
    }

    if (empty($errors)) {
        $hash = password_hash($password, PASSWORD_ARGON2ID);
        $stmt = $pdo->prepare("INSERT INTO users (username, email, password_hash, role) VALUES (?, ?, ?, 'user')");
        $stmt->execute([$username, $email, $hash]);

        // Автоматический вход после регистрации (опционально)
        $_SESSION['user_id'] = $pdo->lastInsertId();
        $_SESSION['username'] = $username;
        $_SESSION['role'] = 'user';
        $_SESSION['logged_in'] = true;
        session_regenerate_id(true);

        header("Location: /dashboard.php");
        exit;
    }
}
?>

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Регистрация</title>
</head>
<body>
    <h1>Регистрация</h1>

    <?php if (!empty($errors)): ?>
        <div style="color: red;">
            <?php foreach ($errors as $error): ?>
                <p><?= htmlspecialchars($error) ?></p>
            <?php endforeach; ?>
        </div>
    <?php endif; ?>

    <form method="post">
        <label>
            Логин:<br>
            <input type="text" name="username" required>
        </label><br><br>

        <label>
            Email:<br>
            <input type="email" name="email" required>
        </label><br><br>

        <label>
            Пароль:<br>
            <input type="password" name="password" required>
        </label><br><br>

        <button type="submit">Зарегистрироваться</button>
    </form>

    <p><a href="/auth/login.php">Уже есть аккаунт? Войти</a></p>
</body>
</html>

Ключевые моменты:

Все входные данные проходят валидацию.
Используется FILTER_SANITIZE_EMAIL и FILTER_VALIDATE_EMAIL.
Хеширование пароля выполняется через password_hash() с алгоритмом PASSWORD_ARGON2ID.
После успешной регистрации пользователь автоматически входит в систему (это повышает UX).
Все выводимые строки экранируются через htmlspecialchars().

Страница входа — безопасная реализация

Файл /auth/login.php:

<?php
session_start();
require_once '../includes/db.php';

$errors = [];

if ($_POST) {
    $identifier = trim($_POST['identifier'] ?? ''); // может быть логин или email
    $password = $_POST['password'] ?? '';

    if (empty($identifier) || empty($password)) {
        $errors[] = "Заполните все поля";
    } else {
        // Поиск по логину или email
        $stmt = $pdo->prepare("SELECT id, username, email, password_hash, role FROM users WHERE username = ? OR email = ?");
        $stmt->execute([$identifier, $identifier]);
        $user = $stmt->fetch();

        if ($user && password_verify($password, $user['password_hash'])) {
            // Успешная аутентификация
            session_regenerate_id(true);
            $_SESSION['user_id'] = $user['id'];
            $_SESSION['username'] = $user['username'];
            $_SESSION['role'] = $user['role'];
            $_SESSION['logged_in'] = true;

            // Перенаправление на предыдущую страницу или на дашборд
            $redirect = $_GET['redirect'] ?? '/dashboard.php';
            header("Location: " . $redirect);
            exit;
        } else {
            $errors[] = "Неверный логин/email или пароль";
        }
    }
}
?>

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Вход</title>
</head>
<body>
    <h1>Вход в систему</h1>

    <?php if (!empty($errors)): ?>
        <div style="color: red;">
            <?php foreach ($errors as $error): ?>
                <p><?= htmlspecialchars($error) ?></p>
            <?php endforeach; ?>
        </div>
    <?php endif; ?>

    <form method="post">
        <label>
            Логин или email:<br>
            <input type="text" name="identifier" required>
        </label><br><br>

        <label>
            Пароль:<br>
            <input type="password" name="password" required>
        </label><br><br>

        <button type="submit">Войти</button>
    </form>

    <p><a href="/auth/register.php">Нет аккаунта? Зарегистрироваться</a></p>
</body>
</html>

💡 Совет: Поле identifier вместо отдельных username и email упрощает интерфейс и соответствует современным практикам (например, как в GitHub или Google).

Выход из системы

Файл /auth/logout.php:

<?php
session_start();

// Очистка сессии
$_SESSION = [];
session_destroy();

// Удаление cookie (если нужно)
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(
        session_name(),
        '',
        time() - 42000,
        $params["path"],
        $params["domain"],
        $params["secure"],
        $params["httponly"]
    );
}

header("Location: /");
exit;
?>

Этот скрипт полностью уничтожает сессию и удаляет cookie, предотвращая повторное использование старого PHPSESSID.

Защищённая страница с проверкой роли

Файл /dashboard.php:

<?php
session_start();
require_once 'includes/auth.php';
requireLogin(); // Требует входа

$title = "Панель управления";
$role = getUserRole();
?>

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title><?= htmlspecialchars($title) ?></title>
</head>
<body>
    <h1>Добро пожаловать, <?= htmlspecialchars($_SESSION['username']) ?>!</h1>
    <p>Ваша роль: <strong><?= htmlspecialchars($role) ?></strong></p>

    <nav>
        <a href="/">Главная</a> |
        <a href="/auth/logout.php">Выйти</a>
    </nav>

    <?php if (hasRole('admin')): ?>
        <div style="margin-top: 20px; padding: 10px; background: #e0f7fa;">
            <h2>Административная зона</h2>
            <ul>
                <li><a href="/admin/users.php">Управление пользователями</a></li>
                <li><a href="/admin/logs.php">Логи системы</a></li>
            </ul>
        </div>
    <?php endif; ?>

    <?php if (hasRole('user')): ?>
        <div style="margin-top: 20px;">
            <h2>Ваши данные</h2>
            <p>Вы можете редактировать профиль, менять пароль и просматривать историю действий.</p>
        </div>
    <?php endif; ?>
</body>
</html>

Такой подход позволяет гибко управлять контентом на основе ролей без дублирования логики.

Продвинутая защита: CSRF и дополнительные меры

Защита от CSRF (Cross-Site Request Forgery)

Добавьте в каждую форму скрытое поле с токеном:

// Генерация токена при старте сессии (или при первом запросе)
if (!isset($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

В форме:

<input type="hidden" name="csrf_token" value="<?= htmlspecialchars($_SESSION['csrf_token']) ?>">

Проверка при обработке:

if (!hash_equals($_SESSION['csrf_token'], $_POST['csrf_token'] ?? '')) {
    die("Недопустимый запрос");
}

Использование hash_equals() предотвращает атаки по времени (timing attacks).

Альтернативы сессиям: stateless-аутентификация

Хотя сессии — стандартный способ управления состоянием в PHP, современные API часто используют токены (например, JWT). Однако для классических веб-приложений с формами и HTML-рендерингом сессии остаются наиболее простым и надёжным решением.

JWT требует:

хранения токена на клиенте (в localStorage или cookie);
подписи токена секретным ключом;
проверки срока действия при каждом запросе;
механизма отзыва токенов (что усложняет архитектуру).

Для большинства сайтов на PHP сессии предпочтительнее.

Резюме по безопасности сессий

Мера	Назначение
`session.cookie_httponly = 1`	Защита от XSS
`session.cookie_secure = 1`	Только по HTTPS
`session.cookie_samesite = "Lax"`	Защита от CSRF
`session_regenerate_id(true)` после входа	Защита от session fixation
Хранение только `user_id`, а не пароля	Минимизация рисков
Использование `password_hash()` и `password_verify()`	Безопасное хранение паролей
Время жизни сессии ≤ 2 часов	Ограничение окна атаки

Восстановление пароля по email

Восстановление пароля — обязательная функция любого приложения с аутентификацией. Она позволяет пользователю получить доступ к аккаунту, если он забыл пароль.

Общая схема восстановления

Пользователь указывает email или логин на странице восстановления.
Система проверяет существование пользователя.
Генерируется одноразовый токен с ограниченным сроком действия.
Токен сохраняется в базе данных и отправляется пользователю по email в виде ссылки.
При переходе по ссылке система проверяет токен.
Если токен действителен, пользователь может задать новый пароль.

Безопасные практики

Токен должен быть случайным, длиной не менее 64 байт (128 символов в hex).
Срок действия токена — от 15 до 60 минут.
Одноразовость: после использования токен удаляется.
Не раскрывать, существует ли пользователь с таким email (чтобы не помогать брутфорсу).

Реализация

1. Форма запроса восстановления (`/auth/forgot.php`)

<?php
session_start();
require_once '../includes/db.php';

if ($_POST) {
    $email = filter_var($_POST['email'] ?? '', FILTER_SANITIZE_EMAIL);

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $error = "Некорректный email";
    } else {
        // Поиск пользователя
        $stmt = $pdo->prepare("SELECT id, email FROM users WHERE email = ?");
        $stmt->execute([$email]);
        $user = $stmt->fetch();

        if ($user) {
            // Генерация токена
            $token = bin2hex(random_bytes(32));
            $expires = time() + 1800; // 30 минут

            // Сохранение в БД
            $stmt = $pdo->prepare("INSERT INTO password_resets (user_id, token, expires_at) VALUES (?, ?, ?)");
            $stmt->execute([$user['id'], $token, date('Y-m-d H:i:s', $expires)]);

            // Отправка email (здесь — заглушка)
            $resetLink = "https://example.com/auth/reset.php?token=" . urlencode($token);
            // mail($email, "Восстановление пароля", "Перейдите по ссылке: $resetLink");

            // В реальном проекте используйте PHPMailer или аналог
            echo "<p>Ссылка для восстановления отправлена на ваш email.</p>";
            exit;
        }

        // Всегда показываем одинаковое сообщение
        echo "<p>Если указанный email зарегистрирован, вы получите инструкции.</p>";
        exit;
    }
}
?>

<form method="post">
    <label>Email:<br><input type="email" name="email" required></label><br><br>
    <button>Восстановить пароль</button>
</form>

2. Страница сброса (`/auth/reset.php`)

<?php
require_once '../includes/db.php';

$token = $_GET['token'] ?? '';
if (!$token) {
    die("Недействительная ссылка");
}

// Поиск токена
$stmt = $pdo->prepare("
    SELECT pr.user_id, pr.expires_at, u.email 
    FROM password_resets pr 
    JOIN users u ON pr.user_id = u.id 
    WHERE pr.token = ?
");
$stmt->execute([$token]);
$record = $stmt->fetch();

if (!$record) {
    die("Ссылка недействительна или устарела");
}

$expires = strtotime($record['expires_at']);
if (time() > $expires) {
    die("Срок действия ссылки истёк");
}

if ($_POST) {
    $password = $_POST['password'] ?? '';
    if (strlen($password) < 8) {
        $error = "Пароль должен быть не короче 8 символов";
    } else {
        $hash = password_hash($password, PASSWORD_ARGON2ID);
        $pdo->prepare("UPDATE users SET password_hash = ? WHERE id = ?")
            ->execute([$hash, $record['user_id']]);

        // Удаление использованного токена
        $pdo->prepare("DELETE FROM password_resets WHERE token = ?")->execute([$token]);

        echo "<p>Пароль успешно изменён. <a href='/auth/login.php'>Войти</a></p>";
        exit;
    }
}
?>

<form method="post">
    <h2>Новый пароль</h2>
    <?php if (!empty($error)): ?>
        <p style="color:red"><?= htmlspecialchars($error) ?></p>
    <?php endif; ?>
    <label>Пароль:<br><input type="password" name="password" required></label><br><br>
    <button>Сохранить</button>
</form>

3. Структура таблицы `password_resets`

CREATE TABLE password_resets (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    token CHAR(64) NOT NULL UNIQUE,
    expires_at DATETIME NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

Журналирование событий входа

Для аудита безопасности рекомендуется вести журнал всех попыток входа.

Таблица `login_attempts`

CREATE TABLE login_attempts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255),
    ip_address VARCHAR(45),
    user_agent TEXT,
    success BOOLEAN,
    attempted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Запись события

Добавьте в обработчик входа:

function logLoginAttempt($username, $success) {
    global $pdo;
    $ip = $_SERVER['REMOTE_ADDR'] ?? 'unknown';
    $ua = $_SERVER['HTTP_USER_AGENT'] ?? '';

    $stmt = $pdo->prepare("
        INSERT INTO login_attempts (username, ip_address, user_agent, success)
        VALUES (?, ?, ?, ?)
    ");
    $stmt->execute([$username, $ip, $ua, (bool)$success]);
}

Вызов:

if ($user && password_verify($password, $user['password_hash'])) {
    // успешный вход
    logLoginAttempt($username, true);
    // ... остальное
} else {
    logLoginAttempt($username, false);
    $error = "Неверный логин или пароль";
}

Это позволяет:

выявлять брутфорс-атаки;
анализировать подозрительную активность;
предоставлять данные при расследовании инцидентов.

Двухфакторная аутентификация (2FA)

Двухфакторная аутентификация повышает безопасность за счёт добавления второго фактора (обычно временный код из приложения или SMS).

Простая реализация с TOTP

При первом включении 2FA генерируется секретный ключ.
Ключ сохраняется в БД и отображается пользователю в виде QR-кода.
При входе после ввода пароля запрашивается код из Google Authenticator.
Сервер проверяет код с помощью библиотеки (например, robthree/twofactorauth).

Установка через Composer (локально)

composer require robthree/twofactorauth

Активация 2FA

use RobThree\Auth\TwoFactorAuth;

$tfa = new TwoFactorAuth('Вселенная IT');
$secret = $tfa->createSecret(); // 16-символьный base32 ключ

// Сохранить в users.totp_secret
// Показать QR-код: $tfa->getQRCodeImageAsDataUri($email, $secret);

Проверка кода при входе

if (isset($_SESSION['pending_2fa'])) {
    // Пользователь уже прошёл пароль, ждём код
    if ($_POST['code'] && $tfa->verifyCode($_SESSION['totp_secret'], $_POST['code'])) {
        $_SESSION['logged_in'] = true;
        unset($_SESSION['pending_2fa']);
        unset($_SESSION['totp_secret']);
        header("Location: /dashboard.php");
        exit;
    } else {
        $error = "Неверный код двухфакторной аутентификации";
    }
}

Полная реализация требует отдельной страницы настройки 2FA, но даже базовая версия значительно повышает защиту.

Тестирование сессий

Для надёжности важно тестировать сценарии работы с сессиями.

Пример теста на PHPUnit (без фреймворка)

// test_session_login.php
require_once 'auth.php';

class SessionLoginTest extends \PHPUnit\Framework\TestCase
{
    private $pdo;

    protected function setUp(): void {
        // Используем in-memory SQLite для тестов
        $this->pdo = new PDO('sqlite::memory:');
        // Создание таблиц и тестовых данных
    }

    public function testSuccessfulLoginSetsSession()
    {
        session_start();
        $_POST = ['username' => 'testuser', 'password' => 'correctpass'];

        // Вызов login.php логики (обёрнутой в функцию)
        handleLogin($this->pdo);

        $this->assertTrue($_SESSION['logged_in']);
        $this->assertEquals('testuser', $_SESSION['username']);
    }

    protected function tearDown(): void {
        session_destroy();
    }
}

Ключевые сценарии для тестирования:

успешный вход;
неверный пароль;
пустые поля;
регенерация session_id;
выход из системы;
истечение срока сессии.

Распространённые проблемы и их решение

Проблема	Причина	Решение
Сессия не сохраняется между страницами	`session_start()` вызван после вывода	Вызывать `session_start()` в самом начале скрипта
Все пользователи видят чужие данные	Один и тот же `PHPSESSID` используется всеми	Проверить, не установлен ли `session_id()` вручную без генерации
Сессия живёт слишком долго	`gc_maxlifetime` слишком большое	Уменьшить значение, добавить собственную проверку времени
CSRF-атаки работают	Отсутствует защита токеном	Внедрить `csrf_token` во все формы
XSS приводит к краже сессии	Cookie без `HttpOnly`	Установить `session.cookie_httponly = 1`

Сессии и современные архитектурные подходы

Современные веб-приложения всё чаще строятся по принципу разделения фронтенда и бэкенда: фронтенд — это SPA (Single Page Application) на React, Vue или Angular, а бэкенд — REST API или GraphQL-сервер на PHP, Node.js, Python и т.д. В такой архитектуре классические PHP-сессии теряют актуальность.

Почему сессии не подходят для stateless API

RESTful API предполагает stateless взаимодействие: каждый запрос должен содержать всю необходимую информацию для его обработки. Сервер не хранит состояние между запросами. Это упрощает масштабирование, кэширование и отказоустойчивость.

PHP-сессии нарушают этот принцип:

они требуют хранения состояния на сервере;
они привязаны к конкретному экземпляру сервера (если нет общего хранилища);
они зависят от cookie, что усложняет кросс-доменные запросы.

Поэтому в API-ориентированных системах вместо сессий используют токены, чаще всего JWT (JSON Web Token).

Когда сессии остаются уместными

Сессии идеально подходят для:

классических веб-сайтов с HTML-рендерингом на стороне сервера;
внутренних корпоративных систем;
приложений с минимальной нагрузкой и простой архитектурой;
случаев, когда требуется строгий контроль над временем жизни сессии и возможностью её принудительного завершения.

Если вы разрабатываете сайт, где PHP генерирует HTML (например, через шаблонизатор Twig или просто echo), сессии — правильный выбор.

Альтернатива: JWT (JSON Web Token)

JWT — это самодостаточный токен, содержащий закодированную информацию о пользователе и сроке действия. Он подписывается секретным ключом, что гарантирует его подлинность.

Пример использования JWT в PHP

Установка через Composer:

composer require firebase/php-jwt

Генерация токена:

use Firebase\JWT\JWT;
use Firebase\JWT\Key;

$key = "your_secret_key";
$payload = [
    "user_id" => 123,
    "username" => "alice",
    "role" => "user",
    "exp" => time() + 3600 // 1 час
];

$jwt = JWT::encode($payload, $key, 'HS256');
echo $jwt;

Проверка токена:

try {
    $decoded = JWT::decode($jwt, new Key($key, 'HS256'));
    // Доступ к данным: $decoded->user_id, $decoded->role и т.д.
} catch (Exception $e) {
    // Невалидный или просроченный токен
    http_response_code(401);
    die("Недействительный токен");
}
``>

В отличие от сессий:
- JWT не требует хранения на сервере;
- он может быть передан в заголовке `Authorization: Bearer <token>`;
- он работает без cookie, что удобно для мобильных и SPA-приложений.

Однако у JWT есть недостаток: **невозможно отозвать токен до истечения срока действия**, если не вести чёрный список (что сводит преимущества к нулю). Поэтому для высокозащищённых систем часто комбинируют JWT с коротким сроком жизни и механизмом refresh-токенов.

---

## Сравнение: сессии vs JWT

| Критерий | Сессии | JWT |
|---------|--------|-----|
| Хранение состояния | На сервере | В самом токене |
| Масштабируемость | Требует общего хранилища (Redis) | Stateless — легко масштабируется |
| Безопасность | Зависит от защиты cookie и ID | Зависит от секретного ключа и алгоритма |
| Отзыв доступа | Мгновенно (`session_destroy()`) | Только через чёрный список или короткий TTL |
| Поддержка CORS | Ограничена (cookie third-party блокируются) | Полная (через заголовки) |
| Использование в SPA | Не рекомендуется | Рекомендуется |

Выбор зависит от архитектуры проекта. Для монолитного PHP-сайта — сессии. Для микросервисов и SPA — JWT.

---

## Практические рекомендации по работе с сессиями

### 1. Настройка `php.ini` для продакшена

```ini
; Защита cookie
session.cookie_httponly = 1
session.cookie_secure = 1
session.cookie_samesite = "Lax"

; Время жизни
session.gc_maxlifetime = 1800 ; 30 минут

; Имя cookie (по умолчанию PHPSESSID)
session.name = "SID"

; Предотвращение фиксации ID
session.use_strict_mode = 1

; Генерация ID только на старте
session.use_trans_sid = 0

2. Обёртка для работы с сессиями

Создайте класс SessionManager, чтобы централизовать логику:

class SessionManager
{
    public static function start(): void
    {
        if (session_status() === PHP_SESSION_NONE) {
            session_start();
        }
    }

    public static function set(string $key, mixed $value): void
    {
        self::start();
        $_SESSION[$key] = $value;
    }

    public static function get(string $key, mixed $default = null): mixed
    {
        self::start();
        return $_SESSION[$key] ?? $default;
    }

    public static function regenerate(): void
    {
        self::start();
        session_regenerate_id(true);
    }

    public static function destroy(): void
    {
        self::start();
        $_SESSION = [];
        session_destroy();
    }

    public static function isLoggedIn(): bool
    {
        return (bool) self::get('logged_in', false);
    }
}

Использование:

SessionManager::set('user_id', 123);
if (SessionManager::isLoggedIn()) {
    // показать панель пользователя
}

Такой подход упрощает тестирование и замену механизма хранения в будущем.

Тестирование сессий вручную

Перед запуском в продакшен проверьте:

Cookie устанавливаются правильно:
Откройте DevTools → Application → Cookies → убедитесь, что PHPSESSID имеет флаги HttpOnly, Secure (если HTTPS), SameSite=Lax.
ID меняется после входа:
Зайдите на сайт как гость → запомните PHPSESSID → войдите → убедитесь, что ID изменился.
Выход уничтожает сессию:
После выхода cookie должна исчезнуть или стать пустой.
Повторное использование старого ID не работает:
Скопируйте старый PHPSESSID после выхода → попробуйте использовать → должно перенаправить на вход.

Распространённые ошибки даже у опытных разработчиков

Хранение пароля в сессии — даже хеша.
→ Храните только user_id и роль.
Отсутствие session_regenerate_id() после входа.
→ Это открывает дверь для session fixation.
Использование == вместо === при проверке флагов.
→ "1" == true, но "1" !== true.
Забытый exit после header("Location: ...").
→ Скрипт продолжает выполняться, что может привести к утечке данных.
Вывод до session_start().
→ Вызовет ошибку «Cannot send session cookie — headers already sent».