Удостоверяване на потребителя в NodeJS с помощта на Passport и MongoDB

Ако искате да защитите чувствително съдържание във вашето приложение Node, имате нужда от начин за удостоверяване на потребителите. Въпреки това, изграждането на ваша собствена система за удостоверяване е сложно и отнема много време и ако не е направено правилно, може да доведе до уязвимости в сигурността във вашето приложение. Инструменти на трети страни като Passport правят удостоверяването по-лесно.

В този урок ще научите как да приложите удостоверяване в Node с помощта на Passport и MongoDB.

Какво представляват удостоверяването и упълномощаването?

Докато удостоверяването и упълномощаването понякога се използват взаимозаменяемо, тези две концепции за сигурност имат различни значения. Удостоверяването е процесът на проверка на това, че потребителят е този, за когото се представя, докато упълномощаването е процес за определяне дали удостоверен потребител има достъп до определени части от вашето приложение.

Какво е Passport.js?

Passport.js (или Passport) е междинен софтуер за удостоверяване за NodeJS, който предоставя повече от 500 стратегии за удостоверяване на потребители, включително

паспортно-местен който използва потребителско име и парола.

Този урок използва паспортно-местен и паспорт-jwt за осигуряване на маршрути.

Как да настроите удостоверяване на потребителя в NodeJS

Сега знаете малко за удостоверяването на потребителя и Passport.js, можем да разгледаме как да настроим удостоверяване на NodeJS. По-долу сме очертали стъпките, които трябва да предприемете.

Стъпка 1: Настройте сървър на възел

Създайте папка с име user-auth-nodejs и отидете до него с помощта на вашия терминал.

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

Следваща инициализация package.json.

npm init

Тъй като ще използвате експресно, бекенд рамка на NodeJS, инсталирайте я, като изпълните следната команда.

npm изразявам

Сега създайте файл, app.jsи добавете следния код, за да създадете сървъра.

const express = изисквам ("експрес");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
console.log(`Слушане на порт ${PORT}`);
});

Свързани: Научете как да инсталирате Npm и Node.js в Ubuntu

Стъпка 2: Настройте базата данни

Имате нужда от база данни, за да съхранявате потребителски данни. Ще използвате mongoose, за да създадете схема за данни на MongoDB, която дефинира структурата и типа на данните, които ще съхранявате в базата данни. Тъй като съхранявате потребителски данни, създайте потребителска схема.

Инсталирайте mongoose.

npm аз мангуст

Създайте нов файл, userModel.js, и добавете следното.

const mongoose = require('mongoose')
const {схема} = мангуста
const UserSchema = нова схема ({
 електронна поща: {
 тип: низ,
 задължително: вярно
 },
 парола: {
 тип: низ,
 задължително: вярно
 }
})
const UserModel = mongoose.model('user', UserSchema);
module.exports = Потребителски модел;

Свързани: Как да създадете база данни и колекция в MongoDB

Преди да запазите паролата, трябва да я криптирате от съображения за сигурност. Вие ще използвате bcryptjs, много полезен npm пакет, който прави работата с криптирани пароли лесна.

Инсталирай bcryptjs.

npm и bcryptjs

Промяна usermodel.js за да криптирате паролата, преди да я запишете в базата данни.

const mongoose = require('mongoose')
const bcrypt = изисквам ('bcryptjs');
const {схема} = мангуста
const UserSchema = нова схема ({
...
})
UserSchema.pre('save', async function (next) {
 опитвам {
 // проверка на метода на регистрация
 const потребител = това;
 if (!user.isModified('password')) next();
 // генерира сол
 const sol = await bcrypt.genSalt (10);
 // хеширане на паролата
 const hashedPassword = await bcrypt.hash (тази.парола, сол);
 // заменете паролата с обикновен текст с хеширана парола
 this.password = hasshedPassword;
 следващия();
 } улов (грешка) {
 върнете следващия (грешка);
 }
 });
...
const Потребител = mongoose.model('Потребител', потребителска схема);

