Zistite, ako tieto technológie skombinovať s praktickou ukážkou.
Riadenie prístupu na základe rolí je bezpečný mechanizmus autentifikácie. Môžete ho použiť na obmedzenie prístupu ku konkrétnym zdrojom pre používateľov, ktorí majú určité roly.
Tento typ autentifikácie pomáha správcom systému kontrolovať povolenia podľa určených rolí používateľov. Táto úroveň podrobnej kontroly pridáva vrstvu zabezpečenia, ktorá umožňuje aplikáciám zabrániť neoprávnenému prístupu.
Implementácia mechanizmu riadenia prístupu na základe rolí pomocou Passport.js a JWT
Riadenie prístupu založeného na rolách (RBAC) je populárny mechanizmus používaný na presadzovanie obmedzení prístupu v aplikáciách na základe rolí a povolení používateľov. Na implementáciu mechanizmu RBAC sú k dispozícii rôzne metódy.
Dva populárne prístupy zahŕňajú použitie vyhradených knižníc RBAC, ako napr AcessControl alebo využitie existujúcich autentifikačných knižníc na implementáciu mechanizmu.
V tomto prípade JSON Web Tokeny (JWT) poskytujú bezpečný spôsob prenosu overovacích poverení, zatiaľ čo Passport.js zjednodušuje proces autentifikácie poskytovaním flexibilnej autentifikácie middleware.
Pomocou tohto prístupu môžete používateľom priradiť roly a zakódovať ich v JWT, keď sa overia. Potom môžete použiť JWT na overenie identity a rolí používateľa v nasledujúcich požiadavkách, čo umožňuje autorizáciu a riadenie prístupu na základe rolí.
Oba prístupy majú svoje výhody a môžu byť efektívne pri implementácii RBAC. Výber medzi metódou implementácie bude závisieť od konkrétnych požiadaviek vášho projektu.
Kód tohto projektu si môžete stiahnuť z jeho úložisko GitHub.
Nastavte projekt Express.js
Začať, lokálne nastaviť projekt Express.js. Po nastavení projektu pokračujte a nainštalujte tieto balíky:
npm install cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pas pas-miestnyĎalšie, vytvorte databázu MongoDB alebo nastaviť klaster na MongoDB Atlas. Skopírujte URI databázového pripojenia a pridajte ho do a .env súbor v koreňovom adresári vášho projektu:
CONNECTION_URI="URI pripojenia"Nakonfigurujte pripojenie k databáze
V koreňovom adresári vytvorte nový utils/db.js súbor a pridajte kód nižšie na vytvorenie pripojenia ku klastru MongoDB spustenému na Atlase pomocou Mongoose.
konšt mangusta = vyžadovať("mongoose");konšt pripojiťDB = async () => {
skúste {
čakať mongoose.connect (process.env. CONNECTION_URI);
konzoly.log("Pripojené k MongoDB!");
} chytiť (chyba) {
konzoly.chyba("Chyba pri pripájaní k MongoDB:", chyba);
}
};
modul.export = connectDB;
Definujte dátový model
V koreňovom adresári vytvorte nový model/user.model.js súbor a pridajte nasledujúci kód na definovanie dátového modelu pre dáta používateľov pomocou Mongoose.
konšt mangusta = vyžadovať("mongoose");konšt userSchema = Nový mangusta. Schéma({
užívateľské meno: Reťazec,
heslo: Reťazec,
rola: Reťazec
});
modul.exports = mongoose.model('používateľ', userSchema);
Vytvorte radič pre koncové body API
Vytvorte nový controllers/user.controller.js súbor v koreňovom adresári a pridajte kód nižšie.
Najprv vykonajte tieto importy:
konšt Používateľ = vyžadovať('../models/user.model');
konšt pas = vyžadovať('pas');
konšt { vygenerovať token } = vyžadovať('../middleware/auth');
vyžadovať('../middleware/passport')(pas);Ďalej definujte logiku na správu funkcií registrácie a prihlásenia používateľa:
exports.registerUser = async (req, res) => {
konšt { meno používateľa, heslo, rola } = req.body;skúste {
čakať User.create({ meno používateľa, heslo, rola });
res.status(201.json({ správu: 'Používateľ sa úspešne zaregistroval' });
} chytiť (chyba) {
konzoly.log (chyba);
res.status(500.json({ správu: 'Nastala chyba!' });
}
};exports.loginUser = (req, res, next) => {
passport.authenticate('miestne', { relácie: falošný }, (chyba, používateľ, informácie) => {
ak (chyba) {
konzoly.log (chyba);vrátiť res.status(500.json({
správa: "Pri prihlasovaní sa vyskytla chyba"
});
}ak (!user) {
vrátiť res.status(401.json({
správa: 'Neplatné prihlasovacie údaje'
});
}req.login (používateľ, { relácie: falošný }, (chyba) => {
ak (chyba) {
konzoly.log (chyba);vrátiť res.status(500.json({
správa: "Pri prihlasovaní sa vyskytla chyba"
});
}
konšt { _id, meno používateľa, rola } = používateľ;
konšt užitočné zaťaženie = { ID používateľa: _id, meno používateľa, rola };
konšt token = generovaťToken (užitočné zaťaženie);
res.cookie('token', token, { http Only: pravda });
vrátiť res.status(200.json({ správu: 'Prihlásenie úspešné' });
});
})(req, res, next);
};
The zaregistrovaťPoužívateľa funkcia spracováva registráciu nového používateľa extrahovaním používateľského mena, hesla a roly z tela požiadavky. Potom vytvorí nový používateľský záznam v databáze a odpovie správou o úspechu alebo chybou, ak sa počas procesu vyskytne.
Na druhej strane, prihlásiťPoužívateľ Táto funkcia uľahčuje prihlásenie používateľa pomocou lokálnej autentifikačnej stratégie, ktorú poskytuje Passport.js. Overí prihlasovacie údaje používateľa a po úspešnom prihlásení vráti token, ktorý sa potom uloží do súboru cookie pre následné overené požiadavky. Ak sa počas procesu prihlasovania vyskytnú nejaké chyby, vráti príslušnú správu.
Nakoniec pridajte kód, ktorý implementuje logiku získavania údajov všetkých používateľov z databázy. Tento koncový bod použijeme ako obmedzenú cestu, aby sme zaistili, že iba autorizovaní používatelia s rolou admin môže pristupovať k tomuto koncovému bodu.
exports.getUsers = async (req, res) => {
skúste {
konšt užívatelia = čakať User.find({});
res.json (používatelia);
} chytiť (chyba) {
konzoly.log (chyba);
res.status(500.json({ správu: 'Nastala chyba!' });
}
};Nastavte stratégiu lokálneho overovania Passport.js
Ak chcete overiť používateľov po tom, ako poskytnú svoje prihlasovacie údaje, musíte nastaviť lokálnu stratégiu overovania.
Vytvorte nový middleware/passport.js súbor v koreňovom adresári a pridajte nasledujúci kód.
konšt LocalStrategy = vyžadovať('passport-local').Stratégia;
konšt Používateľ = vyžadovať('../models/user.model');modul.export = (pas) => {
passport.use(
Nový LocalStrategy(async (používateľské meno, heslo, hotovo) => {
skúste {
konšt užívateľ = čakať User.findOne({ meno používateľa });ak (!user) {
vrátiť hotový(nulový, falošný);
}ak (user.password !== heslo) {
vrátiť hotový(nulový, falošný);
}
vrátiť hotový(nulový, používateľ);
} chytiť (chyba) {
vrátiť hotovo (chyba);
}
})
);
};
Tento kód definuje lokálnu stratégiu passport.js na autentifikáciu používateľov na základe ich poskytnutého používateľského mena a hesla.
Najprv požiada databázu, aby našiel používateľa so zodpovedajúcim používateľským menom, a potom pristúpi k overeniu jeho hesla. Následne vráti overený užívateľský objekt, ak je proces prihlásenia úspešný.
Vytvorte verifikačný middleware JWT
Vnútri middleware adresár, vytvorte nový súbor auth.js a pridajte nasledujúci kód na definovanie middleware, ktorý generuje a overuje JWT.
konšt jwt = vyžadovať('jsonwebtoken');
konšt tajný kľúč = process.env. SECRET_KEY;konšt vygenerovať token = (užitočné zaťaženie) => {
konšt token = jwt.sign (úžitkové zaťaženie, tajný kľúč, { expiruje v: '1h' });
vrátiť žetón;
};konšt overiť token = (požadovaná Role) =>(req, res, next) => {
konšt token = req.cookies.token;ak (!token) {
vrátiť res.status(401.json({ správu: „Neposkytol sa žiadny token“ });
}jwt.verify (token, tajný kľúč, (chyba, dekódované) => {
ak (chyba) {
vrátiť res.status(401.json({ správu: 'Neplatný Token' });
}req.userId = decoded.userId;
ak (decoded.role !== requiredRole) {
vrátiť res.status(403.json({
správa: 'Nemáte oprávnenie a povolenia na prístup k tomuto zdroju.'
});
}Ďalšie();
});
};
modul.exports = { vygenerujToken, over token };
The generovať token funkcia vytvorí JWT so špecifikovaným časom expirácie, zatiaľ čo overiť token funkcia skontroluje, či je token prítomný a platný. Okrem toho tiež overuje, či dekódovaný token obsahuje požadovanú rolu, čím sa v podstate zaisťuje, že prístup majú iba používatelia s autorizovanou rolou a povoleniami.
Ak chcete jedinečne podpísať JWT, musíte vygenerovať jedinečný tajný kľúč a pridať ho do svojho .env súbor, ako je uvedené nižšie.
SECRET_KEY="Toto je vzorový tajný kľúč."Definujte trasy API
V koreňovom adresári vytvorte nový priečinok a pomenujte ho routes. V tomto priečinku vytvorte nový userRoutes.jsa pridajte nasledujúci kód.
konšt vyjadriť = vyžadovať('expresné');
konšt router = expres. Router();
konšt userControllers = vyžadovať('../controllers/userController');
konšt { overToken } = vyžadovať('../middleware/auth');router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);router.get('/api/users', overiť token('admin'), userControllers.getUsers);
modul.export = router;
Tento kód definuje HTTP trasy pre REST API. The používateľov servery ako chránenú cestu. Obmedzením prístupu pre používateľov s admin rolu, efektívne vynútite riadenie prístupu na základe roly.
Aktualizujte súbor hlavného servera
Otvor tvoj server.js súbor a aktualizujte ho takto:
konšt vyjadriť = vyžadovať('expresné');
konšt kors = vyžadovať('cors');
konšt cookieParser = vyžadovať('cookie-parser');
konšt app = express();
konšt prístav = 5000;
vyžadovať('dotenv').config();
konšt pripojiťDB = vyžadovať('./utils/db');
konšt pas = vyžadovať('pas');
vyžadovať('./middleware/passport')(pas);connectDB();
app.use (express.json());
app.use (express.urlencoded({ predĺžený: pravda }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konšt userRoutes = vyžadovať('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konzoly.log(`Server beží na porte ${port}`);
});
Nakoniec spustite vývojový server na spustenie aplikácie.
uzol server.jsVyužite mechanizmus RBAC na zlepšenie svojich autentifikačných systémov
Implementácia riadenia prístupu na základe rolí je efektívny spôsob, ako zvýšiť bezpečnosť vašich aplikácií.
Zatiaľ čo začlenenie existujúcich autentifikačných knižníc na vytvorenie efektívneho systému RBAC je skvelý prístup, využitie knižníc RBAC na explicitne definovať používateľské roly a prideľovať povolenia poskytuje ešte robustnejšie riešenie, ktoré v konečnom dôsledku zvyšuje celkovú bezpečnosť vášho aplikácie.
