En revanche , il n’est pas prévu nativement avec symfony de demander confirmation au moment d’accéder à une page spécifique. Cela peut être très utile sur des pages sensibles de demander confirmation via un OTP(email, sms) ou un code TOTP (Google Authenticator).

Nous allons voir ici, comment mettre en place ce système de re-confirmation d’accès. L’ensemble du code est disponible ici: https://github.com/alamirault/protected-area

Pour proteger une page nous voulons uniquement ajouter une annotation à une action ou a un controlleur.

// src/Controller/AccountController.php

/**
 * @ProtectedArea(name="critical-access")
 * @Route("/account", name="account")
 */
public function account(): Response
{
    return $this->render('account/index.html.twig');
}

// src/Annotation/ProtectedArea.php

/**
 * @Annotation
 */
class ProtectedArea
{
    public string $name;
}

Au moment de se rendre sur les pages qui ont une annotation de protection, nous devons vérifier que les conditions sont remplies (OTP valide). Si ce n’est pas le cas, nous devons les demander tant que ce n’est pas valide. Nous allons donc faire cela grâce à un subscriber.

// src/EventSubscriber/ProtectedAreaSubscriber.php

// On écoute l'évènement 'kernel.controller'
public static function getSubscribedEvents()
{
    return [
        'kernel.controller' => 'onKernelController',
    ];
}

public function onKernelController(ControllerEvent $event)
{
    // On vérifie qu'il y a l'annotation ProtectedArea
    // On verifie que la zone protégée n'est pas déja validée
    // Si ce n'est pas le cas on redirige vers le formulaire d'OTP

if (!is_array($controllers = $event->getController())) {
    return;
}
$request = $event->getRequest();

list($controller, $methodName) = $controllers;

$protectedAreaAnnotation = $this->getAnnotation($controller, $methodName);
if(!$protectedAreaAnnotation){
    return;
}

$sessionKey = $this->protectedAreaSessionManager->getSessionKey($protectedAreaAnnotation);

// If no protected area process, or process is not finished
if (!$request->getSession()->get($sessionKey) || $request->getSession()->get($sessionKey)["status"] != ProtectedAreaSessionManager::OK) {
    $this->protectedAreaSessionManager->setRequestedProtectedAreaInSession($protectedAreaAnnotation, $request);

    //Internal redirect to form otp when user has not secured area in session.
    $event->setController(function () use ($request, $protectedAreaAnnotation) {
        return $this->forward($request, 'App\\Controller\\ProtectedAreaController::form', [
            'protected-area' => $protectedAreaAnnotation->name,
        ]);
    });
}

}

https://github.com/alamirault/protected-area/blob/master/src/EventSubscriber/ProtectedAreaSubscriber.php

Il nous faut maintenant créer le formulaire qui demande l’OTP et le valider. S’il est valide alors l’accès à la zone protégée est accepté.

/**
 * @Route("/protected-area")
 */
public function form(Request $request, ProtectedAreaSessionManager $protectedAreaSessionManager): Response
{
    $protectedAreaName = $request->query->get("protected-area");

    $protectedAreaData = $request->getSession()->get($protectedAreaSessionManager->getSessionKeyFromString($protectedAreaName));

    //Here send otp how you cant
    $otpSent = 'ABC-DEF';

    $form = $this->createForm(OtpType::class, null, [
        "otpSent" => $otpSent,
    ]);
    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        $data = $protectedAreaSessionManager->setAuthorizedProtectedAreaInSession($protectedAreaName, $request);

        //Return to original requested url
        return $this->redirect($data["protected_url"]);
    }
    return $this->render('protected_area/index.html.twig', [
        'form' => $form->createView(),
        'cancelUrl' => $protectedAreaData["cancel_url"],
        'protectedArea' => $protectedAreaName,
    ]);
}

La validation de l’OTP se fait dans l’OtpType. Quand le formulaire est valide, il suffit de mettre en session le fait que l’accès est autorisé et nous redirigons sur la page initiallement demandée. Le subscriber va vérifier les conditions, elles sont remplies, la page est affichée !

L’ajout de zone protégée peut rendre les tests fonctionnels plus complexes. Heureusement nous pouvons outre-passer toute cette partie en passant directement en sessions cette vérification.

protected function passProtectedArea(string $name = "critical-access")
{
    $session = static::$kernel->getContainer()->get("session");
    $session->set("protected-area-" . $name, [
        "status" => "OK",
    ]);
}

