[译]在 Node.js 中开发基于角色的访问控制 (RBAC)

BigYe程普2023-12-04 9:34

原文链接：medium.com/@techsuneel...

原文作者：Suneel Kumar

角色基础访问控制（RBAC）是应用程序安全的一个关键话题。它提供了一种结构化的方法来管理和限制基于组织或应用程序中用户角色的资源访问。在这份全面的指南中，我们将探讨 RBAC 的概念、讨论其好处，并引导你了解如何在 Node.js 应用程序中实现 RBAC。阅读本文结束时，你将对如何为自己的项目设计和实现 RBAC 有一个清晰的理解。

1. 介绍角色基础访问控制 (RBAC)

什么是 RBAC?

角色基础访问控制（RBAC）是一种安全概念，用于限制系统对授权用户的访问。在 RBAC 中，访问权限与角色相关联，用户被分配一个或多个角色。这些角色定义了用户在系统内可以执行的动作或操作。

RBAC 通过集中权限来简化访问控制，允许管理员在高层次上管理用户访问。它通过确保用户只拥有执行其角色所需的权限，降低了未授权行为的风险，从而增强了安全性。

RBAC 的好处

实现 RBAC 提供了许多好处，包括：

  • 安全性：RBAC 最小化了应用程序中未授权访问或行为的风险，减少了安全漏洞。
  • 简单性：通过将权限分组到角色中，它简化了用户访问管理，使管理工作更加直接。
  • 可扩展性：RBAC 高度可扩展，适用于小型和大型应用程序。
  • 合规性：许多监管框架，如 GDPR 和 HIPAA，要求像 RBAC 这样的强大访问控制机制。
  • 可审计性：RBAC 允许你跟踪和审计用户行为，这对于识别安全漏洞至关重要。

现在我们已经理解了 RBAC 的概念和优势，让我们继续在 Node.js 应用程序中开发它。

2. 设置 Node.js 环境

先决条件

在深入 RBAC 实现之前，请确保你已准备好以下先决条件：

  • 在你的系统上安装了 Node.js。
  • 一个代码编辑器（例如，Visual Studio Code）。
  • 对 JavaScript 和 Node.js 的基本了解。
  • 一个终端或命令提示符，用于运行 Node.js 应用程序。
  • npm（Node 包管理器）用于安装依赖项。

项目结构

以下是我们将在本教程中使用的基本项目结构：

lua 复制代码 
my-rbac-app/
│
├── package.json
├── package-lock.json
├── index.js
├── models/
│   └── user.js
├── routes/
│   └── auth.js
│   └── tasks.js
├── controllers/
│   └── authController.js
│   └── tasksController.js
├── middleware/
│   └── rbacMiddleware.js
│
└── config/
    └── roles.json

我们将在教程中逐步构建这个项目结构。

3. 用户角色和权限

定义角色和权限

在 RBAC 中，角色代表组织内的工作职能或头衔，权限则是可以执行的操作或行为。让我们开始为我们的项目定义一些角色和权限。

在 config/ 目录下创建一个 roles.json 文件：

json 复制代码 
{
  "roles": [
    {
      "name": "admin",
      "permissions": [
        "create_task",
        "read_task",
        "update_task",
        "delete_task"
      ]
    },
    {
      "name": "manager",
      "permissions": [
        "create_task",
        "read_task",
        "update_task"
      ]
    },
    {
      "name": "employee",
      "permissions": [
        "create_task",
        "read_task"
      ]
    }
  ]
}

在这里，我们定义了三个角色："admin（超级管理员）"，"manager（管理员）"和"employee（普通用户）"，每个角色都有与任务管理相关的不同权限集。

存储角色和权限数据

现在，让我们创建模型来表示角色和权限。在 models/ 目录下，创建一个名为 role.js 的文件：

javascript 复制代码 
// models/role.js

const roles = require('../config/roles.json');

class Role {
  constructor() {
    this.roles = roles.roles;
  }

  getRoleByName(name) {
    return this.roles.find((role) => role.name === name);
  }

  getRoles() {
    return this.roles;
  }
}

module.exports = Role;

在上面的代码中，我们创建了一个 Role 类，它从 roles.json 文件中读取角色和权限。我们还提供了根据名称检索角色或获取所有角色列表的方法。

