Аутентификация

• Введение

  • Стартовые наборы
  • Особенности базы данных
  • Обзор экосистемы

• Быстрый старт аутентификации

  • Установка стартового набора
  • Получение аутентифицированного пользователя
  • Защита маршрутов
  • Ограничение попыток входа

• Ручная аутентификация пользователей

  • Запоминание пользователей
  • Другие методы аутентификации

• HTTP Basic аутентификация

  • Безсессионная HTTP Basic аутентификация

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

  • Аннулирование сессий на других устройствах

• Подтверждение пароля

  • Настройка
  • Маршрутизация
  • Защита маршрутов

• Добавление пользовательских guards

  • Closure Request guards

• Добавление пользовательских провайдеров пользователей

  • Контракт User Provider
  • Контракт Authenticatable

• Социальная аутентификация

• События

#Введение

Многие веб-приложения предоставляют пользователям возможность аутентифицироваться и «входить» в систему. Реализация этой функции может быть сложной и потенциально рискованной задачей. Поэтому Laravel стремится предоставить инструменты для быстрой, безопасной и простой реализации аутентификации.

В основе аутентификации Laravel лежат «guards» и «providers». Guards определяют, как пользователи аутентифицируются при каждом запросе. Например, Laravel поставляется с session guard, который поддерживает состояние с помощью сессий и cookies.

Providers определяют, как пользователи извлекаются из постоянного хранилища. Laravel поддерживает получение пользователей через Eloquent и конструктор запросов к базе данных. Однако вы можете определить дополнительные провайдеры по мере необходимости для вашего приложения.

Файл конфигурации аутентификации вашего приложения находится по пути config/auth.php. В нем содержится несколько хорошо документированных опций для настройки поведения аутентификационных сервисов Laravel.

#Стартовые наборы

Хотите быстро начать? Установите стартовый набор Laravel в свежем приложении Laravel. После миграции базы данных откройте в браузере /register или любой другой URL, назначенный вашему приложению. Стартовые наборы автоматически создадут всю структуру вашей системы аутентификации!

Даже если вы не планируете использовать стартовый набор в конечном приложении, установка Laravel Breeze — отличный способ изучить, как реализованы все функции аутентификации Laravel на практике. Laravel Breeze создает контроллеры, маршруты и представления для аутентификации, что позволяет изучить их код и понять реализацию.

#Особенности базы данных

По умолчанию Laravel включает модель App\Models\User Eloquent в директории app/Models. Эта модель используется с драйвером аутентификации по умолчанию на базе Eloquent. Если ваше приложение не использует Eloquent, можно применить database провайдер аутентификации, который использует конструктор запросов Laravel.

При создании схемы базы данных для модели App\Models\User убедитесь, что столбец пароля имеет длину не менее 60 символов. Миграция таблицы users, включенная в новые приложения Laravel, уже создает столбец с достаточной длиной.

Также проверьте, что в таблице users (или эквивалентной) есть nullable строковый столбец remember_token длиной 100 символов. Этот столбец используется для хранения токена пользователей, выбравших опцию «запомнить меня» при входе. По умолчанию миграция таблицы users уже содержит этот столбец.

#Обзор экосистемы

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

Сначала рассмотрим, как работает аутентификация. При работе через веб‑браузер пользователь вводит имя пользователя и пароль в форме входа. Если учётные данные верны, приложение сохранит информацию об аутентифицированном пользователе в сессии пользователя. Файл cookie, установленный в браузере, содержит идентификатор сессии, чтобы последующие запросы к приложению могли соотнести пользователя с нужной сессией. После получения cookie с идентификатором сессии приложение извлечёт данные сессии по этому идентификатору, обнаружит, что информация об аутентификации сохранена в сессии, и будет считать пользователя «аутентифицированным».

Когда удалённый сервис должен аутентифицироваться для доступа к API, cookies обычно не используются, так как нет браузера. Вместо этого сервис отправляет API-токен с каждым запросом. Приложение проверяет токен по таблице допустимых токенов и «аутентифицирует» запрос от имени пользователя, связанного с этим токеном.

#Встроенные сервисы аутентификации для браузера Laravel

