Tudástár

A JWT (JSON Web Token) authentikáció alapjai Express.js-ben

iranyonline 0

Üdvözöllek, fejlesztőtársam! A modern webalkalmazások fejlesztésében az authentikáció kulcsfontosságú. Nem elég egy lenyűgöző felhasználói felületet vagy hatékony adatbázis-kezelést biztosítani; alapvető fontosságú garantálni, hogy csak a jogosult felhasználók férhessenek hozzá az érzékeny adatokhoz és funkciókhoz. Ebben a cikkben mélyrehatóan bemutatjuk a JWT (JSON Web Token) alapú authentikációt az Express.js keretrendszerben. Megvizsgáljuk, miért vált ilyen népszerűvé ez a módszer, hogyan épül fel, és lépésről lépésre megvalósítunk egy biztonságos authentikációs rendszert.

Mi az a JWT és miért van rá szükségünk?

A JSON Web Token egy kompakt, URL-biztos módszer arra, hogy információkat továbbítsunk a felek között, mint egy JSON objektumot. Ezeket az információkat digitálisan aláírják, ami garantálja az integritásukat és hitelességüket. A JWT-ket leggyakrabban authentikációra és autorizációra használják API-kban és webalkalmazásokban. A hagyományos, munkamenet (session) alapú authentikációval szemben, ahol a szervernek el kell tárolnia a felhasználói munkamenetek állapotát, a JWT egy stateless (állapotmentes) megközelítést kínál. Ez azt jelenti, hogy a szervernek nem kell emlékeznie a felhasználó állapotára minden kérésnél, ami jelentősen növeli a skálázhatóságot, különösen elosztott rendszerekben vagy mikro szolgáltatások környezetében.

A JWT felépítése: Fejléc, Tartalom és Aláírás

Egy JWT három részből áll, ponttal elválasztva:

  1. Fejléc (Header): Ez a JSON objektum írja le a token típusát (pl. JWT) és az aláíráshoz használt algoritmust (pl. HS256, RS256). Base64Url kódolás után ez lesz az első része a tokennek.
  2. Tartalom (Payload): Ez is egy JSON objektum, amely tartalmazza a tényleges adatokat vagy „claim”-eket. Ezek lehetnek regisztrált claim-ek (pl. `iss` – kibocsátó, `exp` – lejárati idő, `sub` – tárgy), publikus claim-ek (azok, amiket szabadon meghatározhatunk, de ütközés elkerülése végett célszerű URI-ként meghatározni), vagy privát claim-ek (szerver és kliens között megállapodott, egyedi adatok, pl. felhasználói azonosító). Ez is Base64Url kódolás után lesz a token második része.
  3. Aláírás (Signature): Ez biztosítja a token integritását. Létrehozásához a kódolt fejlécet, a kódolt tartalmat és egy titkos kulcsot (secret key) használunk fel az algoritmusnak megfelelően. Az aláírás ellenőrzi, hogy a token nem manipulált-e a kibocsátása óta. Ez a harmadik része a tokennek.

A három rész együttesen néz ki így: `xxxxx.yyyyy.zzzzz`.

Miért előnyös a JWT authentikáció?

  • Skálázhatóság: Mivel a szervernek nem kell tárolnia a munkamenetek állapotát, könnyebben skálázható a rendszer több szerverre.
  • Kliensoldali kompatibilitás: Kiválóan alkalmas webes és mobil alkalmazások authentikációjához egyaránt.
  • Állapotmentesség (Statelessness): Minden kérés tartalmazza a szükséges authentikációs adatokat.
  • Biztonság: Az aláírás megakadályozza az adatok módosítását, és a lejárati idő beállításával korlátozható a token érvényessége.

Express.js Projekt Beállítása JWT Authentikációhoz

Először is, hozzunk létre egy új Express.js projektet, és telepítsük a szükséges csomagokat.


mkdir jwt-auth-express
cd jwt-auth-express
npm init -y
npm install express jsonwebtoken dotenv bcryptjs
  • `express`: A webes keretrendszer.
  • `jsonwebtoken`: A JWT-k generálásához és ellenőrzéséhez.
  • `dotenv`: A környezeti változók kezeléséhez (pl. titkos kulcsok).
  • `bcryptjs`: Jelszavak biztonságos hasheléséhez (bár a cikk fő fókusza a JWT, a valós authentikációhoz elengedhetetlen a jelszóhashelés).