接下来，在 models/ 目录下创建一个 permissions.js 文件：

javascript 复制代码 
// models/permissions.js

class Permissions {
  constructor() {
    this.permissions = [];
  }

  getPermissionsByRoleName(roleName) {
    const role = roles.roles.find((r) => r.name === roleName);
    return role ? role.permissions : [];
  }
}

module.exports = Permissions;

Permissions 类允许我们根据角色的名称获取权限。在 RBAC 中间件中分配角色给用户并检查权限时，我们将使用这些模型。

有了定义的角色和权限以及到位的模型，现在我们继续进行用户认证。

4. 用户认证

开发用户认证

用户认证是 RBAC 的基本组成部分。我们将使用一个叫做 "Passport" 的流行 Node.js 库来处理认证。以下是你可以为 Node.js 应用程序设置 Passport 的方法：

首先，安装所需的依赖项：

lua 复制代码 
npm install passport mongoose passport-local passport-local-mongoose express-session

现在，在 models/user.js 文件中使用 Mongoose 和 Passport 创建一个用户模型：

javascript 复制代码 
// models/user.js

const mongoose = require('mongoose');
const passportLocalMongoose = require('passport-local-mongoose');

const userSchema = new mongoose.Schema({
  username: String,
  password: String,
  role: String,
});

userSchema.plugin(passportLocalMongoose);

const User = mongoose.model('User', userSchema);

module.exports = User;

在上面的代码中，我们创建了一个带有必要字段的用户模型，并利用 passport-local-mongoose 进行用户认证。

角色分配

现在，当用户注册或被创建时，我们需要给他们分配一个角色。在 controllers/authController.js 文件中，添加以下代码：

javascript 复制代码 
// controllers/authController.js

const User = require('../models/user');
const Role = require('../models/role');

// 注册一个带有角色的新用户
exports.registerUser = (req, res) => {
  const { username, password, role } = req.body;
  const user = new User({ username, role });

  User.register(user, password, (err) => {
    if (err) {
      console.error(err);
      return res.status(500).json({ error: err.message });
    }
    res.json({ message: 'User registered successfully' });
  });
};

在上面的代码中，我们在注册时创建了一个新用户并指定了他们的角色。用户的角色将根据应用程序的业务逻辑来定义。

有了用户认证和角色分配，我们现在可以继续创建基于角色的中间件来保护路由。

5. 基于角色的中间件

创建 RBAC 中间件

在 Node.js 中，中间件对于处理路由保护和用户授权等任务至关重要。我们将创建 RBAC 中间件来检查用户是否拥有访问特定路由的必要权限。

在 middleware/rbacMiddleware.js 文件中，添加以下代码：

javascript 复制代码 
// middleware/rbacMiddleware.js

const Role = require('../models/role');
const Permissions = require('../models/permissions');

// 检查用户是否拥有访问路由所需的权限
exports.checkPermission = (permission) => {
  return (req, res, next) => {
    const userRole = req.user ? req.user.role : 'anonymous';
    const userPermissions = new Permissions().getPermissionsByRoleName(userRole);

    if (userPermissions.includes(permission)) {
      return next();
    } else {
      return res.status(403).json({ error: 'Access denied' });
    }
  };
};

在这个中间件中，我们从用户的会话中提取用户的角色，并检查该角色是否具有访问路由所需的权限。如果用户具有必要的权限，则允许继续操作；否则，发送"403 Forbidden"响应。

保护路由

要使用 RBAC 中间件保护特定路由，请在路由处理程序中导入中间件函数并将其应用于所需的路由。

以下是如何使用 checkPermission 中间件保护路由的示例：

javascript 复制代码 
// routes/tasks.js

const express = require('express');
const router = express.Router();
const rbacMiddleware = require('../middleware/rbacMiddleware');

// 导入 Controller
const tasksController = require('../controllers/tasksController');

// 使用 RBAC 中间件保护路由
router.get('/tasks', rbacMiddleware.checkPermission('read_task'), tasksController.getAllTasks);

module.exports = router;

现在，/tasks 路由受到保护，只有拥有 "read_task" 权限的用户才能访问它。

有了 RBAC 中间件，我们现在可以继续构建示例项目，以查看 RBAC 的实际运作情况。

