🎯 Pourquoi l'authentification ?

📚 Les 3 piliers de l'authentification Symfony

1. L'entité User

class User implements UserInterface, PasswordAuthenticatedUserInterface
{
    // Propriétés de l'utilisateur
}

→ Contient toutes les informations de l'utilisateur (email, mot de passe, rôles...)

2. Le User Provider

providers:
    app_user_provider:
        entity:
            class: App\Entity\User
            property: email

→ Dit à Symfony où et comment trouver les utilisateurs

3. Le Firewall

firewalls:
    main:
        provider: app_user_provider
        form_login:
            login_path: app_login

→ Définit les règles de sécurité et les méthodes d'authentification

🛠️ Étape 1 : Créer l'entité User

php bin/console make:user

Questions interactives :

Code généré :

#[ORM\Entity(repositoryClass: UserRepository::class)]
#[ORM\UniqueConstraint(name: 'UNIQ_IDENTIFIER_EMAIL', fields: ['email'])]
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 180, unique: true)]
    private ?string $email = null;

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

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

🔧 Les méthodes clés de l'entité User

1. getUserIdentifier()

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

2. getRoles()

public function getRoles(): array
{
    $roles = $this->roles;
    // Garantir que tout utilisateur a au moins ROLE_USER
    $roles[] = 'ROLE_USER';
    
    return array_unique($roles);
}

3. eraseCredentials()

public function eraseCredentials(): void
{
    // Effacer les données sensibles temporaires
    // $this->plainPassword = null;
}

⚙️ Configuration security.yaml

1. Password Hashers

security:
    password_hashers:
        App\Entity\User:
            algorithm: auto  # Symfony choisit le meilleur algorithme

2. Providers

providers:
    app_user_provider:
        entity:
            class: App\Entity\User
            property: email  # Chercher par email

3. Firewall principal

firewalls:
    main:
        lazy: true
        provider: app_user_provider
        
        form_login:
            login_path: app_login
            check_path: app_login
            default_target_path: app_dashboard
            enable_csrf: true
            
        logout:
            path: app_logout
            target: app_home
            
        remember_me:
            secret: '%kernel.secret%'
            lifetime: 604800  # 1 semaine

🚦 Access Control - Qui va où ?

Configuration des accès

access_control:
    - { path: ^/login, roles: PUBLIC_ACCESS }
    - { path: ^/register, roles: PUBLIC_ACCESS }
    - { path: ^/admin, roles: ROLE_ADMIN }
    - { path: ^/profile, roles: ROLE_USER }

Hiérarchie des rôles

role_hierarchy:
    ROLE_ADMIN: ROLE_USER
    ROLE_SUPER_ADMIN: [ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]

🎮 Contrôleur de connexion

php bin/console make:auth

Méthode login()

#[Route('/login', name: 'app_login')]
public function login(AuthenticationUtils $authenticationUtils): Response
{
    // Si déjà connecté, rediriger
    if ($this->getUser()) {
        return $this->redirectToRoute('app_dashboard');
    }

    // Récupérer l'erreur de connexion s'il y en a une
    $error = $authenticationUtils->getLastAuthenticationError();
    
    // Dernier nom d'utilisateur saisi
    $lastUsername = $authenticationUtils->getLastUsername();

    return $this->render('security/login.html.twig', [
        'last_username' => $lastUsername,
        'error' => $error,
    ]);
}

Méthode logout()

#[Route('/logout', name: 'app_logout')]
public function logout(): void
{
    // Cette méthode peut rester vide
    // Symfony intercepte la route automatiquement
}

🎨 Template de connexion

Structure du formulaire

{% extends 'base.html.twig' %}

