Aller au contenu principal

Login LDAP

Utilisation d'un annuaire LDAP pour se connecter à un projet Symfony

Notions théoriques​

Un serveur LDAP (Lightweight Directory Access Protocol) est un service qui permet de :

  • stocker,
  • interroger,
  • et gérer des informations dans un annuaire.

Cet annuaire est une base de données spécialisée, généralement utilisée pour organiser et centraliser des données sur :

  • des utilisateurs,
  • des groupes,
  • des ordinateurs,
  • et d'autres ressources au sein d'une organisation.

L'annuaire LDAP est structuré sous forme d'un arbre hiérarchique. Chaque entrée dans cet arbre est composée de différents attributs qui représentent des informations spécifiques, comme :

  • le nom d'utilisateur (uid),
  • l'adresse email (mail),
  • le nom complet (cn),
  • etc.
info
  • Un serveur LDAP est souvent utilisé pour gérer des informations d'authentification (nom d'utilisateur et mot de passe) dans les entreprises.
  • Le protocole LDAP permet aux applications de s'interfacer avec un serveur LDAP pour valider l'identité des utilisateurs et contrôler leurs droits d'accès.

LDAP dans Symfony​

Prérequis​

  • Avoir un serveur LDAP fonctionnel (par exemple OpenLDAP ou Active Directory).
  • Un projet Symfony avec le composant Security installé.

Étapes de configuration​

1. Installer le composant ldap de Symfony​

Symfony dispose d'un composant dédié pour se connecter à un serveur LDAP. Il est nécessaire de l'installer si ce n’est pas déjà fait :

composer require symfony/ldap

2. Configurer les paramètres LDAP dans le fichier config/packages/security.yaml​

Voici un exemple de configuration LDAP pour un projet Symfony.

# config/packages/security.yaml
security:
    providers:
        ldap:
            ldap:
                service: Symfony\Component\Ldap\Ldap
                base_dn: "dc=example,dc=com"
                search_dn: "cn=admin,dc=example,dc=com"
                search_password: "password"
                default_roles: ROLE_USER
                uid_key: uid
                filter: "(uid={username})"
                connection_timeout: 5

    firewalls:
        main:
            anonymous: lazy
            provider: ldap
            form_login_ldap:
                service: Symfony\Component\Ldap\Ldap
                dn_string: "uid={username},dc=example,dc=com"
                login_path: /login
                check_path: /login

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

3. Créer le contrôleur de connexion​

Créer un contrôleur pour la gestion de la connexion des utilisateurs :

// src/Controller/SecurityController.php
namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
use Symfony\Component\Routing\Annotation\Route;

class SecurityController extends AbstractController
{
    /**
     * @Route("/login", name="app_login")
     */
    public function login(AuthenticationUtils $authenticationUtils): Response
    {
        // Récupérer les erreurs de connexion si elles existent
        $error = $authenticationUtils->getLastAuthenticationError();
        $lastUsername = $authenticationUtils->getLastUsername();

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

    /**
     * @Route("/logout", name="app_logout")
     */
    public function logout(): void
    {
        // Ce contrôleur peut être laissé vide : il sera intercepté par le firewall Symfony
    }
}

4. Créer la vue Twig pour le formulaire de connexion​

Dans le répertoire templates/security/login.html.twig, ajouter le formulaire de connexion :

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

{% block title %}Login{% endblock %}

{% block body %}
    <form method="post" action="{{ path('app_login') }}">
        {% if error %}
            <div>{{ error.messageKey|trans(error.messageData, 'security') }}</div>
        {% endif %}

        <label for="username">Username:</label>
        <input type="text" id="username" name="_username" value="{{ last_username }}" required>

        <label for="password">Password:</label>
        <input type="password" id="password" name="_password" required>

