Générateur de codes TOTP / 2FA

Qu'est-ce qu'un générateur de codes TOTP / 2FA ?

// Generate a TOTP code in the browser with the Web Crypto API
// (SHA-1, 6 digits, 30s period — RFC 6238 defaults)
async function generateTotp(base32Secret, time = Date.now()) {
  // Decode the Base32 secret to raw bytes (A-Z, 2-7)
  const alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
  let bits = '';
  for (const c of base32Secret.replace(/=+$/, '').toUpperCase())
    bits += alpha.indexOf(c).toString(2).padStart(5, '0');
  const bytes = new Uint8Array(
    bits.match(/.{8}/g).map((b) => parseInt(b, 2)));

  // Counter = number of 30s steps since the Unix epoch (8-byte big-endian)
  const counter = Math.floor(time / 1000 / 30);
  const msg = new Uint8Array(8);
  let c = counter;
  for (let i = 7; i >= 0; i--) { msg[i] = c & 0xff; c = Math.floor(c / 256); }

  const key = await crypto.subtle.importKey(
    'raw', bytes, { name: 'HMAC', hash: 'SHA-1' }, false, ['sign']);
  const hmac = new Uint8Array(await crypto.subtle.sign('HMAC', key, msg));

  // Dynamic truncation (RFC 4226) -> 6-digit code
  const off = hmac[hmac.length - 1] & 0x0f;
  const bin = ((hmac[off] & 0x7f) << 24) | (hmac[off + 1] << 16) |
              (hmac[off + 2] << 8) | hmac[off + 3];
  return (bin % 1_000_000).toString().padStart(6, '0');
}

const code = await generateTotp('JBSWY3DPEHPK3PXP');
// -> a 6-digit code that rotates every 30 seconds

Fonctionnalités clés

Exemples du générateur TOTP

secret: JBSWY3DPEHPK3PXP
algorithm: SHA-1
digits: 6
period: 30s

Code: 282760  ·  expires in 30s

secret: JBSWY3DPEHPK3PXP
algorithm: SHA-256
digits: 8
period: 30s

Code: 31094217  ·  expires in 30s

issuer: Acme
account: alice@example.com
secret: JBSWY3DPEHPK3PXP

otpauth://totp/Acme:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=Acme&algorithm=SHA1&digits=6&period=30

Comment utiliser le générateur TOTP

1. 1

   Collez un secret Base32

   Dans l'onglet Générer, collez votre secret Base32 (par exemple JBSWY3DPEHPK3PXP). Le code TOTP actuel apparaît instantanément avec un compte à rebours de 30 secondes — sans bouton Générer.

2. 2

   Ajustez les options avancées (facultatif)

   Ouvrez les options avancées pour changer l'algorithme (SHA-1/256/512), le nombre de chiffres (6 ou 8) ou la période (30 ou 60 s) afin de correspondre à ce que votre fournisseur a émis.

3. 3

   Configurez ou vérifiez

   Utilisez l'onglet Configurer pour générer un secret et un QR pour une application d'authentification, ou l'onglet Vérifier pour contrôler un code par rapport à un secret avec une tolérance de ±1 pas de temps.

Erreurs courantes

secret + SHA-1/6 digits  // but server expects SHA-256/8

algorithm: SHA-256, digits: 8  // match the otpauth:// URI

system clock 90s fast  // code is two steps ahead

enable NTP / automatic time  // code aligns with server

secret: "JBSW 0NE8"  // contains 0 and 8

secret: "JBSWY3DPEHPK3PXP"  // valid Base32

Cas d'usage courants

Déboguer un flux de connexion 2FA

Reproduisez le code exact qu'affiche l'application d'authentification d'un utilisateur, afin de tracer pourquoi une connexion à deux facteurs est rejetée.

Enregistrer un nouveau compte

Générez un nouveau secret Base32 et un QR code, puis scannez-le dans Google Authenticator, Authy ou 1Password pour configurer la 2FA.

Valider la fenêtre de votre serveur

Vérifiez des codes par rapport à un secret pour confirmer que votre back-end accepte un code qui vient de tourner et rejette un code expiré.

Construire des fixtures de tests de bout en bout

Calculez des codes TOTP déterministes à partir d'un secret connu pour piloter des tests automatisés d'un flux d'authentification à deux facteurs.

Faire correspondre des réglages d'entreprise

Reproduisez des codes à 8 chiffres ou SHA-256 lorsqu'un fournisseur s'écarte des valeurs par défaut SHA-1 / 6 chiffres, pour déboguer une discordance.

Récupérer rapidement l'accès

Générez le code actuel à partir d'un secret sauvegardé lorsque votre téléphone est indisponible — en utilisant une copie jetable du secret.

Détails techniques

Conforme à la RFC 6238 / RFC 4226

Implémente le TOTP selon la RFC 6238 au-dessus de l'algorithme de troncature dynamique HOTP de la RFC 4226, avec SHA-1, SHA-256 et SHA-512 sélectionnables.

HMAC Web Crypto natif

Les codes sont dérivés via un HMAC crypto.subtle sur le compteur de pas de temps en big-endian. Le décodage Base32 et la troncature s'exécutent entièrement dans le navigateur.

URI otpauth:// standard, zéro dépendance

Les URI de configuration suivent le Key Uri Format (otpauth://totp) avec les paramètres émetteur, algorithme, chiffres et période. Aucune bibliothèque externe, aucun appel réseau.

Bonnes pratiques

Traitez le secret comme un mot de passe

Quiconque possède le secret Base32 peut générer tous les codes à venir. Stockez-le dans un gestionnaire de secrets, jamais dans le contrôle de version, et privilégiez ici des secrets de test.

Gardez les horloges synchronisées

Le TOTP dépend d'une heure exacte. Activez la synchronisation horaire réseau sur les serveurs et les appareils pour que les codes s'alignent dans la fenêtre de vérification.

Tenez-vous-en aux valeurs par défaut sauf nécessité

SHA-1, 6 chiffres et une période de 30 secondes maximisent la compatibilité des applications. Ne passez à 8 chiffres ou SHA-256/512 que lorsque votre fournisseur l'impose.

FAQ du générateur TOTP / 2FA