NodeJS- und MongoDB-Anwendungsauthentifizierung durch JWT

In diesem Blog implementieren wir die Authentifizierung mit JWT in einer NodeJS-Webanwendung. Dafür verwenden wir jsonwebtoken Paket

Was ist JWT?

JWT (JSON Web Token) ist ein Token-Format. Es ist digital signiert, in sich geschlossen und kompakt. Es bietet einen bequemen Mechanismus zum Übertragen von Daten. JWT ist nicht von Natur aus sicher, aber die Verwendung von JWT kann die Authentizität der Nachricht sicherstellen, solange die Signatur verifiziert ist und die Integrität der Nutzlast garantiert werden kann. JWT wird häufig für die zustandslose Authentifizierung in einfachen Anwendungsfällen mit nicht komplexen Systemen verwendet.

Hier ist ein Beispiel für JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsIm

Lassen Sie uns nun einige Routen authentifizieren/schützen.

Voraussetzungen:

Grundkenntnisse in HTML/JavaScript
NodeJS sollte auf Ihrem System installiert sein.
Express-Modul zum Erstellen des Servers.
Mongoose-Modul für MongoDB-Verbindung und -Abfragen.
bcrypt-Modul für Hashing.

Sie können alle erforderlichen Pakete mit dem folgenden Befehl installieren:

npm install express mongoose bcrypt  --save

Schritt 1. Erstellen Sie zunächst eine Verzeichnisstruktur wie folgt:

JWTApp

-api
--models
----userModel.js
--controllers
----userController.js
--route
----userRoute.js
--server.js

Schritt 2. Installieren Sie „jsonwebtoken ” Paket mit folgendem Befehl

 npm install jsonwebtoken -- save

Schritt 3. Erstellen Sie das Benutzermodell

Erstellen Sie im Ordner api/models eine Datei namens user userModel.js, indem Sie touch api/models/userModel.js ausführen.

Erstellen Sie in dieser Datei ein Mungo-Schema mit den folgenden Eigenschaften:

vollständiger Name
E-Mail-Adresse
Passwort
das Erstellungsdatum

Fügen Sie den folgenden Code hinzu

'use strict';

var mongoose = require('mongoose'),
  bcrypt = require('bcrypt'),
  Schema = mongoose.Schema;

/**
 * User Schema
 */
var UserSchema = new Schema({
  fullName: {
    type: String,
    trim: true,
    required: true
  },
  email: {
    type: String,
    unique: true,
    lowercase: true,
    trim: true,
    required: true
  },
  hash_password: {
    type: String
  },
  created: {
    type: Date,
    default: Date.now
  }
});

UserSchema.methods.comparePassword = function(password) {
  return bcrypt.compareSync(password, this.hash_password);
};

mongoose.model('User', UserSchema);

Schritt 4. Erstellen Sie die Benutzer-Handler

In api/controllers erstellen Sie eine Datei namens user userController.js, indem Sie touch api/controllers/userController.js

ausführen

Erstellen Sie in der userController-Datei drei verschiedene zu handhabende Handler, indem Sie den folgenden Code verwenden

'use strict';

var mongoose = require('mongoose'),
  jwt = require('jsonwebtoken'),
  bcrypt = require('bcrypt'),
  User = mongoose.model('User');

exports.register = function(req, res) {
  var newUser = new User(req.body);
  newUser.hash_password = bcrypt.hashSync(req.body.password, 10);
  newUser.save(function(err, user) {
    if (err) {
      return res.status(400).send({
        message: err
      });
    } else {
      user.hash_password = undefined;
      return res.json(user);
    }
  });
};

exports.sign_in = function(req, res) {
  User.findOne({
    email: req.body.email
  }, function(err, user) {
    if (err) throw err;
    if (!user || !user.comparePassword(req.body.password)) {
      return res.status(401).json({ message: 'Authentication failed. Invalid user or password.' });
    }
    return res.json({ token: jwt.sign({ email: user.email, fullName: user.fullName, _id: user._id }, 'RESTFULAPIs') });
  });
};

