Um Guia Abrangente de Autenticação no Laravel

A autenticação é uma das características mais críticas e essenciais dos aplicativos web. Frameworks web como o Laravel oferecem diversas maneiras para os usuários se autenticarem.

É possível implementar rapidamente os recursos de autenticação do Laravel de forma segura. No entanto, uma implementação inadequada desses recursos pode ser arriscada, já que indivíduos mal-intencionados podem se aproveitar disso.

Este guia ensinará tudo o que você precisa saber para começar com os métodos de autenticação do Laravel de sua escolha.

Continue lendo!

Uma introdução à autenticação no Laravel

O Laravel introduz módulos compostos por “guards” (guardiões) e “providers” (provedores). Os guardiões definem a autenticação do usuário para cada requisição, e os provedores definem a recuperação do usuário a partir de armazenamento persistente (por exemplo, banco de dados MySQL).

Definimos nossos parâmetros de autenticação em um arquivo chamado config/auth.php. Ele inclui várias opções para ajustar e modificar o comportamento de autenticação de Laravel.

Primeiro, você precisa definir os padrões de autenticação. Esta opção controla o “guard” (guardião) de autenticação padrão do seu aplicativo e as opções de redefinição de senha. Você pode alterar esses padrões conforme necessário, mas eles são um ótimo ponto de partida para a maioria dos aplicativos.

Em seguida, você define os guardiões de autenticação para o seu aplicativo. Aqui, nossa configuração padrão utiliza armazenamento de sessão e o provedor de usuário Eloquent. Todos os drivers de autenticação têm um provedor de usuário.

<?php
return [
    /* 
    Defining Authentication Defaults  
    */
    
    'defaults' => [
        'guard' => 'web', 
        'passwords' => 'users',
    ],
    
    /*
    Defining Authentication Guards
   
    Supported: "session"
    */

    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
     ],
    
    /*
    Defining User Providers

    Supported: "database", "eloquent"
    */

    'providers' => [
        'users' => [
             'driver' => 'eloquent',
             'model' => App\Models\User::class,
        ], 

        // 'users' => [
        //     'driver' => 'database',
        //     'table' => 'users',
        // ],
    ],

    /*
    Defining Password Resetting
    */

    'passwords' => [
        'users' => [
            'provider' => 'users',
            'table' => 'password_resets',
            'expire' => 60,
            'throttle' => 60,
         ],
     ],

     /*
     Defining Password Confirmation Timeout
     */

    'password_timeout' => 10800,
];

Mais tarde, garantimos que todos os drivers de autenticação tenham um provedor de usuário. Isso define como os usuários são recuperados do seu banco de dados ou outros mecanismos de armazenamento para persistir os dados do seu usuário. Você pode configurar múltiplas fontes representando cada modelo ou tabela se tiver várias tabelas ou modelos de usuários. Essas fontes podem ser atribuídas a quaisquer guardiões de autenticação extras que você tenha definido.

Os usuários também podem querer redefinir suas senhas. Para isso, você pode especificar múltiplas configurações de redefinição de senha se tiver mais de uma tabela ou modelo de usuário no aplicativo e quiser configurações separadas com base nos tipos específicos de usuário. O tempo de expiração é o número de minutos que cada token de redefinição será válido. Esse recurso de segurança mantém os tokens com vida útil curta, para que tenham menos tempo para serem adivinhados. Você pode alterar isso conforme necessário.

Por fim, você deve definir o tempo antes de uma confirmação de senha expirar, e o usuário é solicitado a reinserir sua senha na tela de confirmação. Por padrão, o tempo de espera dura três horas.

Tipos de métodos de autenticação no Laravel

Não existe uma maneira perfeita de autenticar cada cenário, mas conhecê-los ajudará a tomar decisões melhores. Isso e como o Laravel está evoluindo com as novas funcionalidades no Laravel 9. Isso torna nosso trabalho como desenvolvedores muito mais fácil ao mudar os modos de autenticação.

Autenticação baseada em senha

Como uma forma rudimentar de autenticar um usuário, ele ainda é usado por milhares de organizações, mas considerando o desenvolvimento atual, ele está claramente se tornando ultrapassado.

