Symfony 5.3.6 authentification notions avancée / PHP8

Symfony 5.3.6 authentification notions avancée / PHP8

Catégories : symfony5

Mots-clés : Applications Mobiles API php8 apache symfony5 authentification administration

1434 lectures

Auteur : user Pol-doe

Date :

Salut,

Ce que je te propose ici c'est de pouvoir authentifier uniquement à l'aide de certain user-agent mais il faut t'être ouvert d'esprit cela pourrait être une api ou autre chose…

Dans un premier temps je te propose d'installer un projet symfony: 

  • symfony new my_project_name --full
    ou 
    composer create-project symfony/website-skeleton my_project_name
     
  • Ici  je ne vais pas détailler ces commandes ni les suivantes si tu es là tu les connais .
     


check point :  Évidement si tout va bien vous avez l'accueil de Symfony 5.3
 

– make:user → email
– doctrine:schema:update  --force   ou  migrate  ect..

– make:auth → Login form authenticator → UserCustomAuthenticator
→ tu choisis  : Login form authenticator
→ Le nom de la class :  UserCustomAuthenticator
→ et par défaut : SecurityController
→ option logout : yes

→ bin/console make:register
→ @UniqueEntity : yes
→ send an email : no
→ automatically authenticate: no
→ redirected to :  app_login

Ici en gros on a une authentification traditionnelle qui va très bien en soit.

On va créer 3 contrôleurs:

le premier : → bin/console make:controller →HomeController 

le deuxième: → bin/console make:controller →User 

le troisième: → bin/console make:controller →OtherSecurityZoneArea 

→ Voilà on va configurer nos routes:

Contrôleur : HomeController

class HomeController extends AbstractController
{
    #[Route('/', name: 'home')]
    public function index(): Response
    {
        return $this->render('home/index.html.twig', [
            'controller_name' => 'HomeController',
        ]);
    }
}

 

Contrôleur : User (a modifier selon le code selon ce code ci-dessous)

#[Route('/user')]
class UserController extends AbstractController
{
    #[Route('/profile', name: 'profile')]
    public function index(): Response
    {
        return $this->render('user/index.html.twig', [
            'controller_name' => 'UserController PROFILE',
        ]);
    }
}


Contrôleur : OtherSecurityZoneArea (a modifier selon le code selon ce code ci-dessous)

#[Route('/otherzonearea')]
class OtherSecurityZoneAreaController extends AbstractController
{
    #[Route('/', name: 'other_security_zone_area')]
    public function index(): Response
    {
        return $this->render('other_security_zone_area/index.html.twig', [
            'controller_name' => 'OtherSecurityZoneAreaController',
        ]);
    }
    #[Route('/secret', name: 'other_security_zone_area_secret')]
    public function index2(): Response
    {
        return $this->render('other_security_zone_area/index.html.twig', [
            'controller_name' => 'OtherSecurityZoneAreaController SECRET',
        ]);
    }

 

check point : Ici tu vas vérifier si ça fonctionne 

 → ton-serveur/
 → ton-serveur/user/profile
 → ton-serveur/otherzonearea
 → ton-serveur/otherzonearea/secret

Pour être le juste possible je fais ce code au fur et à mesure voici  à quoi ressemble notre arborescence:

Là nous allons aller dans le fichier : 
 →config/packages/security.yaml
 
En bas du fichier écris ces lignes :

