Pošiljanje podatkov z enega kraja na drugega? Zaradi lastne brezskrbnosti in zaščite vaših uporabnikov ga zavarujte z JWT.

Ko gradite aplikacijo, je ključnega pomena, da zaščitite občutljive podatke pred nepooblaščenim dostopom. Veliko sodobnih spletnih, mobilnih in oblačnih aplikacij uporablja API-je REST kot primarno sredstvo komunikacije. Zato je ključnega pomena načrtovanje in razvoj zalednih API-jev z varnostjo v ospredju.

Eden od učinkovitih pristopov za zaščito API-ja REST vključuje spletne žetone JSON (JWT). Ti žetoni ponujajo robusten mehanizem za avtentikacijo in avtorizacijo uporabnikov, kar pomaga zaščititi zaščitene vire pred dostopom zlonamernih akterjev.

Kaj so spletni žetoni JSON?

Spletni žeton JSON (JWT) je široko uporabljen varnostni standard. Zagotavlja jedrnato, samozadostno metodo varnega prenosa podatkov med odjemalsko aplikacijo in zalednim sistemom.

API REST lahko uporablja JWT za varno identifikacijo in avtentikacijo uporabnikov, ko vložijo zahteve HTTP za dostop do zaščitenih virov.

instagram viewer

Spletni žeton JSON je sestavljen iz treh različnih delov: glave, koristnega tovora in podpisa. Kodira vsak del in ga poveže s piko (".").

Glava opisuje kriptografski algoritem, ki se uporablja za podpisovanje žetona, medtem ko vsebina vsebuje podatke o uporabniku in vse dodatne metapodatke.

Nazadnje, podpis, izračunan z uporabo glave, tovora in tajnega ključa, zagotavlja celovitost in pristnost žetona.

Ko smo se naučili osnov JWT, zgradimo Node.js REST API in implementirajmo JWT.

Nastavite aplikacijo Express.js in zbirko podatkov MongoDB

Tukaj boste izvedeli, kako zgraditi preprosto avtentikacijo REST API ki obravnava tako funkcijo registracije kot prijave. Ko postopek prijave potrdi pristnost uporabnika, bi moral biti sposoben pošiljati zahteve HTTP na zaščiteno pot API.

Tukaj lahko najdete kodo projekta Repozitorij GitHub.

Za začetek, ustvarite spletni strežnik Expressin namestite te pakete:

npm namestite cors dotenv bycrpt mongoose razčlenjevalnik piškotkov kripto jsonwebtoken mongodb

Naslednji, ustvarite bazo podatkov MongoDB oz konfigurirajte gručo MongoDB v oblaku. Nato kopirajte povezovalni niz baze podatkov, ustvarite a .env datoteko v korenskem imeniku in prilepite povezovalni niz:

CONNECTION_STRING="povezavni niz"

Konfigurirajte povezavo z bazo podatkov

Ustvari novo utils/db.js datoteko v korenskem imeniku mape vašega projekta. V to datoteko dodajte naslednjo kodo za vzpostavitev povezave z bazo podatkov z uporabo Mongoose.

konst mungos = zahtevati('mungos');
konst povežiDB = asinh () => {
poskusi {
čakati mongoose.connect (process.env. CONNECTION_STRING);
konzola.log("Povezan z MongoDB!");
 } ulov (napaka) {
konzola.napaka("Napaka pri povezovanju z MongoDB:", napaka);
 }
};
modul.exports = connectDB;

Definirajte podatkovni model

Definirajte preprosto shemo uporabniških podatkov z uporabo Mongoose. V korenskem imeniku ustvarite nov model/user.model.js datoteko in dodajte naslednjo kodo.

konst mungos = zahtevati('mungos');
konst uporabniška shema = novo mungos. Shema({
 uporabniško ime: Vrvica,
 geslo: {
 vrsta: Vrvica,
 obvezno: prav,
 edinstveno: prav,
 },
});
konst Uporabnik = mongoose.model("Uporabnik", uporabniška shema);
modul.exports = uporabnik;