Laravel включает встроенные сервисы аутентификации и сессий, обычно доступные через фасады Auth и Session. Эти функции обеспечивают аутентификацию на основе cookies для запросов из браузера. Они предоставляют методы для проверки учетных данных пользователя и аутентификации. Кроме того, сервисы автоматически сохраняют данные аутентификации в сессии и выдают cookie сессии пользователя. В этой документации описано, как использовать эти сервисы.

Стартовые наборы приложений

Как описано в документации, вы можете вручную работать с этими сервисами для создания собственной системы аутентификации. Однако, чтобы ускорить старт, мы выпустили бесплатные пакеты, которые предоставляют современный и полный каркас для аутентификации. Это Laravel Breeze, Laravel Jetstream и Laravel Fortify.

Laravel Breeze — простая и минималистичная реализация всех функций аутентификации Laravel: вход, регистрация, сброс пароля, подтверждение email и пароля. Представления Breeze состоят из простых Blade шаблонов, стилизованных с помощью Tailwind CSS. Для начала ознакомьтесь с документацией по стартовым наборам приложений.

Laravel Fortify — это backend-аутентификация без UI, реализующая многие функции из этой документации, включая аутентификацию на основе cookies, двухфакторную аутентификацию и подтверждение email. Fortify служит backend-слоем аутентификации для Laravel Jetstream или может использоваться отдельно вместе с Laravel Sanctum для аутентификации SPA.

Laravel Jetstream — мощный стартовый набор, который использует и расширяет сервисы Laravel Fortify с красивым современным UI на базе Tailwind CSS, Livewire и/или Inertia. Jetstream поддерживает двухфакторную аутентификацию, команды, управление сессиями браузера, управление профилем, интеграцию с Laravel Sanctum для API-токенов и многое другое.

#Сервисы аутентификации API Laravel

Laravel предоставляет два дополнительных пакета для управления API-токенами и аутентификации запросов с их помощью: Passport и Sanctum. Обратите внимание, что эти библиотеки и встроенные cookie-базированные сервисы аутентификации Laravel не исключают друг друга. Они ориентированы на разные задачи: API-токены и cookie-базированная аутентификация браузера соответственно. Многие приложения используют оба подхода.

Passport

Passport — это OAuth2 провайдер аутентификации, предлагающий различные типы OAuth2 «грантов» для выдачи токенов. В целом, это мощный и сложный пакет для API-аутентификации. Однако большинству приложений не нужны все возможности OAuth2, что может запутать пользователей и разработчиков. Кроме того, разработчики часто испытывали трудности с аутентификацией SPA или мобильных приложений через OAuth2 провайдеры, такие как Passport.

Sanctum

В ответ на сложность OAuth2 и путаницу среди разработчиков мы создали более простой и удобный пакет аутентификации, который поддерживает как запросы с веб-браузера, так и API-запросы с токенами. Это Laravel Sanctum, который рекомендуется для приложений с собственным веб-интерфейсом и API, SPA, а также мобильных клиентов.

Laravel Sanctum — гибридный пакет для веб и API аутентификации, управляющий всем процессом аутентификации приложения. При получении запроса Sanctum сначала проверяет наличие cookie сессии, ссылающейся на аутентифицированную сессию, вызывая встроенные сервисы аутентификации Laravel. Если сессия отсутствует, Sanctum ищет API-токен и аутентифицирует запрос с его помощью. Подробнее об этом процессе читайте в документации Sanctum "как это работает".

Laravel Sanctum включен в стартовый набор Laravel Jetstream, так как мы считаем его лучшим решением для большинства задач аутентификации веб-приложений.

#Итоги и выбор стека

Итого, если ваше приложение будет использоваться через браузер и представляет собой монолитное Laravel-приложение, оно будет использовать встроенные сервисы аутентификации Laravel.

Если ваше приложение предоставляет API для сторонних клиентов, выберите между Passport и Sanctum для аутентификации API-токенов. В общем случае предпочтение стоит отдавать Sanctum, так как это простое и полное решение для API, SPA и мобильной аутентификации с поддержкой «scopes» или «abilities».

Если вы создаете SPA с backend на Laravel, используйте Laravel Sanctum. При этом вам нужно либо самостоятельно реализовать backend-маршруты аутентификации, либо использовать Laravel Fortify как headless backend с готовыми маршрутами и контроллерами для регистрации, сброса пароля, подтверждения email и прочего.

