Conceptos de autenticación

¿Qué es autenticación vs autorización?

Estos dos conceptos se confunden frecuentemente, pero son diferentes:

• Autenticación: ¿Quién eres? Verificar la identidad del usuario (login)
• Autorización: ¿Qué puedes hacer? Verificar permisos (veremos esto en la lección 31)

Primero autenticas al usuario (confirmas que es quien dice ser), luego autorizas sus acciones (decides qué puede o no puede hacer).

Cómo funciona la autenticación web

El flujo típico de autenticación en una aplicación web es:

1. El usuario envía sus credenciales (email y contraseña)
2. El servidor verifica las credenciales contra la base de datos
3. Si son correctas, crea una sesión y envía una cookie al navegador
4. En cada petición posterior, el navegador envía la cookie
5. El servidor lee la cookie y sabe quién es el usuario

Laravel abstrae todo esto. Tú solo llamas a métodos como Auth::attempt() o Auth::login() y el framework hace el resto.

Configuración de autenticación

La configuración está en config/auth.php. Veamos los conceptos principales:

<?php

// config/auth.php

return [
    // Guard por defecto
    'defaults' => [
        'guard' => 'web',
        'passwords' => 'users',
    ],

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

    // Providers (de dónde obtener usuarios)
    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
    ],
];

Guards: quién protege las rutas

Un guard define cómo se autentican los usuarios. El guard por defecto es web, que usa sesiones.

Piensa en un guard como un vigilante: decide cómo verificar la identidad de alguien. Diferentes guardias pueden tener diferentes métodos:

• session: Usa cookies y sesiones (aplicaciones web tradicionales)
• token: Usa tokens en las peticiones (APIs simples)
• sanctum: Para SPAs y APIs (lo veremos más adelante)

Para la mayoría de aplicaciones web, el guard web con driver session es lo que necesitas.

Providers: de dónde vienen los usuarios

Un provider define cómo se obtienen los usuarios de tu sistema de almacenamiento. Por defecto usa Eloquent con el modelo User.

Laravel busca usuarios en la tabla definida en el modelo User. La migración por defecto crea la tabla users con los campos necesarios:

<?php

// database/migrations/0001_01_01_000000_create_users_table.php

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamp('email_verified_at')->nullable();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
});

El modelo User

Laravel incluye un modelo User preconfigurado que implementa los contratos necesarios para autenticación:

<?php

declare(strict_types=1);

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    protected $hidden = [
        'password',
        'remember_token',
    ];

    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
        ];
    }
}

El modelo extiende Authenticatable (no Model directamente), lo que le da los métodos necesarios para el sistema de autenticación.

El facade Auth

El facade Auth es tu interfaz principal para interactuar con el sistema de autenticación:

<?php

use Illuminate\Support\Facades\Auth;

// Verificar si hay usuario autenticado
if (Auth::check()) {
    // Usuario logueado
}

// Obtener el usuario actual
$user = Auth::user();

// Obtener solo el ID del usuario
$id = Auth::id();

// Verificar si NO hay usuario autenticado
if (Auth::guest()) {
    // Visitante no autenticado
}

Autenticar usuarios manualmente

Aunque en la siguiente lección usaremos Laravel Breeze (que maneja todo automáticamente), es útil entender cómo funciona la autenticación manual:

<?php

declare(strict_types=1);

namespace App\Http\Controllers;

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

class LoginController extends Controller
{
    public function login(Request $request): RedirectResponse
    {
        $credentials = $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);

        // Intentar autenticar
        if (Auth::attempt($credentials)) {
            // Regenerar sesión para prevenir session fixation
            $request->session()->regenerate();

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

        // Credenciales incorrectas
        return back()->withErrors([
            'email' => 'Las credenciales no coinciden.',
        ])->onlyInput('email');
    }
}

El método Auth::attempt():

• Busca un usuario con el email proporcionado
• Compara la contraseña hasheada
• Si coincide, inicia sesión automáticamente
• Retorna true o false

Recordar usuario (Remember Me)

Para mantener al usuario autenticado incluso después de cerrar el navegador, usa el segundo parámetro de attempt():

<?php

$remember = $request->boolean('remember');

if (Auth::attempt($credentials, $remember)) {
    // Usuario autenticado con "recuérdame"
}

Esto crea una cookie de larga duración que permite reautenticar al usuario automáticamente. La columna remember_token en la tabla users almacena el token necesario.

Cerrar sesión (Logout)

Para cerrar la sesión de un usuario:

<?php

