Benutzerauthentifizierungs-API mit Express, JWT, Bcrypt und MySQL

Diese Anwendung ist ein einfacher Authentifizierungsserver, der mit Express erstellt wurde und JSON Web Tokens (JWT) für die Sitzungsverwaltung und bcrypt für die sichere Speicherung von Passwörtern verwendet. Benutzer können sich registrieren und anmelden, um auf geschützte Routen zuzugreifen. MySQL wird zum Speichern von Benutzerdaten verwendet.

Verwendete Technologien

1. Express.js: Web-Framework zur Handhabung von Routen und Middleware.
2. bcrypt.js: Bibliothek zum sicheren Hashing von Passwörtern.
3. jsonwebtoken: Bibliothek zum Erstellen und Überprüfen von JWT-Tokens.
4. mysql2: MySQL-Client für Node.js mit Unterstützung für Promises.
5. cookie-parser: Middleware zum Parsen von Cookies.

Code-Aufschlüsselung

1. Erforderliche Bibliotheken importieren

const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const cookieParser = require('cookie-parser');
const mysql = require('mysql2/promise');

• Express: Bietet Funktionen zum Erstellen von Routen und zum Verarbeiten von HTTP-Anfragen.
• jsonwebtoken: Wird zum Erstellen und Überprüfen von JWTs für Benutzersitzungen verwendet.
• bcryptjs: Wird zum Hashen von Passwörtern vor dem Speichern in der Datenbank verwendet.
• Cookie-Parser: Middleware zum Parsen von Cookies aus eingehenden HTTP-Anfragen.
• mysql2/promise: MySQL-Client mit Promise-Unterstützung, der asynchrone Vorgänge ermöglicht.

2. Express-App initialisieren und Konstanten definieren

const app = express();
const PORT = 3000;
const JWT_SECRET = 'your_jwt_secret_key';

• App: Die Express-Anwendungsinstanz.
• PORT: Der Port, auf dem der Server lauscht.
• JWT_SECRET: Ein geheimer Schlüssel, der zum Signieren von JWTs verwendet wird. Ersetzen Sie diesen durch einen sicheren, zufällig generierten Wert in der Produktion.

3. Einrichtung der Datenbankverbindung

const db = await mysql.createConnection({
    host: 'localhost',
    user: 'your_mysql_user',
    password: 'your_mysql_password',
    database: 'user_auth'
});

• db: Das MySQL-Datenbankverbindungsobjekt.
• mysql.createConnection(): Stellt mithilfe von async/await eine Verbindung zur MySQL-Datenbank her, die für nicht blockierende Abfragen benötigt wird.
• Host: Hostname Ihrer MySql-Anwendung. Wenn Sie sie auf localhost ausführen, geben Sie nur localhost ein. Wenn Sie MySql auf einem Server bereitgestellt haben, verwenden Sie den Hostnamen des Servers mit PORT.
• Benutzer: Ihr MySql-Benutzername
• Passwort: Ihr MySQL-Passwort
• Datenbank: Der Datenbankname

4. Middleware-Setup

app.use(express.json());
app.use(cookieParser());

• express.json(): Middleware zum Parsen von JSON-Anfragetexten.
• cookieParser(): Middleware zum Parsen von Cookies, die es uns ermöglicht, Cookies aus req.cookies zu lesen.

5. Route registrieren

/registrieren
Diese Route registriert einen neuen Benutzer, indem sein Passwort gehasht und in der Datenbank gespeichert wird.

const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const cookieParser = require('cookie-parser');
const mysql = require('mysql2/promise');

• db.execute(): Führt eine Abfrage aus, um zu prüfen, ob ein Benutzer mit der angegebenen E-Mail bereits existiert. Wenn dies der Fall ist, wird der Status 400 zurückgegeben.
• bcrypt.hash(password, 10): Hasht das Passwort aus Sicherheitsgründen mit einem Salt-Rundungswert von 10.
• db.execute() (Einfügen): Speichert den Namen, die E-Mail-Adresse und das gehashte Passwort des Benutzers in der Datenbank.

6. Anmelderoute

/login
Diese Route meldet einen vorhandenen Benutzer an, indem er seine Anmeldeinformationen überprüft und ein JWT-Token generiert.

