Skip to content

8. Autenticação e autorização

Duas perguntas distintas surgem a cada requisição:

  • Quem é o usuário? Isto é a autenticação: o usuário se identificou com um nome de usuário e uma senha, e cada requisição subsequente deve provar que vem dele;
  • Ele tem permissão para acessar esta página? Isto é a autorização: no estudo de caso, apenas um usuário com o papel ADMIN gerencia médicos e clientes.

A prova de identidade deve acompanhar cada requisição. O [Laravel] normalmente armazena o ID do usuário logado em sua sessão (veja o capítulo sobre escopos), que é a solução mais simples para uma aplicação web. O estudo de caso, em todas as suas versões ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask]), usa em vez disso um token (JWT (*JSON Web Token*)), que usaremos aqui: após o login, o servidor gera um token contendo a identidade do usuário e o assina com uma chave secreta. O token é armazenado em um cookie; o navegador o reenvia a cada requisição; o servidor verifica a assinatura. O usuário pode ler seu token, mas não modificá-lo: qualquer modificação invalida a assinatura. O formato é padronizado (RFC 7519), compreendido por todas as linguagens de programação, e o token inclui sua data de expiração. O mais importante: o servidor não precisa armazenar nada, pois qualquer servidor que conheça a chave pode verificar o token.

