OAuth 2.0

OAuth 2.0 est le protocole d'autorisation standard de l'industrie qui permet aux utilisateurs d'accorder un accès limité à leurs ressources sans partager leurs mots de passe. Contrairement à l'authentification qui vérifie l'identité, OAuth 2.0 se concentre sur l'autorisation déléguée, permettant à une application tierce d'agir au nom d'un utilisateur avec des permissions spécifiques. Ce protocole est massivement utilisé par Google, Facebook, GitHub et pratiquement tous les services web modernes pour gérer les accès sécurisés.

Fondements du protocole

• Séparation des rôles : Resource Owner (utilisateur), Client (application), Authorization Server (serveur d'autorisation) et Resource Server (API protégée)
• Utilisation de tokens d'accès temporaires plutôt que des identifiants utilisateur directs
• Quatre flux d'autorisation principaux : Authorization Code, Implicit, Resource Owner Password Credentials et Client Credentials
• Scopes granulaires définissant précisément les permissions accordées à l'application cliente

Avantages stratégiques

• Sécurité renforcée : les mots de passe ne sont jamais partagés avec les applications tierces
• Contrôle granulaire : les utilisateurs peuvent révoquer l'accès à tout moment sans changer leur mot de passe
• Expérience utilisateur fluide : connexion rapide via des comptes existants (Google, Facebook, etc.)
• Standardisation : implémentation uniforme facilitant l'intégration entre systèmes hétérogènes
• Scalabilité : architecture stateless permettant de gérer des millions d'autorisations simultanées

Exemple concret : flux Authorization Code

Le flux Authorization Code est le plus sécurisé et recommandé pour les applications web. Voici une implémentation TypeScript côté serveur utilisant Express et la bibliothèque Passport :

import express from 'express';
import passport from 'passport';
import { Strategy as OAuth2Strategy } from 'passport-oauth2';

const app = express();

// Configuration de la stratégie OAuth 2.0
passport.use('oauth2', new OAuth2Strategy({
  authorizationURL: 'https://provider.com/oauth/authorize',
  tokenURL: 'https://provider.com/oauth/token',
  clientID: process.env.CLIENT_ID!,
  clientSecret: process.env.CLIENT_SECRET!,
  callbackURL: 'https://myapp.com/auth/callback',
  scope: ['read:user', 'read:email']
},
async (accessToken, refreshToken, profile, done) => {
  try {
    // Récupérer ou créer l'utilisateur en base
    const user = await findOrCreateUser({
      providerId: profile.id,
      accessToken,
      refreshToken
    });
    return done(null, user);
  } catch (error) {
    return done(error);
  }
}));

// Route d'initiation de l'authentification
app.get('/auth/login',
  passport.authenticate('oauth2'));

// Route de callback après autorisation
app.get('/auth/callback',
  passport.authenticate('oauth2', { failureRedirect: '/login' }),
  (req, res) => {
    // Authentification réussie
    res.redirect('/dashboard');
  }
);

// Utilisation du token pour accéder aux ressources
app.get('/api/profile', async (req, res) => {
  const token = req.user.accessToken;
  const response = await fetch('https://api.provider.com/user', {
    headers: { 'Authorization': `Bearer ${token}` }
  });
  const data = await response.json();
  res.json(data);
});

Mise en œuvre d'OAuth 2.0

1. Enregistrer votre application auprès du fournisseur OAuth pour obtenir client_id et client_secret
2. Définir les scopes nécessaires selon les ressources que vous devez accéder
3. Implémenter le flux d'autorisation approprié (Authorization Code recommandé pour les apps web)
4. Configurer l'URL de redirection (callback) de manière sécurisée (HTTPS obligatoire)
5. Gérer le stockage sécurisé des tokens (encrypted at rest, jamais exposés côté client)
6. Implémenter le rafraîchissement automatique des tokens avec refresh_token
7. Mettre en place une gestion d'erreurs robuste et une stratégie de retry
8. Auditer régulièrement les permissions accordées et révoquer les accès inutilisés

Outils et bibliothèques associés

• Passport.js (Node.js) : middleware d'authentification supportant 500+ stratégies OAuth
• Spring Security OAuth (Java) : framework complet pour serveurs d'autorisation et clients
• Authlib (Python) : bibliothèque OAuth complète pour Flask et Django
• IdentityServer (C#/.NET) : serveur OAuth 2.0 et OpenID Connect certifié
• Auth0, Okta, Keycloak : solutions Identity-as-a-Service avec OAuth 2.0 intégré
• Postman, Insomnia : outils de test API avec support OAuth 2.0 natif
• OAuth 2.0 Playground : outil Google pour expérimenter les flux OAuth

OAuth 2.0 s'impose comme la colonne vertébrale de la sécurité moderne des APIs et de l'économie des plateformes. En permettant un partage contrôlé des ressources, il réduit drastiquement les risques de compromission massive tout en facilitant l'innovation via les intégrations tierces. Pour les organisations, maîtriser OAuth 2.0 n'est plus optionnel : c'est un prérequis pour toute architecture cloud-native sécurisée et pour se conformer aux réglementations comme RGPD qui exigent un contrôle granulaire des accès aux données personnelles.