    access_control:
        - { path: ^/user/login, roles: PUBLIC_ACCESS }
        - { path: ^/user, roles: ROLE_USER }
        - { path: ^/otherzonearea, roles: ROLE_USER }

Maintenant re-teste ces liens:
 → ton-serveur/
 → ton-serveur/user/profile
 → ton-serveur/otherzonearea
 → ton-serveur/otherzonearea/secret

Comme tu le vois tu es redirigé .

***********************************************************************************
                                                Le tuto commence ici
***********************************************************************************

Symfony nous a crée un UserCustomAuthenticator 

Nous on va mettre un point d'entrée custom

Dans le dossier Security 
 → on crée un dossier  EntryPoint 
 → dans ce dossier on crée la class : CustomEntryPoint (Tu peux l'appeler “Brouette” selon les habitudes de la maison..)

Voilà à quoi ressemble arborescence:
 



On va commencer par créer la class :
 

namespace App\Security\EntryPoint;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Http\EntryPoint\AuthenticationEntryPointInterface;

class CustomEntryPoint implements AuthenticationEntryPointInterface
{
    public function start(Request $request, AuthenticationException $authException = null) : Response
    {
		dd('ici');
    }
}

Bon pour le moment c'est mystérieux mais laisse toi guider encore un peu.


On retourne au security.yaml
 → Et on rajoute : entry_point: App\Security\EntryPoint\CustomEntryPoint

        main:
            lazy: true
            entry_point: App\Security\EntryPoint\CustomEntryPoint
            provider: app_user_provider
            custom_authenticator: App\Security\UserCustomAuthenticator
            logout:
                path: app_logout

on fait encore une modif et tu vas comprendre le mécanisme :

Tu modifies UserCustomAuthenticator :  tu rajoutes la méthode supports

class UserCustomAuthenticator extends AbstractLoginFormAuthenticator
{

    public function supports(Request $request): bool
    {
        dd('la');
    }
    
    ....
}

 

Maintenant on va regarder ce qui ce passe :

testes :   → ton-serveur/user/profile

Si tu as tout fait tu dois tomber sur notre dd de UserCustomAuthenticator
 



Retourne dans la fonction UserCustomAuthenticator et supprime notre fonction : supports c'était juste pour te faire comprendre le cheminement .

Maintenant actualise à nouveau :  → ton-serveur/user/profile

Là tu vas voir : 

 

Ce qu'on vient de voir c'est quand tu veux accéder à une zone sécurisée :

 → tu entres dans UserCustomAuthenticator : function supports et si supports repond faux (qui se trouve dans la class mère ou cas où) 
la fonction support teste si on est en POST et que URI actuelle est == à URI login (/user/login) sinon elle renvoie faux 
 (si la condition est vraie c'est qu'on est entrain de se loguer)

 → tu entres dans entry_point soit notre class : CustomEntryPoint  puisque aucun Authenticator ne prend en charge la requête Symfony renvoie sur la route login dans le cheminement traditionnel, mais si tu as une autre logique si c'est une api au autre chose tu revois pour les navigateur le chemin login à une api peut etre une 403 ect..


Maintenant qu'est-ce qu'on doit faire ici ?
→ on va rediriger  tu vas modifier CustomEntryPoint comme cela:

namespace App\Security\EntryPoint;

use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Http\EntryPoint\AuthenticationEntryPointInterface;

class CustomEntryPoint implements AuthenticationEntryPointInterface
{
    public function __construct(Private UrlGeneratorInterface $urlGenerator){}

    public function start(Request $request, AuthenticationException $authException = null) : Response
    {
        return new RedirectResponse($this->urlGenerator->generate('app_login'));
    }
}
  

 

Pour résumer là on est au point de départ, symfony fonctionne comme avant :

 check point : Ici tu vas vérifier si ça fonctionne tu te log et délogue

 → ton-serveur/
 → ton-serveur/user/profile
 → ton-serveur/otherzonearea
 → ton-serveur/otherzonearea/secret

Et là tu te demandes on a fait cela pourquoi…. mais attends on commence à peine..

Là on va carrément faire notre class Authenticator pour authentifier Postman et uniquement Postman mais cela pourrait être des téléphones portables ou alors un contrôle de token Bearer

Si tu ne vois pas ce que c'est (Postman) j'ai vu un article ici sur ce sujet.

Dans le dossier Security tu vas créer la class CustomAuthenticator
Notre arborescence : 
 

 

 

namespace App\Security;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Http\Authenticator\InteractiveAuthenticatorInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\PassportInterface;

class CustomAuthenticator implements InteractiveAuthenticatorInterface
{

    public function supports(Request $request): ?bool
    {
        // TODO: Implement supports() method.
    }

    public function authenticate(Request $request): PassportInterface
    {
        // TODO: Implement authenticate() method.
    }

    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
    {
        // TODO: Implement createAuthenticatedToken() method.
    }

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
        // TODO: Implement onAuthenticationSuccess() method.
    }

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        // TODO: Implement onAuthenticationFailure() method.
    }