O [Laravel] tem um sistema de autenticação completo, cujos componentes usaremos como estão:

  • a autenticação é tratada por um *guard*: um objeto que, a cada requisição, identifica o usuário autenticado. O [Laravel] fornece um guard que lê a sessão; escreveremos o nosso, que lê o token, em poucas linhas. O restante da aplicação enxerga apenas o guard: [auth()->user()], [#[CurrentUser]] e [@auth] nas views;
  • a proteção de páginas é tratada pelo middleware de rota (capítulo anterior): [auth] exige um usuário autenticado, [can:admin] exige uma autorização;
  • as autorizações são descritas por Gates (por exemplo, 26);
  • As senhas passam por hash pela facade [Hash] (com o algoritmo *bcrypt*), e os limites de tentativas são aplicados pela facade [RateLimiter] (exemplo 27).

A geração e a verificação de tokens ficam a cargo da biblioteca [firebase/php-jwt], a mais utilizada em [PHP], instalada pelo arquivo [composer.json] dos exemplos.

8.1. Exemplo 25: Login, token e página protegida

25-jwt/
├── app/
│   ├── Auth/
│   │   ├── AuthService.php
│   │   ├── User.php
│   │   └── UsersService.php
│   └── Http/
│       └── Controllers/
│           ├── AuthController.php
│           └── ProfileController.php
├── bootstrap/
│   └── app.php
├── config/
│   ├── auth.php
│   └── jwt.php
├── resources/
│   └── views/
│       ├── auth/
│       │   └── login.blade.php
│       ├── layout.blade.php
│       └── profile/
│           └── profile.blade.php
├── routes/
│   └── web.php
└── ...

8.1.1. Configuração: .env, config/jwt.php e config/auth.php

O token é assinado com uma chave secreta, que não deve ser escrita diretamente no código. É hora de separar de verdade a configuração do código. As definições específicas de uma instalação ficam no arquivo [.env] (exemplo 01), que agora inclui duas novas linhas:

1
2
3
# a chave que assina os tokens JWT (pelo menos 32 caracteres) e seu tempo de vida
JWT_SECRET=a-secret-key-of-at-least-32-characters-for-example-25
JWT_DURATION_MINUTES=60

O padrão exige, para o algoritmo utilizado (HMAC-SHA256), uma chave de pelo menos 256 bits, ou 32 bytes; a biblioteca rejeita uma chave mais curta. O código, no entanto, não lê o arquivo [.env]: ele lê a configuração da aplicação — um conjunto de arquivos [PHP] armazenados na pasta [config], cada um dos quais retorna um array. Criamos o arquivo [config/jwt.php]:

<?php
// config/jwt.php: a configuração dos tokens JWT, lida por config('jwt.secret')...
// env(NAME, default): a variável NAME do ambiente ou do arquivo .env
return [
    // a chave que assina os tokens (pelo menos 32 caracteres): nunca no código
    'secret' => env('JWT_SECRET'),
    // o tempo de vida de um token, em minutos
    'duration' => (int) env('JWT_DURATION_MINUTES', 60),
    // o nome do cookie que carrega o token
    'cookie' => 'token',
];
  • Linha 6: a função [env] lê uma variável do ambiente do processo ou, na falta dela, do arquivo [.env]; seu segundo parâmetro é um valor padrão. Uma variável de ambiente tem precedência sobre o arquivo: em produção, a chave secreta é fornecida pelo ambiente, e o arquivo [.env] não contém uma;
  • linha 8: as variáveis de ambiente são strings: [(int)] converte a duração em um inteiro.

O código lê esses valores por meio da função [config]: [config('jwt.secret')] refere-se à chave [secret] do arquivo [jwt.php]. [env] só é chamada nos arquivos de configuração: em produção, o comando [php artisan config:cache] reúne toda a configuração em um único arquivo para acelerar o processo, e o [.env] deixa de ser lido. O arquivo [config/auth.php] configura a autenticação:

<?php
// config/auth.php: a autenticação. Este arquivo COMPLETA a configuração padrão
// do Laravel (vendor/laravel/framework/config/auth.php)
return [
    // o "guard" usado por padrão: o que lê o token JWT
    'defaults' => [
        'guard' => 'jwt',
    ],
    'guards' => [
        // um guard com o driver [jwt], definido em bootstrap/app.php (Auth::viaRequest)
        'jwt' => [
            'driver' => 'jwt',
        ],
    ],
];

O [Laravel] tem sua própria configuração de autenticação (o arquivo [vendor/laravel/framework/config/auth.php]; veja o exemplo 01); a configuração da aplicação a complementa: as chaves que ela fornece substituem as do framework, enquanto as demais mantêm seus valores. Declaramos um guard chamado [jwt], com o driver [jwt] (linha 12), e o definimos como guard padrão (linha 7). O driver [jwt] não existe no [Laravel]: nós o definimos em [bootstrap/app.php].

No [Linux] ou no [macOS], iniciaríamos a aplicação com uma chave diferente da seguinte forma:

JWT_SECRET="another-key-of-at-least-thirty-two-characters" php artisan serve

e no [Windows] (PowerShell):

$env:JWT_SECRET="another-key-of-at-least-thirty-two-characters"
php artisan serve

8.1.2. Usuários: app/Auth/User.php e UsersService.php

<?php
// app/Auth/User.php: um usuário. Authenticatable: a interface que
// o Laravel espera dos usuários autenticados

namespace App\Auth;

use Illuminate\Contracts\Auth\Authenticatable;

readonly class User implements Authenticatable
{
    public function __construct(
        public string $login,
        public string $name,
        public string $role,
        // o HASH da senha (vazio para um usuário lido a partir de um token)
        public string $passwordHash = '',
        // o conteúdo do token que autenticou o usuário
        public array $claims = [],
    ) {
    }

    // o identificador do usuário: seu login
    public function getAuthIdentifierName(): string
    {
        return 'login';
    }

    public function getAuthIdentifier(): string
    {
        return $this->login;
    }

    public function getAuthPasswordName(): string
    {
        return 'passwordHash';
    }

    public function getAuthPassword(): string
    {
        return $this->passwordHash;
    }

    // o token "remember me" das sessões: inútil aqui
    public function getRememberToken(): ?string
    {
        return null;
    }

    public function setRememberToken($value): void
    {
    }

    public function getRememberTokenName(): string
    {
        return '';
    }
}
  • Linha 9: um usuário. O [Laravel] espera que os usuários autenticados implementem a interface [Authenticatable]: seus métodos fornecem a ele o ID do usuário, sua senha com hash e o token de sessão “lembrar-me”, desnecessário aqui. Em uma aplicação típica, o modelo [Eloquent] da tabela de usuários (próximo capítulo) implementa isso;
  • linhas 12–18: o login, o nome, o papel, o hash da senha e o conteúdo do token que autenticou o usuário (vazio para um usuário obtido da lista de usuários). Um servidor nunca armazena uma senha, mesmo criptografada: se o banco de dados fosse roubado, as senhas também seriam (e muitas pessoas usam a mesma senha em todo lugar). Ele armazena o resultado de uma função de hash, uma função de mão única: é possível calcular o hash de uma senha, mas não é possível recuperar uma senha a partir de seu hash. Para verificar uma senha digitada, calcula-se seu hash e compara-se com o que está registrado.
<?php
// app/Auth/UsersService.php: os usuários, em memória (o exemplo 28 e
// o estudo de caso os colocarão em um banco de dados)

namespace App\Auth;

class UsersService
{
    // NUNCA guardamos uma senha, apenas seu hash bcrypt, calculado
    // uma vez por todas por: php -r "echo password_hash('marie', PASSWORD_BCRYPT);"
    private const USERS = [
        'marie' => ['Marie Pélissier', 'USER', '$2y$10$2DnOgGBiVcyc07su9rj2E.EvOoyPFzHN/h9PLKDuoW5P7UGtclW6W'],
        'admin' => ['Administrator', 'ADMIN', '$2y$10$m5o9euCi0EdgoZkLVw.UsO58RxJcqhMBfVrlLMCIOh2LyGSjuN29K'],
    ];

    public function find(string $login): ?User
    {
        if (! isset(self::USERS[$login])) {
            return null;
        }
        [$name, $role, $hash] = self::USERS[$login];
        return new User($login, $name, $role, $hash);
    }
}
  • Linhas 11–14: dois usuários de teste, escritos diretamente no programa (o exemplo 28 e o estudo de caso popularão um banco de dados com eles): para cada login, o nome, o papel e o hash da senha. O hash é gerado com o algoritmo bcrypt, projetado para senhas. Ele tem duas características distintivas. É intencionalmente lento, com um nível de lentidão ajustável (o custo, aqui definido como 10: 2^10 ciclos de cálculo, resultando no hash [$10$]): algumas dezenas de milissegundos, imperceptíveis para um usuário, mas que tornam muito custoso para um hacker tentar bilhões de senhas. Ele usa salt: um salt gerado aleatoriamente é misturado à senha antes do hash e armazenado dentro do próprio hash (os 22 caracteres que seguem [$10$]); assim, dois usuários com a mesma senha terão hashes diferentes. Os hashes foram calculados de uma vez por todas pela função [password_hash] do [PHP] (linha 10): calculá-los a cada requisição seria um desperdício desnecessário de tempo, já que a aplicação é reconstruída a cada requisição. O [bcrypt] considera apenas os primeiros 72 bytes de uma senha: o estudo de caso leva isso em conta;
  • Linhas 16–23: o usuário de um login, ou [null]. [isset] verifica a existência de uma chave; a atribuição [[$name, $role, $hash] = ...] desestrutura um array: cada variável recebe o elemento correspondente.

8.1.3. O serviço de autenticação: app/Auth/AuthService.php

<?php
// app/Auth/AuthService.php: a verificação das senhas e dos tokens JWT

namespace App\Auth;

use Firebase\JWT\JWT;
use Firebase\JWT\Key;
use Illuminate\Support\Facades\Hash;
use Throwable;

class AuthService
{
    public function __construct(private UsersService $users)
    {
    }

    // o usuário, ou null se o login for desconhecido ou a senha estiver errada.
    // Hash::check faz o hash da senha digitada com o salt do hash armazenado,
    // depois compara os dois resultados
    public function validate(?string $login, ?string $password): ?User
    {
        if (! $login || $password === null) {
            return null;
        }
        $user = $this->users->find($login);
        if ($user === null || ! Hash::check($password, $user->passwordHash)) {
            return null;
        }
        return $user;
    }

    // o token JWT do usuário, assinado com a chave secreta (HMAC-SHA256)
    public function createToken(User $user): string
    {
        $now = time();
        // o conteúdo do token: as "claims" (declarações sobre o usuário)
        $claims = [
            'sub' => $user->login,
            'name' => $user->name,
            'role' => $user->role,
            'iat' => $now,
            'exp' => $now + config('jwt.duration') * 60,
        ];
        return JWT::encode($claims, config('jwt.secret'), 'HS256');
    }

    // o usuário descrito por um token cuja assinatura e data de expiração
    // são válidas; null caso contrário (token forjado, expirado ou ilegível)
    public function check(string $token): ?User
    {
        try {
            // decode retorna um objeto; (array) o converte em um array associativo
            $claims = (array) JWT::decode($token, new Key(config('jwt.secret'), 'HS256'));
        } catch (Throwable) {
            return null;
        }
        return new User($claims['sub'], $claims['name'], $claims['role'], claims: $claims);
    }
}
  • linhas 20–30: verificação de um nome de usuário e uma senha. [Hash::check] calcula o hash da senha digitada usando o salt do hash armazenado e compara os dois hashes. Um nome de usuário desconhecido e uma senha incorreta produzem o mesmo resultado, [null];
  • linhas 33–45: geração do token. Seu conteúdo é um array de claims sobre o usuário. Alguns têm nomes padronizados: [sub] (*subject*), o identificador do usuário; [iat] (*issued at*), a data de criação; [exp] (*expiration*), a data de expiração. As datas são expressas em segundos decorridos desde 1º de janeiro de 1970 (a função [time()] do [PHP]). Os demais campos são opcionais: aqui, o nome e o papel. [JWT::encode] gera o token e o assina usando o algoritmo [HS256] (HMAC-SHA256, uma assinatura que usa uma chave secreta compartilhada);
  • Linhas 49–58: verificação do token. [JWT::decode] verifica a assinatura e a data de expiração e, em seguida, retorna as claims (um objeto, convertido em array por [(array)]). Qualquer anomalia (token forjado, expirado ou malformado) lança uma exceção; [catch (Throwable)] captura todas elas ([Throwable] é a interface de todas as exceções e erros do [PHP]; o nome da variável é opcional quando ela não é usada). O objeto [Key] associa a chave a um algoritmo: um token que especifique outro algoritmo (ou nenhum, [none]) seria rejeitado. O token válido se torna um [User], sem hash, junto com suas claims (parâmetro chamado [claims]).

8.1.4. O guard: bootstrap/app.php

<?php
// bootstrap/app.php: a aplicação do exemplo 25

use App\Auth\AuthService;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // a rota que serve o Bootstrap (veja o exemplo 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // o token já está assinado: o cookie que o carrega não é criptografado
        $middleware->encryptCookies(except: ['token']);
        // um visitante anônimo que solicita uma página protegida: direto para /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // o driver de guard [jwt] (veja config/auth.php): uma função que recebe a
        // requisição e retorna o usuário autenticado, ou null para um visitante anônimo
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // um cookie presente mas inválido (expirado, token forjado): nós o apagamos
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
    })
    ->create();
  • linha 20: o token já está assinado; o cookie que o transporta não é criptografado (exemplo 22), o que permite examiná-lo;
  • linha 22: o middleware [auth] redirecionará os visitantes anônimos para a página de login;
  • linhas 28–39: [Auth::viaRequest] define um driver de guard por meio de uma função simples: ela recebe a requisição e retorna o usuário autenticado, ou [null] para um visitante anônimo. Ela só é chamada se a aplicação precisar do usuário e, depois que encontra um, o [Laravel] o retém durante toda a requisição (para um visitante anônimo, ela é chamada a cada requisição) (o middleware [auth], [auth()->user()]...). Ela não rejeita nada: ela determina quem é o usuário. Isso é a autenticação. [app(AuthService::class)] solicita um objeto ao contêiner (veja o exemplo 06): a função [app] dá acesso ao contêiner em qualquer lugar;
  • Linhas 34–39: se o navegador enviou um cookie, mas seu token é inválido (expirado ou adulterado), aproveitamos para excluí-lo. [Cookie::forget] cria um cookie vazio que já expirou; [Cookie::queue] o enfileira: o middleware [AddQueuedCookiesToResponse] do grupo [web] o adicionará à resposta, seja qual for essa resposta.