Тук използвате a предварително запазване кука, за да промените паролата, преди да бъде запазена. Идеята е да се съхранява хеш версията на паролата вместо паролата с обикновен текст. Хешът е дълъг сложен низ, генериран от низ от обикновен текст.

Използвайте е модифициран за да проверите дали паролата се променя, тъй като трябва само да хеширате нови пароли. След това генерирайте сол и я предайте с паролата за обикновен текст към хеш метода, за да генерирате хеширана парола. Накрая заменете паролата с обикновен текст с хеширана парола в базата данни.

Създайте db.js и конфигурирайте базата данни.

const mongoose = изисквам("мангуст");
мангуста. Обещание = глобално. обещание;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("грешка", () => {
 console.log("не може да се свърже");
 });
 db.once("отворено", () => {
 console.log("> Успешно свързан с базата данни");
 });
};
module.exports = { свържете };

В app.js се свържете с базата данни.

// свързване към db
const db = изисквам ('./db');
db.connect();

Стъпка 3: Настройте паспорт

Инсталирай паспорт и паспортно-местен. Вие ще използвате тези пакети за регистрация и влизане на потребители.

npm i паспорт
npm i passport-local

Създайте нов файл, passportConfig.js, и внос паспортно-местен и на userModel.js.

const LocalStraregy = require("passport-local").Стратегия;
const Потребител = изисква ("./userModel");

Конфигурирайте Passport за обработка на потребителска регистрация.

const LocalStrategy = require("passport-local");
const Потребител = изисква ("./userModel");
module.exports = (паспорт) => {
 passport.use(
 "локална регистрация",
 нова локална стратегия(
 {
 потребителско имеПоле: "имейл",
 passwordField: "password",
 },
 async (имейл, парола, готово) => {
 опитвам {
 // проверка дали потребител съществува
 const userExists = await User.findOne({ "имейл": имейл });
 if (userExists) {
 връщане готово (null, false)
 }
 // Създайте нов потребител с предоставените потребителски данни
 const user = await User.create({ имейл, парола });
 връщане готово (нула, потребител);
 } улов (грешка) {
 готово (грешка);
 }
 }
 )
 );
}

В горния код проверявате дали имейлът вече се използва. Ако имейлът не съществува, регистрирайте потребителя. Имайте предвид, че също така настройвате полето за потребителско име да приема имейл. По подразбиране, паспортно-местен очаква потребителско име, така че трябва да му кажете, че вместо това предавате имейл.

Използвайте паспортно-местен за да обработва и влизането на потребителя.

module.exports = (паспорт) => {
 passport.use(
 "локална регистрация",
 нова локална стратегия(
 ...
 )
 );
passport.use(
 "local-login",
 нова локална стратегия(
 {
 потребителско имеПоле: "имейл",
 passwordField: "password",
 },
 async (имейл, парола, готово) => {
 опитвам {
 const user = await User.findOne({ имейл: имейл });
 if (!user) връща готово (null, false);
 const isMatch = await user.matchPassword (парола);
 ако (!isMatch)
 връщане готово (null, false);
 // ако паролите съвпадат с върнатия потребител
 връщане готово (нула, потребител);
 } улов (грешка) {
 console.log (грешка)
 връщане готово (грешка, лъжа);
 }
 }
 )
 );
};

Тук проверете дали потребителят съществува в базата данни и ако го има, проверете дали предоставената парола съвпада с тази в базата данни. Имайте предвид, че се обаждате и на съвпадение с парола() метод на потребителския модел, така че отидете на userModel.js файл и го добавете.

UserSchema.methods.matchPassword = асинхронна функция (парола) {
 опитвам {
 return await bcrypt.compare (парола, this.password);
 } улов (грешка) {
 хвърлям нова грешка (грешка);
 }
};

Този метод сравнява паролата от потребителя и тази в базата данни и връща true, ако съвпадат.

Стъпка 4: Настройте маршрути за удостоверяване