6. 示例项目：RBAC 实践

在本节中，我们将使用 RBAC 构建一个简单的任务管理系统。我们将定义角色和权限，创建用户认证，为用户分配角色，并根据用户的角色和权限保护路由。

构建一个简单的任务管理系统

首先，让我们定义我们任务管理系统的基本路由。在 routes/ 目录中创建一个名为 tasks.js 的新文件：

javascript 复制代码 
// routes/tasks.js

const express = require('express');
const router = express.Router();
const rbacMiddleware = require('../middleware/rbacMiddleware');

// 导入 Controller
const tasksController = require('../controllers/tasksController');

// 使用 RBAC 中间件保护路由
router.get('/tasks', rbacMiddleware.checkPermission('read_task'), tasksController.getAllTasks);
router.post('/tasks', rbacMiddleware.checkPermission('create_task'), tasksController.createTask);
router.put('/tasks/:id', rbacMiddleware.checkPermission('update_task'), tasksController.updateTask);
router.delete('/tasks/:id', rbacMiddleware.checkPermission('delete_task'), tasksController.deleteTask);

module.exports = router;

在这段代码中，我们定义了列出、创建、更新和删除任务的路由。每个路由都由 RBAC 中间件保护，该中间件在允许访问前检查用户的权限。

定义角色和权限

在我们为用户分配角色之前，让我们为我们的应用程序定义角色和权限。在 config/roles.json 文件中，指定角色及其相关权限：

json 复制代码 
{
  "roles": [
    {
      "name": "admin",
      "permissions": ["create_task", "read_task", "update_task", "delete_task"]
    },
    {
      "name": "manager",
      "permissions": ["create_task", "read_task", "update_task"]
    },
    {
      "name": "employee",
      "permissions": ["create_task", "read_task"]
    }
  ]
}

我们定义了三个角色："admin（管理员）"，"manager（经理）"，和"employee（员工）"，每个角色都有不同级别的访问权限。

开发认证和授权

在 controllers/authController.js 文件中，实现用户注册和登录功能：

javascript 复制代码 
// controllers/authController.js

const User = require('../models/user');
const Role = require('../models/role');

// 注册一个带有角色的新用户
exports.registerUser = (req, res) => {
  const { username, password, role } = req.body;
  const user = new User({ username, role });

  User.register(user, password, (err) => {
    if (err) {
      console.error(err);
      return res.status(500).json({ error: err.message });
    }
    res.json({ message: 'User registered successfully' });
  });
};

// 用户登录并创建会话
exports.loginUser = (req, res) => {
  const { username, password } = req.body;

  User.authenticate(username, password, (err, user) => {
    if (err || !user) {
      return res.status(401).json({ error: 'Invalid credentials' });
    }

    // 创建一个新会话并存储用户 id
    req.session.userId = user._id; 

    res.json({ message: 'Login successful' });
  });
};

// 用户登出并销毁会话
exports.logoutUser = (req, res) => {
  if (req.session) {
    // 销毁会话
    req.session.destroy((err) => {
      if (err) {
        return res.status(500).json({ error: err.message });  
      }
      res.json({ message: 'Logged out successfully' });
    });
  } else {
    res.json({ message: 'Not logged in' });
  }
};

在 loginUser 和 logoutUser 函数中，你可以根据应用程序的需要实现登录和注销逻辑。

测试 RBAC 系统

为了测试 RBAC 系统，创建与先前在 controllers/tasksController.js 文件中定义的角色和权限相对应的示例路由：

javascript 复制代码 
// controllers/tasksController.js

const Role = require('../models/role');
const Permission = require('../models/permission');

// 检查用户是否拥有权限
function hasPermission(permission) {
  return (req, res, next) => {
    const userRoles = req.user.roles;
    
    if

 (userRoles.includes('admin')) {
      next();
    } else {
      const userPermissions = Permission.find({
        role: { $in: userRoles }
      });

      if (userPermissions.includes(permission)) {
        next();
      } else {
        res.status(403).json({ message: 'Forbidden' });
      }
    }
  }
}

// 列出任务
exports.getAllTasks = [
  hasPermission('tasks:list')
], (req, res) => {
  res.json({ message: 'List of tasks'})
});

