pourquoi j'obtiens une erreur de page 419 lorsque je me reconnecte à laravel ?

Question

J'écris des applications dans Laravel et j'ai un problème après m'être connecté à l'application et avoir éteint le navigateur puis relancé l'application, l'erreur 419 s'affiche

est le fichier .env :

BROADCAST_DRIVER=log
CACHE_DRIVER=file
FILESYSTEM_DRIVER=local
QUEUE_CONNECTION=sync
SESSION_DOMAIN_URL=.my domain
SESSION_DRIVER=file
SESSION_LIFETIME=960

et le fichier session.php

<?php

use Illuminate\Support\Str;

return [

    /*
    |--------------------------------------------------------------------------
    | Default Session Driver
    |--------------------------------------------------------------------------
    |
    | This option controls the default session "driver" that will be used on
    | requests. By default, we will use the lightweight native driver but
    | you may specify any of the other wonderful drivers provided here.
    |
    | Supported: "file", "cookie", "database", "apc",
    |            "memcached", "redis", "dynamodb", "array"
    |
    */

    'driver' => env('SESSION_DRIVER', 'file'),

    /*
    |--------------------------------------------------------------------------
    | Session Lifetime
    |--------------------------------------------------------------------------
    |
    | Here you may specify the number of minutes that you wish the session
    | to be allowed to remain idle before it expires. If you want them
    | to immediately expire on the browser closing, set that option.
    |
    */

    'lifetime' => env('SESSION_LIFETIME', 960),

    'expire_on_close' => false,

    /*
    |--------------------------------------------------------------------------
    | Session Encryption
    |--------------------------------------------------------------------------
    |
    | This option allows you to easily specify that all of your session data
    | should be encrypted before it is stored. All encryption will be run
    | automatically by Laravel and you can use the Session like normal.
    |
    */

    'encrypt' => false,

    /*
    |--------------------------------------------------------------------------
    | Session File Location
    |--------------------------------------------------------------------------
    |
    | When using the native session driver, we need a location where session
    | files may be stored. A default has been set for you but a different
    | location may be specified. This is only needed for file sessions.
    |
    */

    'files' => storage_path('framework/sessions'),

    /*
    |--------------------------------------------------------------------------
    | Session Database Connection
    |--------------------------------------------------------------------------
    |
    | When using the "database" or "redis" session drivers, you may specify a
    | connection that should be used to manage these sessions. This should
    | correspond to a connection in your database configuration options.
    |
    */

    'connection' => env('SESSION_CONNECTION', null),

    /*
    |--------------------------------------------------------------------------
    | Session Database Table
    |--------------------------------------------------------------------------
    |
    | When using the "database" session driver, you may specify the table we
    | should use to manage the sessions. Of course, a sensible default is
    | provided for you; however, you are free to change this as needed.
    |
    */

    'table' => 'sessions',

    /*
    |--------------------------------------------------------------------------
    | Session Cache Store
    |--------------------------------------------------------------------------
    |
    | While using one of the framework's cache driven session backends you may
    | list a cache store that should be used for these sessions. This value
    | must match with one of the application's configured cache "stores".
    |
    | Affects: "apc", "dynamodb", "memcached", "redis"
    |
    */

    'store' => env('SESSION_STORE', null),

    /*
    |--------------------------------------------------------------------------
    | Session Sweeping Lottery
    |--------------------------------------------------------------------------
    |
    | Some session drivers must manually sweep their storage location to get
    | rid of old sessions from storage. Here are the chances that it will
    | happen on a given request. By default, the odds are 2 out of 100.
    |
    */

    'lottery' => [2, 100],

    /*
    |--------------------------------------------------------------------------
    | Session Cookie Name
    |--------------------------------------------------------------------------
    |
    | Here you may change the name of the cookie used to identify a session
    | instance by ID. The name specified here will get used every time a
    | new session cookie is created by the framework for every driver.
    |
    */

    'cookie' => env(
        'SESSION_COOKIE',
        Str::slug(env('APP_NAME', 'laravel'), '_').'_session'
    ),

    /*
    |--------------------------------------------------------------------------
    | Session Cookie Path
    |--------------------------------------------------------------------------
    |
    | The session cookie path determines the path for which the cookie will
    | be regarded as available. Typically, this will be the root path of
    | your application but you are free to change this when necessary.
    |
    */

    'path' => '/',

    /*
    |--------------------------------------------------------------------------
    | Session Cookie Domain
    |--------------------------------------------------------------------------
    |
    | Here you may change the domain of the cookie used to identify a session
    | in your application. This will determine which domains the cookie is
    | available to in your application. A sensible default has been set.
    |
    */

    'domain' => env('SESSION_DOMAIN', null),

    /*
    |--------------------------------------------------------------------------
    | HTTPS Only Cookies
    |--------------------------------------------------------------------------
    |
    | By setting this option to true, session cookies will only be sent back
    | to the server if the browser has a HTTPS connection. This will keep
    | the cookie from being sent to you when it can't be done securely.
    |
    */

    'secure' => env('SESSION_SECURE_COOKIE', false),

    /*
    |--------------------------------------------------------------------------
    | HTTP Access Only
    |--------------------------------------------------------------------------
    |
    | Setting this value to true will prevent JavaScript from accessing the
    | value of the cookie and the cookie will only be accessible through
    | the HTTP protocol. You are free to modify this option if needed.
    |
    */

    'http_only' => true,

    /*
    |--------------------------------------------------------------------------
    | Same-Site Cookies
    |--------------------------------------------------------------------------
    |
    | This option determines how your cookies behave when cross-site requests
    | take place, and can be used to mitigate CSRF attacks. By default, we
    | will set this value to "lax" since this is a secure default value.
    |
    | Supported: "lax", "strict", "none", null
    |
    */

    'same_site' => 'lax',

];

