Vai sūtīt datus no vienas vietas uz citu? Jūsu sirdsmieram un lietotāju aizsardzībai jums tas ir jāaizsargā ar JWT.

Kad veidojat lietotni, ir ļoti svarīgi aizsargāt sensitīvos datus no nesankcionētas piekļuves. Daudzas mūsdienu tīmekļa, mobilās un mākoņa lietojumprogrammas izmanto REST API kā galveno saziņas līdzekli. Rezultātā ir ļoti svarīgi izstrādāt un izstrādāt aizmugursistēmas API ar drošību priekšplānā.

Viena efektīva pieeja REST API nodrošināšanai ir JSON tīmekļa marķieri (JWT). Šie marķieri piedāvā spēcīgu lietotāju autentifikācijas un autorizācijas mehānismu, palīdzot aizsargāt aizsargātos resursus pret ļaunprātīgu dalībnieku piekļuvi.

Kas ir JSON tīmekļa marķieri?

JSON tīmekļa marķieris (JWT) ir plaši izmantots drošības standarts. Tas nodrošina kodolīgu, autonomu metodi drošai datu pārsūtīšanai starp klienta lietotni un aizmugursistēmu.

REST API var izmantot JWT, lai droši identificētu un autentificētu lietotājus, kad viņi veic HTTP pieprasījumus, lai piekļūtu aizsargātajiem resursiem.

instagram viewer

JSON tīmekļa marķieris sastāv no trim atšķirīgām daļām: galvenes, lietderīgās slodzes un paraksta. Tas kodē katru daļu un savieno tās, izmantojot punktu (".").

Galvene apraksta kriptogrāfisko algoritmu, ko izmanto marķiera parakstīšanai, savukārt lietderīgā slodze satur datus par lietotāju un visus papildu metadatus.

Visbeidzot, paraksts, kas aprēķināts, izmantojot galveni, lietderīgo slodzi un slepeno atslēgu, nodrošina marķiera integritāti un autentiskumu.

Tā kā JWT pamati nav pieejami, izveidosim Node.js REST API un ieviesīsim JWT.

Iestatiet Express.js lietojumprogrammu un MongoDB datu bāzi

Šeit jūs uzzināsit, kā izveidot vienkāršu autentifikāciju REST API kas apstrādā gan reģistrācijas, gan pieteikšanās funkcionalitāti. Kad pieteikšanās process ir autentificējis lietotāju, viņam vajadzētu būt iespējai veikt HTTP pieprasījumus aizsargātam API maršrutam.

Šeit varat atrast projekta kodu GitHub repozitorijs.

Lai sāktu, izveidot Express tīmekļa serveriun instalējiet šīs pakotnes:

npm instalēt cors dotenv bycrpt mongoose cookie-parser crypto jsonwebtoken mongodb

Nākamais, izveidot MongoDB datu bāzi vai konfigurējiet MongoDB klasteru mākonī. Pēc tam nokopējiet datu bāzes savienojuma virkni, izveidojiet a .env failu saknes direktorijā un ielīmējiet savienojuma virknē:

CONNECTION_STRING="savienojuma virkne"

Konfigurējiet datu bāzes savienojumu

Izveidojiet jaunu utils/db.js failu jūsu projekta mapes saknes direktorijā. Šajā failā pievienojiet šādu kodu, lai izveidotu datu bāzes savienojumu, izmantojot Mongoose.

konst mangusts = pieprasīt('mangusts');
konst connectDB = asinhrons () => {
mēģināt {
gaidīt mongoose.connect (process.env. CONNECTION_STRING);
konsole.log("Savienots ar MongoDB!");
 } noķert (kļūda) {
konsole.error("Kļūda, veidojot savienojumu ar MongoDB:", kļūda);
 }
};
modulis.exports = connectDB;

Definējiet datu modeli

Definējiet vienkāršu lietotāja datu shēmu, izmantojot Mongoose. Saknes direktorijā izveidojiet jaunu model/user.model.js failu un pievienojiet šādu kodu.

konst mangusts = pieprasīt('mangusts');
konst userSchema = jauns mangusts. Shēma({
 lietotājvārds: Stīga,
 parole: {
 veids: Stīga,
 nepieciešams: taisnība,
 unikāls: taisnība,
 },
});
konst Lietotājs = mangoose.model("Lietotājs", userSchema);
modulis.exports = lietotājs;

Definējiet API maršrutu kontrolierus

Kontroliera funkcijas pārvaldīs reģistrāciju un pieteikšanos; tie ir būtiska šīs programmas parauga daļa. Saknes direktorijā izveidojiet a controllers/userControllers.js failu un pievienojiet šādu kodu:

  1. Definējiet lietotāja reģistrācijas kontrolieri.
    konst Lietotājs = pieprasīt("../models/user.model");
    konst bcrypt = pieprasīt('bcrypt');
    konst {generToken} = pieprasīt("../middleware/auth");
    exports.registerUser = asinhrons (req, res) => {
    konst { lietotājvārds, parole } = req.body;
    mēģināt {
    konst hash = gaidīt bcrypt.hash (parole, 10); 
    gaidīt User.create({ lietotājvārds, parole: hash });
     res.status(201).send({ ziņa: "Lietotājs veiksmīgi reģistrēts" });
     } noķert (kļūda) {
    konsole.log (kļūda);
     res.status(500).send({ ziņa: 'Notika kļūda!! ' });
     }
    };
    Šis koda fragments sajauc sniegto paroli, izmantojot bcrypt, un pēc tam izveido jaunu lietotāja ierakstu datu bāzē, saglabājot lietotājvārdu un jaukto paroli. Ja reģistrācija ir veiksmīga, tā nosūta atbildi ar veiksmes ziņojumu.
  2. Definējiet pieteikšanās kontrolieri, lai pārvaldītu lietotāja pieteikšanās procesu:
    exports.loginUser = asinhrons (req, res) => {
    konst { lietotājvārds, parole } = req.body;
    mēģināt {
    konst lietotājs = gaidīt User.findOne({ lietotājvārds });

    ja (!lietotājs) {
    atgriezties res.status(404).send({ ziņa: 'Lietotājs nav atrasts' });
     }
    

    konst passwordMatch = gaidīt bcrypt.compare (parole, user.password);
    

    ja (!passwordMatch) {
    atgriezties res.status(401).send({ ziņa: "Nederīgi pieteikšanās akreditācijas dati" });
     }
    konst krava = { Lietotāja ID: Lietotāja ID };
    konst token = generētToken (lietderīgā slodze);
     res.cookie('žetons', marķieris, { Tikai http: taisnība });
     res.status(200).json({ ziņa: 'Pieteikšanās veiksmīga'});
     } noķert (kļūda) {
    konsole.log (kļūda);
     res.status(500).send({ ziņa: "Pieteikšanās laikā radās kļūda" });
     }
    };
    Kad lietotājs nosūta pieprasījumu uz /login maršrutā, viņiem ir jānodod savi autentifikācijas akreditācijas dati pieprasījuma pamattekstā. Pēc tam kods pārbauda šos akreditācijas datus un ģenerē JSON tīmekļa pilnvaru. Tokens tiek droši glabāts sīkfailā ar Tikai http karodziņš iestatīts uz patiesu. Tas neļauj klienta puses JavaScript piekļūt pilnvarai, aizsargājot pret iespējamiem starpvietņu skriptu (XSS) uzbrukumiem.
  3. Visbeidzot, definējiet aizsargātu maršrutu:
    exports.getUsers = asinhrons (req, res) => {
    mēģināt {
    konst lietotāji = gaidīt User.find({});
     res.json (lietotāji);
     } noķert (kļūda) {
    konsole.log (kļūda);
     res.status(500).send({ ziņa: 'Notika kļūda!!' });
     }
    };
    Saglabājot JWT sīkfailā, turpmākajos API pieprasījumos no autentificēta lietotāja automātiski tiks iekļauts marķieris, ļaujot serverim pārbaudīt un autorizēt pieprasījumus.

Izveidojiet autentifikācijas starpprogrammatūru

Tagad, kad esat definējis pieteikšanās kontrolleri, kas pēc veiksmīgas autentifikācijas ģenerē JWT marķieri, definējiet starpprogrammatūras autentifikācijas funkcijas, kas ģenerēs un pārbaudīs JWT marķieri.

