El control de acceso basado en roles (RBAC, por sus siglas en inglés) es una metodología de seguridad que restringe el acceso a los recursos del sistema en función de los roles asignados a los usuarios. En una aplicación Node.js, RBAC se puede implementar para asegurar que solo los usuarios con los permisos adecuados puedan acceder a ciertas rutas o realizar acciones específicas.

1. Roles: Un conjunto de permisos que se asignan a los usuarios. Ejemplos comunes incluyen "admin", "editor" y "viewer".
2. Permisos: Acciones específicas que un rol puede realizar, como "crear", "leer", "actualizar" y "eliminar".
3. Usuarios: Entidades que se autentican en el sistema y se les asignan roles.

Primero, definimos los roles y los permisos asociados. Esto se puede hacer en un archivo de configuración o directamente en el código.

Creamos un middleware que verifique si el usuario tiene el rol necesario para acceder a una ruta específica.

Utilizamos el middleware de autorización en las rutas que queremos proteger.

Objetivo: Implementar un sistema de control de acceso basado en roles en una aplicación Node.js.

1. Definir Roles y Permisos: Crea un archivo roles.js y define los roles y permisos.
2. Middleware de Autorización: Crea un middleware authorize.js que verifique los permisos del usuario.
3. Aplicar Middleware: Protege las rutas de tu aplicación utilizando el middleware de autorización.

Solución:

1. roles.js:

   const roles = {
     admin: ['create', 'read', 'update', 'delete'],
     editor: ['create', 'read', 'update'],
     viewer: ['read']
   };
   
   module.exports = roles;
   

2. authorize.js:

   const roles = require('./roles');
   
   const authorize = (requiredRole) => {
     return (req, res, next) => {
       const userRole = req.user.role;
   
       if (roles[userRole] && roles[userRole].includes(requiredRole)) {
         next();
       } else {
         res.status(403).json({ message: 'Acceso denegado' });
       }
     };
   };
   
   module.exports = authorize;
   

3. app.js:

   const express = require('express');
   const authorize = require('./authorize');
   const app = express();
   
   app.use((req, res, next) => {
     req.user = { role: 'editor' };
     next();
   });
   
   app.post('/create', authorize('create'), (req, res) => {
     res.send('Recurso creado');
   });
   
   app.get('/read', authorize('read'), (req, res) => {
     res.send('Recurso leído');
   });
   
   app.put('/update', authorize('update'), (req, res) => {
     res.send('Recurso actualizado');
   });
   
   app.delete('/delete', authorize('delete'), (req, res) => {
     res.send('Recurso eliminado');
   });
   
   app.listen(3000, () => {
     console.log('Servidor escuchando en el puerto 3000');
   });
   

1. Olvidar Asignar Roles a los Usuarios: Asegúrate de que cada usuario tenga un rol asignado. Esto generalmente se hace durante el proceso de autenticación.
2. Roles Mal Definidos: Verifica que los roles y permisos estén correctamente definidos y que no haya errores tipográficos.
3. No Proteger Rutas Críticas: Asegúrate de aplicar el middleware de autorización a todas las rutas que requieren protección.

El control de acceso basado en roles es una técnica esencial para asegurar que solo los usuarios autorizados puedan realizar ciertas acciones en tu aplicación. Al implementar RBAC en Node.js, puedes mejorar significativamente la seguridad y la gestión de permisos en tu aplicación. En el siguiente módulo, exploraremos cómo realizar pruebas y depuración en aplicaciones Node.js para asegurar su correcto funcionamiento.