Ta reda på hur du kombinerar dessa tekniker med en praktisk demonstration.
Rollbaserad åtkomstkontroll är en säker autentiseringsmekanism. Du kan använda den för att begränsa åtkomsten till specifika resurser till användare som har vissa roller.
Denna typ av autentisering hjälper systemadministratörer att kontrollera behörigheter enligt användarnas utsedda roller. Denna nivå av granulär kontroll lägger till ett lager av säkerhet, vilket gör att appar kan förhindra obehörig åtkomst.
Implementera rollbaserad åtkomstkontrollmekanism med hjälp av Passport.js och JWTs
Rollbaserad åtkomstkontroll (RBAC) är en populär mekanism som används för att upprätthålla åtkomstbegränsningar i applikationer baserade på användarroller och behörigheter. Det finns olika metoder tillgängliga för att implementera RBAC-mekanismen.
Två populära metoder inkluderar att använda dedikerade RBAC-bibliotek som AccessControl eller utnyttja befintliga autentiseringsbibliotek för att implementera mekanismen.
I det här fallet ger JSON Web Tokens (JWT) ett säkert sätt att överföra autentiseringsuppgifter, medan Passport.js förenklar autentiseringsprocessen genom att tillhandahålla flexibel autentisering mellanprogram.
Med detta tillvägagångssätt kan du tilldela roller till användare och koda dem i JWT när de autentiserar. Du kan sedan använda JWT för att verifiera användarens identitet och roller i efterföljande förfrågningar, vilket möjliggör rollbaserad auktorisering och åtkomstkontroll.
Båda tillvägagångssätten har sina fördelar och kan vara effektiva för att implementera RBAC. Valet mellan vilken metod som ska implementeras beror på ditt projekts specifika krav.
Du kan ladda ner detta projekts kod från dess GitHub-förråd.
Konfigurera ett Express.js-projekt
För att starta, ställ in ett Express.js-projekt lokalt. När du har konfigurerat projektet, fortsätt och installera dessa paket:
npm installera cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pass pass-lokalNästa, skapa en MongoDB-databas eller skapa ett kluster på MongoDB Atlas. Kopiera databasanslutningens URI och lägg till den i en .env fil i ditt projekts rotkatalog för ditt projekt:
CONNECTION_URI="anslutnings-URI"Konfigurera databasanslutningen
Skapa en ny i rotkatalogen utils/db.js fil och lägg till koden nedan för att upprätta anslutningen till MongoDB-klustret som körs på Atlas med Mongoose.
konst mangust = behöva('mungo');konst connectDB = asynkron () => {
Prova {
vänta mongoose.connect (process.env. CONNECTION_URI);
trösta.logga("Ansluten till MongoDB!");
} fånga (fel) {
trösta.fel("Fel vid anslutning till MongoDB:", fel);
}
};
modul.exports = connectDB;
Definiera datamodellen
Skapa en ny i rotkatalogen model/user.model.js fil och lägg till följande kod för att definiera en datamodell för användarnas data som använder Mongoose.
konst mangust = behöva('mungo');konst userSchema = ny mungo. Schema({
Användarnamn: Sträng,
Lösenord: Sträng,
roll: Sträng
});
modul.exports = mongoose.model('Användare', userSchema);
Skapa controllern för API-ändpunkterna
Skapa en ny controllers/user.controller.js fil i rotkatalogen och lägg till koden nedan.
Gör först dessa importer:
konst Användare = behöva('../models/user.model');
konst pass = behöva('pass');
konst { generateToken } = behöva('../middleware/auth');
behöva('../mellanprogram/pass')(pass);Definiera sedan logiken för att hantera användarregistrering och inloggningsfunktioner:
exports.registerUser = asynkron (req, res) => {
konst { användarnamn, lösenord, roll } = req.body;Prova {
vänta User.create({ användarnamn, lösenord, roll });
res.status(201).json({ meddelande: "Användaren har registrerats framgångsrikt" });
} fånga (fel) {
trösta.log (fel);
res.status(500).json({ meddelande: 'Ett fel uppstod!' });
}
};exports.loginUser = (req, res, nästa) => {
passport.authenticate('lokal', { session: falsk }, (fel, användare, info) => {
om (fel) {
trösta.log (fel);lämna tillbaka res.status(500).json({
meddelande: "Ett fel uppstod vid inloggning"
});
}om (!användare) {
lämna tillbaka res.status(401).json({
meddelande: "Ogiltiga inloggningsuppgifter"
});
}req.login (användare, { session: falsk }, (fel) => {
om (fel) {
trösta.log (fel);lämna tillbaka res.status(500).json({
meddelande: "Ett fel uppstod vid inloggning"
});
}
konst { _id, användarnamn, roll } = användare;
konst nyttolast = { användar ID: _id, användarnamn, roll };
konst token = genereraToken (nyttolast);
res.cookie('tecken', token, { httpEndast: Sann });
lämna tillbaka res.status(200).json({ meddelande: 'Inloggningen lyckades' });
});
})(req, res, nästa);
};
De registrera användare funktionen hanterar registreringen av en ny användare genom att extrahera användarnamnet, lösenordet och rollen från förfrågan. Den skapar sedan en ny användarpost i databasen och svarar med ett framgångsmeddelande eller ett fel om något inträffar under processen.
Å andra sidan loginAnvändare funktionen underlättar användarinloggning genom att använda den lokala autentiseringsstrategin som tillhandahålls av Passport.js. Den autentiserar användarens autentiseringsuppgifter och returnerar en token vid lyckad inloggning som sedan lagras i en cookie för efterföljande autentiserade förfrågningar. Om några fel uppstår under inloggningsprocessen kommer det att returnera ett lämpligt meddelande.
Lägg slutligen till koden som implementerar logiken som hämtar alla användares data från databasen. Vi kommer att använda denna slutpunkt som den begränsade vägen för att säkerställa att endast auktoriserade användare med rollen som administration kan komma åt denna slutpunkt.
exports.getUsers = asynkron (req, res) => {
Prova {
konst användare = vänta User.find({});
res.json (användare);
} fånga (fel) {
trösta.log (fel);
res.status(500).json({ meddelande: 'Ett fel uppstod!' });
}
};Ställ in en Passport.js lokal autentiseringsstrategi
För att autentisera användare efter att de har angett sina inloggningsuppgifter måste du ställa in en lokal autentiseringsstrategi.
Skapa en ny middleware/passport.js fil i rotkatalogen och lägg till följande kod.
konst LocalStrategy = behöva("pass-lokal").Strategi;
konst Användare = behöva('../models/user.model');modul.export = (pass) => {
passport.use(
ny LocalStrategy(asynkron (användarnamn, lösenord, klar) => {
Prova {
konst användare = vänta User.findOne({ användarnamn });om (!användare) {
lämna tillbaka Gjort(null, falsk);
}om (user.password !== lösenord) {
lämna tillbaka Gjort(null, falsk);
}
lämna tillbaka Gjort(null, användare);
} fånga (fel) {
lämna tillbaka gjort (fel);
}
})
);
};
Den här koden definierar en lokal passport.js-strategi för att autentisera användare baserat på deras angivna användarnamn och lösenord.
Först frågar den databasen för att hitta en användare med ett matchande användarnamn och fortsätter sedan med att validera deras lösenord. Följaktligen returnerar den det autentiserade användarobjektet om inloggningsprocessen lyckas.
Skapa en JWT-verifieringsmellanvara
Inuti mellanprogram katalog, skapa en ny auth.js-fil och lägg till följande kod för att definiera en mellanprogramvara som genererar och verifierar JWT.
konst jwt = behöva('jsonwebtoken');
konst secretKey = process.env. HEMLIG NYCKEL;konst genereraToken = (nyttolast) => {
konst token = jwt.sign (nyttolast, secretKey, { går ut om: '1h' });
lämna tillbaka tecken;
};konst verifyToken = (obligatorisk Roll) =>(req, res, nästa) => {
konst token = req.cookies.token;om (!token) {
lämna tillbaka res.status(401).json({ meddelande: "Ingen token tillhandahålls" });
}jwt.verify (token, secretKey, (fel, avkodad) => {
om (fel) {
lämna tillbaka res.status(401).json({ meddelande: "Ogiltig token" });
}req.userId = decoded.userId;
om (decoded.role !== obligatorisk Roll) {
lämna tillbaka res.status(403).json({
meddelande: "Du har inte behörighet och behörighet att komma åt den här resursen."
});
}Nästa();
});
};
modul.exports = { generateToken, verifyToken };
De generera Token funktionen skapar en JWT med en specificerad utgångstid, medan verifiera Token funktion kontrollerar om token är närvarande och giltig. Dessutom verifierar den också att den avkodade token innehåller den nödvändiga rollen, i huvudsak, vilket säkerställer att endast användare med den auktoriserade rollen och behörigheterna har åtkomst.
För att unikt signera JWT: erna måste du generera en unik hemlig nyckel och lägga till den i din .env fil som visas nedan.
SECRET_KEY="Detta är ett exempel på en hemlig nyckel."Definiera API-rutter
Skapa en ny mapp i rotkatalogen och namnge den rutter. Skapa en ny i den här mappen userRoutes.js, och lägg till följande kod.
konst uttrycka = behöva('uttrycka');
konst router = express. Router();
konst userControllers = behöva('../controllers/userController');
konst { verifyToken } = behöva('../middleware/auth');router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);router.get('/api/users', verifyToken('administration'), userControllers.getUsers);
modul.exports = router;
Denna kod definierar HTTP-rutter för ett REST API. De användare rutt specifikt, servrar som den skyddade rutten. Genom att begränsa åtkomsten till användare med administration roll, upprätthåller du effektivt rollbaserad åtkomstkontroll.
Uppdatera huvudserverfilen
Öppna din server.js fil och uppdatera den enligt följande:
konst uttrycka = behöva('uttrycka');
konst cors = behöva('cors');
konst cookieParser = behöva("cookie-parser");
konst app = express();
konst port = 5000;
behöva('dotenv').config();
konst connectDB = behöva('./utils/db');
konst pass = behöva('pass');
behöva('./middleware/pass')(pass);connectDB();
app.use (express.json());
app.use (express.urlencoded({ förlängt: Sann }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konst userRoutes = behöva('./routes/userRoutes');
app.use('/', användarvägar);
app.listen (port, () => {
trösta.logga(`Server körs på port ${port}`);
});
Starta slutligen utvecklingsservern för att köra applikationen.
nod server.jsUtnyttja RBAC-mekanismen för att höja dina autentiseringssystem
Att implementera rollbaserad åtkomstkontroll är ett effektivt sätt att förbättra säkerheten för dina applikationer.
Även om det är ett utmärkt tillvägagångssätt att införliva befintliga autentiseringsbibliotek för att etablera ett effektivt RBAC-system, kan RBAC-bibliotek utnyttjas för att att uttryckligen definiera användarroller och tilldela behörigheter ger en ännu mer robust lösning som i slutändan förbättrar den övergripande säkerheten för din Ansökan.
