Удостоверяването на потребителя е процес на проверка на самоличността на потребител, който се опитва да получи достъп до вашето приложение. Това включва оторизиране и прехвърляне на идентификационни данни за потвърждаване на автентичността на потребителя.
Можете да приложите прост модел за удостоверяване на потребителя в Node.js с помощта на Express, Bcrypt и MongoDB само с няколко стъпки.
Стъпка 1: Настройване на среда за разработка
Първо създайте папка на проекта и cd в него, като стартирате:
mkdir потребителско удостоверяване
cd потребителско удостоверяване
След това инициализирайте npm в директорията на вашия проект, като изпълните:
npm init -y
The -y флаг инициализира npm и създава вашия package.json файл с всички негови настройки по подразбиране.
Този модел за удостоверяване на потребителя изисква няколко зависимости.
Те включват:
- Експресно: Express е Node.js рамка който предоставя стабилен набор от функции за уеб и мобилни приложения. Това улеснява изграждането на бекенд приложения с Node.js.
- Bcrypt: bcrypt е npm пакет, който прилага функцията за хеширане на парола bcrypt. Позволява ви да създавате хешове от обикновени низове с пароли.
- Mongoose: Mongoose е библиотека за моделиране на обектни данни на MongoDB. Той опростява взаимодействията между вашето приложение и MongoDB база данни.
- dotenv: dotenv е пакет с нулева зависимост, който зарежда променливи на средата от a .env файл в process.env.
- Валидатор: валидаторът е пакет, който съдържа различни функции за валидиране на низове.
- Body-parser: Пакетът body-parser анализира телата на заявките в междинен софтуер преди вашите манипулатори.
Инсталирайте пакетите, като стартирате:
npm Инсталирай експрес bcrypt mongoose dotenv валидатор тяло-анализатор
След това създайте app.js файл в главната директория на вашия проект и добавете кодовия блок по-долу, за да създадете основен Express сървър:
// app.js
конст експрес = изискват('експресно');
конст приложение = експрес();
конст bodyParser = изискват("тяло-парсер");конст порт = 3000;
ап.използване(bodyParser.json());
ап.използване(bodyParser.urlencoded({ удължен: вярно }));
app.listen (порт, ()=>{
конзола.log(„Приложението слуша порт ${порт}`);
});
Този код създава екземпляр на експресно приложение чрез извикване на експресната функция. След това използва анализатор на тялото междинен софтуер за анализиране на тела на входящи заявки. След това започва да слуша за трафик на порт 3000, като извиква метода за слушане на експресния екземпляр и предава променливата на порта като аргумент.
Стъпка 2: Свързване на вашето приложение към база данни
В главната директория на вашия проект създайте a .env файл и съхранете вашите идентификационни данни за MongoDB в него. Това избягва разкриването на идентификационните данни на вашата база данни в код, който може да даде на злонамерени потребители достъп до вашата база данни.
След това отворете вашия app.js файл и импортиране на mongoose:
конст мангуста = изискват("мангуста");
След това извикайте импортиране dotenv и се обадете на конфиг метод върху него:
изисквам("dotenv").config();
Обаждане на конфиг метод на dotenv зарежда променливи на средата в process.env.
Накрая извикайте метода за свързване мангуста и предайте вашия MongoDB URI като аргумент:
mongoose.connect (process.env. MONGODB_URI).тогава(() => {
console.log('Успешна връзка с базата данни')
})
Стъпка 3: Създаване на потребителски модел
В главната директория на вашия проект създайте „модели” папка; това е мястото, където ще съхранявате модела си mongoose:
mkdir модели
След това създайте „userModel” и добавете следните импортирания:
конст мангуста = изискват("мангуста")
конст { е имейл } = изискват(„валидатор“)
е имейл е функция за валидиране, която връща вярно ако даден низ е имейл. Ще ви трябва, за да приложите мангуста валидиране към вашия потребителски модел.
След това добавете следния код към вашия userModel файл:
// модели/userModel
конст userSchema = mongoose. Схема ({
електронна поща: {
Тип: низ,
задължително: [вярно, 'Изисква се имейл'],
валидиране: {
валидатор: isEmail,
съобщение: props => `${props.value} не е валиден имейл`
}
},парола: {
Тип: низ,
задължително: [вярно, 'изисква се парола'],
валидиране: {
валидатор: функция (стойност) {
връщане стойност.дължина >= 6
},
съобщение: () =>'Паролата трябва да е с дължина поне шест знака'
}
}
})
модул.износ = mongoose.model('Потребител', потребителска схема)
Кодът по-горе създава a userSchema променлива, която съхранява стойността на мангуста. Схема метод. Мангустата. Методът Schema картографира свойства към колекция MongoDB и дефинира формата на документите в нея. Схемата mongoose има две свойства - an електронна поща и а парола— което ще бъде вашите изисквания за удостоверяване.
Свойството имейл е тип низ и има изисква се зададено на true. Придружаващото съобщение за грешка „Изисква се имейл“ ще се покаже, ако тялото на заявката не съдържа електронна поща Имот. И накрая, използвайки персонализирано валидиране на mongoose, валидатор собственост refenes на е имейл функция. Тази функция връща true или false въз основа на валидността на низа като имейл. Тогава свойството съобщение приема стойността на имейла (реквизит) и създава смислено съобщение за грешка.
Свойството парола е задължителен тип низ със съобщение за грешка, което гласи „Изисква се парола“. The валидатор функцията е анонимна, която връща true, ако паролата е дълга поне шест знака.
Последният ред създава и експортира мангуст модел чрез извикване на модел метод на мангуста. Предайте името на модела (Потребител) като първи аргумент и схема (userSchema) като втори аргумент.
Стъпка 4: Внедряване на маршрути за влизане и регистрация
В главната директория на вашия проект създайте a маршрути папка:
mkdir маршрути
Във вашата папка с маршрути създайте a userRoutes.js файл и добавете следните импортирания:
// маршрути/userRoutes.js
конст експрес = изискват("експресен");
конст Потребител = изискват("../models/userModel");
конст bcrypt = изискват("bcrypt");
Създайте екземпляр на Express Router, като извикате Рутер метод на експресен:
конст рутер = експрес. Рутер();
След това създайте своя маршрут за регистрация, като добавите кодовия блок по-долу към вашия userRoute.js файл:
router.post("/sign-up", async (req, res) => {
опитвам {
// Извличане на имейл и парола от обекта req.body
конст { имейл, парола } = req.body;// Проверетеако имейлът е вече визползване
позволявам userExists = изчакайте User.findOne({имейл});if (userExists) {
res.status(401).json({ съобщение: „Имейлът вече е в използване." });
връщане;
}// Дефиниране на солени кръгове
конст сол кръгове = 10;// Хеш парола
bcrypt.hash (парола, saltRounds, (грешка, хеш) => {
ако (грешка) хвърлямновГрешка(„Вътрешен сървър Грешка");// Създавайте а новпотребител
позволявам потребител = нов потребител ({
електронна поща,
парола: хеш,
});
// Запазване на потребител в база данни
user.save().then(() => {
res.json({ съобщение: "Потребителят е създаден успешно", потребител });
});
});
} улов (грешка) {
връщанерез.състояние(401).изпрати(грешка.съобщение);
}
});
В кодовия блок по-горе първо сте деструктурирали имейла и паролата от req.body обект. След това проверете дали даден потребител вече използва имейла, защото той трябва да е уникален за всеки потребител. Ако имейлът вече е бил използван, вие се връщате и спирате изпълнението на кода с код за състояние 401.
Съхраняването на обикновени пароли в база данни е огромна заплаха за сигурността, тъй като злонамерени хакери могат да получат достъп до базата данни. Трябва да хеширате паролите, преди да ги сортирате във вашата база данни, така че дори ако хакер ги открие, не трябва да има риск за потребителите. Хеширането е процес на преобразуване на даден „ключ“ в друга стойност. Хеширането е еднопосочна функция, което означава, че не можете да извлечете оригиналната стойност от хешираната, за разлика от криптирането.
Използвайки bcrypt, вие хеширате вашата потребителска парола, като извикате хеш метода на bcrypt. Методът за хеширане приема три параметъра: низът за хеширане, солени кръгове и функция за обратно извикване. Подавате потребителската парола, променливата saltRounds, която сте създали по-рано, и обратно извикване.
Солените кръгове се отнасят до времето, необходимо за изчисляване на един bcrypt хеш. Колкото по-високи са кръговете сол, толкова повече са кръговете за хеширане.
Ако хеш методът хвърля грешка, вие хвърляте „вътрешна сървърна грешка“. В противен случай задавате свойството за парола на успешния хеш и го запазвате във вашата база данни, като извиквате метода за запазване на Потребител инстанция.
След това създайте своя маршрут за влизане, като добавите кодовия блок по-долу към вашия userRoute.js файл:
router.post("/sign-in", async (req, res) => {
опитвам {
// Извличане на имейл и парола от обекта req.body
конст { имейл, парола } = req.body;// Проверетеакопотребителсъществувавбаза данни
позволявам потребител = изчакайте User.findOne({имейл});if (!user) {
върне res.status (401).json({ съобщение: "Невалидни идентификационни данни" });
}// Сравнете паролите
bcrypt.compare (парола, потребителска.парола, (грешка, резултат) => {
ако (резултат) {
върне res.status (200).json({ съобщение: "Потребителят е влязъл успешно" });
}конзола.log (грешка);
върне res.status (401).json({ съобщение: "Невалидни идентификационни данни" });
});
} улов (грешка) {
рез.състояние(401).изпрати(грешка.съобщение);
}
});
модул.износ = рутер;
В кодовия блок по-горе първо деструктурирате имейла и паролата от req.body обект. След това проверявате дали съществува потребител във вашата база данни. Ако потребителят не съществува във вашата база данни, вие се връщате с код за състояние 401.
След това, използвайки метода за сравнение на bcrypt, предайте паролата, предоставена от потребителя, и хешираната парола, която сте извлекли от вашата база данни. Сравнете двете, за да потвърдите дали съвпадат. Ако паролите съвпадат, вие връщате код за състояние 200 и съобщение за успех. В противен случай връщате код за състояние 401 и съобщение за грешка.
И накрая, импортирайте рутер във вашия app.js файл и го използвайте като междинен софтуер на ниво приложение.
Това завършва вашия модел за удостоверяване на потребителя; сега потребителите могат безопасно да се регистрират и да влязат във вашето приложение.
Значението на удостоверяването на потребителя
Удостоверяването на потребителя гарантира, че само легитимни потребители могат да получат достъп до вашето приложение. Ако вашите данни са по някакъв начин лични или частни, трябва да предприемете стъпки, за да предотвратите достъпа на неавтентифицирани потребители.