        <button type="submit">Login</button>
    </form>
{% endblock %}

Test de mémorisation/compréhension​


Que signifie le terme LDAP ?


Quel fichier de configuration Symfony est principalement utilisé pour définir l'authentification LDAP ?


Quel composant Symfony permet la connexion à un serveur LDAP ?


Quel est le rôle de `dn_string` dans la configuration LDAP de Symfony ?


Quel type de serveur est couramment utilisé pour héberger un annuaire LDAP ?


Quel attribut LDAP est généralement utilisé pour représenter l'identifiant unique d'un utilisateur ?


Dans la hiérarchie LDAP, comment s'appelle la racine de l'annuaire ?


Quel est l’avantage principal de l’utilisation de LDAP pour l'authentification dans Symfony ?


Lequel des éléments suivants n'est pas un attribut LDAP standard pour un utilisateur ?


Que permet de faire la méthode `getLastAuthenticationError` dans Symfony ?


TP pour réfléchir et résoudre des problèmes​

Objectif :​

Le but de ce TP est de configurer un serveur LDAP et de l'intégrer dans un projet Symfony pour authentifier les utilisateurs via cet annuaire.

Vous devrez :

  • installer un serveur LDAP localement,
  • ajouter des utilisateurs à cet annuaire,
  • et configurer Symfony pour qu'il utilise ces utilisateurs lors de l'authentification.

Voici les étapes à suivre :

Étape 1 : Installation de Docker sous Windows (si nécessaire)​

Si vous ne l'avez pas encore, installez Docker Desktop pour pouvoir exécuter des conteneurs sur votre machine. Suivez ces instructions :

  1. Télécharger Docker Desktop : Rendez-vous sur le site officiel de Docker et téléchargez Docker Desktop pour Windows.
  2. Installer Docker Desktop : Une fois téléchargé, suivez l'assistant d'installation.
  3. Vérifier le bon fonctionnement : Après l'installation, lancez Docker Desktop et assurez-vous qu'il fonctionne correctement. Vous pouvez tester en ouvrant un terminal et en exécutant une commande simple comme docker --version pour vérifier l'installation.

Étape 2 : Créer un serveur LDAP local​

Dans cette étape, vous allez utiliser Docker pour créer un serveur LDAP local.

