Adatokat küld egyik helyről a másikra? Saját nyugalma és felhasználói védelme érdekében a JWT-vel kell biztosítania.

Amikor egy alkalmazást készít, létfontosságú, hogy megvédje az érzékeny adatokat az illetéktelen hozzáféréstől. Számos modern webes, mobil- és felhőalkalmazás használja a REST API-kat elsődleges kommunikációs eszközként. Ennek eredményeként kulcsfontosságú a háttér API-k tervezése és fejlesztése a biztonsággal az élen.

A REST API biztosításának egyik hatékony módja a JSON Web Tokens (JWT). Ezek a tokenek robusztus mechanizmust kínálnak a felhasználói hitelesítéshez és engedélyezéshez, és segítenek megvédeni a védett erőforrásokat a rosszindulatú szereplők hozzáférésétől.

Mik azok a JSON webes tokenek?

JSON webes token (JWT) egy széles körben használt biztonsági szabvány. Tömör, önálló módszert biztosít az adatok biztonságos továbbítására az ügyfélalkalmazás és a háttérrendszer között.

A REST API a JWT-ket használhatja a felhasználók biztonságos azonosítására és hitelesítésére, amikor HTTP-kérelmeket küldenek a védett erőforrásokhoz.

instagram viewer

A JSON webes token három különálló részből áll: a fejlécből, a hasznos terhelésből és az aláírásból. Minden egyes részt kódol, és ponttal (".") összefűzi őket.

A fejléc a token aláírásához használt kriptográfiai algoritmust írja le, míg a hasznos adat a felhasználó adatait és az esetleges további metaadatokat tartalmazza.

Végül a fejléc, a hasznos adat és a titkos kulcs felhasználásával kiszámított aláírás biztosítja a token integritását és hitelességét.

A JWT-k alapjainak kihagyásával építsünk egy Node.js REST API-t, és valósítsuk meg a JWT-ket.

Állítson be egy Express.js alkalmazást és MongoDB adatbázist

Itt megtudhatja, hogyan kell felépíteni egy egyszerű hitelesítést REST API amely mind a regisztrációs, mind a bejelentkezési funkciókat kezeli. Miután a bejelentkezési folyamat hitelesíti a felhasználót, képesnek kell lennie arra, hogy HTTP-kéréseket küldjön egy védett API-útvonalon.

Ebben megtalálod a projekt kódját GitHub adattár.

A kezdéshez hozzon létre egy Express webszervert, és telepítse ezeket a csomagokat:

npm install cors dotenv bycrpt mongoose cookie-elemző crypto jsonwebtoken mongodb

Következő, Hozzon létre egy MongoDB adatbázist vagy konfiguráljon egy MongoDB-fürtöt a felhőben. Ezután másolja ki az adatbázis-kapcsolati karakterláncot, hozzon létre a .env fájlt a gyökérkönyvtárba, és illessze be a kapcsolati karakterláncba:

CONNECTION_STRING="kapcsolati karakterlánc"

Állítsa be az adatbázis-kapcsolatot

Újat csinálni utils/db.js fájlt a projektmappa gyökérkönyvtárában. Ebben a fájlban adja hozzá a következő kódot az adatbázis-kapcsolat létrehozásához a Mongoose használatával.

const mangúz = igényelnek('indiai menyét');
const connectDB = async () => {
próbáld ki {
várja mongoose.connect (process.env. CONNECTION_STRING);
konzol.log("Csatlakoztatva a MongoDB-hez!");
 } fogás (hiba) {
konzol.hiba("Hiba a MongoDB-hez való csatlakozáskor:", hiba);
 }
};
modult.exports = connectDB;

Határozza meg az adatmodellt

Határozzon meg egy egyszerű felhasználói adatsémát a Mongoose segítségével. A gyökérkönyvtárban hozzon létre egy újat model/user.model.js fájlt, és adja hozzá a következő kódot.

const mangúz = igényelnek('indiai menyét');
const userSchema = új indiai menyét. Séma({
 felhasználónév: Húr,
 Jelszó: {
 típus: Húr,
 kívánt: igaz,
 egyedi: igaz,
 },
});
const User = mongoose.model("Felhasználó", userSchema);
modult.exports = Felhasználó;

