Siit saate teada, kuidas ühendada need tehnoloogiad praktilise demonstratsiooniga.
Rollipõhine juurdepääsukontroll on turvaline autentimismehhanism. Saate seda kasutada, et piirata juurdepääsu teatud ressurssidele kasutajatele, kellel on teatud rollid.
Seda tüüpi autentimine aitab süsteemiadministraatoritel kontrollida õigusi vastavalt kasutaja määratud rollidele. See üksikasjaliku kontrolli tase lisab turvalisuse kihi, võimaldades rakendustel vältida volitamata juurdepääsu.
Rollipõhise juurdepääsukontrolli mehhanismi rakendamine Passport.js-i ja JWT-de abil
Rollipõhine juurdepääsukontroll (RBAC) on populaarne mehhanism, mida kasutatakse kasutajarollidel ja õigustel põhinevate rakenduste juurdepääsupiirangute jõustamiseks. RBAC-mehhanismi rakendamiseks on saadaval mitmesuguseid meetodeid.
Kaks populaarset lähenemisviisi hõlmavad spetsiaalsete RBAC-teekide kasutamist, näiteks AcessControl või olemasolevate autentimisteekide kasutamine mehhanismi rakendamiseks.
Sel juhul pakuvad JSON-i veebimärgid (JWT-d) turvalist viisi autentimismandaatide edastamiseks, samas kui Passport.js lihtsustab autentimisprotsessi, pakkudes paindlikku autentimist vahevara.
Seda lähenemisviisi kasutades saate määrata kasutajatele rolle ja kodeerida need autentimisel JWT-sse. Seejärel saate kasutada JWT-d kasutaja identiteedi ja rollide kontrollimiseks järgmistes päringutes, võimaldades rollipõhist autoriseerimist ja juurdepääsu kontrolli.
Mõlemal lähenemisviisil on oma eelised ja need võivad olla RBAC-i rakendamisel tõhusad. Rakendusmeetodi valik sõltub teie projekti erinõuetest.
Selle projekti koodi saate alla laadida selle saidilt GitHubi hoidla.
Express.js projekti seadistamine
Alustamiseks seadistage kohapeal Express.js projekt. Kui olete projekti seadistanud, jätkake ja installige järgmised paketid:
npm install cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pass pass-kohalikJärgmiseks looge MongoDB andmebaas või looge MongoDB Atlases klaster. Kopeerige andmebaasi ühenduse URI ja lisage see a .env faili oma projekti juurkataloogis:
CONNECTION_URI="ühenduse URI"Andmebaasiühenduse konfigureerimine
Loo juurkataloogis uus utils/db.js faili ja lisage allolev kood, et luua ühendus Mongoose'i abil Atlases töötava MongoDB klastriga.
konst mangust = nõuda("mongoose");konst connectDB = asünkr () => {
proovi {
ootama mongoose.connect (process.env. CONNECTION_URI);
konsool.log("Ühendatud MongoDB-ga!");
} püüda (viga) {
konsool.error("Viga MongoDB-ga ühenduse loomisel:", viga);
}
};
moodul.exports = connectDB;
Määratlege andmemudel
Loo juurkataloogis uus model/user.model.js faili ja lisage järgmine kood, et määrata Mongoose'i abil kasutajate andmete jaoks andmemudel.
konst mangust = nõuda("mongoose");konst userSchema = uus mangust. Skeem({
kasutajanimi: String,
parool: String,
roll: String
});
moodul.exports = mongoose.model('kasutaja', userSchema);
Looge API lõpp-punktide jaoks kontroller
Loo uus controllers/user.controller.js faili juurkataloogi ja lisage allolev kood.
Esmalt tehke järgmised impordid:
konst Kasutaja = nõuda('../models/user.model');
konst pass = nõuda('pass');
konst {genereerida Token} = nõuda("../middleware/auth");
nõuda('../vahevara/pass')(pass);Järgmisena määratlege kasutaja registreerimise ja sisselogimise funktsioonide haldamise loogika:
exports.registerUser = asünkr (req, res) => {
konst { kasutajanimi, parool, roll } = req.body;proovi {
ootama User.create({ kasutajanimi, parool, roll });
res.status(201).json({ sõnum: "Kasutaja registreeriti edukalt" });
} püüda (viga) {
konsool.log (viga);
res.status(500).json({ sõnum: 'Ilmnes viga!' });
}
};exports.loginUser = (req, res, next) => {
pass.authenticate('kohalik', { istungil: vale }, (err, user, info) => {
kui (err) {
konsool.log (err);tagasi res.status(500).json({
sõnum: "Sisselogimisel ilmnes viga"
});
}kui (!kasutaja) {
tagasi res.status(401).json({
sõnum: "Valed sisselogimismandaadid"
});
}req.login (kasutaja, { istungil: vale }, (err) => {
kui (err) {
konsool.log (err);tagasi res.status(500).json({
sõnum: "Sisselogimisel ilmnes viga"
});
}
konst { _id, kasutajanimi, roll } = kasutaja;
konst kasulik koormus = { kasutaja ID: _id, kasutajanimi, roll };
konst token = genereeridaToken (kasulik koormus);
res.cookie('märk', märk, { Ainult http: tõsi });
tagasi res.status(200).json({ sõnum: "Sisselogimine õnnestus" });
});
})(req, res, next);
};
The registreeriKasutaja Funktsioon tegeleb uue kasutaja registreerimisega, eraldades päringu kehast kasutajanime, parooli ja rolli. Seejärel loob see andmebaasi uue kasutajakirje ja vastab eduteate või veateate, kui see protsessi käigus ilmneb.
Teisest küljest, logi sisseKasutaja funktsioon hõlbustab kasutaja sisselogimist, kasutades Passport.js pakutavat kohalikku autentimisstrateegiat. See autentib kasutaja mandaadid ja tagastab edukal sisselogimisel loa, mis seejärel salvestatakse küpsisesse järgmiste autentitud taotluste jaoks. Kui sisselogimisel ilmnevad vead, tagastab see vastava teate.
Lõpuks lisage kood, mis rakendab kõigi kasutajate andmete andmebaasist toomise loogikat. Kasutame seda lõpp-punkti piiratud marsruudina tagamaks, et ainult volitatud kasutajad, kelle roll on admin pääseb sellele lõpp-punktile juurde.
exports.getUsers = asünkr (req, res) => {
proovi {
konst kasutajad = ootama User.find({});
res.json (kasutajad);
} püüda (viga) {
konsool.log (viga);
res.status(500).json({ sõnum: 'Ilmnes viga!' });
}
};Seadistage Passport.js kohalik autentimisstrateegia
Kasutajate autentimiseks pärast sisselogimismandaatide esitamist peate seadistama kohaliku autentimisstrateegia.
Loo uus vahevara/passport.js faili juurkataloogis ja lisage järgmine kood.
konst LocalStrategy = nõuda('pass-kohalik').Strateegia;
konst Kasutaja = nõuda('../models/user.model');moodul.eksport = (passi) => {
pass.use(
uus LocalStrategy(asünkr (kasutajanimi, parool, valmis) => {
proovi {
konst kasutaja = ootama User.findOne({ kasutajanimi });kui (!kasutaja) {
tagasi tehtud (null, vale);
}kui (kasutaja.parool !== parool) {
tagasi tehtud (null, vale);
}
tagasi tehtud (null, kasutaja);
} püüda (viga) {
tagasi tehtud (viga);
}
})
);
};
See kood määratleb kohaliku passport.js strateegia kasutajate autentimiseks nende antud kasutajanime ja parooli alusel.
Alguses teeb see andmebaasist päringu, et leida sobiva kasutajanimega kasutaja, ja seejärel kinnitab see parooli. Järelikult tagastab see autentitud kasutajaobjekti, kui sisselogimisprotsess on edukas.
Looge JWT kinnitamise vahevara
Sees vahevara kataloogi, looge uus fail auth.js ja lisage järgmine kood, et määratleda JWT-sid genereeriv ja kontrolliv vahevara.
konst jwt = nõuda('jsonwebtoken');
konst secretKey = process.env. SECRET_KEY;konst generToken = (kasulik koormus) => {
konst token = jwt.sign (kasutav koormus, salajane võti, { aegub: '1h' });
tagasi märk;
};konst verifyToken = (nõutav Roll) =>(req, res, next) => {
konst token = req.cookies.token;kui (!märk) {
tagasi res.status(401).json({ sõnum: 'märki pole esitatud' });
}jwt.verify (token, secretKey, (err, decoded) => {
kui (err) {
tagasi res.status(401).json({ sõnum: "Vigane tunnus" });
}req.userId = dekodeeritud.kasutajaId;
kui (decoded.role !== vajalikRole) {
tagasi res.status(403).json({
sõnum: "Teil pole sellele ressursile juurdepääsuks volitusi ega õigusi."
});
}next();
});
};
moodul.exports = {genereeridaToken, verifyToken};
The genereerida Token funktsioon loob määratud aegumisajaga JWT, samal ajal kui verifyToken funktsioon kontrollib, kas luba on olemas ja kehtiv. Lisaks kontrollib see ka seda, et dekodeeritud luba sisaldab vajalikku rolli, tagades sisuliselt, et juurdepääs on ainult volitatud rolli ja õigustega kasutajatel.
JWT-de unikaalseks allkirjastamiseks peate genereerima ainulaadse salajase võtme ja lisama selle oma .env faili, nagu allpool näidatud.
SECRET_KEY="See on salajase võtme näidis."Määrake API marsruudid
Loo juurkataloogis uus kaust ja nimeta sellele marsruudid. Looge selles kaustas uus userRoutes.jsja lisage järgmine kood.
konst väljendada = nõuda('väljendama');
konst ruuter = ekspress. Ruuter ();
konst userControllers = nõuda("../controllers/userController");
konst { verifyToken } = nõuda("../middleware/auth");ruuter.post('/api/register', userControllers.registerUser);
ruuter.post('/api/login', userControllers.loginUser);ruuter.get('/api/users', verifyToken("admin"), userControllers.getUsers);
moodul.exports = ruuter;
See kood määrab REST API HTTP-marsruudid. The kasutajad konkreetselt, serverid kaitstud marsruudina. Piirates juurdepääsu kasutajatele, kellel on admin rolli, jõustate tõhusalt rollipõhist juurdepääsukontrolli.
Värskendage põhiserveri faili
Ava oma server.js faili ja värskendage seda järgmiselt:
konst väljendada = nõuda('väljendama');
konst cors = nõuda('kors');
konst cookieParser = nõuda('cookie-parser');
konst rakendus = express();
konst port = 5000;
nõuda('dotenv').config();
konst connectDB = nõuda('./utils/db');
konst pass = nõuda('pass');
nõuda("./middleware/pass")(pass);connectDB();
app.use (express.json());
app.use (express.urlencoded({ pikendatud: tõsi }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konst userRoutes = nõuda('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konsool.log(`Server töötab pordis ${port}`);
});
Lõpuks käivitage rakenduse käivitamiseks arendusserver.
sõlme server.jsKasutage oma autentimissüsteemide täiustamiseks RBAC-i mehhanismi
Rollipõhise juurdepääsukontrolli rakendamine on tõhus viis teie rakenduste turvalisuse suurendamiseks.
Olemasolevate autentimisteekide kaasamine tõhusa RBAC-süsteemi loomiseks on suurepärane lähenemisviis, kuid RBAC-teekide kasutamine kasutajarollide selgesõnaline määratlemine ja õiguste määramine pakub veelgi jõulisemat lahendust, suurendades lõpuks teie kasutajate üldist turvalisust. rakendus.