public function logout(Request $request): RedirectResponse
{
    Auth::logout();

    // Invalidar la sesión
    $request->session()->invalidate();

    // Regenerar el token CSRF
    $request->session()->regenerateToken();

    return redirect('/');
}

Acceder al usuario en vistas

En las plantillas Blade puedes usar las directivas de autenticación:

{{-- Contenido solo para usuarios autenticados --}}
@auth
    <p>Hola, {{ auth()->user()->name }}</p>
    <a href="{{ route('logout') }}">Cerrar sesión</a>
@endauth

{{-- Contenido solo para invitados --}}
@guest
    <a href="{{ route('login') }}">Iniciar sesión</a>
    <a href="{{ route('register') }}">Registrarse</a>
@endguest

También puedes usar el helper auth():

@if(auth()->check())
    <p>ID del usuario: {{ auth()->id() }}</p>
    <p>Email: {{ auth()->user()->email }}</p>
@endif

Hashear contraseñas

Laravel usa Bcrypt por defecto para hashear contraseñas. Nunca almacenes contraseñas en texto plano:

<?php

use Illuminate\Support\Facades\Hash;

// Hashear una contraseña
$hashed = Hash::make('mi-contraseña-secreta');

// Verificar una contraseña
if (Hash::check('mi-contraseña-secreta', $hashed)) {
    // La contraseña es correcta
}

Kits de inicio (Starter Kits)

Laravel ofrece varios paquetes oficiales que implementan toda la lógica de autenticación por ti:

• Laravel Breeze: Implementación mínima con Blade, Vue, React o API. Ideal para aprender y proyectos simples.
• Laravel Jetstream: Más completo, incluye equipos, autenticación de dos factores, gestión de sesiones, etc.
• Laravel Fortify: Backend de autenticación sin vistas. Útil si quieres crear tu propio frontend.

En la siguiente lección instalaremos Laravel Breeze, que es la opción recomendada para empezar. Proporciona:

• Registro de usuarios
• Login y logout
• Recuperación de contraseña
• Verificación de email
• Confirmación de contraseña

Resumen

• Autenticación verifica identidad; autorización verifica permisos
• Los guards definen cómo se autentica (sesión, token, etc.)
• Los providers definen de dónde vienen los usuarios (Eloquent, database)
• Auth::attempt() verifica credenciales e inicia sesión
• Auth::check() verifica si hay usuario autenticado
• Auth::user() obtiene el usuario actual
• Auth::logout() cierra la sesión
• En Blade: @auth, @guest y auth()
• Usa Laravel Breeze para implementar autenticación rápidamente

Ejercicios

Ejercicio 1: Verificar configuración de autenticación

Abre el archivo config/auth.php de tu proyecto Laravel y responde: ¿Cuál es el guard por defecto? ¿Qué driver usa? ¿Qué modelo utiliza el provider de usuarios?

En config/auth.php encontrarás:

1. Guard por defecto: 'web'
   'defaults' => [
       'guard' => 'web',
   ]

2. Driver del guard 'web': 'session'
   'guards' => [
       'web' => [
           'driver' => 'session',
           'provider' => 'users',
       ],
   ]

3. Modelo del provider 'users': App\Models\User::class
   'providers' => [
       'users' => [
           'driver' => 'eloquent',
           'model' => App\Models\User::class,
       ],
   ]

Ejercicio 2: Componente de navegación con auth

Crea un componente Blade llamado x-nav que muestre un enlace de "Iniciar sesión" si el usuario es invitado, o el nombre del usuario y un enlace de "Cerrar sesión" si está autenticado. Los enlaces pueden apuntar a rutas ficticias por ahora.

{{-- resources/views/components/nav.blade.php --}}

<nav>
    <a href="/">Inicio</a>

    @guest
        <a href="{{ route('login') }}">Iniciar sesión</a>
        <a href="{{ route('register') }}">Registrarse</a>
    @endguest

    @auth
        <span>Hola, {{ auth()->user()->name }}</span>
        <form method="POST" action="{{ route('logout') }}">
            @csrf
            <button type="submit">Cerrar sesión</button>
        </form>
    @endauth
</nav>

Ejercicio 3: Método de logout

Escribe un método logout en un controlador que: cierre la sesión del usuario, invalide la sesión, regenere el token CSRF, y redirija a la página principal con un mensaje flash de despedida.

<?php

declare(strict_types=1);

namespace App\Http\Controllers;

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

class AuthController extends Controller
{
    public function logout(Request $request): RedirectResponse
    {
        Auth::logout();

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

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

        return redirect('/')
            ->with('success', 'Has cerrado sesión correctamente.');
    }
}