Lietotāja autentifikācija ir tāda lietotāja identitātes verifikācijas process, kurš mēģina piekļūt jūsu lietojumprogrammai. Tas ietver akreditācijas datu autorizāciju un pārsūtīšanu, lai apstiprinātu lietotāja autentiskumu.
Varat ieviest vienkāršu lietotāja autentifikācijas modeli pakalpojumā Node.js, izmantojot Express, Bcrypt un MongoDB, veicot tikai dažas darbības.
1. darbība: izstrādes vides iestatīšana
Vispirms izveidojiet projekta mapi un cd tajā, palaižot:
mkdir lietotāja autentifikācija
cd lietotāja autentifikācija
Pēc tam inicializējiet npm savā projekta direktorijā, izpildot:
npm init -y
The -y karodziņš inicializē npm un izveido jūsu pack.json failu ar visiem tā noklusējuma iestatījumiem.
Šim lietotāja autentifikācijas modelim ir nepieciešamas dažas atkarības.
Tajos ietilpst:
- Express: Express ir Node.js ietvars kas nodrošina spēcīgu funkciju kopumu tīmekļa un mobilajām lietojumprogrammām. Tas atvieglo aizmugursistēmas lietojumprogrammu izveidi, izmantojot Node.js.
- Bcrypt: bcrypt ir npm pakotne, kas ievieš bcrypt paroles jaukšanas funkciju. Tas ļauj izveidot jaucējus no vienkāršām paroļu virknēm.
- Mongoose: Mongoose ir MongoDB objektu datu modelēšanas bibliotēka. Tas vienkāršo mijiedarbību starp jūsu lietotni un MongoDB datu bāzi.
- dotenv: dotenv ir nulles atkarības pakotne, kas ielādē vides mainīgos no a .env failu process.env.
- Validators: validators ir pakotne, kas satur dažādas virknes validācijas funkcijas.
- Ķermeņa parsētājs: pamatteksta parsētāja pakotne parsē starpprogrammatūras pieprasījumu pamattekstus pirms apstrādātājiem.
Instalējiet pakotnes, izpildot:
npm uzstādīt express bcrypt mongoose dotenv validators ķermenis-parsētājs
Pēc tam izveidojiet an app.js failu sava projekta saknes direktorijā un pievienojiet tālāk esošo koda bloku, lai izveidotu pamata Express serveri:
// app.js
konst izteikt = pieprasīt('izteikt');
konst lietotne = express();
konst bodyParser = pieprasīt("ķermeņa parsētājs");konst ports = 3000;
lietotne.izmantot(bodyParser.json());
lietotne.izmantot(bodyParser.urlencoded({ pagarināts: taisnība }));
app.listen (port, ()=>{
konsole.log(`Lietotne klausās portā ${port}`);
});
Šis kods izveido ātrās lietojumprogrammas gadījumu, izsaucot ekspresfunkciju. Pēc tam tas izmanto ķermeņa parsētājs starpprogrammatūra ienākošo pieprasījumu struktūru parsēšanai. Pēc tam tas sāk klausīties trafiku portā 3000, izsaucot ātrās instances klausīšanās metodi un nododot porta mainīgo kā argumentu.
2. darbība: lietojumprogrammas savienošana ar datu bāzi
Sava projekta saknes direktorijā izveidojiet a .env failu un saglabājiet tajā savus MongoDB akreditācijas datus. Tas ļauj izvairīties no datu bāzes akreditācijas datu atklāšanas kodā, kas var nodrošināt ļaunprātīgiem lietotājiem piekļuvi jūsu datubāzei.
Pēc tam pārejiet uz savu app.js failu un importēt mangustu:
konst mangusts = pieprasīt("mangusts");
Pēc tam zvaniet importēšanai dotenv un zvaniet uz konfigurācija metode par to:
prasīt ("dotenv").config();
Zvanot uz konfigurācija metode ieslēgta dotenv ielādē vides mainīgos lielumus process.env.
Visbeidzot, ieslēdziet savienojuma metodi mangusts un nododiet savu MongoDB URI kā argumentu:
mongoose.connect (process.env. MONGODB_URI).tad(() => {
console.log('Savienojums ar datu bāzi ir veiksmīgi izveidots')
})
3. darbība: lietotāja modeļa izveide
Sava projekta saknes direktorijā izveidojiet "modeļiem” mape; šeit jūs glabāsit savu mangustu modeli:
mkdir modeļi
Pēc tam izveidojiet "userModel” failu un pievienojiet šādu importēšanu:
konst mangusts = pieprasīt("mangusts")
konst { isEmail } = pieprasīt('validators')
isEmail ir validācijas funkcija, kas atgriež taisnība ja dotā virkne ir e-pasts. Tas būs nepieciešams, lai savam lietotāja modelim lietotu mongoose validāciju.
Pēc tam pievienojiet tālāk norādīto kodu savam userModel fails:
// modeļi/lietotājaModelis
konst userSchema = mangusts. Shēma({
e-pasts: {
veids: Stīga,
nepieciešams: [taisnība, 'Nepieciešams e-pasts'],
apstiprināt: {
validators: isEmail,
ziņa: rekvizīti => `${props.value} nav derīgs e-pasts”.
}
},parole: {
veids: Stīga,
nepieciešams: [taisnība, 'nepieciešama parole'],
apstiprināt: {
pārbaudītājs: funkciju (vērtību) {
atgriezties vērtība.garums >= 6
},
ziņa: () =>'Parolei jābūt vismaz sešām rakstzīmēm garai'
}
}
})
modulis.eksportu = mongoose.model('Lietotājs', userSchema)
Iepriekš minētais kods izveido a lietotāju shēma mainīgais, kas saglabā vērtību mangusts. Shēma metodi. Mangusts. Shēmas metode kartē rekvizītus MongoDB kolekcijā un nosaka tajā esošo dokumentu formu. Mangusa shēmai ir divas īpašības — an e-pasts un a parole— kas būs jūsu autentifikācijas prasības.
E-pasta rekvizīts ir virknes veids, un tam ir nepieciešams iestatīt uz patiesu. Ja pieprasījuma pamattekstā nav ietverts, tiks parādīts pievienotais kļūdas ziņojums “Ir nepieciešams e-pasts”. e-pasts īpašums. Visbeidzot, izmantojot mongoose pielāgoto validāciju, validators īpašuma referenti isEmail funkciju. Šī funkcija atgriež patiesu vai nepatiesu, pamatojoties uz virknes kā e-pasta derīgumu. Pēc tam ziņojuma rekvizīts ņem e-pasta vērtību (rekvizīti) un izveido nozīmīgu kļūdas ziņojumu.
Paroles rekvizīts ir obligāts virknes veids ar kļūdas ziņojumu “Nepieciešama parole”. The validators funkcija ir anonīma, kas atgriež patiesu, ja parole ir vismaz sešas rakstzīmes gara.
Pēdējā rinda izveido un eksportē mangustu modeli, izsaucot modelis metode ieslēgta mangusts. Nododiet modeļa nosaukumu (Lietotājs) kā pirmo argumentu un shēmu (lietotāju shēma) kā otro argumentu.
4. darbība. Pierakstīšanās un reģistrēšanās maršrutu ieviešana
Sava projekta saknes direktorijā izveidojiet a maršrutos mape:
mkdir maršruti
Maršrutu mapē izveidojiet a userRoutes.js failu un pievienojiet šādu importēšanu:
// routes/userRoutes.js
konst izteikt = pieprasīt("izteikt");
konst Lietotājs = pieprasīt(../models/userModel");
konst bcrypt = pieprasīt("bcrypt");
Izveidojiet Express Router gadījumu, zvanot uz Maršrutētājs metode ieslēgta izteikt:
konst maršrutētājs = ekspress. Maršrutētājs ();
Pēc tam izveidojiet savu reģistrēšanās maršrutu, pievienojot tālāk norādīto kodu bloku userRoute.js fails:
router.post("/sign-up", async (req, res) => {
mēģināt {
// Izņemiet e-pastu un paroli no objekta req.body
konst {e-pasts, parole} = req.body;// Pārbaudietja e-pasts ir jau iekšāizmantot
ļaut userExists = gaidīt User.findOne({ e-pasts });if (userExists) {
res.status(401).json({ message: "E-pasts jau ir ievadīts izmantot.&citāts; });
atgriezties;
}// Definējiet sāls kārtas
konst sālsApaļi = 10;// Jauktā parole
bcrypt.hash (parole, saltRounds, (err, hash) => {
ja (kļūda) mestjaunsKļūda("Iekšējais serveris Kļūda");// Izveidot a jaunslietotājs
ļaut lietotājs = jauns Lietotājs({
e-pasts,
parole: hash,
});
// Saglabāt lietotāju datu bāzē
lietotājs.save().tad(() => {
res.json({ ziņojums: "Lietotājs ir veiksmīgi izveidots", lietotājs });
});
});
} noķert (kļūda) {
atgrieztiesres.statuss(401).nosūtīt(kļūda.ziņa);
}
});
Iepriekš minētajā koda blokā, pirmkārt, jūs destrukturējāt e-pasta adresi un paroli no req.body objektu. Pēc tam pārbaudiet, vai lietotājs jau izmanto e-pastu, jo tam ir jābūt unikālam katram lietotājam. Ja e-pasts jau ir izmantots, jūs atgriežat un pārtraucat koda izpildi ar statusa kodu 401.
Vienkāršu paroļu glabāšana datu bāzē ir milzīgs drošības apdraudējums, jo ļaunprātīgi hakeri var piekļūt datu bāzei. Pirms paroles ievietošanas datu bāzē tās ir jāsajauc, tāpēc pat tad, ja hakeris tās atklāj, nevajadzētu radīt risku lietotājiem. Jaukšana ir process, kurā dotā “atslēga” tiek pārvērsta citā vērtībā. Jaukšana ir vienvirziena funkcija, kas nozīmē, ka atšķirībā no šifrēšanas jūs nevarat izgūt sākotnējo vērtību no jauktās vērtības.
Izmantojot bcrypt, jūs veicat jaukšanu jūsu lietotāja paroli, izsaucot jaucējmetodi vietnē bcrypt. Jaukšanas metodei ir nepieciešami trīs parametri: jauktā virkne, sāls kārtas un atzvanīšanas funkcija. Jūs nododat lietotāja paroli, iepriekš izveidoto mainīgo saltRounds un atzvanīšanu.
Sāls kārtas attiecas uz laiku, kas nepieciešams, lai aprēķinātu vienu bcrypt hash. Jo augstākas ir sāls kārtas, jo vairāk ir jaukšanas kārtas.
Ja jaukšanas metode rada kļūdu, tiek parādīta “iekšēja servera kļūda”. Pretējā gadījumā jūs iestatāt paroles rekvizītu uz veiksmīgo jaukšanu un saglabājat to savā datu bāzē, izsaucot saglabāšanas metodi Lietotājs piemēram.
Pēc tam izveidojiet pierakstīšanās maršrutu, pievienojot tālāk norādīto kodu bloku userRoute.js fails:
router.post("/sign-in", async (req, res) => {
mēģināt {
// Izņemiet e-pastu un paroli no objekta req.body
konst {e-pasts, parole} = req.body;// Pārbaudietjalietotājspastāviekšādatu bāze
ļaut lietotājs = gaidīt User.findOne({ e-pasts });if (!lietotājs) {
atgriezt res.status (401).json({ ziņojums: "Nederīgi akreditācijas dati" });
}// Salīdziniet paroles
bcrypt.compare (parole, user.password, (err, result) => {
if (rezultāts) {
atgriezt res.status (200).json({ ziņojums: "Lietotājs veiksmīgi pieteicies" });
}konsole.log (err);
atgriezt res.status (401).json({ ziņojums: "Nederīgi akreditācijas dati" });
});
} noķert (kļūda) {
res.statuss(401).nosūtīt(kļūda.ziņa);
}
});
modulis.eksportu = maršrutētājs;
Iepriekš esošajā koda blokā vispirms destrukturējiet e-pastu un paroli no req.body objektu. Pēc tam pārbaudiet, vai jūsu datu bāzē pastāv lietotājs. Ja lietotājs jūsu datu bāzē nepastāv, jūs atgriežaties ar statusa kodu 401.
Pēc tam, izmantojot bcrypt salīdzināšanas metodi, ievadiet lietotāja norādīto paroli un jaukto paroli, ko izguvāt no savas datu bāzes. Salīdziniet abus, lai apstiprinātu, vai tie sakrīt. Ja paroles sakrīt, jūs atgriežat statusa kodu 200 un veiksmes ziņojumu. Pretējā gadījumā jūs atgriežat statusa kodu 401 un kļūdas ziņojumu.
Visbeidzot, importējiet maršrutētājs tavā app.js failu un izmantojiet to kā lietojumprogrammas līmeņa starpprogrammatūru.
Tas pabeidz jūsu lietotāja autentifikācijas modeli; tagad lietotāji var droši reģistrēties un pierakstīties jūsu lietojumprogrammā.
Lietotāja autentifikācijas nozīme
Lietotāju autentifikācija nodrošina, ka tikai likumīgi lietotāji var piekļūt jūsu lietojumprogrammai. Ja jūsu dati jebkādā veidā ir personiski vai privāti, jums jāveic pasākumi, lai novērstu neautentificētu lietotāju piekļuvi.
