---
title: "Comment stocker des tokens d'authentification de façon sécurisée en React Native"
description: "Où garder tokens, sessions et clés en React Native : expo-secure-store, react-native-keychain et MMKV chiffré, avec la déconnexion et la réinstallation."
url: "https://arbabnaseer.com/fr/articles/stocker-tokens-securise-react-native/"
lang: "fr"
author: "Arbab Naseer"
datePublished: "2026-10-23T00:00:00+05:00"
dateModified: "2026-10-23T00:00:00+05:00"
tags: "React Native, Expo, Security, MMKV, TypeScript, iOS, Android"
---

# Comment stocker des tokens d'authentification de façon sécurisée en React Native

> Où garder tokens, sessions et clés en React Native : expo-secure-store, react-native-keychain et MMKV chiffré, avec la déconnexion et la réinstallation.

Arbab Naseer · 2026-10-23 · https://arbabnaseer.com/fr/articles/stocker-tokens-securise-react-native/

**Réponse courte :** gardez le refresh token (et tout identifiant de session à longue durée de vie) dans **expo-secure-store** ou **react-native-keychain**, qui le confient au Keychain iOS et à l'Android Keystore. Gardez l'access token à courte durée de vie en mémoire. Pour des données sensibles plus volumineuses, utilisez **MMKV avec chiffrement** et ne stockez que sa clé de chiffrement dans le stockage sécurisé. Ne mettez jamais de tokens dans AsyncStorage ou dans MMKV sans chiffrement.

Chaque application avec connexion que je développe, doit répondre dès le premier jour à la même question : où vit la session entre deux lancements ? Cet article présente la configuration que j'utilise, avec les deux particularités de plateforme qui piègent souvent les développeurs (les réinstallations sur iOS et les sauvegardes Android). Il fait partie d'une petite série sur le stockage local ; la vue d'ensemble se trouve dans [MMKV vs AsyncStorage vs SQLite vs SecureStore](https://arbabnaseer.com/fr/articles/comparatif-stockage-local-react-native/).

## Ce qui compte comme donnée sensible

Un test simple : si quelqu'un copiait cette valeur depuis le téléphone, pourrait-il agir à la place de l'utilisateur ou lire ses données privées ? Si oui, elle est sensible.

| Donnée | Sensible ? | Où la garder |
|---|---|---|
| Refresh token, identifiant de session | Oui | SecureStore ou Keychain |
| Access token (JWT à courte durée de vie) | Oui | En mémoire, renouvelé grâce au refresh token |
| PIN ou mot de passe de l'utilisateur | Oui, évitez même de le stocker | Keychain avec protection biométrique, si vous y êtes obligé |
| Clé de chiffrement d'une base locale | Oui | SecureStore ou Keychain |
| Messages privés, données de santé ou financières en cache | Oui, et souvent volumineuses | MMKV chiffré ou SQLCipher, clé dans le stockage sécurisé |
| Thème, langue, flag d'onboarding | Non | MMKV sans chiffrement ou AsyncStorage |

## Pourquoi AsyncStorage et MMKV sans chiffrement ne suffisent pas

Les deux écrivent dans des fichiers à l'intérieur du sandbox de votre application. Sur un téléphone normal, le sandbox empêche les autres applications de les lire, mais les valeurs sont stockées en clair. Sur un appareil rooté ou jailbreaké, depuis une sauvegarde non chiffrée de l'appareil, ou avec un outil de débogage sur le téléphone d'un développeur, n'importe qui peut ouvrir ces fichiers et lire le token.

