4 - Un peu de sécurité

Une fois le modèle définis, il est désormais assez simple de créer les API selon le cahier des charges.

Le plus dur est de correctement la sécurisé, c'est cependant grandement simplifié avec Symfony et son composant de sécurité.

Une fois de plus, leur doc est un très bon point d'entré:

Security (Symfony 7.2 Docs)symfony

La doc officielle

Souvent ce bundle: https://symfony.com/bundles/LexikJWTAuthenticationBundle/current/index.html est utilisé pour gérer l'authentification via API. Cependant il est souvent mal compris, et il n'est pas difficile de créer son propre système.

Si vous souhaitez mieux comprendre comment fonctionne un JWT: https://www.vaadata.com/blog/fr/jetons-jwt-et-securite-principes-et-cas-dutilisation/

Gérer soit même la sécurité

Tout commence par l'installation du composant Symfony:

composer require symfony/security-bundle
composer require --dev maker

Une fois ces deux packages installés, on peut commencer le code.

Si vous n'avez pas d'entity User, vous pouvez la créer avec une commande du maker:

php bin/console make:user

Cette commande ne fait simplement que de générer une entité en lui ajoutant deux interfaces requises par le composant Security de symfony et en implémentant toutes les méthodes par défaut:

use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Component\Security\Core\User\UserInterface;


class User implements UserInterface, PasswordAuthenticatedUserInterface
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    public ?int $id = null;

    #[ORM\Column(length: 180)]
    public ?string $email = null;

    #[ORM\Column]
    public array $roles = [];

    #[ORM\Column]
    public ?string $password = null;

    public function getUserIdentifier(): string
    {
        return (string)$this->email;
    }

    public function getRoles(): array
    {
        $roles = $this->roles;
        $roles[] = 'ROLE_USER';

        return array_unique($roles);
    }

    public function getPassword(): ?string
    {
        return $this->password;
    }

    public function eraseCredentials(): void
    {
    }
}

Notre classe utilisateur est prête à être utiliser par la sécurité Symfony.

La commande make:user édite normalement la configuration du fichier de sécurité, pour lui dire que lorsque notre app aura besoin de charger un utilisateur, il se basera sur cette entité.

C'est toujours bien d'aller jeter un coup d'oeil au cas où.

# config/packages/security.yaml
security:
    ....
    providers:
        app_user_provider:
            entity:
                class: App\Entity\User
                property: email
    ....

Le provider défini comment (re)charger des utilisateurs depuis un stockage en fonction d'un "UserIdentifier".

Ici on utilise l'entityUserProvider de base fournis par symfony. On lui précise que l'entity à check est App\Entity\User et que la propiété qui sert de "UserIdentifier" est l'email.

Pour la suite on supposera que vous avez déjà des utilisateurs en base, et que vous connaissez le couple email/password d'un compte. (vous pouvez faire une Command de création d'user par exemple)

Comme pour le JWT, on souhaite faire un système d'auth via un Token. Il sera donc en 2 parties:

1. Authentification via email/password pour récupérer notre Token

2. Authentification via notre Token

Récupérer un token

Une fois de plus, Symfony fait quasiment tout pour nous et nous propose un JSON login authenticator, exactement ce qu'il nous faut pour notre API.

Pour l'utiliser c'est très simple, il nous suffit d'ajouter un nouveau Firewall dans notre fichier de config de la sécurité:

# config/packages/security.yaml
security:
    ....
    firewalls:
        dev: # pré-config par symfony
            ....
        api_login: # le notre
            pattern: /api/login
            stateless: true
            provider: app_user_provider
            json_login:
                check_path: api_login
                username_path: 'email'
        main: # pré-config par symfony
            ....

Les firewall dev et main sont présent par défaut avec Symfony, nous nous plaçons simplement entre les deux.

Ici la config est plutôt simple:

• api_login: le nom de notre nouveau firewall