{% block body %}
    {# Affichage des erreurs #}
    {% if error %}
        

            {{ error.messageKey|trans(error.messageData, 'security') }}
        
    {% endif %}

    {# Message de bienvenue si déjà connecté #}
    {% if app.user %}
        

            Vous êtes connecté en tant que {{ app.user.userIdentifier }}
        
    {% endif %}

    

        {# Token CSRF obligatoire #}
        

        {# Email #}
        Email
        

        {# Mot de passe #}
        Mot de passe
        

        {# Se souvenir de moi #}
        

            
                 Se souvenir de moi
            
        

        Se connecter
    
{% endblock %}

📝 Système d'inscription

php bin/console make:registration-form

Contrôleur d'inscription

#[Route('/register', name: 'app_register')]
public function register(
    Request $request, 
    UserPasswordHasherInterface $userPasswordHasher, 
    EntityManagerInterface $entityManager
): Response {
    $user = new User();
    $form = $this->createForm(RegistrationFormType::class, $user);
    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        // Encoder le mot de passe
        $user->setPassword(
            $userPasswordHasher->hashPassword(
                $user,
                $form->get('plainPassword')->getData()
            )
        );

        // Sauvegarder en base
        $entityManager->persist($user);
        $entityManager->flush();

        // Message de succès
        $this->addFlash('success', 'Compte créé avec succès !');

        return $this->redirectToRoute('app_login');
    }

    return $this->render('registration/register.html.twig', [
        'registrationForm' => $form->createView(),
    ]);
}

📋 FormType d'inscription

class RegistrationFormType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('email', EmailType::class, [
                'label' => 'Adresse email',
                'attr' => ['class' => 'form-control']
            ])
            ->add('plainPassword', RepeatedType::class, [
                'type' => PasswordType::class,
                'mapped' => false,
                'first_options' => [
                    'label' => 'Mot de passe',
                    'attr' => ['class' => 'form-control']
                ],
                'second_options' => [
                    'label' => 'Confirmer le mot de passe',
                    'attr' => ['class' => 'form-control']
                ],
                'invalid_message' => 'Les mots de passe ne correspondent pas.',
                'constraints' => [
                    new NotBlank(['message' => 'Entrez un mot de passe']),
                    new Length([
                        'min' => 6,
                        'minMessage' => 'Le mot de passe doit contenir au moins {{ limit }} caractères',
                        'max' => 4096,
                    ]),
                ],
            ])
            ->add('agreeTerms', CheckboxType::class, [
                'mapped' => false,
                'label' => 'J\'accepte les conditions d\'utilisation',
                'constraints' => [
                    new IsTrue(['message' => 'Vous devez accepter nos conditions.']),
                ],
            ]);
    }
}

🔐 Protection des routes

Méthode 1 : Attribut IsGranted (Recommandé)

use Symfony\Component\Security\Http\Attribute\IsGranted;

#[Route('/admin', name: 'app_admin')]
#[IsGranted('ROLE_ADMIN')]
public function admin(): Response
{
    return $this->render('admin/index.html.twig');
}

Méthode 2 : Dans le contrôleur

public function dashboard(): Response
{
    // Vérifier et lancer une exception si pas autorisé
    $this->denyAccessUnlessGranted('ROLE_USER');
    
    // Récupérer l'utilisateur connecté
    $user = $this->getUser();
    
    return $this->render('dashboard/index.html.twig', [
        'user' => $user
    ]);
}

Méthode 3 : Vérification manuelle

public function profile(): Response
{
    if (!$this->isGranted('ROLE_USER')) {
        throw $this->createAccessDeniedException('Accès refusé');
    }
    
    // Suite du code...
}

🎨 Authentification dans Twig

Navigation adaptative

{# Vérifier si l'utilisateur est connecté #}
{% if app.user %}
    
{% else %}
    
{% endif %}

Vérification des rôles

{# Afficher le menu admin uniquement aux admins #}
{% if is_granted('ROLE_ADMIN') %}
    

        
Administration
        Gérer les utilisateurs
        Paramètres
    
{% endif %}

{# Contenu différent selon le rôle #}
{% if is_granted('ROLE_PREMIUM') %}
    

        
    
{% else %}
    

        
Passez en Premium pour accéder à plus de fonctionnalités !
    
{% endif %}

⚠️ Erreurs courantes et solutions

Erreur 1 : "User must implement UserInterface"

// ❌ Incorrect
class User {
    // ...
}

// ✅ Correct
class User implements UserInterface, PasswordAuthenticatedUserInterface {
    // ...
}

Erreur 2 : Boucle de redirection infinie

access_control:
    - { path: ^/login, roles: PUBLIC_ACCESS }  # IMPORTANT !
    - { path: ^/register, roles: PUBLIC_ACCESS }

Erreur 3 : Mot de passe non haché

// ❌ JAMAIS faire ça !
$user->setPassword($plainPassword);

// ✅ Toujours hasher
$hashedPassword = $userPasswordHasher->hashPassword($user, $plainPassword);
$user->setPassword($hashedPassword);

🗄️ Base de données et migrations

Étape 1 : Configurer la base

# Dans .env ou .env.local
DATABASE_URL="mysql://root:password@127.0.0.1:3306/symfony_auth"

Étape 2 : Créer la base

# Créer la base de données
php bin/console doctrine:database:create

Étape 3 : Créer la migration

# Générer le fichier de migration
php bin/console make:migration

Étape 4 : Appliquer la migration

# Exécuter la migration
php bin/console doctrine:migrations:migrate

# Voir le statut des migrations
php bin/console doctrine:migrations:status

# Voir le SQL qui sera exécuté
php bin/console doctrine:migrations:migrate --dry-run

# Annuler la dernière migration (attention !)
php bin/console doctrine:migrations:migrate prev

✅ Checklist de vérification

🧪 Test de votre système

Scénario de test complet

Points de vérification :

# Démarrer le serveur de développement
php bin/console server:start

# Ouvrir dans le navigateur
# http://localhost:8000/register

🚀 Pour aller plus loin

Fonctionnalités avancées à implémenter

Félicitations !

Vous maîtrisez maintenant les bases de l'authentification Symfony !

Bon développement avec Symfony ! 🚀