8.1.5. Os controllers

<?php
// app/Http/Controllers/AuthController.php: login e logout

namespace App\Http\Controllers;

use App\Auth\AuthService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class AuthController
{
    public function __construct(private AuthService $auth)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return view('auth.login');
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            // uma mensagem deliberadamente vaga: não dizemos se é o login ou a senha
            return view('auth.login', ['login' => $login,
                'error' => 'Incorrect login or password.']);
        }
        // o token, em um cookie: o JavaScript da página não consegue lê-lo
        // (httpOnly); ele não acompanha as requisições POST vindas de outros sites
        // (sameSite); ele desaparece ao mesmo tempo que o token expira (duração em minutos)
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    // logout: somente POST (um simples link, colocado em outro site, não pode
    // desconectar o usuário sem o seu conhecimento); apagamos o cookie
    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }
}
  • linhas 30–34: o login. Se o login falhar, o formulário é exibido novamente com o nome de usuário digitado e uma mensagem deliberadamente vaga: dizer “nome de usuário desconhecido” revelaria a um hacker quais nomes de usuário existem;
  • linhas 39–41: em caso de sucesso, o token é armazenado em um cookie e o usuário é redirecionado para a página protegida (padrão PRG). O cookie é [httpOnly]: o [JavaScript] da página não consegue lê-lo, o que protege o token contra injeção de scripts (XSS); ele é [sameSite: 'lax']: o navegador não o envia com uma requisição POST originada de outro site, o que protege a aplicação contra ataques CSRF (exemplo 18); sua duração (em minutos) é a mesma do token. Em produção, para HTTPS, adicionaríamos [secure: true]: o cookie nunca seria enviado por uma conexão não criptografada;
  • Linhas 46–49: o logout exclui o cookie ([withoutCookie]). Esta é uma action POST: um simples link para [/logout], colocado em outro site ou dentro de uma imagem, não pode desconectar o usuário sem que ele saiba. Observe uma limitação dos tokens: o próprio token continua válido até expirar. Quem tiver feito uma cópia dele ainda poderia usá-lo. É por isso que sua duração é limitada.
