Je crée un blog en utilisant les dernières technologies MEAN Stack. Un utilisateur connecté peut créer un nouvel utilisateur avec les rôles «admin» et «modérateur».
Création d'un nouvel utilisateur avec un rôle d'administrateur ou un rôle de modérateur
Cette route est protégée et actuellement, seul un utilisateur connecté peut y accéder. Voici le middleware pour vérifier si l'utilisateur est authentifié ou non.
router.post("/login", (req, res, next) => {
let fetchedUser;
User.findOne({ email: req.body.email })
.then(user => {
if (!user) {
return res.status(401).json({
message: "Auth failed"
});
}
fetchedUser = user;
return bcrypt.compare(req.body.password, user.password);
})
.then(result => {
if (!result) {
return res.status(401).json({
message: "Auth failed"
});
}
const token = jwt.sign(
{ email: fetchedUser.email, userId: fetchedUser._id, role: fetchedUser.role },
"my_jwt_secret",
{ expiresIn: "1h" }
);
res.status(200).json({
token: token,
expiresIn: 3600
});
})
.catch(err => {
return res.status(401).json({
message: "Auth failed"
});
});
});
J'applique ce middleware pour protéger l'accès non autorisé à certaines de mes routes. Je souhaite créer un middleware similaire dans lequel je vérifie si l'utilisateur est un administrateur ou non. Je peux donc appliquer ce middleware sur la route de création d'utilisateurs, de sorte que seuls un utilisateur autorisé et un utilisateur qui a le rôle d'administrateur peuvent créer un nouvel utilisateur.
Je pense que cela peut aider à créer le middleware. Lorsqu'un utilisateur se connecte, l'identifiant, l'e-mail et le rôle sont stockés dans le fichier jwt.
//check_auth.js
const jwt = require('jsonwebtoken');
module.exports = (req, res, next) => {
try {
const token = req.headers.authorization.split(' ')[1];
jwt.verify(token, 'my_jwt_secret');
next();
} catch (error) {
res.status(401).json({ message: 'Auth failed!'});
}
};
L'ensemble du code se trouve dans mon référentiel GitHub: https://github.com/ rajotam / Eleven
3 Réponses :
Ajoutez un gestionnaire d'itinéraire à tous les points de terminaison qui nécessitent une vérification et importez-le là où c'est nécessaire. https://expressjs.com/en/guide/routing.html
ex.
module.exports = {
isAdmin: (req, res, next) =>{
if(req.user.admin){
next();
}else{
res.status(403).send();
}
}
}
// vérifier la fonction dans un fichier séparé
router.post('/login', verify.isAdmin, (req, res, next) => {
//do something
})
Exemples de code complet:
Je sais que je dois le faire de cette façon puisque j'ai déjà créé un middleware pour vérifier si l'utilisateur est authentifié ou non. Je ne sais pas comment extraire le rôle du jeton et vérifier si l'utilisateur est un administrateur?
J'ai édité ma réponse avec des exemples de code complets du support.
Lorsque vous créez le jeton
router.post('/login', checkAuthMiddleware, (req, res, next) => {
//Now you have userId, role and email Id to use
const userId = req.userId
const role = req.role
const email = req.email
// Now you can separate user role here
// Write some other logic here
})
email , userId et role sont ajoutés à ce jeton. Maintenant, vous pouvez les utiliser lorsque le jeton est décodé.
Après avoir appliqué le middleware sur les routes pour obtenir l'authentification de l'utilisateur
try {
const token = req.headers.authorization.split(' ')[1];
const decodedToken = jwt.verify(token, 'my_jwt_secret');
req.userId = decodedToken.userId
req.email = decodedToken.email
req.role = decodedToken.role
next()
}
Seul le code important est ici qui est le bloc try
// You did this
// jwt.verify(token, 'my_jwt_secret');
// You need to store this into variable so that you can use them
// use them in going request.
const decodedToken = jwt.verify(token, 'your_jwt_secret');
/*
This decodedToken holds email, userId and role
you can pass it to req
req.userId = decodedToken.userId
req.email = decodedToken.email
req.role = decodedToken.role
next()
*/
Dans votre itinéraire
const token = jwt.sign(
{ email: fetchedUser.email, userId: fetchedUser._id, role: fetchedUser.role },
"your_jwt_secret",
{ expiresIn: "1h" });
const jwt = require("jsonwebtoken");
module.exports = (req, res, next) => {
try {
const token = req.headers.authorization.split(" ")[1];
const decodedToken = jwt.verify(token, process.env.JWT_KEY);
req.userData = { email: decodedToken.email, userId: decodedToken.userId, role: decodedToken.role};
next();
} catch (error) {
res.status(401).json({ message: "You are not authenticated!" });
}
};