Passport стоит выбирать, если вашему приложению необходимы все возможности спецификации OAuth2.

Если хотите быстро начать, рекомендуем Laravel Breeze — простой способ создать новое приложение Laravel с нашим предпочтительным стеком аутентификации: встроенными сервисами Laravel и Laravel Sanctum.

#Быстрый старт аутентификации

#Установка стартового набора

Сначала установите стартовый набор Laravel. Наши текущие наборы, Laravel Breeze и Laravel Jetstream, предлагают красиво оформленные отправные точки для добавления аутентификации в новое приложение Laravel.

Laravel Breeze — минималистичная и простая реализация всех функций аутентификации Laravel: вход, регистрация, сброс пароля, подтверждение email и пароля. Представления Breeze состоят из простых Blade шаблонов, стилизованных с помощью Tailwind CSS. Кроме того, Breeze предлагает варианты scaffolding на базе Livewire или Inertia с выбором Vue или React для Inertia.

Laravel Jetstream — более мощный стартовый набор, поддерживающий scaffolding с Livewire или Inertia и Vue. Jetstream включает опциональную поддержку двухфакторной аутентификации, команд, управления профилем, сессиями браузера, API через Laravel Sanctum, удаление аккаунта и многое другое.

#Получение аутентифицированного пользователя

После установки стартового набора и предоставления пользователям возможности регистрироваться и входить, часто нужно взаимодействовать с текущим аутентифицированным пользователем. Во время обработки входящего запроса вы можете получить пользователя через метод user фасада Auth:

use Illuminate\Support\Facades\Auth;

// Получить текущего аутентифицированного пользователя...
$user = Auth::user();

// Получить ID текущего аутентифицированного пользователя...
$id = Auth::id();

Альтернативно, после аутентификации пользователя можно получить через экземпляр Illuminate\Http\Request. Классы с type-hint автоматически внедряются в методы контроллера. Указав Illuminate\Http\Request, вы получите удобный доступ к аутентифицированному пользователю через метод user объекта запроса:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class FlightController extends Controller
{
    /**
     * Обновить информацию о рейсе.
     */
    public function update(Request $request): RedirectResponse
    {
        $user = $request->user();

        // ...

        return redirect('/flights');
    }
}

#Определение, аутентифицирован ли текущий пользователь

Чтобы проверить, аутентифицирован ли пользователь, отправивший HTTP-запрос, используйте метод check фасада Auth. Он вернет true, если пользователь аутентифицирован:

use Illuminate\Support\Facades\Auth;

if (Auth::check()) {
    // Пользователь вошел в систему...
}

#Защита маршрутов

Middleware маршрутов позволяет разрешать доступ к маршруту только аутентифицированным пользователям. Laravel поставляется с middleware auth, который ссылается на класс Illuminate\Auth\Middleware\Authenticate. Поскольку этот middleware уже зарегистрирован в HTTP kernel вашего приложения, достаточно добавить его к определению маршрута:

Route::get('/flights', function () {
    // Доступ к этому маршруту разрешен только аутентифицированным пользователям...
})->middleware('auth');

#Перенаправление неаутентифицированных пользователей

Если middleware auth обнаружит неаутентифицированного пользователя, он перенаправит его на именованный маршрут login. Вы можете изменить это поведение, обновив функцию redirectTo в файле app/Http/Middleware/Authenticate.php вашего приложения:

use Illuminate\Http\Request;

/**
 * Получить путь для перенаправления пользователя.
 */
protected function redirectTo(Request $request): string
{
    return route('login');
}

#Указание guard

При добавлении middleware auth к маршруту можно указать, какой «guard» использовать для аутентификации пользователя. Указанный guard должен соответствовать одному из ключей массива guards в конфигурации auth.php:

Route::get('/flights', function () {
    // Доступ к этому маршруту разрешен только аутентифицированным пользователям...
})->middleware('auth:admin');

#Ограничение попыток входа

Если вы используете Laravel Breeze или Laravel Jetstream стартовые наборы, ограничение частоты запросов автоматически применяется к попыткам входа. По умолчанию пользователь не сможет войти в течение одной минуты, если после нескольких попыток будут введены неверные учётные данные. Ограничение применяется отдельно для имени пользователя/адреса электронной почты и IP-адреса пользователя.