en entrant dans la page de l'application après s'être correctement connecté, puis en fermant la page et en se connectant à nouveau, une erreur de page 419 apparaît, puis lorsque vous entrez le chemin manuellement, par exemple .my domain.pl/home l'application démarre sans problème, mais autrement l'erreur 419 apparaît, je ne sais pas pourquoi

Answer 1

Vous devez configurer le CSRF https://laravel.com/docs/8.x/csrf

Introduction

Les forgeries de requêtes intersites sont un type d'exploitation malveillante par laquelle des commandes non autorisées sont exécutées au nom d'un utilisateur authentifié. Heureusement, Laravel permet de protéger facilement votre application contre les attaques CSRF (cross-site request forgery).

Une explication de la vulnérabilité

Au cas où vous ne seriez pas familier avec les faux requêtes intersites, voyons un exemple de la façon dont cette vulnérabilité peut être exploitée. Imaginez que votre application possède une route /user/email qui accepte une requête POST pour modifier l'adresse électronique de l'utilisateur authentifié. Très probablement, cette route s'attend à ce qu'un champ de saisie de l'adresse électronique contienne l'adresse électronique que l'utilisateur souhaite commencer à utiliser.

Sans protection CSRF, un site web malveillant pourrait créer un formulaire HTML qui pointe vers la route /user/email de votre application et soumet la propre adresse électronique de l'utilisateur malveillant :

<form action="https://your-application.com/user/email" method="POST">
    <input type="email" value="malicious-email@example.com">
</form>

<script>
    document.forms[0].submit();
</script>

Si le site web malveillant soumet automatiquement le formulaire lors du chargement de la page, il suffit à l'utilisateur malveillant d'inciter un utilisateur peu méfiant de votre application à visiter son site web pour que son adresse électronique soit modifiée dans votre application.

Pour éviter cette vulnérabilité, nous devons inspecter chaque demande POST, PUT, PATCH ou DELETE entrante pour y trouver une valeur de session secrète à laquelle l'application malveillante ne peut pas accéder.

Prévention des requêtes CSRF Laravel génère automatiquement un "jeton" CSRF pour chaque session utilisateur active gérée par l'application. Ce jeton est utilisé pour vérifier que l'utilisateur authentifié est bien la personne qui effectue les demandes à l'application. Comme ce jeton est stocké dans la session de l'utilisateur et change à chaque fois que la session est régénérée, une application malveillante ne peut pas y accéder.

Le jeton CSRF de la session actuelle est accessible via la session de la demande ou via la fonction d'aide csrf_token :

use Illuminate\Http\Request;

Route::get('/token', function (Request $request) {
    $token = $request->session()->token();

    $token = csrf_token();

    // ...
});

Chaque fois que vous définissez un formulaire HTML "POST", "PUT", "PATCH" ou "DELETE" dans votre application, vous devez inclure un champ CSRF _token caché dans le formulaire afin que le middleware de protection CSRF puisse valider la requête. Pour plus de commodité, vous pouvez utiliser la directive @csrf Blade pour générer le champ de saisie du jeton caché :

<form method="POST" action="/profile">
    @csrf

    <!-- Equivalent to... -->
    <input type="hidden" name="_token" value="{{ csrf_token() }}" />
</form>

L'application \Http\Middleware\VerifyCsrfToken qui est inclus par défaut dans le groupe des intergiciels web, vérifiera automatiquement que le jeton de la requête en entrée correspond au jeton stocké dans la session. Lorsque ces deux jetons correspondent, nous savons que l'utilisateur authentifié est celui qui a initié la requête.

Jetons CSRF et SPAs Si vous construisez un SPA qui utilise Laravel comme backend d'API, vous devez consulter la documentation de Laravel Sanctum pour obtenir des informations sur l'authentification avec votre API et la protection contre les vulnérabilités CSRF.

Exclusion des URI de la protection CSRF Il peut arriver que vous souhaitiez exclure un ensemble d'URI de la protection CSRF. Par exemple, si vous utilisez Stripe pour traiter les paiements et que vous utilisez leur système de webhook, vous devrez exclure votre route de gestionnaire de webhook Stripe de la protection CSRF puisque Stripe ne saura pas quel jeton CSRF envoyer à vos routes.

En règle générale, vous devez placer ces types de routes en dehors du groupe d'intergiciels Web que l'application doit utiliser. \Providers\RouteServiceProvider s'applique à toutes les routes du fichier routes/web.php. Cependant, vous pouvez également exclure les routes en ajoutant leurs URI à la propriété $except de l'intergiciel VerifyCsrfToken :

<?php

namespace App\Http\Middleware;

use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;

class VerifyCsrfToken extends Middleware
{
    /**
     * The URIs that should be excluded from CSRF verification.
     *
     * @var array
     */
    protected $except = [
        'stripe/*',
        'http://example.com/foo/bar',
        'http://example.com/foo/*',
    ];
}