Aller au contenu principal

Login LDAP

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

Schéma

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.

Bonne pratique - Toujours vérifier une installation avec --version

Après l'installation de Docker, exécuter docker --version confirme que l'outil est dans le PATH et opérationnel. Cette vérification rapide évite de diagnostiquer des erreurs bizarres 30 minutes plus tard quand l'outil est simplement absent du terminal.

É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 : Trouver une image Docker appropriée et la lancer sur votre machine.
  2. Définir les variables de configuration : Lors de la création du conteneur LDAP, définissez les paramètres de base (organisation, domaine, mot de passe administrateur).
  3. Vérifier que le serveur LDAP est opérationnel : Après avoir démarré le conteneur, assurez-vous qu'il est accessible sur le port 389.

Bonne pratique - Nommer les conteneurs Docker

L'option --name ldap-service facilite la gestion des conteneurs. Au lieu de mémoriser un ID hexadécimal, on peut utiliser docker stop ldap-service, docker start ldap-service ou référencer ce conteneur depuis un autre conteneur (comme phpLDAPadmin) par son nom.

Étape 3 : Ajouter une interface de gestion LDAP​

Pour rendre la gestion des utilisateurs plus simple, nous allons utiliser phpLDAPadmin.

  1. Démarrer un conteneur phpLDAPadmin : Utiliser Docker pour lancer phpLDAPadmin.
  2. Lier phpLDAPadmin à votre serveur LDAP : Le conteneur phpLDAPadmin doit se connecter à votre serveur OpenLDAP.
  3. Accéder à l'interface phpLDAPadmin : Ouvrir votre navigateur et se connecter avec les identifiants administratifs.

Bonne pratique - Utiliser le nom du conteneur comme nom d'hôte

PHPLDAPADMIN_LDAP_HOSTS=ldap-service utilise le nom du conteneur OpenLDAP comme adresse réseau. Docker crée automatiquement un réseau interne où les conteneurs se trouvent par leur nom. C'est plus robuste qu'une adresse IP qui peut changer au redémarrage.

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

Maintenant que votre serveur LDAP est en place, créez des utilisateurs dans l'annuaire.

  1. Se connecter à phpLDAPadmin : Connexion en tant qu'administrateur à https://localhost:6443.
  2. Créer de nouvelles entrées utilisateur : Créer des utilisateurs en spécifiant les attributs nécessaires (uid, cn, mot de passe, etc.).
  3. Vérifier les utilisateurs créés : S'assurer que les utilisateurs sont correctement enregistrés dans l'annuaire LDAP.

Bonne pratique - L'attribut uid_key fait le lien entre LDAP et Symfony

La valeur de uid_key dans security.yaml doit correspondre à l'attribut LDAP qui contient l'identifiant de connexion. Par défaut uid, mais certains annuaires Active Directory utilisent sAMAccountName. Adapter uid_key à votre configuration LDAP si la connexion échoue.

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

Vous allez maintenant intégrer votre serveur LDAP dans votre projet Symfony.

  1. Installer le composant LDAP de Symfony : Installer le composant dédié.
  2. Configurer security.yaml : Ajouter le provider LDAP, configurer le firewall et les contrôles d'accès.
  3. Créer le contrôleur de connexion : Route /login et formulaire Twig.

Bonne pratique - Ne jamais stocker le mot de passe LDAP en clair dans .yaml

Le search_password dans security.yaml est le mot de passe du compte d'administration LDAP. En production, le stocker dans .env comme variable d'environnement et y référencer via %env(LDAP_ADMIN_PASSWORD)%. Ne jamais versionner un mot de passe en clair dans un fichier de configuration.

Étape 6 : Tester la connexion LDAP dans Symfony​

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

  1. Démarrer le serveur Symfony : Lancer en mode développement.
  2. Accéder à la page de connexion : Ouvrir /login dans le navigateur.
  3. Tester l'authentification : Se connecter avec les identifiants d'un utilisateur LDAP.
  4. Vérifier les droits d'accès : S'assurer que les rôles sont correctement attribués.

É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 : S'assurer que base_dn, search_dn et le mot de passe sont corrects.
  2. Vérifier les logs de Symfony : Consulter var/log/dev.log pour les erreurs.
  3. Tester avec ldapsearch : Utiliser un outil pour vérifier que le serveur LDAP est accessible et que les utilisateurs existent.

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

Si vous le souhaitez, aller plus loin en :

  1. Créant des groupes dans LDAP : Ajouter des groupes (admin, user, etc.) dans votre serveur LDAP.
  2. Attribuant des rôles basés sur ces groupes : Modifier la configuration de Symfony pour attribuer des rôles en fonction des groupes LDAP.
  3. Testant les permissions avancées : Vérifier que les utilisateurs avec différents rôles accèdent aux bonnes sections de l'application.

Bonne pratique - LDAP pour centraliser la gestion des utilisateurs

Dans un environnement d'entreprise, LDAP évite de dupliquer les comptes utilisateurs dans chaque application. Un utilisateur qui quitte l'organisation est désactivé une seule fois dans l'annuaire, et perd automatiquement l'accès à toutes les applications configurées avec ce LDAP. C'est le principe du SSO (Single Sign-On).

📌 Une solution