Felhasználó hitelesítés a NodeJS-ben Passport és MongoDB használatával

Ha meg akarja védeni a Node-alkalmazás érzékeny tartalmát, szüksége van egy módra a felhasználók hitelesítésére. A saját hitelesítési rendszer felépítése azonban bonyolult és időigényes, és ha nem végzik el megfelelően, biztonsági réseket okozhat az alkalmazásban. A harmadik féltől származó eszközök, például a Passport megkönnyítik a hitelesítést.

Ebből az oktatóanyagból megtudhatja, hogyan valósíthat meg hitelesítést a Node-ban a Passport és a MongoDB használatával.

Mi az a hitelesítés és engedélyezés?

Míg a hitelesítést és az engedélyezést néha felcserélhetően használják, ez a két biztonsági fogalom eltérő jelentéssel bír. A hitelesítés az a folyamat, amelynek során ellenőrizzük, hogy a felhasználó kinek mondja magát, miközben a hitelesítés az folyamat annak meghatározására, hogy egy hitelesített felhasználó hozzáfér-e az alkalmazás bizonyos részeihez.

Mi az a Passport.js?

Passport.js (vagy Passport) egy hitelesítési köztes szoftver a NodeJS számára, amely több mint 500 stratégiát kínál a felhasználók hitelesítésére, beleértve útlevél-helyi amely felhasználónevet és jelszót használ.

Ez az oktatóanyag használja útlevél-helyi és útlevél-jwt útvonalak biztosítására.

A felhasználói hitelesítés beállítása a NodeJS-ben

Most már ismer egy kicsit a felhasználói hitelesítésről és a Passport.js-ről, és megnézheti, hogyan állíthatja be a hitelesítést a NodeJS-en. Az alábbiakban felvázoltuk azokat a lépéseket, amelyeket meg kell tennie.

1. lépés: Csomópont-kiszolgáló beállítása

Hozzon létre egy nevű mappát user-auth-nodejs és navigáljon oda a termináljával.

mkdir user-auth-nodejs. 
cd user-auth-nodejs

Következő inicializálás package.json.

npm init

Mivel fogod használni Expressz, egy NodeJS háttérrendszer, telepítse a következő parancs futtatásával.

npm kifejezem

Most hozzon létre egy fájlt, app.js, és adja hozzá a következő kódot a szerver létrehozásához.