exports.loginRequired = function(req, res, next) {
  if (req.user) {
    next();
  } else {

    return res.status(401).json({ message: 'Unauthorized user!!' });
  }
};
exports.profile = function(req, res, next) {
  if (req.user) {
    res.send(req.user);
    next();
  } 
  else {
   return res.status(401).json({ message: 'Invalid token' });
  }
};

Hinweis: Ein Hash-Passwort wurde mit bcrypt in der Datenbank gespeichert.

Schritt 6. In api/route erstellen Sie eine Datei namens user userRoute.js und fügen Sie den folgenden Code hinzu:

'use strict';
module.exports = function(app) {
    var userHandlers = require('../controllers/userController.js');
    // todoList Routes
    app.route('/tasks')
        .post(userHandlers.loginRequired, userHandlers.profile);
    app.route('/auth/register')
        .post(userHandlers.register);
   app.route('/auth/sign_in')
        .post(userHandlers.sign_in);
};

Schritt 7. Fügen Sie den folgenden Code in server.js hinzu

'use strict';

var express = require('express'),
  app = express(),
  port = process.env.PORT || 3000,


  User = require('./api/models/userModel'),
  bodyParser = require('body-parser'),
  jsonwebtoken = require("jsonwebtoken");

const mongoose = require('mongoose');
const option = {
    socketTimeoutMS: 30000,
    keepAlive: true,
    reconnectTries: 30000
};

const mongoURI = process.env.MONGODB_URI;
mongoose.connect('mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb', option).then(function(){
    //connected successfully
}, function(err) {
    //err handle
});

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

app.use(function(req, res, next) {
  if (req.headers && req.headers.authorization && req.headers.authorization.split(' ')[0] === 'JWT') {
    jsonwebtoken.verify(req.headers.authorization.split(' ')[1], 'RESTFULAPIs', function(err, decode) {
      if (err) req.user = undefined;
      req.user = decode;
      next();
    });
  } else {
    req.user = undefined;
    next();
  }
});
var routes = require('./api/routes/userRoutes');
routes(app);

app.use(function(req, res) {
  res.status(404).send({ url: req.originalUrl + ' not found' })
});

app.listen(port);

console.log(' RESTful API server started on: ' + port);

module.exports = app;

Schritt 9. Jetzt müssen Sie nur noch das Projekt mit dem folgenden Befehl ausführen und versuchen, sich mit dem JWT anzumelden.

npm start

Schritt 10. Öffnen Sie Postman und erstellen Sie eine Post-Anforderung an localhost:3000/auth/register wie folgt:

Schritt 11. Danach signieren wir mit dieser URL localhost:3000/auth/sign_in . Geben Sie die Schlüssel und Werte für E-Mail und Passwort ein

Fügen Sie unter dem Wert JWT und das Token mit einem Leerzeichen dazwischen hinzu, etwa so:

JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImZ1bGxOYW1lIjoiT2xhdHVuZGUgR2FydWJhIiwiX2lkIjoiNThmMjYzNDdiMTY1YzUxODM1NDMxYTNkIiwiaWF0IjoxNDkyMjgwMTk4fQ.VcMpybz08cB5PsrMSr25En4_EwCGWZVFgciO4M-3ENE

Schritt 11. Geben Sie dann die Parameter für den Schlüssel und den Wert zum Abrufen des Profils ein. Sie möchten wie unten gezeigt erstellen und senden:

Wie wir gesehen haben, ist es ziemlich einfach, ein JWT-Authentifizierungssystem mit NodeJS zu erstellen. Den vollständigen Code, der in diesem Tutorial verwendet wird, finden Sie hier.

Hinweis:Mit diesem Tool können Sie Ihre JWT-Token-Details entschlüsseln oder verifizieren