    public function isInteractive(): bool
    {
        // TODO: Implement isInteractive() method.
    }
}

Alors pas de panique, ces méthodes te seront proposées par ton IDE..

On doit aussi modifier notre security.yaml 
 

On a rajouté ça : - App\Security\CustomAuthenticator

On va commencer, dans l'ordre on va indiquer à Symfony si on prend en charge cette requête :
Tu te rappeler la méthode supports ben c'est la même.. 

    public function supports(Request $request): ?bool
    {
       return str_starts_with($request->getPathInfo(), '/otherzonearea') && $request->isMethod('POST') ;
    }

la fonction support est le point d'entrée de notre class,  on test si c'est URI qu'on veut prendre en charge et si c'est la méthode est POST

Mais pour rester cohérent on va modifier aussi notre contrôleur  : OtherSecurityZoneAreaController
 

#[Route('/otherzonearea')]
class OtherSecurityZoneAreaController extends AbstractController
{
    #[Route('/', name: 'other_security_zone_area',methods: ['POST'])]
    public function index(): Response
    {
        return new JsonResponse(['message' => 'otherzonearea'. date('d-m-y h:i:s')],Response::HTTP_OK);
    }
    #[Route('/secret', name: 'other_security_zone_area_secret',methods: ['POST'])]
    public function index2(): Response
    {
        return new JsonResponse(['message' => 'otherzonearea-secret'. date('d-m-y h:i:s')],Response::HTTP_OK);
    }
}

On lui dit juste qu'on accepte que les requêtes POST et on répond en JSON. 

La seconde méthode est : authenticate 

Et là si tu est fatigué, fais un tour, bois un café ou vas dormir et reviens on va coder…

Le but de authenticate est de retourner un passeport mais c'est quoi..?

Un passeport est une class qui va contenir un badge utilisateur (UserInterface) et un badge Credentials (password) et evt. un  badge CsrfToken tu sais ce qui se trouve caché dans ton formulaire de soumission.
 

    public function __construct(private UserProviderInterface $userProvider,){}

    public function authenticate(Request $request): PassportInterface
    {
        $email = $request->server->get('PHP_AUTH_USER', '');
        $pwd = $request->server->get('PHP_AUTH_PW', '');
        return new Passport(
            new UserBadge($email, [$this->userProvider, 'loadUserByIdentifier']),
            new PasswordCredentials($pwd)
        );
    }

 

On ne peut pas encore tester alors on continue mais on part dans l'idée que l'authentification a réussi

On doit continuer je t'explique après..

On va faire la class  createAuthenticatedToken  

 

    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
    {
        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
    }

Ici on va créer un token utilisé par le moteur interne de Symfony qui va être injecter dans la session par exemple.


On continue avec createAuthenticatedToken    

 

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
            return null;
    }

 

Ici nous on va retourner null mais tu pourrais retourner une redirection selon les conditions et  le contexte de ton application.

check point :  on va faire un test avec Postman
 

Si tu as tout fait tu envoies ton user avec postman en POST à :  → ton-serveur/otherzonearea

Tu va recevoir un code 200 et un petit message

On va attaquer maintenant un problème de login

Avec la méthode onAuthenticationFailure  :

Ici on doit fournir la réponse adéquate en cas d'erreur

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        return new JsonResponse(['error' => 'UNAUTHORIZED'], Response::HTTP_UNAUTHORIZED);
    }

Ici simplement on va répondre non autorisé mais on revient après par là.

check point :  on va faire un test avec Postman

Si tu as tout fait tu envoies ton user avec postman en POST à :  → ton-serveur/otherzonearea avec un mauvais password



On récapitule voilà la class en entier:
 


namespace App\Security;

use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Http\Authenticator\InteractiveAuthenticatorInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Credentials\PasswordCredentials;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\PassportInterface;

class CustomAuthenticator implements InteractiveAuthenticatorInterface
{
    /**
     * @param UserProviderInterface $userProvider
     */
    public function __construct(private UserProviderInterface $userProvider,
    ){}

    /**
     * @param Request $request
     * @return bool|null
     */
    public function supports(Request $request): ?bool
    {
       return str_starts_with($request->getPathInfo(), '/otherzonearea') && $request->isMethod('POST') ;
    }

