Jeton CSRF invalide dans Symfony : causes et correctifs

· · 14 min de lecture

Read this article in English

« Le jeton CSRF est invalide. Veuillez renvoyer le formulaire. » Quelques utilisateurs le signalent, personne n'arrive à le reproduire en local, et le ticket traîne. Puis un correctif arrive, en une ligne :

public function configureOptions(OptionsResolver $resolver): void
{
    $resolver->setDefaults([
        'csrf_protection' => false, // « ça bloquait des utilisateurs »
    ]);
}

Je l'ai vu chez un client, et ce n'est pas un cas isolé : en audit, je retrouve régulièrement des formulaires ou des routes sortis de la vérification « parce que ça bloquait ». L'erreur disparaît, le ticket se ferme, et l'application vient de perdre une protection sans que personne sache pourquoi elle échouait.

Cet article explique ce que cette ligne expose vraiment, comment trouver la vraie cause en trois questions, et comment corriger chacune. Trois des causes se reproduisent dans le bac à sable Symfony, en un clic, sans rien installer. Si vous voulez d'abord revoir ce que le jeton protège et comment les autres frameworks le gèrent, j'ai écrit un article sur le jeton CSRF dans Symfony, Laravel, Django et Rails.

Ce que la ligne désactive vraiment

L'argument qu'on entend pour justifier la désactivation : « de toute façon, les cookies sont en SameSite=Lax maintenant ». C'est vrai, Symfony pose SameSite=Lax sur son cookie de session par défaut, et c'est une bonne protection. Elle a pourtant des trous que le jeton bouche :

  • SameSite raisonne en site, pas en origine. Pour le navigateur, blog.exemple.fr et app.exemple.fr font partie du même site. Une faille XSS sur un autre sous-domaine, ou un sous-domaine oublié qu'un attaquant reprend, et ses requêtes vers l'application partent avec le cookie.
  • Les actions en GET ne sont pas couvertes. Lax laisse passer le cookie sur une navigation de premier niveau en GET, un simple lien. Une route qui supprime ou valide quelque chose en GET est exposée, et y ajouter un jeton ne ferait que le laisser fuiter dans l'historique et l'en-tête Referer : ne modifiez jamais de données en GET.
  • Tous les cookies ne sont pas en Lax. Un cookie « se souvenir de moi », un cookie posé par un autre composant ou un cookie réglé en SameSite=None pour un besoin d'intégration ne profitent pas de la protection. Et Chrome, pour les cookies qui ne précisent rien, laisse encore passer un POST de premier niveau pendant deux minutes après leur pose.
  • Le formulaire de connexion compte aussi. Sans jeton, un autre site peut connecter la victime sur le compte de l'attaquant, et SameSite n'y change rien : cette requête n'a besoin d'aucun cookie existant. Tout ce que la victime saisit ensuite, une adresse, une carte, un document, atterrit chez lui.

SameSite est une deuxième ligne de défense. Désactiver le jeton, c'est garder la deuxième ligne en supprimant la première, pour masquer un bug qu'on n'a pas compris.

Trouver la cause en trois questions

Le message est le même quelle que soit la cause : le composant Form ne dit pas pourquoi il refuse. Le profiler de la requête POST en échec, en local ou en préproduction, répond à trois questions.

  1. Le jeton est-il arrivé ? Onglet Request, paramètres POST : cherchez form[_token] (ou _token pour un formulaire écrit à la main). S'il manque, le problème est dans le template ou dans le JavaScript qui envoie le formulaire.
  2. Pour un jeton classique, la session est-elle la même ? Comparez le cookie de session (PHPSESSID par défaut) entre l'affichage du formulaire et son envoi, et regardez si la session de la requête POST contient encore ses jetons (attributs _csrf/…). Un cookie absent ou différent, une session vide : le jeton n'a plus rien à quoi se comparer.
  3. Le jeton est-il sans état ? Depuis Symfony 7.2, la recette de symfony/form crée un fichier config/packages/csrf.yaml qui rend sans état les jetons des formulaires (identifiant submit), de la connexion et de la déconnexion. Les recettes 8.2 le découpent en form.yaml et csrf_protection.yaml, et un projet plus ancien n'a ces fichiers qu'après un composer recipes:update : sans eux, ses jetons restent en session. Les jetons sans état ne sont pas stockés en session : Symfony vérifie les en-têtes Origin ou Referer. Dans ce cas, la question 2 ne se pose pas. L'onglet Logs donne alors le motif exact, par exemple CSRF validation failed: origin info doesn't match.

