Find ud af, hvordan du kombinerer disse teknologier med en praktisk demonstration.
Rollebaseret adgangskontrol er en sikker godkendelsesmekanisme. Du kan bruge det til at begrænse adgangen til specifikke ressourcer til brugere, der har bestemte roller.
Denne type godkendelse hjælper systemadministratorer med at kontrollere tilladelser i henhold til brugernes udpegede roller. Dette niveau af granuleret kontrol tilføjer et lag af sikkerhed, så apps kan forhindre uautoriseret adgang.
Implementering af rollebaseret adgangskontrolmekanisme ved hjælp af Passport.js og JWT'er
Rollebaseret adgangskontrol (RBAC) er en populær mekanisme, der bruges til at håndhæve adgangsbegrænsninger i applikationer baseret på brugerroller og tilladelser. Der findes forskellige metoder til at implementere RBAC-mekanismen.
To populære tilgange inkluderer brug af dedikerede RBAC-biblioteker som Adgangskontrol eller udnyttelse af eksisterende autentificeringsbiblioteker til at implementere mekanismen.
I dette tilfælde giver JSON Web Tokens (JWT'er) en sikker måde at overføre autentificeringsoplysninger, mens Passport.js forenkler godkendelsesprocessen ved at give fleksibel godkendelse mellemvare.
Ved at bruge denne tilgang kan du tildele roller til brugere og indkode dem i JWT, når de godkendes. Du kan derefter bruge JWT til at verificere brugerens identitet og roller i efterfølgende anmodninger, hvilket giver mulighed for rollebaseret autorisation og adgangskontrol.
Begge tilgange har deres fordele og kan være effektive til at implementere RBAC. Valget mellem hvilken metode, der skal implementeres, afhænger af dit projekts specifikke krav.
Du kan downloade dette projekts kode fra dens GitHub-depot.
Konfigurer et Express.js-projekt
For at komme i gang, opsætte et Express.js-projekt lokalt. Når du har konfigureret projektet, skal du gå videre og installere disse pakker:
npm installer cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pas pas-lokaleNæste, oprette en MongoDB-database eller oprette en klynge på MongoDB Atlas. Kopier databaseforbindelsens URI og tilføj den til en .env fil i dit projekts rodmappe til dit projekt:
CONNECTION_URI="forbindelses-URI"Konfigurer databaseforbindelsen
I rodmappen skal du oprette en ny utils/db.js fil, og tilføj koden nedenfor for at etablere forbindelsen til MongoDB-klyngen, der kører på Atlas ved hjælp af Mongoose.
konst mangust = kræve('mangust');konst connectDB = asynkron () => {
prøve {
vente mongoose.connect (process.env. CONNECTION_URI);
konsol.log("Forbundet til MongoDB!");
} fangst (fejl) {
konsol.fejl("Fejl ved forbindelse til MongoDB:", fejl);
}
};
modul.exports = connectDB;
Definer datamodellen
I rodmappen skal du oprette en ny model/bruger.model.js fil, og tilføj følgende kode for at definere en datamodel for brugernes data ved hjælp af Mongoose.
konst mangust = kræve('mangust');konst userSchema = ny mangust. Skema({
brugernavn: Snor,
adgangskode: Snor,
rolle: Snor
});
modul.exports = mongoose.model('Bruger', brugerskema);
Opret controlleren til API-endepunkterne
Opret en ny controllere/bruger.controller.js fil i rodmappen og tilføj koden nedenfor.
Foretag først disse importer:
konst Bruger = kræve('../models/user.model');
konst pas = kræve('pas');
konst {genererToken } = kræve('../middleware/auth');
kræve('../middleware/pas')(pas);Definer derefter logikken til at administrere brugerregistrering og loginfunktionalitet:
exports.registerBruger = asynkron (req, res) => {
konst { brugernavn, adgangskode, rolle } = req.body;prøve {
vente User.create({ brugernavn, adgangskode, rolle });
res.status(201).json({ besked: 'Bruger registreret med succes' });
} fangst (fejl) {
konsol.log (fejl);
res.status(500).json({ besked: 'En fejl opstod!' });
}
};exports.loginUser = (kræve, res, næste) => {
pasport.authenticate('lokal', { session: falsk }, (fejl, bruger, info) => {
hvis (fejl) {
konsol.log (fejl);Vend tilbage res.status(500).json({
besked: 'Der opstod en fejl under login'
});
}hvis (!bruger) {
Vend tilbage res.status(401).json({
besked: 'Ugyldige loginoplysninger'
});
}req.login (bruger, { session: falsk }, (fejl) => {
hvis (fejl) {
konsol.log (fejl);Vend tilbage res.status(500).json({
besked: 'Der opstod en fejl under login'
});
}
konst { _id, brugernavn, rolle } = bruger;
konst nyttelast = { bruger ID: _id, brugernavn, rolle };
konst token = generToken (nyttelast);
res.cookie('polet', polet, { Kun http: rigtigt });
Vend tilbage res.status(200).json({ besked: 'Login lykkedes' });
});
})(req, res, næste);
};
Det registrer bruger funktion håndterer registreringen af en ny bruger ved at udtrække brugernavnet, adgangskoden og rollen fra anmodningens krop. Den opretter derefter en ny brugerindtastning i databasen og svarer med en succesmeddelelse eller en fejl, hvis der opstår nogen under processen.
På den anden side loginBruger funktionen letter brugerlogin ved at bruge den lokale godkendelsesstrategi leveret af Passport.js. Det autentificerer brugerens legitimationsoplysninger og returnerer et token ved vellykket login, som derefter gemmes i en cookie til efterfølgende autentificerede anmodninger. Hvis der opstår fejl under login-processen, vil den returnere en passende meddelelse.
Tilføj endelig koden, der implementerer logikken, der henter alle brugeres data fra databasen. Vi vil bruge dette slutpunkt som den begrænsede rute for at sikre, at kun autoriserede brugere med rollen som admin kan få adgang til dette slutpunkt.
exports.getUsers = asynkron (req, res) => {
prøve {
konst brugere = vente Bruger.find({});
res.json (brugere);
} fangst (fejl) {
konsol.log (fejl);
res.status(500).json({ besked: 'En fejl opstod!' });
}
};Konfigurer en Passport.js lokal godkendelsesstrategi
For at godkende brugere, efter at de har givet deres loginoplysninger, skal du konfigurere en lokal godkendelsesstrategi.
Opret en ny middleware/passport.js fil i rodmappen og tilføj følgende kode.
konst Lokal Strategi = kræve('pas-lokal').Strategi;
konst Bruger = kræve('../models/user.model');modul.eksport = (pas) => {
pas.brug(
ny Lokal Strategi(asynkron (brugernavn, adgangskode, færdig) => {
prøve {
konst bruger = vente User.findOne({ brugernavn });hvis (!bruger) {
Vend tilbage Færdig(nul, falsk);
}hvis (user.password !== adgangskode) {
Vend tilbage Færdig(nul, falsk);
}
Vend tilbage Færdig(nul, bruger);
} fangst (fejl) {
Vend tilbage udført (fejl);
}
})
);
};
Denne kode definerer en lokal passport.js-strategi til at godkende brugere baseret på deres angivne brugernavn og adgangskode.
Først forespørger den databasen for at finde en bruger med et matchende brugernavn og fortsætter derefter med at validere deres adgangskode. Følgelig returnerer det det godkendte brugerobjekt, hvis login-processen er vellykket.
Opret en JWT Verification Middleware
Inde i mellemvare mappe, opret en ny auth.js-fil og tilføj følgende kode for at definere en middleware, der genererer og verificerer JWT'er.
konst jwt = kræve('jsonwebtoken');
konst secretKey = proces.env. SECRET_KEY;konst generereToken = (nyttelast) => {
konst token = jwt.sign (nyttelast, secretKey, { udløberIn: '1h' });
Vend tilbage polet;
};konst verifyToken = (påkrævet Rolle) =>(kræve, res, næste) => {
konst token = req.cookies.token;hvis (!polet) {
Vend tilbage res.status(401).json({ besked: 'Ingen token angivet' });
}jwt.verify (token, secretKey, (fejl, afkodet) => {
hvis (fejl) {
Vend tilbage res.status(401).json({ besked: 'Ugyldig Token' });
}req.userId = decoded.userId;
hvis (decoded.role !== påkrævet Rolle) {
Vend tilbage res.status(403).json({
besked: 'Du har ikke tilladelsen og tilladelserne til at få adgang til denne ressource.'
});
}Næste();
});
};
modul.exports = { generateToken, verifyToken };
Det generere Token funktionen opretter en JWT med en specificeret udløbstid, mens verifyToken funktion kontrollerer, om tokenet er til stede og gyldigt. Derudover verificerer den også, at det afkodede token indeholder den påkrævede rolle, i det væsentlige, hvilket sikrer, at kun brugere med den autoriserede rolle og tilladelser har adgang.
For entydigt at signere JWT'erne skal du generere en unik hemmelig nøgle og tilføje den til din .env fil som vist nedenfor.
SECRET_KEY="Dette er et eksempel på en hemmelig nøgle."Definer API-ruterne
I rodmappen skal du oprette en ny mappe og navngive den ruter. Inde i denne mappe skal du oprette en ny userRoutes.js, og tilføj følgende kode.
konst udtrykke = kræve('udtrykke');
konst router = ekspres. Router();
konst userControllers = kræve('../controllers/userController');
konst { verifyToken } = kræve('../middleware/auth');router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);router.get('/api/brugere', verifyToken('admin'), userControllers.getUsers);
modul.exports = router;
Denne kode definerer HTTP-ruterne for en REST API. Det brugere rute specifikt, servere som den beskyttede rute. Ved at begrænse adgangen til brugere med admin rolle, håndhæver du effektivt rollebaseret adgangskontrol.
Opdater hovedserverfilen
Åben din server.js fil og opdater den som følger:
konst udtrykke = kræve('udtrykke');
konst cors = kræve('cors');
konst cookieParser = kræve('cookie-parser');
konst app = express();
konst port = 5000;
kræve('dotenv').config();
konst connectDB = kræve('./utils/db');
konst pas = kræve('pas');
kræve('./middleware/pas')(pas);connectDB();
app.use (express.json());
app.use (express.urlencoded({ udvidet: rigtigt }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konst brugerruter = kræve('./routes/brugerRoutes');
app.brug('/', brugerruter);
app.listen (port, () => {
konsol.log(`Serveren kører på port ${port}`);
});
Til sidst skal du starte udviklingsserveren for at køre applikationen.
node server.jsUdnyt RBAC-mekanismen til at løfte dine godkendelsessystemer
Implementering af rollebaseret adgangskontrol er en effektiv måde at forbedre sikkerheden i dine applikationer på.
Selvom det er en fantastisk tilgang at inkorporere eksisterende autentificeringsbiblioteker for at etablere et effektivt RBAC-system, udnytter RBAC-biblioteker til eksplicit definere brugerroller og tildele tilladelser giver en endnu mere robust løsning, der i sidste ende forbedrer den overordnede sikkerhed for din Ansøgning.