public function testAccountListing(): void {

    $this->passProtectedArea();
    // Test normal

}

L’ensemble du code est disponible ici: https://github.com/alamirault/protected-area

Si vous avez des remarques ou des commentaires n’hésitez pas. Vous pouvez également me contacter sur twitter : a_lamirault

<?php

namespace App\Form\Common;

use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;

class EnumType extends ChoiceType
{
    public function configureOptions(OptionsResolver $resolver): void
    {
        parent::configureOptions($resolver);

        $invalidMessageParametersNormalizer = static function(Options $options) {
            return [
                '{{ permissibleValues }}' => implode(', ', $options['choices']),
            ];
        };

        $resolver->setDefaults([
            'invalid_message' => "The value '{{ value }}' is not allowed. Permissible values: {{ permissibleValues }}",
            'invalid_message_parameters' => [],
        ]);

        $resolver->setNormalizer('invalid_message_parameters', $invalidMessageParametersNormalizer);
    }
}

https://gist.github.com/alamirault/b9701cb832899e920f918636f81643a9

Most of the app in PHP are linked with relational database. They have advantages and drawbacks but today I will not confront this model with NoSql database. Why? Because they don’t have the same goal. In my case I must store app logs (changes on entities, actions..) and must have the possibility to search it. ElasticSearch was the best solution and will talk about it.

Elasticsearch is easy to consume (Api REST), have a powerful full-text search mechanism and have a great scalabilty.

There is a lot of libraries in PHP in order to wrap http calls. Most famous are elasticsearch/elasticsearch-php (official), ruflin/elastica (my choice), friendsofsymfony/elastica-bundle…

Why I choose Elastica ? All searches are made with objects not with deep array! It’s very easy to compose and maintain code.

Elastica is amazing, but not enough. We have to manage our mapping, indexes, searches…

I decided to make my own bundle `alamirault/elasticsearch-form-bundle` in order to fix these problems. Mapping are defined by yaml, indexes are created automatically and we can manage forms!

Manage form is for me the most important. We want edit Elasticsearch search when user choose a value in a select, filter by date, by action.. With doctrine and SQL, the easiest way I found is lexik/form-filter-bundle. I was inspired by this bundle to works with elasticsearch.

Principle is very easy, when bundle is registered a new option `elastic_filter_condition` is available in FormTypes.

public function buildForm(FormBuilderInterface $builder, array $options)
        {
                    $builder->add('uuid', TextType::class, [
                        'elastic_filter_condition' => function (?string $value) {
                            if (is_null($value)) {
                                return;
                            }
        
                            return new Match('uuid', $value);
                        },
                    ])
        }

When value is filled, we want filtering documents with an uuid perfect match. On each form fields you have to implements the return of this option. Query parts are aggregated in a global query (MUST).

FormType is very easy but how manage it in my controller ? In all pages of my website search system is the same: create form, manage pagination query, sort direction, query search, submission etc…

public function indexAction(Request $request, FormFactoryInterface $formFactory, EntityManagerInterface $entityManager,
                                TranslatorInterface $translator, BoLogEntryDenormalizer $denormalizer)
    {
        $form = $formFactory->create(ExampleFilterType::class);

        $sortableChanges = $this->elasticsearchMaker->manageForm($form, $request, $this->indexRegistry,
            "changes", $denormalizer);

        return $this->render('AlamiraultLogsBundle:Changes:index.html.twig',
            [
                "form" => $form->createView(),
                "sortableChanges" => $sortableChanges,
            ]
        );
    }

The class ElasticsearchMaker make all the job with method manageForm. It takes search form with options elastic_filter_condition, request in order to submit form and also extract pagination settings, in which Index make search and a denormalizer in order to work with object. (I really hate works with arrays).

And that all ! This method returns an object SortableItems with only the N (defined by pagination settings) documents, sort fields, sort directions and the current page.

Of course is possible to compose your own logic calling only sort method, pagination or extract query of form.

It was a quick overview of my way to store data and especially have a powerful system allowing complex searches without pain !

If you have questions or if you have any comments feel free to contact me here or on twitter: a_lamirault

Have a good day !

Inspiration: https://jolicode.github.io/elasticsearch-php-conf/slides/#/

En ajoutant un facteur d’authentification nous assurons la protection de l’accès à un compte. Dans cet article j’ai fait le choix d’utiliser Google Authenticator en second facteur mais sachez qu’il y a d’autres principes plus ou moins compliqués à mettre en oeuvre.