• pattern: le pattern que l'url doit avoir pour que ce firewall s'applique (ici, l'url doit forcément être "/api/login")

• stateless: cela signifie que les informations des sessions ouvertes ne sont pas stockées côté serveur (contrairement au sessions/cookie)

• provider: le provider configuré plus tôt, pour indiquer à symfony comment charger notre utilisateur

• json_login.check_path: le nom de la route lié à notre authenticator

• json_login.username_path: customisation de la requête d'authentification pour lui dire qu'on veut envoyer un "email" dans notre requête JSON

Désormais nous devons créer notre controller:

php bin/console make:controller LoginController

Ce contrôleur de connexion sera appelé après que l'authenticator de Symfony ait authentifié l'utilisateur avec succès. Vous pouvez récupérer l'utilisateur authentifié, générer un token et renvoyer une réponse JSON

<?php

namespace App\Controller;

use App\Entity\User;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\CurrentUser;

class LoginController extends AbstractController
{
    #[Route('/api/login', name: 'api_login', methods: ['POST'])]
    public function index(#[CurrentUser] ?User $user): Response
    {
        if (null === $user) {
            throw $this->createAccessDeniedException();
        }

        return $this->json(['token' => 'votre-super-token', 'user' => $user->getUserIdentifier()]);
    }
}

⚠️ La config de votre attribut #[Route] doit suivre la config de votre firewall (l'url === la clé pattern, le name === la clé check_path)

Désormais si vous appelez /api/login avec les identifiants correct, vous devriez obtenir votre-super-token:

{
    "email": "[e-mail]",
    "password": "victor"
}

Nous devons maintenant générer un vrai token sécurisé.

Pour ce faire voici un exemple de service qui peut encoder/decoder un token:

<?php declare(strict_types=1);

namespace App\Security;

use Symfony\Component\DependencyInjection\Attribute\Autowire;

final readonly class Tokens
{
    public function __construct(
        #[Autowire(param: 'kernel.secret')]
        private string $secret,
    ) {
    }

    public function generateTokenForUser(string $email, \DateTime $expire = new \DateTime('+4 hours')): string
    {
        $encoded = json_encode([
            'email' => $email,
            'expire' => $expire->getTimestamp(),
        ]);

        return base64_encode(json_encode([
            $encoded,
            $this->sign($encoded)
        ]));
    }

    public function decodeUserToken(?string $token): ?string
    {
        try {
            [$info, $sign] = json_decode(base64_decode($token), true);

            if ($sign !== $this->sign($info)) {
                return null;
            }

            $info = json_decode($info, true);

            if ($info['expire'] < time()) {
                return null;
            }

            if (isset($info['email']) && filter_var($info['email'], FILTER_VALIDATE_EMAIL)) {
                return $info['email'];
            }

            return null;
        } catch (\Throwable) {
            return null;
        }
    }

    private function sign(string $encoded): string
    {
        return hash('sha256', $encoded.'/'.$this->secret);
    }
}

Ce service va venir créer un token sécurisé qui stock l'email de notre utilisateur via la fonction generateTokenForUser, c'est cette fonction que nous devrions utiliser dans notre LoginController pour récupérer le token et ainsi pouvoir s'authentifier dans le reste de l'API.

Authentification via notre token

Pour nous authentifer via notre Token, nous allons créer un Authenticator custom côté Symfony.

Pour cela, le concept de base est le même: on ajoute un firewall dans notre config.

# config/packages/security.yaml
security:
    ....
    firewalls:
        dev: # pré-config par symfony
            ....
        api_login: # celui créé précedemment
            ....
        api: # le nouveau
            pattern: ^/api/
            provider: app_user_provider
            stateless: true
            custom_authenticators:
                - App\Security\Authenticator\TokenAuthenticator
        main: # pré-config par symfony
            ....

Toujours le même schéma:

• pattern: le pattern que l'url doit avoir pour que ce firewall s'applique (ici, l'url doit forcément commencé par "/api/")

• stateless: cela signifie que les informations des sessions ouvertes ne sont pas stockées côté serveur (contrairement au sessions/cookie)

• provider: le provider configuré plus tôt, pour indiquer à symfony comment charger notre utilisateur

• custom_authenticators: l'autenthicator custom que nous allons utilisé pour checker si notre token est valide ou non.

L'ordre des firewalls est important ! Seul le premier match sera analysé

Nous devons maintenant créer l'authenticator qui sera chargé de checker à chaque requête commencant par /api si le token fournis est valide et donc nous connecter à l'API / nous refuser l'accès

<?php declare(strict_types=1);

namespace App\Security\Authenticator;

use App\Entity\User;
use App\Security\Tokens;
use Doctrine\ORM\EntityManagerInterface;
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\Exception\AuthenticationException;
use Symfony\Component\Security\Http\Authenticator\AbstractAuthenticator;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\SelfValidatingPassport;

final class TokenAuthenticator extends AbstractAuthenticator
{
    public function __construct(
        private readonly Tokens $tokens,
        private readonly EntityManagerInterface $em,
    ) {
    }

    public function supports(Request $request): ?bool
    {
        return $request->headers->has('Authorization');
    }

    public function authenticate(Request $request): Passport
    {
        $token = $request->headers->get('Authorization');

        return new SelfValidatingPassport(new UserBadge($token, function (string $token): ?User {
            if (null !== $email = $this->tokens->decodeUserToken($token)) {
                return $this->em->getRepository(User::class)->findOneBy(['email' => $email]);
            }

            return null;
        }));

    }

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

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

En bref, cet authenticator vérifie que notre requête courante à bien un header Authorization.

Si la requête à bien ce header, nous passerons dans la méthode authenticate qui sera chargé de vérifier le token fournis dans le header. Si il est valide, il nous retourne l'utilisateur lié à ce token, sinon il ne renverra rien.

Enfin, si l'auth ne fonctionne pas (dans le cas ou la méthode authenticate ne trouve pas d'utilisateur) , on passe dans la méthode onAuthenticationFailure qui se charge de renvoyer une réponse d'erreur et mets fin au process.

Toutes vos Api créer précédemment sont donc limité aux utilisateurs sans plus d'actions de votre part.

La suite est d'accorder de la granularité aux données visibles selon l'utilisateur connecté.