TOTP et NTP : Pourquoi Vos Codes 2FA Dépendent de l'Heure Exacte

Par Richard DEMONGEOT | 11 février 2026 | Temps de lecture : 9 min
TOTP et NTP : la sécurité du temps garantit l'authentification — schéma NTS, satellites GNSS et validation 2FA

Qu'est-ce que TOTP ?

TOTP signifie Time-based One-Time Password (mot de passe à usage unique basé sur le temps). C'est l'algorithme qui se cache derrière les codes à 6 chiffres que vous saisissez lors de la double authentification (2FA).

Défini dans la RFC 6238 (publiée en 2011), TOTP est une extension de HOTP (RFC 4226, basé sur un compteur) où le compteur est remplacé par le temps.

Le principe est simple :

  1. Votre application et le serveur partagent un secret (établi lors de la configuration initiale, souvent via QR code)
  2. Les deux parties utilisent l'heure actuelle pour calculer un code
  3. Si les deux codes correspondent, l'authentification est validée

Comment Fonctionne l'Algorithme

L'algorithme TOTP se décompose en trois étapes principales. Voici une vue simplifiée du calcul que votre application effectue plusieurs fois par minute :

// Étape 1 : Obtenir l'intervalle de temps actuel
T = floor(timestamp_unix / 30)

// Exemple : le 11 février 2026 à 14:30:00 UTC
// timestamp = 1770843000
// T = 1770843000 / 30 = 59028100

// Étape 2 : Calculer le HMAC
hmac = HMAC-SHA1(secret, T)

// Étape 3 : Tronquer pour obtenir 6 chiffres
offset = hmac[dernier_octet] & 0x0F
code   = (hmac[offset..offset+3] & 0x7FFFFFFF) % 1000000

// Résultat : un code à 6 chiffres, par ex. 482937

Le point crucial est l'étape 1 : le calcul repose entièrement sur le timestamp UNIX, c'est-à-dire le nombre de secondes écoulées depuis le 1er janvier 1970 00:00:00 UTC. La division par 30 crée des "intervalles" de 30 secondes.

Le Lien entre NTP et TOTP

Pour que TOTP fonctionne, il faut que deux appareils qui ne communiquent pas directement entre eux arrivent au même résultat. La seule variable commune est le temps.

Votre téléphone
Secret + Heure
Code: 482937
↓ NTP synchronise l'heure des deux côtés ↓
Serveur d'auth
Secret + Heure
Code: 482937
Même secret + même heure = même code

NTP est le garant de cette synchronisation. Votre téléphone se synchronise via les serveurs NTP de votre opérateur ou du fabricant (Google, Apple). Le serveur d'authentification se synchronise via ses propres sources NTP. Les deux parties obtiennent ainsi une heure cohérente à quelques millisecondes près — largement suffisant pour les intervalles de 30 secondes de TOTP.

Pour comprendre en détail comment fonctionne le protocole NTP, consultez notre guide dédié.

Les Applications d'Authentification

Toutes ces applications utilisent le même algorithme TOTP (RFC 6238). Elles sont donc interchangeables pour la plupart des services :

G

Google Authenticator

La plus connue. Simple, pas de sauvegarde cloud (par défaut).

M

Microsoft Authenticator

Sauvegarde cloud, notifications push, compatibilité Microsoft 365.

A

Authy (Twilio)

Sauvegarde chiffrée, multi-appareils, application desktop.

F

FreeOTP / FreeOTP+

Open source (Red Hat). Aucune dépendance cloud.

Y

Yubico Authenticator

Stocke les secrets sur une YubiKey physique. Utilise l'horloge de l'appareil hôte.

2

2FAS

Open source, sauvegarde chiffrée, interface moderne.

Que Se Passe-t-il Quand l'Horloge Dérive ?

Un quartz d'appareil mobile dérive typiquement de 0,5 à 2 secondes par jour. Sans synchronisation NTP régulière, cette dérive s'accumule et finit par poser problème.

Décalage Impact sur TOTP Conséquence
0 - 15 s Aucun Le code est dans l'intervalle actuel, tout fonctionne normalement.
15 - 30 s Limite Le code est en fin d'intervalle. Peut fonctionner grâce à la tolérance du serveur.
30 - 60 s Dégradé Fonctionne uniquement si le serveur accepte T-1 ou T+1. Comportement aléatoire.
60 - 90 s Échec quasi-total Le code tombe rarement dans la fenêtre de tolérance. Échecs fréquents.
> 90 s Échec total Les codes sont systématiquement rejetés. Nécessite une resynchronisation de l'horloge ou un code de secours.

La Fenêtre de 30 Secondes et la Tolérance