Vous pouvez retrouver l’intégralité du code sur mon gihub, le tout sans bundle additionnel !

Authentification “Simple”

L’objectif est de limiter l’accès du dashboard aux utilisateurs qui n’ont pas rempli les deux facteurs.

src/Controller/DashboardController.php:

<?php

namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class DashboardController extends AbstractController
{
    /**
     * @Route("/dashboard", name="dashboard")
     */
    public function index()
    {
        return $this->render('dashboard/index.html.twig');
    }
}

config/packages/security.yaml:

security:

  providers :
    app_users:
      id: App\Security\CustomerProvider

  firewalls:
    dev:
      pattern: ^/(_(profiler|wdt)|css|images|js)/
      security: false

    main:
      anonymous: ~
      pattern: ^/
      guard:
          authenticators:
              - App\Security\CustomerAuthenticator
      logout:
        path:   app_logout
        target: app_login

  access_control:
    - { path: ^/login$, roles: IS_AUTHENTICATED_ANONYMOUSLY }
    - { path: ^/dashboard, roles: ROLE_USER }

Pour accéder à n’importe quelle page de notre application il faut passer le guard CustomerAuthenticator. La page login est accessible en ayant le rôle IS_AUTHENTICATED_ANONYMOUSLY (Non connecté).

src/Security/CustomerAuthenticator.php:

<?php

namespace App\Security;

use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
use Symfony\Component\Security\Core\Exception\InvalidCsrfTokenException;
use Symfony\Component\Security\Core\Security;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Csrf\CsrfToken;
use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
use Symfony\Component\Security\Guard\AbstractGuardAuthenticator;
use Symfony\Component\Security\Http\Util\TargetPathTrait;

class CustomerAuthenticator extends AbstractGuardAuthenticator
{

    use TargetPathTrait;

    /**
     * @var RouterInterface
     */
    private $router;
    /**
     * @var CsrfTokenManagerInterface
     */
    private $csrfTokenManager;
    /**
     * @var PasswordEncoder
     */
    private $passwordEncoder;
    /**
     * @var CustomerProvider
     */
    private $customerProvider;


    /**
     * DatabaseAuthenticator constructor.
     * @param RouterInterface $router
     * @param CsrfTokenManagerInterface $csrfTokenManager
     * @param UserPasswordEncoderInterface $passwordEncoder
     */
    public function __construct(RouterInterface $router, CsrfTokenManagerInterface $csrfTokenManager,
                                UserPasswordEncoderInterface $passwordEncoder, CustomerProvider $customerProvider)
    {
        $this->router = $router;
        $this->csrfTokenManager = $csrfTokenManager;
        $this->passwordEncoder = $passwordEncoder;
        $this->customerProvider = $customerProvider;
    }

    public function supports(Request $request)
    {
        return 'app_login' === $request->attributes->get('_route') && $request->isMethod('POST');
    }

    public function start(Request $request, AuthenticationException $authException = null)
    {
        $url = $this->router->generate('app_login');

        return new RedirectResponse($url);
    }

    public function getCredentials(Request $request)
    {
        $credentials = [
            'login' => $request->request->get('login'),
            'password' => $request->request->get('password'),
            'csrf_token' => $request->request->get('_csrf_token'),
        ];
        $request->getSession()->set(
            Security::LAST_USERNAME,
            $credentials['login']
        );

        return $credentials;
    }

    public function getUser($credentials, UserProviderInterface $userProvider)
    {
        $token = new CsrfToken('authenticate', $credentials['csrf_token']);
        if (!$this->csrfTokenManager->isTokenValid($token)) {
            throw new InvalidCsrfTokenException();
        }

        return $this->customerProvider->loadUserByUsername($credentials['login']);
    }

    public function checkCredentials($credentials, UserInterface $user)
    {
        return true; // Here you must check credentials with PasswordEncoder or by ldap connexion
    }

    public function onAuthenticationFailure(Request $request, AuthenticationException $exception)
    {
        $request->getSession()->set(Security::AUTHENTICATION_ERROR, $exception);
    }

    public function onAuthenticationSuccess(Request $request, TokenInterface $token, $providerKey)
    {
        $url = $this->router->generate('dashboard');
        if ($targetUrl = $this->getTargetPath($request->getSession(), $providerKey)) {
            $url = $targetUrl;
        }

        return new RedirectResponse($url);
    }