Os fornecedores devem impor implementações de senhas complexas, garantindo ao mesmo tempo, fricção mínima para o usuário final.

Funciona de forma bem direta, o usuário insere o nome e a senha e, se no banco de dados houver uma correspondência entre os dois, o servidor decide autenticar a solicitação e permite que o usuário acesse os recursos por um tempo predefinido.

Autenticação baseada em tokens

Esta metodologia é usada onde o usuário recebe um token único após a verificação.

Tendo este token, agora o usuário pode acessar recursos relevantes. O privilégio está ativo até que o token expire.

Enquanto o token estiver ativo, o usuário não tem que usar nenhum nome de usuário ou senha, mas ao recuperar um novo token, esses dois são necessários.

Tokens são amplamente utilizados em múltiplos cenários hoje, pois são entidades sem estado que contêm todos os dados de autenticação.

Fornecer uma maneira de separar a geração do token da verificação do token oferece aos fornecedores muita flexibilidade.

Autenticação de múltiplos fatores

Como o nome sugere, isso implica em usar pelo menos dois fatores de autenticação, elevando a segurança que ela proporciona.

Ao contrário da autenticação de dois fatores que envolve apenas dois fatores, este método pode envolver dois, três, quatro, e mais…

A implementação típica deste método envolve o uso de uma senha, após a qual o usuário recebe um código de verificação em seu smartphone. Os fornecedores que implementam este método devem procurar por falsos positivos e quedas de rede, que podem se tornar grandes problemas enquanto aumentam a escala rapidamente.

Como implementar a autenticação no Laravel

Esta seção ensinará várias maneiras de autenticar os usuários do seu aplicativo. Algumas bibliotecas como Jetstream, Breeze e Socialite têm tutoriais gratuitos sobre como usá-las.

Autenticação manual

Começando com o registro de usuários e a criação das rotas necessárias em routes/web.php.

Criaremos duas rotas, uma para visualizar o formulário e outra para registrar:

use App\Http\Controllers\Auth\RegisterController;
use Illuminate\Support\Facades\Route;

/*
Web Routes 

Register web routes for your app's RouteServiceProvider 
in a group containing the "web" middleware
*/

Route::get('/register', [RegisterController::class, 'create']);

Route::post('/register', [RegisterController::class, 'store']);

E criar o controlador necessário para eles:

php artisan make controller Auth/RegisterController -r

Agora atualize o código da seguinte forma:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use illuminate\Htpp\Request;

class RegisterController extends Controller
{
    public function create()
    {
        return view('auth.register');
    }

    public function store(Request $request)
    {
    }
}

O controlador está vazio agora e retorna uma visão para o registro. Vamos criar essa visão em resources/views/auth e chamá-la de register.blade.php.

Agora com tudo no lugar, devemos visitar nossa rota /register e ver o seguinte formulário:

Agora que podemos exibir um formulário que um usuário pode preencher e obter os dados dele, devemos obter os dados dos usuários, validá-los e, em seguida, armazená-los no banco de dados se tudo estiver correto. Aqui, você deve usar uma transação de banco de dados para garantir que os dados inseridos estejam completos.

Usaremos o recurso de validação de requisição do Laravel para garantir que as três credenciais sejam obrigatórias. Precisamos ter certeza de que o e-mail tem um formato de e-mail e é único na tabela users e que a senha é confirmada e tem um mínimo de oito caracteres:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class RegisterController extends Controller
{
    public function store(Request $request)
    {
        /* 
        Validation
        */
        $request->validate([
            'name' => 'required',
            'email' => 'required|email|unique:users',
            'password' => 'required|confirmed|min:8',
        ]);

        /*
        Database Insert
        */
         $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);

        return back();
    }

    public function create()
    {
        return view('auth.register');
    }
}

Agora que nossa entrada foi validada, qualquer coisa que vá contra nossa validação lançará um erro que será exibido no formulário:

Assumindo que tenhamos criado uma conta de usuário no método store, também queremos fazer o login do usuário. Há duas maneiras de fazermos isso. Podemos fazer isso manualmente ou usar Auth facade.

Após o login do usuário, não devemos devolvê-los à tela de Registro, mas sim a uma nova página, como um painel de controle ou página inicial. Isso é o que vamos fazer aqui:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Auth\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;

class RegisterController extends Controller
{
    public function store(Request $request)
    {
        /* 
        Validation
        */
        $request->validate([
            'name' => 'required',
            'email' => 'required|email|unique:users',
            'password' => 'required|confirmed|min:8',
        ]);

        /*
        Database Insert
        */
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);

        Auth::login($user);

        return redirect(RouteServiceProvider::HOME);
    }

    public function create()
    {
        return view('auth.register');
    }
}

E agora que temos um usuário registrado e logado -n, devemos nos certificar de que ele possa sair do site com segurança.

O Laravel sugere que invalidemos a sessão e regeneremos o token por motivos de segurança após o logout. E é exatamente isso que vamos fazer. Começamos criando uma nova rota /logout usando o método destroy do LogoutController:

use App\Http\Controllers\Auth\RegisterController;
use App\Http\Controllers\Auth\LogoutController;
use Illuminate\Support\Facades\Route;

/*
Web Routes

Here is where you can register web routes for your application. These
routes are loaded by the RrouteServiceProvider with a group which
contains the "web" middleware group. Now create something great!
*/

Route::get('/register', [RegisterController::class, 'create']);

Route::post('/register', [RegisterController::class, 'store']);

Route::post('/logout', [Logoutcontroller::class, 'destroy'])
    ->middleware('auth');

Passar o logout através do middleware auth é muito importante. Os usuários devem ser incapazes de acessar a rota se não estiverem logados.

Agora, crie um controlador como fizemos antes:

php artisan make:controller Auth/LogoutController -r

Podemos garantir que recebamos a requisição como um parâmetro no método destroy. Desconectamos o usuário através do Auth facade, invalidamos a sessão e regeneramos o token, depois redirecionamos o usuário para a página inicial:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class LogoutController extends Controller
{
    public function destroy(Request $request)
    { 
        Auth::logout();

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

        $request->session()->regenerateToken();
 
        return redirect('/');
     }
}

Lembrando os usuários

A maioria, senão todos, dos aplicativos web modernos oferece uma opção “lembrar de mim” em seu formulário de login.

Se quisermos fornecer uma funcionalidade “lembrar de mim”, podemos passar um valor booleano como segundo argumento para o método attempt.

Quando válido, Laravel manterá o usuário autenticado indefinidamente ou até que eles sejam desconectados manualmente. A tabela de usuários deve incluir a string remember_token (é por isso que regeneramos os tokens), onde armazenaremos nosso token “lembrar de mim”.

A migração padrão para os usuários já a inclui.

Primeiro, você tem que adicionar o campo Remember Me ao seu formulário:

E depois disso, obtenha as credenciais do pedido e use-as no método de tentativa no Auth facade.

Se o usuário deve ser lembrado, nós o conectaremos e o redirecionaremos para nossa página inicial. Caso contrário, lançaremos um erro:

public function store(Request $request)
{
    $credentials = $request->only('email', 'password');

    if (Auth::attempt($credentials, $request->filled('remember'))) {
        $request->session()->regenerate();
 
        return redirect()->intended('/');
    }

    return back()->withErrors([
    return back()->withErrors([
 'email' => 'The provided credentials do not match our records.',
 ]);
}

Redefinição de senhas

A maioria dos aplicativos web de hoje fornecem maneiras para os usuários redefinirem suas senhas.

Faremos outra rota para a senha esquecida e criaremos o controlador como fizemos. Além disso, adicionaremos uma rota para o link da senha de reset que contém o token para todo o processo:

Route::post('/forgot-password', [ForgotPasswordLinkController::class, 'store']);

Route::post('/forgot-password/{token}', [ForgotPasswordController::class, 'reset']);

Dentro do método “store”, pegaremos o e-mail da requisição e validaremos como fizemos anteriormente.

Após isso, podemos usar o método “sendResetLink ” da facade “password”.

E então, como resposta, queremos retornar o status se teve sucesso em enviar o link ou erros, caso contrário:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Password;

class ForgotPasswordLinkController extends Controller
{
    public function store(Request $request)
    {
        $request->validate([
             'email' => 'required|email',
        ]);

        $status = Password::sendResetLink(
            $request->only('email');
        );

        return $status === Password::RESET_LINK_SENT
            ? back()->with('status', __($status))
            : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]);
     }
}