Določite krmilnike za poti API-ja

Funkcije krmilnika bodo upravljale registracijo in prijavo; so pomemben del tega vzorčnega programa. V korenskem imeniku ustvarite a krmilniki/userControllers.js datoteko in dodajte naslednjo kodo:

  1. Določite krmilnik registracije uporabnikov.
    konst Uporabnik = zahtevati('../models/user.model');
    konst bcrypt = zahtevati('bcrypt');
    konst {generiraj žeton} = zahtevati('../middleware/auth');
    exports.registerUser = asinh (req, res) => {
    konst { uporabniško ime, geslo } = req.body;
    poskusi {
    konst hash = čakati bcrypt.hash (geslo, 10); 
    čakati User.create({ uporabniško ime, geslo: hash });
     res.status(201).pošlji({ sporočilo: 'Uporabnik je uspešno registriran' });
     } ulov (napaka) {
    konzola.log (napaka);
     res.status(500).pošlji({ sporočilo: 'Pojavila se je napaka!! ' });
     }
    };
    Ta delček kode zgosti podano geslo z uporabo bcrypt in nato ustvari nov uporabniški zapis v bazi podatkov, ki shrani uporabniško ime in zgoščeno geslo. Če je registracija uspešna, pošlje odgovor s sporočilom o uspehu.
  2. Definirajte prijavni krmilnik za upravljanje postopka prijave uporabnika:
    exports.loginUser = asinh (req, res) => {
    konst { uporabniško ime, geslo } = req.body;
    poskusi {
    konst uporabnik = čakati User.findOne({uporabniško ime});

    če (!uporabnik) {
    vrnitev res.status(404).pošlji({ sporočilo: 'Uporabnik ni najden' });
     }
    

    konst PasswordMatch = čakati bcrypt.compare (geslo, uporabniško.geslo);
    

    če (!passwordMatch) {
    vrnitev res.status(401).pošlji({ sporočilo: 'Neveljavne poverilnice za prijavo' });
     }
    konst nosilnost = { Uporabniško ime: Uporabniško ime };
    konst žeton = generiraj žeton (tovor);
     res.piškotek('žeton', žeton, { Samo http: prav });
     res.status(200).json({ sporočilo: 'Prijava uspešna'});
     } ulov (napaka) {
    konzola.log (napaka);
     res.status(500).pošlji({ sporočilo: 'Pri prijavi je prišlo do napake' });
     }
    };
    Ko uporabnik pošlje zahtevo na /login poti, morajo posredovati svoje poverilnice za preverjanje pristnosti v telesu zahteve. Koda nato preveri te poverilnice in ustvari spletni žeton JSON. Žeton je varno shranjen v piškotku z Samo http zastavica nastavljena na true. To preprečuje JavaScriptu na strani odjemalca dostop do žetona in ščiti pred morebitnimi napadi s skriptnim izvajanjem na več mestih (XSS).
  3. Na koncu določite zaščiteno pot:
    exports.getUsers = asinh (req, res) => {
    poskusi {
    konst uporabniki = čakati User.find({});
     res.json (uporabniki);
     } ulov (napaka) {
    konzola.log (napaka);
     res.status(500).pošlji({ sporočilo: 'Pojavila se je napaka!!' });
     }
    };
    S shranjevanjem JWT v piškotek bodo naslednje zahteve API-ja od overjenega uporabnika samodejno vključevale žeton, kar bo strežniku omogočilo preverjanje in avtorizacijo zahtev.

Ustvarite vmesno programsko opremo za preverjanje pristnosti

Zdaj, ko ste definirali krmilnik za prijavo, ki generira žeton JWT po uspešnem preverjanju pristnosti, definirajte funkcije preverjanja pristnosti vmesne programske opreme, ki bodo generirale in preverjale žeton JWT.