Hozzon létre egy `.env` fájlt a projekt gyökerében, és adjon hozzá egy titkos kulcsot. Ez létfontosságú az aláírás generálásához és ellenőrzéséhez. Soha ne tegye ki ezt a kulcsot nyilvánosan!


TOKEN_SECRET=valamilyenhosszusagutimtitkoskulcsotgeneraltatoka

Egy biztonságos titkos kulcs generálásához használhatja például a Node.js `crypto` modulját:


require('crypto').randomBytes(64).toString('hex');
// Példa kimenet: 'd0e7a2b5c6f1a8e9d0c7b6a5e4f3a2b1c0d9e8f7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b1c0d9'

Hozzuk létre az `app.js` fájlt:


// app.js
require('dotenv').config(); // Betöltjük a .env fájlt
const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');

const app = express();
const port = 3000;

app.use(express.json()); // Engedélyezi a JSON body-k parse-olását

// Egyszerű "adatbázis" a felhasználók tárolására (éles alkalmazásban MongoDB, PostgreSQL stb.)
const users = []; 

app.listen(port, () => {
    console.log(`Server is running on port ${port}`);
});

JWT Authentikáció Implementálása Express.js-ben

1. Felhasználó Regisztráció

Először is, szükségünk van egy útvonalra, ahol a felhasználók regisztrálhatnak. Itt hasheljük a jelszót, mielőtt eltárolnánk azt.


// app.js folytatása

// Regisztráció
app.post('/register', async (req, res) => {
    try {
        const { username, password } = req.body;
        if (!username || !password) {
            return res.status(400).send('Felhasználónév és jelszó kötelező.');
        }

        // Ellenőrizzük, létezik-e már a felhasználó
        if (users.find(u => u.username === username)) {
            return res.status(409).send('Ez a felhasználónév már foglalt.');
        }

        const hashedPassword = await bcrypt.hash(password, 10); // Jelszó hashelése
        const newUser = { id: users.length + 1, username, password: hashedPassword };
        users.push(newUser);
        res.status(201).send('Sikeres regisztráció!');
    } catch (error) {
        res.status(500).send('Hiba történt a regisztráció során.');
    }
});

2. Bejelentkezés és Token Generálás

A bejelentkezési útvonalon ellenőrizzük a felhasználó hitelesítő adatait. Ha sikeres, generálunk egy JWT token-t és visszaküldjük a kliensnek.


// app.js folytatása

// Bejelentkezés
app.post('/login', async (req, res) => {
    try {
        const { username, password } = req.body;
        if (!username || !password) {
            return res.status(400).send('Felhasználónév és jelszó kötelező.');
        }

        const user = users.find(u => u.username === username);
        if (!user) {
            return res.status(400).send('Hibás felhasználónév vagy jelszó.');
        }

        const isPasswordValid = await bcrypt.compare(password, user.password);
        if (!isPasswordValid) {
            return res.status(400).send('Hibás felhasználónév vagy jelszó.');
        }

        // JWT token generálása
        // A payload-ba tegyünk olyan adatokat, amik a felhasználót azonosítják
        // és nem szenzitívek (pl. id, szerepkör)
        const token = jwt.sign(
            { id: user.id, username: user.username },
            process.env.TOKEN_SECRET,
            { expiresIn: '1h' } // A token lejárati ideje: 1 óra
        );

        res.json({ token });
    } catch (error) {
        res.status(500).send('Hiba történt a bejelentkezés során.');
    }
});

A `jwt.sign()` függvény három argumentumot vár:

  • Az első a payload objektum, ami tetszőleges adatokat tartalmazhat (pl. felhasználó azonosító, szerepkörök).
  • A második a titkos kulcs, amellyel az aláírás generálódik. Ezt a kulcsot szigorúan titokban kell tartani.
  • A harmadik egy opcionális objektum, ahol beállíthatunk például lejárati időt (`expiresIn`). Erősen ajánlott rövid lejárati időt használni a token-ek esetében a biztonság növelése érdekében.