    /**
     * @param Request $request
     * @return PassportInterface
     */
    public function authenticate(Request $request): PassportInterface
    {
        $email = $request->server->get('PHP_AUTH_USER', '');
        $pwd = $request->server->get('PHP_AUTH_PW', '');
        return new Passport(
            new UserBadge($email, [$this->userProvider, 'loadUserByIdentifier']),
            new PasswordCredentials($pwd)
        );
    }

    /**
     * @param PassportInterface $passport
     * @param string $firewallName
     * @return TokenInterface
     */
    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
    {
        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
    }

    /**
     * @param Request $request
     * @param TokenInterface $token
     * @param string $firewallName
     * @return Response|null
     */
    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
        return null;
    }

    /**
     * @param Request $request
     * @param AuthenticationException $exception
     * @return Response|null
     */
    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        return new JsonResponse(['error' => 'UNAUTHORIZED'], Response::HTTP_UNAUTHORIZED);
    }

    public function isInteractive(): bool
    {
        return true;
    }
}


Bon mais on a un problème c'est qu'on laisse passer tout le monde pour autant que l'user et le pass soient corrects

On va régler cela :

Tu vas créer dans le dossier security un dossier badges et dedans une class : UserAgentBadge

Notre arborescence : 

 

Voici notre class :

namespace App\Security\badges;

use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;

class UserAgentBadge implements BadgeInterface
{

    public function isResolved(): bool
    {
        // TODO: Implement isResolved() method.
    }
}

Bon et tu vas la modifier ainsi :
 

namespace App\Security\badges;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;

class UserAgentBadge implements BadgeInterface
{
    private bool $resolved;

    public function __construct(private Request $request){
        $this->resolved =  str_starts_with($this->request->headers->get("user-agent"), 'Postman');
    }

    public function isResolved(): bool
    {
        return $this->resolved;
    }
}

Le but d'un badge est de répondre par oui ou par non par la méthode :  isResolved() obligatoire
 

check point :  on va faire un test avec Postman

Si tu as tout fais tu envois ton user avec postman en POST à :  → ton-serveur/otherzonearea ton utilisateur avec le bon mot de passe 

Essaie un autre agent peu importe mets  ex :
$this->resolved =  str_starts_with($this->request->headers->get("user-agent"), 'Supermann');

Bon ça marche …  mais on a un problème on renvoie une 401 et pas une 403..

Bon alors on continue…

Dans le dossier Security  tu vas créer un dossier Exceptions et dedans une class UserAgentNotAuthorizedException

Notre arborescence :  

Et voila le code : 

namespace App\Security\Exceptions;

use Symfony\Component\Security\Core\Exception\AuthenticationException;

class UserAgentNotAuthorizedException extends AuthenticationException{}


Le but est d'utiliser Symfony avec notre nom de class

Maintenant on va modifier à nouveau : UserAgentBadge

namespace App\Security\badges;

use App\Security\Exceptions\UserAgentNotAuthorizedException;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;

class UserAgentBadge implements BadgeInterface
{
    private bool $resolved;

    public function __construct(private Request $request){
        $this->resolved =  str_starts_with($this->request->headers->get("user-agent"), 'tPostman');
    }

    public function isResolved(): bool
    {
        if (!$this->resolved)
            throw new UserAgentNotAuthorizedException('User Agent FORBIDDEN', Response::HTTP_FORBIDDEN);
        return $this->resolved;
    }
}


Comme tu le vois on dit dans la méthode  isResolved  si resolved est faux on rajoute une exception.

Maintenant tu t'en doutes on va modifier la class : CustomAuthenticator → onAuthenticationFailure  

Et tu dois te douter que dans cette méthode :    public function onAuthenticationFailure(Request $request, AuthenticationException $exception) 
l'argument AuthenticationException n'est pas là pour rien.

 

 

    /**
     * @param Request $request
     * @param AuthenticationException $exception
     * @return Response|null
     */
    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        $code  = 403;
        $message = 'FORBIDDEN';
 
        if($exception instanceof BadCredentialsException){
            $code  = 401;
            $message = $exception->getMessage();
        }else if ($exception instanceof UserAgentNotAuthorizedException) {
            $code  = $exception->getCode();
            $message = $exception->getMessage();
        }
        return new JsonResponse(['error' => $message], $code);
    }

    public function isInteractive(): bool
    {
        return true;
    }

 

check point :  Ici tu dois pouvoir gérer les connections avec Postman   tester un mauvais email ou pass ou d'autoriser Supermann au lieu de Postman .

Au cas où je te remets la class complète :

 

<?php
 
namespace App\Security;

use App\Security\badges\UserAgentBadge;
use App\Security\Exceptions\UserAgentNotAuthorizedException;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Http\Authenticator\InteractiveAuthenticatorInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Credentials\PasswordCredentials;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\PassportInterface;
use Symfony\Component\Security\Core\Exception\BadCredentialsException;

class CustomAuthenticator implements InteractiveAuthenticatorInterface
{
    /**
     * @param UserProviderInterface $userProvider
     */
    public function __construct(private UserProviderInterface $userProvider,
    ){}

    /**
     * @param Request $request
     * @return bool|null
     */
    public function supports(Request $request): ?bool
    {
       return str_starts_with($request->getPathInfo(), '/otherzonearea') && $request->isMethod('POST') ;
    }

    /**
     * @param Request $request
     * @return PassportInterface
     */
    public function authenticate(Request $request): PassportInterface
    {
        $email = $request->server->get('PHP_AUTH_USER', '');
        $pwd = $request->server->get('PHP_AUTH_PW', '');
        return new Passport(
            new UserBadge($email, [$this->userProvider, 'loadUserByIdentifier']),
            new PasswordCredentials($pwd),
            [
                new UserAgentBadge($request),
            ]
        );
    }

    /**
     * @param PassportInterface $passport
     * @param string $firewallName
     * @return TokenInterface
     */
    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
    {
        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
    }

    /**
     * @param Request $request
     * @param TokenInterface $token
     * @param string $firewallName
     * @return Response|null
     */
    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
        return null;
    }

    /**
     * @param Request $request
     * @param AuthenticationException $exception
     * @return Response|null
     */
    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        $code  = 403;
        $message = 'FORBIDDEN';

        if($exception instanceof BadCredentialsException){
            $code  = 401;
            $message = $exception->getMessage();
        }else if ($exception instanceof UserAgentNotAuthorizedException) {
            $code  = $exception->getCode();
            $message = $exception->getMessage();
        }
        return new JsonResponse(['error' => $message], $code);
    }

    public function isInteractive(): bool
    {
        return true;
    }
} 

 

Bon la tu vas devoir imaginer car je suis a court d'idée dans ton user tu as des préférences que tu gères et tu interdis l'accès à certaines ressources n'oublie pas que tu as la méthode supports et que tu fais comme tu veux!

Allez on fait quelques modifs:

On va dans le terminal 

→ bin/console make:entity → User
→ et on ajoute secretaccess
→ type :  boolean
→ nullable: true

et on termine avec un :
→ doctrine:schema:update  --force ou  migrate  ect..

On va créer un nouveau badge avec la class → SecretAccessBadge

Et dans le dossier Security tu vas créer un dossier Subscribers
Et dedans tu vas créer une class SecretAccessBadgeSubscriber

Notre arborescence :  
 

On va commencer par SecretAccessBadge enfin son squelette :
 

namespace App\Security\badges;


use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;

class SecretAccessBadge implements BadgeInterface
{
    private bool $resolved = false;



    public function isResolved(): bool
    {
        return $this->resolved;
    }
}

 

On passe maintenant à SecretAccessBadgeSubscriber
 

namespace App\Security\Subscribers;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class SecretAccessBadgeSubscriber implements EventSubscriberInterface
{

    public static function getSubscribedEvents()
    {
        // TODO: Implement getSubscribedEvents() method.
    }
}

Maintenant on doit lui dire sur quel événement on veut se connecter :
Nous on veut voir les événements passeport donc → CheckPassportEvent::class => 'onCheckPassportEvent',

Notre class ressemble maintenant à ça:

namespace App\Security\Subscribers;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Security\Http\Event\CheckPassportEvent;

class SecretAccessBadgeSubscriber implements EventSubscriberInterface
{
    public function onCheckPassportEvent(CheckPassportEvent $event)
    {

    }

