Ismerje meg, hogyan kombinálhatja ezeket a technológiákat egy gyakorlati bemutatóval.

A szerepkör alapú hozzáférés-vezérlés egy biztonságos hitelesítési mechanizmus. Segítségével korlátozhatja az egyes erőforrásokhoz való hozzáférést bizonyos szerepkörrel rendelkező felhasználók számára.

Ez a fajta hitelesítés segít a rendszergazdáknak az engedélyek szabályozásában a felhasználók kijelölt szerepkörének megfelelően. A részletes vezérlés ezen szintje egy biztonsági réteget ad, amely lehetővé teszi az alkalmazások számára, hogy megakadályozzák az illetéktelen hozzáférést.

Szerep alapú hozzáférés-vezérlési mechanizmus megvalósítása Passport.js és JWT használatával

A szerepkör alapú hozzáférés-vezérlés (RBAC) egy népszerű mechanizmus, amellyel a felhasználói szerepkörök és engedélyek alapján kényszerítik ki a hozzáférési korlátozásokat az alkalmazásokban. Különféle módszerek állnak rendelkezésre az RBAC mechanizmus megvalósítására.

Két népszerű megközelítés a dedikált RBAC-könyvtárak, például AcessControl vagy a meglévő hitelesítési könyvtárak kihasználása a mechanizmus megvalósításához.

instagram viewer

Ebben az esetben a JSON Web Tokenek (JWT-k) biztonságos módot biztosítanak a hitelesítési adatok továbbítására, míg a Passport.js rugalmas hitelesítést biztosítva egyszerűsíti a hitelesítési folyamatot köztes szoftver.

Ezzel a megközelítéssel szerepköröket rendelhet a felhasználókhoz, és hitelesítéskor kódolhatja őket a JWT-ben. Ezután a JWT segítségével ellenőrizheti a felhasználó személyazonosságát és szerepköreit a következő kérésekben, lehetővé téve a szerepkör alapú engedélyezést és hozzáférés-szabályozást.

Mindkét megközelítésnek megvannak a maga előnyei, és hatékonyak lehetnek az RBAC megvalósításában. A megvalósítási mód közötti választás a projekt konkrét követelményeitől függ.

Letöltheti a projekt kódját innen GitHub adattár.

Állítson be egy Express.js projektet

A kezdéshez állítson be egy Express.js projektet helyileg. Miután beállította a projektet, folytassa és telepítse ezeket a csomagokat:

npm install cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
 útlevél útlevél-helyi

Következő, hozzon létre egy MongoDB adatbázist vagy fürt létrehozása a MongoDB Atlason. Másolja ki az adatbázis-kapcsolat URI-jét, és adja hozzá a .env fájl a projekt gyökérkönyvtárában:

CONNECTION_URI="kapcsolat URI"

Állítsa be az adatbázis-kapcsolatot

A gyökérkönyvtárban hozzon létre egy újat utils/db.js fájlt, és adja hozzá az alábbi kódot a kapcsolat létrehozásához az Atlason futó MongoDB-fürttel a Mongoose használatával.

const mangúz = igényelnek('indiai menyét');
const connectDB = async () => {
próbáld ki {
várja mongoose.connect (process.env. CONNECTION_URI);
konzol.log("Csatlakoztatva a MongoDB-hez!");
 } fogás (hiba) {
konzol.hiba("Hiba a MongoDB-hez való csatlakozáskor:", hiba);
 }
};
modul.exports = connectDB;

Határozza meg az adatmodellt

A gyökérkönyvtárban hozzon létre egy újat model/user.model.js fájlt, és adja hozzá a következő kódot a Mongoose használatával adatmodell meghatározásához a felhasználók adataihoz.

const mangúz = igényelnek('indiai menyét');
const userSchema = új indiai menyét. Séma({
 felhasználónév: Húr,
 Jelszó: Húr,
 szerep: Húr
});
modul.exports = mongoose.model("Felhasználó", userSchema);

Hozzon létre egy vezérlőt az API-végpontokhoz

Újat csinálni controllers/user.controller.js fájlt a gyökérkönyvtárba, és adja hozzá az alábbi kódot.

Először hajtsa végre a következő importálásokat:

const Felhasználó = igényelnek("../models/user.model");
const útlevél = igényelnek('útlevél');
const { GeneratoToken } = igényelnek("../middleware/auth");
igényelnek("../middleware/passport")(útlevél);