#Ручная аутентификация пользователей

Вам не нужно использовать встроенный аутентификационный каркас из Laravel стартовые наборы приложений. Если вы решите не применять этот каркас, придётся управлять аутентификацией пользователей напрямую с помощью классов аутентификации Laravel. Не переживайте — это проще простого!

Мы будем обращаться к сервисам аутентификации Laravel через Auth фасад, поэтому нужно импортировать Auth фасад вверху класса. Далее посмотрим метод attempt. Метод attempt обычно используется для обработки попыток аутентификации с формы входа в вашем приложении. Если аутентификация успешна, следует регенерировать сессию пользователя, чтобы предотвратить фиксацию сессии:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    /**
     * Обработать попытку аутентификации.
     */
    public function authenticate(Request $request): RedirectResponse
    {
        $credentials = $request->validate([
            'email' => ['required', 'email'],
            'password' => ['required'],
        ]);

        if (Auth::attempt($credentials)) {
            $request->session()->regenerate();

            return redirect()->intended('dashboard');
        }

        return back()->withErrors([
            'email' => 'Предоставленные учетные данные не совпадают с нашими записями.',
        ])->onlyInput('email');
    }
}

Метод attempt принимает массив пар ключ/значение в качестве первого аргумента. Значения в массиве используются для поиска пользователя в таблице базы данных. Таким образом, в приведённом выше примере пользователь будет извлечён по значению столбца email. Если пользователь найден, хешированный пароль, хранящийся в базе данных, будет сравнен со значением password, переданным методу через массив. Не нужно хешировать значение password из входящего запроса, так как фреймворк автоматически захеширует его перед сравнением с хешем пароля в базе данных. Если хеши совпадут, для пользователя начнётся аутентифицированная сессия.

Помните, что сервисы аутентификации Laravel извлекают пользователей из базы согласно настройкам «provider» вашего guard. В конфигурации config/auth.php по умолчанию указан Eloquent провайдер с моделью App\Models\User. Вы можете изменить эти значения в конфигурации под нужды приложения.

Метод attempt возвращает true, если аутентификация прошла успешно, иначе — false.

Метод intended редиректит пользователя на URL, который он пытался открыть до перехвата middleware аутентификации. Можно указать запасной URI на случай, если целевой недоступен.

#Указание дополнительных условий

При желании можно добавить дополнительные условия к запросу аутентификации помимо email и пароля. Для этого просто добавьте условия в массив, передаваемый в метод attempt. Например, можно проверить, что пользователь активен:

if (Auth::attempt(['email' => $email, 'password' => $password, 'active' => 1])) {
    // Аутентификация прошла успешно...
}

Для сложных условий можно передать closure в массив учетных данных. Этот closure будет вызван с экземпляром запроса, что позволит настроить запрос под нужды приложения:

use Illuminate\Database\Eloquent\Builder;

if (Auth::attempt([
    'email' => $email,
    'password' => $password,
    fn (Builder $query) => $query->has('activeSubscription'),
])) {
    // Аутентификация прошла успешно...
}

Метод attemptWhen, принимающий closure вторым аргументом, позволяет более тщательно проверить потенциального пользователя перед аутентификацией. Closure получает пользователя и должен вернуть true или false, разрешая или запрещая аутентификацию:

if (Auth::attemptWhen([
    'email' => $email,
    'password' => $password,
], function (User $user) {
    return $user->isNotBanned();
})) {
    // Аутентификация прошла успешно...
}

#Доступ к конкретным экземплярам guard

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

Имя guard, передаваемое в метод guard, должно соответствовать одному из guard, настроенных в вашем конфигурационном файле auth.php:

if (Auth::guard('admin')->attempt($credentials)) {
    // ...
}

#Запоминание пользователей

Многие веб-приложения предоставляют на форме входа чекбокс "запомнить меня". Если вы хотите реализовать такую функциональность в вашем приложении, вы можете передать булево значение вторым аргументом в метод attempt.