    public static function getSubscribedEvents()
    {
        return [
            CheckPassportEvent::class => 'onCheckPassportEvent',
        ];
    }
}

Alors on est câblé on continu:
Bon je te montre la class et je l'explique :
 

namespace App\Security\Subscribers;


use App\Security\badges\SecretAccessBadge;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Event\CheckPassportEvent;

class SecretAccessBadgeSubscriber implements EventSubscriberInterface
{

    public function onCheckPassportEvent(CheckPassportEvent $event)
    {
        // On recupere le passeport 
        /** @var Passport $passport */
        $passport = $event->getPassport();
        
        // Comme on est abonné à tous les événements on controle que le passeport contient ces badges
        if ($passport->hasBadge(SecretAccessBadge::class) === false) {
            return;
        }
        // Voir plus haut 
        if ($passport->hasBadge(UserBadge::class) === false) {
            return;
        }

        /** @var UserBadge $badgeUser */
        $badgeUser = $passport->getBadge(UserBadge::class);
        $secretAccessBadge = $passport->getBadge(SecretAccessBadge::class);

        // Ici on a les instances donc on va checker
        /** @var SecretAccessBadge $badgeToken */
        $secretAccessBadge->check($badgeUser->getUser());

    }

    public static function getSubscribedEvents()
    {
        return [
            CheckPassportEvent::class => 'onCheckPassportEvent',
        ];
    }
}


A / On vérifie que l'événement nous concerne il doit avoir nos deux badges
B / On récupère nos instances 
C / On va exécuter → $secretAccessBadge->check($badgeUser->getUser())  sur SecretAccessBadge (elle arrive plus bas).
 

Et pourquoi on a fait comme ça cette fois ci à cause de l'utilisateur afin d'avoir son instance de UserInterface et la passer à notre badge SecretAccessBadge, je te montre juste une technique rien n'est vraiment figé….

Il est vrai qu'il y a mieux comme exemple mais bon.

On va encore créer une class dans Exceptions → SecretAccessException

namespace App\Security\Exceptions;

use Symfony\Component\Security\Core\Exception\AuthenticationException;

class SecretAccessException extends AuthenticationException{}

C'est la même chose que l'autre fois..

Bon on retourne à notre class → SecretAccessBadge

namespace App\Security\badges;


use App\Repository\UserRepository;
use App\Security\Exceptions\SecretAccessException;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;

class SecretAccessBadge implements BadgeInterface
{
    private bool $resolved = false;

    public function __construct(private UserRepository $userRepository)
    {
    }


    public function check(?UserInterface $userBadge){
        if($userBadge){
           $this->resolved = ($this->userRepository->findOneBy(['email'=>$userBadge->getUserIdentifier()]))->getSecretaccess()??false;
        }
    }

    public function isResolved(): bool
    {
        if (!$this->resolved)
            throw new SecretAccessException('FORBIDDEN', Response::HTTP_FORBIDDEN);
        return $this->resolved;
    }
}




Donc dans la méthode check  on vérifie si cet utilisateur a droit à cette ressource par exemple . (secretaccess true/false)


Bon tu dois savoir qu'il y a plusieurs type de passeport si on travaillerait avec un token bearer j'aurais utilisé plutôt SelfValidatingPassport mais si ce tuto présente un intérêt je ferais un complément.. 

Bon attends c'est pas fini c'est le bonus !

Mais pour faire ça on va modifier security.yaml
 

        main:
            lazy: true
            entry_point: App\Security\EntryPoint\CustomEntryPoint
            provider: app_user_provider
            custom_authenticator:
                - App\Security\UserCustomAuthenticator
                - App\Security\CustomAuthenticator
                  
            login_throttling:
                max_attempts: 2
                interval: '2 minutes'

 Tu vas rajouter la partie login_throttling 

Et là tu vas avoir une erreur

 
Bon  t'as compris → composer require symfony/rate-limiter
Bon plus d'erreur ouf..

Ce composant limite le nombre d'erreur par minute(s)

