Création d'un jeton d'authentification
Contexte :
Vous allez tout d'abord utiliser et configurer le bundle Lexic Authentication JWT
dans une application Symfony sans API Platform.
Mais avant d'installer ce bundle, comprenez comment les JWT
fonctionnent.
Un JWT
est une chaine de caractères encodée qui doit être envoyée par le client à chaque requête. Cette chaîne de caractères permet à l'API d'authentifier l'utilisateur afin de lui permettre d'accéder à ses diverses fonctionnalités.
Afin que le serveur puisse identifier le client, le token doit se structurer en trois parties :
Un
header
enJSON
, contenant notamment l'algorithme utilisé pour générer la signature. Il décrit aussi le token.Un
payload
enJSON
, contenant les informations que l'on souhaite transmettre, par exemple l'identifiant de l'utilisateur.Une
signature
, très importante, créée à partir duheader
, dupayload
et d'une clé secrète.
Ces trois parties sont assemblées pour former le token.
Quand le client s'authentifie correctement, ce token, généré par le serveur, est envoyé au client. À chaque requête, le token est renvoyé par le client au serveur et il suffit au serveur de vérifier la signature afin de savoir si le token est valide. S'il est valide, alors les informations dans le payload peuvent être utilisées pour, par exemple, identifier l'utilisateur.
Ce processus est critique à la sécurité de l'application. C'est pour cela que l'on utilise des librairies éprouvées comme Lexic Authentication JWT
afin de créer et manipuler les JWT
.
Grâce à ce bundle, vous allez sécuriser votre API Symfony afin que seuls les utilisateurs authentifiés puissent accéder aux divers points d'API de vos articles.
Remarque :
Afin de bénéficier de points d'API déjà fonctionnels, une API déjà créée sera utilisée ici.
Avant de pouvoir utiliser le bundle, toutes les URLs doivent cependant être préfixées par « /api ». Il faut également qu'une entité User soit créée avec la commande make:auth
(rappel ici : Symfony Docs ) et qu'un utilisateur soit bien sûr enregistré en base de données.
Méthode :
Afin d'installer le bundle, il faut utiliser composer :
Exemple : Code
composer require lexik/jwt-authentication-bundle
Méthode :
La première étape est de générer des clés publiques et privées à l'aide, par exemple, de l'utilitaire OpenSSL
que vous pouvez installer sous Windows, Mac ou Linux. Ces clés seront utilisées par le bundle afin de signer et valider les tokens.
Dans le dossier « config » de l'application Symfony, créez un nouveau dossier « jwt ». Vous allez y stocker les clés. Placez vous dans ce dossier, cliquez droit « ouvrir dans un terminal » puis exécuter la ligne de commande suivante afin de générer la clé privée :
Exemple : Code
openssl genrsa -out private.pem -aes256 4096
Méthode :
Lors de la génération, un mot de passe devra être créé. Veuillez le conserver car il vous sera redemandé.
Vous allez créer la clé publique avec cette commande :
Exemple : Code
openssl rsa -pubout -in private.pem -out public.pem
Complément :
Voici une guidance sur la génération de clés sur OpenSSL.
Méthode :
Une fois ces clés générées, vous allez devoir renseigner leur chemin, ainsi que le mot de passe utilisé, dans des variables d'environnement spécifiques (à l'intérieur du fichier « .env.local »). Ces variables d'environnements sont utilisées par défaut par le fichier « config/package/lexik_jwt_authentication.yaml » afin de générer les tokens.
Exemple : Code
###> lexik/jwt-authentication-bundle ###
JWT_SECRET_KEY=%kernel.project_dir%/config/jwt/private.pem
JWT_PUBLIC_KEY=%kernel.project_dir%/config/jwt/public.pem
JWT_PASSPHRASE=MotDePasseUtiliséPourGénérerLesClefs
###< lexik/jwt-authentication-bundle ###
Méthode :
Maintenant que les clés sont générées et utilisables par le bundle pour authentifier les utilisateurs, il faut configurer les règles de sécurité de Symfony afin qu'il protège toutes les URLs d'API en utilisant le mécanisme de JWT
géré par le bundle. Ces informations sont à ajouter dans le fichier « config/packages/security.yaml » :
Exemple : Code
security
encoders
App\Entity\User
algorithm auto
providers
# used to reload user from session & other features (e.g. switch_user)
app_user_provider
entity
class App\Entity\User
property username
firewalls
dev
pattern ^/(_(profiler|wdt)|css|images|js)/
securityfalse
login
pattern ^/api/login
statelesstrue
anonymoustrue
json_login
check_path /api/login_check
success_handler lexik_jwt_authentication.handler.authentication_success
failure_handler lexik_jwt_authentication.handler.authentication_failure
api
pattern ^/api
statelesstrue
guard
authenticators
lexik_jwt_authentication.jwt_token_authenticatoraccess_control
path ^/api/login roles IS_AUTHENTICATED_ANONYMOUSLY
path ^/api roles IS_AUTHENTICATED_FULLY
Dernière étape, il faut créer la route « /api/login » (celle renseignée dans le fichier de configuration de la sécurité) afin que le client puisse envoyer son nom et son mot de passe en POST
, à la suite de quoi le serveur lui renverra le token.
Dans le fichier routes.yaml, il faut ajouter les lignes suivantes :
Exemple : Code
authentication_token
path /api/login
methods'POST'
Et le tour est joué !
Désormais, toutes les URLs commençant par « /api » nécessitent une authentification et ne sont pas accessibles tant que l'utilisateur n'envoie pas dans sa requête un token valide.
Pour récupérer ce token, le client doit faire une requête POST
sur l'URL : « /api/login ». Cette requête doit contenir dans le body le nom de l'utilisateur ainsi que son mot de passe. Si ces identifiants sont valides, alors votre API, à l'aide du bundle, retourne un token au client.
Ensuite, pour accéder aux ressources de votre API, le client doit renseigner pour chaque requête ce token dans un header
« authorisation
» de type « Bearer Token
». Si le token est validé, alors votre serveur donne au client le droit d'accéder aux URLs demandées.
Votre API est maintenant sécurisée !
Fondamental :
Dans une API, les utilisateurs sont généralement authentifiés en utilisant le mécanisme de
JWT
, aliasJSON Web Token
.Quand un client s'authentifie auprès de l'API, l'API lui renvoie un token. Ce token sera utilisé par le client à chaque nouvelle requête afin de vérifier son identité.
La génération et la gestion de ces tokens sont un processus complexe et critique pour la sécurité de l'application et il est conseillé d'utiliser des librairies connues pour mettre en place ces fonctionnalités.
Dans une application Symfony, le bundle
Lexic Authentication JWT
peut être utilisé.