Saknes direktorijā izveidojiet jaunu mapi, starpprogrammatūra. Šajā mapē pievienojiet divus failus: auth.js un config.js.

Pievienojiet šo kodu config.js:

konst kriptovalūta = pieprasīt('kripto');
modulis.exports = {
 SecretKey: crypto.randomBytes(32).toString('hex')
};

Šis kods ģenerē jaunu nejaušu slepeno atslēgu katru reizi, kad tas darbojas. Pēc tam varat izmantot šo slepeno atslēgu, lai parakstītu un pārbaudītu JWT autentiskumu. Kad lietotājs ir veiksmīgi autentificēts, ģenerējiet un parakstiet JWT ar slepeno atslēgu. Pēc tam serveris izmantos atslēgu, lai pārbaudītu, vai JWT ir derīgs.

Pievienojiet tālāk norādīto kodu auth.js kas definē starpprogrammatūras funkcijas, kas ģenerē un pārbauda JWT.

konst jwt = pieprasīt("jsonwebtoken");
konst { SecretKey} = pieprasīt('./config');
konst GeneToken = (kravnesība) => {
konst marķieris = jwt.sign (lietderīgā slodze, secretKey, { beidzasIn: '1h' });
atgriezties žetons ;
};


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


ja (!token) {
atgriezties res.status(401).json({ ziņa: "Nav nodrošināts marķieris" });
 }


 jwt.verify (token, secretKey, (err, decoded) => {
ja (kļūda) {
atgriezties res.status(401).json({ ziņa: "Nederīgs marķieris" });
 }


 req.userId = decoded.userId;
 Nākamais();
 }); 
};
modulis.exports = {generToken, verifyToken};

The GeneToken funkcija ģenerē JWT, parakstot lietderīgo kravu, izmantojot slepeno atslēgu, un iestatot derīguma termiņu, kamēr verifyToken funkcija kalpo kā starpprogrammatūra, lai pārbaudītu nodrošinātā marķiera autentiskumu un derīgumu.

Definējiet API maršrutus

Izveidojiet jaunu routes/userRoutes.js failu saknes direktorijā un pievienojiet šādu kodu.

konst izteikt = pieprasīt('izteikt');
konst maršrutētājs = ekspress. Maršrutētājs ();
konst userControllers = pieprasīt("../controllers/userControllers");
konst { verifyToken } = pieprasīt("../middleware/auth");
router.post('/api/register', userControllers.registerUser);
router.post('/api/login', userControllers.loginUser);
router.get('/api/lietotāji', verifyToken, userControllers.getUsers);
modulis.exports = maršrutētājs;

Atjauniniet savu servera ieejas punktu

Atjauniniet savu serveris.js failu ar šādu kodu.

konst izteikt = pieprasīt('izteikt');
konst cors = pieprasīt('kors');
konst lietotne = express();
konst ports = 5000;
pieprasīt('dotenv').config();
konst connectDB = pieprasīt('./utils/db');
konst cookieParser = pieprasīt('cookie-parser');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ pagarināts: taisnība }));
app.use (cors());
app.use (cookieParser());
konst userRoutes = pieprasīt('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
konsole.log(`Serveris klausās plkst http://localhost:${port}`);
});

Lai pārbaudītu REST API, izveidojiet izstrādes serveri un veiciet API pieprasījumus definētajiem galapunktiem:

mezgla serveris.js

Node.js REST API nodrošināšana

Node.js REST API aizsardzība sniedz ne tikai JWT izmantošanu, bet arī tām ir izšķiroša nozīme autentifikācijā un autorizācija, ir svarīgi pieņemt holistisku drošības pieeju drošībai, lai aizsargātu savu aizmugursistēmu sistēmas. Papildus JWT apsveriet arī HTTPS ieviešanu, lai šifrētu saziņu, ievades validāciju un dezinfekciju, kā arī daudzas citas.

Apvienojot vairākus drošības pasākumus, jūs varat izveidot stabilu drošības sistēmu savam Node.js REST API un samazina nesankcionētas piekļuves, datu pārkāpumu un citas drošības risku draudiem.