jwt.sign() jedesmal Token zum vorherigen Token hinzugefügt

Question

Jedesmal, wenn ich eine Postanforderung an die Authentifizierungsroute mache, indem ich Token zum vorherigen Token hinzufüge. Ich kann den Grund dieses Problems

const express = require("express"); 
const router = express.Router(); 
const User = require("../models/user"); 
const bcrypt = require("bcryptjs"); 
const config = require("../config/data"); 
const jwt = require("jsonwebtoken"); 
const mongoose = require("mongoose"); 

//Registration route 
router.post("/register",(req,res)=>{ 
    let date=new Date(); 
    let newUser = new User({ 
     name:req.body.name, 
     email:req.body.email, 
     password:req.body.password, 
     role:"User", 
     isActive:true, 
     created:date, 
     updatedToken:"JWT" 

    }); 
    User.addUser(newUser,(err,user)=>{ 
     if(err){ 
      res.json({success: false, msg:'Failed to register user'}); 
      } else { 
      res.json({success: true, msg:'User registered'}); 
      } 
    }); 


}); 

//Authentication route 
router.post('/authenticate', (req, res) => { 
    const email = req.body.email; 
    const password = req.body.password; 

    User.getUser(email, (err, user) => { 
     if(err) throw err; 
     if(!user){ 
     return res.json({success: false, msg: 'User not found'}); 
     } 

     User.comparePassword(password, user.password, (err, isMatch) => { 
     if(err) throw err; 
     if(isMatch){ 
      let payload={ 
      name:user.name, 
      email:user.email, 
      role:user.role, 
      deleted:user.deleted, 
      isActive:user.isActive, 
      created:user.created, 
      updatedToken:user.updatedToken, 
      }; 

      let token=jwt.sign(payload,config.secret) 

      User.saveToken(email,token,(err,success)=>{ 
      if(err) return err; 
      console.log("Success"); 
      res.json({ 
       success: true, 
       token: token 
      }); 
      }); 


     } else { 
      return res.json({success: false, msg: 'Wrong password'}); 
     } 
     }); 
    }); 
    }); 
// router.use(function(req, res, next) { 

//  // check header or url parameters or post parameters for token 
//  var token = req.body.token || req.query.token || req.headers['x-access-token']; 

//  // decode token 
//  if (token) { 

//   // verifies secret and checks exp 
//   jwt.verify(token, app.get('superSecret'), function(err, decoded) {  
//   if (err) { 
//    return res.json({ success: false, message: 'Failed to authenticate token.' });  
//   } else { 
//    // if everything is good, save to request for use in other routes 
//    req.decoded = decoded;  
//    next(); 
//   } 
//   }); 

//  } else { 

//   // if there is no token 
//   // return an error 
//   return res.status(403).send({ 
//    success: false, 
//    message: 'No token provided.' 
//   }); 

//  } 
//  }); 

//  // Dashboard 
// router.get('/dashboard', (req, res) => { 
// res.json({user: req.user}); 
// }); 

module.exports = router; 

Und das ist Schema und Funktionen

const mongoose = require("mongoose"); 
const bcrypt = require("bcryptjs"); 
const config = require("../config/data"); 
const jwt = require("jsonwebtoken"); 

let userSchema = mongoose.Schema({ 
    name:{ 
     type:String, 
     required:true 
    }, 
    email:{ 
     type:String, 
     required:true 
    }, 
    password:{ 
     type:String, 
     required:true 
    }, 
    role:{ 
     type:String, 
     required:true 
    }, 
    deleted:{ 
     type:Date, 
     default:null, 

    }, 
    isActive:{ 
     type:Boolean, 
     required:true 
    }, 
    created:{ 
     type:Date, 
     required:true 
    }, 
    updatedToken:{ 
     type:String, 
     required:true 
    } 
}); 

let User = module.exports = mongoose.model('User',userSchema,'Users'); 


module.exports.getUser = function(username, callback){ 
    let query = {email: username} 
    User.findOne(query, callback); 
} 

module.exports.addUser = function(newUser, callback){ 
    bcrypt.genSalt(10, (err, salt) => { 
    bcrypt.hash(newUser.password, salt, (err, hash) => { 
     if(err) throw err; 
     newUser.password = hash; 
     newUser.save(callback); 
    }); 
    }); 
} 

module.exports.comparePassword = function(candidatePassword, hash, callback){ 
    bcrypt.compare(candidatePassword, hash, (err, isMatch) => { 
    if(err) throw err; 
    callback(null, isMatch); 
    }); 
} 
module.exports.saveToken = function(username,token,callback){ 
    let query = {email:username}; 
    let updateToken={updatedToken:token}; 
    User.findOneAndUpdate(query,updateToken,callback); 
} 
module.exports.generateToken=function(payload,secret){ 
    let token = jwt.sign(payload,secret,{ 
     expiresIn: 604800 
    }) 
    return token; 
} 

Dies ist Server

const express = require ("express"); 
const app = express(); 
const bodyParser = require("body-parser"); 
const mongoose = require("mongoose"); 
const config = require("./config/data"); 
const cors = require("cors"); 
const morgan = require("morgan"); 

const route = require("./routes/users"); 
mongoose.Promise = global.Promise; 

let options = { 
    useMongoClient: true, 
    reconnectTries: Number.MAX_VALUE, 
    reconnectInterval: 500, 
    poolSize: 10, 
    bufferMaxEntries: 0 
    }; 

mongoose.connect(config.database,options); 

let db = mongoose.connection; 
db.on('error', console.error.bind(console, 'connection error:')); 
db.once('open', function() { 
console.log(`DB connected ${new Date()}...`); 
}); 


app.use(bodyParser.json()); 

app.use(cors()); 

app.use(morgan('dev')); 

app.get('/',(req,res)=>{ 
    res.send("Works aziz"); 
}); 

app.use("/users",route); 


app.listen(config.port,()=>{ 
    console.log(`Server running ${config.port}...`); 
}); 

finden Ich brauche das, wenn der Benutzer pos Um die Route zu authentifizieren, muss das Token generiert und dem Variablentoken übergeben werden. Es muss nicht jedes Mal verkettet werden, wenn der Benutzer eine Postanforderung ausführt. Vielen Dank !!!!!!

Answer 1

Sieht aus wie der Fehler mit updatedToken:user.updatedToken, innerhalb der Nutzlast ist. Bei der ersten Registrierung ist es JWT, weil Sie dies im Registrierungs-Controller festgelegt haben. Z.B. mit realen Werten

let payload={ 
    name: "testuser", 
    email: "test@example.com", 
    role: "user", 
    deleted: false, 
    isActive: true, 
    created: 2017-11-26, 
    updatedToken: "JWT", 
}; 

Nach der ersten Authentifizierung wird user.updatedToken mit dem Token Sie in saveToken() machen aktualisiert. Das ist ey ... etwas.

Nach der zweiten Authentifizierung Sie hinzufügen, die lange JWT Token (ey ...) innerhalb der Nutzlast:

let payload={ 
    name: "testuser", 
    email: "test@example.com", 
    role: "user", 
    deleted: false, 
    isActive: true, 
    created: 2017-11-26, 
    updatedToken: "ey1232abc456...", 
}; 

Dies ist die Nutzlast für das neue Token ist, die user.updatedToken gespeichert wird. Sie speichern das alte Token im neuen Token.

Also bin ich mir ziemlich sicher updatedToken innerhalb der Nutzlast muss gehen.