Implémentation du contrôle d'accès basé sur les rôles (RBAC) : utilisation de PHP et RBAC

Avec la popularité des applications Internet, nous espérons protéger les données contenues dans l'application afin de garantir que les données sensibles ne soient pas utilisées à mauvais escient ou volées. L'une des solutions consiste à utiliser le contrôle d'accès basé sur les rôles (RBAC).

Le contrôle d'accès basé sur les rôles (RBAC) est un modèle de contrôle d'accès basé sur la relation entre les utilisateurs et les rôles. L'idée centrale de ce modèle est de lier le rôle de l'utilisateur à l'opération de contrôle d'accès, plutôt que de lier l'opération de contrôle d'accès directement à l'utilisateur. Cette approche augmente la flexibilité du contrôle d'accès et permet aux administrateurs de gérer plus facilement les utilisateurs.

Dans cet article, nous utiliserons PHP et RBAC pour implémenter un système de contrôle d'accès utilisateur de base. Voici le tableau que nous utiliserons :

• users : Utilisé pour stocker des informations sur les utilisateurs enregistrés.
• roles : Utilisé pour stocker des listes d'accès centrées sur les rôles.
• user_roles : utilisé pour stocker les rôles auxquels appartient l'utilisateur.
• permissions : utilisé pour stocker les listes d'autorisations et les listes de contrôle d'accès.
• role_permissions : Utilisé pour stocker la liste des autorisations détenues par le rôle.

Nous utiliserons les étapes suivantes pour mettre en œuvre notre système de contrôle RBAC :

Étape 1 : Créer une base de données et construire les tables qui y sont liées

# 🎜🎜#Créez une nouvelle base de données dans la base de données MySQL et établissez les 4 tables suivantes :

CREATE TABLE users (
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE roles (
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE user_roles (
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    user_id INT(11) NOT NULL,
    role_id INT(11) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY user_id_fk (user_id) REFERENCES users(id),
    FOREIGN KEY role_id_fk (role_id) REFERENCES roles(id)
);

CREATE TABLE permissions (
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE role_permissions (
    id INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    role_id INT(11) NOT NULL,
    permission_id INT(11) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY role_id_fk (role_id) REFERENCES roles(id),
    FOREIGN KEY permission_id_fk (permission_id) REFERENCES permissions(id)
);

Étape 2 : Écrivez du code PHP

Nous implémenterons une classe PHP de base pour gérer notre système de contrôle RBAC. Cette classe nous permettra d'ajouter des utilisateurs, d'ajouter des rôles, d'ajouter des autorisations, d'attribuer des utilisateurs à des rôles et d'attribuer des autorisations aux rôles.

class Rbac {

  // 数据库连接和表名
  private $conn;
  private $users_table = "users";
  private $roles_table = "roles";
  private $user_roles_table = "user_roles";
  private $permissions_table = "permissions";
  private $role_permissions_table = "role_permissions";

  // 构造函数将数据库连接
  public function __construct($db) {
    $this->conn = $db;
  }

  // 添加用户
  public function addUser($username, $password, $email) {
    // 生成密码哈希
    $password_hash = password_hash($password, PASSWORD_BCRYPT);
    // 插入用户到数据库
    $query = "INSERT INTO " . $this->users_table . "(username, password, email) VALUES (:username, :password, :email)";
    $stmt = $this->conn->prepare($query);
    $stmt->bindParam(":username", $username);
    $stmt->bindParam(":password", $password_hash);
    $stmt->bindParam(":email", $email);
    if($stmt->execute()) {
      return true;
    } else {
      return false;
    }
  }

  // 添加角色
  public function addRole($name) {
    $query = "INSERT INTO " . $this->roles_table . "(name) VALUES (:name)";
    $stmt = $this->conn->prepare($query);
    $stmt->bindParam(":name", $name);
    if($stmt->execute()) {
      return true;
    } else {
      return false;
    }
  }

  // 添加权限
  public function addPermission($name) {
    $query = "INSERT INTO " . $this->permissions_table . "(name) VALUES (:name)";
    $stmt = $this->conn->prepare($query);
    $stmt->bindParam(":name", $name);
    if($stmt->execute()) {
      return true;
    } else {
      return false;
    }
  }

  // 将用户分配给角色
  public function assignUserRole($user_id, $role_id) {
    $query = "INSERT INTO " . $this->user_roles_table . "(user_id, role_id) VALUES (:user_id, :role_id)";
    $stmt = $this->conn->prepare($query);
    $stmt->bindParam(":user_id", $user_id);
    $stmt->bindParam(":role_id", $role_id);
    if($stmt->execute()) {
      return true;
    } else {
      return false;
    }
  }

  // 将权限分配给角色
  public function assignRolePermission($role_id, $permission_id) {
    $query = "INSERT INTO " . $this->role_permissions_table . "(role_id, permission_id) VALUES (:role_id, :permission_id)";
    $stmt = $this->conn->prepare($query);
    $stmt->bindParam(":role_id", $role_id);
    $stmt->bindParam(":permission_id", $permission_id);
    if($stmt->execute()) {
      return true;
    } else {
      return false;
    }
  }

}

Nous avons maintenant une classe simple qui peut ajouter des utilisateurs, ajouter des rôles, ajouter des autorisations, attribuer des utilisateurs à des rôles et attribuer des autorisations aux rôles.

Étape 3 : Test

Nous pouvons maintenant créer un script de test pour tester notre système de contrôle RBAC. Voici l'exemple de code :

// 包括我们的RBAC类
include_once 'Rbac.php';

// 设置数据库连接
$database = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");

// 定义RBAC类
$rbac = new Rbac($database);

// 添加用户
$rbac->addUser("user1", "password1", "user1@example.com");
$rbac->addUser("user2", "password2", "user2@example.com");

// 添加角色
$rbac->addRole("admin");
$rbac->addRole("editor");
$rbac->addRole("user");

// 添加权限
$rbac->addPermission("create");
$rbac->addPermission("read");
$rbac->addPermission("update");
$rbac->addPermission("delete");

// 将用户分配给角色
$rbac->assignUserRole(1, 1); // user1 is assigned the admin role
$rbac->assignUserRole(1, 3); // user1 is also assigned the user role
$rbac->assignUserRole(2, 2); // user2 is assigned the editor role

// 将权限分配给角色
$rbac->assignRolePermission(1, 1); // admin role is assigned the create permission
$rbac->assignRolePermission(1, 2); // admin role is assigned the read permission
$rbac->assignRolePermission(1, 3); // admin role is assigned the update permission
$rbac->assignRolePermission(1, 4); // admin role is assigned the delete permission
$rbac->assignRolePermission(3, 2); // user role is assigned the read permission

// 提示测试完成
echo "Test complete!";

Le script de test ci-dessus exécutera notre système de contrôle RBAC et ajoutera un utilisateur, 3 rôles différents, 4 autorisations différentes, puis attribuera l'utilisateur au rôle et attribuera des autorisations. à chaque rôle.

Conclusion

Dans cet article, nous avons appris comment implémenter un contrôle d'accès basé sur les rôles à l'aide de PHP et RBAC. Nous avons construit un système de contrôle RBAC simple qui peut ajouter des utilisateurs, ajouter des rôles, ajouter des autorisations, attribuer des utilisateurs à des rôles et attribuer des autorisations aux rôles. Dans les applications pratiques, le système de contrôle RBAC peut être plus routinier et complexe, ce qui nous oblige à l'étendre et à l'améliorer en fonction de la situation réelle.

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!