Сега трябва да създадете крайните точки, до които потребителите ще изпращат данни. На първо място е маршрутът за регистрация, който ще приеме имейла и паролата на нов потребител.

В app.js, използвайте междинния софтуер за удостоверяване на паспорт, който току-що създадохте, за да регистрирате потребителя.

app.post(

 "/auth/signup",
 passport.authenticate('local-signup', { session: false }),
 (req, res, next) => {
 // Регистрирай се
 res.json({
 потребител: req.user,
 });
 }
);

Свързани: Удостоверяване срещу Упълномощаване: Каква е разликата?

Ако е успешен, маршрутът за регистрация трябва да върне създадения потребител.

След това създайте маршрута за влизане.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Влизам
 res.json({
 потребител: req.user,
 });
 }
);

Стъпка 5: Добавете защитени маршрути

Досега сте използвали паспорт за създаване на междинен софтуер, който регистрира потребител в базата данни и друг, който позволява на регистриран потребител да влезе. След това ще създадете междинен софтуер за упълномощаване за защита на чувствителни маршрути с помощта на JSON уеб токен (JWT). За да приложите JWT оторизация, трябва:

• Генериране на JWT токен.
• Предайте токена на потребителя. Потребителят ще го изпрати обратно в заявки за упълномощаване.
• Проверете токена, изпратен обратно от потребителя.

Вие ще използвате jsonwebtoken пакет за работа с JWT.

Изпълнете следната команда, за да го инсталирате.

npm и jsonwebtoken

След това генерирайте токен за всеки потребител, който успешно влезе.

В app.js, внос jsonwebtoken и променете маршрута за влизане, както е по-долу.

app.post(
 "/auth/login",
 passport.authenticate('local-login', { session: false }),
 (req, res, next) => {
 // Влизам
 jwt.sign({user: req.user}, 'secretKey', {expiresIn: '1h'}, (err, token) => {
 ако (грешка) {
 върне res.json({
 съобщение: "Неуспешно влизане",
 токен: нула,
 });
 }
 res.json({
 токен
 });
 })
 }
);

В приложение в реалния живот ще използвате по-сложен таен ключ и ще го съхранявате в конфигурационен файл.

Маршрутът за влизане връща токен, ако е успешен.

Използвайте паспорт-jwt за достъп до защитени маршрути.

npm i passport-jwt

В passportConfig.js, конфигурирайте паспорт-jwt.

const JwtStrategy = require("passport-jwt").Стратегия;
const { ExtractJwt } = изисквам ("passport-jwt")
module.exports = (паспорт) => {
passport.use(
 "local-login",
 нова локална стратегия(
 ...
 );
passport.use(
 нова JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("упълномощаване"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, готово) => {
 опитвам {
 // Извличане на потребител
 const потребител = jwtPayload.user;
 готово (нула, потребител);
 } улов (грешка) {
 направено (грешка, невярно);
 }
 }
 )
 );
};

Забележете, че извличате JWT от заглавката за оторизация вместо от тялото на заявката. Това не позволява на хакерите да прихванат заявка и да грабнат токена.

За да видите как паспорт-jwt пази маршрути, създайте защитен маршрут в app.js.

app.get(
 "/потребител/защитен",
 passport.authenticate("jwt", { session: false }),
 (req, res, next) => {
 res.json({user: req.user});
 }
);

Само заявка с валиден JWT връща потребителските данни.

Вече сте готови да изведете удостоверяването на потребителя на следващото ниво

В този урок научихте как можете да удостоверявате потребители с помощта на имейл и парола с помощта на Passport. В началото може да изглежда обезсърчително, но процесът е сравнително лесен. Можете да отидете още по-далеч и да използвате доставчици на идентичност на трети страни, поддържани от Passport, като Twitter, Facebook и Google.

Какво представлява удостоверяването на потребителя и как работи?

Важно е да разберете основите на удостоверяването на потребителя, за да осигурите максимално ниво на сигурност за вашите онлайн акаунти. Така че, нека се потопим.

Прочетете Следващото

За автора