Határozza meg az API-útvonalak vezérlőit

A vezérlő funkciók kezelik a regisztrációt és a bejelentkezést; jelentős részét képezik ennek a mintaprogramnak. A gyökérkönyvtárban hozzon létre a controllers/userControllers.js fájlt, és adja hozzá a következő kódot:

  1. Határozza meg a felhasználói regisztrációs vezérlőt.
    const Felhasználó = igényelnek("../models/user.model");
    const bcrypt = igényelnek("titkos");
    const { GeneratoToken } = igényelnek("../middleware/auth");
    exports.registerUser = async (req, res) => {
    const { felhasználónév, jelszó } = req.body;
    próbáld ki {
    const hash = várja bcrypt.hash (jelszó, 10); 
    várja User.create({ felhasználónév, Jelszó: hash });
     res.status(201).Küld({ üzenet: "Felhasználó sikeresen regisztrálva" });
     } fogás (hiba) {
    konzol.log (hiba);
     res.status(500).Küld({ üzenet: 'Hiba lépett fel!! ' });
     }
    };
    Ez a kódrészlet kivonatolja a megadott jelszót a bcrypt segítségével, majd új felhasználói rekordot hoz létre az adatbázisban, tárolva a felhasználónevet és a kivonatolt jelszót. Sikeres regisztráció esetén sikeres üzenetet küld.
  2. Határozzon meg egy bejelentkezési vezérlőt a felhasználói bejelentkezési folyamat kezeléséhez:
    exports.loginUser = async (req, res) => {
    const { felhasználónév, jelszó } = req.body;
    próbáld ki {
    const felhasználó = várja User.findOne({ felhasználónév });

    ha (!felhasználó) {
    Visszatérés res.status(404).Küld({ üzenet: 'Felhasználó nem található' });
     }
    

    const passwordMatch = várja bcrypt.compare (jelszó, user.password);
    

    ha (!passwordMatch) {
    Visszatérés res.status(401).Küld({ üzenet: "Érvénytelen bejelentkezési adatok" });
     }
    const hasznos teher = { Felhasználói azonosító: Felhasználói azonosító };
    const token = generálToken (hasznos terhelés);
     res.cookie('jelképes', token, { Csak http: igaz });
     res.status(200).json({ üzenet: 'Sikeres bejelentkezés'});
     } fogás (hiba) {
    konzol.log (hiba);
     res.status(500).Küld({ üzenet: "Hiba történt a bejelentkezés során" });
     }
    };
    Amikor egy felhasználó kérést küld a /login útvonalon, át kell adniuk hitelesítési adataikat a kérés törzsében. A kód ezután ellenőrzi ezeket a hitelesítő adatokat, és létrehoz egy JSON webes tokent. A tokent biztonságosan tárolja egy cookie-ban a Csak http zászló igazra állítva. Ez megakadályozza, hogy az ügyféloldali JavaScript hozzáférjen a jogkivonathoz, így védelmet nyújt a potenciális webhelyek közötti parancsfájl- (XSS) támadásokkal szemben.
  3. Végül határozzon meg egy védett útvonalat:
    exports.getUsers = async (req, res) => {
    próbáld ki {
    const felhasználók = várja User.find({});
     res.json (felhasználók);
     } fogás (hiba) {
    konzol.log (hiba);
     res.status(500).Küld({ üzenet: 'Hiba lépett fel!!' });
     }
    };
    Ha a JWT-t cookie-ban tárolja, a hitelesített felhasználótól érkező további API-kérések automatikusan tartalmazzák a tokent, lehetővé téve a szerver számára a kérések érvényesítését és engedélyezését.

Hozzon létre egy hitelesítési köztes szoftvert

Most, hogy meghatározott egy bejelentkezési vezérlőt, amely sikeres hitelesítés esetén JWT-jogkivonatot hoz létre, határozza meg a JWT-jogkivonatot generáló és ellenőrző köztes szoftver hitelesítési funkciókat.

