Uzziniet, kā šīs tehnoloģijas apvienot ar praktisku demonstrāciju.
Uz lomu balstīta piekļuves kontrole ir drošs autentifikācijas mehānisms. Varat to izmantot, lai ierobežotu piekļuvi konkrētiem resursiem lietotājiem, kuriem ir noteiktas lomas.
Šis autentifikācijas veids palīdz sistēmas administratoriem kontrolēt atļaujas atbilstoši lietotāju norādītajām lomām. Šis detalizētās kontroles līmenis papildina drošības līmeni, ļaujot lietotnēm novērst nesankcionētu piekļuvi.
Uz lomu balstīta piekļuves kontroles mehānisma ieviešana, izmantojot Passport.js un JWT
Uz lomu balstīta piekļuves kontrole (RBAC) ir populārs mehānisms, ko izmanto, lai ieviestu piekļuves ierobežojumus lietojumprogrammās, pamatojoties uz lietotāju lomām un atļaujām. Ir pieejamas dažādas metodes RBAC mehānisma ieviešanai.
Divas populāras pieejas ietver īpašu RBAC bibliotēku izmantošanu, piemēram, AcessControl vai izmantojot esošās autentifikācijas bibliotēkas, lai ieviestu mehānismu.
Šajā gadījumā JSON tīmekļa marķieri (JWT) nodrošina drošu veidu, kā pārsūtīt autentifikācijas akreditācijas datus, savukārt Passport.js vienkāršo autentifikācijas procesu, nodrošinot elastīgu autentifikāciju starpprogrammatūra.
Izmantojot šo pieeju, varat piešķirt lietotājiem lomas un kodēt tos JWT, kad viņi autentificējas. Pēc tam varat izmantot JWT, lai pārbaudītu lietotāja identitāti un lomas turpmākajos pieprasījumos, ļaujot veikt uz lomām balstītu autorizāciju un piekļuves kontroli.
Abām pieejām ir savas priekšrocības, un tās var būt efektīvas RBAC ieviešanā. Izvēle, kuru metodi ieviest, būs atkarīga no jūsu projekta īpašajām prasībām.
Jūs varat lejupielādēt šī projekta kodu no tā GitHub repozitorijs.
Iestatiet Express.js projektu
Lai sāktu, iestatiet Express.js projektu lokāli. Kad esat iestatījis projektu, turpiniet un instalējiet šīs pakotnes:
npm instalēt cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pase pase-vietējāNākamais, izveidot MongoDB datu bāzi vai izveidojiet klasteru vietnē MongoDB Atlas. Kopējiet datu bāzes savienojuma URI un pievienojiet to a .env failu sava projekta saknes direktorijā:
CONNECTION_URI="savienojuma URI"Konfigurējiet datu bāzes savienojumu
Saknes direktorijā izveidojiet jaunu utils/db.js failu un pievienojiet tālāk norādīto kodu, lai izveidotu savienojumu ar MongoDB klasteru, kas darbojas vietnē Atlas, izmantojot Mongoose.
konst mangusts = pieprasīt('mangusts');konst connectDB = asinhrons () => {
mēģināt {
gaidīt mongoose.connect (process.env. CONNECTION_URI);
konsole.log("Savienots ar MongoDB!");
} noķert (kļūda) {
konsole.error("Kļūda, veidojot savienojumu ar MongoDB:", kļūda);
}
};
modulis.exports = connectDB;
Definējiet datu modeli
Saknes direktorijā izveidojiet jaunu model/user.model.js failu un pievienojiet šādu kodu, lai definētu datu modeli lietotāju datiem, izmantojot Mongoose.
konst mangusts = pieprasīt('mangusts');konst userSchema = jauns mangusts. Shēma({
lietotājvārds: Stīga,
parole: Stīga,
loma: Stīga
});
modulis.exports = mangusts.model('Lietotājs', userSchema);
Izveidojiet kontrolieri API galapunktiem
Izveidojiet jaunu controllers/user.controller.js failu saknes direktorijā un pievienojiet tālāk norādīto kodu.
Vispirms veiciet šādu importēšanu:
konst Lietotājs = pieprasīt("../models/user.model");
konst pase = pieprasīt('pase');
konst {generToken} = pieprasīt("../middleware/auth");
pieprasīt("../middleware/passe")(pase);Pēc tam definējiet lietotāja reģistrācijas un pieteikšanās funkcionalitātes pārvaldības loģiku:
exports.registerUser = asinhrons (req, res) => {
konst { lietotājvārds, parole, loma } = req.body;mēģināt {
gaidīt User.create({ lietotājvārds, parole, loma });
res.status(201).json({ ziņa: "Lietotājs veiksmīgi reģistrēts" });
} noķert (kļūda) {
konsole.log (kļūda);
res.status(500).json({ ziņa: 'Notika kļūda!' });
}
};exports.loginUser = (req, res, next) => {
pass.authenticate('vietējais', { sesija: viltus }, (kļūda, lietotājs, informācija) => {
ja (kļūda) {
konsole.log (err);atgriezties res.status(500).json({
ziņa: "Pieteikšanās laikā radās kļūda"
});
}ja (!lietotājs) {
atgriezties res.status(401).json({
ziņa: "Nederīgi pieteikšanās akreditācijas dati"
});
}req.login (lietotājs, { sesija: viltus }, (kļūda) => {
ja (kļūda) {
konsole.log (err);atgriezties res.status(500).json({
ziņa: "Pieteikšanās laikā radās kļūda"
});
}
konst { _id, lietotājvārds, loma } = lietotājs;
konst krava = { Lietotāja ID: _id, lietotājvārds, loma };
konst token = generētToken (lietderīgā slodze);
res.cookie('žetons', marķieris, { Tikai http: taisnība });
atgriezties res.status(200).json({ ziņa: 'Pieteikšanās veiksmīga' });
});
})(req, res, next);
};
The reģistrēt Lietotājs funkcija apstrādā jauna lietotāja reģistrāciju, izvelkot lietotājvārdu, paroli un lomu no pieprasījuma pamatteksta. Pēc tam tas izveido jaunu lietotāja ierakstu datu bāzē un atbild ar veiksmes ziņojumu vai kļūdu, ja tāda notiek procesa laikā.
No otras puses, loginUser funkcija atvieglo lietotāja pieteikšanos, izmantojot Passport.js nodrošināto vietējo autentifikācijas stratēģiju. Tas autentificē lietotāja akreditācijas datus un pēc veiksmīgas pieteikšanās atgriež marķieri, kas pēc tam tiek saglabāts sīkfailā turpmākiem autentificētiem pieprasījumiem. Ja pieteikšanās procesā rodas kļūdas, tas atgriezīs atbilstošu ziņojumu.
Visbeidzot pievienojiet kodu, kas ievieš loģiku visu lietotāju datu iegūšanai no datu bāzes. Mēs izmantosim šo galapunktu kā ierobežotu maršrutu, lai nodrošinātu, ka tikai autorizētie lietotāji ar lomu admin var piekļūt šim galapunktam.
exports.getUsers = asinhrons (req, res) => {
mēģināt {
konst lietotāji = gaidīt User.find({});
res.json (lietotāji);
} noķert (kļūda) {
konsole.log (kļūda);
res.status(500).json({ ziņa: 'Notika kļūda!' });
}
};Iestatiet Passport.js vietējās autentifikācijas stratēģiju
Lai autentificētu lietotājus pēc tam, kad viņi ir norādījuši savus pieteikšanās akreditācijas datus, jums ir jāiestata vietējā autentifikācijas stratēģija.
Izveidojiet jaunu starpprogrammatūra/passport.js failu saknes direktorijā un pievienojiet šādu kodu.
konst Vietējā stratēģija = pieprasīt('pase-vietējais').Stratēģija;
konst Lietotājs = pieprasīt("../models/user.model");modulis.eksports = (pase) => {
pass.use(
jauns LocalStrategy(asinhrons (lietotājvārds, parole, gatavs) => {
mēģināt {
konst lietotājs = gaidīt User.findOne({ lietotājvārds });ja (!lietotājs) {
atgriezties darīts (null, viltus);
}ja (lietotāja.parole !== parole) {
atgriezties darīts (null, viltus);
}
atgriezties darīts (null, lietotājs);
} noķert (kļūda) {
atgriezties darīts (kļūda);
}
})
);
};
Šis kods nosaka vietējo passport.js stratēģiju, lai autentificētu lietotājus, pamatojoties uz viņu norādīto lietotājvārdu un paroli.
Sākumā tas vaicā datu bāzē, lai atrastu lietotāju ar atbilstošu lietotājvārdu, un pēc tam apstiprina viņa paroli. Līdz ar to tas atgriež autentificēto lietotāja objektu, ja pieteikšanās process ir veiksmīgs.
Izveidojiet JWT verifikācijas starpprogrammatūru
Iekšpusē starpprogrammatūra direktorijā, izveidojiet jaunu auth.js failu un pievienojiet tālāk norādīto kodu, lai definētu starpprogrammatūru, kas ģenerē un pārbauda JWT.
konst jwt = pieprasīt("jsonwebtoken");
konst secretKey = process.env. SECRET_KEY;konst GeneToken = (kravnesība) => {
konst marķieris = jwt.sign (lietderīgā slodze, secretKey, { beidzasIn: '1h' });
atgriezties žetons;
};konst verifyToken = (nepieciešamaLoma) =>(req, res, next) => {
konst marķieris = req.cookies.token;ja (!token) {
atgriezties res.status(401).json({ ziņa: "Nav nodrošināts marķieris" });
}jwt.verify (token, secretKey, (err, decoded) => {
ja (kļūda) {
atgriezties res.status(401).json({ ziņa: "Nederīgs marķieris" });
}req.userId = decoded.userId;
ja (decoded.role !== requiredRole) {
atgriezties res.status(403).json({
ziņa: "Jums nav pilnvaru un atļauju, lai piekļūtu šim resursam."
});
}Nākamais();
});
};
modulis.exports = {generToken, verifyToken};
The GeneToken funkcija izveido JWT ar noteiktu derīguma termiņu, savukārt verifyToken funkcija pārbauda, vai marķieris ir un ir derīgs. Turklāt tas arī pārbauda, vai dekodētajā pilnvarā ir vajadzīgā loma, būtībā nodrošinot, ka piekļuve ir tikai lietotājiem ar autorizētu lomu un atļaujām.
Lai unikāli parakstītu JWT, jums ir jāģenerē unikāla slepenā atslēga un jāpievieno tā savam .env failu, kā parādīts zemāk.
SECRET_KEY="Šī ir slepenās atslēgas paraugs."Definējiet API maršrutus
Saknes direktorijā izveidojiet jaunu mapi un nosauciet tai maršrutus. Šajā mapē izveidojiet jaunu userRoutes.jsun pievienojiet šādu kodu.
konst izteikt = pieprasīt('izteikt');
konst maršrutētājs = ekspress. Maršrutētājs ();
konst userControllers = pieprasīt("../controllers/userController");
konst { verifyToken } = pieprasīt("../middleware/auth");router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);router.get('/api/lietotāji', verifyToken('admins'), userControllers.getUsers);
modulis.exports = maršrutētājs;
Šis kods nosaka HTTP maršrutus REST API. The lietotājiem maršruts konkrēti, serveri kā aizsargātais maršruts. Ierobežojot piekļuvi lietotājiem ar admin lomu, jūs efektīvi ieviešat uz lomām balstītu piekļuves kontroli.
Atjauniniet galvenā servera failu
Atver savu serveris.js failu un atjauniniet to šādi:
konst izteikt = pieprasīt('izteikt');
konst cors = pieprasīt('kors');
konst cookieParser = pieprasīt('cookie-parser');
konst lietotne = express();
konst ports = 5000;
pieprasīt('dotenv').config();
konst connectDB = pieprasīt('./utils/db');
konst pase = pieprasīt('pase');
pieprasīt('./middleware/passport')(pase);connectDB();
app.use (express.json());
app.use (express.urlencoded({ pagarināts: taisnība }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konst userRoutes = pieprasīt('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konsole.log(`Serveris darbojas portā ${port}`);
});
Visbeidzot, startējiet izstrādes serveri, lai palaistu lietojumprogrammu.
mezgla serveris.jsIzmantojiet RBAC mehānismu, lai uzlabotu savas autentifikācijas sistēmas
Uz lomu balstītas piekļuves kontroles ieviešana ir efektīvs veids, kā uzlabot jūsu lietojumprogrammu drošību.
Lai gan esošo autentifikācijas bibliotēku iekļaušana efektīvas RBAC sistēmas izveidei ir lieliska pieeja, izmantojot RBAC bibliotēkas, lai skaidri definējiet lietotāju lomas un piešķiriet atļaujas, kas nodrošina vēl stabilāku risinājumu, galu galā uzlabojot jūsu vispārējo drošību pieteikumu.