    public function supportsRememberMe()
    {
        return true;
    }
}

La méthode supports() indique que le CustomerAuthenticator sera exécuté si l’on est sur la page de login et que l’on vient de valider le formulaire (POST). Si cette condition est remplie alors la méthode getCredentials est appelée. Cela permet de formater les données à partir de la requête. Survient ensuite la récupération de l’utilisateur avec la méthode getUser. On vérifie dans un premier temps que le token CSRF est valide puis on récupère le user par son login grâce au CustomerProvider. Enfin on vérifie qu’il a le bon mot de passe dans la méthode checkCredentials. Dans cet exemple il n’y a pas de vérification. (Tout mot de passe est considéré comme valide). S’il y a la moindre exception AuthenticationException de levée elle est mise en session pour être affichée à l’utilisateur. Si ce n’est pas le cas et que tout est ok l’utilisateur est redirigé sur la page qu’il souhaitait accéder.

L’utilisateur peut maintenant se connecter à notre site avec son login et mot de passe. C’est la méthode préconisée par Symony.

Mise en place de Google Authenticator

Le principe de Google Authenticator est assez simple. Chaque utilisateur de votre site a un code secret. Il permet de générer un QrCode qu’il doit scanner dans l’application afin de générer des TOTP. L’utilisateur doit juste saisir ce code sur votre site et on doit s’assurer qu’il est valide avec le code secret.

Pour gérer la création des codes secrets et leurs vérifications j’ai choisi la library pragmarx/google2fa. Pour le QRCode bacon/bacon-qr-code. Vous pouvez utiliser bien entendu n’importe quelles autres paquets.

Il faut prévoir dans notre entité Customer un nouveau champ pour stocker le code secret. Celui-ci peut être null et sera enregistré uniquement quand l’utilisateur aura validé son code pour la première fois.

/**
 * @ORM\Column(type="string", length=16, nullable=true)
 */
private $googleAuthenticatorSecret;

public function getGoogleAuthenticatorSecret(): ?string
    {
        return $this->googleAuthenticatorSecret;
    }

public function setGoogleAuthenticatorSecret(?string $googleAuthenticatorSecret): self
    {
        $this->googleAuthenticatorSecret = $googleAuthenticatorSecret;

        return $this;
    }

Pour forcer l’utilisateur à rentrer son code Google Authenticator, nous allons rajouter un Subscriber qui redirigera sur une seconde page de login tant que l’utilisateur n’aura pas le role 2FA_SUCCEED.

<?php

namespace App\EventSubscriber;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Guard\Token\PostAuthenticationGuardToken;

class TwoFactorAuthenticationSubscriber implements EventSubscriberInterface
{
    const ROLE_2FA_SUCCEED = "2FA_SUCCEED";

    const FIREWALL_NAME = "main";
    const ROUTE_FOR_2FA = "two-factor";
    /**
     * @var TokenStorageInterface
     */
    private $tokenStorage;
    /**
     * @var RouterInterface
     */
    private $router;

    /**
     * TwoFactorAuthenticationSubscriber constructor.
     * @param TokenStorageInterface $tokenStorage
     * @param RouterInterface $router
     */
    public function __construct(TokenStorageInterface $tokenStorage, RouterInterface $router)
    {
        $this->tokenStorage = $tokenStorage;
        $this->router = $router;
    }


    public function onKernelRequest(GetResponseEvent $event)
    {
        if (!$event->isMasterRequest()) {
            return;
        }

        if (in_array($event->getRequest()->attributes->get('_route'), ["app_login", self::ROUTE_FOR_2FA])) {
            return;
        }


        if (($currentToken = $this->tokenStorage->getToken()) && $currentToken instanceof PostAuthenticationGuardToken) {
            if ($currentToken->getProviderKey() === self::FIREWALL_NAME) {
                if (!$this->hasRole($currentToken, self::ROLE_2FA_SUCCEED)) {
                    $response = new RedirectResponse($this->router->generate(self::ROUTE_FOR_2FA));
                    $event->setResponse($response);
                }
            }
        }
    }

    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::REQUEST => ['onKernelRequest', -10],
        ];
    }

    private function hasRole(TokenInterface $token, string $role): bool
    {
        foreach ($token->getRoles() as $userRole) {
            if ($userRole->getRole() === $role) {
                return true;
            }
        }
        return false;
    }
}

Cette page affiche un formulaire pour rentrer le code OTP ainsi que le QrCode s’il n’est pas encore enregistré dans l’entité Customer. Le secret est mis en session pour éviter d’être régénéré à chaque chargement de la page.