Ezután határozza meg a felhasználói regisztráció és a bejelentkezési funkciók kezelésének logikáját:

exports.registerUser = async (req, res) => {
const { felhasználónév, jelszó, szerepkör } = req.body;
próbáld ki {
várja User.create({ felhasználónév, jelszó, szerepkör });
 res.status(201).json({ üzenet: "Felhasználó sikeresen regisztrálva" });
 } fogás (hiba) {
konzol.log (hiba);
 res.status(500).json({ üzenet: 'Hiba lépett fel!' });
 }
};


exports.loginUser = (req, res, next) => {
 passport.authenticate('helyi', { ülés: hamis }, (hiba, felhasználó, információ) => {
ha (hiba) {
konzol.log (hiba);


Visszatérés res.status(500).json({
 üzenet: "Hiba történt a bejelentkezés során"
 });
 }


ha (!felhasználó) {
Visszatérés res.status(401).json({
 üzenet: "Érvénytelen bejelentkezési adatok"
 });
 }


 req.login (felhasználó, { ülés: hamis }, (hiba) => {
ha (hiba) {
konzol.log (hiba);


Visszatérés res.status(500).json({
 üzenet: "Hiba történt a bejelentkezés során"
 });
 }
const { _id, felhasználónév, szerep } = felhasználó;
const hasznos teher = { Felhasználói azonosító: _id, felhasználónév, szerepkör };
const token = generálToken (hasznos terhelés);
 res.cookie('jelképes', token, { Csak http: igaz });
Visszatérés res.status(200).json({ üzenet: 'Sikeres bejelentkezés' });
 });
 })(req, res, next);
};

A registerUser függvény kezeli az új felhasználó regisztrációját a felhasználónév, a jelszó és a szerepkör kinyerésével a kérés törzséből. Ezután új felhasználói bejegyzést hoz létre az adatbázisban, és sikerüzenettel vagy hibaüzenettel válaszol, ha a folyamat során előfordul.

Másrészt a loginUser A funkció megkönnyíti a felhasználói bejelentkezést a Passport.js által biztosított helyi hitelesítési stratégia felhasználásával. Hitelesíti a felhasználó hitelesítő adatait, és sikeres bejelentkezéskor egy tokent ad vissza, amelyet aztán egy cookie-ban tárol a későbbi hitelesített kérésekhez. Ha bármilyen hiba történik a bejelentkezési folyamat során, akkor a megfelelő üzenetet küldi vissza.

Végül adja hozzá azt a kódot, amely megvalósítja az összes felhasználó adatát az adatbázisból lekérő logikát. Ezt a végpontot fogjuk korlátozott útvonalként használni annak biztosítására, hogy csak a szerepkörrel rendelkező jogosult felhasználók legyenek admin hozzáférhet ehhez a végponthoz.

exports.getUsers = async (req, res) => {
próbáld ki {
const felhasználók = várja User.find({});
 res.json (felhasználók);
 } fogás (hiba) {
konzol.log (hiba);
 res.status(500).json({ üzenet: 'Hiba lépett fel!' });
 }
};

Állítson be egy Passport.js helyi hitelesítési stratégiát

A felhasználók hitelesítéséhez, miután megadták bejelentkezési hitelesítő adataikat, be kell állítania egy helyi hitelesítési stratégiát.

Újat csinálni middleware/passport.js fájlt a gyökérkönyvtárba, és adja hozzá a következő kódot.

const LocalStrategy = igényelnek(„helyi útlevél”).Stratégia;
const Felhasználó = igényelnek("../models/user.model");
modul.export = (útlevél) => {
 passport.use(
új LocalStrategy(async (felhasználónév, jelszó, kész) => {
próbáld ki {
const felhasználó = várja User.findOne({ felhasználónév });


ha (!felhasználó) {
Visszatérés Kész(nulla, hamis);
 }


ha (user.password !== jelszó) {
Visszatérés Kész(nulla, hamis);
 }
Visszatérés Kész(nulla, felhasználó);
 } fogás (hiba) {
Visszatérés kész (hiba);
 }
 })
 );
};

Ez a kód egy helyi passport.js stratégiát határoz meg a felhasználók hitelesítésére a megadott felhasználónév és jelszó alapján.

Először lekérdezi az adatbázist, hogy megtalálja a megfelelő felhasználónévvel rendelkező felhasználót, majd folytatja a jelszó érvényesítését. Következésképpen visszaadja a hitelesített felhasználói objektumot, ha a bejelentkezési folyamat sikeres.