<?php
// app/Http/Controllers/ProfileController.php: uma página reservada a usuários autenticados

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class ProfileController
{
    // #[CurrentUser]: o container fornece o usuário autenticado da requisição,
    // o encontrado pelo guard (veja bootstrap/app.php)
    public function display(#[CurrentUser] User $user): View
    {
        return view('profile.profile', ['user' => $user]);
    }
}
  • Linha 14: o atributo [#[CurrentUser]] solicita ao contêiner o usuário autenticado — aquele encontrado pelo guard (veja o exemplo 12 para os atributos de parâmetro). A action é protegida pelo middleware [auth] (veja a tabela de rotas): ela tem a garantia de receber um usuário. Ele também poderia ser obtido por meio de [auth()->user()] ou [$request->user()].

A tabela de rotas:

<?php
// routes/web.php: as rotas do exemplo 25

use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// o middleware [auth]: a rota só é acessível a um usuário autenticado
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');
  • Linha 14: o middleware [auth] protege a página de perfil. Para um visitante anônimo, ele lança uma exceção [AuthenticationException], que o [Laravel] converte em um redirecionamento para a página de login ([redirectGuestsTo]). [auth] é um alias — um nome curto que o [Laravel] associa ao middleware [Illuminate\Auth\Middleware\Authenticate]. Um grupo de rotas pode ser protegido de uma só vez: [Route::middleware('auth')->group(...)].

8.1.6. As views

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login ?? '' }}" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @isset($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endisset
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • Linha 6: o formulário de login é protegido contra requisições forjadas, como todos os formulários (exemplo 18);
  • linha 9: o login digitado é exibido novamente após uma tentativa malsucedida.
@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- logging out: a POST form reduced to its button --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • Linhas 8–10: o conteúdo do token, exibido para fins ilustrativos;
  • linhas 13–16: o logout, por meio de um formulário reduzido a um único botão.

8.1.7. Execução

Vamos solicitar a página protegida [/profile] sem estar logado:

curl -i http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Content-Type: text/html; charset=utf-8
...

Uma senha incorreta:

Image

Login bem-sucedido. Com o [curl], é preciso primeiro solicitar o formulário para obter o token anti-CSRF e o cookie de sessão (exemplo 18) e, em seguida, enviar o formulário mantendo o cookie recebido:

curl -c token.txt -b token.txt http://localhost:8000/login
curl -i -c token.txt -b token.txt -d "_token=...&login=marie&password=marie" http://localhost:8000/login
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/profile
Set-Cookie: token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNDM5NjgyLCJleHAiOjE3OTA0NDMyODJ9.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw; expires=Sat, 26 Sep 2026 17:21:22 GMT; Max-Age=3600; path=/; httponly; samesite=lax
...

O token é composto de três partes, separadas por pontos, cada uma codificada em Base64: o cabeçalho, o conteúdo e a assinatura. As duas primeiras partes podem ser decodificadas sem nenhuma chave:

{"typ":"JWT","alg":"HS256"}
{"sub":"marie","name":"Marie Pélissier","role":"USER","iat":1790439682,"exp":1790443282}

O tempo de expiração é de uma hora (3.600 segundos) após a criação. No navegador, a página de perfil exibe esse mesmo conteúdo:

Image

Um usuário malicioso modifica seu token: ele substitui o papel [USER]*** no conteúdo por [ADMIN]***, recodifica essa parte em Base64 e mantém a assinatura original. O servidor recalcula a assinatura do conteúdo modificado, que já não confere:

curl -i -b "token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.<modified content>.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw" http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Set-Cookie: token=deleted; expires=Fri, 26 Sep 2025 16:21:27 GMT; Max-Age=0; path=/; httponly; samesite=lax
...

O token forjado é rejeitado e excluído (o valor [deleted] e a data expirada instruem o navegador a excluir o cookie). Para gerar uma assinatura válida, seria preciso conhecer a chave secreta — daí a importância de mantê-la em segredo e de escolher uma chave longa e aleatória.

8.2. Exemplo 26: Papéis

O exemplo 26 adiciona uma página de administração, restrita ao papel ADMIN. Apenas os arquivos novos ou modificados são exibidos.

8.2.1. Uma autorização: bootstrap/app.php

<?php
// bootstrap/app.php: a aplicação do exemplo 26

use App\Auth\AuthService;
use App\Auth\User;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Support\Facades\Gate;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // a rota que serve o Bootstrap (veja o exemplo 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // o token já está assinado: o cookie que o carrega não é criptografado
        $middleware->encryptCookies(except: ['token']);
        // um visitante anônimo que solicita uma página protegida: direto para /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // o driver de guard [jwt] (veja config/auth.php): uma função que recebe a
        // requisição e retorna o usuário autenticado, ou null para um visitante anônimo
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // um cookie presente mas inválido (expirado, token forjado): nós o apagamos
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
        // uma AUTORIZAÇÃO nomeada [admin]: a função recebe o usuário
        // autenticado e diz se ele tem o direito solicitado
        Gate::define('admin', fn (User $user) => $user->role === 'ADMIN');
    })
    ->create();
  • Linha 44: a facade [Gate] (um “portão”) define uma autorização chamada [admin]. A função recebe o usuário autenticado (e, opcionalmente, outros parâmetros: o objeto a ser acessado, por exemplo) e retorna [true] se o usuário tiver a permissão solicitada. Uma permissão pode ser verificada de várias maneiras: [Gate::allows('admin')] ou [Gate::authorize('admin')] (que lança uma exceção, 403) no código, [@can('admin')] nas views e o middleware [can:admin] nas rotas. Para um número maior de regras, o [Laravel] sugere agrupá-las por classe de modelo em policies (*policies*).

8.2.2. A tabela de rotas e o controller

<?php
// routes/web.php: as rotas do exemplo 26

use App\Http\Controllers\AdminController;
use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// o middleware [auth]: a rota só é acessível a um usuário autenticado
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');

// dois middlewares: [auth] (um usuário autenticado), depois [can:admin] (que tem
// a autorização [admin], veja bootstrap/app.php)
Route::get('admin', [AdminController::class, 'display'])->middleware(['auth', 'can:admin']);
  • linha 19: dois middlewares, executados em ordem: [auth] verifica se há um usuário autenticado (caso contrário, redireciona para a página de login) e, em seguida, [can:admin] verifica se o usuário tem a permissão [admin] (caso contrário, um erro 403, *Forbidden*). O texto que segue [:] é o parâmetro do middleware, que o [Laravel] passa a ele após [$next]. A diferença entre as duas respostas de negação é significativa: para um usuário que está autenticado, mas não tem o papel solicitado, fazer login novamente não serviria para nada, já que ele já está autenticado.
