Contactez-nous

Intégration avec des fournisseurs d'identité tiers (OAuth 2.0)

Permettez a vos utilisateurs de se connecter via Google, Facebook, etc., a votre application Node.js en integrant OAuth 2.0, generalement via la bibliotheque Passport.js.

Simplifier l'authentification : "Se connecter avec..."

De nombreuses applications web modernes offrent aux utilisateurs la possibilité de s'inscrire ou de se connecter en utilisant leurs comptes existants auprès de fournisseurs d'identité populaires comme Google, Facebook, GitHub, Twitter, etc. Cette approche présente plusieurs avantages :

  • Commodité pour l'utilisateur : Pas besoin de créer et de mémoriser un nouveau mot de passe spécifique à votre application.
  • Processus d'inscription accéléré : Réduit les frictions lors de l'arrivée de nouveaux utilisateurs.
  • Sécurité déléguée (en partie) : Vous vous appuyez sur les mécanismes de sécurité robustes (et souvent l'authentification multi-facteurs) mis en place par ces grands fournisseurs.
  • Accès potentiel aux API du fournisseur : Bien que non obligatoire pour la simple connexion, cela peut ouvrir la voie à l'utilisation des API du fournisseur (ex: récupérer la liste de contacts Google, poster sur Facebook).

Le standard industriel qui permet cette délégation d'authentification (et d'autorisation) est OAuth 2.0. OAuth 2.0 est un framework d'autorisation, mais il est très couramment utilisé comme base pour des protocoles d'authentification construits par-dessus, comme OpenID Connect (OIDC), qui est une couche d'identité au-dessus d'OAuth 2.0, souvent utilisée pour les flux "Se connecter avec...".

Intégrer OAuth 2.0 directement peut être complexe en raison des différents flux et des spécificités de chaque fournisseur. Heureusement, l'écosystème Node.js, notamment avec Express.js, dispose d'excellents outils pour simplifier ce processus, le plus notable étant la bibliothèque Passport.js.

