Finn ut hvordan du kombinerer disse teknologiene med en praktisk demonstrasjon.

Rollebasert tilgangskontroll er en sikker autentiseringsmekanisme. Du kan bruke den til å begrense tilgangen til bestemte ressurser til brukere som har bestemte roller.

Denne typen autentisering hjelper systemadministratorer med å kontrollere tillatelser i henhold til brukernes utpekte roller. Dette nivået av granulær kontroll legger til et lag med sikkerhet, slik at apper kan forhindre uautorisert tilgang.

Implementering av rollebasert tilgangskontrollmekanisme ved å bruke Passport.js og JWTs

Rollebasert tilgangskontroll (RBAC) er en populær mekanisme som brukes til å håndheve tilgangsbegrensninger i applikasjoner basert på brukerroller og tillatelser. Det er forskjellige metoder tilgjengelig for å implementere RBAC-mekanismen.

To populære tilnærminger inkluderer bruk av dedikerte RBAC-biblioteker som Tilgangskontroll eller utnytte eksisterende autentiseringsbiblioteker for å implementere mekanismen.

I dette tilfellet gir JSON Web Tokens (JWTs) en sikker måte å overføre autentiseringslegitimasjon, mens Passport.js forenkler autentiseringsprosessen ved å tilby fleksibel autentisering mellomvare.

instagram viewer

Ved å bruke denne tilnærmingen kan du tilordne roller til brukere og kode dem i JWT når de autentiserer. Du kan deretter bruke JWT til å verifisere brukerens identitet og roller i påfølgende forespørsler, noe som gir mulighet for rollebasert autorisasjon og tilgangskontroll.

Begge tilnærmingene har sine fordeler og kan være effektive i implementeringen av RBAC. Valget mellom hvilken metode som skal implementeres vil avhenge av prosjektets spesifikke krav.

Du kan laste ned koden til dette prosjektet fra dens GitHub-depot.

Sett opp et Express.js-prosjekt

For å komme i gang, sette opp et Express.js-prosjekt lokalt. Når du har satt opp prosjektet, fortsett og installer disse pakkene:

npm installer cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
 pass pass-lokale

Neste, opprette en MongoDB-database eller sette opp en klynge på MongoDB Atlas. Kopier databasetilkoblingens URI og legg den til i en .env fil i prosjektets rotkatalog for prosjektet:

CONNECTION_URI="tilkoblings-URI"

Konfigurer databasetilkoblingen

Opprett en ny i rotkatalogen utils/db.js fil, og legg til koden nedenfor for å etablere forbindelsen til MongoDB-klyngen som kjører på Atlas ved hjelp av Mongoose.

konst mangust = krever("mangus");
konst connectDB = asynkron () => {
prøve {
avvente mongoose.connect (process.env. CONNECTION_URI);
konsoll.Logg("Koblet til MongoDB!");
 } å fange (feil) {
konsoll.feil("Feil ved tilkobling til MongoDB:", feil);
 }
};
modul.exports = connectDB;

Definer datamodellen

Opprett en ny i rotkatalogen model/user.model.js fil, og legg til følgende kode for å definere en datamodell for brukernes data ved bruk av Mongoose.

konst mangust = krever("mangus");
konst userSchema = ny mangust. Skjema({
 brukernavn: String,
 passord: String,
 rolle: String
});
modul.exports = mongoose.model('Bruker', brukerskjema);

Opprett kontrolleren for API-endepunktene

Lage en ny kontroller/bruker.kontroller.js fil i rotkatalogen og legg til koden nedenfor.

Foreta først disse importene:

konst Bruker = krever('../models/user.model');
konst pass = krever('pass');
konst { genererToken } = krever('../middleware/auth');
krever('../middleware/passport')(pass);

Definer deretter logikken for å administrere brukerregistrering og påloggingsfunksjonalitet:

exports.registerUser = asynkron (req, res) => {
konst { brukernavn, passord, rolle } = req.body;
prøve {
avvente User.create({ brukernavn, passord, rolle });
 res.status(201).json({ beskjed: "Bruker registrert vellykket" });
 } å fange (feil) {
konsoll.log (feil);
 res.status(500).json({ beskjed: 'En feil oppstod!' });
 }
};


exports.loginUser = (req, res, neste) => {
 passport.authenticate('lokal', { økt: falsk }, (feil, bruker, info) => {
hvis (feil) {
konsoll.log (feil);


komme tilbake res.status(500).json({
 beskjed: "Det oppstod en feil under pålogging"
 });
 }


hvis (!bruker) {
komme tilbake res.status(401).json({
 beskjed: 'Ugyldig innloggingsinformasjon'
 });
 }


 req.login (bruker, { økt: falsk }, (feil) => {
hvis (feil) {
konsoll.log (feil);


komme tilbake res.status(500).json({
 beskjed: "Det oppstod en feil under pålogging"
 });
 }
konst { _id, brukernavn, rolle } = bruker;
konst nyttelast = { bruker-ID: _id, brukernavn, rolle };
konst token = generToken (nyttelast);
 res.cookie('token', token, { httpBare: ekte });
komme tilbake res.status(200).json({ beskjed: 'Vellykket innlogging' });
 });
 })(req, res, neste);
};

De registrer bruker funksjonen håndterer registreringen av en ny bruker ved å trekke ut brukernavnet, passordet og rollen fra forespørselsteksten. Deretter oppretter den en ny brukeroppføring i databasen og svarer med en suksessmelding eller en feil hvis noen oppstår under prosessen.