Agora que o link de redefinição foi enviado para o e-mail do usuário, devemos cuidar da lógica do que acontece depois disso.

Vamos pegar o token, e-mail e a nova senha na requisição e validá-los.

Depois disso, podemos usar o método “reset” da facade “password” para deixar o Laravel cuidar de todo o resto nos bastidores.

Sempre vamos fazer o hash da senha para mantê-la segura.

No final, vamos verificar se a senha foi redefinida, e se foi, redirecionaremos o usuário para a tela de login com uma mensagem de sucesso. Caso contrário, exibiremos um erro informando que não foi possível redefini-la:

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Password;
use Illuminate\Support\Str;

class ForgotPasswordController extends Controller
{
    public function reset(Request $request)
    {
        $request->validate([
            'token' => 'required',
            'email' => 'required|email',
            'password' => 'required|string|confirmed|min:8',
        ]);

        $status = Password::reset(
            $request->only('email', 'password', 'password_confirmation', 'token'),
            function ($user) use ($request) {
                $user->forceFill(
                    'password' => Hash::make($request->password),
                    'remember_token' => Str::random(60)
                ])->save();
            }
        );

        return $status == Password::PASSWORD_RESET
            ? redirect()->route('login')->with('status', __($status))
            : back()->withInput($request->only('email'))->withErrors(['email' => __($status)]);
    }
}

Laravel Breeze

Laravel Breeze é uma implementação simples dos recursos de autenticação Laravel: login, registro, redefinição de senha, verificação de e-mail e confirmação de senha. Você pode usá-lo para implementar a autenticação em seu novo aplicativo Laravel.

Instalação e configuração

Após criar seu aplicativo Laravel, tudo que você tem que fazer é configurar seu banco de dados, executar suas migrações e instalar o pacote Laravel/breeze através do Composer:

composer require laravel/breeze --dev

Após isso, execute o seguinte:

php artisan breeze:install

Isso publicará suas visualizações de autenticação, rotas, controladores e outros recursos que ele usa. Após esta etapa, você tem controle total sobre tudo que o Breeze oferece.

Agora temos que renderizar nosso aplicativo no frontend, então instalaremos nossas dependências JS (que usarão @vite):

npm install

:

npm run dev

Depois disso, os links para login e registro devem estar em sua página inicial, e tudo deve funcionar sem problemas.

Laravel Jetstream

Laravel Jetstream estende o Laravel Breeze com funcionalidades úteis e outras pilhas frontend.

Ele fornece login, registro, verificação de e-mail, autenticação de dois fatores, gerenciamento de sessão, suporte API via Sanctum, e gerenciamento de equipe opcional.

Você deve escolher entre Livewire e Inertia no frontend ao instalar o Jetstream. No backend, ele usa Laravel Fortify, que é um frontend agnóstico, “headless” de autenticação para Laravel.

Instalação e configuração

Vamos instalá-lo através do Composer no nosso Projeto Laravel:

composer require laravel/jetstream

Depois disso, executaremos o comando php artisan jetstream:install [stack], que aceita [stack] argumentos Livewire ou Inertia. Você pode passar a opção --teams para habilitar o recurso de equipes.

Isto também irá instalar o Pest PHP para testes.

E, finalmente, teremos que renderizar o frontend do nosso aplicativo usando o seguinte:

npm install
npm run dev

Laravel Fortify

Laravel Fortify é uma implementação de autenticação de backend que é agnóstica de frontend. Você não precisa usar o Laravel Fortify para implementar funcionalidades de autenticação do Laravel.

