A felhasználói hitelesítés az a folyamat, amely során ellenőrizzük az alkalmazáshoz hozzáférést próbáló felhasználó személyazonosságát. Ez magában foglalja a hitelesítő adatok engedélyezését és átvitelét a felhasználó hitelességének megerősítésére.
Egyszerű felhasználói hitelesítési modellt valósíthat meg a Node.js-ben Express, Bcrypt és MongoDB használatával, mindössze néhány lépésben.
1. lépés: Fejlesztési környezet beállítása
Először hozzon létre egy projekt mappát, és CD futva bele:
mkdir felhasználói hitelesítés
CD felhasználói hitelesítés
Ezután inicializálja az npm-et a projektkönyvtárban a következő futtatással:
npm init -y
Az -y flag inicializálja az npm-et, és létrehozza az Ön package.json fájlt az összes alapértelmezett értékével.
Ez a felhasználói hitelesítési modell néhány függőséget igényel.
Tartalmazzák:
- Expressz: Az Express egy Node.js keretrendszer amely robusztus funkciókészletet biztosít webes és mobilalkalmazásokhoz. Könnyebbé teszi a háttéralkalmazások Node.js-szel való felépítését.
- Bcrypt: A bcrypt egy npm csomag, amely megvalósítja a bcrypt jelszó-kivonatolási funkciót. Lehetővé teszi hashek létrehozását egyszerű jelszó karakterláncokból.
- Mongoose: A Mongoose egy MongoDB objektumadat-modellező könyvtár. Leegyszerűsíti az alkalmazás és a MongoDB adatbázis közötti interakciókat.
- dotenv: a dotenv egy nulla függőségi csomag, amely a környezeti változókat tölti be a .env fájlba folyamat.env.
- Validator: a validator egy csomag, amely különféle karakterlánc-ellenőrzési funkciókat tartalmaz.
- Body-parser: A body-parser csomag a kérések törzseit egy köztes szoftverben elemzi a kezelők előtt.
Telepítse a csomagokat a következő futtatással:
npm telepítés expressz bcrypt mongoose dotenv validátor test-elemző
Ezután hozzon létre egy app.js fájlt a projekt gyökérkönyvtárába, és adja hozzá az alábbi kódblokkot egy alapszintű Express szerver létrehozásához:
// app.js
const expressz = igényelnek('Expressz');
const app = express();
const bodyParser = igényelnek("test-elemző");const port = 3000;
kb.használat(bodyParser.json());
kb.használat(bodyParser.urlencoded({ kiterjedt: igaz }));
app.listen (port, ()=>{
konzol.log(`Az alkalmazás figyel a porton ${port}`);
});
Ez a kód expressz alkalmazáspéldányt hoz létre az expressz függvény meghívásával. Ezután a test-elemző köztes szoftver a bejövő kéréstestek elemzéséhez. Ezután elkezdi figyelni a 3000-es porton lévő forgalmat úgy, hogy meghívja az expressz példány figyelési metódusát, és argumentumként átadja a portváltozót.
2. lépés: Az alkalmazás összekapcsolása egy adatbázissal
A projekt gyökérkönyvtárában hozzon létre egy .env fájlt, és tárolja benne MongoDB hitelesítő adatait. Ezzel elkerülhető, hogy az adatbázis hitelesítő adatai megjelenjenek a kódban, amely rosszindulatú felhasználók számára hozzáférést biztosíthat az adatbázishoz.
Ezután navigáljon a sajátjához app.js fájl és import mongoose:
const mangúz = igényelnek("indiai menyét");
Ezután hívja az importálást dotenv és hívja a config módszer rajta:
igényel("dotenv").config();
Felhívja a config módszer bekapcsolva dotenv környezeti változókat tölt be a folyamat.env.
Végül hívja be a csatlakozási módot indiai menyét és adja át a MongoDB URI-ját argumentumként:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Sikeresen csatlakozott az adatbázishoz')
})
3. lépés: Felhasználói modell létrehozása
A projekt gyökérkönyvtárában hozzon létre egy „modellek” mappa; itt fogja tárolni a mongúz modelljét:
mkdir modellek
Ezután hozzon létre egy „userModel” fájlt, és adja hozzá a következő importálást:
const mangúz = igényelnek('indiai menyét')
const { isEmail } = igényelnek('ellenőrző')
isEmail egy érvényesítési függvény, amely visszaadja igaz ha egy adott karakterlánc egy e-mail. Szüksége lesz rá a mongoose érvényesítés alkalmazásához a felhasználói modellre.
Ezután adja hozzá a következő kódot a sajátjához userModel fájl:
// modellek/felhasználómodell
const userSchema = mangúz. Séma({
email: {
típus: Húr,
kötelező: [igaz, 'E-mail megadása kötelező'],
érvényesít: {
érvényesítő: isEmail,
üzenet: kellékek => `${props.value} nem érvényes e-mail."
}
},Jelszó: {
típus: Húr,
kötelező: [igaz, 'Jelszó szükséges'],
érvényesít: {
érvényesítő: funkció (érték) {
Visszatérés érték.hossz >= 6
},
üzenet: () =>'A jelszónak legalább hat karakterből kell állnia'
}
}
})
modult.export = mongoose.model('User', userSchema)
A fenti kód létrehozza a userSchema változó, amely az értékét tárolja indiai menyét. Séma módszer. A mangúz. A séma metódus a tulajdonságokat leképezi egy MongoDB gyűjteményre, és meghatározza a benne lévő dokumentumok alakját. A mongúz séma két tulajdonsággal rendelkezik: egy email és a Jelszó– ez lesz a hitelesítési követelménye.
Az email tulajdonság karakterlánc típusú, és rendelkezik kívánt igazra állítva. A kísérő hibaüzenet, „E-mail szükséges” jelenik meg, ha a kérés törzse nem tartalmaz egy email ingatlan. Végül a mongoose egyéni érvényesítés segítségével a érvényesítő tulajdon referens az isEmail funkció. Ez a függvény igaz vagy hamis értéket ad vissza a karakterlánc e-mailként való érvényessége alapján. Ezután az üzenet tulajdonság felveszi az email értéket (kellékek), és értelmes hibaüzenetet készít.
A jelszó tulajdonság egy kötelező karakterlánctípus, amelyen a következő hibaüzenet jelenik meg: „Jelszó szükséges”. Az érvényesítő függvény egy névtelen, amely igazat ad vissza, ha a jelszó legalább hat karakter hosszú.
Az utolsó sor egy mongúz modellt hoz létre és exportál a következő meghívásával modell módszer bekapcsolva indiai menyét. Add meg a modell nevét (Felhasználó) mint első argumentum és séma (userSchema) második érvként.
4. lépés: A bejelentkezési és regisztrációs útvonalak megvalósítása
A projekt gyökérkönyvtárában hozzon létre egy útvonalak mappa:
mkdir útvonalak
Az útvonalak mappában hozzon létre a userRoutes.js fájlt, és adja hozzá a következő importálást:
// routes/userRoutes.js
const expressz = igényelnek("Expressz");
const Felhasználó = igényelnek(../models/userModel");
const bcrypt = igényelnek("bcrypt");
Hozzon létre egy Express Router példányt a Router módszer bekapcsolva Expressz:
const router = expressz. Router();
Ezután hozza létre a regisztrációs útvonalat az alábbi kódblokk hozzáadásával userRoute.js fájl:
router.post("/sign-up", async (req, res) => {
próbálja meg {
// E-mail-cím és jelszó kibontása a req.body objektumból
const { email, password } = req.body;// Jelölje beha az email van már ban benhasználat
hagyja userExists = várják User.findOne({ email });if (felhasználó létezik) {
res.status(401).json({ üzenet: "Az e-mail már megérkezett használat.&idézet; });
Visszatérés;
}// Define salt rounds
const sóKerek = 10;// Hash jelszó
bcrypt.hash (jelszó, saltRounds, (err, hash) => {
ha (téved) dobásújHiba("Belső szerver Hiba");// Teremt a újfelhasználó
hagyja felhasználó = új Felhasználó({
email,
Jelszó: hash,
});
// Felhasználó mentése adatbázisba
user.save().then(() => {
res.json({ üzenet: "Felhasználó sikeresen létrehozva", felhasználó });
});
});
} fogás (hiba) {
Visszatérésres.állapot(401).Küld(téved.üzenet);
}
});
A fenti kódblokkban először destrukturálta az e-mailt és a jelszót a req.body tárgy. Ezután ellenőrizze, hogy egy felhasználó használja-e már az e-mailt, mert annak minden felhasználó számára egyedinek kell lennie. Ha az e-mailt már használták, 401-es állapotkóddal térjen vissza, és állítsa le a kód végrehajtását.
Az egyszerű jelszavak adatbázisban való tárolása hatalmas biztonsági fenyegetést jelent, mivel a rosszindulatú hackerek hozzáférhetnek az adatbázishoz. Érdemes kivonatolni a jelszavakat, mielőtt besorolná őket az adatbázisba, így még ha egy hacker felfedezi is őket, nem jelenthet veszélyt a felhasználókra. A kivonatolás az a folyamat, amikor egy adott „kulcsot” egy másik értékké alakítanak át. A kivonatolás egyirányú funkció, ami azt jelenti, hogy a titkosítással ellentétben nem lehet lekérni az eredeti értéket a hasedből.
A bcrypt használatával kivonatoltad felhasználói jelszavát a bcrypt hash metódusának meghívásával. A kivonatolási módszer három paramétert vesz igénybe: a kivonatolni kívánt karakterláncot, a sót és a visszahívási függvényt. Átadja a felhasználói jelszót, a korábban létrehozott saltRounds változót és egy visszahívást.
A sós körök azt az időt jelentik, amely egyetlen bcrypt hash kiszámításához szükséges. Minél magasabb a sókör, annál több a kivonatolási kör.
Ha a hash metódus hibát ad, akkor „belső szerverhiba” üzenetet ad. Ellenkező esetben a jelszó tulajdonságot a sikeres hash értékre állítja, és a mentési metódus meghívásával mentse el az adatbázisba Felhasználó példa.
Ezután hozza létre a bejelentkezési útvonalat az alábbi kódblokk hozzáadásával userRoute.js fájl:
router.post("/sign-in", async (req, res) => {
próbálja meg {
// E-mail-cím és jelszó kibontása a req.body objektumból
const { email, password } = req.body;// Jelölje behafelhasználólétezikban benadatbázis
hagyja felhasználó = várják User.findOne({ email });if (!felhasználó) {
return res.status (401).json({ üzenet: "Érvénytelen hitelesítő adatok" });
}// Jelszavak összehasonlítása
bcrypt.compare (jelszó, user.password, (err, result) => {
if (eredmény) {
return res.status (200).json({ üzenet: "Felhasználó sikeresen bejelentkezett" });
}konzol.log (hiba);
return res.status (401).json({ üzenet: "Érvénytelen hitelesítő adatok" });
});
} fogás (hiba) {
res.állapot(401).Küld(téved.üzenet);
}
});
modult.export = router;
A fenti kódblokkban először destrukturálja az e-mailt és a jelszót a req.body tárgy. Ezután ellenőrizze, hogy van-e felhasználó az adatbázisban. Ha a felhasználó nem létezik az adatbázisban, akkor egy 401-es állapotkóddal tér vissza.
Ezután a bcrypt összehasonlítási módszerével adja meg a felhasználó által megadott jelszót és az adatbázisból letöltött kivonatolt jelszót. Hasonlítsa össze a kettőt, hogy megerősítse, megfelelnek-e. Ha a jelszavak egyeznek, egy 200-as állapotkódot és egy sikerüzenetet ad vissza. Ellenkező esetben 401-es állapotkódot és hibaüzenetet ad vissza.
Végül az importálás router a tiédbe app.js fájlt, és alkalmazásszintű köztes szoftverként használja.
Ezzel befejeződik a felhasználói hitelesítési modell; mostantól a felhasználók biztonságosan regisztrálhatnak és bejelentkezhetnek az alkalmazásába.
A felhasználói hitelesítés jelentősége
A felhasználói hitelesítés biztosítja, hogy csak jogos felhasználók férhessenek hozzá az alkalmazáshoz. Ha az Ön adatai bármilyen módon személyesek vagy magánjellegűek, lépéseket kell tennie annak érdekében, hogy megakadályozza a nem hitelesített felhasználók hozzáférését.