Authentification MFA avec React Native & NestJS

Implémentation complète de l'authentification multi-facteurs avec TOTP et SMS.

Sécurité

Implémentation MFA avec React Native et NestJS

L'authentification multi-facteurs (MFA) est devenue incontournable pour toute application nécessitant un haut niveau de sécurité. Cet article vous guide à travers l'implémentation complète d'un système MFA robuste en utilisant React Native pour le frontend mobile et NestJS pour l'API backend, dans une approche Zero Trust moderne.

Points essentiels à retenir:

  • Le MFA améliore significativement la sécurité en ajoutant une deuxième couche de vérification
  • Un code OTP à usage unique permet de vérifier l'identité de l'utilisateur
  • React Native + NestJS forment une stack moderne et typée pour l'implémentation MFA
  • Une architecture bien structurée facilite la maintenance et l'évolution
  • Le modèle Zero Trust devient indispensable pour sécuriser les applications modernes

1. Architecture globale de la solution MFA

L'authentification à deux facteurs (2FA) suit un flux précis où l'utilisateur doit prouver son identité par deux moyens différents. Dans notre implémentation, nous combinons :

  1. Une authentification classique par email/mot de passe
  2. Un code de vérification à usage unique (OTP - One Time Password)

Ce processus se décompose en plusieurs étapes clés, formant un circuit complet et sécurisé :

Login Vérification OTP Zone sécurisée Validation creds Validation OTP Vérif JWT Token Session Token sessionToken JWT Tokens JWT Tokens

L'implémentation complète comprend les étapes suivantes :

  • Configuration de l'environnement et des projets frontend/backend
  • Développement des écrans d'authentification en React Native
  • Implémentation de l'API d'authentification en NestJS
  • Tests et corrections

2. Frontend : React Native avec TypeScript

L'interface utilisateur mobile est composée de trois écrans principaux que l'on peut voir dans les captures d'écran :

Écran de login avec champs email et mot de passe
Écran de saisie du code OTP à 6 chiffres
Écran d'accueil sécurisé

2.1 Architecture des composants

Nous adoptons une approche "feature-first" qui organise le code par fonctionnalité plutôt que par type de fichier. C'est particulièrement adapté aux applications avec plusieurs domaines fonctionnels :

Structure du projet React Native

src/
├── features/
│   └── auth/
│       ├── screens/
│       │   ├── LoginScreen.tsx
│       │   ├── OtpScreen.tsx
│       │   └── HomeScreen.tsx
│       ├── context/
│       │   └── AuthProvider.tsx
│       └── services/
│           └── authApi.ts
├── shared/
│   ├── theme/
│   ├── utils/
│   │   └── axiosInstance.ts
│   └── components/
└── navigation/
    └── AppNavigator.tsx

Cette organisation facilite la maintenance et permet une meilleure séparation des responsabilités. Chaque fonctionnalité contient ses écrans, services et logique métier spécifiques, ce qui s'aligne parfaitement avec une approche Zero Trust où chaque module peut avoir son propre contrôle d'accès.

3. Le modèle Zero Trust et son application

Notre implémentation MFA s'inscrit dans le cadre plus large du modèle de sécurité Zero Trust, devenu essentiel dans le développement d'applications modernes distribuées.

Principes fondamentaux du Zero Trust

  • Ne jamais faire confiance par défaut, toujours vérifier
  • Appliquer le principe du moindre privilège
  • Vérifier constamment les accès, même après authentification
  • Segmenter les ressources et contrôler chaque accès individuellement

Voici comment ces principes se traduisent concrètement dans notre implémentation :

Application des principes Zero Trust dans le code