Hozzon létre egy JWT-ellenőrző köztes szoftvert

Benne köztes szoftver könyvtárba, hozzon létre egy új auth.js fájlt, és adja hozzá a következő kódot a JWT-ket előállító és ellenőrző köztes szoftver meghatározásához.

const jwt = igényelnek("jsonwebtoken");
const secretKey = process.env. TITKOS KULCS;
const generToken = (hasznos teher) => {
const token = jwt.sign (payload, secretKey, { lejárIn: "1h" });
Visszatérés jelképes;
};


const verifyToken = (szükségesRole) =>(req, res, next) => {
const token = req.cookies.token;


ha (!token) {
Visszatérés res.status(401).json({ üzenet: "Nincs token megadva" });
 }


 jwt.verify (token, secretKey, (hiba, dekódolt) => {
ha (hiba) {
Visszatérés res.status(401).json({ üzenet: 'Érvénytelen kód' });
 }


 req.userId = dekódolt.felhasználói azonosító; 


ha (dekódolt.role !== szükségesRole) {
Visszatérés res.status(403).json({
 üzenet: "Nincs jogosultsága és engedélye az erőforrás eléréséhez."
 });
 }


 következő();
 });
};
modul.exports = {generToken, verifyToken };

A generToken funkció meghatározott lejárati idejű JWT-t hoz létre, míg a verifyToken funkció ellenőrzi, hogy a token megvan-e és érvényes-e. Ezenkívül azt is ellenőrzi, hogy a dekódolt token tartalmazza-e a szükséges szerepet, lényegében biztosítva, hogy csak a jogosult szerepkörrel és jogosultsággal rendelkező felhasználók férhessenek hozzá.

A JWT-k egyedi aláírásához létre kell hoznia egy egyedi titkos kulcsot, és hozzá kell adnia a kulcshoz .env fájlt az alábbiak szerint.

SECRET_KEY="Ez egy titkos kulcs minta."

Határozza meg az API-útvonalakat

A gyökérkönyvtárban hozzon létre egy új mappát, és nevezze el útvonalaknak. Ebben a mappában hozzon létre egy újat userRoutes.js, és adja hozzá a következő kódot.

const expressz = igényelnek('Expressz');
const router = expressz. Router();
const userControllers = igényelnek("../controllers/userController");
const { verifyToken } = igényelnek("../middleware/auth");
router.post('/api/regiszter', userControllers.registerUser);
router.post('/api/bejelentkezés', userControllers.loginUser);


router.get('/api/felhasználók', verifyToken("admin"), userControllers.getUsers);
modul.exports = útválasztó;

Ez a kód határozza meg a REST API HTTP-útvonalait. A felhasználókat konkrétan a szervereket, mint védett útvonalat. A hozzáférés korlátozásával a felhasználók számára a admin szerepkörrel, hatékonyan érvényesítheti a szerepkör alapú hozzáférés-szabályozást.

Frissítse a fő szerver fájlt

Nyissa meg server.js fájlt, és frissítse az alábbiak szerint:

const expressz = igényelnek('Expressz');
const cors = igényelnek("cors");
const cookieParser = igényelnek("cookie-parser");
const app = express();
const port = 5000;
igényelnek("dotenv").config();
const connectDB = igényelnek('./utils/db');
const útlevél = igényelnek('útlevél');
igényelnek("./middleware/passport")(útlevél);
connectDB();


app.use (express.json());
app.use (express.urlencoded({ kiterjedt: igaz }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());


const userRoutes = igényelnek('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konzol.log(`A szerver a porton fut ${port}`);
});

Végül indítsa el a fejlesztőkiszolgálót az alkalmazás futtatásához.

csomópont szerver.js

Használja ki az RBAC-mechanizmust a hitelesítési rendszerek fejlesztéséhez

A szerepalapú hozzáférés-vezérlés megvalósítása hatékony módja az alkalmazások biztonságának növelésének.

Míg a meglévő hitelesítési könyvtárak beépítése egy hatékony RBAC rendszer létrehozása érdekében nagyszerű megközelítés, az RBAC könyvtárak kihasználása a felhasználói szerepkörök kifejezetten definiálása és az engedélyek hozzárendelése még robusztusabb megoldást kínál, végső soron javítva az Ön általános biztonságát. Alkalmazás.