Também é usado em kits iniciantes como Breeze e Jetstream. Você também pode usar o Fortify de forma independente, que é apenas uma implementação de backend. Se você usar de forma independente, seu frontend deve chamar as rotas do Fortify.

Instalação e configuração

Podemos instalar o Fortify através do Composer:

composer require laravel/fortify

Agora temos que publicar os recursos do Fortify:

php artisan vendor:publish --provider="Laravel\Fortify\FortifyServiceProvider"

Depois disso, criaremos um novo diretório app/Actions além do novo FortifyServiceProvider, arquivo de configuração e migrações do banco de dados.

Finalmente, execute:

php artisan migrate

Ou:

php artisan migrate:fresh

E seu Fortify está pronto para usar.

Laravel Socialite

Laravel inclui um recurso simples de autenticação de usuário baseado em OAuth. Ele suporta logins sociais via Facebook, Twitter, LinkedIn, Google, Bitbucket, GitHub, e GitLab.

Instalação

Podemos instalá-lo através do Composer:

composer require laravel/socialite

Configuração e uso

Após instalá-lo, temos que adicionar as credenciais para o provedor OAuth que nosso aplicativo utiliza. Adicionaremos em config/services.php para cada serviço.

Na configuração, devemos combinar a chave com os serviços anteriores. Algumas dessas chaves incluem:

• facebook
• twitter (Para OAuth 1.0)
• twitter-oauth-2 (Para o OAuth 2.0)
• linkedin
• google
• github
• gitlab
• bitbucket

Uma configuração de serviço pode se parecer com isso:

'google' => [
    'client_id' => env("GOOGLE_CLIENT_ID"),
    'client_secret' => env("GOOGLE_CLIENT_SECRET"),
    'redirect' => "http://example.com/callback-url",
],

Autenticação de usuários

Para esta ação, precisaremos de duas rotas, uma para redirecionar o usuário para o provedor OAuth:

use Laravel\Socialite\Facades\Sociliate;

Route::get('/auth/redirect', function () {
    return Socialite::driver('google')->redirect();
});

E uma para o callback do provedor após a autenticação:

use Laravel\Socialite\Facades\Socialite;

Route:;get('/auht/callback', function () {
    $user = Socialite::driver('google')->user();

    // Getting the user data
    $user->token;
});

Socialite fornece o método redirect, e a facade redireciona o usuário para o provedor OAuth. Enquanto isso, o método user examina o request recebido e recupera as informações do usuário.

Após obter nosso usuário, temos que verificar se ele existe em nosso banco de dados e autenticá-lo. Se não existir, criaremos um novo registro para representar o usuário:

use App\Models\User;
use Illuminate\Support\Facades\Auth;
use Laravel\Socialite\Facades\Socialite;

Route::get('/auth/callback', function () {
   /*
   Get the user
   */
   $googleUser = Socialite::driver('google')->user();
   
   /*
   Create the user if it does not exist
   Update the user if it exists
   
   Check for google_id in database
   */
   $user = User::updateOrCreate([
       'google_id' => $googleUser->id,
   ], [
       'name' => $googleUser->name,
       'email' => $googleUser->email,
       'google_token' => $googleUser->token,
       'google_refresh_token' => $googleUser->refreshToken,
   ]);

   /*
   Authenticates the user using the Auth facade
   */
    Auth::login($user);
   
    return redirect('/dashboard');
});

Se quisermos limitar o escopo de acesso do usuário, podemos usar o método scopes, que incluiremos com o pedido de autenticação. Isso mesclará todos os escopos previamente especificados com os escopos especificados.

Uma alternativa é usar o método setScopes que sobrescreve todos os outros escopos existentes:

use Laravel\Socialite\Facades\Socialite;

return Socialite::driver('google')
    ->scopes(['read:user', 'write:user', 'public_repo'])
    ->redirect();

return Socialite::driver('google')
    ->setScopes(['read:user', 'public_repo'])
    ->redirect();

Agora que sabemos tudo e como conseguir um usuário após o callback, vamos olhar alguns dos dados que podemos obter a partir dele.

