Benutzerauthentifizierung mit Node.js

Question

Ich mache eine Benutzerauthentifizierung mit Reisepass. Zuerst habe ich einen Standard-Admin-Benutzer erstellt. Jetzt muss dieser Admin Benutzer erstellen können, aber keine anderen Benutzer. Dazu habe ich einen Admin-Benutzer in der Datenbank angelegt. Jetzt ist meine Frage, wie man die anderen Benutzer durch den Admin erstellt und nur dieser Admin sollte Zugriff auf alle API-Routen aber nicht für andere Benutzer wie die APIs schützen? In der Datei server.js habe ich die Middleware-Funktion als

erstellt. Bitte helfen Sie mit. Ich hoffe, es macht euch nichts aus, so lange Dateien zu posten.

'authentication.js'

'use strict'; 
var passport = require('passport'), 
    mongoose = require('mongoose'), 
    Users = mongoose.model('Users'); 


var authentication = { 

    register: function(req, res, name, email, password) { 
     var userData = req.body; 

     var user = new Users({ 
      email: userData.email, 
      name: userData.name, 
     }); 

     user.setPassword(userData.password); 

     if(!user) { 
      res.status(400).send({error: 'All fields required'}); 
     } 

     user.save(function(err, result) { 
      if(err) { 
       console.log('Could not save the User'); 
       res.status(500).send({error: 'Could not save the User'}); 
      }else { 
       res.send('New User Created Successfully'); 
      } 
     }); 
    }, 

    login: function (req, res) { 
     if(!req.body.email || !req.body.password) { 
      res.status(400).send({"message": "All fields required"}); 
      return;  
     } 

     passport.authenticate('local', function (err, user, info) { 
      var token; 

      if (err) { 
     res.status(404).send({err: 'An Error Occured'}); 
       return; 
      } 

      if(user) { 
       token = user.generateJwt(); 
     res.status(300).send({"token": token}); 
      }else { 
     res.status(401).send('Unauthorized User'); 
      } 
     }); 
    } 

}; 

module.exports = authentication; 

'user-model.js'

'use strict'; 
var mongoose = require('mongoose'), 
    crypto = require('crypto'), 
    jwt = require('jsonwebtoken'), 
    Schema = mongoose.Schema; 

var userSchema = new mongoose.Schema({ 
    email: { 
     type: String, 
     required: true, 
     unique: true 
    }, 
    name: { 
     type: String, 
     required: true 
    }, 
    hash: String, 
    salt: String 
}); 



userSchema.methods.setPassword = function (password) { 
    this.salt = crypto.randomBytes(16).toString('hex'); 
    this.hash = crypto.pbkdf2Sync(password, this.salt, 1000, 64).toString('hex'); 
}; 

//Validating a submitted password 
userSchema.methods.validPassword = function (password) { 
    var hash = crypto.pbkdf2Sync(password, this.salt, 1000, 64).toString('hex'); 
    return this.hash === hash; 
}; 

//Generating a JSON Web Token 
userSchema.methods.generateJwt = function() { 
    var expiry = new Date(); 
    expiry.setDate(expiry.getDate() + 7); 

    return jwt.sign({ 
     _id: this._id, 
     email: this.email, 
     name: this.name, 
     exp: parseInt(expiry.getTime()/1000) 
    }, process.env.JWT_SECRET); 
}; 

var User = mongoose.model('Users', userSchema); 
var user = new User(); 
user.name = 'Arjun Kumar'; 
user.email = 'arjun@kumar.com'; 
user.setPassword('myPassword'); 
user.save(); 

'user-route.js'

'use strict'; 
var express = require('express'), 
    userRoute = express.Router(), 
    jwt = require('express-jwt'), 
    authentication = require('../controllers/authentication'); 

var auth = jwt({ 
    secret: process.env.JWT_SECRET, 
    userProperty: 'payload' 
}); 

userRoute.post('/:adminuserid/register', auth, authentication.register) 
    .post('/login', authentication.login); 

module.exports = userRoute; 

'passport.js'

var passport = require('passport'), 
    LocalStrategy = require('passport-local').Strategy, 
    mongoose = require('mongoose'), 
    Users = mongoose.model('Users'); 

passport.use(new LocalStrategy({usernameField: 'email'}, function (username, password, done) { 
    Users.findOne({ email: username }, function (err, user) { 
     if (err) { 
      return done(err); 
     } 
     if (!user) {      
      return done(null, false, { 
       message: 'Incorrect username.' 
      }) 
     } 
     if (!user.validPassword(password)) { 
      return done(null, false, {  
       message: 'Incorrect password.' 
      }); 
     } 
     return done(null, user); 
    }); 
})); 

Answer 1

Eine Sache, die Sie tun können es so alle Funktionen in einem bedingten zu setzen Zugang zu geben, nur dem Server-Betreiber:

If(req.user.email === your admin email) { 

Your function 

} 

Dies unter den Routen gehen sollte, dass Sie nur Zugriff haben der Administrator möchten.

Oder wenn Sie mehrere Administratoren haben, dann sollten Sie Ihr Schema ein wenig ändern und fügen Sie eine admin : Number, die später zum Beispiel jeder Benutzer mit admin:1 sind Systemadministratoren andernfalls nicht.

Ich hoffe, ich habe Ihre Frage richtig verstanden.

Viel Glück