Datan lähettäminen paikasta toiseen? Oman mielenrauhasi ja käyttäjiesi suojan vuoksi sinun tulee suojata se JWT: llä.

Kun rakennat sovellusta, on erittäin tärkeää suojata arkaluontoiset tiedot luvattomalta käytöltä. Monet nykyaikaiset verkko-, mobiili- ja pilvisovellukset käyttävät REST-sovellusliittymiä ensisijaisena viestintävälineenä. Tämän seurauksena on erittäin tärkeää suunnitella ja kehittää taustasovellusliittymiä, joiden turvallisuus on eturintamassa.

Eräs tehokas tapa suojata REST API: ta ovat JSON Web Tokens (JWT). Nämä tunnukset tarjoavat vankan mekanismin käyttäjien todennusta ja valtuutusta varten, mikä auttaa suojaamaan suojattuja resursseja haitallisten toimijoiden pääsyltä.

Mitä ovat JSON-verkkotunnukset?

JSON-verkkotunnus (JWT) on laajalti käytetty tietoturvastandardi. Se tarjoaa tiiviin, itsenäisen tavan siirtää tietoja turvallisesti asiakassovelluksen ja taustajärjestelmän välillä.

REST API voi käyttää JWT: itä tunnistamaan ja todentamaan käyttäjät turvallisesti, kun he tekevät HTTP-pyyntöjä päästäkseen suojattuihin resursseihin.

instagram viewer

JSON-verkkotunnus koostuu kolmesta erillisestä osasta: otsikosta, hyötykuormasta ja allekirjoituksesta. Se koodaa jokaisen osan ja ketjuttaa ne pisteellä (".").

Otsikko kuvaa salausalgoritmia, jota käytetään tunnuksen allekirjoittamiseen, kun taas hyötykuorma sisältää tietoja käyttäjästä ja mahdolliset muut metatiedot.

Lopuksi otsikon, hyötykuorman ja salaisen avaimen avulla laskettu allekirjoitus varmistaa tunnuksen eheyden ja aitouden.

Kun JWT: iden perusteet ovat poissa tieltä, rakennetaan Node.js REST API ja toteutetaan JWT: t.

Määritä Express.js-sovellus ja MongoDB-tietokanta

Täältä saat ohjeet yksinkertaisen todennuksen luomiseen REST API joka hoitaa sekä rekisteröinti- että kirjautumistoiminnot. Kun kirjautumisprosessi todentaa käyttäjän, hänen pitäisi pystyä tekemään HTTP-pyyntöjä suojatulle API-reitille.

Löydät projektin koodin tästä GitHub-arkisto.

Aloita luo Express-verkkopalvelinja asenna nämä paketit:

npm asennus cors dotenv bycrpt mongoose cookie-parser krypto jsonwebtoken mongodb

Seuraava, luo MongoDB-tietokanta tai määritä MongoDB-klusteri pilveen. Kopioi sitten tietokantayhteysmerkkijono ja luo a .env tiedosto juurihakemistoon ja liitä yhteysmerkkijonoon:

CONNECTION_STRING="yhteysmerkkijono"

Määritä tietokantayhteys

Luoda uusi utils/db.js tiedosto projektikansiosi juurihakemistossa. Lisää tähän tiedostoon seuraava koodi luodaksesi tietokantayhteyden Mongoosen avulla.

konst mangusti = vaatia('mungo');
konst connectDB = asynk () => {
yrittää {
odottaa mongoose.connect (process.env. CONNECTION_STRING);
konsoli.Hirsi("Yhdistetty MongoDB: hen!");
 } ottaa kiinni (virhe) {
konsoli.virhe("Virhe yhdistettäessä MongoDB: hen:", virhe);
 }
};
moduuli.exports = connectDB;

Määritä tietomalli

Määrittele yksinkertainen käyttäjädataskeema käyttämällä Mongoosea. Luo juurihakemistoon uusi model/user.model.js tiedosto ja lisää seuraava koodi.