A gyökérkönyvtárban hozzon létre egy új mappát, köztes szoftver. Adjon hozzá két fájlt ehhez a mappához: auth.js és config.js.

Add hozzá ezt a kódot config.js:

const kriptográfia = igényelnek("kripto");
modult.exports = {
 titkos kulcs: crypto.randomBytes(32).toString("hex")
};

Ez a kód minden futáskor egy új véletlenszerű titkos kulcsot generál. Ezután ezt a titkos kulcsot használhatja a JWT-k aláírására és hitelességének ellenőrzésére. A felhasználó sikeres hitelesítése után hozzon létre és írjon alá egy JWT-t a titkos kulccsal. A kiszolgáló ezután a kulcs segítségével ellenőrizze, hogy a JWT érvényes-e.

Adja hozzá a következő kódot auth.js amely a JWT-ket generáló és ellenőrző köztes szoftver funkciókat határozza meg.

const jwt = igényelnek("jsonwebtoken");
const { titkos kulcs } = igényelnek('./config');
const generToken = (hasznos teher) => {
const token = jwt.sign (payload, secretKey, { lejárIn: "1h" });
Visszatérés token ;
};


const verifyToken = (req, res, next) => {
const token = req.cookies.token;


ha (!token) {
Visszatérés res.status(401).json({ üzenet: "Nincs token megadva" });
 }


 jwt.verify (token, secretKey, (hiba, dekódolt) => {
ha (hiba) {
Visszatérés res.status(401).json({ üzenet: 'Érvénytelen kód' });
 }


 req.userId = dekódolt.felhasználói azonosító;
 következő();
 }); 
};
modult.exports = {generToken, verifyToken };

A generToken függvény JWT-t generál úgy, hogy aláír egy hasznos adatot egy titkos kulccsal, és beállít egy lejárati időt, miközben a verifyToken funkció köztes szoftverként szolgál a biztosított token hitelességének és érvényességének ellenőrzésére.

Határozza meg az API-útvonalakat

Újat csinálni routes/userRoutes.js fájlt a gyökérkönyvtárba, és adja hozzá a következő kódot.

const expressz = igényelnek('Expressz');
const router = expressz. Router();
const userControllers = igényelnek("../controllers/userControllers");
const { verifyToken } = igényelnek("../middleware/auth");
router.post('/api/regiszter', userControllers.registerUser);
router.post('/api/bejelentkezés', userControllers.loginUser);
router.get('/api/felhasználók', verifyToken, userControllers.getUsers);
modult.exports = útválasztó;

Frissítse a szerver belépési pontját

Frissítse a server.js fájl a következő kóddal.

const expressz = igényelnek('Expressz');
const cors = igényelnek("cors");
const app = express();
const port = 5000;
igényelnek("dotenv").config();
const connectDB = igényelnek('./utils/db');
const cookieParser = igényelnek("cookie-parser");
connectDB();


app.use (express.json());
app.use (express.urlencoded({ kiterjedt: igaz }));
app.use (cors());
app.use (cookieParser());
const userRoutes = igényelnek('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konzol.log(`Szerver figyel itt http://localhost:${port}`);
});

A REST API teszteléséhez forgassa fel a fejlesztői kiszolgálót, és küldjön API-kérelmeket a meghatározott végpontokhoz:

csomópont szerver.js

Node.js REST API-k védelme

A Node.js REST API-k biztonságossá tétele túlmutat a JWT-k használatán, bár kulcsfontosságú szerepet játszanak a hitelesítésben és Az engedélyezéshez elengedhetetlen, hogy holisztikus biztonsági megközelítést alkalmazzunk a háttérrendszer védelme érdekében rendszerek. A JWT-k mellett érdemes megfontolni a HTTPS bevezetését is a kommunikáció titkosítására, a bemeneti ellenőrzésre és fertőtlenítésre, valamint sok másra.

Több biztonsági intézkedés kombinálásával robusztus biztonsági keretrendszert hozhat létre Node.js REST API-kat, és minimalizálja a jogosulatlan hozzáférés, adatszivárgás és egyéb biztonság kockázatát fenyegetések.