Zjistěte, jak tyto technologie spojit s praktickou ukázkou.
Řízení přístupu na základě rolí je bezpečný mechanismus ověřování. Můžete jej použít k omezení přístupu ke konkrétním zdrojům uživatelům, kteří mají určité role.
Tento typ ověřování pomáhá správcům systému řídit oprávnění podle určených rolí uživatelů. Tato úroveň podrobné kontroly přidává vrstvu zabezpečení, která aplikacím umožňuje zabránit neoprávněnému přístupu.
Implementace mechanismu řízení přístupu založeného na rolích pomocí Passport.js a JWT
Řízení přístupu založené na rolích (RBAC) je oblíbený mechanismus používaný k vynucení omezení přístupu v aplikacích na základě uživatelských rolí a oprávnění. K implementaci mechanismu RBAC jsou k dispozici různé metody.
Dva populární přístupy zahrnují použití vyhrazených knihoven RBAC, jako je AcessControl nebo využití existujících autentizačních knihoven k implementaci mechanismu.
V tomto případě JSON Web Tokeny (JWT) poskytují bezpečný způsob přenosu autentizačních pověření, zatímco Passport.js zjednodušuje proces ověřování tím, že poskytuje flexibilní ověřování middleware.
Pomocí tohoto přístupu můžete uživatelům přiřadit role a zakódovat je do JWT, když se ověřují. JWT pak můžete použít k ověření identity uživatele a rolí v následných požadavcích, což umožňuje autorizaci a řízení přístupu na základě rolí.
Oba přístupy mají své výhody a mohou být účinné při implementaci RBAC. Výběr mezi metodou implementace bude záviset na konkrétních požadavcích vašeho projektu.
Kód tohoto projektu si můžete stáhnout z jeho úložiště GitHub.
Nastavte projekt Express.js
Začít, lokálně nastavit projekt Express.js. Jakmile projekt nastavíte, pokračujte a nainstalujte tyto balíčky:
npm install cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
pas pas-místníDalší, vytvořit databázi MongoDB nebo nastavit cluster na MongoDB Atlas. Zkopírujte URI připojení k databázi a přidejte jej do a .env soubor v kořenovém adresáři vašeho projektu:
CONNECTION_URI="URI připojení"Nakonfigurujte připojení k databázi
V kořenovém adresáři vytvořte nový utils/db.js a přidejte níže uvedený kód pro navázání připojení ke clusteru MongoDB běžícímu na Atlasu pomocí Mongoose.
konst mangusta = vyžadovat('mangusta');konst connectDB = asynchronní () => {
Snaž se {
čekat mongoose.connect (process.env. CONNECTION_URI);
řídicí panel.log("Připojeno k MongoDB!");
} chytit (chyba) {
řídicí panel.chyba("Chyba při připojování k MongoDB:", chyba);
}
};
modul.export = connectDB;
Definujte datový model
V kořenovém adresáři vytvořte nový model/user.model.js a přidejte následující kód k definování datového modelu pro data uživatelů pomocí Mongoose.
konst mangusta = vyžadovat('mangusta');konst userSchema = Nový mangusta. Schéma({
uživatelské jméno: Tětiva,
Heslo: Tětiva,
role: Tětiva
});
modul.exports = mongoose.model('Uživatel', userSchema);
Vytvořte řadič pro koncové body API
Vytvoř nový controllers/user.controller.js soubor v kořenovém adresáři a přidejte kód níže.
Nejprve proveďte tyto importy:
konst Uživatel = vyžadovat('../models/user.model');
konst pas = vyžadovat('cestovní pas');
konst { vygenerovat token } = vyžadovat('../middleware/auth');
vyžadovat('../middleware/passport')(cestovní pas);Dále definujte logiku pro správu funkcí registrace a přihlašování uživatelů:
exports.registerUser = asynchronní (req, res) => {
konst { uživatelské jméno, heslo, role } = req.body;Snaž se {
čekat User.create({ uživatelské jméno, heslo, role });
res.status(201.json({ zpráva: 'Uživatel byl úspěšně zaregistrován' });
} chytit (chyba) {
řídicí panel.log (chyba);
res.status(500.json({ zpráva: 'Vyskytla se chyba!' });
}
};exports.loginUser = (požadavek, res, další) => {
passport.authenticate('místní', { zasedání: Nepravdivé }, (chyba, uživatel, informace) => {
-li (chyba) {
řídicí panel.log (chyba);vrátit se res.status(500.json({
zpráva: "Při přihlašování došlo k chybě"
});
}-li (!user) {
vrátit se res.status(401.json({
zpráva: 'Neplatné přihlašovací údaje'
});
}req.login (uživatel, { zasedání: Nepravdivé }, (chyba) => {
-li (chyba) {
řídicí panel.log (chyba);vrátit se res.status(500.json({
zpráva: "Při přihlašování došlo k chybě"
});
}
konst { _id, uživatelské jméno, role } = uživatel;
konst užitečné zatížení = { uživatelské ID: _id, uživatelské jméno, role };
konst token = generovatToken (užitné zatížení);
res.cookie('žeton', token, { httpOnly: skutečný });
vrátit se res.status(200.json({ zpráva: 'Přihlášení úspěšné' });
});
})(požadavek, res, další);
};
The zaregistrovat uživatele funkce zpracovává registraci nového uživatele extrahováním uživatelského jména, hesla a role z těla požadavku. Poté vytvoří nový uživatelský záznam v databázi a odpoví zprávou o úspěchu nebo chybou, pokud se během procesu objeví.
Na druhou stranu, přihlášeníUživatel Tato funkce usnadňuje přihlášení uživatele využitím místní autentizační strategie poskytované Passport.js. Ověřuje přihlašovací údaje uživatele a po úspěšném přihlášení vrátí token, který je pak uložen v cookie pro následné ověřené požadavky. Pokud se během procesu přihlašování vyskytnou nějaké chyby, vrátí příslušnou zprávu.
Nakonec přidejte kód, který implementuje logiku načítání dat všech uživatelů z databáze. Tento koncový bod použijeme jako omezenou cestu, abychom zajistili, že pouze oprávnění uživatelé s rolí admin může přistupovat k tomuto koncovému bodu.
exports.getUsers = asynchronní (req, res) => {
Snaž se {
konst uživatelé = čekat User.find({});
res.json (uživatelé);
} chytit (chyba) {
řídicí panel.log (chyba);
res.status(500.json({ zpráva: 'Vyskytla se chyba!' });
}
};Nastavte strategii místního ověřování Passport.js
Chcete-li ověřovat uživatele poté, co poskytnou své přihlašovací údaje, musíte nastavit strategii místního ověřování.
Vytvoř nový middleware/passport.js soubor v kořenovém adresáři a přidejte následující kód.
konst LocalStrategy = vyžadovat(„místní pas“).Strategie;
konst Uživatel = vyžadovat('../models/user.model');modul.export = (cestovní pas) => {
passport.use(
Nový LocalStrategy(asynchronní (uživatelské jméno, heslo, hotovo) => {
Snaž se {
konst uživatel = čekat User.findOne({ uživatelské jméno });-li (!user) {
vrátit se Hotovo(nula, Nepravdivé);
}-li (user.password !== heslo) {
vrátit se Hotovo(nula, Nepravdivé);
}
vrátit se Hotovo(nula, uživatel);
} chytit (chyba) {
vrátit se hotovo (chyba);
}
})
);
};
Tento kód definuje místní strategii passport.js pro ověřování uživatelů na základě jejich poskytnutého uživatelského jména a hesla.
Nejprve se dotáže databáze, aby našel uživatele s odpovídajícím uživatelským jménem, a poté přistoupí k ověření jeho hesla. Následně vrátí objekt ověřeného uživatele, pokud je proces přihlášení úspěšný.
Vytvořte ověřovací middleware JWT
Uvnitř middleware adresář, vytvořte nový soubor auth.js a přidejte následující kód pro definování middlewaru, který generuje a ověřuje JWT.
konst jwt = vyžadovat('jsonwebtoken');
konst tajný klíč = process.env. TAJNÝ KLÍČ;konst generovatToken = (užitečné zatížení) => {
konst token = jwt.sign (payload, secretKey, { vyprší v: '1h' });
vrátit se žeton;
};konst ověřitToken = (požadovanáRole) =>(požadavek, res, další) => {
konst token = req.cookies.token;-li (!token) {
vrátit se res.status(401.json({ zpráva: 'Žádný token není poskytnut' });
}jwt.verify (token, tajný klíč, (chyba, dekódováno) => {
-li (chyba) {
vrátit se res.status(401.json({ zpráva: 'Neplatný token' });
}req.userId = decoded.userId;
-li (decoded.role !== requiredRole) {
vrátit se res.status(403.json({
zpráva: 'Nemáte oprávnění a oprávnění pro přístup k tomuto zdroji.'
});
}další();
});
};
modul.exports = { vygenerovatToken, ověřitToken };
The generovat token funkce vytvoří JWT se zadanou dobou expirace, zatímco ověřit token funkce zkontroluje, zda je token přítomen a platný. Kromě toho také ověřuje, že dekódovaný token obsahuje požadovanou roli, což v podstatě zajišťuje, že přístup mají pouze uživatelé s autorizovanou rolí a oprávněními.
Chcete-li jedinečně podepsat JWT, musíte vygenerovat jedinečný tajný klíč a přidat jej do svého .env soubor, jak je uvedeno níže.
SECRET_KEY="Toto je ukázkový tajný klíč."Definujte trasy API
V kořenovém adresáři vytvořte novou složku a pojmenujte ji routes. V této složce vytvořte nový userRoutes.jsa přidejte následující kód.
konst vyjádřit = vyžadovat('vyjádřit');
konst router = expres. Router();
konst userControllers = vyžadovat('../controllers/userController');
konst { ověřitToken } = vyžadovat('../middleware/auth');router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);router.get('/api/users', ověřit token('admin'), userControllers.getUsers);
modul.exports = router;
Tento kód definuje HTTP trasy pro REST API. The uživatelů specificky, servery jako chráněnou trasu. Omezením přístupu pro uživatele s admin role, efektivně vynucujete řízení přístupu na základě rolí.
Aktualizujte soubor hlavního serveru
Otevři tvůj server.js soubor a aktualizujte jej následovně:
konst vyjádřit = vyžadovat('vyjádřit');
konst kors = vyžadovat('cors');
konst cookieParser = vyžadovat('cookie-parser');
konst app = express();
konst přístav = 5000;
vyžadovat('dotenv').config();
konst connectDB = vyžadovat('./utils/db');
konst pas = vyžadovat('cestovní pas');
vyžadovat('./middleware/passport')(cestovní pas);connectDB();
app.use (express.json());
app.use (express.urlencoded({ prodloužený: skutečný }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());konst userRoutes = vyžadovat('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
řídicí panel.log(`Server běží na portu ${port}`);
});
Nakonec spusťte vývojový server pro spuštění aplikace.
uzel server.jsVyužijte mechanismus RBAC ke zvýšení úrovně svých autentizačních systémů
Implementace řízení přístupu na základě rolí je efektivním způsobem, jak zvýšit zabezpečení vašich aplikací.
I když začlenění existujících autentizačních knihoven k vytvoření efektivního systému RBAC je skvělý přístup, využití knihoven RBAC k explicitně definovat uživatelské role a přidělovat oprávnění poskytuje ještě robustnější řešení, které v konečném důsledku zvyšuje celkovou bezpečnost vašeho aplikace.