// Dans AuthProvider.tsx
const checkAccessPermission = async (feature: string) => {
  // 1. Vérification du token (validité, expiration)
  const token = await secureStorage.getItem('accessToken');
  if (!token || isTokenExpired(token)) {
    await refreshToken(); // Renouvellement automatique
  }
  
  // 2. Vérification du contexte d'exécution
  const deviceInfo = await getDeviceInfo();
  const lastKnownDevice = await secureStorage.getItem('lastDevice');
  
  if (deviceInfo.id !== lastKnownDevice) {
    // Demande de re-vérification si appareil différent
    return logoutAndRequestReauth();
  }
  
  // 3. Vérification des permissions spécifiques à la feature
  const permissions = decodePermissions(token);
  
  return permissions.includes(feature)
    ? { granted: true }
    : { granted: false, reason: 'insufficient_permissions' };
}

3.1 Architecture Zero Trust dans notre application

Notre implémentation respecte ces principes grâce à :

  • Segmentation modulaire : Chaque feature est isolée avec son propre contrôle d'accès
  • Vérification continue : Les tokens sont vérifiés à chaque requête API
  • Sessions contextuelles : Nous associons l'appareil avec la session utilisateur
  • Renouvellement automatique : Les tokens d'accès sont de courte durée (15min) et renouvelés par un refresh token

Cette approche offre un niveau de sécurité bien supérieur à une authentification classique.

4.1 Implémentation des écrans clés

Examinons maintenant le code des composants essentiels pour l'authentification MFA :

LoginScreen.tsx - Écran de connexion initial

import React, { useState } from 'react';
import { View, Text, TextInput, TouchableOpacity, StyleSheet, Image } from 'react-native';
import { useAuth } from '../context/AuthProvider';
import { FONTS } from '../../../shared/theme/fonts';
import { COLORS } from '../../../shared/theme/theme';

export default function LoginScreen() {
  const { signIn } = useAuth();
  
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  
  const handleSubmit = () => {
    signIn(email, password);
  };
  
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Démo MFA</Text>
      
      <TextInput
        placeholder="Email"
        value={email}
        onChangeText={setEmail}
        style={styles.input}
        keyboardType="email-address"
        autoCapitalize="none"
      />
      <TextInput
        placeholder="Mot de passe"
        value={password}
        onChangeText={setPassword}
        style={styles.input}
        secureTextEntry
      />
      
      <TouchableOpacity>
        <Text style={styles.forgotPassword}>Mot de passe oublié ?</Text>
      </TouchableOpacity>
      
      <TouchableOpacity style={styles.button} onPress={handleSubmit}>
        <Text style={styles.buttonText}>Se connecter</Text>
      </TouchableOpacity>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: COLORS.primary,
    alignItems: 'center',
    justifyContent: 'center',
    padding: 20,
  },
  image: {
    width: 180,
    height: 180,
    marginBottom: 20,
    resizeMode: 'contain',
  },
  title: {
    fontSize: 28,
    fontFamily: FONTS.bold,
    color: COLORS.secondary,
    marginBottom: 24,
  },
  input: {
    width: '100%',
    backgroundColor: COLORS.background,
    padding: 12,
    borderRadius: 8,
    marginBottom: 12,
    fontFamily: FONTS.regular,
  },
  forgotPassword: {
    alignSelf: 'flex-end',
    marginBottom: 20,
    color: COLORS.background,
    fontSize: 14,
    fontFamily: FONTS.regular,
  },
  button: {
    backgroundColor: COLORS.background,
    paddingVertical: 14,
    paddingHorizontal: 24,
    borderRadius: 8,
    width: '100%',
  },
  buttonText: {
    color: COLORS.text,
    textAlign: 'center',
    fontFamily: FONTS.bold,
    fontSize: 16,
  },
});

OtpScreen.tsx - Écran de vérification du code OTP

import React, { useState } from 'react';
import { View, Text, TextInput, TouchableOpacity, StyleSheet } from 'react-native';
import { useAuth } from '../context/AuthProvider';
import { FONTS } from '../../../shared/theme/fonts';
import { COLORS } from '../../../shared/theme/theme';