// 创建任务
exports.createTask = [
  hasPermission('tasks:create')  
], (req, res) => {
  res.json({ message: 'Task created' });
};

// 更新任务
exports.updateTask = [
  hasPermission('tasks:update')
], (req, res) => {
  res.json({ message: 'Task updated' });
}; 

// 删除任务
exports.deleteTask = [
  hasPermission('tasks:delete') 
], (req, res) => {
  res.json({ message: 'Task deleted' });
};

现在，当用户访问这些路由时，RBAC 中间件将检查他们的权限，并且只允许授权用户访问。

要测试 RBAC 系统，请创建具有不同角色的用户帐户并以这些用户身份登录。然后，尝试访问受 RBAC 中间件保护的路由，并观察根据分配的角色和权限如何授予或拒绝访问权限。

index.js 文件

javascript 复制代码 
// 导入所需模块和文件
const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const authRoutes = require('./routes/auth');
const tasksRoutes = require('./routes/tasks');
const authController = require('./controllers/authController');
const tasksController = require('./controllers/tasksController');
const rbacMiddleware = require('./middleware/rbacMiddleware');

// 配置中间件
app.use(bodyParser.json());

// 定义路由
app.use('/auth', authRoutes);
app.use('/tasks', rbacMiddleware.checkRole('user'), tasksRoutes);

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

这个 index.js 文件设置了一个 Express.js 服务器，导入了必要的模块，并配置了所需的中间件。它还定义了用于认证和任务的路由，利用 rbacMiddleware 在允许访问任务路由之前检查用户的角色。

7. 最佳实践和安全考虑

在你的 Node.js 应用程序中实现 RBAC 时，请考虑以下最佳实践和安全考虑：

数据验证

始终验证用户输入，以防止 SQL 注入、XSS 攻击等安全漏洞。使用验证库或框架确保数据完整性。

审计跟踪

引入审计日志以跟踪用户行为和访问尝试。这对于识别安全漏洞或未授权活动至关重要。

细粒度权限

定义细粒度权限以确保用户只拥有执行其任务所需的最少权限。避免角色过度分配权限。

定期更新和监控

保持你的 RBAC 系统更新。随着你的应用程序的发展，角色和权限可能需要调整。定期监控和审查你的 RBAC 策略，以维护安全性。

8. 结论

在这份全面的指南中，我们探讨了角色基础访问控制（RBAC）的概念，并演示了如何在 Node.js 应用程序中实现它。我们涵盖了角色和权限定义、用户认证、角色分配、基于角色的中间件，并创建了一个示例任务管理系统来展示 RBAC 实践。

通过引入 RBAC，你可以显著增强 Node.js 应用程序的安全性，有效控制用户访问，并降低安全漏洞的风险。此外，遵循最佳实践并考虑安全因素可确保你的 RBAC 系统的健壮性。

相关推荐
平凡之辈5 小时前
四轮分析法：Nodejs Heap Snapshot 深度分析方法论
node.js
光影少年5 小时前
如何开发一个CLI工具？
javascript·测试工具·前端框架·node.js
带娃的IT创业者7 小时前
AI 时代产品经理能取代程序员吗？一人全栈背后的残酷真相
人工智能·ai·程序员·产品经理·全栈·职业焦虑
晴天1611 小时前
Neutralinojs 核心原理解析
javascript·electron·node.js
晴天1612 小时前
【跨桌面应用开发】Neutralinojs快速入门指南
前端·javascript·electron·node.js
ybwycx12 小时前
Node.js卸载超详细步骤(附图文讲解)
node.js
ooseabiscuit13 小时前
node.js卸载并重新安装（超详细图文步骤）
node.js
belldeep1 天前
nodejs：Vite + Svelte + ts 入门示例
typescript·node.js·ts·vite·svelte
码森林1 天前
别卷模型了！OpenAI 工程师都在偷偷用的"Harness Engineering"，才是 AI 编程的终极杀器
agent·ai编程·全栈
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）05班级宠物园部署指南06【计算机一级WPSoffice】小黑课堂题库软件下载安装教程（2026年3月最新版）07“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）08UV安装并设置国内源09中国象棋-html版本10OpenClaw 使用和管理 MCP 完全指南