Preverjanje pristnosti uporabnika je postopek preverjanja identitete uporabnika, ki poskuša pridobiti dostop do vaše aplikacije. Vključuje avtorizacijo in prenos poverilnic za potrditev pristnosti uporabnika.
Preprost model avtentikacije uporabnika lahko implementirate v Node.js z uporabo Express, Bcrypt in MongoDB v le nekaj korakih.
1. korak: Nastavitev razvojnega okolja
Najprej ustvarite mapo projekta in cd vanj tako, da zaženete:
mkdir preverjanje pristnosti uporabnika
cd avtentikacija uporabnika
Nato inicializirajte npm v imeniku vašega projekta tako, da zaženete:
npm init -y
The -y zastavica inicializira npm in ustvari vaš package.json datoteko z vsemi privzetimi vrednostmi.
Ta model preverjanja pristnosti uporabnika zahteva nekaj odvisnosti.
Vključujejo:
- Express: Express je ogrodje Node.js ki zagotavlja robusten nabor funkcij za spletne in mobilne aplikacije. Omogoča lažjo gradnjo zalednih aplikacij z Node.js.
- Bcrypt: bcrypt je paket npm, ki izvaja funkcijo zgoščevanja gesel bcrypt. Omogoča ustvarjanje zgoščenih vrednosti iz navadnih nizov gesel.
- Mongoose: Mongoose je knjižnica za modeliranje objektnih podatkov MongoDB. Poenostavi interakcijo med vašo aplikacijo in bazo podatkov MongoDB.
- dotenv: dotenv je paket ničelne odvisnosti, ki naloži spremenljivke okolja iz a .env datoteko v proces.env.
- Validator: validator je paket, ki vsebuje različne funkcije za preverjanje nizov.
- Body-parser: Paket body-parser razčleni telesa zahtev v vmesni programski opremi pred vašimi obdelovalci.
Namestite pakete tako, da zaženete:
npm namestite express bcrypt mongoose dotenv validator telo-razčlenjevalnik
Nato ustvarite app.js datoteko v korenskem imeniku vašega projekta in dodajte spodnji blok kode, da ustvarite osnovni strežnik Express:
// app.js
konst izraziti = zahtevati('hitro');
konst app = express();
konst bodyParser = zahtevati("razčlenjevalnik telesa");konst pristanišče = 3000;
aplikacijauporaba(bodyParser.json());
aplikacija.uporaba(bodyParser.urlencoded({ podaljšan: prav }));
app.listen (vrata, ()=>{
konzola.log(`Aplikacija posluša vrata ${port}`);
});
Ta koda ustvari ekspresni primerek aplikacije s klicem ekspresne funkcije. Nato uporabi razčlenjevalnik telesa vmesna programska oprema za razčlenjevanje teles dohodnih zahtev. Nato začne poslušati promet na vratih 3000 tako, da pokliče metodo poslušanja hitre instance in posreduje spremenljivko vrata kot argument.
2. korak: Povezovanje aplikacije z zbirko podatkov
V korenskem imeniku vašega projekta ustvarite a .env datoteko in vanjo shranite svoje poverilnice MongoDB. S tem se izognete razkrivanju poverilnic baze podatkov v kodi, ki lahko zlonamernim uporabnikom omogoči dostop do vaše baze podatkov.
Nato se pomaknite do svojega app.js datoteko in uvoz mongoose:
konst mungos = zahtevati("mungos");
Nato pokličite uvoz dotenv in pokličite konfiguracija metoda na njem:
zahtevaj("dotenv").config();
Klicanje konfiguracija metoda na dotenv naloži okoljske spremenljivke v proces.env.
Končno pokličite metodo povezovanja mungos in posredujte svoj MongoDB URI kot argument:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Povezava z zbirko podatkov uspešno')
})
3. korak: Ustvarjanje uporabniškega modela
V korenskem imeniku projekta ustvarite »modeli” mapa; tukaj boste shranili svoj model mungosa:
modeli mkdir
Nato ustvarite »userModel” in dodajte naslednje uvoze:
konst mungos = zahtevati('mungos')
konst { isEmail } = zahtevati('validator')
isEmail je validacijska funkcija, ki vrne prav če je dani niz e-poštno sporočilo. Potrebovali ga boste za uporabo validacije mongoose za vaš uporabniški model.
Nato svoji kodi dodajte naslednjo kodo userModel mapa:
// modeli/userModel
konst userSchema = mongoose. Shema({
E-naslov: {
vrsta: Vrvica,
obvezno: [true, 'E-pošta je obvezna'],
potrdi: {
validator: isEmail,
sporočilo: props => `${props.value} ni veljaven e-poštni naslov`
}
},geslo: {
vrsta: Vrvica,
obvezno: [true, 'zahtevano je geslo'],
potrdi: {
validator: funkcijo (vrednost) {
vrnitev vrednost.dolžina >= 6
},
sporočilo: () =>'Geslo mora biti dolgo vsaj šest znakov'
}
}
})
modul.izvoz = mongoose.model('Uporabnik', uporabniška shema)
Zgornja koda ustvari a userSchema spremenljivka, ki hrani vrednost mungos. Shema metoda. mungos. Metoda sheme preslika lastnosti v zbirko MongoDB in definira obliko dokumentov v njej. Shema mongoose ima dve lastnosti – an E-naslov in a geslo— kar bodo vaše zahteve za preverjanje pristnosti.
Lastnost e-pošte je vrsta niza in ima potrebno nastavljen na true. Spremno sporočilo o napaki »Potrebna je e-pošta« se prikaže, če telo zahteve ne vsebuje E-naslov premoženje. Končno, z uporabo validacije po meri Mongoose, je validator lastnina referenes the isEmail funkcijo. Ta funkcija vrne true ali false glede na veljavnost niza kot e-pošte. Nato lastnost sporočila prevzame e-poštno vrednost (rekviziti) in ustvari smiselno sporočilo o napaki.
Lastnost gesla je obvezna vrsta niza s sporočilom o napaki, ki se glasi »Zahtevano je geslo«. The validator funkcija je anonimna, ki vrne true, če je geslo dolgo vsaj šest znakov.
Zadnja vrstica ustvari in izvozi model mongoose s klicem model metoda na mungos. Posredujte ime modela (Uporabnik) kot prvi argument in shema (userSchema) kot drugi argument.
4. korak: Implementacija poti za prijavo in prijavo
V korenskem imeniku vašega projekta ustvarite a poti mapa:
poti mkdir
V vaši mapi poti ustvarite a userRoutes.js datoteko in dodajte naslednje uvoze:
// routes/userRoutes.js
konst izraziti = zahtevati("hitro");
konst Uporabnik = zahtevati("../modeli/userModel");
konst bcrypt = zahtevati("bcrypt");
Ustvarite primerek Express Router tako, da pokličete Usmerjevalnik metoda na ekspresno:
konst usmerjevalnik = express. Usmerjevalnik();
Nato ustvarite svojo prijavno pot tako, da svojemu dodate spodnji kodni blok userRoute.js mapa:
router.post("/sign-up", async (req, res) => {
poskusi {
// Ekstrahiraj e-pošto in geslo iz objekta req.body
konst { email, password } = req.body;// Preveriteče e-pošta je že vuporaba
pustiti uporabnikObstaja = čakati User.findOne({ email });if (userExists) {
res.status(401).json({ sporočilo: "E-pošta je že v uporaba." });
vrnitev;
}// Definiraj solne kroge
konst solne kroge = 10;// Zgoščeno geslo
bcrypt.hash (geslo, saltRounds, (napaka, hash) => {
če (napaka) metatinovoNapaka("Notranji strežnik Napaka");// Ustvari a novouporabnik
pustiti uporabnik = novo Uporabnik ({
E-naslov,
geslo: hash,
});
// Shrani uporabnika v bazo podatkov
uporabnik.save().then(() => {
res.json({ sporočilo: "Uporabnik je bil uspešno ustvarjen", uporabnik });
});
});
} ulov (napaka) {
vrnitevres.stanje(401).pošlji(napaka.sporočilo);
}
});
V zgornjem bloku kode ste najprej destrukturirali e-pošto in geslo iz req.body predmet. Nato preverite, ali uporabnik že uporablja e-pošto, ker mora biti edinstvena za vsakega uporabnika. Če je bil e-poštni naslov že uporabljen, se vrnete in zaustavite izvajanje kode s statusno kodo 401.
Shranjevanje navadnih gesel v zbirko podatkov je velika varnostna grožnja, saj lahko zlonamerni hekerji pridobijo dostop do baze podatkov. Gesla morate zgostiti, preden jih razvrstite v zbirko podatkov, tako da tudi če jih heker odkrije, ne bi smelo biti tveganja za uporabnike. Zgoščevanje je postopek pretvorbe danega "ključa" v drugo vrednost. Zgoščevanje je enosmerna funkcija, kar pomeni, da ne morete pridobiti izvirne vrednosti iz zgoščene, za razliko od šifriranja.
Z uporabo bcrypt ste razpršili svoje uporabniško geslo tako, da pokličete metodo hash na bcrypt. Metoda zgoščevanja zavzema tri parametre: niz, ki ga želite zgostiti, solne kroge in funkcijo povratnega klica. Posredujete uporabniško geslo, spremenljivko saltRounds, ki ste jo ustvarili prej, in povratni klic.
Salt runde se nanašajo na čas, ki je potreben za izračun posameznega zgoščevanja bcrypt. Višji kot so krogi soli, več je krogov zgoščevanja.
Če metoda zgoščevanja vrže napako, vržete »notranjo napako strežnika«. V nasprotnem primeru nastavite lastnost gesla na uspešno razpršitev in jo shranite v bazo podatkov s klicem metode shranjevanja na Uporabnik primerek.
Nato ustvarite svojo prijavno pot tako, da svojemu dodate spodnji kodni blok userRoute.js mapa:
router.post("/sign-in", async (req, res) => {
poskusi {
// Ekstrahiraj e-pošto in geslo iz objekta req.body
konst { email, password } = req.body;// Preveritečeuporabnikobstajavzbirka podatkov
pustiti uporabnik = čakati User.findOne({ email });if (!user) {
vrni res.status (401).json({ sporočilo: "Neveljavne poverilnice" });
}// Primerjaj gesla
bcrypt.compare (geslo, uporabniško.geslo, (napaka, rezultat) => {
če (rezultat) {
vrni res.status (200).json({ sporočilo: "Uporabnik se je uspešno prijavil" });
}konzola.log (napaka);
vrni res.status (401).json({ sporočilo: "Neveljavne poverilnice" });
});
} ulov (napaka) {
res.stanje(401).pošlji(napaka.sporočilo);
}
});
modul.izvoz = usmerjevalnik;
V zgornjem bloku kode najprej destrukturirate e-pošto in geslo iz req.body predmet. Nato preverite, ali uporabnik obstaja v vaši bazi podatkov. Če uporabnik ne obstaja v vaši bazi podatkov, se vrnete s statusno kodo 401.
Nato z metodo primerjave bcrypt posredujte geslo, ki ga je navedel uporabnik, in zgoščeno geslo, ki ste ga pridobili iz svoje baze podatkov. Primerjajte oba, da potrdite, ali se ujemata. Če se gesli ujemata, vrnete statusno kodo 200 in sporočilo o uspehu. V nasprotnem primeru vrnete statusno kodo 401 in sporočilo o napaki.
Končno, uvoz usmerjevalnik v tvoje app.js datoteko in jo uporabite kot vmesno programsko opremo na ravni aplikacije.
S tem je vaš model avtentikacije uporabnika zaključen; zdaj se lahko uporabniki varno prijavijo in prijavijo v vašo aplikacijo.
Pomen avtentikacije uporabnika
Preverjanje pristnosti uporabnika zagotavlja, da lahko samo zakoniti uporabniki dobijo dostop do vaše aplikacije. Če so vaši podatki na kakršen koli način osebni ali zasebni, morate ukrepati, da preprečite dostop nepreverjenim uporabnikom.