Если это значение true, Laravel будет поддерживать аутентификацию пользователя бессрочно или до тех пор, пока он не выйдет вручную. В вашей таблице users должен быть столбец типа string с именем remember_token, который будет использоваться для хранения токена "запомнить меня". Миграция таблицы users, включённая в новые приложения Laravel, уже содержит этот столбец:

use Illuminate\Support\Facades\Auth;

if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) {
    // Пользователь запоминается...
}

Если ваше приложение поддерживает функциональность "запомнить меня", вы можете использовать метод viaRemember, чтобы определить, был ли текущий аутентифицированный пользователь аутентифицирован с помощью cookie "запомнить меня":

use Illuminate\Support\Facades\Auth;

if (Auth::viaRemember()) {
    // ...
}

#Другие методы аутентификации

#Аутентификация существующего экземпляра пользователя

Если вам нужно установить существующий экземпляр пользователя как текущего аутентифицированного, вы можете передать этот экземпляр в метод login фасада Auth. Переданный экземпляр пользователя должен реализовывать контракт Illuminate\Contracts\Auth\Authenticatable contract. Модель App\Models\User, включённая в Laravel, уже реализует этот интерфейс. Такой способ аутентификации полезен, когда у вас уже есть валидный экземпляр пользователя, например, сразу после регистрации пользователя в вашем приложении:

use Illuminate\Support\Facades\Auth;

Auth::login($user);

Вы можете передать булево значение вторым аргументом в метод login. Это значение указывает, нужна ли функциональность "запомнить меня" для аутентифицированной сессии. Помните, это означает, что сессия будет аутентифицирована бессрочно или до тех пор, пока пользователь не выйдет вручную из приложения:

Auth::login($user, $remember = true);

При необходимости вы можете указать guard аутентификации перед вызовом метода login:

Auth::guard('admin')->login($user);

#Аутентификация пользователя по ID

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

Auth::loginUsingId(1);

Вы можете передать булево значение вторым аргументом в метод loginUsingId. Это значение указывает, нужна ли функциональность "запомнить меня" для аутентифицированной сессии. Помните, это означает, что сессия будет аутентифицирована бессрочно или до тех пор, пока пользователь не выйдет вручную из приложения:

Auth::loginUsingId(1, $remember = true);

#Одноразовая аутентификация пользователя

Вы можете использовать метод once для аутентификации пользователя в приложении только на один запрос. При вызове этого метода не будут использоваться сессии или cookie:

if (Auth::once($credentials)) {
    // ...
}

#Базовая HTTP-аутентификация

Аутентификация HTTP Basic позволяет быстро аутентифицировать пользователей вашего приложения без создания отдельной страницы входа. Чтобы начать, подключите auth.basic middleware к маршруту. auth.basic middleware включён в состав фреймворка Laravel, поэтому вам не нужно его определять:

Route::get('/profile', function () {
    // Доступ к этому маршруту имеют только аутентифицированные пользователи...
})->middleware('auth.basic');

После прикрепления middleware к маршруту, при обращении к нему в браузере вы автоматически получите запрос на ввод учётных данных. По умолчанию middleware auth.basic предполагает, что столбец email в вашей таблице users является "имя пользователя".

#Примечание о FastCGI

Если вы используете PHP FastCGI и Apache для обслуживания вашего приложения Laravel, HTTP Basic аутентификация может работать некорректно. Чтобы исправить эти проблемы, в файл .htaccess вашего приложения можно добавить следующие строки:

RewriteCond %{HTTP:Authorization} ^(.+)$
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

#Базовая HTTP-аутентификация без состояния

Вы также можете использовать HTTP Basic Authentication без установки cookie идентификатора пользователя в сессии. Это особенно полезно, если вы хотите использовать HTTP Authentication для аутентификации запросов к API вашего приложения. Для этого определите middleware, который вызывает метод onceBasic. Если метод onceBasic не возвращает ответ, запрос может быть передан дальше в приложение:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Symfony\Component\HttpFoundation\Response;

class AuthenticateOnceWithBasicAuth
{
    /**
     * Обработать входящий запрос.
     *
     * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
     */
    public function handle(Request $request, Closure $next): Response
    {
        return Auth::onceBasic() ?: $next($request);
    }

}

Далее прикрепите middleware к маршруту:

Route::get('/api/user', function () {
    // Доступ к этому маршруту имеют только аутентифицированные пользователи...
})->middleware(AuthenticateOnceWithBasicAuth::class);

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

