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 :
- Une authentification classique par email/mot de passe
- 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é :
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 :
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é :
- Authentification à deux facteurs : Un premier niveau avec email/mot de passe, suivi d'un code OTP à usage unique
- Tokens à durée limitée : Le token d'accès a une durée de vie courte (15 minutes)
- Vérification continue : Chaque requête API vérifie la validité du token
- Stockage sécurisé : Utilisation de SecureStore pour stocker les tokens côté client
- Validation du contexte d'exécution : Vérification de l'appareil lors des requêtes sensibles
À 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.