Utiliser le passeport pour autoriser deux types d'utilisateur complètement différents à s'authentifier

Question

Donc, j'ai une application qui a deux types d '«utilisateur»: les humains et les appareils.

L'utilisateur se connecte en utilisant le nom d'utilisateur/mot de passe (stratégie locale). Les périphériques se connectent à l'aide d'un certificat.

Ce sont des choses très différentes, donc ce n'est pas le même que d'avoir un accès spécial pour les utilisateurs d'administration par rapport aux utilisateurs normaux. Je ne peux pas avoir une seule table db pour toutes les entités qui peuvent se connecter.

Je comprends comment je peux avoir plusieurs stratégies d'authentification (je différencie simplement par point final), mais je suis un peu perplexe sur la façon de gérer la désérialisation de le jeton pour les demandes entrantes. Express/passeport semble permettre seulement une fonction deserializeUser que je peux écrire. En outre, je voudrais découpler ces deux types afin que je puisse garder les dispositifs et les humains dans leur propre code plutôt que d'avoir une fonction de désérialisation monolithique qui les trie.

Idéalement, je serais en mesure d'avoir deux fonctions deserializeUser et la droite est appelée en fonction du format de jeton, mais je ne vois pas la meilleure façon de le faire.

Des suggestions?

Answer 1

Je compris vos besoins que vous avez besoin d'une connexion de type d'utilisateur différent de sorte que vous pouvez utiliser le paramètre de demande de passeport pour identifier le type d'utilisateur de sorte que votre fonction sera commune.

passport.use(new LocalStrategy({ 
     usernameField: 'email', 
     passwordField: 'password',// this is the virtual field on the model 
     passReqToCallback: true 
    }, 
    function (req, email, password, done) { 
     // get req here 
     enter code here 
    }); 

Answer 2

Je fini par la standardisation sur un ensemble minimal d'éléments communs, chaque type d'utilisateur doit avoir:

• id (en utilisant _id de mongo) de type
• (défini comme une mangouste virtuelle)

Cela me permet d'inclure le type dans la sérialisation et de rechercher uniquement l'entité dans la table correcte lors de la désérialisation.

C'est assez proche de ce que j'espérais obtenir. J'aurais préféré ne pas avoir de fonctions de sérialiseur/désérialiseur central, mais je pense que c'est le compromis minimum que je pourrais faire.

est ici le code de sérialisation et désérialisation:

passport.serializeUser(function (entity, done) { 
    done(null, { id: entity.id, type: entity.type }); 
}); 

passport.deserializeUser(function (obj, done) { 
    switch (obj.type) { 
     case 'user': 
      User.findById(obj.id) 
       .then(user => { 
        if (user) { 
         done(null, user); 
        } 
        else { 
         done(new Error('user id not found:' + objid, null)); 
        } 
       }); 
      break; 
     case 'device': 
      Device.findById(obj.id) 
       .then(device => { 
        if (device) { 
         done(null, device); 
        } else { 
         done(new Error('device id not found:' + obj.id, null)); 
        } 
       }); 
      break; 
     default: 
      done(new Error('no entity type:', obj.type), null); 
      break; 
    } 
});