  1. Télécharger et démarrer un conteneur OpenLDAP : Vous devrez trouver une image Docker appropriée (comme l'image officielle OpenLDAP) et la lancer sur votre machine en tant que conteneur.
  2. Définir les variables de configuration : Lors de la création du conteneur LDAP, définissez les paramètres de base comme l'organisation, le domaine, le mot de passe administrateur, etc.
  3. Vérifier que le serveur LDAP est opérationnel : Après avoir démarré le conteneur, assurez-vous que le serveur est accessible sur le bon port (habituellement le port 389 pour LDAP).

Étape 3 : Ajouter une interface de gestion LDAP​

Pour rendre la gestion des utilisateurs plus simple, nous allons utiliser phpLDAPadmin ou une autre interface web. Cela vous permettra de gérer les utilisateurs LDAP via une interface graphique.

  1. Démarrer un conteneur phpLDAPadmin : Utilisez Docker pour télécharger et démarrer une image Docker de phpLDAPadmin.
  2. Lier phpLDAPadmin à votre serveur LDAP : Assurez-vous que le conteneur phpLDAPadmin se connecte correctement à votre serveur OpenLDAP.
  3. Accéder à l'interface phpLDAPadmin : Ouvrez votre navigateur et connectez-vous à l'interface Web de phpLDAPadmin en vous servant des identifiants administratifs que vous avez définis lors de la configuration du serveur LDAP.

Étape 4 : Création des utilisateurs dans l'annuaire LDAP​

Maintenant que votre serveur LDAP est en place, vous devez créer des utilisateurs qui seront utilisés pour l'authentification dans Symfony.

  1. Se connecter à phpLDAPadmin : Connectez-vous en tant qu'administrateur à l'interface de gestion phpLDAPadmin.
  2. Créer de nouvelles entrées utilisateur : Dans l'interface, créez des utilisateurs en spécifiant les attributs nécessaires, comme le nom d'utilisateur, le mot de passe, et d'autres informations importantes (comme uid, cn, etc.).
  3. Vérifier les utilisateurs créés : Assurez-vous que les utilisateurs sont correctement enregistrés dans l'annuaire LDAP.

Étape 5 : Configurer l'authentification LDAP dans Symfony​

Vous allez maintenant intégrer votre serveur LDAP dans votre projet Symfony pour authentifier les utilisateurs.

  1. Installer le composant LDAP de Symfony : Symfony possède un composant dédié pour gérer les connexions à un annuaire LDAP. Installez ce composant si ce n'est pas déjà fait.
  2. Configurer le fichier de sécurité (security.yaml) : Dans Symfony, vous allez modifier le fichier de configuration de sécurité pour :
    • Ajouter un fournisseur d'utilisateur basé sur LDAP.
    • Configurer la connexion au serveur LDAP, incluant le base_dn, search_dn, uid, et le mot de passe d'administration.
    • Définir les rôles par défaut pour les utilisateurs authentifiés via LDAP.
    • Paramétrer un système de login et de vérification des identifiants via LDAP.
  3. Configurer les routes d'authentification : Vérifiez que les routes de votre application (comme /login) sont correctement configurées pour utiliser le firewall de Symfony avec LDAP.
  4. Créer un contrôleur de connexion : Si vous ne l'avez pas déjà, mettez en place un contrôleur pour gérer le formulaire de connexion.
  5. Créer le formulaire de connexion : Créez une vue Twig pour le formulaire de connexion, permettant aux utilisateurs de se connecter avec leur nom d'utilisateur et mot de passe définis dans LDAP.

Étape 6 : Tester la connexion LDAP dans Symfony​

Une fois la configuration terminée, vous devez tester l'authentification LDAP.

  1. Démarrer le serveur Symfony : Lancez votre serveur Symfony en mode développement.
  2. Accéder à la page de connexion : Ouvrez un navigateur et accédez à l'URL de la page de connexion de votre application (souvent /login).
  3. Tester l'authentification avec les utilisateurs LDAP : Essayez de vous connecter en utilisant les informations d'un utilisateur que vous avez créé dans votre serveur LDAP.
  4. Vérifier les droits d'accès : Assurez-vous que les utilisateurs se voient attribuer les bons rôles et qu'ils accèdent uniquement aux sections de l'application pour lesquelles ils ont les permissions nécessaires.

Étape 7 : Debugging et vérification​

Si l'authentification ne fonctionne pas comme prévu, voici quelques pistes pour vérifier la configuration :

  1. Vérifier la configuration LDAP : Assurez-vous que les informations de connexion au serveur LDAP sont correctes, notamment le base_dn, search_dn, et le mot de passe.
  2. Vérifier les logs de Symfony : Consultez les logs de Symfony pour toute erreur liée à l'authentification LDAP.
  3. Tester avec ldapsearch : Si nécessaire, vous pouvez utiliser un outil comme ldapsearch (via Docker ou un autre outil) pour vérifier que le serveur LDAP est bien accessible et que les utilisateurs existent.

Étape 8 : Bonus - Gestion des rôles dans LDAP​

Si vous le souhaitez, vous pouvez aller plus loin en :

  1. Créant des groupes dans LDAP : Ajoutez des groupes (comme admin, user, etc.) dans votre serveur LDAP.
  2. Attribuer des rôles basés sur ces groupes : Modifiez la configuration de Symfony pour attribuer des rôles en fonction des groupes LDAP auxquels un utilisateur appartient.
  3. Tester les permissions avancées : Testez votre application pour vous assurer que les utilisateurs avec différents rôles ont bien accès aux sections appropriées de l'application.

Résultats attendus :​

À la fin de ce TP, vous devriez avoir :

  • Un serveur LDAP fonctionnel hébergé en local via Docker.
  • Des utilisateurs définis dans l'annuaire LDAP.
  • Un projet Symfony configuré pour authentifier ces utilisateurs via LDAP.
  • La capacité de gérer les connexions utilisateur via une page de connexion Symfony et de vérifier les rôles attribués à chaque utilisateur.
Une solution