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.
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 mongodbKö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:
- Határozza meg a felhasználói regisztrációs vezérlőt.
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.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!! ' });
}
}; - Határozzon meg egy bejelentkezési vezérlőt a felhasználói bejelentkezési folyamat kezeléséhez:
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.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" });
}
}; - Végül határozzon meg egy védett útvonalat:
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.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!!' });
}
};
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.jsNode.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.
