Autentificare și autorizare utilizatori

JWT + Bcrypt

1

Generare folderului pentru rute

În cadrul folderului server, creăm folderul routes care va conține rutele pentru toate modelele pe care urmează să le creăm.

Ne apucăm să generăm ruta de autentificare pentru utilizatori prin crearea fisierului auth.routes.js în cadrul folderului routes.

Structură fișiere:

server/ ├── database/ │ └── models/ │ ├── User.js │ └── index.js ├── routes/ │ └── auth.routes.js ├── .env ├── .gitignore ├── package.json ├── package-lock.json ├── server.js └── index.js

2

Adăugarea unei chei de enviroment pentru generarea token-ului

În procesul de autentificare cu JWT, cheia de environment TOKEN_SECRET joacă un rol esențial în securitatea aplicației.

TOKEN_SECRET este o cheie secretă folosită de librăria jsonwebtoken pentru crearea și verificarea token-urilor JWT.

• Când generezi un JWT (jwt.sign()), TOKEN_SECRET este folosit pentru a semna token-ul, astfel încât să nu poată fi falsificat.

• Când verifici un JWT (jwt.verify()), aceeași cheie este folosită pentru a confirma că token-ul nu a fost modificat și este autentic.

• Este important ca TOKEN_SECRET să fie unic și păstrat secret, de obicei stocat în fișierul .env și nu trebuie să fie pus în codul sursă sau în Git.

Astfel, mergem în fișierul .env si adăugăm noua cheie .env:

PORT=3000
TOKEN_SECRET=my_jwt_secret_key

3

Generarea rutei de autentificare

În cadrul fișierului auth.routes.js, începem prin importarea librăriilor de care vom avea nevoie și a modelului de utilizator.

// server/routes/auth.routes.js
const express = require('express');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const { User } = require('../database/models');

const router = express.Router();

router.post('/login', async (req, res) => {
    const { email, password } = req.body;

    const existingUser = await User.findOne({
        where: {
            email
        }
    })

    if (!existingUser) {
        return res.status(400).json({success: false, message: 'User not found', data: {}});
    }

    const isValidPassword = bcrypt.compareSync(password, existingUser.dataValues.password);

    if (!isValidPassword) {
        return res.status(400).json({success: false, message: 'Not the same password', data: {}});
    }

    const token = jwt.sign({id: existingUser.dataValues.id, role: existingUser.dataValues.role}, process.env.TOKEN_SECRET, {
        expiresIn: '1h'
    })

    res.status(200).json({success: true, message: 'Valid email and password', data: token})
})

Un Promise în JavaScript este un obiect care reprezintă o operațiune asincronă care se va finaliza în viitor și care poate avea una dintre cele trei stări:

1. Pending (în așteptare) – operațiunea nu s-a terminat încă.

2. Fulfilled (îndeplinit) – operațiunea s-a terminat cu succes și are un rezultat disponibil.

3. Rejected (respins) – operațiunea s-a terminat cu eroare și oferă un motiv (error).

Explicații privind logica fișierul auth.routes.js și a rutei de autentificare:

• Crearea router-ului Express – Se importă express și se creează un router pentru a defini rutele legate de autentificare.

• Importuri importante – Se aduc bcrypt pentru verificarea parolelor criptate, jsonwebtoken (JWT) pentru generarea token-urilor și modelul User din baza de date.

• Ruta POST /login – Aceasta primește datele de autentificare (email și password) de la client.

• Verificarea existenței utilizatorului – Se caută în baza de date un utilizator cu email-ul dat. Dacă nu există, se răspunde cu eroare 400.

• Verificarea parolei – Se compară parola introdusă cu cea stocată în baza de date folosind bcrypt.compareSync. Dacă nu corespund, se trimite eroare 400.

• Generarea token-ului JWT – Dacă email-ul și parola sunt corecte, se generează un JWT care include id și role ale utilizatorului, care expiră într-o oră.

• Răspuns către client – Se trimite token-ul în format JSON pentru a fi folosit ulterior la autentificarea în aplicație.

4

Implementare rută autentificată la nivel de server

Ca ruta de autentificare să poată fi folosită, este nevoie să asigurăm că serverul are la cunoștință existența acestei rute.

Așadar, mergem în fisierul index.js din folderul server, unde adăugăm importul router-ului de auth și middlware-ul de rutare către rutele de autentificare (putem șterge importul modelului de utilizator).

// server/index.js
const express = require('express');
const cors = require('cors');
const dotenv = require('dotenv');
const morgan = require('morgan');
const app = express();
dotenv.config();

const authRoutes = require('./routes/auth.routes');

const PORT = process.env.PORT || 3000;

app.use(morgan('dev'))
app.use(cors());
app.use(express.json());

app.get('/', (req, res) => {
    res.status(200).json({ message: 'Hello' })
})
app.use('/auth', authRoutes);

app.listen(PORT, () => {
    console.log(`Server successfully started on port ${PORT}`)
})

Middleware-ul de rutare (route middleware):

• Atașează router-ul authRoutes la ruta de bază /auth.

Practic, toate rutele definite în authRoutes vor fi prefixate automat cu /auth.

• De exemplu, ruta router.post('/login', ...) din auth.routes.js va fi accesibilă la /auth/login.

• Este modul standard în Express de a organiza rutele pe module și de a „monta” routere în aplicație.