Skip to Content

Backend Node / Express

Ajoutez la connexion à une application Node.js Express à l'aide de la bibliothèque openid-client et du flux Authorization Code avec PKCE.

Ce guide ajoute la connexion OIDC à une application Express au moyen de la bibliothèque openid-client, qui prend en charge la discovery, PKCE et la validation des tokens. Il part d'un client confidentiel (un backend capable de garder un secret).

Si vous n'avez pas encore enregistré d'application, voir Avant de commencer. Pour le protocole sous-jacent, voir OpenID Connect (Authorization Code + PKCE).

1. Installer les dépendances

npm install express express-session openid-client

2. Configurer le client

import * as client from 'openid-client';

// Your instance's login domain (issuer). openid-client reads the
// discovery document at <issuer>/.well-known/openid-configuration.
const server = new URL('https://<your-domain>');
const clientId = process.env.OIDC_CLIENT_ID;
const clientSecret = process.env.OIDC_CLIENT_SECRET;
const redirectUri = 'https://app.example.com/callback';
const scope = 'openid profile email offline_access';

// Discover endpoints and prepare the client (default: client_secret_basic).
const config = await client.discovery(server, clientId, clientSecret);

Gardez OIDC_CLIENT_ID et OIDC_CLIENT_SECRET dans l'environnement, jamais dans la gestion de versions.

3. Démarrer la connexion

Construisez l'URL d'autorisation avec une challenge PKCE et un state, mémorisez les deux dans la session, puis redirigez le navigateur.

import express from 'express';
import session from 'express-session';

const app = express();
app.use(session({ secret: process.env.SESSION_SECRET, resave: false, saveUninitialized: false }));

app.get('/login', async (req, res) => {
  const codeVerifier = client.randomPKCECodeVerifier();
  const codeChallenge = await client.calculatePKCECodeChallenge(codeVerifier);
  const state = client.randomState();

  // stash for the callback
  req.session.codeVerifier = codeVerifier;
  req.session.state = state;

  const authUrl = client.buildAuthorizationUrl(config, {
    redirect_uri: redirectUri,
    scope,
    code_challenge: codeChallenge,
    code_challenge_method: 'S256',
    state,
  });

  res.redirect(authUrl.href);
});

4. Traiter le callback

Échangez le code contre des tokens. openid-client valide pour vous la réponse, le state et le verifier PKCE.

app.get('/callback', async (req, res) => {
  const currentUrl = new URL(req.originalUrl, 'https://app.example.com');

  const tokens = await client.authorizationCodeGrant(config, currentUrl, {
    pkceCodeVerifier: req.session.codeVerifier,
    expectedState: req.session.state,
  });

  const claims = tokens.claims(); // validated ID-token claims
  req.session.user = { sub: claims.sub, name: claims.name, email: claims.email };
  req.session.idToken = tokens.id_token;

  // Optional: fetch additional claims from UserInfo
  // const userinfo = await client.fetchUserInfo(config, tokens.access_token, claims.sub);

  res.redirect('/');
});

5. Déconnexion

Envoyez l'utilisateur vers l'endpoint end-session, puis effacez votre propre session.

app.get('/logout', (req, res) => {
  const endSession = client.buildEndSessionUrl(config, {
    id_token_hint: req.session.idToken,
    post_logout_redirect_uri: 'https://app.example.com/',
  });
  req.session.destroy(() => res.redirect(endSession.href));
});

Enregistrez https://app.example.com/ comme post-logout redirect URI sur l'application, de la même manière que vous enregistrez une redirect URI.

Dépannage

  • L'appel de discovery échoue. Vérifiez que https://<your-domain>/.well-known/openid-configuration est joignable depuis votre serveur et que le domaine est bien l'hôte de connexion de votre instance.
  • Erreurs de state ou de PKCE au callback. La session qui a démarré la connexion doit être celle qui traite le callback. Assurez-vous que les cookies de session survivent à la redirection (SameSite correct et, en production, cookies secure sur HTTPS).
  • Aucun refresh token n'est jamais renvoyé. Incluez offline_access dans le scope et vérifiez que l'application est configurée pour recevoir des refresh tokens.

Étapes suivantes

Sur cette page