Вы открываете приложение на Laravel и видите страницу входа.

Вы вводите свой email и пароль.

✅ Вход выполнен успешно.

Теперь представьте, что вы —  сотрудник в системе управления для администраторов.

Вы можете просматривать собственный профиль и задачи.

Но когда вы пытаетесь открыть:

/admin/users

Laravel говорит:

 403 | This action is unauthorized.

В этот момент вы можете задаться вопросом:

 «Я уже вошел в систему. Почему у меня нет доступа к этой странице?»

Ответ кроется в двух концепциях:

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

Звучит похоже, но они решают совершенно разные задачи.

Давайте разберем их на реальном примере из Laravel.

Аутентификация: «Кто ты?»

Аутентификация — это  установление личности пользователя.

Простыми словами:

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

Например:

Email: mrchauhan@example.com
Password: ********

Laravel проверяет учетные данные.

Если они верны:

User authenticated ✅

Если они неверны:

Authentication failed ❌

Типичные задачи аутентификации включают:

  • Вход в систему (Login)
  • Выход из системы (Logout)
  • Регистрация
  • Сброс пароля
  • Подтверждение email
  • Запомнить меня (Remember me)
  • Аутентификация по API-токену

Авторизация: «Что тебе разрешено делать?»

Теперь предположим, что пользователь успешно вошел в систему.

Аутентификация завершена.

Но Laravel все еще должен спросить:

 Что этому пользователю разрешено делать?

Например:

Admin
  → Manage users
  → Delete users
  → View reports

Team Lead
  → Manage team tasks
  → View team members

Employee
  → View own tasks
  → Update own profile

Это и есть  авторизация.

Самый простой способ запомнить разницу:

Authentication = Who are you?
Authorization = What can you do?

Простой пример из реальной жизни

Представьте, что вы входите в офис.

На входе охрана проверяет ваш пропуск.

Это:

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

Пройдя внутрь, вы пытаетесь зайти в серверную.

Охрана проверяет, есть ли у вас на это право.

Это:

 Авторизация

Вы можете быть законным сотрудником компании, но при этом не иметь доступа в серверную.

Точно такая же концепция применяется и в приложениях на Laravel.

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

Laravel предоставляет возможности аутентификации через свою встроенную систему и стартовые наборы (starter kits).

Распространенная проверка:

if (auth()->check()) {
    // User is authenticated
}

Вы можете получить текущего авторизованного пользователя с помощью:

$user = auth()->user();

Или:

$request->user();

Например:

$user = $request->user();

return response()->json([
    'name' => $user->name,
]);

Защита маршрутов с помощью аутентификации

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

Route::get('/dashboard', function () {
    return view('dashboard');
});

Любой может получить доступ к этому маршруту, если мы его не защитим.

Добавьте middleware auth:

Route::middleware('auth')->group(function () {
  Route::get('/dashboard', function () {
        return view('dashboard');
    });
});

Теперь Laravel проверяет:

Request
   ↓
Is user authenticated?
   ↓
Yes → Continue
No  → Redirect / Reject

Это  аутентификация, а не авторизация.

Где разработчики часто путаются

Рассмотрим такой маршрут:

Route::middleware('auth')
    ->delete('/users/{user}', [UserController::class, 'destroy']);

Middleware auth отвечает только на один вопрос:

«Пользователь вошел в систему?»

Он  не отвечает на вопрос:

«Есть ли у этого пользователя право удалить данного пользователя?»

Это задача авторизации.

Для этого вам понадобится другой уровень.

Авторизация в Laravel

Laravel предоставляет несколько способов реализации авторизации.

Наиболее распространенные подходы:

Gates
Policies
Middleware
Role / Permission systems

Для авторизации на уровне приложения  политики (Policies) особенно полезны, когда права связаны с конкретной моделью.

Пример: Управление пользователями

Предположим, в нашем приложении есть:

Admin
Team Lead
Employee

И у нас есть UserPolicy.

Мы хотим разрешить удаление пользователей только администраторам.

Создаем политику:

php artisan make:policy UserPolicy --model=User

Затем:

class UserPolicy
{
    public function delete(User $user, User $target): bool
    {
        return $user->is_admin;
    }
}

Теперь Laravel может спросить:

Can the current user delete this user?

Использование авторизации в контроллере

Например:

public function destroy(User $user)
{
    $this->authorize('delete', $user);
    
    $user->delete();
    
    return response()->json([
        'message' => 'User deleted successfully.',
    ]);
}

Вот что происходит:

User logged in?
        ↓
      YES
        ↓
Can user delete this user?
        ↓
      YES
        ↓
Delete user

Если авторизация не проходит:

403 Forbidden

Аутентификация и авторизация в рамках одного запроса

Давайте объединим все вместе.

Представьте запрос:

DELETE /users/25

Laravel может обработать его следующим образом:

HTTP Request
     ↓
Authentication
     ↓
Is user logged in?
     ↓
    YES
     ↓
Authorization
     ↓
Can this user delete User #25?
     ↓
    YES
     ↓
Controller
     ↓
Delete User #25

Если аутентификация не удалась:

401 Unauthorized

Если аутентификация прошла успешно, но авторизация не удалась:

403 Forbidden

Это различие чрезвычайно важно.

