web-dev-qa-db-fra.com

Autorisation jwt basée sur les rôles

J'essaie d'authentifier une API Node.js avec des jetons Web JSON. Je pourrais générer le jeton authentifier les utilisateurs. Maintenant, je dois protéger mon API en fonction des rôles d’utilisateur . Voici comment je route un middleware pour s’authentifier et vérifier le jeton.

var app = express();

var apiRoutes = express.Router();
apiRoutes.use(function (req, res, next) {

    var token = req.body.token || req.param('token') || req.headers['x-access-token'];

    if (token) {
        jwt.verify(token, app.get('superSecret'), function (err, decoded) {
            if (err) {
                return res.json({ success: false, message: 'Failed to authenticate token.' });
            } else {
                req.decoded = decoded;
                next();
            }
        });

    } else {
        return res.status(403).send({
            success: false,
            message: 'No token provided.'
        });
    }
});

apiRoutes.get('/check', function (req, res) {
    //...
});

app.use('/api', apiRoutes);

De cette façon, je protège l'API dire /api/check. Ceci est accessible uniquement par admin user. Maintenant, j'ai un autre super user qui peut accéder à /api/validate auquel le admin user ne peut pas accéder. Comment puis-je protéger /api/validate uniquement pour super user. Dois-je écrire un autre middleware pour le faire?

Voici comment je fais la vérification admin maintenant,

apiRoutes.post('/delete/:id',requireAdmin, function (req, res) {
//do the rest
};

function requireAdmin(req, res, next) {
    var currentUserRole=".."; //get current user role
    if('admin' == currentUserRole )
     {
         next();
     }
     else{
          next(new Error("Permission denied."));
    return;
     }  
};

De même, la fonction requireSuperUser pour la vérification du super utilisateur. Est-ce la bonne façon de procéder à la vérification admin/super utilisateur?

node.jsjwt
6
NaaN

Lors de la création du JWT, vous pouvez fournir votre propre charge utile sous forme de revendication privée. Par exemple.:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true,
  "superUser": false
}

De la même manière, vous pouvez peut-être répertorier un ensemble de rôles d’utilisateur pour l’utilisateur connecté.

{
  "sub": "1234567890",
  "name": "John Doe",
  "roles": [
    "ADMIN",
    "SUPERUSER"
  ]
}

Il est ensuite nécessaire de décoder le jeton (le meilleur middleware express.js pour cette authentification/autorisation), de vérifier les rôles et d'envoyer un HTTP 401 lorsqu'il n'est pas autorisé. Lorsque cela est autorisé, appelez next(); pour poursuivre et entrez l'itinéraire correspondant.

Petit exemple d'une telle fonction de middleware possible:

function canAccess(req, res, next) {
  checkAuthorization(req, function (err, authorized) {
      if (err || !authorized) {
          res.send({message: 'Unauthorized', status: 401});
      }

      next();
  });

  function checkAuthorization(req, callback) {
      // jwt decode and actual authentication admin/superuser matching goes here..
  }
}

router.use(canAccess);

Pour plus d'informations sur les revendications JWT: https://jwt.io/introduction

Pour plus d'informations sur le middleware expressjs: https://expressjs.com/fr/guide/using-middleware.html

8
Nico Van Belle

Ajout de la fonction requireAdmin et vérification si le rôle est admin en décodant la charge.

api.post('/create',requireAdmin, function (req, res) {
   //.....
}

function requireAdmin(request, response, next) {
    if (request.decoded.role != 'admin') {
        response.json({message: 'Permission denied.' });
    }
    else {
        next();
    }
};
1
NaaN