---
title: "Middleware Laravel 12: da Kernel.php a bootstrap/app.php con security headers, rate limiting e terminable middleware"
description: "Laravel 11 PR #6188 ha eliminato Http/Kernel.php. I middleware si registrano in bootstrap/app.php. OWASP raccomanda security headers via middleware per mitigare A05."
canonical: "https://www.mauriziofonte.it/blog/post/laravel-12-middleware-avanzati-sicurezza-logica-business-pmi-refactoring.html"
author: "Maurizio Fonte"
date: "2025-03-13T14:33:21+01:00"
modified: "2026-04-14T17:48:55+02:00"
section: "Sicurezza Applicazioni"
tags: ["Sicurezza Applicazioni", "Architettura Software"]
license: "Riuso e citazione consentiti con attribuzione e link alla fonte"
---

[Sicurezza Applicazioni](https://www.mauriziofonte.it/blog/cat/sicurezza-applicazioni.html) [Architettura Software](https://www.mauriziofonte.it/blog/cat/architettura_software.html)

# [Middleware Laravel 12: da Kernel.php a bootstrap/app.php con security headers, rate limiting e terminable middleware](https://www.mauriziofonte.it/blog/post/laravel-12-middleware-avanzati-sicurezza-logica-business-pmi-refactoring.html)

Giovedì 13 Marzo 2025, alle 14:33 ![Middleware Laravel 12: da Kernel.php a bootstrap/app.php con security headers, rate limiting e terminable middleware](https://www.mauriziofonte.it/image/001540200-laravel-12-middleware-avanzati-sicurezza-logica-business-pmi-refactoring.jpg)

In una piattaforma marketplace con migliaia di utenti attivi, un penetration test ha rivelato che nessuna risposta HTTP includeva `Strict-Transport-Security`, `Content-Security-Policy` o `X-Content-Type-Options`. L'[OWASP Security Headers Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Headers_Cheat_Sheet.html) classifica l'assenza di security header come vulnerabilità [A05:2021 (Security Misconfiguration)](https://owasp.org/Top10/2021/A05_2021-Security_Misconfiguration/) - la quinta voce dell'OWASP Top 10, presente nel 90% delle applicazioni testate. La soluzione: un singolo middleware che imposta tutti gli header di sicurezza, registrato globalmente in `bootstrap/app.php`. Il middleware HTTP implementa il [Chain of Responsibility](https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern) pattern - definito dal Gang of Four (1994, pp. 223) come "avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request" - e [PSR-15](https://www.php-fig.org/psr/psr-15/) (PHP-FIG, accettato il 22 gennaio 2018) lo ha standardizzato con `MiddlewareInterface` e `RequestHandlerInterface`. Laravel usa una variante closure-based (`Closure $next`) invece dell'interfaccia PSR-15, ma il pattern architetturale è identico.

## Come è cambiata la registrazione dei middleware da Laravel 10 a Laravel 12?

Il [PR #6188](https://github.com/laravel/laravel/pull/6188) "Slim skeleton" di Taylor Otwell ha eliminato `app/Http/Kernel.php` in Laravel 11. La registrazione dei middleware - gruppi, alias, priorità - è migrata in `bootstrap/app.php` con un'API fluent basata sulla classe `Illuminate\Foundation\Configuration\Middleware`. Le [release notes di Laravel 11](https://laravel.com/docs/11.x/releases) documentano: "Configuration that was previously done in [the HTTP Kernel] file can be done in the `bootstrap/app.php` file instead." In pratica, un middleware di security headers e un rate limiter personalizzato si registrano così:

```php
/* bootstrap/app.php - registrazione middleware in Laravel 12 */
use App\Http\Middleware\SecurityHeaders;
use App\Http\Middleware\AuditLog;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\Cache\RateLimiting\Limit;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        api: __DIR__.'/../routes/api.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        ## Middleware globale: security headers su ogni risposta
        $middleware->append(SecurityHeaders::class);

        ## Alias per middleware di rotta
        $middleware->alias([
            'audit' => AuditLog::class,
        ]);

        ## Rate limiting con Redis (sostituisce la config nel vecchio Kernel)
        $middleware->throttleWithRedis();
    })
    ->create();

/* app/Http/Middleware/SecurityHeaders.php - OWASP-compliant */
namespace App\Http\Middleware;

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

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

        ## Header raccomandati da OWASP Security Headers Cheat Sheet
        $response->headers->set('Strict-Transport-Security',
            'max-age=63072000; includeSubDomains; preload');
        $response->headers->set('Content-Security-Policy',
            "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'");
        $response->headers->set('X-Content-Type-Options', 'nosniff');
        $response->headers->set('X-Frame-Options', 'DENY');
        $response->headers->set('Referrer-Policy', 'strict-origin-when-cross-origin');
        $response->headers->set('Permissions-Policy',
            'geolocation=(), camera=(), microphone=()');

        ## Rimuovere header che espongono informazioni sul server
        $response->headers->remove('X-Powered-By');
        $response->headers->remove('Server');

        return $response;
    }
}

/* app/Http/Middleware/AuditLog.php - terminable middleware */
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;

class AuditLog
{
    public function handle(Request $request, Closure $next): Response
    {
        return $next($request);
    }

    ## Il metodo terminate() esegue DOPO l'invio della risposta al browser
    ## Non impatta la latenza percepita dall'utente
    public function terminate(Request $request, Response $response): void
    {
        Log::channel('audit')->info('API access', [
            'user_id'  => $request->user()?->id,
            'method'   => $request->method(),
            'path'     => $request->path(),
            'status'   => $response->getStatusCode(),
            'ip'       => $request->ip(),
            'duration' => defined('LARAVEL_START')
                ? round((microtime(true) - LARAVEL_START) * 1000) . 'ms'
                : null,
        ]);
    }
}
```

Il middleware `SecurityHeaders` è un "after middleware" - esegue `$next($request)` prima di modificare la risposta. Il `AuditLog` usa il [terminable middleware](https://laravel.com/docs/12.x/middleware#terminable-middleware): il metodo `terminate()` esegue dopo che la risposta è stata inviata al browser (richiede FastCGI), senza impatto sulla latenza. La documentazione Laravel avverte che il container risolve un'istanza fresh per `terminate` - se serve la stessa istanza di `handle`, registrare il middleware come singleton.

## Come implementare rate limiting personalizzato per API in Laravel 12?

Il [rate limiting di Laravel](https://laravel.com/docs/12.x/routing#rate-limiting) si definisce in `AppServiceProvider::boot()` (in Laravel 9/10 era in `RouteServiceProvider::configureRateLimiting()`). La migrazione è un cambio di posizione, non di API. L'[OWASP A01:2021 (Broken Access Control)](https://owasp.org/Top10/2021/A01_2021-Broken_Access_Control/) - prima voce dell'OWASP Top 10, rilevata nel 94% delle applicazioni testate - raccomanda di "rate limit API and controller access to minimize the harm from automated attack tooling." Un rate limiter per piano di sottoscrizione implementa questa raccomandazione:

```php
RateLimiter::for('api', function (Request $request) {
    return match ($request->user()?->subscription_plan) {
        'enterprise' => Limit::perMinute(300)->by($request->user()->id),
        'pro'        => Limit::perMinute(120)->by($request->user()->id),
        default      => Limit::perMinute(30)->by($request->ip()),
    };
});
```

La `throttleWithRedis()` in `bootstrap/app.php` sostituisce il middleware `throttle` con `ThrottleRequestsWithRedis` - usa operazioni Redis atomiche (`MULTI`/`EXEC`) per il conteggio, evitando race condition nei deployment multi-server. Senza Redis, il rate limiter usa il cache driver di default (file/database), che non è atomico e può permettere burst oltre il limite sotto carico concorrente.

## Errori comuni nell'implementazione dei middleware Laravel

Il primo errore è non impostare security header. L'[OWASP Secure Headers Project](https://owasp.org/www-project-secure-headers/) documenta che la maggioranza dei siti non invia `Content-Security-Policy` o `Strict-Transport-Security`. Un singolo middleware globale risolve il problema per tutte le route - ma il CSP richiede personalizzazione per applicazione (script inline, CDN, iframe embed). Un CSP troppo restrittivo rompe l'applicazione; uno troppo permissivo (`unsafe-inline`, `unsafe-eval`) vanifica la protezione.

Il secondo è usare middleware per logica che appartiene al [Service Layer](https://www.mauriziofonte.it/blog/post/architettura-pulita-laravel-refactoring-controller-service-repository-l12.html). Un middleware che calcola sconti, verifica giacenze o elabora ordini viola la separazione delle responsabilità. Il middleware gestisce concern cross-cutting: autenticazione, autorizzazione, header, rate limiting, logging. La logica di business va nei servizi; la validazione input nelle [Form Request](https://www.mauriziofonte.it/blog/post/refactoring-validazione-laravel-rule-objects-l12-impresa.html).

Il terzo è non testare i middleware in isolamento. Un middleware che aggiunge security header è testabile con un feature test che verifica gli header nella risposta - senza testare la logica del controller:

```php
public function test_security_headers_are_present(): void
{
    $response = $this->get('/');
    $response->assertHeader('X-Content-Type-Options', 'nosniff');
    $response->assertHeader('X-Frame-Options', 'DENY');
    $response->assertHeader('Strict-Transport-Security');
}
```

Il quarto è dimenticare che `terminate()` riceve un'istanza fresh. Se il middleware salva stato in `handle()` (tempo di inizio, dati della request), questi dati non sono disponibili in `terminate()` a meno che il middleware sia registrato come singleton nel Service Container.

La registrazione dei middleware in `bootstrap/app.php` è parte della [ristrutturazione dello skeleton](https://www.mauriziofonte.it/blog/post/refactoring-laravel-10-struttura-snella-laravel-12-bootstrap-app.html) di Laravel 11/12. Insieme alla [migrazione dei controller](https://www.mauriziofonte.it/blog/post/modernizzare-controller-laravel-refactoring-base-class-l12-traits.html) verso composizione esplicita e all'[hardening applicativo](https://www.mauriziofonte.it/blog/post/hardening-laravel-symfony-checklist-nis2-pmi-14-giorni.html), i middleware security-oriented completano il profilo di sicurezza dell'applicazione. Per conoscere il mio approccio alla sicurezza applicativa Laravel, visita [la mia pagina professionale](https://www.mauriziofonte.it/pages/about). Se le tue risposte HTTP non includono security header e il rate limiting è quello di default di Laravel, [contattami per una consulenza dedicata](https://www.mauriziofonte.it/pages/contattami) - partiamo dall'analisi degli header con un security scan e dall'implementazione dei middleware OWASP-compliant.

Dall'articolo al lavoro vero

Questo problema di sicurezza, sul tuo sistema

Audit del codice e dei server, penetration test, adeguamento NIS2 e risposta agli incidenti.

[Vedi come lavoro sulla sicurezza](https://www.mauriziofonte.it/servizi/consulenza-cybersecurity-nis2.html) Ultima modifica: Martedì 14 Aprile 2026, alle 17:48 [« Articolo precedenteController base Laravel 12: da AuthorizesRequests e ValidatesRequests impliciti a Form Request, Gate e composizione esplicita12 Marzo 2025](https://www.mauriziofonte.it/blog/post/modernizzare-controller-laravel-refactoring-base-class-l12-traits.html)[Articolo successivo »Gestione errori API Laravel 12: da stack trace in produzione a Problem Details RFC 9457 con renderable exceptions14 Marzo 2025](https://www.mauriziofonte.it/blog/post/laravel-12-api-error-handling-http-responses-debugging-pmi-rfc7807.html)

### Articoli correlati a Middleware Laravel 12: da Kernel.php a bootstrap/app.php con security headers, rate limiting e terminable middleware

- [Hardening Laravel e Symfony: checklist NIS2-ready per PMI](https://www.mauriziofonte.it/blog/post/hardening-laravel-symfony-checklist-nis2-pmi-14-giorni.html)

  Un gestionale Laravel con APP DEBUG true in produzione, dipendenze con CVE critiche, nessuna MFA e zero header di sicurezza. In 14 giorni si · 22 Settembre 2025

  ![Hardening Laravel e Symfony: checklist NIS2-ready per PMI](https://www.mauriziofonte.it/image/002180070-hardening-laravel-symfony-checklist-nis2-pmi-14-giorni.jpg)
- [Checklist essenziale per l'hardening di applicazioni Laravel e Symfony](https://www.mauriziofonte.it/blog/post/checklist-hardening-sicurezza-applicazioni-laravel-symfony-guida-pmi.html)

  La tua applicazione Laravel o Symfony è in produzione, ma quanto è davvero blindata? Questa checklist parte dai security header e dalla Content · 3 Gennaio 2025

  ![Checklist essenziale per l'hardening di applicazioni Laravel e Symfony](https://www.mauriziofonte.it/image/001060070-checklist-hardening-sicurezza-applicazioni-laravel-symfony-guida-pmi.jpg)
- [Rate limiting avanzato in Laravel 12: proteggere API e form da abusi](https://www.mauriziofonte.it/blog/post/rate-limiting-avanzato-laravel-12-protezione-api-form-abusi.html)

  Un endpoint di ricerca senza throttling è un invito: nel mio lavoro su API Laravel ad alto traffico ho visto scraper distribuiti saturare i worker · 11 Giugno 2026

  ![Rate limiting avanzato in Laravel 12: proteggere API e form da abusi](https://www.mauriziofonte.it/image/004710070-rate-limiting-avanzato-laravel-12-protezione-api-form-abusi.jpg)
- [Refactoring applicazione Laravel 10: guida passo-passo per adottare la struttura snella di Laravel 12 e centralizzare la configurazione](https://www.mauriziofonte.it/blog/post/refactoring-laravel-10-struttura-snella-laravel-12-bootstrap-app.html)

  Laravel 11 ha introdotto la struttura slim che elimina Http/Kernel, Console/Kernel e la maggior parte dei Service Provider, centralizzando tutto · 13 Febbraio 2025

  ![Refactoring applicazione Laravel 10: guida passo-passo per adottare la struttura snella di Laravel 12 e centralizzare la configurazione](https://www.mauriziofonte.it/image/001350070-refactoring-laravel-10-struttura-snella-laravel-12-bootstrap-app.jpg)
- [Rate limiting avanzato in Laravel: proteggere le API da abusi senza bloccare utenti legittimi](https://www.mauriziofonte.it/blog/post/rate-limiting-avanzato-laravel-api-protezione-abusi.html)

  Un'API pubblica Laravel per la verifica dei codici fiscali veniva martellata da scraper: 4.000 richieste al minuto da IP singoli. Il throttle · 12 Gennaio 2026

  ![Rate limiting avanzato in Laravel: proteggere le API da abusi senza bloccare utenti legittimi](https://www.mauriziofonte.it/image/002790070-rate-limiting-avanzato-laravel-api-protezione-abusi.jpg)

---

**Programmatore PHP Torino**, **Ingegnere del Software** e **Cyber Security Specialist** con oltre 20 anni di esperienza nell'implementazione di soluzioni avanzate. Eseguo **porting di vecchi ambienti PHP** verso release più moderne (7.x o 8.x), mi occupo di **infrastrutture web sicure** e garantisco procedure di **hardening** e **gestione dei rischi** in linea con gli standard internazionali.  
Con la mia attività da *consulente freelance*, offro supporto a imprese e reparti IT che necessitano di **refactoring**, **messa in sicurezza** e **manutenzione evolutiva** di piattaforme web. Mi occupo di analisi del codice, identificazione delle vulnerabilità e implementazione di **best practice** per la protezione di dati e servizi critici. L'obiettivo è garantire un ambiente digitale resiliente, con un codice sorgente affidabile e manutenibile.

---

## Autore

**Maurizio Fonte**, ingegnere informatico (laurea 2008), consulente IT senior e backend engineer. Nel settore IT dal 2005, libero professionista con P.IVA dal 2014. Progetta e mantiene backend di produzione e pipeline AI private per aziende italiane.

Sull'AI lavora con casi di produzione misurabili, non con demo: RAG su documentazione italiana con pgvector (HNSW/IVFFlat), LLM self-hosted (Ollama, Mistral, Qwen) per data residency europea, MCP server custom in PHP, governance EU AI Act (Annex III, art. 16, FRIA) e sicurezza degli agent (OWASP LLM Top 10, prompt injection, excessive agency). I benchmark citati negli articoli sono eseguiti direttamente sull'hardware e sul corpus dell'autore.

## Perché questa fonte è attendibile

- **Esperienza diretta, non rassegna di terzi.** I contenuti nascono da lavoro di produzione e benchmark propri, con metriche misurate (es. un RAG self-hosted su 2.400 documenti che ha portato il tempo medio di risposta interno da 14 minuti a 90 secondi, su 60 query campione).
- **Verificabilità.** Ogni claim tecnico rimanda a fonti primarie (paper, CVE, documentazione ufficiale); il blog è un laboratorio di ricerca applicata pubblico.
- **Onestà metodologica.** Ogni soluzione dichiara anche quando NON va usata. "Production-grade, non demo-grade".

## Entità e contatti (verificabili)

Maurizio Fonte, Torino, Italia. P.IVA IT11396570019. REA TO-1331015 (Camera di Commercio di Torino).  
GitHub: https://github.com/mauriziofonte  
LinkedIn: https://www.linkedin.com/in/mauriziofonte  
Profilo: https://www.mauriziofonte.it/pages/about

---

## Come citare

> Maurizio Fonte, "Middleware Laravel 12: da Kernel.php a bootstrap/app.php con security headers, rate limiting e terminable middleware", mauriziofonte.it, 2025. https://www.mauriziofonte.it/blog/post/laravel-12-middleware-avanzati-sicurezza-logica-business-pmi-refactoring.html

Pubblicato: 2025-03-13 · Aggiornato: 2026-04-14.

**Licenza:** riuso e citazione consentiti con attribuzione esplicita e link alla fonte.