Buenas Prácticas de Seguridad en Laravel

Guía completa de seguridad para aplicaciones Laravel que protege contra vulnerabilidades comunes.

Cuándo Activar

• Agregar autenticación o autorización
• Manejar entrada de usuarios y subida de archivos
• Construir nuevos endpoints de API
• Gestionar secretos y configuración de entornos
• Reforzar despliegues en producción

Cómo Funciona

• El middleware proporciona protecciones de base (CSRF mediante VerifyCsrfToken, cabeceras de seguridad mediante SecurityHeaders).
• Los guards y policies aplican el control de acceso (auth:sanctum, $this->authorize, middleware de policy).
• Los Form Requests validan y dan forma a la entrada (UploadInvoiceRequest) antes de que llegue a los servicios.
• La limitación de velocidad agrega protección contra abusos (RateLimiter::for('login')) junto con controles de autenticación.
• La seguridad de datos proviene de casts encriptados, guards de asignación masiva y rutas firmadas (URL::temporarySignedRoute + middleware signed).

Configuración Principal de Seguridad

• APP_DEBUG=false en producción
• APP_KEY debe estar establecido y rotarse al comprometerse
• Establecer SESSION_SECURE_COOKIE=true y SESSION_SAME_SITE=lax (o strict para apps sensibles)
• Configurar proxies de confianza para la detección correcta de HTTPS

Reforzamiento de Sesión y Cookies

• Establecer SESSION_HTTP_ONLY=true para prevenir acceso desde JavaScript
• Usar SESSION_SAME_SITE=strict para flujos de alto riesgo
• Regenerar sesiones al iniciar sesión y al cambiar privilegios

Autenticación y Tokens

• Usar Laravel Sanctum o Passport para autenticación de API
• Preferir tokens de corta vida con flujos de actualización para datos sensibles
• Revocar tokens al cerrar sesión y en cuentas comprometidas

Ejemplo de protección de rutas:

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;

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

Seguridad de Contraseñas

• Hashear contraseñas con Hash::make() y nunca almacenar texto plano
• Usar el password broker de Laravel para los flujos de restablecimiento

use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\Rules\Password;

$validated = $request->validate([
    'password' => ['required', 'string', Password::min(12)->letters()->mixedCase()->numbers()->symbols()],
]);

$user->update(['password' => Hash::make($validated['password'])]);

Autorización: Policies y Gates

• Usar policies para autorización a nivel de modelo
• Aplicar autorización en controladores y servicios

$this->authorize('update', $project);

Usar middleware de policy para aplicación a nivel de ruta:

use Illuminate\Support\Facades\Route;

Route::put('/projects/{project}', [ProjectController::class, 'update'])
    ->middleware(['auth:sanctum', 'can:update,project']);

Validación y Sanitización de Datos

• Siempre validar entradas con Form Requests
• Usar reglas de validación estrictas y verificaciones de tipo
• Nunca confiar en los payloads de la request para campos derivados

Protección contra Asignación Masiva

• Usar $fillable o $guarded y evitar Model::unguard()
• Preferir DTOs o mapeo explícito de atributos

Prevención de Inyección SQL

• Usar Eloquent o el query builder con binding de parámetros
• Evitar SQL crudo a menos que sea estrictamente necesario

DB::select('select * from users where email = ?', [$email]);

Prevención de XSS

• Blade escapa la salida por defecto ({{ }})
• Usar {!! !!} solo para HTML de confianza y sanitizado
• Sanitizar texto enriquecido con una librería dedicada

Protección CSRF

• Mantener el middleware VerifyCsrfToken habilitado
• Incluir @csrf en formularios y enviar tokens XSRF en requests de SPA

Para autenticación SPA con Sanctum, asegurarse de que las requests stateful estén configuradas:

// config/sanctum.php
'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', 'localhost')),

Seguridad en Subida de Archivos

• Validar tamaño de archivo, tipo MIME y extensión
• Almacenar subidas fuera del directorio público cuando sea posible
• Escanear archivos en busca de malware si es necesario

final class UploadInvoiceRequest extends FormRequest
{
    public function authorize(): bool
    {
        return (bool) $this->user()?->can('upload-invoice');
    }

    public function rules(): array
    {
        return [
            'invoice' => ['required', 'file', 'mimes:pdf', 'max:5120'],
        ];
    }
}

$path = $request->file('invoice')->store(
    'invoices',
    config('filesystems.private_disk', 'local') // establecer a un disco no público
);

Limitación de Velocidad

• Aplicar middleware throttle en endpoints de autenticación y escritura
• Usar límites más estrictos para login, restablecimiento de contraseña y OTP

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('login', function (Request $request) {
    return [
        Limit::perMinute(5)->by($request->ip()),
        Limit::perMinute(5)->by(strtolower((string) $request->input('email'))),
    ];
});

Secretos y Credenciales

• Nunca hacer commit de secretos al control de versiones
• Usar variables de entorno y gestores de secretos
• Rotar claves después de una exposición e invalidar sesiones

Atributos Encriptados

Usar casts encriptados para columnas sensibles en reposo.

protected $casts = [
    'api_token' => 'encrypted',
];

Cabeceras de Seguridad

• Agregar CSP, HSTS y protección de frames donde sea apropiado
• Usar configuración de proxies de confianza para forzar redirecciones HTTPS

Ejemplo de middleware para establecer cabeceras:

use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

final class SecurityHeaders
{
    public function handle(Request $request, \Closure $next): Response
    {
        $response = $next($request);

        $response->headers->add([
            'Content-Security-Policy' => "default-src 'self'",
            'Strict-Transport-Security' => 'max-age=31536000', // agregar includeSubDomains/preload solo cuando todos los subdominios sean HTTPS
            'X-Frame-Options' => 'DENY',
            'X-Content-Type-Options' => 'nosniff',
            'Referrer-Policy' => 'no-referrer',
        ]);

        return $response;
    }
}

CORS y Exposición de API

• Restringir orígenes en config/cors.php
• Evitar orígenes wildcard para rutas autenticadas

// config/cors.php
return [
    'paths' => ['api/*', 'sanctum/csrf-cookie'],
    'allowed_methods' => ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
    'allowed_origins' => ['https://app.example.com'],
    'allowed_headers' => [
        'Content-Type',
        'Authorization',
        'X-Requested-With',
        'X-XSRF-TOKEN',
        'X-CSRF-TOKEN',
    ],
    'supports_credentials' => true,
];

Logging y PII

• Nunca registrar contraseñas, tokens o datos completos de tarjetas
• Redactar campos sensibles en logs estructurados

use Illuminate\Support\Facades\Log;

Log::info('User updated profile', [
    'user_id' => $user->id,
    'email' => '[REDACTED]',
    'token' => '[REDACTED]',
]);

Seguridad de Dependencias

• Ejecutar composer audit regularmente
• Fijar dependencias con cuidado y actualizar rápidamente ante CVEs

URLs Firmadas

Usar rutas firmadas para enlaces temporales a prueba de manipulaciones.

use Illuminate\Support\Facades\URL;

$url = URL::temporarySignedRoute(
    'downloads.invoice',
    now()->addMinutes(15),
    ['invoice' => $invoice->id]
);

use Illuminate\Support\Facades\Route;

Route::get('/invoices/{invoice}/download', [InvoiceController::class, 'download'])
    ->name('downloads.invoice')
    ->middleware('signed');