Résilience côté frontend : préparer tes apps aux pannes et attaques
En cybersécurité, la résilience est la capacité d'une application à continuer de fonctionner même après une panne ou une attaque. Côté frontend, cela implique des stratégies proactives pour gérer les erreurs, les pertes de connexion et les sessions compromises. Dans cet article, nous allons explorer les meilleures pratiques pour rendre vos applications React et React Native résilientes face aux imprévus.
Points essentiels à retenir:
- Implémenter des composants de fallback intelligents
- Mettre en place une gestion de session robuste
- Utiliser le stockage local pour la persistance
- Créer des workflows de récupération automatique
- Gérer les erreurs réseau de manière élégante
1. Composants de Fallback UI
Un composant de fallback est une interface utilisateur qui s'affiche lorsque quelque chose ne fonctionne pas comme prévu. Il permet de maintenir une expérience utilisateur fluide même en cas de problème.
Exemple de composant ErrorBoundary avec gestion de résilience
import React, { Component, ErrorInfo } from 'react';
interface Props {
children: React.ReactNode;
fallback?: React.ReactNode;
}
interface State {
hasError: boolean;
errorMessage?: string;
retryCount: number;
}
class ResilienceErrorBoundary extends Component<Props, State> {
constructor(props: Props) {
super(props);
this.state = {
hasError: false,
retryCount: 0
};
}
static getDerivedStateFromError(error: Error): State {
// Mise à jour de l'état pour afficher le fallback
return {
hasError: true,
errorMessage: error.message,
retryCount: 0
};
}
componentDidCatch(error: Error, errorInfo: ErrorInfo) {
// Logger l'erreur vers un service d'analytics
console.error('Resilience Boundary caught an error:', error, errorInfo);
// Envoyer vers un service de monitoring (ex: Sentry)
this.sendErrorToMonitoring(error, errorInfo);
}
sendErrorToMonitoring(error: Error, errorInfo: ErrorInfo) {
// Simulation d'envoi vers Sentry ou autre
// Sentry.captureException(error);
}
handleRetry = () => {
this.setState(prevState => ({
hasError: false,
retryCount: prevState.retryCount + 1
}));
}
render() {
if (this.state.hasError) {
// Fallback UI personnalisé
return this.props.fallback || (
<div className="error-container">
<h2>Une erreur inattendue est survenue</h2>
<p>{this.state.errorMessage}</p>
<button
onClick={this.handleRetry}
disabled={this.state.retryCount > 3}
>
{this.state.retryCount > 3
? 'Veuillez recharger la page'
: 'Réessayer'}
</button>
</div>
);
}
return this.props.children;
}
}
2. Gestion intelligente des sessions
La gestion des sessions est cruciale pour la résilience. Il faut anticiper les expirations, les déconnexions imprévues et les tentatives de fraude.
Exemple de gestionnaire de session résilient
// sessionManager.ts
interface SessionConfig {
tokenKey: string;
refreshThreshold: number; // en minutes avant expiration
maxRetries: number;
onLogout?: () => void; // Stratégie de redirection personnalisée
}
class SessionManager {
private config: SessionConfig;
private refreshTimer: NodeJS.Timeout | null = null;
constructor(config: SessionConfig) {
this.config = config;
this.initializeSessionCheck();
}
private initializeSessionCheck() {
// Vérifier la session au chargement
this.checkSession();
// Vérifier régulièrement l'état de la session
setInterval(() => this.checkSession(), 60000); // Toutes les minutes
}
private async checkSession() {
const token = localStorage.getItem(this.config.tokenKey);
if (!token) return;
try {
const tokenData = this.decodeToken(token);
const expiresIn = tokenData.exp * 1000 - Date.now();
// Rafraîchir le token si proche de l'expiration
if (expiresIn < this.config.refreshThreshold * 60000) {
await this.refreshToken();
}
} catch (error) {
console.error('Session check failed:', error);
// Fallback sur la déconnexion
this.clearSession();
}
}
async refreshToken() {
let attempt = 0;
while (attempt < this.config.maxRetries) {
try {
const response = await fetch('/api/refresh-token', {
method: 'POST',
headers: {
'Authorization': `Bearer ${localStorage.getItem(this.config.tokenKey)}`
}
});
if (response.ok) {
const { token } = await response.json();
localStorage.setItem(this.config.tokenKey, token);
return token;
}
attempt++;
} catch (error) {
attempt++;
await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
}
}
// Échec après les tentatives
this.clearSession();
throw new Error('Unable to refresh session');
}
clearSession() {
localStorage.removeItem(this.config.tokenKey);
// Rediriger selon l'environnement (SPA vs Web)
if (this.config.onLogout) {
this.config.onLogout();
} else {
// Fallback pour navigation classique
window.location.href = '/login';
}
}
private decodeToken(token: string) {
const base64Url = token.split('.')[1];
const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
return JSON.parse(window.atob(base64));
}
}
// Utilisation dans un contexte React SPA
import { useNavigate } from 'react-router-dom';
function useSessionManager() {
const navigate = useNavigate();
return new SessionManager({
tokenKey: 'auth_token',
refreshThreshold: 5, // 5 minutes avant expiration
maxRetries: 3,
onLogout: () => {
// Navigation SPA sécurisée
navigate('/login', { replace: true });
}
});
}
// Utilisation dans React Native
import { NavigationProp } from '@react-navigation/native';
function useRNSessionManager(navigation: NavigationProp<any>) {
return new SessionManager({
tokenKey: 'auth_token',
refreshThreshold: 5,
maxRetries: 3,
onLogout: () => {
navigation.reset({
index: 0,
routes: [{ name: 'Login' }],
});
}
});
}
3. Gestion proactive des erreurs réseau
La perte de connexion est l'un des problèmes les plus fréquents en frontend. Il faut mettre en place des mécanismes de détection et de récupération automatique.
Composant React pour la détection de connexion
import React, { useState, useEffect } from 'react';
interface NetworkStatus {
isOnline: boolean;
lastOnline: Date | null;
reconnectAttempts: number;
}
export function NetworkStatusDetector({ children }: { children: React.ReactNode }) {
const [networkStatus, setNetworkStatus] = useState<NetworkStatus>({
isOnline: navigator.onLine,
lastOnline: new Date(),
reconnectAttempts: 0
});
useEffect(() => {
const handleOnline = () => {
setNetworkStatus(prev => ({
isOnline: true,
lastOnline: new Date(),
reconnectAttempts: 0
}));
// Synchroniser les données en attente
synchronizePendingData();
};
const handleOffline = () => {
setNetworkStatus(prev => ({
...prev,
isOnline: false
}));
};
window.addEventListener('online', handleOnline);
window.addEventListener('offline', handleOffline);
return () => {
window.removeEventListener('online', handleOnline);
window.removeEventListener('offline', handleOffline);
};
}, []);
const synchronizePendingData = async () => {
// Récupérer les données en attente du localStorage
const pendingRequests = JSON.parse(localStorage.getItem('pendingRequests') || '[]');
for (const request of pendingRequests) {
try {
await fetch(request.url, request.options);
// Retirer la requête de la file d'attente
removeFromQueue(request.id);
} catch (error) {
console.error('Sync failed for request:', request.id);
}
}
};
const removeFromQueue = (requestId: string) => {
const pendingRequests = JSON.parse(localStorage.getItem('pendingRequests') || '[]');
const filtered = pendingRequests.filter((req: any) => req.id !== requestId);
localStorage.setItem('pendingRequests', JSON.stringify(filtered));
};
if (!networkStatus.isOnline) {
return (
<div style={{
padding: '15px',
backgroundColor: '#ff9800',
color: 'white',
textAlign: 'center',
position: 'fixed',
top: 0,
left: 0,
right: 0,
zIndex: 9999
}}>
Vous êtes actuellement hors ligne. Les changements seront synchronisés dès que la connexion sera rétablie.
</div>
);
}
return <>{children}</>;
}
4. Stockage local pour la persistance
Le stockage local permet de sauvegarder temporairement les données utilisateur pour ne pas les perdre en cas de problème réseau ou de crash de l'application.
Service de stockage résilient
// resilientStorage.ts
class ResilientStorage {
private readonly prefix = 'app_';
private readonly maxRetries = 3;
async saveData(key: string, data: any): Promise<boolean> {
let attempts = 0;
while (attempts < this.maxRetries) {
try {
const serializedData = JSON.stringify({
data,
timestamp: Date.now(),
version: '1.0'
});
localStorage.setItem(this.prefix + key, serializedData);
// Vérifier que les données ont bien été écrites
const verification = localStorage.getItem(this.prefix + key);
if (verification === serializedData) {
return true;
}
attempts++;
} catch (error) {
attempts++;
if (error instanceof DOMException && error.name === 'QuotaExceededError') {
// Essayer de libérer de l'espace
this.cleanupOldData();
}
}
}
return false;
}
async getData(key: string): Promise<any> {
try {
const raw = localStorage.getItem(this.prefix + key);
if (!raw) return null;
const { data, timestamp } = JSON.parse(raw);
// Vérifier si les données ne sont pas trop anciennes
const ageInHours = (Date.now() - timestamp) / (1000 * 60 * 60);
if (ageInHours > 24) {
// Données périmées, les supprimer
localStorage.removeItem(this.prefix + key);
return null;
}
return data;
} catch (error) {
console.error('Error reading from storage:', error);
return null;
}
}
private cleanupOldData() {
const keys = Object.keys(localStorage);
const appKeys = keys.filter(key => key.startsWith(this.prefix));
// Trier par timestamp et supprimer les plus anciennes
appKeys.sort((a, b) => {
const dataA = JSON.parse(localStorage.getItem(a) || '{}');
const dataB = JSON.parse(localStorage.getItem(b) || '{}');
return (dataA.timestamp || 0) - (dataB.timestamp || 0);
});
// Supprimer 20% des données les plus anciennes
const toRemove = Math.ceil(appKeys.length * 0.2);
for (let i = 0; i < toRemove; i++) {
localStorage.removeItem(appKeys[i]);
}
}
}
// Utilisation
const storage = new ResilientStorage();
// Sauvegarder des données de formulaire
async function saveFormData(formData: any) {
const saved = await storage.saveData('draft_form', formData);
if (!saved) {
alert('Impossible de sauvegarder localement. Vos données pourraient être perdues.');
}
}
5. Détection des comportements suspects
La résilience inclut aussi la capacité à détecter et réagir face aux activités suspectes qui pourraient indiquer une attaque.
Modal de sécurité personnalisé
// SecurityModal.tsx
import React from 'react';
interface SecurityModalProps {
message: string;
onConfirm: () => void;
onCancel: () => void;
}
export function SecurityModal({ message, onConfirm, onCancel }: SecurityModalProps) {
return (
<div className="fixed inset-0 z-50 flex items-center justify-center">
<div className="absolute inset-0 bg-black opacity-50" onClick={onCancel} />
<div className="relative bg-white rounded-lg p-6 max-w-md w-full mx-4">
<h3 className="text-lg font-semibold mb-4 text-red-600">
Alerte de sécurité
</h3>
<p className="mb-6">{message}</p>
<div className="flex justify-end space-x-4">
<button
onClick={onCancel}
className="px-4 py-2 text-gray-600 hover:text-gray-800"
>
Continuer
</button>
<button
onClick={onConfirm}
className="px-4 py-2 bg-red-600 text-white rounded hover:bg-red-700"
>
Me déconnecter
</button>
</div>
</div>
</div>
);
}
Détecteur d'activités suspectes
// securityMonitor.ts
interface SecurityEvent {
type: 'multiple_login_attempts' | 'unusual_location' | 'rapid_requests' | 'token_tampering';
timestamp: number;
metadata?: any;
}
interface SecurityMonitorConfig {
alertThreshold?: number;
tokenKey: string;
onSecurityAlert?: (options: {
message: string;
onConfirm: () => void;
onCancel: () => void;
}) => void;
clearAuthData?: () => void;
onForceLogout?: (reason: string) => void;
}
class SecurityMonitor {
private events: SecurityEvent[] = [];
private readonly alertThreshold: number;
private readonly config: SecurityMonitorConfig;
constructor(config: SecurityMonitorConfig) {
this.config = config;
this.alertThreshold = config.alertThreshold || 5;
}
recordEvent(event: SecurityEvent) {
this.events.push(event);
this.analyzeRecentEvents();
}
private analyzeRecentEvents() {
// Analyser les événements des 5 dernières minutes
const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
const recentEvents = this.events.filter(e => e.timestamp > fiveMinutesAgo);
// Détecter les patterns suspects
const suspiciousPatterns = {
multipleLoginAttempts: recentEvents.filter(e => e.type === 'multiple_login_attempts').length >= 3,
rapidRequests: recentEvents.filter(e => e.type === 'rapid_requests').length >= 10,
mixedSuspiciousActivity: recentEvents.length >= this.alertThreshold
};
if (Object.values(suspiciousPatterns).some(Boolean)) {
this.triggerSecurityAlert(recentEvents);
}
}
private triggerSecurityAlert(events: SecurityEvent[]) {
// Afficher une alerte via un système de notification personnalisé
if (this.config.onSecurityAlert) {
this.config.onSecurityAlert({
message: 'Nous avons détecté une activité inhabituelle sur votre compte.',
onConfirm: () => this.forceLogout(),
onCancel: () => this.sendSecurityLogs(events)
});
} else {
// Fallback sur confirm natif
const userAlert = confirm(
'Nous avons détecté une activité inhabituelle sur votre compte. ' +
'Souhaitez-vous vous déconnecter pour sécuriser votre session ?'
);
if (userAlert) {
this.forceLogout();
} else {
this.sendSecurityLogs(events);
}
}
}
private forceLogout() {
// Nettoyage ciblé des données d'authentification uniquement
if (this.config.clearAuthData) {
this.config.clearAuthData();
} else {
localStorage.removeItem(this.config.tokenKey);
sessionStorage.removeItem(this.config.tokenKey);
}
// Redirection personnalisée
if (this.config.onForceLogout) {
this.config.onForceLogout('security_alert');
} else {
window.location.href = '/login?reason=security_alert';
}
}
private async sendSecurityLogs(events: SecurityEvent[]) {
try {
await fetch('/api/security/log', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ events })
});
} catch (error) {
console.error('Failed to send security logs:', error);
}
}
}
À Retenir
- Composants de fallback : Créez des interfaces de secours élégantes pour maintenir l'expérience utilisateur même en cas d'erreur
- Gestion de session proactive : Surveillez et rafraîchissez les tokens automatiquement avant leur expiration
- Détection réseau : Implémentez des mécanismes pour détecter la perte de connexion et synchroniser les données dès le retour en ligne
- Stockage local résilient : Utilisez le localStorage avec prudence et mettez en place des stratégies de nettoyage automatique
- Surveillance de sécurité : Détectez les comportements suspects côté client pour réagir rapidement aux tentatives d'attaque