På den annen side loginBruker funksjonen letter brukerinnlogging ved å bruke den lokale autentiseringsstrategien levert av Passport.js. Den autentiserer brukerens legitimasjon og returnerer et token ved vellykket pålogging som deretter lagres i en informasjonskapsel for påfølgende autentiserte forespørsler. Hvis det oppstår feil under påloggingsprosessen, vil det returnere en passende melding.

Til slutt legger du til koden som implementerer logikken som henter alle brukernes data fra databasen. Vi bruker dette endepunktet som den begrensede ruten for å sikre at kun autoriserte brukere med rollen som admin kan få tilgang til dette endepunktet.

exports.getUsers = asynkron (req, res) => {
prøve {
konst brukere = avvente Bruker.finn({});
 res.json (brukere);
 } å fange (feil) {
konsoll.log (feil);
 res.status(500).json({ beskjed: 'En feil oppstod!' });
 }
};

Sett opp en Passport.js lokal autentiseringsstrategi

For å autentisere brukere etter at de har oppgitt påloggingsinformasjonen, må du sette opp en lokal autentiseringsstrategi.

Lage en ny mellomvare/passport.js fil i rotkatalogen og legg til følgende kode.

konst Lokal Strategi = krever("pass-lokal").Strategi;
konst Bruker = krever('../models/user.model');
modul.eksport = (pass) => {
 passport.use(
ny lokal strategi(asynkron (brukernavn, passord, ferdig) => {
prøve {
konst bruker = avvente User.findOne({ brukernavn });


hvis (!bruker) {
komme tilbake ferdig(null, falsk);
 }


hvis (bruker.passord !== passord) {
komme tilbake ferdig(null, falsk);
 }
komme tilbake ferdig(null, bruker);
 } å fange (feil) {
komme tilbake gjort (feil);
 }
 })
 );
};

Denne koden definerer en lokal passport.js-strategi for å autentisere brukere basert på deres oppgitte brukernavn og passord.

Først spør den databasen for å finne en bruker med et matchende brukernavn og fortsetter deretter med å validere passordet. Følgelig returnerer den det autentiserte brukerobjektet hvis påloggingsprosessen er vellykket.

Opprett en JWT-verifiseringsmellomvare

Inne i mellomvare katalog, opprett en ny auth.js-fil, og legg til følgende kode for å definere en mellomvare som genererer og verifiserer JWT-er.

konst jwt = krever('jsonwebtoken');
konst secretKey = prosess.env. SECRET_KEY;
konst generToken = (nyttelast) => {
konst token = jwt.sign (nyttelast, secretKey, { utgår om: '1t' });
komme tilbake token;
};


konst verifyToken = (nødvendig Rolle) =>(req, res, neste) => {
konst token = req.cookies.token;


hvis (!token) {
komme tilbake res.status(401).json({ beskjed: "Ingen token gitt" });
 }


 jwt.verify (token, secretKey, (feil, dekodet) => {
hvis (feil) {
komme tilbake res.status(401).json({ beskjed: "Ugyldig token" });
 }


 req.userId = decoded.userId; 


hvis (decoded.role !== obligatorisk Rolle) {
komme tilbake res.status(403).json({
 beskjed: "Du har ikke autorisasjonen og tillatelsene til å få tilgang til denne ressursen."
 });
 }


 neste();
 });
};
modul.exports = { generateToken, verifyToken };

De generere Token funksjonen oppretter en JWT med en spesifisert utløpstid, mens verifyToken funksjonen sjekker om tokenet er tilstede og gyldig. I tillegg verifiserer den også at det dekodede tokenet inneholder den nødvendige rollen, i hovedsak, og sikrer at bare brukere med den autoriserte rollen og tillatelsene har tilgang.

For å signere JWT-ene unikt, må du generere en unik hemmelig nøkkel og legge den til .env fil som vist nedenfor.

SECRET_KEY="Dette er et eksempel på en hemmelig nøkkel."

Definer API-rutene

Opprett en ny mappe i rotkatalogen og navngi den ruter. Opprett en ny i denne mappen userRoutes.js, og legg til følgende kode.

konst uttrykke = krever('uttrykke');
konst ruter = ekspress. Ruter();
konst userControllers = krever('../controllers/userController');
konst { verifyToken } = krever('../middleware/auth');
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);


router.get('/api/brukere', verifyToken('admin'), userControllers.getUsers);
modul.exports = ruter;

Denne koden definerer HTTP-rutene for en REST API. De brukere rute spesifikt, servere som den beskyttede ruten. Ved å begrense tilgangen til brukere med admin rolle, håndhever du effektivt rollebasert tilgangskontroll.

Oppdater hovedserverfilen

Åpne din server.js fil og oppdater den som følger:

konst uttrykke = krever('uttrykke');
konst cors = krever('cors');
konst cookieParser = krever("cookie-parser");
konst app = express();
konst port = 5000;
krever('dotenv').config();
konst connectDB = krever('./utils/db');
konst pass = krever('pass');
krever('./middleware/passport')(pass);
koble DB();


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


konst brukerruter = krever('./ruter/brukerruter');
app.bruk('/', brukerruter);
app.listen (port, () => {
konsoll.Logg(`Tjeneren kjører på port ${port}`);
});

Til slutt starter du utviklingsserveren for å kjøre applikasjonen.

node server.js

Utnytt RBAC-mekanismen for å heve autentiseringssystemene dine

Implementering av rollebasert tilgangskontroll er en effektiv måte å forbedre sikkerheten til applikasjonene dine på.

Selv om det er en flott tilnærming å innlemme eksisterende autentiseringsbiblioteker for å etablere et effektivt RBAC-system, men å utnytte RBAC-bibliotekene til å eksplisitt definere brukerroller og tildele tillatelser gir en enda mer robust løsning, som til slutt forbedrer den generelle sikkerheten til applikasjon.