OAuth1 Utilizador tem token e tokenSecret:

$user = Socialite::driver('google')->user();

$token = $user->token;
$tokenSecret = $user->tokenSecret;

OAuth2 fornece token, refreshToken, e expiresIn:

$user = Socialite::driver('google')->user();

$token = $user->token;
$refreshToken = $user->refreshToken;
$expiresIn = $user->expiresIn;

Tanto OAuth1 como OAuth2 fornecem getId, getNickname, getName, getEmail, e getAvatar:

$user = Socialite::driver('google')->user();

$user->getId();
$user->getNickName();
$user->getName();
$user->getEmail();
$user->getAvatar();

E se quisermos obter detalhes de um token (OAuth 2) ou de um token e segredo (OAuth 1), o Socialite fornece dois métodos para isso: userFromToken e userFromTokenAndSecret:

use Laravel\Socialite\Facades\Socialite;

$user = Socialite::driver('google')->userFromToken($token);
$user = Socialite::driver('twitter')->userFromTokenAndSecret($token, $secret);

Laravel Sanctum

Laravel Sanctum é um sistema de autenticação leve para SPAs (Single Page Applications) e aplicativos móveis. Ele permite que os usuários gerem múltiplos tokens de API com escopos específicos.

Uso

Sanctum pode ser usado para emitir tokens de API para o usuário sem as complexidades do OAuth. Esses tokens geralmente têm longos tempos de expiração, mas podem ser revogados e regenerados pelo usuário a qualquer momento.

Instalação e configuração

Podemos instalá-lo via Composer:

composer require laravel/sanctum

Depois, precisamos publicar os arquivos de configuração e migração:

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Após gerar novos arquivos de migração, execute:

php artisan migrate:fresh

Como emitir Tokens API

Antes de emitir tokens, nosso modelo de usuário deve usar o trait LaravelSanctumHasApiTokens:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticable
{
    use HasApiTokens;
}

Quando temos o usuário, podemos emitir um token chamando o método createToken, que retorna uma instância de LaravelSanctumNewAccessToken.

Podemos chamar o método plainTextToken na instância NewAccessToken para ver o valor em texto simples SHA-256 do token.

Dicas e melhores práticas para autenticação no Laravel

Invalidação de sessões em outros dispositivos

Como discutimos anteriormente, invalidar a sessão é crucial quando o usuário faz logout, mas isso também deve estar disponível como uma opção para todos os dispositivos que ele possui.

Essa funcionalidade é geralmente usada quando o usuário muda ou atualiza sua senha e queremos invalidar sua sessão em qualquer outro dispositivo.

Fornecido com a facade Auth, isso é fácil de ser feito. Considerando que a rota que estamos usando tem auth.session middleware, podemos usar o método estático logoutOtherDevices da facade:

Route::get('/logout', [LogoutController::class, 'invoke'])
    ->middleware(['auth', 'auth.session']);

use Illuminate\Support\Facades\Auth;

Auth::logoutOtherDevices($password);

Configuração com Auth::routes()

O método de rotas do Auth facade é apenas um auxiliar para gerar todas as rotas necessárias para a autenticação do usuário.

As rotas incluem Login (Get, Post), Logout (Post), Register (Get, Post) e Password Reset/Email (Get, Post).

Quando você chama o método facade, ele faz o seguinte:

public static function routes(array $options = [])
{
    if (!static::$app->providerIsLoaded(UiServiceProvider::class)) {
        throw new RuntimeException('In order to use the Auth:;routes() method, please install the laravel/ui package.');
    }
   
    static::$app->make('router')->auth($options);
}

Estamos interessados no que acontece quando o método estático é chamado no roteador. Isso pode ser complicado devido à forma como facades funcionam, mas o método seguinte chamado é assim:

/**
Register the typical authentication routes for an application.

@param array $options
@return void
*/
public function auth(array $options = [])
{
    // Authentication Routes...
    $this->get('login', 'Auth\LoginController@showLoginForm')->name('login');
    $this->post('login', 'Auth\LoginController@login');
    $this->post('logout', 'Auth\LoginController@logout')->name('logout');

    // Registration Routes...
    if ($options['register'] ?? true) {
        $this->get('register', 'Auth\RegisterController@showRegistrationForm')->name('register');
        $this->post('register', 'Auth\RegisterController@register');
    }
   
    // Password Reset Routes...
    if ($options['reset'] ?? true) {
        $this->resetPassword();
    }

    // Email Verification Routes...
    if ($options['verify'] ?? false) {
        $this->emailVerification();
    }
}   

Por padrão, ele gera todas as rotas, exceto a de verificação de e-mail. Sempre teremos as rotas de Login e Logout, mas as outras podemos controlar através do array de opções.

Se quisermos ter apenas login/logout e registro, podemos passar o seguinte array de opções:

$options = ["register" => true, "reset" => false, "verify" => false];

Protegendo rotas e guards personalizados

Queremos garantir que algumas rotas só possam ser acessadas por usuários autenticados e isso pode ser feito rapidamente adicionando uma chamada ao método middleware na facade Route ou encadeando o método middleware nela:

Route::middleware('auth')->get('/user', function (Request $request) {
    return $request->user();
});

Route::get('/user', function (Request $request) {
    return $request->user();
})->middleware('auth');

Esse guardião garante que as solicitações recebidas sejam autenticadas.

Confirmação de senha

Para maior segurança adicional do site, muitas vezes você deseja confirmar a senha de um usuário antes de prosseguir com qualquer outra tarefa.

Devemos definir uma rota a partir da visão de confirmação de senha para lidar com a solicitação. Ela irá validar e redirecionar o usuário para seu destino pretendido. Ao mesmo tempo, garantiremos que nossa senha apareça confirmada na sessão. Por padrão, a senha precisa ser reconfirmada a cada três horas, mas isso pode ser alterado no arquivo de configuração em config/auth.php:

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' => ['The provided password does not match our records.']
        ]);
    }

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

    return redirect()->intended();
})->middleware(['auth']);

Contrato autêntico

O contrato Autêntico localizado em IlluminateContracts Auth define um modelo do que a facade UserProvider deve implementar:

namespace Illuminate\Contracts\Auth;

interface Authenticable 
{
    public function getAuthIdentifierName();
    
    public function getAuthIdentifier();
    
    public function getAuthPassord();
  
    public function getRememberToken();

    public function setRememberToken($value);
  
    public function getrememberTokenName();
}

A interface permite que o sistema de autenticação funcione com qualquer classe “usuário” que a implemente.

Isso vale independentemente de qual ORM ou camadas de armazenamento são usadas. Por padrão, o Laravel tem o App\Models\User que implementa essa interface, e isso também pode ser visto no arquivo de configuração:

return [
    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
     ],
];

Eventos de autenticação

Há vários eventos que são disparados durante todo o processo de autenticação.

Dependendo dos seus objetivos, você pode anexar ouvintes a esses eventos no seu EventServiceProvider.

Crie novos usuários rapidamente

A criação de um novo usuário pode ser feita rapidamente através do App\User:

$user = new App\User();
$user->password = Hash::make('strong_password');
$user->email = '[email protected]';
$user->name = 'Username';
$user->save();

Ou através do método de criar estática na facade do usuário:

User::create([
 'password' => Hash::make('strong-password'),
 'email' => '[email protected]',
 'name' => 'username'
]);

Resumo

O ecossistema Laravel possui muitos kits de iniciação para colocar seu aplicativo em funcionamento com um sistema de autenticação, como o Breeze e o Jetstream. Eles são altamente personalizáveis, pois o código é gerado do nosso lado, e podemos modificá-lo o quanto quisermos, usando como um modelo, se necessário.

Há muitas preocupações de segurança em relação à autenticação e suas complexidades, mas todas elas podem ser facilmente resolvidas através das ferramentas que o Laravel oferece. Essas ferramentas são altamente personalizáveis e fáceis de usar.

Implante seus aplicativos Laravel de forma rápida e eficiente com o nosso serviço de hospedagem Laravel. Veja seu aplicativo em ação com um teste gratuito.