const express = követelmény("expressz");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Hangolás a ${PORT} porton`);
});

Összefüggő: Ismerje meg, hogyan telepítheti az Npm-et és a Node.js-t Ubuntun

2. lépés: Állítsa be az adatbázist

A felhasználói adatok tárolásához adatbázisra van szükség. A mongoose segítségével létrehozhat egy MongoDB adatsémát, amely meghatározza az adatbázisban tárolandó adatok szerkezetét és típusát. Mivel Ön felhasználói adatokat tárol, hozzon létre egy felhasználói sémát.

Telepítse a mongoose-t.

npm én mangúz

Hozzon létre egy új fájlt, userModel.js, és adja hozzá a következőket.

const mongoose = megköveteli('mongoose')
const {Séma} = mangúz
const UserSchema = új séma ({
 email: {
 típus: húr,
 kötelező: igaz
 },
 Jelszó: {
 típus: húr,
 kötelező: igaz
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = UserModel;

Összefüggő: Hogyan hozzunk létre adatbázist és gyűjteményt a MongoDB-ben

A jelszó tárolása előtt biztonsági okokból titkosítania kell. Használni fogod bcryptjs, egy nagyon hasznos npm csomag, amely megkönnyíti a titkosított jelszavakkal való munkát.

Telepítés bcryptjs.

npm és bcryptjs

Módosít usermodel.js titkosítsa a jelszót, mielőtt elmenti az adatbázisba.

const mongoose = megköveteli('mongoose')
const bcrypt = request('bcryptjs');
const {Séma} = mangúz
const UserSchema = új séma ({
...
})
UserSchema.pre('save', async function (next) {
 próbálja meg {
 // ellenőrizze a regisztráció módját
 const user = ez;
 if (!user.isModified('jelszó')) next();
 // sót generál
 const salt = várakozás bcrypt.genSalt (10);
 // kivonatolja a jelszót
 const hashedPassword = várja a bcrypt.hash (this.password, salt);
 // cserélje ki az egyszerű szöveges jelszót kivonatolt jelszóra
 this.password = hashedPassword;
 következő();
 } fogás (hiba) {
 return next (hiba);
 }
 });
...
const User = mongoose.model('User', UserSchema);

Itt az a mentés előtt horog a jelszó módosításához a mentés előtt. Az ötlet az, hogy az egyszerű szöveges jelszó helyett a jelszó hash verzióját tároljuk. A hash egy egyszerű szöveges karakterláncból előállított hosszú összetett karakterlánc.

Használat isMódosítva ellenőrizni, hogy változik-e a jelszó, mivel csak az új jelszavakat kell kivonatolni. Ezután hozzon létre egy sót, és adja át az egyszerű szöveges jelszóval a hash metódusnak a kivonatolt jelszó létrehozásához. Végül cserélje ki az egyszerű szöveges jelszót az adatbázisban lévő kivonatolt jelszóra.

Hozzon létre db.js fájlt, és konfigurálja az adatbázist.

const mongoose = igény("mongúz");
indiai menyét. Ígéret = globális. Ígéret;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("hiba", () => {
 console.log("nem sikerült csatlakozni");
 });
 db.once("nyitva", () => {
 console.log("> Sikeres csatlakozás az adatbázishoz");
 });
};
module.exports = {csatlakozás};

Az app.js fájlban csatlakozzon az adatbázishoz.

// csatlakozni a db-hoz
const db = követelmény('./db');
db.connect();

3. lépés: Állítsa be a Passportot

Telepítés Útlevél és útlevél-helyi. Ezeket a csomagokat a felhasználók regisztrálására és bejelentkezésére fogja használni.

npm i útlevél
npm i útlevél-helyi

Hozzon létre egy új fájlt, passportConfig.js, és import útlevél-helyi és a userModel.js.

const LocalStraregy = követelmény("passport-local").Stratégia;
const Felhasználó = követelmény("./felhasználómodell");

Konfigurálja a Passportot a felhasználói regisztráció kezelésére.

const LocalStrategy = request("passport-local");
const Felhasználó = követelmény("./felhasználómodell");
module.exports = (útlevél) => {
 passport.use(
 "helyi regisztráció",
 new LocalStrategy(
 {
 felhasználónévMező: "e-mail",
 jelszóMező: "jelszó",
 },
 async (e-mail, jelszó, kész) => {
 próbálja meg {
 // ellenőrizze, hogy létezik-e felhasználó
 const userExists = várja User.findOne({ "e-mail": email });
 if (felhasználó létezik) {
 visszaküldés kész (null, false)
 }
 // Új felhasználó létrehozása a megadott felhasználói adatokkal
 const user = await User.create({ email, password });
 visszatérés kész (null, user);
 } fogás (hiba) {
 kész (hiba);
 }
 }
 )
 );
}

A fenti kódban azt ellenőrzi, hogy az e-mail már használatban van-e. Ha az e-mail cím nem létezik, regisztrálja a felhasználót. Vegye figyelembe, hogy a felhasználónév mezőt is úgy állítja be, hogy e-mailt fogadjon el. Alapértelmezés szerint, útlevél-helyi felhasználónevet vár, ezért közölnie kell vele, hogy e-mailt ad át.

Használat útlevél-helyi hogy kezelje a felhasználói bejelentkezést is.

module.exports = (útlevél) => {
 passport.use(
 "helyi regisztráció",
 new localStrategy(
 ...
 )
 );
passport.use(
 "helyi bejelentkezés",
 new LocalStrategy(
 {
 felhasználónévMező: "e-mail",
 jelszóMező: "jelszó",
 },
 async (e-mail, jelszó, kész) => {
 próbálja meg {
 const user = await User.findOne({ email: email });
 if (!user) return done (null, false);
 const isMatch = várja user.matchPassword (jelszó);
 if (!isMatch)
 return kész (null, false);
 // ha a jelszavak megegyeznek a visszatérő felhasználóval
 visszatérés kész (null, user);
 } fogás (hiba) {
 console.log (hiba)
 visszaküldés kész (hiba, hamis);
 }
 }
 )
 );
};

Itt ellenőrizze, hogy a felhasználó létezik-e az adatbázisban, és ha igen, ellenőrizze, hogy a megadott jelszó megegyezik-e az adatbázisban lévővel. Megjegyzés: Ön is hívja a matchPassword() módszert a felhasználói modellen, tehát lépjen a következőre userModel.js fájlt, és adja hozzá.

UserSchema.methods.matchPassword = async function (jelszó) {
 próbálja meg {
 return await bcrypt.compare (jelszó, this.password);
 } fogás (hiba) {
 dob új Error (hiba);
 }
};

Ez a módszer összehasonlítja a felhasználó jelszavát és az adatbázisban lévő jelszót, és igazat ad vissza, ha egyezik.

4. lépés: Hitelesítési útvonalak beállítása

Most létre kell hoznia azokat a végpontokat, amelyekre a felhasználók adatokat küldenek. Először a regisztrációs útvonal, amely elfogadja az új felhasználó e-mail-címét és jelszavát.

Ban ben app.js, használja az imént létrehozott útlevél-hitelesítési köztes szoftvert a felhasználó regisztrálásához.

app.post(

 "/auth/signup",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // regisztrálj
 res.json({
 felhasználó: req.user,
 });
 }
);

Összefüggő: Hitelesítés vs. Engedélyezés: Mi a különbség?

Ha sikeres, a regisztrációs útvonalnak vissza kell adnia a létrehozott felhasználót.

Ezután hozza létre a bejelentkezési útvonalat.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Belépés
 res.json({
 felhasználó: req.user,
 });
 }
);

5. lépés: Adjon hozzá védett útvonalakat

Eddig használtad Útlevél létrehozni egy köztes szoftvert, amely regisztrál egy felhasználót az adatbázisban, és egy másikat, amely lehetővé teszi a regisztrált felhasználók bejelentkezését. Ezután létre kell hoznia egy engedélyezési köztes szoftvert az érzékeny útvonalak védelmére JSON web token (JWT) használatával. A JWT engedélyezés végrehajtásához a következőket kell tennie:

• JWT tokent generál.
• Adja át a tokent a felhasználónak. A felhasználó jogosultsági kérésben küldi vissza.
• Ellenőrizze a felhasználó által visszaküldött tokent.

Használni fogja a jsonwebtoken csomag a JWT-k kezelésére.

A telepítéshez futtassa a következő parancsot.

npm i jsonwebtoken

Ezután hozzon létre egy tokent minden sikeresen bejelentkező felhasználó számára.

Ban ben app.js, import jsonwebtoken és módosítsa a bejelentkezési útvonalat az alábbiak szerint.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Belépés
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 if (err) {
 return res.json({
 üzenet: "Nem sikerült bejelentkezni",
 token: null,
 });
 }
 res.json({
 jelképes
 });
 })
 }
);

Valós alkalmazásokban bonyolultabb titkos kulcsot kell használni, és azt egy konfigurációs fájlban kell tárolni.

A bejelentkezési útvonal sikeresen visszaküld egy tokent.

Használat útlevél-jwt védett útvonalak eléréséhez.

npm i passport-jwt

Ban ben passportConfig.js, konfigurálja a útlevél-jwt.

const JwtStrategy = követelmény("passport-jwt").Stratégia;
const { ExtractJwt } = követelmény("passport-jwt")
module.exports = (útlevél) => {
passport.use(
 "helyi bejelentkezés",
 new LocalStrategy(
 ...
 );
passport.use(
 új JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("engedély"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, kész) => {
 próbálja meg {
 // Felhasználó kibontása
 const user = jwtPayload.user;
 kész (null, user);
 } fogás (hiba) {
 kész (hiba, hamis);
 }
 }
 )
 );
};

Figyelje meg, hogy a JWT-t az engedélyezési fejlécből vonja ki a kérés törzse helyett. Ez megakadályozza, hogy a hackerek elfogjanak egy kérést és megragadják a tokent.

Hogy hogyan útlevél-jwt őrzi az útvonalakat, hozzon létre egy védett útvonalat app.js.

app.get(
 "/felhasználó/védett",
 passport.authenticate("jwt", { session: false }),
 (req, res, next) => {
 res.json({felhasználó: req.user});
 }
);

Csak az érvényes JWT-vel rendelkező kérés adja vissza a felhasználói adatokat.

Most már készen áll arra, hogy felhasználói hitelesítését a következő szintre emelje

Ebben az oktatóanyagban megtanulta, hogyan hitelesítheti a felhasználókat e-mail és jelszó használatával a Passport segítségével. Elsőre ijesztőnek tűnhet, de a folyamat viszonylag egyszerű. Még tovább is léphet, és használhatja a Passport által támogatott külső identitásszolgáltatókat, például a Twittert, a Facebookot és a Google-t.

Mi az a felhasználói hitelesítés és hogyan működik?

Fontos, hogy megértse a felhasználói hitelesítés alapjait, hogy biztosítsa online fiókjainak maximális biztonságát. Szóval, merüljünk bele.

Olvassa el a következőt

A szerzőről