export default function OtpScreen() {
  const { verifyOtpCode } = useAuth();
  const [code, setCode] = useState('');
  
  const handleSubmit = () => {
    verifyOtpCode(code);
  };
  
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Code de vérification</Text>
      <TextInput
        style={styles.input}
        value={code}
        onChangeText={setCode}
        placeholder="6 chiffres"
        keyboardType="numeric"
        maxLength={6}
      />
      <TouchableOpacity style={styles.button} onPress={handleSubmit}>
        <Text style={styles.buttonText}>Valider</Text>
      </TouchableOpacity>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: COLORS.primary,
    justifyContent: 'center',
    alignItems: 'center',
    padding: 24,
  },
  title: {
    fontSize: 24,
    fontFamily: FONTS.bold,
    marginBottom: 20,
  },
  input: {
    backgroundColor: COLORS.background,
    padding: 12,
    fontFamily: FONTS.regular,
    fontSize: 18,
    borderRadius: 8,
    width: '100%',
    textAlign: 'center',
    marginBottom: 20,
  },
  button: {
    backgroundColor: COLORS.background,
    padding: 14,
    borderRadius: 8,
    width: '100%',
  },
  buttonText: {
    color: COLORS.primary,
    textAlign: 'center',
    fontFamily: FONTS.bold,
    fontSize: 16,
  },
});
          </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    justifyContent: 'center',
    backgroundColor: '#EFB93D',
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 40,
    textAlign: 'center',
    color: '#333',
  },
  input: {
    backgroundColor: 'white',
    borderRadius: 8,
    padding: 15,
    marginBottom: 30,
    textAlign: 'center',
    fontSize: 18,
  },
  verifyButton: {
    backgroundColor: 'white',
    borderRadius: 8,
    padding: 15,
    alignItems: 'center',
  },
  buttonText: {
    fontWeight: 'bold',
    color: '#333',
  },
  errorText: {
    color: 'red',
    marginTop: 10,
    textAlign: 'center',
  }
});

4.2 Gestion de l'authentification avec AuthProvider

Le cœur de notre système d'authentification est géré par un contexte React qui encapsule toute la logique d'authentification, les requêtes API, et le stockage sécurisé des tokens :

AuthProvider.tsx - Le gestionnaire central d'authentification

import React, { createContext, useContext, useState, useEffect } from 'react';
import * as SecureStore from 'expo-secure-store';
import { login, verifyOtp, refreshTokens } from '../services/authApi';

const AuthContext = createContext(null);