Le [guide de sécurité de React Native](https://reactnative.dev/docs/security) dit la même chose : AsyncStorage n'est pas chiffré et ne doit contenir ni tokens ni secrets. Le stockage sécurisé est différent, parce que le secret est confié au système d'exploitation :

- **iOS :** les valeurs vont dans le [Keychain](https://developer.apple.com/documentation/security/keychain_services), chiffré par le système et lié au code de l'appareil.
- **Android :** les valeurs sont chiffrées avec une clé qui se trouve dans l'[Android Keystore](https://developer.android.com/privacy-and-security/keystore?hl=fr). Sur la plupart des téléphones récents, cette clé est conservée dans un composant matériel sécurisé dédié, donc elle n'entre jamais dans la mémoire de votre application et ne peut pas être copiée hors de l'appareil.

## Option 1 : expo-secure-store

[expo-secure-store](https://docs.expo.dev/versions/latest/sdk/securestore/) est le choix le plus simple, et il fonctionne dans Expo Go. Les versions ici viennent de l'Expo SDK 58 (`expo-secure-store` 58.0.2) :

```bash
npx expo install expo-secure-store
```

```ts
import * as SecureStore from 'expo-secure-store';

const REFRESH_TOKEN = 'refreshToken';

export async function saveRefreshToken(token: string) {
  await SecureStore.setItemAsync(REFRESH_TOKEN, token, {
    // Lisible après le premier déverrouillage depuis le démarrage, donc le rafraîchissement en arrière-plan fonctionne.
    // THIS_DEVICE_ONLY l'exclut des sauvegardes restaurées sur un autre téléphone.
    keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
  });
}

export function getRefreshToken() {
  return SecureStore.getItemAsync(REFRESH_TOKEN);
}

export function deleteRefreshToken() {
  return SecureStore.deleteItemAsync(REFRESH_TOKEN);
}
```

Les clés ne peuvent contenir que des lettres, des chiffres, `.`, `-` et `_`. Gardez des valeurs petites : la documentation Expo signale que certaines versions d'iOS refusaient les valeurs au-delà d'environ 2048 octets. Un token tient largement, un profil utilisateur entier non.

## Option 2 : react-native-keychain

[react-native-keychain](https://oblador.github.io/react-native-keychain) (version 10.0.0 au moment où j'écris) vous donne plus de contrôle : règles d'accès biométriques, vérification du niveau de sécurité et « services » séparés pour différents secrets. C'est un choix courant dans les applications React Native sans Expo.

```ts
import * as Keychain from 'react-native-keychain';

const SERVICE = 'com.example.app.session';

export async function saveSession(userId: string, refreshToken: string) {
  await Keychain.setGenericPassword(userId, refreshToken, {
    service: SERVICE,
    accessible: Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
  });
}

export async function loadSession() {
  const credentials = await Keychain.getGenericPassword({ service: SERVICE });
  return credentials ? { userId: credentials.username, refreshToken: credentials.password } : null;
}

export function clearSession() {
  return Keychain.resetGenericPassword({ service: SERVICE });
}
```

La paire nom d'utilisateur et mot de passe peut sembler étrange pour un token, mais elle correspond bien à une session : l'identifiant de l'utilisateur va dans `username` et le token dans `password`.

**Lequel choisir ?** Dans une application Expo, expo-secure-store couvre la plupart des besoins avec moins de configuration. Passez à react-native-keychain quand vous avez besoin de règles biométriques plus fines ou que vous êtes dans une application sans Expo qui l'utilise déjà.

## Option 3 : MMKV chiffré pour les données sensibles plus volumineuses

Le stockage sécurisé est conçu pour de petits secrets, pas pour un cache de messages privés ou de données financières. Pour ces cas, j'utilise MMKV avec le chiffrement activé et je ne garde que la clé dans le stockage sécurisé :

```ts
import * as Crypto from 'expo-crypto';
import * as SecureStore from 'expo-secure-store';
import { createMMKV } from 'react-native-mmkv';

const KEY_NAME = 'mmkvEncryptionKey';

function getOrCreateEncryptionKey() {
  let key = SecureStore.getItem(KEY_NAME);
  if (!key) {
    // 16 octets aléatoires en hexadécimal = 32 caractères, le maximum pour AES-256 dans MMKV
    key = Array.from(Crypto.getRandomBytes(16), (b) => b.toString(16).padStart(2, '0')).join('');
    SecureStore.setItem(KEY_NAME, key, {
      keychainAccessible: SecureStore.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
    });
  }
  return key;
}

export const secureCache = createMMKV({
  id: 'secure-cache',
  encryptionKey: getOrCreateEncryptionKey(),
  encryptionType: 'AES-256',
});
```

J'utilise ici les fonctions synchrones `getItem` et `setItem` d'expo-secure-store pour que l'instance chiffrée puisse être créée au démarrage, avant le premier écran. La longueur de la clé compte : react-native-mmkv refuse les clés de plus de 16 octets en AES-128 et de plus de 32 octets en AES-256, ce que j'ai vérifié dans son code source. Vous gardez la vitesse de MMKV (j'en parle dans [comment rendre le stockage local rapide en React Native](https://arbabnaseer.com/fr/articles/stockage-local-rapide-react-native-mmkv/)) et les données sur le disque sont inutilisables sans la clé conservée dans le Keychain ou le Keystore.

Si les données sensibles sont relationnelles, le même principe fonctionne avec SQLite : expo-sqlite et op-sqlite prennent tous deux en charge SQLCipher, et vous gardez sa clé dans le stockage sécurisé.

## Le flux complet des tokens

En assemblant le tout, voici le flux que je mets en place dans les applications avec connexion :

1. **Connexion :** le serveur renvoie un access token et un refresh token. Enregistrez le refresh token dans le stockage sécurisé. Gardez l'access token dans une variable ou dans votre store d'état, pas sur le disque.
2. **Lancement de l'application :** lisez le refresh token. S'il existe, demandez un nouvel access token au serveur. Si la requête échoue avec une 401, renvoyez l'utilisateur vers l'écran de connexion.
3. **Appels API :** joignez l'access token gardé en mémoire. Sur une 401, rafraîchissez une fois et réessayez.
4. **Déconnexion :** supprimez le refresh token, videz les instances MMKV propres à l'utilisateur, videz le cache des requêtes et demandez au serveur de révoquer la session.

Un gestionnaire de tokens minimal :

```ts
import * as SecureStore from 'expo-secure-store';

let accessToken: string | null = null;

export const tokens = {
  getAccess: () => accessToken,
  setAccess: (token: string | null) => {
    accessToken = token;
  },
  async clearAll() {
    accessToken = null;
    await SecureStore.deleteItemAsync('refreshToken');
  },
};
```

Garder l'access token uniquement en mémoire signifie qu'une sauvegarde volée ou une copie des fichiers de l'application ne contient rien d'utile en dehors du refresh token, qui se trouve dans le Keychain ou le Keystore et que votre serveur peut révoquer.

## Deux particularités de plateforme à gérer

### iOS conserve les données du Keychain après la désinstallation

Sur iOS, les éléments du Keychain peuvent survivre à une désinstallation. Un utilisateur supprime votre application, la réinstalle quelques semaines plus tard et se retrouve « déjà connecté » avec une ancienne session, ou pire, avec la session de quelqu'un d'autre sur un appareil partagé. La documentation Expo le signale et conseille de ne pas compter sur ce comportement, dans un sens comme dans l'autre.

La solution s'appuie sur le fait que les fichiers MMKV, eux, sont supprimés à la désinstallation :

```ts
import * as SecureStore from 'expo-secure-store';
import { appStorage } from './storage';

export async function clearKeychainOnFreshInstall() {
  if (appStorage.getBoolean('hasLaunchedBefore')) return;
  await SecureStore.deleteItemAsync('refreshToken');
  appStorage.set('hasLaunchedBefore', true);
}
```

Appelez-la une fois au démarrage, avant de lire la session. Si le flag est absent, c'est une nouvelle installation, donc tout élément restant dans le Keychain est supprimé.

### Les sauvegardes Android ne peuvent pas restaurer les valeurs chiffrées

La sauvegarde automatique d'Android (Auto Backup) peut copier les shared preferences de votre application dans le cloud, mais la clé du Keystore qui sert à les chiffrer n'est jamais sauvegardée. Après une restauration sur un nouveau téléphone, les valeurs ne peuvent plus être déchiffrées. expo-secure-store exclut ses propres données de la sauvegarde automatique par défaut. Si votre application a une configuration de sauvegarde personnalisée, excluez vous-même les shared preferences de `SecureStore`, comme l'explique la [section Android Auto Backup](https://docs.expo.dev/versions/latest/sdk/securestore/#android-auto-backup) de la documentation, et assurez-vous que votre application gère l'absence de token en demandant à l'utilisateur de se reconnecter.

## Protection biométrique

Les deux bibliothèques peuvent exiger Face ID, Touch ID ou une empreinte digitale avant de lire une valeur. Avec expo-secure-store, passez `requireAuthentication: true` ; avec react-native-keychain, définissez `accessControl: Keychain.ACCESS_CONTROL.BIOMETRY_ANY`.

Réservez-la aux actions à fort enjeu, comme déverrouiller une application bancaire ou confirmer un paiement, et non au refresh token que votre application lit en silence à chaque lancement. Sachez aussi que les valeurs protégées de cette façon deviennent illisibles quand l'utilisateur modifie ses données biométriques (en ajoutant une nouvelle empreinte, par exemple) : prévoyez toujours un retour vers une connexion normale.

## Ce que le stockage sécurisé ne protège pas

Le stockage sécurisé protège les données au repos sur l'appareil. Il ne sert à rien si :

- Vous **écrivez les tokens dans les logs** avec `console.log` ou les envoyez à un outil de rapport de plantage.
- Vous mettez des tokens dans des **URL**, où ils finissent dans les logs des serveurs et des proxys.
- L'appareil est compromis et un attaquant **s'accroche à votre application en cours d'exécution**, lisant le token en mémoire une fois que vous l'avez chargé.

Pour ce dernier cas, il n'existe pas de réponse parfaite sur un appareil que vous ne contrôlez pas. Des access tokens à courte durée de vie, la rotation des refresh tokens et la révocation côté serveur limitent les dégâts. Le projet [OWASP Mobile Application Security](https://mas.owasp.org/) est la référence que j'utilise quand une application a besoin d'un vrai audit de sécurité.

## Questions fréquentes

### Où stocker un JWT en React Native ?

Stockez le refresh token dans expo-secure-store ou react-native-keychain, et gardez l'access token à courte durée de vie en mémoire. Si votre backend n'émet qu'un seul JWT à longue durée de vie, traitez-le comme un refresh token et gardez-le dans le stockage sécurisé.

### AsyncStorage est-il sûr pour les tokens ?

Non. AsyncStorage stocke les valeurs sans chiffrement dans le sandbox de l'application. La documentation de React Native déconseille d'y mettre des tokens ou des secrets. Utilisez le Keychain iOS et l'Android Keystore via une bibliothèque de stockage sécurisé.

### expo-secure-store est-il sûr ?

Oui, pour de petits secrets. Il stocke les valeurs dans le Keychain iOS et, sur Android, les chiffre avec une clé conservée dans l'Android Keystore. Il n'est pas conçu pour de grosses données, et certaines versions d'iOS refusaient les valeurs de plus d'environ 2048 octets.

### MMKV chiffré est-il aussi sûr que le Keychain ?

Seulement si la clé de chiffrement est bien protégée. Coder la clé en dur dans votre bundle JavaScript rend le chiffrement inutile, car n'importe qui peut l'extraire. Générez une clé aléatoire sur l'appareil et stockez-la dans SecureStore ou Keychain, comme montré plus haut.

### Pourquoi mon utilisateur est-il toujours connecté après une réinstallation sur iOS ?

Le Keychain iOS peut conserver des éléments après une désinstallation. Stockez un flag « a déjà été lancée » dans MMKV ou AsyncStorage, qui sont supprimés à la désinstallation, et videz les éléments du Keychain quand ce flag est absent.

### Le stockage sécurisé fonctionne-t-il dans Expo Go ?

expo-secure-store fonctionne dans Expo Go. react-native-keychain et react-native-mmkv contiennent du code natif, donc ils nécessitent un development build.

---

C'est la dernière partie de ma série sur le stockage local. Commencez par [MMKV vs AsyncStorage vs SQLite vs SecureStore](https://arbabnaseer.com/fr/articles/comparatif-stockage-local-react-native/) si vous l'avez sautée. Si vous voulez un développeur React Native attentif à la sécurité sur votre application, [contactez-moi](/fr/contact/).