401 против 403

Разработчики часто путают эти два HTTP-статуса.

401 — Не аутентифицирован (Unauthenticated)

Пользователь  не был должным образом аутентифицирован.

Например:

API request without a valid token

Приложение не знает, кто вы.

403 — Доступ запрещен (Forbidden)

Пользователь аутентифицирован, но  не имеет необходимых прав.

Например:

Employee trying to access admin-only functionality

Laravel знает, кто вы.

У вас просто нет разрешений на выполнение этого действия.

Итак:

401 → Who are you? We can't authenticate you.
403 → We know who you are, but you're not allowed.

Аутентификация с помощью Sanctum

Laravel Sanctum обычно используется для аутентификации в API.

Например:

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::get('/tasks', [TaskController::class, 'index']);
});

Этот middleware проверяет, аутентифицирован ли запрос к API.

Например:

Authorization: Bearer <token>

Если токен валиден:

Authenticated ✅

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

Вам все еще нужна авторизация.

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

Представьте API для управления задачами сотрудников.

У нас есть:

Admin
Team Lead
Employee

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

Does the request contain a valid authenticated user?

Авторизация:

Is this user allowed to update this task?

Например:

public function update(Task $task)
{
    $this->authorize('update', $task);

    // Update task...
}

Ваша политика может содержать:

public function update(User $user, Task $task): bool
{
    return $user->id === $task->assigned_to
        || $user->hasRole('Team Lead')
        || $user->hasRole('Admin');
}

Теперь система становится гораздо безопаснее.

Gates против Policies

В Laravel также есть механизм  Gates (Врата).

Gate удобен для логики авторизации, которая не обязательно привязана к конкретной модели.

Например:

Gate::define('view-admin-dashboard', function (User $user) {
    return $user->is_admin;
});

Затем:

if (Gate::allows('view-admin-dashboard')) {
    // Show dashboard
}

Простое правило для выбора:

Gate
→ General authorization rule

Policy
→ Authorization related to a model/resource

Например:

Can this user view the admin dashboard?
→ Gate

Can this user update this Task?
→ Policy

Как насчет ролей и разрешений?

В крупных приложениях авторизация часто становится более детализированной.

Вместо простого вопроса:

Is admin?

у вас могут быть конкретные права, такие как:

users.view
users.create
users.update
users.delete

tasks.view
tasks.create
tasks.update
tasks.delete

Затем пользователям могут назначаться роли:

Admin
    ↓
All permissionsTeam Lead
    ↓
tasks.view
tasks.create
tasks.update
Employee
    ↓
tasks.view
tasks.update

Пакеты вроде  Spatie Laravel Permission обычно используются для управления ролями и разрешениями в приложениях на Laravel.

Например:

if ($user->can('tasks.update')) {
    // Update task
}

Это и есть авторизация.

При этом пользователь все равно должен быть сначала аутентифицирован.

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

Пожалуй, это самый важный урок.

Представьте:

User successfully logs in ✅

Это значит:

Аутентификация успешно пройдена.

Это  не значит:

Delete any user ✅
View financial reports ✅
Access admin panel ✅
Modify system settings ✅

Это уже вопросы авторизации.

Думайте об этом так:

LOGIN
  ↓
Authentication
  ↓
"Who is this?"
  ↓
Authorization
  ↓
"What is this person allowed to do?"

Распространенная ошибка безопасности

Рассмотрим код:

public function delete(User $user)
{
    $user->delete();
}

Маршрут уже может использовать:

auth

Поэтому разработчик думает:

«Только авторизованные пользователи могут добраться сюда».

Этого недостаточно.

Любой аутентифицированный пользователь потенциально может удалить ресурс, если не настроена дополнительная авторизация.

Лучший подход:

public function delete(User $user)
{
    $this->authorize('delete', $user);
    
    $user->delete();
}

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

Авторизация определяет, что ему разрешено делать внутри.

Жизненный цикл в Laravel

Хорошо спроектированное приложение на Laravel следует такому алгоритму:

Request
                       ↓
                Authentication
                       ↓
              Is user authenticated?
                 ↙           ↘
               NO             YES
               ↓               ↓
              401        Authorization
                               ↓
                     Is action allowed?
                         ↙       ↘
                       NO         YES
                       ↓           ↓
                      403      Controller
                                   ↓
                                Response

Понимание этого цикла делает работу с безопасностью в Laravel намного понятнее.

Заключение

Аутентификация и авторизация — это два разных уровня безопасности.

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

 «Кто ты?»

 Авторизация отвечает на вопрос:

 «Что тебе разрешено делать?»

В Laravel вы можете использовать:

Authentication
→ auth middleware
→ Sanctum
→ Sessions
→ Login systems

Authorization
→ Gates
→ Policies
→ Middleware
→ Roles & Permissions

Безопасному приложению на Laravel нужны оба этих механизма.

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

И это простое различие может предотвратить очень серьезные проблемы с безопасностью.

Запомните

Authentication = Identity
Authorization  = Permission

401 = Not authenticated
403 = Not authorized

Как только это станет понятным, встроенный middleware аутентификации в Laravel, Gates, Policies, Sanctum и системы прав начнут работать в слаженной системе.

Успешного кодинга! 🚀

— Mr. Chauhan