Installation

yarn add koa-passport passport-local

Configuration de la stratégie d'authentification pour vérifier l'utilisateur et le mot de passe

const passport = require('koa-passport')
const LocalAuth = require('passport-local').Strategy
const Account = require('../../dbs/models/accounts')

passport.use(new LocalAuth((pseudo, mdp, termine) => {
  Account.findOne({pseudo}, (err, compte) => {
    if (err) return termine(err)
    if (!compte) return termine(null, false, {message: 'Compte introuvable'})
    if (compte.mdp !== mdp) return termine(null, false, {message: 'Mot de passe incorrect'})
    return termine(null, compte)
  })
}))

passport.serializeUser((compte, termine) => {
  termine(null, compte)
})

passport.deserializeUser((compte, termine) => {
  termine(null, compte)
})

module.exports = passport

Intégration de passport dans l'application principale

app.use(passport.initialize())
app.use(passport.session())

La stratégie d'authentification est maintenant configurée

Mise en œuvre de l'endpoint de connexion

router.post('/connexion', async ctx => {
  return Passport.authenticate('local', (erreur, compte, infos, statut) => {
    if (erreur) {
      ctx.body = {
        code:-1,
        msg:erreur
      }
    }else {
      if (compte) {
        ctx.body = {
          code:0,
          msg:'Connexion réussie',
          compte
        }
        return ctx.login(compte)
      } else {
        ctx.body = {
          code:1,
          msg:infos
        }
      }
    }
  })(ctx)
})

Code sourceVérification de l'état de connexion de l'utilisateur

router.get('/verifier-utilisateur', async ctx => {
  if (ctx.isAuthenticated()){
    {pseudo, courriel} = ctx.session.passport.user
    ctx.body = {
      pseudo,
      courriel
    }
  } else {
    ctx.body = {
      pseudo: '',
      courriel: ''
    }
  }
})

Code sourceDéconnexion de l'utilisateur

router.get('/deconnexion', async ctx => {
  await ctx.logout()
  if (!ctx.isAuthenticated()) {
    ctx.body = {
      code:0
    }
  } else {
    ctx.body = {
      code:-1
    }
  }
})

Code sourceAnalyse technique

La fonction passport.serializeUser définit l'opération de sérialisation. L'appel de ctx.login() déclenche cette opération de sérialisation.

La fonction passport.deserializeUser définit l'opération de désérialisation. Si une session existe avec passport:{utilisateur:'Susan'}, l'opération de désérialisation est déclenchée.

La méthode passport.use(new LocalStrategy('local', ...)) enregistre la stratégie. L'appel de passport.authenticate('local',...) active cette stratégie.

L'utilisation de app.use(passport.initialize()) ajoute les méthodes suivantes au conetxte :

ctx.state.utilisateur - utilisateur authentifié ctx.login(utilisateur) - connexion de l'utilisateur ctx.logout() - déconnexion de l'utilisateur ctx.isAuthenticated() - vérification de l'état d'authentification

authenticate