Utilisez PHP et MySQL pour implémenter un puissant système de contrôle des droits des utilisateurs

Dans les applications Web modernes, le contrôle des autorisations des utilisateurs est crucial. Pour garantir la sécurité et l'intégrité de votre application, vous devez restreindre l'accès des utilisateurs à des opérations et informations spécifiques, et définir les tâches spécifiques que les utilisateurs sont autorisés à effectuer. Dans cet article, je vais vous présenter comment utiliser PHP et MySQL pour créer un puissant système de contrôle des autorisations des utilisateurs afin de garantir la sécurité et l'intégrité de vos applications Web.

1. Conception des tables de la base de données

Dans la base de données MySQL, nous avons besoin d'au moins deux tables pour implémenter le système de contrôle des droits des utilisateurs. Le premier tableau enregistre les informations de base de tous les utilisateurs, notamment le nom d'utilisateur, le mot de passe et l'adresse e-mail. Le deuxième tableau est le tableau des autorisations, qui enregistre les autorisations de chaque rôle/groupe d'utilisateurs. Par conséquent, nous devons créer les deux tables suivantes dans la base de données :

1. users table

CREATE TABLE users ( users (
id int(11) NOT NULL AUTO_INCREMENT,
username varchar(50) NOT NULL,
password varchar(255) NOT NULL,
email varchar(100) NOT NULL,
PRIMARY KEY (id)
);

2. roles表

CREATE TABLE roles (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(50) NOT NULL,
PRIMARY KEY (id)
);

我们还需要一个将用户和角色关联的表。这个表将用户ID映射到角色ID。让我们来创建这个表。

3. role_user表

CREATE TABLE role_user (
role_id int(11) NOT NULL,
user_id int(11) NOT NULL,
PRIMARY KEY (role_id,user_id),
CONSTRAINT FK_role_user_role_id FOREIGN KEY (role_id) REFERENCES roles (id),
CONSTRAINT FK_role_id_user_id FOREIGN KEY (user_id) REFERENCES users (id id int(11) NON NULL AUTO_INCREMENT,
nom d'utilisateur varchar(50) NON NULL,

mot de passe code > varchar(255) NON NULL,<p> <code>email varchar(100) NON NULL,

PRIMARY KEY (id)

); # 🎜🎜#

roles table

CREATE TABLE rôles (

id int ( 11) NON NULL AUTO_INCREMENT,

nom varchar(50) NON NULL,

PRIMARY KEY (id)
2. );#🎜 🎜 #
Nous avons également besoin d'un tableau qui associe les utilisateurs aux rôles. Ce tableau mappe les ID utilisateur aux ID de rôle. Créons ce tableau.

role_user table

3. CREATE TABLE role_user (

role_id int (11) NON NULL,

user_id int(11) NON NULL,

PRIMARY KEY (role_id,user_id) ,

CONTRAINTE FK_role_user_role_id CLÉ ÉTRANGÈRE (role_id) RÉFÉRENCES rôles (id),

CONTRAINTE FK_role_id_user_id CLÉ ÉTRANGÈRE (user_id) RÉFÉRENCES users (id)

);
2. Implémentation du système de contrôle des droits des utilisateurs

Maintenant que nous avons créé les tables de base de données requises, nous pouvons commencer à implémenter le système de contrôle des droits des utilisateurs pour notre application. Voici quelques concepts de base :

2. role

Un rôle est une structure logique qui associe un ensemble d'autorisations entre elles. Par exemple, nous pouvons créer un rôle « Administrateur » et accorder toutes les autorisations administratives à ce rôle.

3. Permissions

Les autorisations sont les droits de contrôle d'une certaine fonction. Par exemple, afficher, créer, modifier et supprimer des utilisateurs sont des autorisations différentes. L'octroi de ces autorisations à des rôles spécifiques limite l'accès des utilisateurs.

4. Utilisateur

Un utilisateur est un individu qui interagit avec une application. Chaque utilisateur se verra attribuer un ou plusieurs rôles, qui définissent les actions qu'il peut effectuer et auxquelles il peut accéder.

Voyons maintenant comment mettre en œuvre ce système.

Créer un utilisateur#🎜🎜##🎜🎜##🎜🎜#Pour chaque nouvel utilisateur, nous devons créer un enregistrement d'utilisateur correspondant. Nous créerons un enregistrement dans le tableau « utilisateurs » pour chaque utilisateur, comprenant le nom d'utilisateur, le mot de passe et l'adresse e-mail. Utilisez le code suivant pour créer l'utilisateur. #🎜🎜#

function create_user($username, $password, $email) {
  // Encrypt password
  $encrypted_password = password_hash($password, PASSWORD_DEFAULT);

  // Prepare SQL statement
  $sql = "INSERT INTO users (username, password, email) VALUES (?, ?, ?)";

  // Bind parameters
  $stmt = $conn->prepare($sql);
  $stmt->bind_param("sss", $username, $encrypted_password, $email);

  // Execute statement
  if ($stmt->execute()) {
    return true;
  } else {
    return false;
  }
}

#🎜🎜##🎜🎜#Créer un rôle#🎜🎜##🎜🎜##🎜🎜#Créer un rôle est très simple, il suffit d'insérer un enregistrement dans le tableau "rôles". Voici un exemple. #🎜🎜#

function create_role($name) {
  // Prepare SQL statement
  $sql = "INSERT INTO roles (name) VALUES (?)";

  // Bind parameters
  $stmt = $conn->prepare($sql);
  $stmt->bind_param("s", $name);

  // Execute statement
  if ($stmt->execute()) {
    return true;
  } else {
    return false;
  }
}

#🎜🎜##🎜🎜#Attribuer des rôles aux utilisateurs #🎜🎜##🎜🎜##🎜🎜# Maintenant que nous avons créé des utilisateurs et des rôles, nous devons les associer. Les rôles peuvent être attribués en insérant l'ID de rôle et l'ID d'utilisateur dans la table "role_user". Vous trouverez ci-dessous un exemple de code. #🎜🎜#

function assign_role_to_user($role_id, $user_id) {
  // Prepare SQL statement
  $sql = "INSERT INTO role_user (role_id, user_id) VALUES (?, ?)";

  // Bind parameters
  $stmt = $conn->prepare($sql);
  $stmt->bind_param("ii", $role_id, $user_id);

  // Execute statement
  if ($stmt->execute()) {
    return true;
  } else {
    return false;
  }
}

#🎜🎜##🎜🎜#Vérifier si l'utilisateur a l'autorisation#🎜🎜##🎜🎜##🎜🎜#Enfin, nous devons vérifier si l'utilisateur a l'autorisation d'effectuer une action. Nous trouverons tous les rôles auxquels appartient l'utilisateur et vérifierons si les rôles disposent des autorisations requises. Renvoie vrai si l'utilisateur a l'autorisation, faux sinon. Vous trouverez ci-dessous un exemple de code. #🎜🎜#

function has_permission($user_id, $permission) {
  // Fetch user roles
  $sql = "SELECT role_id FROM role_user WHERE user_id = ?";
  $stmt = $conn->prepare($sql);
  $stmt->bind_param("i", $user_id);
  $stmt->execute();
  $result = $stmt->get_result();

  // Check if any role has permission
  while ($row = $result->fetch_assoc()) {
    $sql2 = "SELECT permissions FROM roles WHERE id = " . $row['role_id'];
    $result2 = $conn->query($sql2);

    if ($result2->num_rows == 1) {
      $row2 = $result2->fetch_assoc();

      $permissions = json_decode($row2['permissions'], true);

      if (in_array($permission, $permissions)) {
        return true;
      }
    }
  }

  // Permission not found
  return false;
}

#🎜🎜#3. Résumé#🎜🎜##🎜🎜#L'utilisation de PHP et MySQL pour créer un système de contrôle des droits des utilisateurs peut garantir la sécurité et l'intégrité des applications Web. Nous pouvons restreindre l'accès des utilisateurs à des opérations et des informations spécifiques en fonction des rôles et des autorisations. Avec ce système, nous pouvons protéger les applications Web contre les accès non autorisés, améliorant ainsi la sécurité globale. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!