Comprendre le flux OAuth 2.0 (simplifie pour l'authentification)

Même en utilisant une bibliothèque, il est utile de comprendre les étapes générales du flux d'autorisation OAuth 2.0 (souvent le flux "Authorization Code") lorsqu'il est utilisé pour l'authentification :

  1. Initiation par l'utilisateur : L'utilisateur clique sur un bouton "Se connecter avec Google" sur votre application Node.js.
  2. Redirection vers le fournisseur : Votre application redirige le navigateur de l'utilisateur vers la page de connexion/autorisation du fournisseur d'identité (Google), en passant des informations comme votre Client ID (identifiant unique de votre application chez Google) et la Redirect URI (l'URL de votre application où Google doit renvoyer l'utilisateur après l'authentification).
  3. Authentification et Consentement : L'utilisateur se connecte sur le site du fournisseur (s'il ne l'est pas déjà) et approuve (consent) les permissions demandées par votre application (ex: accéder à son profil de base).
  4. Redirection vers votre application avec un code : Le fournisseur redirige le navigateur de l'utilisateur vers la Redirect URI spécifiée à l'étape 2, en ajoutant un code d'autorisation temporaire dans l'URL.
  5. Echange du code contre des tokens : Votre serveur Node.js reçoit cette requête sur la Redirect URI, extrait le code d'autorisation, puis effectue une requête back-end (serveur à serveur) vers le fournisseur d'identité pour échanger ce code contre un Access Token et souvent un ID Token (pour OpenID Connect). Cette étape nécessite votre Client ID et votre Client Secret (une clé privée connue uniquement de votre serveur et du fournisseur).
  6. Récupération des informations utilisateur : En utilisant l'Access Token (pour appeler les API du fournisseur) ou en décodant et vérifiant l'ID Token (qui contient directement des informations sur l'utilisateur authentifié), votre serveur récupère les détails nécessaires sur l'utilisateur (son ID unique chez le fournisseur, son email, son nom, etc.).
  7. Création de session / JWT local : Votre application Node.js utilise les informations récupérées pour identifier l'utilisateur dans votre propre système (en le trouvant dans votre base de données ou en créant un nouveau compte si c'est sa première connexion). Ensuite, vous établissez une session locale pour cet utilisateur (via `express-session` ou en générant votre propre JWT) comme vous le feriez pour une connexion classique par mot de passe.
  8. Réponse au client : Finalement, votre serveur répond au navigateur de l'utilisateur, souvent en le redirigeant vers son tableau de bord ou sa page de profil, maintenant authentifié au sein de votre application.

Ce flux complexe assure que les identifiants de l'utilisateur ne sont jamais partagés directement avec votre application, seulement avec le fournisseur d'identité de confiance.

Simplifier l'integration avec Passport.js

Implémenter manuellement toutes ces étapes et gérer les spécificités de chaque fournisseur OAuth serait très laborieux et source d'erreurs. Passport.js est un middleware d'authentification pour Node.js extrêmement flexible et populaire qui abstrait cette complexité.

Passport fonctionne avec un concept de stratégies (strategies). Pour chaque fournisseur d'identité (Google, Facebook, GitHub, Twitter, JWT, authentification locale, etc.), il existe une stratégie Passport correspondante (souvent sous forme de package npm séparé, ex: `passport-google-oauth20`, `passport-facebook`, `passport-github2`, `passport-jwt`).

Les étapes générales avec Passport :

  1. Installer Passport et la stratégie désirée : `npm install passport passport-google-oauth20` (par exemple).
  2. Configurer Passport : Initialiser Passport comme middleware dans Express (`app.use(passport.initialize())`). Si vous utilisez les sessions Passport (courant avec OAuth), vous aurez aussi besoin de `app.use(passport.session())` après `express-session`.
  3. Configurer la Stratégie : Vous instanciez la stratégie choisie (ex: `new GoogleStrategy(...)`) en lui fournissant votre Client ID, Client Secret (obtenus lors de l'enregistrement de votre application auprès du fournisseur), et la Callback URL (votre Redirect URI).
  4. Implémenter la fonction de vérification (Verify Callback) : C'est la fonction clé fournie à la stratégie. Elle est appelée par Passport après avoir réussi à échanger le code contre des tokens et récupéré le profil utilisateur du fournisseur. Votre rôle dans cette fonction est de :
    • Recevoir le profil utilisateur du fournisseur (ex: `profile`).
    • Trouver l'utilisateur correspondant dans votre base de données (par exemple, en cherchant par l'ID unique du fournisseur).
    • Si l'utilisateur existe dans votre base, appeler la fonction `done(null, user)` pour indiquer à Passport que l'authentification a réussi et lui passer votre objet utilisateur local.
    • Si l'utilisateur n'existe pas, vous pouvez soit choisir de le créer automatiquement dans votre base de données (auto-inscription) puis appeler `done(null, newUser)`, soit appeler `done(null, false)` pour indiquer que l'authentification a échoué pour cet utilisateur (il n'est pas encore enregistré chez vous).
    • Gérer les erreurs éventuelles en appelant `done(err)`.
  5. Définir les Routes : Vous devez définir au moins deux routes :
    • Une route pour initier le flux d'authentification (ex: `app.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] }));`). Cliquer sur un lien vers cette route redirigera l'utilisateur vers Google. Le paramètre `scope` définit les permissions demandées.
    • Une route pour gérer le callback (Redirect URI) (ex: `app.get('/auth/google/callback', passport.authenticate('google', { failureRedirect: '/login' }), (req, res) => { /* Succès */ res.redirect('/dashboard'); });`). Passport intercepte cette route, finalise l'authentification en appelant votre fonction de vérification, et si elle réussit (`done(null, user)`), il attache `req.user` et exécute le handler final (ici, une redirection vers `/dashboard`). En cas d'échec, il redirige vers `/login`.
  6. Sérialisation/Désérialisation (si sessions Passport) : Si vous utilisez `passport.session()`, vous devez implémenter `passport.serializeUser((user, done) => done(null, user.id))` (pour stocker uniquement l'ID utilisateur dans la session) et `passport.deserializeUser((id, done) => { /* chercher user par id en BDD */ done(null, user); })` (pour récupérer l'objet utilisateur complet depuis l'ID stocké en session à chaque requête).

Bien que cela semble encore comporter plusieurs étapes, Passport structure le processus et gère une grande partie de la complexité du protocole OAuth 2.0 pour vous.

// Exemple conceptuel de configuration de stratégie Google
const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;

passport.use(new GoogleStrategy({
    clientID: process.env.GOOGLE_CLIENT_ID,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    callbackURL: "/auth/google/callback" // Doit correspondre à celle configurée chez Google
  },
  async (accessToken, refreshToken, profile, done) => {
    // Fonction de vérification (Verify Callback)
    // profile contient les infos de l'utilisateur Google
    console.log('Profil Google reçu:', profile);
    try {
      // Chercher si l'utilisateur existe dans notre BDD via profile.id
      let user = await User.findOne({ googleId: profile.id });
      if (user) {
        return done(null, user); // Utilisateur trouvé
      } else {
        // Optionnel: Créer un nouvel utilisateur dans notre BDD
        user = await User.create({
          googleId: profile.id,
          displayName: profile.displayName,
          email: profile.emails[0].value // Attention: email peut ne pas être fourni/vérifié
          // ... autres champs ...
        });
        return done(null, user); // Nouvel utilisateur créé
      }
    } catch (err) {
      return done(err); // Erreur BDD ou autre
    }
  }
));

// Routes (voir texte ci-dessus)
app.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
app.get('/auth/google/callback', 
  passport.authenticate('google', { failureRedirect: '/login', session: true }), // Utilise les sessions
  (req, res) => {
    // Authentification réussie !
    res.redirect('/dashboard');
  }
);

Securite et bonnes pratiques

Stockage des Secrets : Ne jamais hardcoder le Client ID et surtout le Client Secret dans votre code. Utilisez des variables d'environnement ou un gestionnaire de secrets.

Callback URL (Redirect URI) : Assurez-vous que l'URL de callback configurée dans votre application Node.js correspond exactement à celle enregistrée auprès du fournisseur d'identité. C'est une mesure de sécurité essentielle.

Paramètre `state` : Utilisez toujours un paramètre `state` opaque et unique lors de la redirection initiale vers le fournisseur. Ce paramètre vous est renvoyé dans le callback. En le vérifiant, vous vous protégez contre les attaques CSRF (Cross-Site Request Forgery). Passport gère souvent cela implicitement ou via des options.

Validation de l'ID Token : Si vous utilisez OpenID Connect (ce qui est souvent le cas pour la connexion), validez soigneusement l'ID Token reçu (signature, audience, émetteur, expiration) avant de faire confiance aux informations qu'il contient.

HTTPS : Toutes les communications OAuth (redirections, échanges de code/token) doivent impérativement se faire via HTTPS en production.

Conclusion : une passerelle vers l'identite unifiee

L'intégration avec des fournisseurs d'identité tiers via OAuth 2.0 et OpenID Connect est une fonctionnalité puissante qui améliore considérablement l'expérience utilisateur pour l'authentification. Bien que le protocole lui-même soit complexe, des bibliothèques comme Passport.js rendent son implémentation dans Node.js beaucoup plus accessible.

En comprenant les flux principaux et en utilisant les bons outils, vous pouvez offrir à vos utilisateurs une méthode de connexion familière et sécurisée, tout en vous déchargeant d'une partie de la complexité de la gestion des identités et des mots de passe.