Чтобы вручную выйти из приложения, вы можете использовать метод logout фасада Auth. Это удалит информацию об аутентификации из сессии пользователя, чтобы последующие запросы не были аутентифицированы.

Помимо вызова метода logout, рекомендуется инвалидировать сессию пользователя и регенерировать их CSRF токен. После выхода пользователя обычно выполняется перенаправление на корень приложения:

use Illuminate\Http\Request;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Auth;

/**
 * Выйти из приложения.
 */
public function logout(Request $request): RedirectResponse
{
    Auth::logout();

    $request->session()->invalidate();

    $request->session()->regenerateToken();

    return redirect('/');
}

#Инвалидация сессий на других устройствах

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

Перед началом убедитесь, что middleware Illuminate\Session\Middleware\AuthenticateSession подключён к маршрутам, которые должны использовать аутентификацию сессии. Обычно этот middleware добавляют в группу маршрутов, чтобы он применялся к большинству маршрутов приложения. По умолчанию middleware AuthenticateSession можно подключить к маршруту через псевдоним auth.session, определённый в HTTP ядре приложения:

Route::middleware(['auth', 'auth.session'])->group(function () {
    Route::get('/', function () {
        // ...
    });
});

Затем вы можете использовать метод logoutOtherDevices фасада Auth. Этот метод требует подтверждения текущего пароля пользователя, который ваше приложение должно принимать через форму ввода:

use Illuminate\Support\Facades\Auth;

Auth::logoutOtherDevices($currentPassword);

При вызове метода logoutOtherDevices сессии пользователя на других устройствах будут полностью инвалидированы, то есть пользователь будет "вышел" из всех guard, в которых он был аутентифицирован ранее.

#Подтверждение пароля

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

#Настройка

После подтверждения пароля пользователь не будет запрашиваться о подтверждении снова в течение трёх часов. Однако вы можете изменить время, через которое пользователя снова попросят подтвердить пароль, изменив значение password_timeout в конфигурационном файле config/auth.php вашего приложения.

#Маршрутизация

#Форма подтверждения пароля

Сначала определим маршрут, который будет отображать представление с запросом подтверждения пароля:

Route::get('/confirm-password', function () {
    return view('auth.confirm-password');
})->middleware('auth')->name('password.confirm');

Как и ожидалось, возвращаемое этим маршрутом представление должно содержать форму с полем password. Кроме того, вы можете добавить текст, объясняющий, что пользователь входит в защищённую часть приложения и должен подтвердить пароль.

#Подтверждение пароля

Далее определим маршрут, который будет обрабатывать запрос формы из представления "подтверждение пароля". Этот маршрут будет отвечать за проверку пароля и перенаправление пользователя к нужному месту:

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Redirect;

Route::post('/confirm-password', function (Request $request) {
    if (! Hash::check($request->password, $request->user()->password)) {
        return back()->withErrors([
            'password' => ['Введённый пароль не совпадает с нашими записями.']
        ]);
    }

    $request->session()->passwordConfirmed();

    return redirect()->intended();
})->middleware(['auth', 'throttle:6,1']);

Прежде чем продолжить, рассмотрим этот маршрут подробнее. Сначала поле password из запроса проверяется на совпадение с паролем аутентифицированного пользователя. Если пароль верен, необходимо сообщить сессии Laravel, что пользователь подтвердил пароль. Метод passwordConfirmed установит отметку времени в сессии пользователя, которую Laravel использует для определения времени последнего подтверждения пароля. Наконец, пользователя перенаправляют к нужному месту.

#Защита маршрутов

Вы должны убедиться, что любой маршрут, выполняющий действие, требующее недавнего подтверждения пароля, имеет middleware password.confirm. Этот middleware включён в стандартную установку Laravel и автоматически сохраняет в сессии место назначения пользователя, чтобы после подтверждения пароля пользователь мог быть перенаправлен туда. После сохранения места назначения middleware перенаправит пользователя на именованный маршрут password.confirm:

Route::get('/settings', function () {
    // ...
})->middleware(['password.confirm']);

Route::post('/settings', function () {
    // ...
})->middleware(['password.confirm']);

#Добавление пользовательских guard