class TwoFactorAuthenticationController extends AbstractController
{
    /**
     * @Route("/two-factor", name="two-factor")
     * @param Request $request
     * @param TokenStorageInterface $tokenStorage
     * @param SessionInterface $session
     * @param EntityManagerInterface $entityManager
     * @return \Symfony\Component\HttpFoundation\RedirectResponse|\Symfony\Component\HttpFoundation\Response
     * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
     * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
     * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
     */
    public function twoFactorAction(Request $request, TokenStorageInterface $tokenStorage, SessionInterface $session,
                                    EntityManagerInterface $entityManager)
    {
        $form = $this->createForm(GoogleAuthenticatorType::class);

        $form->handleRequest($request);
        $google2fa = new Google2FA();

        $svg = null;

        /** @var Customer $customer */
        $customer = $this->getUser();
        if (!$customer->getGoogleAuthenticatorSecret()) {
            if ($session->get('2fa_secret')) {
                $secret = $session->get('2fa_secret');
            } else {
                $secret = $google2fa->generateSecretKey();
                $request->getSession()->set('2fa_secret', $secret);
            }

            $svg = $this->generateSvgForUser($google2fa, $customer, $secret);
        } else {
            $secret = $customer->getGoogleAuthenticatorSecret();
        }

        if ($form->isSubmitted() && $form->isValid()) {
            $code = $form->getData()["code"];
            $codeIsValid = $google2fa->verifyKey($secret, $code, 4);
            if ($codeIsValid) {
                if (!$customer->getGoogleAuthenticatorSecret()) {
                      $customer->setGoogleAuthenticatorSecret($secret);
                    $entityManager->persist($customer);
                    $entityManager->flush();
                }

                $this->addRoleTwoFA($tokenStorage, $session);

                return $this->redirectToRoute("dashboard");
            }
            $this->addFlash("error", "Invalid verification code");
        }

        return $this->render("security/two-factor.html.twig", [
            "svg" => $svg,
            "form" => $form->createView(),
        ]);
    }
}

La génération de l’url de QrCode prend le secret mais aussi le nom de site et le login utilisateur. Cela permettra à votre utilisateur de retrouver le bon code généré facilement parmi ses autres codes.

private function generateSvgForUser(Google2FA $google2FA, Customer $customer, string $secret): string
    {
        $g2faUrl = $google2FA->getQRCodeUrl(
            "My website",
            $customer->getLogin(),
            $secret
        );

        $writer = new Writer(
            new ImageRenderer(
                new RendererStyle(400),
                new SvgImageBackEnd() // can also user new ImagickImageBackEnd() in order to generate png
            )
        );

        return $writer->writeString($g2faUrl);
    }

Le plus important est l’ajout de rôle 2FA_SUCCEED à l’utilisateur quand le bon code est rentré. Pour cela on duplique le token actuel et on merge ce rôle avec les rôles existants de l’utilisateur. Il faut remplacer le token à la fois dans le TokenStorage et en session. Durant la redirection, le Subscriber remarque le nouveau rôle et n’intercepte pas la requête.

private function addRoleTwoFA(TokenStorageInterface $tokenStorage, SessionInterface $session): void
    {
        /** @var PostAuthenticationGuardToken $currentToken */
        $currentToken = $tokenStorage->getToken();
        $roles = array_merge($currentToken->getRoles(), [TwoFactorAuthenticationSubscriber::ROLE_2FA_SUCCEED]);
        $newToken = new PostAuthenticationGuardToken($currentToken->getUser(), $currentToken->getProviderKey(), $roles);
        $tokenStorage->setToken($newToken);
        $session->set('_security_' . $currentToken->getProviderKey(), serialize($newToken));
    }

Nous devons également modifier notre utilisateur pour qu’il implémente l’interface Symfony\Component\Security\Core\User\EquatableInterface. Cette interface permet à symfony de vérifier que notre utilisateur présent en session est identique à l’utilisateur qui a était rechargé après la redirection.

use Symfony\Component\Security\Core\User\EquatableInterface;
class User implements UserInterface, EquatableInterface
{
  ...
  public function isEqualTo(UserInterface $user){
      return $this->getEmail() === $user->getEmail()

  }

} 

Si vous avez des remarques ou des commentaires n’hésitez pas. Vous pouvez également me contacter sur twitter : a_lamirault