Atelier 6: Système d’authentification

Cet atelier propose la réalisation d’un système d’authentification simple en PHP orienté objet, utilisant PDO pour la connexion à une base de données MySQL. L’objectif est de créer un système complet comprenant une interface d’inscription, une interface de connexion, une page d’accueil personnalisée et une déconnexion sécurisée. Pour suivre cet atelier, il est nécessaire d’avoir un serveur local avec PHP, MySQL et un accès à phpMyAdmin ou un outil équivalent.

Objectifs

• Créer une base de données MySQL et une table pour stocker les utilisateurs.
• Développer une classe PHP USER avec les méthodes d’inscription, de connexion, de vérification de session, de redirection et de déconnexion.
• Mettre en place une page d’inscription sécurisée avec validation des données et gestion des erreurs.
• Mettre en place une page de connexion avec vérification des identifiants et gestion des sessions.
• Afficher une page d’accueil personnalisée pour l’utilisateur connecté.
• Permettre la déconnexion et la destruction sécurisée de la session utilisateur.

Prérequis et configuration

• Serveur local avec PHP et MySQL (ex : XAMPP, WAMP, MAMP).
• Accès à phpMyAdmin ou un autre outil pour gérer la base de données.
• Connaissances de base en PHP orienté objet et SQL.
• Fichiers CSS fournis pour le style des pages.
• Structure finale du projet respectant les fichiers : db_conf.php, class/user.php, index.php, sign-up.php, home.php, logout.php.

Création de la base de données et de la table "users"

Commencez par créer une base de données MySQL nommée inscription. Ensuite, créez la table users avec la structure suivante, soit via phpMyAdmin, soit en exécutant ce script SQL :

CREATE TABLE `inscription`.`users` (
  `user_id` INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
  `user_name` VARCHAR(255) NOT NULL,
  `user_email` VARCHAR(60) NOT NULL,
  `user_pass` VARCHAR(255) NOT NULL,
  UNIQUE (`user_name`),
  UNIQUE (`user_email`)
) ENGINE=INNODB;

Cette table stockera les informations des utilisateurs : identifiant, nom, email et mot de passe (haché).

Création de la classe USER

Créez un fichier class/user.php contenant la classe user qui gérera les opérations liées aux utilisateurs. Cette classe doit inclure les méthodes suivantes :

• __construct($DB_con) : constructeur qui reçoit la connexion PDO à la base de données.
• register($uname, $umail, $upass) : enregistre un nouvel utilisateur après avoir haché son mot de passe. Utilisez des requêtes préparées avec des paramètres nommés pour éviter les injections SQL.
• login($uname, $umail, $upass) : vérifie si l’utilisateur existe par nom ou email, puis valide le mot de passe avec password_verify. Si correct, crée une session.
• is_loggedin() : vérifie si une session utilisateur existe.
• redirect($url) : redirige vers une URL donnée.
• logout() : détruit la session pour déconnecter l’utilisateur.

Voici un extrait clé de la méthode register :

public function register($uname, $umail, $upass) {
  try {
    $new_password = password_hash($upass, PASSWORD_DEFAULT);
    $sql = "INSERT INTO users(user_name, user_email, user_pass) VALUES(:uname, :umail, :upass)";
    $req = $this->db->prepare($sql);
    $req->bindparam(":uname", $uname);
    $req->bindparam(":umail", $umail);
    $req->bindparam(":upass", $new_password);
    $req->execute();
    return $req;
  } catch(PDOException $e) {
    echo $e->getMessage();
  }
}

Assurez-vous que la classe est bien incluse et instanciée dans le fichier de configuration de la base de données db_conf.php.

Création du fichier de connexion db_conf.php

Ce fichier initialise la session, crée la connexion PDO à la base de données inscription et instancie la classe user. Voici le contenu essentiel :

<?php
session_start();

$DB_host = "localhost";
$DB_user = "root";
$DB_pass = "";
$DB_name = "inscription";

try {
  $DB_con = new PDO("mysql:host={$DB_host};dbname={$DB_name}", $DB_user, $DB_pass);
} catch(PDOException $e) {
  echo $e->getMessage();
}

include_once 'class/user.php';
$user = new USER($DB_con);
?>

Ce fichier doit être inclus dans toutes les pages nécessitant une connexion à la base de données et l’accès aux méthodes utilisateur.

Création de la page index.php (page d’identification)

La page index.php sert à connecter un utilisateur existant. Elle contient un formulaire demandant le nom d’utilisateur ou l’email, ainsi que le mot de passe. Après soumission, les données sont récupérées et la méthode login est appelée.

Si la connexion réussit, l’utilisateur est redirigé vers home.php. Sinon, un message d’erreur est affiché.

Extrait du traitement PHP :

if(isset($_POST['btn-login'])) {
  $uname = $_POST['txt_uname_email'];
  $umail = $_POST['txt_uname_email'];
  $upass = $_POST['txt_password'];

  if ($user->login($uname, $umail, $upass)) {
    $user->redirect('home.php');
  } else {
    $error = "informations erronées !";
  }
}

Le formulaire HTML doit contenir :

• Un champ texte pour le nom d’utilisateur ou email (txt_uname_email).
• Un champ mot de passe (txt_password).
• Un bouton de soumission nommé btn-login.

Un message d’erreur s’affiche si la connexion échoue.