konst mangusti = vaatia('mungo');
konst userSchema = Uusi mungo. Schema({
 käyttäjätunnus: merkkijono,
 Salasana: {
 tyyppi: merkkijono,
 edellytetään: totta,
 ainutlaatuinen: totta,
 },
});
konst User = mangoose.model("Käyttäjä", userSchema);
moduuli.exports = Käyttäjä;

Määritä API-reittien ohjaimet

Rekisterinpitäjän toiminnot hallitsevat rekisteröintiä ja kirjautumista; ne ovat olennainen osa tätä malliohjelmaa. Luo juurihakemistoon a controllers/userControllers.js tiedosto ja lisää seuraava koodi:

  1. Määritä käyttäjän rekisteröinnin ohjain.
    konst Käyttäjä = vaatia('../models/user.model');
    konst bcrypt = vaatia("bcrypt");
    konst { generoi Token } = vaatia("../middleware/auth");
    exports.registerUser = asynk (req, res) => {
    konst { käyttäjätunnus, salasana } = req.body;
    yrittää {
    konst hash = odottaa bcrypt.hash (salasana, 10); 
    odottaa User.create({ käyttäjänimi, Salasana: hash });
     res.status(201).lähettää({ viesti: "Käyttäjä rekisteröity onnistuneesti" });
     } ottaa kiinni (virhe) {
    konsoli.log (virhe);
     res.status(500).lähettää({ viesti: 'Tapahtui virhe!! ' });
     }
    };
    Tämä koodinpätkä tiivistää toimitetun salasanan bcryptillä ja luo sitten uuden käyttäjätietueen tietokantaan, joka tallentaa käyttäjänimen ja hajautetun salasanan. Jos rekisteröinti onnistuu, se lähettää vastauksen onnistumisviestillä.
  2. Määritä sisäänkirjautumisohjain käyttäjien kirjautumisprosessin hallintaa varten:
    exports.loginUser = asynk (req, res) => {
    konst { käyttäjätunnus, salasana } = req.body;
    yrittää {
    konst käyttäjä = odottaa User.findOne({ käyttäjänimi });

    jos (!käyttäjä) {
    palata res.status(404).lähettää({ viesti: 'Käyttäjää ei löydy' });
     }
    

    konst passwordMatch = odottaa bcrypt.compare (salasana, käyttäjä.salasana);
    

    jos (!passwordMatch) {
    palata res.status(401).lähettää({ viesti: 'Väärät kirjautumistiedot' });
     }
    konst hyötykuorma = { käyttäjätunnus: käyttäjätunnus };
    konst token = generoToken (hyötykuorma);
     res.cookie("tunnus", tunnus, { Vain http: totta });
     res.status(200).json({ viesti: 'Kirjautuminen onnistui'});
     } ottaa kiinni (virhe) {
    konsoli.log (virhe);
     res.status(500).lähettää({ viesti: "Tapahtui virhe kirjautuessa" });
     }
    };
    Kun käyttäjä lähettää pyynnön /login reittiä, heidän tulee välittää todennustietonsa pyynnön rungossa. Koodi vahvistaa sitten nämä valtuustiedot ja luo JSON-verkkotunnuksen. Tunnus on tallennettu turvallisesti evästeeseen Vain http lippu asetettu tosi. Tämä estää asiakaspuolen JavaScriptiä pääsemästä tunnukseen ja suojaa mahdollisilta sivustojen välisiltä komentosarjahyökkäyksiltä (XSS).
  3. Määritä lopuksi suojattu reitti:
    exports.getUsers = asynk (req, res) => {
    yrittää {
    konst käyttäjät = odottaa User.find({});
     res.json (käyttäjät);
     } ottaa kiinni (virhe) {
    konsoli.log (virhe);
     res.status(500).lähettää({ viesti: 'Tapahtui virhe!!' });
     }
    };
    Kun JWT tallennetaan evästeeseen, todennetun käyttäjän myöhemmät API-pyynnöt sisältävät automaattisesti tunnuksen, jolloin palvelin voi vahvistaa ja valtuuttaa pyynnöt.

Luo todennuksen väliohjelmisto