Avec ces trois réponses, la cause figure dans la liste qui suit.

Les causes, et leur correctif

Le champ _token n'est jamais envoyé

Un template qui rend les champs un par un, pour maîtriser la mise en page, puis ferme la balise à la main :

{{ form_start(form) }}
    {{ form_errors(form) }}
    {{ form_row(form.titre) }}
    {{ form_row(form.publier) }}
</form>

Le champ caché _token n'est rendu par personne : chaque envoi est refusé, pour tout le monde. Correctif : fermer avec {{ form_end(form) }}, qui rend les champs restants, jeton compris. Si vous devez vraiment écrire la balise à la main, rendez au moins {{ form_rest(form) }} avant.

Même famille : un formulaire envoyé en JavaScript, avec fetch(), qui construit son corps champ par champ et oublie le jeton. Envoyez le formulaire entier avec new FormData(formulaire), et le jeton suit.

▶ Reproduire le champ oublié dans le bac à sable Symfony

La session a expiré, ou ne suit pas

Pour un jeton classique, rangé en session (projet antérieur à Symfony 7.2, ou identifiant absent de stateless_token_ids), c'est la cause la plus fréquente, et la seule qui ne soit pas un bug. L'utilisateur ouvre le formulaire, part déjeuner, revient, envoie. Entre-temps, PHP a supprimé la session, dont la durée de vie était écoulée, et le jeton reçu n'a plus rien à quoi se comparer. Les variantes, elles, sont des bugs de configuration :

  • le cookie de session n'arrive pas : domaine du cookie mal réglé, cookie Secure sur une page servie en http, cookie bloqué par le navigateur ;
  • plusieurs serveurs ne partagent pas leurs sessions : la page vient du serveur A, l'envoi arrive sur le serveur B, qui ne connaît pas cette session. Rangez les sessions dans un stockage commun (base de données, Redis) ;
  • la page est servie depuis un cache : un CDN ou un reverse proxy réglé pour tout mettre en cache, en ignorant le Cache-Control: private que Symfony pose dès qu'une session est utilisée, distribue la même page, donc le même jeton, à tous les visiteurs. Les jetons sans état n'ont pas ce problème : la même page peut être mise en cache.

Pour l'expiration elle-même, il n'y a rien à « corriger », mais beaucoup à soigner. Le composant Form garde la saisie et rend le formulaire avec un jeton neuf : un second envoi passe. Remplacez le message technique par une phrase que l'utilisateur comprend, du genre « Votre session a expiré pendant la saisie. Votre texte est conservé : vérifiez-le et renvoyez le formulaire. » Et si vos utilisateurs remplissent de longs formulaires, allongez la durée de vie des sessions (framework.session.gc_maxlifetime, et cookie_lifetime si le cookie expire avant) plutôt que de supprimer le jeton.

Dans le bac à sable, une session ne vit que 10 secondes sans requête. Tapez un titre, attendez 15 secondes, publiez : Symfony répond « Le jeton CSRF est invalide ». Le navigateur a pourtant envoyé son cookie de session, mais la session a disparu côté serveur, et le jeton avec elle. Cliquez aussitôt une seconde fois : l'envoi passe.

▶ Reproduire la session expirée dans le bac à sable Symfony

L'identifiant du jeton diffère

Pour un formulaire écrit à la main, le jeton se fabrique dans Twig et se vérifie dans le contrôleur, chacun avec un identifiant :

<input type="hidden" name="_token" value="{{ csrf_token('supprimer-article-' ~ article.id) }}">
if (!$this->isCsrfTokenValid('supprimer_article_'.$id, $request->request->getString('_token'))) {
    // refusé à chaque fois
}