Вы можете определить собственные guard аутентификации с помощью метода extend фасада Auth. Вызов метода extend следует разместить в service provider. Поскольку Laravel уже поставляется с AuthServiceProvider, мы можем добавить код в этот провайдер:

<?php

namespace App\Providers;

use App\Services\Auth\JwtGuard;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Auth;

class AuthServiceProvider extends ServiceProvider
{
    /**
     * Зарегистрировать сервисы аутентификации / авторизации приложения.
     */
    public function boot(): void
    {
        Auth::extend('jwt', function (Application $app, string $name, array $config) {
            // Вернуть экземпляр Illuminate\Contracts\Auth\Guard...

            return new JwtGuard(Auth::createUserProvider($config['provider']));
        });
    }
}

Как видно из примера выше, callback, передаваемый в метод extend, должен возвращать реализацию Illuminate\Contracts\Auth\Guard. Этот интерфейс содержит несколько методов, которые необходимо реализовать для определения пользовательского guard. После определения вашего guard вы можете указать его в конфигурации guards файла auth.php:

'guards' => [
    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    ],
],

#Guard на основе замыкания для HTTP-запросов

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

Для начала вызовите метод Auth::viaRequest в методе boot вашего AuthServiceProvider. Метод viaRequest принимает имя драйвера аутентификации в качестве первого аргумента. Это имя может быть любой строкой, описывающей ваш пользовательский guard. Вторым аргументом передаётся замыкание, которое принимает входящий HTTP-запрос и возвращает экземпляр пользователя или null, если аутентификация не удалась:

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

/**
 * Зарегистрировать сервисы аутентификации / авторизации приложения.
 */
public function boot(): void
{
    Auth::viaRequest('custom-token', function (Request $request) {
        return User::where('token', (string) $request->token)->first();
    });
}

После определения пользовательского драйвера аутентификации вы можете настроить его как драйвер в конфигурации guards файла auth.php:

'guards' => [
    'api' => [
        'driver' => 'custom-token',
    ],
],

Наконец, вы можете указать этот guard при назначении middleware аутентификации маршруту:

Route::middleware('auth:api')->group(function () {
    // ...
});

#Добавление пользовательских провайдеров пользователей

Если вы не используете традиционную реляционную базу данных для хранения пользователей, вам потребуется расширить Laravel собственным провайдером пользователей для аутентификации. Мы будем использовать метод provider фасада Auth для определения пользовательского провайдера пользователей. Резолвер провайдера должен возвращать реализацию Illuminate\Contracts\Auth\UserProvider:

<?php

namespace App\Providers;

use App\Extensions\MongoUserProvider;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Auth;

class AuthServiceProvider extends ServiceProvider
{
    /**
     * Зарегистрировать сервисы аутентификации / авторизации приложения.
     */
    public function boot(): void
    {
        Auth::provider('mongo', function (Application $app, array $config) {
            // Вернуть экземпляр Illuminate\Contracts\Auth\UserProvider...

            return new MongoUserProvider($app->make('mongo.connection'));
        });
    }
}

После регистрации провайдера с помощью метода provider вы можете переключиться на нового провайдера в конфигурационном файле auth.php. Сначала определите provider, использующий ваш новый драйвер:

'providers' => [
    'users' => [
        'driver' => 'mongo',
    ],
],

Наконец, вы можете указать этого провайдера в конфигурации guards:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
],

#Контракт User Provider

Реализации Illuminate\Contracts\Auth\UserProvider отвечают за получение реализации Illuminate\Contracts\Auth\Authenticatable из постоянного хранилища, такого как MySQL, MongoDB и т.д. Эти два интерфейса позволяют механизмам аутентификации Laravel работать независимо от способа хранения данных пользователя и типа класса, используемого для представления аутентифицированного пользователя:

Рассмотрим контракт Illuminate\Contracts\Auth\UserProvider:

<?php

namespace Illuminate\Contracts\Auth;

interface UserProvider
{
    public function retrieveById($identifier);
    public function retrieveByToken($identifier, $token);
    public function updateRememberToken(Authenticatable $user, $token);
    public function retrieveByCredentials(array $credentials);
    public function validateCredentials(Authenticatable $user, array $credentials);
}