Mais ok mais nous on veut le notifier à notre utilisateur.
ok alors on modifie onAuthenticationFailure

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        $code = 403;
        $message = 'FORBIDDEN';
        if ($exception instanceof TooManyLoginAttemptsAuthenticationException) {
            $code = Response::HTTP_UNAUTHORIZED;
            $message = 'Too many failed login attempts, please try again in a few minutes.';
            $MessageData = $exception->getMessageData();
            if (is_array($MessageData)) {
                if (key_exists('%minutes%', $MessageData)) {
                    $message = $exception->getMessageKey();
                    $message = str_replace("%minutes%", $MessageData['%minutes%'], $message);
                }
            }
        } else if ($exception instanceof BadCredentialsException) {
            $code = 401;
            $message = $exception->getMessage();
        } else if ($exception instanceof UserAgentNotAuthorizedException) {
            $code = $exception->getCode();
            $message = $exception->getMessage();
        }
        return new JsonResponse(['error' => $message], $code);
    }


Et ici la class au complet si j'ai oublie de te dire un truc comme d'où vient le UserRepository..

<?php

namespace App\Security;

use App\Repository\UserRepository;
use App\Security\badges\SecretAccessBadge;
use App\Security\badges\UserAgentBadge;
use App\Security\Exceptions\UserAgentNotAuthorizedException;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\Exception\TooManyLoginAttemptsAuthenticationException;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Http\Authenticator\InteractiveAuthenticatorInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Credentials\PasswordCredentials;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\PassportInterface;
use Symfony\Component\Security\Core\Exception\BadCredentialsException;

class CustomAuthenticator implements InteractiveAuthenticatorInterface
{
    /**
     * @param UserProviderInterface $userProvider
     */
    public function __construct(private UserProviderInterface $userProvider,
                                private UserRepository        $userRepository
    )
    {
    }

    /**
     * @param Request $request
     * @return bool|null
     */
    public function supports(Request $request): ?bool
    {
        return str_starts_with($request->getPathInfo(), '/otherzonearea') && $request->isMethod('POST');
    }

    /**
     * @param Request $request
     * @return PassportInterface
     */
    public function authenticate(Request $request): PassportInterface
    {
        $email = $request->server->get('PHP_AUTH_USER', '');
        $pwd = $request->server->get('PHP_AUTH_PW', '');

        return new Passport(
            new UserBadge($email, [$this->userProvider, 'loadUserByIdentifier']),
            new PasswordCredentials($pwd),
            [
                new UserAgentBadge($request),
                new SecretAccessBadge($this->userRepository)
            ]
        );
    }

    /**
     * @param PassportInterface $passport
     * @param string $firewallName
     * @return TokenInterface
     */
    public function createAuthenticatedToken(PassportInterface $passport, string $firewallName): TokenInterface
    {
        return new UsernamePasswordToken($passport->getUser(), null, $firewallName, $passport->getUser()->getRoles());
    }

    /**
     * @param Request $request
     * @param TokenInterface $token
     * @param string $firewallName
     * @return Response|null
     */
    public function onAuthenticationSuccess(Request $request, TokenInterface $token, string $firewallName): ?Response
    {
        return null;
    }

    /**
     * @param Request $request
     * @param AuthenticationException $exception
     * @return Response|null
     */
    public function onAuthenticationFailure(Request $request, AuthenticationException $exception): ?Response
    {
        $code = 403;
        $message = 'FORBIDDEN';
        if ($exception instanceof TooManyLoginAttemptsAuthenticationException) {
            $code = Response::HTTP_UNAUTHORIZED;
            $message = 'Too many failed login attempts, please try again in a few minutes.';
            $MessageData = $exception->getMessageData();
            if (is_array($MessageData)) {
                if (key_exists('%minutes%', $MessageData)) {
                    $message = $exception->getMessageKey();
                    $message = str_replace("%minutes%", $MessageData['%minutes%'], $message);
                }
            }
        } else if ($exception instanceof BadCredentialsException) {
            $code = 401;
            $message = $exception->getMessage();
        } else if ($exception instanceof UserAgentNotAuthorizedException) {
            $code = $exception->getCode();
            $message = $exception->getMessage();
        }
        return new JsonResponse(['error' => $message], $code);
    }

    public function isInteractive(): bool
    {
        return true;
    }
}

 

Bon là tu sais presque tout soit curieux ouvre le capot de symfony  il y a les autres passeport
 

Si tu es arrivé jusque là bravo et peut être à une prochaine.