<?php
// app/Http/Controllers/AdminController.php: uma página reservada ao papel ADMIN

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class AdminController
{
    public function display(#[CurrentUser] User $user): View
    {
        return view('admin.admin', ['name' => $user->name]);
    }
}

O controller não realiza nenhuma verificação: isso é responsabilidade do middleware. O [Laravel] também permite especificar middlewares diretamente na própria action, por meio de atributos: [#[Middleware('auth')]], [#[Authorize('admin')]].

8.2.3. Views

@extends('layout')
{{-- the page of the 403 error, which Laravel displays by itself: a view
     errors/<code>.blade.php replaces the standard error page of this code --}}

@section('content')
  <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
  <p><a href="/profile">Back to the profile</a></p>
@endsection

A página de erro 403: o [Laravel] procura uma view [errors/<code>.blade.php] quando ocorre um erro HTTP e a exibe no lugar de sua página padrão (veja o capítulo anterior). Não há nada a declarar. A página de perfil fornece um link para a página de administração:

@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  {{-- @can: the block is displayed only if the user has the [admin] authorization --}}
  @can('admin')
    <p><a href="/admin">The administration area</a></p>
  @else
    <p><a href="/admin">The administration area</a> (which is forbidden to you)</p>
  @endcan
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- logging out: a POST form reduced to its button --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • Linhas 7–11: a diretiva [@can] exibe seu bloco apenas se o usuário tiver a permissão; [@else] trata o caso oposto. Isso evita que seja exibido um link que levaria a um erro; no entanto, isso é apenas uma medida de conveniência: a proteção real vem do roteamento.

8.2.4. Execução

Marie, com o papel USER, segue o link para a página de administração:

Image

O administrador, por outro lado, tem acesso a ela:

Image

Com o [curl]: um usuário com o papel USER (o arquivo [token.txt], obtido fazendo login como no exemplo 25, mas no exemplo 26: os dois exemplos assinam seus tokens com chaves diferentes), seguido de um visitante anônimo:

curl -i -b token.txt http://localhost:8000/admin
curl -i http://localhost:8000/admin
HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
...
        <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
...
HTTP/1.1 302 Found
Location: http://localhost:8000/login
...

Proteger as rotas uma a uma tem uma falha: se uma for esquecida, a página se torna acessível a todos. O estudo de caso inverterá essa lógica: todas as rotas são protegidas por padrão por um grupo, e apenas algumas rotas (a página de login, a página de cadastro) são excluídas.

8.3. Exemplo 27: CAPTCHA e limites de tentativas

Um formulário de login é um alvo: um programa pode tentar milhares de senhas por minuto (ataque de força bruta). Duas proteções se complementam:

  • um CAPTCHA (*Completely Automated Public Turing test to tell Computers and Humans Apart*): uma imagem contendo um código distorcido, fácil de ler para um ser humano, mas difícil para um programa;
  • um limite de tentativas: após três tentativas malsucedidas, o endereço IP do cliente é bloqueado por um minuto.

O exemplo 27 se baseia no exemplo 25 e adiciona essas duas medidas de segurança.

8.3.1. A imagem do CAPTCHA: app/Auth/CaptchaDrawing.php

<?php
// app/Auth/CaptchaDrawing.php: o desenho de um captcha, uma imagem SVG (texto XML)
// construída à mão

namespace App\Auth;

class CaptchaDrawing
{
    public const WIDTH = 150;

    public const HEIGHT = 50;

    // A "fonte": cada caractere é uma lista de traços, cada traço uma
    // sequência de pontos x, y em uma grade 4 x 6 (y para baixo).
    // Caracteres fáceis demais de confundir entre si: excluídos (0 O, 1 I L).
    private const FONT = [
        'A' => [[0, 6, 2, 0, 4, 6], [0.8, 3.8, 3.2, 3.8]],
        'B' => [[0, 0, 0, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3], [0, 0, 3, 0, 4, 1, 4, 2, 3, 3]],
        'C' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],
        'D' => [[0, 0, 0, 6, 2.5, 6, 4, 4.5, 4, 1.5, 2.5, 0, 0, 0]],
        'E' => [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],
        'F' => [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],
        'G' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.5, 2.5, 3.5]],
        'H' => [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],
        'J' => [[4, 0, 4, 5, 3, 6, 1, 6, 0, 5]],
        'K' => [[0, 0, 0, 6], [4, 0, 0, 3.5], [1.3, 2.6, 4, 6]],
        'M' => [[0, 6, 0, 0, 2, 3.5, 4, 0, 4, 6]],
        'N' => [[0, 6, 0, 0, 4, 6, 4, 0]],
        'P' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3]],
        'Q' => [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0], [2.5, 4.5, 4, 6.3]],
        'R' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3], [2, 3, 4, 6]],
        'S' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        'T' => [[0, 0, 4, 0], [2, 0, 2, 6]],
        'U' => [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],
        'V' => [[0, 0, 2, 6, 4, 0]],
        'W' => [[0, 0, 1, 6, 2, 2.5, 3, 6, 4, 0]],
        'X' => [[0, 0, 4, 6], [4, 0, 0, 6]],
        'Y' => [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],
        'Z' => [[0, 0, 4, 0, 0, 6, 4, 6]],
        '2' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 0, 6, 4, 6]],
        '3' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1.5, 3], [3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '4' => [[3, 6, 3, 0, 0, 4, 4, 4]],
        '5' => [[4, 0, 0, 0, 0, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '6' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3]],
        '7' => [[0, 0, 4, 0, 1.5, 6]],
        '8' => [[1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1, 3, 0, 4, 0, 5, 1, 6, 3, 6, 4, 5,
            4, 4, 3, 3]],
        '9' => [[4, 3, 1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5]],
    ];

    // algumas cores escuras, fáceis de ler sobre o fundo claro
    private const COLORS = ['#1f4e79', '#7b2d26', '#2e6b30', '#5b2c83', '#8a5a00', '#23395d', '#9c2a5b'];

    // um texto aleatório. random_int é um gerador "criptográfico",
    // imprevisível (ao contrário de rand ou mt_rand, cuja sequência poderia ser adivinhada)
    public static function randomText(int $length): string
    {
        $alphabet = array_keys(self::FONT);
        $text = '';
        for ($i = 0; $i < $length; $i++) {
            $text .= $alphabet[random_int(0, count($alphabet) - 1)];
        }
        return $text;
    }

    // um número de ponto flutuante, aleatório, entre $minimum e $maximum
    private static function random(float $minimum, float $maximum): float
    {
        return $minimum + ($maximum - $minimum) * random_int(0, PHP_INT_MAX) / PHP_INT_MAX;
    }

    private static function color(): string
    {
        return self::COLORS[random_int(0, count(self::COLORS) - 1)];
    }

    public static function svg(string $text): string
    {
        $l = self::WIDTH;
        $h = self::HEIGHT;
        $pieces = ["<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"$l\" height=\"$h\" viewBox=\"0 0 $l $h\">",
            '<rect width="100%" height="100%" fill="#f5f7fa"/>'];

        // os caracteres: cada um ampliado, inclinado, deslocado, e cada ponto
        // levemente movido ao acaso
        $step = ($l - 20) / strlen($text);
        foreach (str_split($text) as $i => $character) {
            $scale = self::random(4.6, 5.6);    // tamanho de uma unidade da grade, em pixels
            $angle = self::random(-0.35, 0.35);   // rotação, em radianos (cerca de ±20°)
            $cx = 10 + $step * ($i + 0.5) + self::random(-3, 3);    // centro do caractere
            $cy = $h / 2 + self::random(-4, 4);
            foreach (self::FONT[$character] as $stroke) {
                $d = [];
                for ($k = 0; $k < count($stroke); $k += 2) {
                    // ponto da grade, centralizado em (2, 3), distorcido, girado, posicionado
                    $x = ($stroke[$k] - 2 + self::random(-0.2, 0.2)) * $scale;
                    $y = ($stroke[$k + 1] - 3 + self::random(-0.2, 0.2)) * $scale;
                    $px = $cx + $x * cos($angle) - $y * sin($angle);
                    $py = $cy + $x * sin($angle) + $y * cos($angle);
                    $d[] = sprintf('%s%.1f %.1f', $k === 0 ? 'M' : 'L', $px, $py);
                }
                $pieces[] = sprintf('<path d="%s" fill="none" stroke="%s" stroke-width="%.1f" '
                    .'stroke-linecap="round" stroke-linejoin="round"/>',
                    implode(' ', $d), self::color(), self::random(2.2, 3));
            }
        }

        // 3 linhas de embaralhamento: curvas que cruzam a imagem
        for ($n = 0; $n < 3; $n++) {
            $pieces[] = sprintf('<path d="M%.1f %.1f C%.1f %.1f %.1f %.1f %.1f %.1f" fill="none" '
                .'stroke="%s" stroke-width="1.3"/>',
                self::random(0, 20), self::random(5, 45), self::random(30, 60), self::random(0, 50),
                self::random(90, 120), self::random(0, 50), self::random(130, 150), self::random(5, 45),
                self::color());
        }
        $pieces[] = '</svg>';
        return implode('', $pieces);
    }
}

A imagem está no formato SVG (*Scalable Vector Graphics*): um gráfico vetorial descrito em XML — ou seja, texto — que o servidor gera sem uma biblioteca gráfica e que o navegador exibe diretamente na página.

  • Linhas 16–49: uma “fonte” minimalista: cada caractere é uma lista de traços, e cada traço é uma lista de coordenadas [x, y] em uma grade de 4 × 6. Os caracteres facilmente confundidos ([0] e [O], [1], [I] e [L]) são excluídos;
  • Linhas 56–64: uma string de texto aleatória, selecionada entre os caracteres da fonte ([array_keys], as chaves da tabela). As funções [rand] e [mt_rand] do [PHP] produzem sequências de números previsíveis (quem conhece alguns valores pode adivinhar os seguintes): são adequadas para simulações, não para segurança. [random_int] é um gerador criptográfico; ele é imprevisível;
  • linhas 67–70: um número de ponto flutuante aleatório, gerado a partir de um inteiro aleatório ([PHP_INT_MAX] é o maior inteiro do [PHP]);
  • linhas 77–118: o desenho. Cada caractere é redimensionado, girado e movido aleatoriamente, e cada um de seus pontos é ligeiramente deslocado; cada traço se torna um elemento [<path>] do SVG ([M]: deslocamento, [L]: linha). Três curvas ([C]: curva de Bézier) atravessam a imagem para atrapalhar os programas de reconhecimento. A função [sprintf] formata uma string: [%s] insere nela uma string e [%.1f] insere um número com uma casa decimal. [str_split] divide uma string em caracteres.

8.3.2. O serviço de CAPTCHA: app/Auth/CaptchaService.php

<?php
// app/Auth/CaptchaService.php: os captchas pendentes, mantidos pelo servidor,
// no cache (veja o exemplo 20)

namespace App\Auth;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;

class CaptchaService
{
    // o tempo de vida de um captcha, em segundos
    private const LIFETIME = 600;

    public function generate(): Captcha
    {
        $text = CaptchaDrawing::randomText(5);
        // um identificador aleatório, impossível de adivinhar
        $id = Str::random(24);
        // a resposta esperada, no cache, por 10 minutos: o cache a esquecerá
        // sozinho depois
        Cache::put("captcha:$id", $text, self::LIFETIME);
        return new Captcha($id, CaptchaDrawing::svg($text));
    }

    // o captcha é CONSUMIDO em todos os casos: uma imagem é usada apenas uma vez
    public function check(?string $id, ?string $answer): bool
    {
        // pull: lê o valor E o remove do cache (null se ele não existir ou tiver expirado)
        $expected = $id ? Cache::pull("captcha:$id") : null;
        if ($expected === null || $answer === null) {
            return false;
        }
        return strcasecmp($expected, trim($answer)) === 0;
    }
}
  • Linhas 15–24: um novo CAPTCHA: texto aleatório, um identificador aleatório impossível de adivinhar ([Str::random] também usa um gerador criptográfico) e a imagem. Para cada identificador, o servidor armazena a resposta esperada no cache (exemplo 20) por dez minutos: [Cache::put(key, value, seconds)]. Depois desse prazo, o cache a descarta automaticamente. A página recebe apenas o identificador e a imagem: a resposta nunca sai do servidor. A classe [Captcha] combina o identificador e a imagem;
  • linhas 27–35: a verificação. [Cache::pull] lê o valor e o remove do cache: o CAPTCHA é consumido em todos os casos, com sucesso ou não. Sem isso, um programa poderia tentar todas as respostas possíveis na mesma imagem. A comparação ignora maiúsculas e minúsculas ([strcasecmp] retorna 0 para duas strings iguais, independentemente de letras maiúsculas ou minúsculas) e os espaços ao redor da entrada ([trim]).

8.3.3. O controller: app/Http/Controllers/AuthController.php

<?php
// app/Http/Controllers/AuthController.php: login (com captcha e limitação de tentativas) e logout

namespace App\Http\Controllers;

use App\Auth\AuthService;
use App\Auth\CaptchaService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\View\View;

class AuthController
{
    // no máximo 3 falhas, por 60 segundos
    private const MAX_FAILURES = 3;

    private const BLOCK_DURATION = 60;

    public function __construct(private AuthService $auth, private CaptchaService $captchas)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return $this->loginPage();
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        // a chave do contador de falhas: o endereço IP do cliente
        $key = 'login:'.$request->ip();

        // 1. um endereço bloqueado nem sequer é ouvido
        if (RateLimiter::tooManyAttempts($key, self::MAX_FAILURES)) {
            $seconds = RateLimiter::availableIn($key);
            return $this->loginPage($login, "Too many attempts: try again in $seconds s.");
        }
        // 2. primeiro o captcha (barato), depois a senha (bcrypt, caro)
        if (! $this->captchas->check($request->input('captchaId'), $request->input('captcha'))) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'The image code is incorrect.');
        }
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'Incorrect login or password.');
        }
        RateLimiter::clear($key);
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }

    // cada exibição do formulário constrói um NOVO captcha
    private function loginPage(?string $login = null, ?string $error = null): View
    {
        return view('auth.login', ['login' => $login, 'error' => $error,
            'captcha' => $this->captchas->generate()]);
    }
}
  • linha 38: o limite é tratado pela facade [RateLimiter] do [Laravel], que conta as “tentativas” sob uma chave no cache. A chave aqui é o endereço IP do cliente;
  • linhas 41–44: um endereço bloqueado nem sequer é ouvido. [tooManyAttempts(key, 3)] é verdadeiro se a chave atingiu 3 tentativas; [availableIn] retorna o número de segundos restantes antes do fim do bloqueio;
  • linhas 46–54: o CAPTCHA é verificado antes da senha; verificá-lo quase não custa nada, ao passo que o [bcrypt] é intencionalmente lento. Um programa que digitasse o CAPTCHA errado, portanto, não acionaria o [bcrypt]. Cada falha — seja do CAPTCHA ou da senha — é contada: [RateLimiter::hit(key, 60)] adiciona uma tentativa e define a duração do contador em 60 segundos. Na terceira falha, o endereço fica, portanto, bloqueado até o fim desses 60 segundos, contados a partir da primeira falha;
  • linha 55: um login bem-sucedido zera as tentativas malsucedidas;
  • linhas 67–71: a cada vez que o formulário é exibido, um novo CAPTCHA é gerado, mesmo após uma tentativa malsucedida.

O [Laravel] também fornece um middleware, [throttle], que limita o número de requisições para uma rota ([->middleware('throttle:5,1')]: 5 requisições por minuto); optamos por contar apenas as tentativas malsucedidas, para não incomodar um usuário que faz login normalmente.

8.3.4. A view: resources/views/auth/login.blade.php

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login }}" required>
    </div>
    <div class="mb-2">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="captcha">Copy the code of the image</label>
      {{-- the SVG image, built by the server: inserted without escaping --}}
      <div class="mb-1">{!! $captcha->svg !!}</div>
      {{-- the captcha identifier travels in a hidden field; the answer stays on the server --}}
      <input type="hidden" name="captchaId" value="{{ $captcha->id }}">
      <input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @if ($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endif
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • Linha 18: a imagem SVG é inserida na página como está, sem escape (exemplo 14). Isso é legítimo: esse HTML foi gerado pelo servidor e não contém nenhuma entrada do usuário;
  • Linha 20: o ID do captcha, em um campo oculto;
  • linha 21: o navegador não sugere nenhuma entrada anterior para esse campo.

8.3.5. Execução

Image

Um código copiado incorretamente:

Image

Após três tentativas malsucedidas, o endereço é bloqueado:

Image

Com o [curl], quatro tentativas usando um ID de CAPTCHA inventado (depois de obter, como no exemplo 25, o cookie de sessão e o token anti-CSRF):

curl -b cookies.txt -d "_token=...&login=marie&password=marie&captchaId=abc&captcha=XXXXX" http://localhost:8000/login
1
2
3
4
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">Too many attempts: try again in 60 s.</div>

Mesmo com a senha correta, a quarta tentativa é rejeitada sem ser processada.