Функция retrieveById обычно принимает ключ, идентифицирующий пользователя, например, автоинкрементный ID из базы MySQL. Метод должен получить и вернуть реализацию Authenticatable, соответствующую этому ID.

Функция retrieveByToken получает пользователя по уникальному $identifier и токену "запомнить меня" $token, обычно хранящемуся в столбце базы данных remember_token. Как и в предыдущем методе, должен быть возвращён объект Authenticatable с соответствующим значением токена.

Метод updateRememberToken обновляет у экземпляра $user поле remember_token новым значением $token. Новый токен присваивается пользователям при успешной аутентификации с "запомнить меня" или при выходе пользователя из системы.

Метод retrieveByCredentials получает массив учётных данных, переданных в метод Auth::attempt при попытке аутентификации. Метод должен выполнить "запрос" к постоянному хранилищу для поиска пользователя, соответствующего этим учётным данным. Обычно это запрос с условием "where", который ищет запись пользователя с "username", совпадающим со значением $credentials['username']. Метод должен вернуть реализацию Authenticatable. Этот метод не должен выполнять проверку пароля или аутентификацию.

Метод validateCredentials должен сравнить переданного $user с $credentials для аутентификации пользователя. Например, этот метод обычно использует Hash::check для сравнения значения $user->getAuthPassword() с $credentials['password']. Метод должен возвращать true или false, указывая, валиден ли пароль.

#Контракт Authenticatable

Теперь, когда мы рассмотрели методы UserProvider, давайте посмотрим на контракт Authenticatable. Помните, что провайдеры пользователей должны возвращать реализации этого интерфейса из методов retrieveById, retrieveByToken и retrieveByCredentials:

<?php

namespace Illuminate\Contracts\Auth;

interface Authenticatable
{
    public function getAuthIdentifierName();
    public function getAuthIdentifier();
    public function getAuthPassword();
    public function getRememberToken();
    public function setRememberToken($value);
    public function getRememberTokenName();
}

Этот интерфейс простой. Метод getAuthIdentifierName должен возвращать имя поля "первичного ключа" пользователя, а метод getAuthIdentifier — значение этого "первичного ключа". При использовании MySQL это обычно автоинкрементный первичный ключ записи пользователя. Метод getAuthPassword должен возвращать хешированный пароль пользователя.

Этот интерфейс позволяет системе аутентификации работать с любым классом "пользователя", независимо от используемого ORM или слоя абстракции хранения. По умолчанию Laravel включает класс App\Models\User в директории app/Models, который реализует этот интерфейс.

#События

Laravel генерирует множество событий в процессе аутентификации. Вы можете прикреплять слушателей к этим событиям в вашем EventServiceProvider:

/**
 * Отображение сопоставления слушателей событий для приложения.
 *
 * @var array
 */
protected $listen = [
    'Illuminate\Auth\Events\Registered' => [
        'App\Listeners\LogRegisteredUser',
    ],

    'Illuminate\Auth\Events\Attempting' => [
        'App\Listeners\LogAuthenticationAttempt',
    ],

    'Illuminate\Auth\Events\Authenticated' => [
        'App\Listeners\LogAuthenticated',
    ],

    'Illuminate\Auth\Events\Login' => [
        'App\Listeners\LogSuccessfulLogin',
    ],

    'Illuminate\Auth\Events\Failed' => [
        'App\Listeners\LogFailedLogin',
    ],

    'Illuminate\Auth\Events\Validated' => [
        'App\Listeners\LogValidated',
    ],

    'Illuminate\Auth\Events\Verified' => [
        'App\Listeners\LogVerified',
    ],

    'Illuminate\Auth\Events\Logout' => [
        'App\Listeners\LogSuccessfulLogout',
    ],

    'Illuminate\Auth\Events\CurrentDeviceLogout' => [
        'App\Listeners\LogCurrentDeviceLogout',
    ],

    'Illuminate\Auth\Events\OtherDeviceLogout' => [
        'App\Listeners\LogOtherDeviceLogout',
    ],

    'Illuminate\Auth\Events\Lockout' => [
        'App\Listeners\LogLockout',
    ],

    'Illuminate\Auth\Events\PasswordReset' => [
        'App\Listeners\LogPasswordReset',
    ],
];