V korenskem imeniku ustvarite novo mapo, vmesna programska oprema. V to mapo dodajte dve datoteki: auth.js in config.js.

Dodajte to kodo v config.js:

konst kripto = zahtevati('crypto');
modul.exports = {
 secretKey: crypto.randomBytes(32).toString('hex')
};

Ta koda ustvari nov naključni skrivni ključ ob vsakem zagonu. Nato lahko s tem skrivnim ključem podpišete in preverite pristnost JWT-jev. Ko je uporabnik uspešno overjen, ustvarite in podpišite JWT s skrivnim ključem. Strežnik bo nato s ključem preveril, ali je JWT veljaven.

Dodajte naslednjo kodo auth.js ki definira funkcije vmesne programske opreme, ki ustvarjajo in preverjajo JWT.

konst jwt = zahtevati('jsonwebtoken');
konst {tajniKey} = zahtevati('./config');
konst generiraj žeton = (tovor) => {
konst žeton = jwt.sign (payload, secretKey, { poteče: '1h' });
vrnitev žeton ;
};


konst verifyToken = (req, res, next) => {
konst žeton = req.cookies.token;


če (!žeton) {
vrnitev res.status(401).json({ sporočilo: 'Žeton ni na voljo' });
 }


 jwt.verify (žeton, skrivni ključ, (napaka, dekodirano) => {
če (napaka) {
vrnitev res.status(401).json({ sporočilo: 'Neveljaven žeton' });
 }


 req.userId = decoded.userId;
 Naslednji();
 }); 
};
modul.exports = {generateToken, verifyToken};

The generateToken funkcija ustvari JWT tako, da podpiše tovor s skrivnim ključem in nastavi čas poteka, medtem ko verifyToken služi kot vmesna programska oprema za preverjanje pristnosti in veljavnosti podanega žetona.

Določite poti API-ja

Ustvari novo routes/userRoutes.js datoteko v korenskem imeniku in dodajte naslednjo kodo.

konst izraziti = zahtevati('express');
konst usmerjevalnik = express. Usmerjevalnik();
konst uporabniški krmilniki = zahtevati('../controllers/userControllers');
konst {verifyToken} = zahtevati('../middleware/auth');
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);
router.get('/api/uporabniki', verifyToken, userControllers.getUsers);
modul.exports = usmerjevalnik;

Posodobite svojo vstopno točko strežnika

Posodobite svoje server.js datoteko z naslednjo kodo.

konst izraziti = zahtevati('express');
konst cors = zahtevati('cors');
konst app = express();
konst pristanišče = 5000;
zahtevati('dotenv').config();
konst povežiDB = zahtevati('./utils/db');
konst piškotekParser = zahtevati('razčlenjevalnik piškotkov');
povežiDB();


app.use (express.json());
app.use (express.urlencoded({ podaljšan: prav }));
app.use (cors());
app.use (cookieParser());
konst userRoutes = zahtevati('./routes/userRoutes');
app.use('/', uporabniške poti);
app.listen (vrata, () => {
konzola.log(`Strežnik posluša http://localhost:${port}`);
});

Če želite preizkusiti REST API, zavrtite razvojni strežnik in naredite zahteve API-ja do definiranih končnih točk:

strežnik vozlišča.js

Varovanje API-jev REST Node.js

Zaščita API-jev REST Node.js presega le uporabo JWT-jev, čeprav igrajo ključno vlogo pri preverjanju pristnosti in pooblastila, je bistvenega pomena, da sprejmete celovit varnostni pristop k varnosti, da zaščitite svoje zaledje sistemi. Poleg JWT bi morali razmisliti tudi o uvedbi HTTPS za šifriranje komunikacije, preverjanje veljavnosti vnosa in sanacijo ter mnoge druge.

S kombiniranjem več varnostnih ukrepov lahko vzpostavite robusten varnostni okvir za vašo API-ji REST Node.js in zmanjšajte tveganje nepooblaščenega dostopa, kršitev podatkov in druge varnosti grožnje.