Odesílání dat z jednoho místa na druhé? Pro váš klid a ochranu vašich uživatelů byste to měli zabezpečit pomocí JWT.

Při vytváření aplikace je důležité chránit citlivá data před neoprávněným přístupem. Mnoho moderních webových, mobilních a cloudových aplikací používá REST API jako primární prostředek komunikace. V důsledku toho je klíčové navrhovat a vyvíjet backendová API s bezpečností v popředí.

Jeden účinný přístup k zabezpečení REST API zahrnuje webové tokeny JSON (JWT). Tyto tokeny nabízejí robustní mechanismus pro autentizaci a autorizaci uživatelů a pomáhají chránit chráněné zdroje před přístupem zlomyslných aktérů.

Co jsou webové tokeny JSON?

Webový token JSON (JWT) je široce používaný bezpečnostní standard. Poskytuje stručnou a samostatnou metodu bezpečného přenosu dat mezi klientskou aplikací a backendovým systémem.

REST API může používat JWT k bezpečné identifikaci a autentizaci uživatelů, když zadávají HTTP požadavky na přístup k chráněným zdrojům.

Webový token JSON se skládá ze tří odlišných částí: záhlaví, datové části a podpisu. Zakóduje každou část a zřetězí je pomocí tečky (".").

instagram viewer

Záhlaví popisuje kryptografický algoritmus použitý k podepsání tokenu, zatímco užitečné zatížení obsahuje data o uživateli a jakákoli další metadata.

A konečně podpis, vypočítaný pomocí hlavičky, užitečného zatížení a tajného klíče, zajišťuje integritu a autenticitu tokenu.

Se základy JWT z cesty, pojďme vytvořit Node.js REST API a implementovat JWT.

Nastavte aplikaci Express.js a databázi MongoDB

Zde se dozvíte, jak vytvořit jednoduchou autentizaci REST API který se stará o funkci registrace i přihlášení. Jakmile proces přihlášení ověří uživatele, měl by být schopen odesílat požadavky HTTP na chráněnou trasu API.

Zde najdete kód projektu úložiště GitHub.

Začít, vytvořit expresní webový servera nainstalujte tyto balíčky:

npm install cors dotenv bycrpt mongoose cookie-parser crypto jsonwebtoken mongodb

Další, vytvořit databázi MongoDB nebo nakonfigurovat cluster MongoDB v cloudu. Poté zkopírujte řetězec připojení k databázi, vytvořte a .env soubor v kořenovém adresáři a vložte připojovací řetězec:

CONNECTION_STRING="připojovací řetězec"

Nakonfigurujte připojení k databázi

Vytvoř nový utils/db.js soubor v kořenovém adresáři složky vašeho projektu. V tomto souboru přidejte následující kód k navázání připojení k databázi pomocí Mongoose.

konst mangusta = vyžadovat('mangusta');
konst connectDB = asynchronní () => {
Snaž se {
čekat mongoose.connect (process.env. CONNECTION_STRING);
ří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

Definujte jednoduché schéma uživatelských dat pomocí Mongoose. V kořenovém adresáři vytvořte nový model/user.model.js soubor a přidejte následující kód.

konst mangusta = vyžadovat('mangusta');
konst userSchema = Nový mangusta. Schéma({
 uživatelské jméno: Tětiva,
 Heslo: {
 typ: Tětiva,
 Požadované: skutečný,
 unikátní: skutečný,
 },
});
konst Uživatel = mongoose.model("Uživatel", userSchema);
modul.exports = Uživatel;

Definujte řadiče pro trasy API

Funkce ovladače budou spravovat registraci a přihlášení; jsou podstatnou součástí tohoto vzorového programu. V kořenovém adresáři vytvořte a controllers/userControllers.js soubor a přidejte následující kód:

  1. Definujte řadič registrace uživatele.
    konst Uživatel = vyžadovat('../models/user.model');
    konst bcrypt = vyžadovat('bcrypt');
    konst { vygenerovat token } = vyžadovat('../middleware/auth');
    exports.registerUser = asynchronní (req, res) => {
    konst { uživatelské jméno, heslo } = req.body;
    Snaž se {
    konst hash = čekat bcrypt.hash (heslo, 10); 
    čekat User.create({ uživatelské jméno, Heslo: hash });
     res.status(201).poslat({ zpráva: 'Uživatel byl úspěšně zaregistrován' });
     } chytit (chyba) {
    řídicí panel.log (chyba);
     res.status(500).poslat({ zpráva: 'Vyskytla se chyba!! ' });
     }
    };
    Tento úryvek kódu zahašuje poskytnuté heslo pomocí bcrypt a poté vytvoří nový uživatelský záznam v databázi a uloží uživatelské jméno a hashované heslo. Pokud je registrace úspěšná, odešle odpověď se zprávou o úspěchu.
  2. Definujte řadič přihlášení pro správu procesu přihlášení uživatele:
    exports.loginUser = asynchronní (req, res) => {
    konst { uživatelské jméno, heslo } = req.body;
    Snaž se {
    konst uživatel = čekat User.findOne({ uživatelské jméno });

    -li (!user) {
    vrátit se res.status(404).poslat({ zpráva: 'Uživatel nenalezen' });
     }
    

    konst passwordMatch = čekat bcrypt.compare (heslo, user.password);
    

    -li (!passwordMatch) {
    vrátit se res.status(401).poslat({ zpráva: 'Neplatné přihlašovací údaje' });
     }
    konst užitečné zatížení = { uživatelské ID: uživatelské ID };
    konst token = generovatToken (užitné zatížení);
     res.cookie('žeton', token, { httpOnly: skutečný });
     res.status(200.json({ zpráva: 'Přihlášení úspěšné'});
     } chytit (chyba) {
    řídicí panel.log (chyba);
     res.status(500).poslat({ zpráva: "Při přihlašování došlo k chybě" });
     }
    };
    Když uživatel odešle požadavek na /login cestou, měli by předat své ověřovací údaje v těle požadavku. Kód pak tyto přihlašovací údaje ověří a vygeneruje webový token JSON. Token je bezpečně uložen v cookie s httpOnly příznak nastaven na true. To zabraňuje JavaScriptu na straně klienta v přístupu k tokenu a chrání před potenciálními útoky cross-site scripting (XSS).
  3. Nakonec definujte chráněnou trasu:
    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).poslat({ zpráva: 'Vyskytla se chyba!!' });
     }
    };
    Uložením JWT do cookie budou následné požadavky API od ověřeného uživatele automaticky zahrnovat token, což serveru umožní ověřit a autorizovat požadavky.