export const AuthProvider = ({ children }) => {
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState(null);
  const [sessionToken, setSessionToken] = useState(null);
  const [user, setUser] = useState(null);
  const [tokens, setTokens] = useState({
    accessToken: null,
    refreshToken: null,
  });

  // Tente de restaurer la session au démarrage
  useEffect(() => {
    const loadTokens = async () => {
      try {
        const accessToken = await SecureStore.getItemAsync('accessToken');
        const refreshToken = await SecureStore.getItemAsync('refreshToken');
        const userData = await SecureStore.getItemAsync('user');
        
        if (accessToken && refreshToken && userData) {
          setTokens({
            accessToken,
            refreshToken,
          });
          setUser(JSON.parse(userData));
        }
      } catch (err) {
        console.error('Failed to load auth info', err);
      }
    };
    
    loadTokens();
  }, []);

  // Effectue le premier login (email + mot de passe)
  const handleLogin = async (email, password) => {
    setIsLoading(true);
    setError(null);
    
    try {
      const response = await login(email, password);
      setSessionToken(response.sessionToken);
      
      // Stocke le token de session temporaire
      await SecureStore.setItemAsync('sessionToken', response.sessionToken);
      
      return true;
    } catch (err) {
      setError(err.message || 'Échec de connexion');
      return false;
    } finally {
      setIsLoading(false);
    }
  };

  // Vérifie le code OTP
  const handleVerifyOtp = async (otpCode) => {
    setIsLoading(true);
    setError(null);
    
    try {
      // Récupère le token de session stocké
      const storedSessionToken = await SecureStore.getItemAsync('sessionToken');
      const sessionToUse = sessionToken || storedSessionToken;
      
      if (!sessionToUse) {
        throw new Error('Session expirée');
      }
      
      // Appel API pour vérifier l'OTP
      const response = await verifyOtp(sessionToUse, otpCode);
      
      // Stocke en sécurité les tokens et infos utilisateur
      await SecureStore.setItemAsync('accessToken', response.accessToken);
      await SecureStore.setItemAsync('refreshToken', response.refreshToken);
      await SecureStore.setItemAsync('user', JSON.stringify(response.user));
      
      // Met à jour l'état
      setTokens({
        accessToken: response.accessToken,
        refreshToken: response.refreshToken,
      });
      setUser(response.user);
      
      // Nettoie le token de session temporaire
      await SecureStore.deleteItemAsync('sessionToken');
      setSessionToken(null);
      
      return true;
    } catch (err) {
      setError(err.message || 'Code de vérification invalide');
      return false;
    } finally {
      setIsLoading(false);
    }
  };

  // Déconnexion
  const handleLogout = async () => {
    // Supprime tous les tokens et données de session
    await SecureStore.deleteItemAsync('accessToken');
    await SecureStore.deleteItemAsync('refreshToken');
    await SecureStore.deleteItemAsync('user');
    await SecureStore.deleteItemAsync('sessionToken');
    
    // Réinitialise l'état
    setTokens({ accessToken: null, refreshToken: null });
    setUser(null);
    setSessionToken(null);
  };

  // Rafraîchit le token d'accès
  const handleRefreshToken = async () => {
    try {
      const response = await refreshTokens(tokens.refreshToken);
      
      // Met à jour les tokens
      await SecureStore.setItemAsync('accessToken', response.accessToken);
      
      setTokens({
        ...tokens,
        accessToken: response.accessToken,
      });
      
      return true;
    } catch (err) {
      // En cas d'échec, déconnecte l'utilisateur
      await handleLogout();
      return false;
    }
  };

  return (
    <AuthContext.Provider
      value={{
        isAuthenticated: !!user,
        user,
        isLoading,
        error,
        login: handleLogin,
        verifyOtp: handleVerifyOtp,
        logout: handleLogout,
        refreshToken: handleRefreshToken,
      }}
    >
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => useContext(AuthContext);

5. Backend NestJS: API sécurisée

Côté serveur, notre API NestJS gère l'authentification, la génération des codes OTP, et la validation des tokens. Voici les principales composantes :

5.1 Contrôleur d'authentification

auth.controller.ts - Points d'entrée API pour l'authentification

import { Controller, Post, Body, UnauthorizedException } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LoginDto } from './dto/login.dto';
import { VerifyOtpDto } from './dto/verify-otp.dto';
import { RefreshTokenDto } from './dto/refresh-token.dto';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('login')
  async login(@Body() dto: LoginDto) {
    const user = await this.authService.validateUser(dto.email, dto.password);
    if (!user) throw new UnauthorizedException('Identifiants invalides');

    const sessionToken = await this.authService.generateOtp(user.id);
    return {
      otp_required: true,
      sessionToken,
    };
  }

  @Post('verify-otp')
  async verifyOtp(@Body() dto: VerifyOtpDto) {
    const userId = this.authService.verifyOtp(dto.sessionToken, dto.otp);
    if (!userId) throw new UnauthorizedException('Code OTP invalide ou expiré');

    const tokens = this.authService.generateTokens(userId);
    return {
      accessToken: tokens.accessToken,
      refreshToken: tokens.refreshToken,
      user: {
        id: userId,
        email: 'test@example.com',
      },
    };
  }

  @Post('refresh')
  refreshAccessToken(@Body() dto: RefreshTokenDto) {
    const newToken = this.authService.refreshAccessToken(dto.refreshToken);
    if (!newToken) throw new UnauthorizedException('Refresh token invalide ou expiré');

    return {
      accessToken: newToken,
    };
  }
}

5.2 Service d'authentification

auth.service.ts - Logique métier d'authentification

import { Injectable } from '@nestjs/common';
import * as jwt from 'jsonwebtoken';
import { OtpService } from './otp/otp.service';

@Injectable()
export class AuthService {
  constructor(private readonly otpService: OtpService) {}

