Meilleures Pratiques de Validation d'Horodatages : Guide Complet

Introduction

La validation des horodatages est cruciale pour la sécurité et la fiabilité de votre application. Ce tutoriel couvre les meilleures pratiques pour valider les horodatages dans différents contextes.

Ce que Vous Apprendrez

• ✅ Validation de format et longueur
• ✅ Validation de plage
• ✅ Validation de précision
• ✅ Validation de fuseau horaire
• ✅ Considérations de sécurité

Validation de Format

JavaScript

Copy
JAVASCRIPT
1function validerTimestamp(valeur) {
2  // Doit être un nombre ou une chaîne numérique
3  const num = Number(valeur);
4  
5  if (isNaN(num)) {
6    return { valide: false, erreur: 'Pas un nombre valide' };
7  }
8  
9  // Vérifier la longueur pour déterminer la précision
10  const str = String(Math.floor(num));
11  const longueurs = [10, 13, 16, 19];
12  
13  if (!longueurs.includes(str.length)) {
14    return { 
15      valide: false, 
16      erreur: `Longueur invalide : ${str.length}. Attendu : ${longueurs.join(', ')}` 
17    };
18  }
19  
20  return { valide: true, precision: obtenirPrecision(str.length) };
21}
22
23function obtenirPrecision(longueur) {
24  const carte = { 10: 'secondes', 13: 'millisecondes', 16: 'microsecondes', 19: 'nanosecondes' };
25  return carte[longueur];
26}

Python

Copy
PYTHON
1def valider_timestamp(valeur: str) -> dict:
2    """Valide le format de l'horodatage"""
3    # Chiffres uniquement
4    if not valeur.isdigit():
5        return {'valide': False, 'erreur': 'Doit contenir uniquement des chiffres'}
6    
7    longueur = len(valeur)
8    precisions = {10: 'secondes', 13: 'millisecondes', 16: 'microsecondes', 19: 'nanosecondes'}
9    
10    if longueur not in precisions:
11        return {
12            'valide': False, 
13            'erreur': f'Longueur invalide : {longueur}. Attendu : {list(precisions.keys())}'
14        }
15    
16    return {'valide': True, 'precision': precisions[longueur]}

Validation de Plage

Plages Valides par Précision

JavaScript

Copy
JAVASCRIPT
1function validerPlage(timestamp, precision = 'millisecondes') {
2  const PLAGES = {
3    secondes: { min: 0, max: 253402300799 },
4    millisecondes: { min: 0, max: 253402300799999 },
5    microsecondes: { min: 0, max: 253402300799999999n },
6    nanosecondes: { min: 0n, max: 253402300799999999999n }
7  };
8  
9  const plage = PLAGES[precision];
10  if (!plage) {
11    return { valide: false, erreur: 'Précision inconnue' };
12  }
13  
14  const valeur = precision.includes('nano') ? BigInt(timestamp) : Number(timestamp);
15  
16  if (valeur < plage.min || valeur > plage.max) {
17    return { 
18      valide: false, 
19      erreur: `Hors plage : ${plage.min} - ${plage.max}` 
20    };
21  }
22  
23  return { valide: true };
24}

Validation de Plage Métier

Copy
PYTHON
1from datetime import datetime, timezone
2
3def valider_plage_metier(timestamp_ms: int, config: dict) -> dict:
4    """Valide que l'horodatage est dans les plages métier"""
5    dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
6    
7    # Ne peut pas être dans le futur
8    if config.get('pas_futur', True):
9        if dt > datetime.now(timezone.utc):
10            return {'valide': False, 'erreur': 'Horodatage dans le futur'}
11    
12    # Ne peut pas être trop ancien
13    annee_min = config.get('annee_minimum', 2000)
14    if dt.year < annee_min:
15        return {'valide': False, 'erreur': f'Année antérieure à {annee_min}'}
16    
17    # Ne peut pas être trop dans le futur
18    annee_max = config.get('annee_maximum', 2100)
19    if dt.year > annee_max:
20        return {'valide': False, 'erreur': f'Année postérieure à {annee_max}'}
21    
22    return {'valide': True, 'datetime': dt}

Validation de Fuseau Horaire

Valider ISO 8601 avec Fuseau Horaire

Copy
JAVASCRIPT
1function validerIso8601(valeur) {
2  // Regex pour ISO 8601 avec fuseau horaire obligatoire
3  const regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
4  
5  if (!regex.test(valeur)) {
6    return { 
7      valide: false, 
8      erreur: 'Format ISO 8601 invalide ou fuseau horaire manquant' 
9    };
10  }
11  
12  const date = new Date(valeur);
13  if (isNaN(date.getTime())) {
14    return { valide: false, erreur: 'Date résultante invalide' };
15  }
16  
17  return { valide: true, date };
18}

Valider Identifiant de Fuseau Horaire

Copy
PYTHON
1from zoneinfo import ZoneInfo
2
3def valider_fuseau_horaire(zone: str) -> dict:
4    """Valide qu'il s'agit d'un identifiant IANA valide"""
5    try:
6        ZoneInfo(zone)
7        return {'valide': True}
8    except Exception as e:
9        return {'valide': False, 'erreur': f'Fuseau horaire invalide : {zone}'}
10
11# Exemple
12print(valider_fuseau_horaire('America/New_York'))  # {'valide': True}
13print(valider_fuseau_horaire('EST'))  # {'valide': False, ...} - ambigu

Considérations de Sécurité

1. Prévenir l'Injection

Copy
JAVASCRIPT
1function assainirTimestamp(entree) {
2  // N'autoriser que les chiffres et caractères ISO valides
3  const assaini = String(entree).replace(/[^0-9TZ:.\-+]/g, '');
4  
5  if (assaini !== String(entree)) {
6    throw new Error('Caractères invalides détectés');
7  }
8  
9  return assaini;
10}

2. Prévenir le Dépassement

Copy
PYTHON
1import sys
2
3def valider_sans_depassement(valeur: str) -> dict:
4    """Prévient le dépassement d'entiers"""
5    try:
6        num = int(valeur)
7        
8        # Vérifier les limites 64-bit
9        if num > sys.maxsize:
10            return {'valide': False, 'erreur': 'Dépasse la limite d\'entier'}
11        
12        if num < 0:
13            return {'valide': False, 'erreur': 'Horodatages négatifs non autorisés'}
14        
15        return {'valide': True, 'valeur': num}
16    except ValueError:
17        return {'valide': False, 'erreur': 'Pas un entier valide'}

3. Rate Limiting pour Horodatages

Copy
JAVASCRIPT
1// Prévenir la manipulation d'horodatages dans les requêtes
2function validerTimestampRequete(timestamp, toleranceMs = 30000) {
3  const maintenant = Date.now();
4  const diff = Math.abs(maintenant - timestamp);
5  
6  if (diff > toleranceMs) {
7    return { 
8      valide: false, 
9      erreur: `Horodatage hors tolérance : ${diff}ms > ${toleranceMs}ms` 
10    };
11  }
12  
13  return { valide: true };
14}

Résumé

• Validez le format : Vérifiez longueur et caractères
• Validez la plage : Technique et métier
• Validez le fuseau horaire : Utilisez les identifiants IANA
• Considérez la sécurité : Assainissez, prévenez le dépassement
• Utilisez des validateurs complets : Combinez toutes les validations

Essayez notre Convertisseur Unix Timestamp pour valider les horodatages !