3. Védett Útvonalak Létrehozása Authentikációs Middleware-rel

Miután a felhasználó bejelentkezett és megkapta a tokent, minden további kérését a védett erőforrások felé ezzel a tokennel kell hitelesítenie. Ehhez létrehozunk egy middleware függvényt, amely ellenőrzi a token érvényességét minden védett útvonal előtt.


// app.js folytatása

// Authentikációs middleware
function authenticateToken(req, res, next) {
    const authHeader = req.headers['authorization'];
    // A token a "Bearer TOKEN_STRING" formátumban érkezik az Authorization fejlécben
    const token = authHeader && authHeader.split(' ')[1];

    if (token == null) return res.sendStatus(401); // Nincs token

    jwt.verify(token, process.env.TOKEN_SECRET, (err, user) => {
        if (err) {
            console.error('Token verification error:', err);
            return res.sendStatus(403); // Érvénytelen token (pl. lejárt, manipulált)
        }
        req.user = user; // A felhasználó adatait eltároljuk a request objektumban
        next(); // Továbbengedjük a kérést a következő middleware-re vagy útvonalra
    });
}

// Védett útvonal
app.get('/protected', authenticateToken, (req, res) => {
    res.json({ message: `Üdvözöllek, ${req.user.username}! Ez egy védett erőforrás.`, user: req.user });
});

A kliensnek a generált tokent a `Authorization` HTTP fejlécben kell elküldenie, `Bearer` előtaggal:


Authorization: Bearer <a_generált_token_ide>

Refresh Token-ek (Frissítő Tokenek) – A Fokozott Biztonságért

Mivel az access tokenek érvényességi ideje rövid (pl. 15 perc – 1 óra), a felhasználóknak gyakran újra be kellene jelentkezniük. Ennek elkerülésére vezették be a refresh token-eket. A frissítő tokenek hosszabb élettartammal rendelkeznek (pl. hetek, hónapok), és kizárólag arra szolgálnak, hogy új access tokent igényeljenek, amikor a régi lejár. Fontos, hogy a refresh token-eket biztonságosan tároljuk (adatbázisban), és csak egyszer használjuk fel (vagy figyeljük a felhasználást).

Működése röviden:

  1. A felhasználó bejelentkezik, és kap egy access tokent (rövid élettartamú) és egy refresh tokent (hosszabb élettartamú).
  2. Az access tokent használja az API kérésekhez.
  3. Amikor az access token lejár, a kliens elküldi a refresh tokent egy speciális `refresh-token` végpontra.
  4. A szerver ellenőrzi a refresh tokent az adatbázisban (azonosítja a felhasználót).
  5. Ha érvényes, generál egy új access tokent (és opcionálisan egy új refresh tokent), majd visszaküldi a kliensnek.
  6. Fontos: A refresh tokeneket is le lehet járathatni (pl. kijelentkezéskor).

// app.js folytatása - Refresh token példa

// Szükség van egy helyre a refresh tokenek tárolására
const refreshTokens = []; 

app.post('/token', (req, res) => {
    const refreshToken = req.body.token;
    if (refreshToken == null) return res.sendStatus(401);
    if (!refreshTokens.includes(refreshToken)) return res.sendStatus(403);

    jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET, (err, user) => {
        if (err) return res.sendStatus(403);
        
        // Generálunk egy új access tokent
        const accessToken = jwt.sign(
            { id: user.id, username: user.username },
            process.env.TOKEN_SECRET,
            { expiresIn: '1h' }
        );
        res.json({ accessToken: accessToken });
    });
});

app.delete('/logout', (req, res) => {
    // Távolítsuk el a refresh tokent a tárolóból
    const refreshToken = req.body.token;
    const index = refreshTokens.indexOf(refreshToken);
    if (index > -1) {
        refreshTokens.splice(index, 1);
    }
    res.sendStatus(204); // Nincs tartalom
});

