Разберете как да комбинирате тези технологии с практическа демонстрация.

Контролът на достъпа, базиран на роли, е защитен механизъм за удостоверяване. Можете да го използвате, за да ограничите достъпа до конкретни ресурси до потребители, които имат определени роли.

Този тип удостоверяване помага на системните администратори да контролират разрешенията според определените роли на потребителите. Това ниво на детайлен контрол добавя ниво на сигурност, което позволява на приложенията да предотвратяват неоторизиран достъп.

Внедряване на ролеви механизъм за контрол на достъпа с помощта на Passport.js и JWT

Контролът на достъпа, базиран на роли (RBAC), е популярен механизъм, използван за налагане на ограничения за достъп в приложения въз основа на потребителски роли и разрешения. Има различни налични методи за прилагане на механизма RBAC.

Два популярни подхода включват използването на специални RBAC библиотеки като AcessControl или използване на съществуващи библиотеки за удостоверяване за прилагане на механизма.

instagram viewer

В този случай JSON уеб токените (JWT) предоставят сигурен начин за предаване на идентификационни данни за удостоверяване, докато Passport.js опростява процеса на удостоверяване, като предоставя гъвкаво удостоверяване междинен софтуер.

Използвайки този подход, можете да присвоите роли на потребителите и да ги кодирате в JWT, когато се удостоверяват. След това можете да използвате JWT, за да проверите самоличността и ролите на потребителя в последващи заявки, което позволява базирано на роли оторизиране и контрол на достъпа.

И двата подхода имат своите предимства и могат да бъдат ефективни при прилагането на RBAC. Изборът между това кой метод да се приложи ще зависи от специфичните изисквания на вашия проект.

Можете да изтеглите кода на този проект от него GitHub хранилище.

Настройте проект Express.js

За да започнете, настройте локално проект Express.js. След като настроите проекта, продължете и инсталирайте тези пакети:

npm инсталирайте cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
 паспорт паспорт-местен

Следващия, създайте база данни MongoDB или настройте клъстер на MongoDB Atlas. Копирайте URI адреса на връзката с базата данни и го добавете към a .env файл в основната директория на вашия проект:

CONNECTION_URI="URI адрес на връзката"

Конфигурирайте връзката към базата данни

В основната директория създайте нова utils/db.js файл и добавете кода по-долу, за да установите връзката към клъстера MongoDB, работещ на Atlas, използвайки Mongoose.

конст мангуста = изискват("мангуста");
конст connectDB = асинхронен () => {
опитвам {
изчакайте mongoose.connect (process.env. CONNECTION_URI);
конзола.log(„Свързан с MongoDB!“);
 } улов (грешка) {
конзола.грешка(„Грешка при свързване с MongoDB:“, грешка);
 }
};
модул.exports = connectDB;

Дефинирайте модела на данни

В основната директория създайте нова модел/user.model.js файл и добавете следния код, за да дефинирате модел на данни за данните на потребителите, използващи Mongoose.

конст мангуста = изискват("мангуста");
конст потребителска схема = нов мангуста. Схема ({
 потребителско име: низ,
 парола: низ,
 роля: низ
});
модул.exports = mongoose.model("Потребител", потребителска схема);

Създайте контролера за крайните точки на API

Създайте нов контролери/user.controller.js файл в основната директория и добавете кода по-долу.

Първо направете тези импорти:

конст Потребител = изискват('../models/user.model');
конст паспорт = изискват("паспорт");
конст {generateToken} = изискват('../среден софтуер/auth');
изискват('../middleware/passport')(паспорт);

След това дефинирайте логиката за управление на регистрацията на потребителите и функционалността за влизане:

exports.registerUser = асинхронен (req, res) => {
конст {потребителско име, парола, роля} = req.body;
опитвам {
изчакайте User.create({потребителско име, парола, роля});
 res.status(201).json({ съобщение: „Потребителят се регистрира успешно“ });
 } улов (грешка) {
конзола.log (грешка);
 res.status(500).json({ съобщение: 'Възникна грешка!' });
 }
};


exports.loginUser = (req, res, next) => {
 passport.authenticate("местен", { сесия: невярно }, (грешка, потребител, информация) => {
ако (грешка) {
конзола.log (грешка);


връщане res.status(500).json({
 съобщение: „Възникна грешка при влизане“
 });
 }


ако (!потребител) {
връщане res.status(401).json({
 съобщение: „Невалидни идентификационни данни за вход“
 });
 }


 req.login (потребител, { сесия: невярно }, (грешка) => {
ако (грешка) {
конзола.log (грешка);


връщане res.status(500).json({
 съобщение: „Възникна грешка при влизане“
 });
 }
конст { _id, потребителско име, роля } = потребител;
конст полезен товар = { userId: _id, потребителско име, роля};
конст токен = генерира Токен (полезен товар);
 res.cookie('token', токен, { Само http: вярно });
връщане res.status(200).json({ съобщение: 'Успешен вход' });
 });
 })(req, res, next);
};

The registerUser функцията обработва регистрацията на нов потребител, като извлича потребителското име, паролата и ролята от тялото на заявката. След това създава нов потребителски запис в базата данни и отговаря със съобщение за успех или грешка, ако възникне такава по време на процеса.

От друга страна, loginUser функцията улеснява влизането на потребителите чрез използване на локалната стратегия за удостоверяване, предоставена от Passport.js. Той удостоверява идентификационните данни на потребителя и връща токен при успешно влизане, който след това се съхранява в бисквитка за последващи удостоверени заявки. Ако възникнат грешки по време на процеса на влизане, той ще върне съответното съобщение.