Création de la page sign-up.php (page d’inscription)

La page sign-up.php permet à un nouvel utilisateur de s’inscrire. Le formulaire comprend trois champs : nom d’utilisateur, email et mot de passe.

Le script PHP vérifie :

• Que les champs ne sont pas vides.
• Que l’email est valide.
• Que le mot de passe fait au moins 6 caractères.
• Que le nom d’utilisateur et l’email ne sont pas déjà utilisés dans la base.

En cas d’erreurs, elles sont affichées sous forme d’alertes. Sinon, la méthode register est appelée pour ajouter l’utilisateur, puis une redirection vers la même page avec un paramètre ?joined est effectuée pour afficher un message de succès.

Extrait de la vérification et insertion :

if(isset($_POST['btn-signup'])) {
  $uname = trim($_POST['txt_uname']);
  $umail = trim($_POST['txt_umail']);
  $upass = trim($_POST['txt_upass']);
  $error = [];

  if($uname=="") {
    $error[] = "Vous devez saisir un nom d'utilisateur!";
  } else if($umail=="") {
    $error[] = "Vous devez saisir un email";
  } else if(!filter_var($umail, FILTER_VALIDATE_EMAIL)) {
    $error[] = 'Vous devez saisir un email valide';
  } else if($upass=="") {
    $error[] = "Vous devez saisir un mot de passe";
  } else if(strlen($upass) < 6) {
    $error[] = "Le mot de passe doit avoir au moins 6 caractères";
  } else {
    try {
      $req = $DB_con->prepare("SELECT user_name,user_email FROM users WHERE user_name=:uname OR user_email=:umail");
      $req->execute(array(':uname'=>$uname, ':umail'=>$umail));
      $ligne = $req->fetch(PDO::FETCH_ASSOC);

      if($ligne['user_name'] == $uname) {
        $error[] = "Désolé, le nom d'utilisateur existe déjà !";
      } else if($ligne['user_email'] == $umail) {
        $error[] = "Désolé, l'email existe déjà";
      } else {
        if ($user->register($uname, $umail, $upass)) {
          $user->redirect('sign-up.php?joined');
        }
      }
    } catch(PDOException $e) {
      echo $e->getMessage();
    }
  }
}

Le formulaire HTML doit inclure les champs txt_uname, txt_umail, txt_upass et un bouton btn-signup. Les messages d’erreur ou de succès sont affichés au-dessus du formulaire.

Création de la page home.php (page d’accueil)

Cette page est accessible uniquement si l’utilisateur est connecté. Sinon, il est redirigé vers index.php.

La page récupère les informations de l’utilisateur à partir de son identifiant stocké en session, puis affiche un message de bienvenue avec son nom d’utilisateur et son email. Un menu de navigation est présent, ainsi qu’un lien de déconnexion.

Extrait PHP :

if(!$user->is_loggedin()) {
  $user->redirect('index.php');
}

$user_id = $_SESSION['user_session'];
$req = $DB_con->prepare("SELECT * FROM users WHERE user_id=:user_id");
$req->execute(array(":user_id"=>$user_id));
$ligne = $req->fetch(PDO::FETCH_ASSOC);

Dans le corps HTML, affichez :

• Le nom d’utilisateur : <?php print($ligne['user_name']); ?>
• L’email dans le titre et le menu.
• Un lien vers logout.php pour se déconnecter.

Création de la page logout.php (page de déconnexion)

Cette page détruit la session utilisateur et redirige vers la page de connexion index.php. Elle commence par vérifier que l’utilisateur est connecté, sinon elle redirige également vers index.php.

Code PHP :

require_once 'db_conf.php';

if(!$user->is_loggedin()) {
  $user->redirect('index.php');
}

$user->logout();
$user->redirect('index.php');

Résultats attendus

• La base de données inscription contient une table users avec les colonnes spécifiées.
• La page sign-up.php permet d’enregistrer un nouvel utilisateur avec validation des données et messages d’erreur clairs.
• La page index.php permet à un utilisateur inscrit de se connecter avec son nom d’utilisateur ou son email et son mot de passe.
• Après connexion, la page home.php affiche un message de bienvenue personnalisé et propose un lien de déconnexion.
• La page logout.php déconnecte l’utilisateur et le redirige vers la page de connexion.
• Les sessions sont correctement gérées pour empêcher l’accès non autorisé aux pages protégées.

Pièges courants

• Ne pas utiliser de requêtes préparées avec paramètres nommés peut exposer à des injections SQL.
• Oublier de hacher le mot de passe avant de l’enregistrer dans la base de données.
• Ne pas vérifier si le nom d’utilisateur ou l’email existent déjà avant l’inscription, ce qui provoque des erreurs de duplication.
• Ne pas démarrer la session avec session_start() dans db_conf.php, ce qui empêche la gestion des sessions.
• Ne pas vérifier si l’utilisateur est connecté avant d’accéder à home.php ou logout.php, ce qui peut causer des erreurs ou des accès non autorisés.
• Confondre les variables dans la méthode register : utiliser $req pour préparer la requête, mais exécuter $stmt peut provoquer une erreur. Il faut utiliser la même variable.
• Ne pas afficher les messages d’erreur ou de succès dans les formulaires, ce qui rend difficile la compréhension des problèmes pour l’utilisateur.