Nyt kun olet määrittänyt kirjautumisohjaimen, joka luo JWT-tunnuksen onnistuneen todennuksen jälkeen, määritä väliohjelmiston todennustoiminnot, jotka luovat ja vahvistavat JWT-tunnuksen.

Luo juurihakemistoon uusi kansio, väliohjelmisto. Lisää tähän kansioon kaksi tiedostoa: auth.js ja config.js.

Lisää tämä koodi config.js:

konst krypto = vaatia('crypto');
moduuli.exports = {
 SecretKey: crypto.randomBytes(32).toString("heksa")
};

Tämä koodi luo uuden satunnaisen salaisen avaimen joka kerta, kun se suoritetaan. Tämän salaisen avaimen avulla voit allekirjoittaa ja varmistaa JWT: iden aitouden. Kun käyttäjä on todennettu onnistuneesti, luo ja allekirjoita JWT salaisella avaimella. Palvelin käyttää avainta varmistaakseen, että JWT on kelvollinen.

Lisää seuraava koodi auth.js joka määrittää väliohjelmistotoiminnot, jotka luovat ja tarkistavat JWT: t.

konst jwt = vaatia("jsonwebtoken");
konst { salainen avain } = vaatia('./config');
konst generoToken = (hyötykuorma) => {
konst token = jwt.sign (hyötykuorma, salainen avain, { vanhenee: '1h' });
palata token ;
};


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


jos (!tunnus) {
palata res.status(401).json({ viesti: "Ei merkkiä annettu" });
 }


 jwt.verify (tunnus, secretKey, (err, decoded) => {
jos (err) {
palata res.status(401).json({ viesti: "Virheellinen tunnus" });
 }


 req.userId = purettu.käyttäjätunnus;
 Seuraava();
 }); 
};
moduuli.exports = {generoToken, verifyToken };

The generoi Token -toiminto luo JWT: n allekirjoittamalla hyötykuorman salaisella avaimella ja asettamalla vanhenemisajan vahvista Token toiminto toimii väliohjelmistona toimitetun tunnuksen aitouden ja kelpoisuuden tarkistamiseksi.

Määritä API-reitit

Luoda uusi routes/userRoutes.js tiedosto juurihakemistoon ja lisää seuraava koodi.

konst express = vaatia('ilmaista');
konst reititin = express. Reititin();
konst userControllers = vaatia('../controllers/userControllers');
konst { verifyToken } = vaatia("../middleware/auth");
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);
router.get('/api/käyttäjät', verifyToken, userControllers.getUsers);
moduuli.exports = reititin;

Päivitä palvelimesi sisääntulopiste

Päivitä omasi server.js tiedosto seuraavalla koodilla.

konst express = vaatia('ilmaista');
konst cors = vaatia("cors");
konst sovellus = express();
konst portti = 5000;
vaatia('dotenv').config();
konst connectDB = vaatia('./utils/db');
konst cookieParser = vaatia('cookie-parser');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ laajennettu: totta }));
app.use (cors());
app.use (cookieParser());
konst userRoutes = vaatia('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (portti, () => {
konsoli.Hirsi(`Palvelin kuuntelee klo http://localhost:${port}`);
});

Testaaksesi REST API: ta, pyöritä kehityspalvelin ja tee API-pyyntöjä määritettyihin päätepisteisiin:

solmupalvelin.js

Node.js REST -sovellusliittymien suojaaminen

Node.js REST -sovellusliittymien suojaaminen menee pidemmälle kuin vain JWT: iden käyttö, vaikka niillä onkin ratkaiseva rooli todentamisessa ja valtuutus, on tärkeää omaksua kokonaisvaltainen tietoturvalähestymistapa taustajärjestelmän suojaamiseksi järjestelmät. JWT: iden lisäksi kannattaa harkita myös HTTPS: n käyttöönottoa viestinnän, syötteiden validoinnin ja desinfioinnin ja monien muiden salaamiseksi.

Yhdistämällä useita suojaustoimenpiteitä voit luoda vankan suojauskehyksen Node.js REST API: t ja minimoi luvattoman käytön, tietomurtojen ja muun turvallisuuden riskin uhkauksia.