Par défaut, TOTP utilise un pas de temps (timestep) de 30 secondes. Mais la plupart des serveurs d'authentification implémentent une fenêtre de tolérance pour compenser de légères dérives :

T-2
Rejeté
T-1
Accepté
T
Actuel
T+1
Accepté
T+2
Rejeté

La configuration la plus courante est d'accepter T-1, T, et T+1, ce qui offre une fenêtre effective d'environ 90 secondes (3 intervalles de 30 secondes). Ce paramètre est configurable côté serveur :

  • Google : accepte T-1, T, T+1 (tolérance ~90 s)
  • Microsoft : accepte T-1, T, T+1 par défaut
  • GitHub : fenêtre configurable, T-1 à T+1 par défaut
  • RFC 6238 : recommande au serveur de tester quelques intervalles autour de T

Bonnes Pratiques de Synchronisation

Pour garantir que vos codes 2FA fonctionnent en permanence, suivez ces recommandations selon votre contexte :

Pour les utilisateurs (smartphones, PC)

  • Activez la synchronisation automatique de l'heure sur tous vos appareils (Android : Paramètres > Système > Date et heure ; iPhone : Réglages > Général > Date et heure > Réglage automatique)
  • Ne désactivez jamais l'heure automatique sauf besoin temporaire de test, et réactivez-la immédiatement après
  • Vérifiez régulièrement votre horloge avec notre outil de vérification en ligne

Pour les administrateurs (serveurs, infrastructure)

  • Configurez NTP sur tous les serveurs d'authentification avec au moins 4 sources de temps redondantes
  • Utilisez NTS (Network Time Security) pour protéger la synchronisation contre les attaques MITM
  • Surveillez la dérive horaire avec des alertes Nagios/Zabbix/Prometheus si l'offset dépasse 100 ms
  • Attention aux machines virtuelles : les VM (notamment sur Proxmox VE) peuvent accumuler une dérive plus importante que les machines physiques. Configurez chrony en mode invité ou activez la synchronisation hôte-invité.
  • Documentez la tolérance TOTP de vos systèmes et ne l'augmentez pas au-delà de T-2/T+2 sans raison impérieuse

Questions Fréquentes

Pourquoi mes codes Google Authenticator ne fonctionnent plus ?

Si vos codes 2FA sont systématiquement rejetés, c'est très probablement un problème d'horloge. Vérifiez que la synchronisation automatique de l'heure est activée sur votre appareil.

  • Android : Paramètres > Système > Date et heure > Heure automatique
  • iPhone : Réglages > Général > Date et heure > Réglage automatique
TOTP fonctionne-t-il sans Internet ?

Oui, une fois le secret configuré, l'application génère les codes hors-ligne. Elle n'a besoin que de l'heure système. Cependant, sans Internet pendant une longue période, l'horloge ne sera plus synchronisée par NTP et finira par dériver suffisamment pour causer des échecs d'authentification.

Quel est le lien entre NTP et la double authentification (2FA) ?

NTP garantit que votre téléphone et le serveur d'authentification partagent la même heure. Sans cette synchronisation, les codes TOTP générés ne correspondent pas à ceux attendus par le serveur, et la connexion échoue. C'est un maillon invisible mais critique de la chaîne de sécurité.

Les clés physiques (YubiKey) sont-elles concernées ?

Les YubiKey utilisent principalement FIDO2/WebAuthn qui ne dépend pas du temps, ou HOTP (basé sur un compteur). Cependant, quand une YubiKey génère des codes TOTP (via Yubico Authenticator), elle dépend de l'horloge de l'appareil hôte, car la clé elle-même n'a pas d'horloge interne.

Comment sécuriser la source de temps pour protéger le 2FA ?

Un attaquant qui manipulerait votre horloge pourrait invalider vos codes 2FA ou exploiter des fenêtres de temps. Utilisez NTS (Network Time Security) pour authentifier cryptographiquement votre source de temps et empêcher ce type d'attaque. La même logique d'horloge fiable conditionne d'ailleurs les fenêtres de rétention des sauvegardes immuables anti-ransomware : un verrou WORM piloté par l'heure système ne tient que si cette heure tient.

Pourquoi 30 secondes et pas plus ?

L'intervalle de 30 secondes est un compromis entre sécurité (un code valide moins longtemps est plus difficile à exploiter) et utilisabilité (l'utilisateur a suffisamment de temps pour lire et saisir le code). Certains services utilisent 60 secondes pour plus de confort, au prix d'une fenêtre d'attaque plus large.

Outils NTP gratuits

Trois outils indépendants pour diagnostiquer votre synchronisation de temps :