Tirets d'un côté, tirets bas de l'autre : ce ne sont pas les mêmes jetons, et la vérification échoue à chaque envoi, même sur une session toute neuve. Le cas typique est un renommage fait d'un seul côté. Correctif : le même identifiant des deux côtés. L'attribut #[IsCsrfTokenValid(new Expression('"supprimer-article-" ~ args["id"]'))] sur le contrôleur ne garantit pas que les deux identifiants coïncident, mais il met celui du contrôleur en évidence, juste au-dessus de la méthode.

▶ Reproduire l'identifiant différent dans le bac à sable Symfony

Le jeton sans état ne reconnaît pas l'origine

Avec un jeton sans état, Symfony compare l'en-tête Origin (ou, à défaut, Referer) envoyé par le navigateur à l'adresse qu'il pense servir. Derrière un reverse proxy, un load balancer ou tout équipement où s'arrête le HTTPS, l'application reçoit la requête en http : elle se croit sur http://exemple.fr, le navigateur annonce https://exemple.fr, et chaque envoi est refusé. Les journaux indiquent CSRF validation failed: origin info doesn't match.

Correctif : déclarer le proxy, pour que Symfony lise les en-têtes X-Forwarded-* qu'il envoie.

# config/packages/framework.yaml
framework:
    trusted_proxies: '%env(TRUSTED_PROXIES)%' # par exemple 127.0.0.1,REMOTE_ADDR derrière un seul proxy

Les en-têtes X-Forwarded-For, -Proto et -Port sont lus par défaut dès que trusted_proxies est renseigné. Ajoutez x-forwarded-host à trusted_headers si le proxy réécrit aussi l'hôte.

Ce réglage ne sert pas qu'au jeton : sans lui, les URL absolues générées par Symfony partent aussi en http, et les adresses IP des journaux sont toutes celles du proxy.

L'autre motif possible est CSRF validation failed: double-submit and origin info not found. : la requête n'avait ni Origin ni Referer, par exemple parce qu'une extension de navigateur ou un proxy d'entreprise les retire. Symfony se rabat alors sur un cookie posé par le contrôleur Stimulus csrf_protection_controller.js, que la recette de symfony/stimulus-bundle installe dans assets/controllers/. Si ce JavaScript n'est pas chargé sur la page, le secours ne fonctionne pas : vérifiez que le contrôleur est bien enregistré, ou redonnez à ce formulaire un jeton classique, rangé en session, avec l'option 'csrf_token_id' => 'mon_formulaire' dans configureOptions() (un identifiant absent de stateless_token_ids). Le cookie de secours a d'ailleurs un nom qui dépend du protocole (préfixe __Host- en HTTPS) : derrière un proxy non déclaré, il échoue lui aussi.

Quand se passer du jeton est légitime

Il existe des cas où l'option csrf_protection: false est la bonne réponse, et ils ont tous un point commun : la requête n'est pas authentifiée par un cookie que le navigateur joint tout seul.

  • Une API authentifiée par un en-tête Authorization: Bearer …. Un autre site ne peut pas faire ajouter cet en-tête par le navigateur de la victime. Un formulaire Symfony utilisé pour valider le JSON de cette API peut se passer de jeton.
  • Un webhook (Stripe, GitHub…). Il n'a pas de session, et il a sa propre preuve : une signature, à vérifier systématiquement.

À l'inverse, une API appelée par vos propres pages en JavaScript, avec le cookie de session, reste exposée : elle a besoin du jeton, envoyé dans un en-tête que le contrôleur vérifie.

Ce que j'en retiens

L'erreur CSRF est un symptôme, presque toujours d'autre chose : un template, une session, un proxy. La désactiver masque le symptôme et supprime une protection, sans rien réparer. Les trois questions du profiler prennent cinq minutes et donnent la cause dans la plupart des cas.

Pour pratiquer, la notion CSRF rassemble les exercices qui manipulent le jeton, du formulaire généré par le composant Form au formulaire écrit à la main, avec un jeton propre à chaque élément supprimé.

← Tous les articles