Ajouter une valeur personnalisée lors de l'inscription Symfony

Quand on démarre le développement d’une site sous Symfony, l’une des première chose à faire concerne la gestion des utilisateurs. En effet dans la plupart des cas notre application devra permettre à des utilisateurs de s’inscrire puis de se connecter au site afin d’avoir accès à des sections particulières (espace membre, espace administrateur). Entrons dans le vif du sujet, avec la création de l’entité « User », dans « /src/Entity/User.php ».

Créer et configurer l’entité User

Nous avons créé notre entité User, et elle implémente UserInterface, ce qui la rend compatible avec le système de sécurité de Symfony. Cette ligne de commande se comporte dans un premier temps comme une sorte de surcouche au make:entity User, puisqu’elle va implémenter UserInterface et PasswordAuthenticatedUserInterface. Le champ plainPassword qui contiendra le mot de passe avant hachage n’est pas mappé.

Une fois ce fichier enregistré, on peux mettre à jour notre base de données afin d’y créer la table « User ». Mettez à jour votre base de données avec la commande suivante : symfony console doctrine:schema:update --force.

Ajouter des champs personnalisés à l’inscription

Commencez par ajouter les champs qui manquent au formulaire d'enregistrement pour le faire correspondre à notre entité (en particulier les rôles, le prénom et le nom de famille) et ajouter les éventuelles options qui vous paraissent pertinentes. Les rôles doivent être une collection de checkbox, avec possibilité de sélectionner plusieurs rôles. Les choix possibles sont ROLE_USER et ROLE_ADMIN.

Pour l’inscription, on va d’abord créer le formulaire dans un fichier à part qui sera « /src/Form/UserType.php ». Nous allons utiliser ce formulaire dans le controller « /src/Controller/RegistrationController.php ». La page permettant l’inscription sera accessible sur l’url « /register », ici on enregistre et on valide directement le compte, on peut aussi attribuer le rôle utilisateur dans ce controlleur.

Générer rapidement le formulaire et le contrôleur

L’inscription d’un utilisateur est elle aussi grandement simplifiée grâce au MakerBundle. A présent, pour créer le formulaire d’inscription nous allons taper : symfony console make:registration-form. Cette commande va créer une nouvelle classe de formulaire dans votre application Symfony, spécifiquement conçue pour l’inscription des utilisateurs.

Une fois l’utilisateur enregistré, il vous est demandé de définir vers quelle route le rediriger. $this->redirectToRoute('ma_route') redirige l’utilisateur vers la route spécifiée lors de la saisie via l’invite de commande. Le contrôleur 📄 RegistrationController.php a été créé.

Hasher et sécuriser le mot de passe

Pour des raisons de sécurité évidente, nous n’allons pas sauvegarder les mots de passe en base de données tels quels. Symfony va donc rendre ces mots de passe illisibles grâce à un objet appelé hacheur, pour que nous puissions les enregistrer sans risque. Cette transformation sera à sens unique et nous ne prenons ainsi pas le risque que quelqu’un décrypte ces mots de passe.

Comme vous pouvez le deviner en lisant ces lignes, c’est l’endroit où nous pouvons choisir de quelle façon nous allons hacher les mots de passe de chaque classe d'utilisateur que nous pourrions avoir. Ici par exemple, nous choisissons auto, ce qui veut dire que nous laissons Symfony choisir le bon algorithme, pour toutes les classes qui implémentent PasswordAuthenticatedUserInterface, comme notre classe User. L’algorithme utilisé pour hasher le mot de passe est spécifié dans le fichier de configuration 📄 security.yaml.

Configurer l’authentification (login/logout, firewall, providers)

Pour faire fonctionner la déconnexion « logout », il faut simplement créer la route. Pour déconnecter un utilisateur, il faut dans un premier temps créer une route associée au chemin /logout. La particularité de cette route est qu’il n’est pas nécessaire de lui implémenter de logique via une méthode de contrôleur.

On configure aussi les liens /login et /logout à utiliser, les différents roles possible (ROLE_USER, ROLE_ADMIN) et bien sur les droits d’accès en fonctions des rôles. Lorsqu’un utilisateur se connecte au site web, Symfony appelle la méthode getRoles() sur l’entité User afin de récupérer les rôles de l’utilisateur en question.

Le firewall, en français pare-feu, est au cœur de l’authentification d’une application Symfony. Nous avons donc déjà deux firewalls paramétrés : dev et main. Vous pouvez avoir autant de firewalls que vous le souhaitez. Chaque firewall s’applique uniquement aux URL correspondant à la clé pattern de sa configuration. Si vous ne renseignez pas de pattern, le firewall s’applique à toute l’application. En clair, Symfony applique le premier firewall qui correspond au chemin et n’applique pas les suivants.

Configurer le provider et les sources d'utilisateurs

Entity User provider : Charge les utilisateurs stockés en base de données via Doctrine. LDAP User Provider : Charge les utilisateurs depuis un serveur LDAP. Memory User Provider : Charge les utilisateurs depuis un fichier de configuration. Chain User Provider : Fusionne deux ou davantage de user providers en un nouveau.

De la même manière, le provider par défaut users_in_memory utilisé par le pare-feu a été remplacé par app_user_provider. La commande make:user exécutée précédemment a rajouté le nom de notre UserProvider à la clé provider du firewall main.

Créer l’authenticator et les templates