Накрая добавете кода, който прилага логиката за извличане на всички потребителски данни от базата данни. Ще използваме тази крайна точка като ограничен маршрут, за да гарантираме, че само оторизирани потребители с ролята на администратор има достъп до тази крайна точка.

exports.getUsers = асинхронен (req, res) => {
опитвам {
конст потребители = изчакайте User.find({});
 res.json (потребители);
 } улов (грешка) {
конзола.log (грешка);
 res.status(500).json({ съобщение: 'Възникна грешка!' });
 }
};

Настройте стратегия за локално удостоверяване на Passport.js

За да удостоверите потребителите, след като предоставят своите идентификационни данни за вход, трябва да настроите стратегия за локално удостоверяване.

Създайте нов междинен софтуер/passport.js файл в основната директория и добавете следния код.

конст LocalStrategy = изискват('местен паспорт').Стратегия;
конст Потребител = изискват('../models/user.model');
модул.exports = (паспорт) => {
 passport.use(
нов LocalStrategy(асинхронен (потребителско име, парола, готово) => {
опитвам {
конст потребител = изчакайте User.findOne({потребителско име});


ако (!потребител) {
връщане Свършен(нула, невярно);
 }


ако (user.password !== парола) {
връщане Свършен(нула, невярно);
 }
връщане Свършен(нула, потребител);
 } улов (грешка) {
връщане готово (грешка);
 }
 })
 );
};

Този код дефинира локална стратегия на passport.js за удостоверяване на потребителите въз основа на предоставените от тях потребителско име и парола.

Първо, той прави заявка в базата данни, за да намери потребител със съответстващо потребителско име и след това продължава да потвърждава паролата им. Следователно, той връща удостоверения потребителски обект, ако процесът на влизане е успешен.

Създайте JWT мидълуер за проверка

Вътре в междинен софтуер директория, създайте нов файл auth.js и добавете следния код, за да дефинирате междинен софтуер, който генерира и проверява JWT.

конст jwt = изискват('jsonwebtoken');
конст secretKey = process.env. SECRET_KEY;
конст generateToken = (полезен товар) => {
конст токен = jwt.sign (полезен товар, secretKey, { изтича на: „1ч“ });
връщане жетон;
};


конст verifyToken = (задължителна роля) =>(req, res, next) => {
конст токен = req.cookies.token;


ако (!токен) {
връщане res.status(401).json({ съобщение: „Не е предоставен токен“ });
 }


 jwt.verify (token, secretKey, (грешка, декодиран) => {
ако (грешка) {
връщане res.status(401).json({ съобщение: 'Невалиден Жетон' });
 }


 req.userId = decoded.userId; 


ако (decoded.role !== requiredRole) {
връщане res.status(403).json({
 съобщение: „Нямате оторизация и разрешения за достъп до този ресурс.“
 });
 }


 следващия();
 });
};
модул.exports = {generateToken, verifyToken};

The generateToken създава JWT с определено време на изтичане, докато verifyToken функцията проверява дали токенът присъства и е валиден. В допълнение, той също така проверява дали декодираният токен съдържа необходимата роля, като по същество гарантира, че само потребители с оторизираната роля и разрешения имат достъп.

За да подпишете уникално JWT, трябва да генерирате уникален таен ключ и да го добавите към вашия .env файл, както е показано по-долу.

SECRET_KEY="Това е примерен таен ключ."

Дефинирайте API маршрутите

В главната директория създайте нова папка и я наименувайте routes. В тази папка създайте нова userRoutes.jsи добавете следния код.

конст експрес = изискват("експресен");
конст рутер = експрес. Рутер();
конст потребителски контролери = изискват('../controllers/userController');
конст { verifyToken } = изискват('../среден софтуер/auth');
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);


router.get('/api/потребители', verifyToken("администратор"), userControllers.getUsers);
модул.exports = рутер;

Този код дефинира HTTP маршрутите за REST API. The потребители конкретно маршрут, сървърите като защитен маршрут. Чрез ограничаване на достъпа до потребители с администратор роля, вие ефективно налагате контрол на достъпа, базиран на роли.

Актуализирайте основния сървърен файл

Отвори си server.js файл и го актуализирайте, както следва:

конст експрес = изискват("експресен");
конст корс = изискват("корс");
конст cookieParser = изискват("cookie-parser");
конст приложение = експрес();
конст порт = 5000;
изискват('dotenv').config();
конст connectDB = изискват('./utils/db');
конст паспорт = изискват("паспорт");
изискват('./мидълуер/паспорт')(паспорт);
свържетеDB();


app.use (express.json());
app.use (express.urlencoded({ удължен: вярно }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());


конст userRoutes = изискват('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (порт, () => {
конзола.log(`Сървърът работи на порт ${порт}`);
});

Накрая стартирайте сървъра за разработка, за да стартирате приложението.

възел server.js

Възползвайте се от механизма RBAC, за да подобрите вашите системи за удостоверяване

Внедряването на ролеви контрол на достъпа е ефективен начин за подобряване на сигурността на вашите приложения.

Въпреки че включването на съществуващи библиотеки за удостоверяване за създаване на ефективна RBAC система е чудесен подход, използването на RBAC библиотеки за изрично дефиниране на потребителски роли и присвояване на разрешения осигурява още по-стабилно решение, което в крайна сметка повишава цялостната сигурност на вашия приложение.