Auth & Refresh Token – Guide Complet

Implémentation sécurisée d'authentification JWT avec refresh tokens en Node.js et React.

Sécurité

Implémenter une authentification sécurisée dans une app mobile demande une gestion rigoureuse des tokens. Dans cet article, on met en place un système JWT avec refresh token automatique via Axios Interceptors.

Points essentiels à retenir:

  • Utilisation de deux tokens distincts : access token (courte durée) et refresh token (longue durée)
  • Intercepteur Axios pour gérer automatiquement l'expiration des tokens
  • Stockage sécurisé avec une abstraction d'AsyncStorage

1. Le principe

On utilise deux types de tokens : un access token de courte durée, et un refresh token pour obtenir un nouveau access token sans forcer l'utilisateur à se reconnecter.

API Access Token 401 Unauthorized Refresh Token

2. Structure recommandée

  • services/api/axiosInstance.ts : instance Axios de base
  • services/interceptors/authInterceptor.ts : intercepteur 401 → refresh + retry
  • services/storage/TokenStorage.ts : abstraction AsyncStorage
  • features/auth/services/authService.ts : login, register, refresh

3. Le cycle de rafraîchissement

  1. Un appel API retourne 401 (token expiré)
  2. Axios intercepte l'erreur et appelle authService.refreshToken()
  3. Le nouveau token est stocké et le call initial est relancé automatiquement

Exemple d'intercepteur Axios

// services/interceptors/authInterceptor.ts
import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from 'axios';
import TokenStorage from '../storage/TokenStorage';
import authService from '../../features/auth/services/authService';

let isRefreshing = false;
let refreshQueue: Array<(token: string) => void> = [];

const processQueue = (token: string) => {
 refreshQueue.forEach(callback => callback(token));
 refreshQueue = [];
};

const setupAuthInterceptor = (axiosInstance: AxiosInstance) => {
 axiosInstance.interceptors.response.use(
   response => response,
   async (error: AxiosError) => {
     const originalRequest = error.config as AxiosRequestConfig & { _retry?: boolean };
     
     if (error.response?.status === 401 && !originalRequest._retry) {
       if (isRefreshing) {
         // Mettre en file d'attente si refresh déjà en cours
         return new Promise(resolve => {
           refreshQueue.push((token: string) => {
             originalRequest.headers = {
               ...originalRequest.headers,
               Authorization: `Bearer ${token}`
             };
             resolve(axiosInstance(originalRequest));
           });
         });
       }

       originalRequest._retry = true;
       isRefreshing = true;

       try {
         const { accessToken } = await authService.refreshToken();
         await TokenStorage.setAccessToken(accessToken);
         
         processQueue(accessToken);
         
         originalRequest.headers = {
           ...originalRequest.headers,
           Authorization: `Bearer ${accessToken}`
         };
         
         return axiosInstance(originalRequest);
       } catch (refreshError) {
         // Échec du refresh, déconnexion
         await authService.logout();
         return Promise.reject(refreshError);
       } finally {
         isRefreshing = false;
       }
     }
     
     return Promise.reject(error);
   }
 );
};

4. Stockage sécurisé

Les tokens sont stockés avec AsyncStorage via un helper centralisé (TokenStorage.ts). Pensez à chiffrer si besoin avec expo-secure-store.

5. Cas à prévoir

  • Expiration du refresh token → déconnexion
  • Erreurs réseaux → file d'attente ou message utilisateur
  • Appels concurrents pendant le refresh → synchronisation

À Retenir

  • Double token : Séparez l'accès (court) du rafraîchissement (long)
  • Intercepteur Axios : Automatisez la gestion des tokens expirés
  • File d'attente : Gérez les appels concurrents pendant le rafraîchissement
  • Stockage abstrait : Utilisez une classe dédiée pour manipuler les tokens
  • Sécurité : Envisagez le chiffrement avec expo-secure-store pour plus de protection

👉 Ce système améliore l'expérience utilisateur et la sécurité, tout en gardant le code propre et testable.