// A login endpointet módosítani kell, hogy generáljon refresh tokent is
// A refresh token generálásához ÉRDEMES KÜLÖN TITKOS KULCSOT HASZNÁLNI!
// .env fájlban: REFRESH_TOKEN_SECRET=valamilyenhosszusagutitkosrefreshkulcs
app.post('/login', async (req, res) => {
    // ... (felhasználó ellenőrzése, mint fent) ...

    const accessToken = jwt.sign(
        { id: user.id, username: user.username },
        process.env.TOKEN_SECRET,
        { expiresIn: '1h' }
    );
    const refreshToken = jwt.sign(
        { id: user.id, username: user.username },
        process.env.REFRESH_TOKEN_SECRET,
        { expiresIn: '7d' } // Refresh token lejárati ideje: 7 nap
    );

    refreshTokens.push(refreshToken); // Tároljuk a refresh tokent
    res.json({ accessToken, refreshToken });
});

Ne felejtsen el egy `REFRESH_TOKEN_SECRET` változót is hozzáadni a `.env` fájlhoz, ha refresh tokeneket használ!

Biztonsági Megfontolások és Best Practice-ek

Bár a JWT rendkívül hatékony, fontos betartani bizonyos biztonsági elveket:

  • Titkos kulcs kezelése: A secret key-t rendkívül biztonságosan kell tárolni (környezeti változók, kulcstárolók). Soha ne hardkódolja be az alkalmazásba, és rendszeresen rotálja (cserélje le).
  • Lejárati idő: Mindig állítson be lejárati időt az access tokeneknek (rövid, pl. 15-60 perc). A refresh tokeneknek lehet hosszabb élettartama.
  • HTTPS használata: Mindig használjon SSL/TLS titkosítást (HTTPS), hogy megakadályozza a tokenek lehallgatását az átvitel során.
  • Ne tároljon érzékeny adatot a payloadban: A JWT payload Base64Url kódolású, nem titkosított! Bárki dekódolhatja. Csak olyan adatokat tegyen bele, amik nem jelentenek kockázatot nyilvánosságra hozatal esetén (pl. felhasználó ID, szerepkör).
  • Tárolás a kliensoldalon:
    • localStorage / sessionStorage: Könnyen hozzáférhető, de sebezhető XSS (Cross-Site Scripting) támadásokkal szemben.
    • httpOnly cookies: Ellenállóbb az XSS támadásokkal szemben, de sebezhető CSRF (Cross-Site Request Forgery) támadásokkal szemben. Használjon CSRF védelmi mechanizmusokat (pl. `csrf-token`-ek) ha `httpOnly` cookie-kat használ.
    • A legjobb gyakorlat általában az, ha az access tokent `localStorage`-ben vagy memóriában (SPA-k esetén) tárolja, míg a refresh tokent `httpOnly` és `secure` (HTTPS esetén) beállításokkal ellátott cookie-ban.
  • Rate Limiting: Alkalmazzon kérésekre vonatkozó korlátozást (rate limiting) a bejelentkezési és tokenfrissítési végpontokon, hogy megakadályozza a brute-force támadásokat.
  • Token visszavonása: Bár a JWT-k alapvetően állapotmentesek, ha egy felhasználó kijelentkezik vagy megváltoztatja a jelszavát, érdemes valamilyen módon visszavonni az aktív tokenjeit (pl. feketelista vagy a refresh token eltávolítása).

Összefoglalás

A JWT alapú authentikáció modern és hatékony megoldást kínál az Express.js alkalmazások számára. Az állapotmentes jellege miatt kiválóan skálázható, és jól illeszkedik a mikro szolgáltatás alapú architektúrákhoz. Ebben a cikkben bemutattuk a JWT felépítését, a token generálásának és ellenőrzésének lépéseit, valamint a védett útvonalak létrehozását middleware segítségével. Kitérünk a refresh tokenek fontosságára is, amelyek jelentősen javítják a felhasználói élményt és a biztonságot.

Mint minden technológia, a JWT is megköveteli a gondos és körültekintő implementációt. A fent említett biztonsági gyakorlatok betartása elengedhetetlen a robusztus és biztonságos rendszer felépítéséhez. Reméljük, ez a részletes útmutató segít Önnek abban, hogy magabiztosan implementálja a JWT authentikációt következő Express.js projektjében!

Kapcsolódó

Leave a Reply

Az e-mail címet nem tesszük közzé. A kötelező mezőket * karakterrel jelöltük