const app = express();
const PORT = 3000;
const JWT_SECRET = 'your_jwt_secret_key';

• bcrypt.compare(password, user.password): Überprüft, ob das gehashte Passwort mit dem in der Datenbank gespeicherten übereinstimmt.
• jwt.sign(): Erstellt ein JWT, das Benutzerinformationen (z. B. ID, Name und E-Mail) enthält. Der Token läuft in 1 Stunde ab. Die Methode jwt.sign() benötigt zwei Argumente: Payload, JWT_SECRET, Optionen(optional)
• res.cookie(): Setzt ein Cookie mit dem JWT, gesichert durch httpOnly (nur für den Server zugänglich) und sameSite-Einstellungen.

7. JWT-Verifizierungs-Middleware

Die VerifyToken-Middleware stellt sicher, dass nur Anfragen mit einem gültigen JWT-Token auf geschützte Routen zugreifen können.

const db = await mysql.createConnection({
    host: 'localhost',
    user: 'your_mysql_user',
    password: 'your_mysql_password',
    database: 'user_auth'
});

• req.cookies.token: Extrahiert das Token aus Cookies.
• jwt.verify(token, JWT_SECRET): Verifiziert das Token mithilfe des geheimen JWT-Schlüssels. Wenn gültig, enthält dekodiert **die Nutzlast des Tokens, die **req.user zugewiesen ist.
• next(): Geht zur nächsten Middleware über, wenn das Token gültig ist.

8. Geschützte Route – /protected

Eine geschützte Beispielroute, die nur authentifizierten Benutzern zugänglich ist. Es gibt eine personalisierte Begrüßung mit dem Namen des Benutzers aus dem Token zurück.

app.use(express.json());
app.use(cookieParser());

• verifyToken: Middleware wird angewendet, um den Authentifizierungsstatus des Benutzers zu überprüfen.
• req.user.name: Greift auf den Namen des Benutzers aus der dekodierten JWT-Nutzlast zu.

9. Starten Sie den Server

Der Server lauscht am definierten PORT.

app.post('/register', async (req, res) => {
    const { name, email, password } = req.body;

    try {
        // Check if user already exists
        const [rows] = await db.execute('SELECT * FROM users WHERE email = ?', [email]);
        if (rows.length > 0) {
            return res.status(400).json({ message: 'User already exists' });
        }

        // Hash the password
        const hashedPassword = await bcrypt.hash(password, 10);

        // Save the user in the database
        await db.execute('INSERT INTO users (name, email, password) VALUES (?, ?, ?)', [name, email, hashedPassword]);
        res.status(201).json({ message: 'User registered successfully!' });
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: 'Server error' });
    }
});

Vollständiger Code

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

    try {
        // Find user
        const [rows] = await db.execute('SELECT * FROM users WHERE email = ?', [email]);
        const user = rows[0];
        if (!user) {
            return res.status(400).json({ message: 'User not found' });
        }

        // Check password
        const isMatch = await bcrypt.compare(password, user.password);
        if (!isMatch) {
            return res.status(400).json({ message: 'Invalid credentials' });
        }

        // Create JWT token
        const token = jwt.sign({ id: user.id, name: user.name, email: user.email }, JWT_SECRET, { expiresIn: '1h' });

        // Set JWT in cookie
        res.cookie('token', token, {
            httpOnly: true,
            secure: process.env.NODE_ENV === 'production',
            sameSite: 'Strict',
            maxAge: 3600000 // 1 hour
        });

        res.json({ message: 'Logged in successfully!' });
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: 'Server error' });
    }
});

Zusammenfassung

Diese Anwendung:

1. Ermöglicht die Benutzerregistrierung durch Hashing von Passwörtern und Speichern von Benutzerdaten in MySQL.
2. Unterstützt sichere Anmeldung mit JWT-Authentifizierung.
3. Verwendet Cookies, um das JWT auf der Clientseite zu speichern.
4. Stellt Middleware zur Überprüfung von JWTs bereit, bevor Zugriff auf geschützte Routen gewährt wird.

Das obige ist der detaillierte Inhalt vonBenutzerauthentifizierungs-API mit Express, JWT, Bcrypt und MySQL. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!