• K : Clé secrète partagée, encodée en Base32 selon la RFC 4648.
• T : Entier non signé de 64 bits (8 octets, Big-Endian) représentant le nombre de tranches de 30 secondes depuis l'époque Unix.
• Truncate : Algorithme de troncature dynamique qui extrait un entier de 31 bits à partir du digest HMAC de 20 octets.

Voici le code complet en Python 3 utilisant exclusivement les modules de la bibliothèque standard (hmac, hashlib, time, struct, base64) :

import hmac
import hashlib
import time
import struct
import base64
def generate_totp(secret_base32: str, interval: int = 30, digits: int = 6) -> str:
1. Nettoyage et complétion du padding Base32
cleaned_secret = secret_base32.replace(” ”, "").upper()
missing_padding = len(cleaned_secret) % 8
if missing_padding:
cleaned_secret += ’=’ * (8 - missing_padding)
key = base64.b32decode(cleaned_secret, casefold=True)
2. Calcul du pas temporel (8 octets, Big-Endian)
time_step = int(time.time()) // interval
time_bytes = struct.pack(“>Q”, time_step)
3. Calcul HMAC-SHA1
hmac_digest = hmac.new(key, time_bytes, hashlib.sha1).digest()
4. Troncature dynamique (RFC 4226 section 5.3)
offset = hmac_digest[-1] & 0x0F
code_int = struct.unpack(“>I”, hmac_digest[offset:offset + 4])[0] & 0x7FFFFFFF
5. Modulo et formatage
code = code_int % (10 ** digits)
return str(code).zfill(digits)
if name == “main”:
secret = “JBSWY3DPEHPK3PXP”
print(“Code TOTP généré :”, generate_totp(secret))

Cette implémentation exploite l'API standardisée window.crypto.subtle pour exécuter les opérations cryptographiques à vitesse native dans le navigateur sans fuite de mémoire :

function base32ToUint8Array(base32) {
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
const clean = base32.replace(/\s/g, '').toUpperCase();
let bits = 0, value = 0, index = 0;
const output = new Uint8Array(Math.floor((clean.length * 5) / 8));
for (let i = 0; i < clean.length; i++) {
const val = alphabet.indexOf(clean[i]);
if (val === -1) continue;
value = (value << 5) | val;
bits += 5;
if (bits >= 8) {
output[index++] = (value >>> (bits - 8)) & 255;
bits -= 8;
}
}
return output;
}
async function getTOTPCode(secretBase32, interval = 30) {
const keyBytes = base32ToUint8Array(secretBase32);
const cryptoKey = await crypto.subtle.importKey(
‘raw’, keyBytes, { name: ‘HMAC’, hash: ‘SHA-1’ }, false, [‘sign’]
);
const timeStep = Math.floor(Date.now() / 1000 / interval);
const timeBuffer = new ArrayBuffer(8);
new DataView(timeBuffer).setBigUint64(0, BigInt(timeStep), false);
const signature = await crypto.subtle.sign(‘HMAC’, cryptoKey, timeBuffer);
const hash = new Uint8Array(signature);
const offset = hash[hash.length - 1] & 0x0F;
const dv = new DataView(hash.buffer, offset, 4);
const codeInt = (dv.getUint32(0, false) & 0x7FFFFFFF) % 1000000;
return codeInt.toString().padStart(6, ‘0’);
}

L'annexe B de la spécification RFC 6238 fournit des vecteurs de test officiels basés sur la chaîne ASCII 12345678901234567890 (20 octets, soit la clé Base32 GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ) :

• Fenêtre de dérive d'horloge (Tolerance Window) : Validez toujours les pas temporels [T-1, T, T+1] pour compenser les légers retards d'horloge entre le smartphone et le serveur NTP.
• Protection anti-rejeu (Anti-Replay) : Marquez chaque code vérifié avec succès comme consommé dans un cache (ex. Redis avec un TTL de 90 secondes) pour interdire qu'un code intercepté ne soit rejoué.
• Stockage sécurisé des secrets : Chiffrez les secrets Base32 au repos en base de données avec AES-GCM-256 ou enveloppez-les via un module HSM/KMS.
• Limitation de débit (Rate Limiting) : Bloquez temporairement l'adresse IP et le compte après 5 tentatives échouées consécutives pour neutraliser les attaques par force brute.