Vytvořte ověřovací middleware

Nyní, když jste definovali řadič přihlášení, který po úspěšné autentizaci generuje token JWT, definujte autentizační funkce middlewaru, které vygenerují a ověří token JWT.

V kořenovém adresáři vytvořte novou složku, middleware. Do této složky přidejte dva soubory: auth.js a config.js.

Přidejte tento kód do config.js:

konst krypto = vyžadovat('crypto');
modul.exports = {
 tajný klíč: crypto.randomBytes(32).toString("hexadecimální")
};

Tento kód generuje nový náhodný tajný klíč při každém spuštění. Tento tajný klíč pak můžete použít k podepsání a ověření pravosti JWT. Jakmile je uživatel úspěšně ověřen, vygenerujte a podepište JWT pomocí tajného klíče. Server pak použije klíč k ověření platnosti JWT.

Přidejte následující kód auth.js který definuje middlewarové funkce, které generují a ověřují JWT.

konst jwt = vyžadovat('jsonwebtoken');
konst { secretKey } = vyžadovat('./config');
konst generovatToken = (užitečné zatížení) => {
konst token = jwt.sign (payload, secretKey, { vyprší v: '1h' });
vrátit se token ;
};


konst ověřitToken = (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;
 další();
 }); 
};
modul.exports = { vygenerovatToken, ověřitToken };

The generovat token funkce generuje JWT podepsáním užitečného zatížení pomocí tajného klíče a nastavením doby vypršení platnosti ověřit token funkce slouží jako middleware k ověření pravosti a platnosti poskytnutého tokenu.

Definujte trasy API

Vytvoř nový routes/userRoutes.js soubor v kořenovém adresáři a 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/userControllers');
konst { ověřitToken } = vyžadovat('../middleware/auth');
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);
router.get('/api/users', ověřitToken, userControllers.getUsers);
modul.exports = router;

Aktualizujte svůj vstupní bod serveru

Aktualizujte svůj server.js soubor s následujícím kódem.

konst vyjádřit = vyžadovat('vyjádřit');
konst kors = vyžadovat('cors');
konst app = express();
konst přístav = 5000;
vyžadovat('dotenv').config();
konst connectDB = vyžadovat('./utils/db');
konst cookieParser = vyžadovat('cookie-parser');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ prodloužený: skutečný }));
app.use (cors());
app.use (cookieParser());
konst userRoutes = vyžadovat('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
řídicí panel.log(`Server poslouchá na http://localhost:${port}`);
});

Chcete-li otestovat REST API, roztočte vývojový server a odešlete požadavky API na definované koncové body:

uzel server.js

Zabezpečení Node.js REST API

Zabezpečení Node.js REST API přesahuje pouhé použití JWT, ačkoli hrají klíčovou roli při ověřování a autorizace, je nezbytné přijmout holistický bezpečnostní přístup k zabezpečení, aby byl váš backend chráněn systémy. Kromě JWT byste měli také zvážit implementaci HTTPS pro šifrování komunikace, ověřování vstupu a dezinfekci a mnoho dalších.

Kombinací více bezpečnostních opatření můžete vytvořit robustní bezpečnostní rámec Node.js REST API a minimalizuje riziko neoprávněného přístupu, narušení dat a další zabezpečení hrozby.