Auth0 et OAuth 2.0 : architecture complète pour comprendre les flux d'autorisation

Comprendre les rouages d'OAuth 2.0 dans Auth0 : Authorization Code Flow, PKCE, Client Credentials et Implicit. Schémas, code et cas d'usage réels.

Par Auth0.Expert · 2025-01-10 · 14 min de lecture

OAuth2 Architecture Auth0

Auth0 et OAuth 2.0 : architecture complète

TL;DR

OAuth 2.0 définit comment une application obtient un accès délégué à une ressource. Auth0 implémente 4 flux principaux. Choisir le mauvais flux expose vos utilisateurs à des attaques. Ce guide vous montre lequel choisir et pourquoi.

---

Pourquoi les équipes se trompent de flux

Les points de douleur les plus fréquents que nos clients signalent :

---

Les 4 flux Auth0 à connaître

Voici un aperçu rapide des usages adaptés à chaque flux Auth0.

1. Authorization Code Flow + PKCE (recommandé pour SPAs et mobiles)

Ce code montre comment initialiser le flux Authorization Code PKCE, garantissant la sécurité pour les applications front-end en évitant le vol de token.

Browser → /authorize?response_type=code&code_challenge=xxx
Auth0 → redirect avec ?code=abc
Browser → POST /token { code, code_verifier }
Auth0 → { access_token, id_token, refresh_token }

Ce bloc génère un code PKCE sécurisé côté JavaScript et prépare l’URL d’autorisation avec tous les paramètres requis pour Auth0.

Code PKCE (JavaScript) :

// Générer le code verifier
const codeVerifier = crypto.randomUUID().replace(/-/g, '') + crypto.randomUUID().replace(/-/g, '');

// Générer le code challenge (SHA-256)
const digest = await crypto.subtle.digest('SHA-256',
  new TextEncoder().encode(codeVerifier));
const codeChallenge = btoa(String.fromCharCode(...new Uint8Array(digest)))
  .replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');

// Construire l'URL authorize
const params = new URLSearchParams({
  response_type: 'code',
  client_id: 'YOUR_CLIENT_ID',
  redirect_uri: 'https://app.example.com/callback',
  scope: 'openid email',
  code_challenge: codeChallenge,
  code_challenge_method: 'S256',
  state: crypto.randomUUID(),
});
window.location.href = `https://YOUR_DOMAIN.auth0.com/authorize?${params}`;

Ce code permet à votre SPA ou application mobile de lancer la connexion sécurisée via PKCE.

2. Client Credentials Flow (M2M)

Ce flux est utilisé pour les échanges entre machines ou microservices, aucun utilisateur n’est impliqué, seulement l’authentification du service lui-même.

curl -X POST https://YOUR_DOMAIN.auth0.com/oauth/token   -H "Content-Type: application/json"   -d '{
    "client_id": "CLIENT_ID",
    "client_secret": "CLIENT_SECRET",
    "audience": "https://api.example.com",
    "grant_type": "client_credentials"
  }'

3. Authorization Code Flow (backend traditionnel)

Ce flux permet à une application serveur de gérer les sessions utilisateurs via un callback, très utile pour les applications web SSR ou API privées.

# Python / FastAPI callback handler
from authlib.integrations.starlette_client import OAuth

oauth = OAuth()
oauth.register(
    name='auth0',
    client_id=os.environ['AUTH0_CLIENT_ID'],
    client_secret=os.environ['AUTH0_CLIENT_SECRET'],
    server_metadata_url=f'https://{os.environ["AUTH0_DOMAIN"]}/.well-known/openid-configuration',
    client_kwargs={'scope': 'openid email profile'},
)

@app.get('/callback')
async def callback(request: Request):
    token = await oauth.auth0.authorize_access_token(request)
    user = token.get('userinfo')
    return user

Ce code gère l’échange du code d’autorisation contre des tokens, puis récupère le profil utilisateur en backend.

4. Device Authorization Flow

Ce flux est indispensable pour connecter des appareils qui n’ont pas de clavier ou de navigateur complet, comme une télévision ou un terminal IoT.

Device → POST /oauth/device/code
Auth0 → { device_code, user_code, verification_uri }
Device affiche : "Allez sur auth0.com/activate et entrez : XXXX-YYYY"
Device poll → POST /oauth/token { device_code, grant_type=urn:ietf:params:oauth:grant-type:device_code }

Il permet à l’utilisateur de valider l’accès sur un autre appareil via un navigateur.

---

Tableau comparatif des flux

Ce tableau aide à comparer rapidement les caractéristiques de chaque flux Auth0 selon le contexte technique.

| Flux | Contexte | Client Secret | PKCE | Refresh Token | |------|----------|---------------|------|---------------| | Auth Code + PKCE | SPA, Mobile | ❌ | ✅ obligatoire | ✅ avec rotation | | Auth Code | Backend server | ✅ | Optionnel | ✅ | | Client Credentials | M2M | ✅ | ❌ | ❌ | | Device | TV/CLI/IoT | ❌ | ❌ | ✅ | | Implicit | Obsolète | ❌ | ❌ | ❌ |

---

Fonctionnalités Auth0 natives à exploiter

Les fonctionnalités suivantes optimisent sécurité, expérience utilisateur, et gestion multi-API dans Auth0.

---

Outils open source complémentaires

Ces outils facilitent l’intégration OAuth/OIDC avec Auth0 dans différents langages ou frameworks.

| Outil | Rôle | Licence | |-------|------|---------| | oidc-client-ts | Gestion OAuth/OIDC côté browser | Apache-2.0 | | authlib | Client OAuth universel Python | BSD-3 | | passport-auth0 | Middleware Node/Express | MIT | | jwt-decode | Décoder un JWT sans vérification | MIT | | jose | Vérification JWT/JWK côté browser | MIT |

---

Points de vigilance en production

Voici les points de contrôle essentiels pour sécuriser votre implémentation Auth0 en production.

  1. Toujours valider le state pour prévenir le CSRF.
  2. Valider l'aud du JWT côté API — ne jamais faire confiance à un token sans vérifier qu'il vous est destiné.
  3. Ne jamais logguer un access_token complet — tronquez à 8 caractères pour le debug.
  4. Expiration courte : 15 minutes pour les access tokens, 1h max.

---

Besoin d'un audit de votre implémentation OAuth ?

Nos experts analysent votre architecture actuelle et identifient les vulnérabilités en 48h.

📧 [email protected] · 📞 +33 1 23 45 67 89

Autres articles