  async validateUser(
    email: string,
    password: string,
  ): Promise<{ id: string; email: string } | null> {
    if (email === 'test@example.com' && password === 'password123') {
      return { id: '1', email };
    }
    return null;
  }

  generateOtp(userId: string): string {
    return this.otpService.generateOtp(userId);
  }

  verifyOtp(sessionToken: string, code: string): string | null {
    return this.otpService.verifyOtp(sessionToken, code);
  }

  generateTokens(userId: string): {
    accessToken: string;
    refreshToken: string;
  } {
    const JWT_SECRET = process.env.JWT_SECRET ?? 'demo_mfa_fallback_secret';
    const JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET ?? 'demo_mfa_fallback_refresh';

    const accessToken = jwt.sign({ sub: userId }, JWT_SECRET, {
      expiresIn: '15m',
    });

    const refreshToken = jwt.sign(
      { sub: userId },
      JWT_REFRESH_SECRET,
      { expiresIn: '7d' },
    );

    return { accessToken, refreshToken };
  }
  
  refreshAccessToken(refreshToken: string): string | null {
    const JWT_SECRET = process.env.JWT_SECRET ?? 'demo_mfa_fallback_secret';
    const JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET ?? 'demo_mfa_fallback_refresh';
  
    try {
      const decoded = jwt.verify(refreshToken, JWT_REFRESH_SECRET) as { sub: string };
      const accessToken = jwt.sign({ sub: decoded.sub }, JWT_SECRET, { expiresIn: '15m' });
      return accessToken;
    } catch (err) {
      return null;
    }
  }
}signAsync(
        { sub: userId, type: 'refresh' },
        { expiresIn: '7d' }, // Token de rafraîchissement plus long
      ),
    ]);
    
    return { accessToken, refreshToken };
  }

  // Rafraîchit le token d'accès
  async refreshTokens(refreshToken: string) {
    try {
      // Vérifie le token de rafraîchissement
      const decoded = this.jwtService.verify(refreshToken, {
        secret: process.env.JWT_REFRESH_SECRET,
      });
      
      if (decoded.type !== 'refresh') {
        throw new UnauthorizedException('Invalid token type');
      }
      
      // Génère un nouveau token d'accès
      const accessToken = await this.jwtService.signAsync(
        { sub: decoded.sub, type: 'access' },
        { expiresIn: '15m' },
      );
      
      return { accessToken };
    } catch (error) {
      throw new UnauthorizedException('Invalid refresh token');
    }
  }

  // Récupère le profil utilisateur
  async getUserProfile(userId: number) {
    return this.userService.findById(userId);
  }
}

6. Intégration du modèle Zero Trust

Conformément aux principes Zero Trust mentionnés précédemment, notre implémentation intègre plusieurs niveaux de sécurité :

  1. Authentification à deux facteurs : Un premier niveau avec email/mot de passe, suivi d'un code OTP à usage unique
  2. Tokens à durée limitée : Le token d'accès a une durée de vie courte (15 minutes)
  3. Vérification continue : Chaque requête API vérifie la validité du token
  4. Stockage sécurisé : Utilisation de SecureStore pour stocker les tokens côté client
  5. Validation du contexte d'exécution : Vérification de l'appareil lors des requêtes sensibles
Couche Utilisateur Login MFA Vérif. Contexte Tokens JWT Stockage Sécurisé Couche Réseau HTTPS/TLS Validation IP Rate Limiting Protection CSRF Couche Application Validation JWT ACL par Module Audit Logs Privilèges minimaux

À Retenir

  • MFA comme fondation : L'authentification multi-facteurs est essentielle pour répondre aux exigences de sécurité modernes.
  • Architecture modulaire : La structure feature-first facilite l'isolation et la sécurisation du code.
  • Sécurité proactive : Le modèle Zero Trust implémente un contrôle constant et granulaire des accès.
  • React Native + NestJS : Une stack complète et typée pour simplifier le développement d'applications sécurisées.
  • Planning : Prévoir une organisation adéquate pour une implémentation complète du MFA selon les principes Zero Trust.