Pour pouvoir authentifier nos utilisateurs, nous allons avoir besoin de configurer un objet appelé Authenticator. Symfony embarque nativement un nombre assez important d’Authenticators parmi les plus communs : formulaire de login, lien de login, authentification JSON… Pour les formulaires, utilisez la commande symfony console make:auth (ATTENTION : depuis l'écriture de certains tutoriels, make:auth a été déprécié et remplacé par la commande security).

Cette commande génère plusieurs fichiers, y compris UsersAuthenticator.php dans src/Security, SecurityController.php dans src/Controller, et login.html.twig dans templates/security. Dans le fichier src/Security/UserAuthenticator.php, ouvrez la méthode onAuthenticationSuccess() pour définir un chemin de redirection personnalisé.

Il est temps de passer à la configuration. Pour avoir accès à nos route « /register » et « /login » de nos controllers il nous faut créer les 2 templates appelés par ceux-ci. Ces 2 templates dépendent de « base.html.twig », c’est à dire le fichier « /templates/base.html.twig ».

Protéger les zones selon les rôles (espace membre / admin)

Le dernier point à voir, c’est la création des « espace membre » et « espace administrateur » limité selon les rôles de l’utilisateur. Il suffit pour cela, en accord avec la configuration faite dans « /config/packages/security.yaml » de faire commencer les routes par « /member » ou « /admin » selon ce que l’on souhaite.

Nombreux sont les sites web nécessitant la mise en place d’un espace membre. Pas d’espace membre possible sans utilisateur. Ainsi, j’ai inclus ici un menu vers différente page de l’application : les page d’inscription/connnexion ou de déconnexion si on est connecté. Ainsi qu’une page d’accueil, et un espace membre et/ou espace admin en fonction du rôle de l’utilisateur connecté.

CSRF, validation et protection

La faille CSRF (Cross-Site Request Forgery) est liée à une vulnérabilité de l’authentification d’un site web. Pour se protéger contre les attaques CSRF, une mesure de sécurité courante consiste à demander au serveur de générer aléatoirement un jeton unique nommé token CSRF, puis de le transmettre au client. Lors de la soumission d’un formulaire, ce token est envoyé au serveur via un champ de formulaire caché. Sa présence et validité permettront ainsi d’attester que l’utilisateur effectue bien cette action de son plein gré.

Assurez-vous que tous les champs requis sont correctement validés et que les contraintes de sécurité sont en place. Vous pouvez ajouter des contraintes supplémentaires dans RegistrationFormType.php et configurer les messages d'erreur appropriés.

Options avancées et ergonomie : lien magique, remember me, SSO

La connexion par lien magique permet à vos utilisateurs de s’authentifier sur vos applications sans avoir à saisir le moindre mot de passe. Ce mode de connexion présente plusieurs avantages non négligeables : la simplicité apportée évite à vos utilisateurs d’être détournés de leur objectif premier : réaliser une action, finaliser une commande, bref : votre taux de conversion pourrait également être impacté positivement.

La question « Do you want to support remember me? » lors de la génération de l’authentificateur vise à déterminer si vous souhaitez inclure la fonctionnalité « Remember Me » dans votre système d’authentification. Si vous répondez « yes », Symfony inclura alors le support pour « Remember Me ». Vous pouvez choisir « Activate when the user checks a box » ou « Always activate remember me » selon le comportement souhaité.

Pour des besoins d’intégration externes, il est possible de mettre en place un SSO via JWT ou des providers (Okta, KeyCloak, Google, etc.). miniOrange fournit une authentification des utilisateurs à partir de diverses sources externes et peut être intégrée à Symfony.

5 - Inscription et Authentification des utilisateurs (Symfony 7)

Checklist pratique pour ajouter une valeur personnalisée à l’inscription

Créer/mettre à jour l’entité User dans /src/Entity/User.php (ajouter prénom, nom, roles, champ personnalisé).
Générer le formulaire d’inscription : symfony console make:registration-form ou créer /src/Form/UserType.php manuellement.
Ajouter les champs personnalisés (ex. description, profil) et les valider dans RegistrationFormType.php.
Hasher le mot de passe via le service PasswordHasher configuré dans security.yaml (option 'auto' pour laisser Symfony choisir).
Mettre à jour la base de données : symfony console doctrine:schema:update --force.
Créer le controller d’enregistrement /src/Controller/RegistrationController.php et rediriger après inscription ($this->redirectToRoute).
Ajouter les templates (base.html.twig, register.html.twig, login.html.twig) et adapter le front (Bootstrap 4 si souhaité).
Configurer security.yaml : providers, firewalls, access_control pour /member et /admin.
Vérifier CSRF, contraintes de validation et tests d’inscription et connexion.

Exemple de champ personnalisé : description dynamique

Vous pouvez composer une description personnalisée à l'enregistrement, par exemple :

$description = ’Je suis ’ . ucfirst($user->getFirstName()) . ’ ’ . mb_strtoupper($user->getLastName()) . ’, mon anniversaire est le ’ .

Cet exemple montre comment construire une chaîne descriptive en combinant des attributs de l’entité User. Vous pouvez enregistrer cette valeur dans une propriété dédiée de l’entité et l’exposer via l’API ou les templates.

Ressources et bonnes pratiques

Consultez la documentation officielle du SecurityBundle pour approfondir la configuration des firewalls et access_control.
Testez les routes /register et /login pour vérifier l’enregistrement et l’authentification.
Protégez la page d’enregistrement si nécessaire (retirer ou restreindre l’accès une fois les comptes créés).
Envisagez des options d’authentification modernes : lien magique, SSO, JWT selon vos besoins.

Étape	Commande / Fichier
Créer entité User	/src/Entity/User.php ou symfony console make:user
Formulaire d’inscription	symfony console make:registration-form ou /src/Form/UserType.php
Authentification	symfony console make:auth (ou security), /src/Security/*
Migrations BDD	symfony console doctrine:schema:update --force
Configuration sécurité	/config/packages/security.yaml

balises: