Hoe een 2FA-code werkt zonder internet: TOTP
Zet je je telefoon in vliegtuigmodus, dan blijft je authenticator-app gewoon elke dertig seconden een nieuwe 2FA-code tonen. En die code klopt ook nog, terwijl de app de server nooit heeft gesproken. Dat werkt met TOTP, het algoritme achter apps als Google Authenticator. Het idee is eenvoudig: beide kanten hebben hetzelfde geheim en dezelfde klok, en rekenen dus onafhankelijk van elkaar hetzelfde getal uit.
In dit artikel reken ik zo'n code zelf uit, byte voor byte, met een paar regels Python. Je ziet wat er in de QR-code staat, hoe uit twintig bytes zes cijfers komen, waarom een code van dertig seconden geleden vaak nog werkt en waar TOTP tekortschiet.
Het gedeelde geheim uit de QR-code
Als je 2FA aanzet, toont de site een QR-code. Daarin staat een adres in het Key Uri Format dat Google voor Google Authenticator beschrijft. Voor mijn demo-account ziet dat er zo uit:
otpauth://totp/Wallieweb%20demo:jeroen%40example.nl?secret=O5QWY3DJMV3WKYRNORXXI4BNMRSW23ZB&issuer=Wallieweb%20demo
Het belangrijkste deel is secret. Dat is een willekeurige sleutel, geschreven in Base32: alleen de hoofdletters A tot en met Z en de cijfers 2 tot en met 7. Een 0 of 1 kom je er dus niet in tegen. Elk teken draagt 5 bits, dus deze 32 tekens zijn 160 bits ofwel 20 bytes. Dat is precies de lengte die RFC 4226 aanbeveelt. Het minimum volgens die RFC is 128 bits. Optioneel kunnen algorithm, digits en period erbij, met als standaard SHA1, 6 cijfers en 30 seconden.
Na het scannen hebben app en server dezelfde sleutel. Alles wat volgt, rekenen ze los van elkaar uit.
Hoe TOTP van de klok een teller maakt
TOTP staat in RFC 6238 en is een uitbreiding op HOTP uit RFC 4226. HOTP maakt een code uit een sleutel en een teller die bij elke code met één omhooggaat. TOTP vervangt die teller door de tijd:
T = floor((huidige Unix-tijd - T0) / X)
Standaard is T0 gelijk aan 0 (1 januari 1970, middernacht UTC) en is X 30 seconden. De RFC geeft zelf het voorbeeld: op Unix-tijd 59 is T gelijk aan 1, op 60 wordt het 2. Elke app met de standaardinstellingen wisselt dus op hetzelfde moment van code, op de hele en de halve minuut.
Als voorbeeld neem ik vrijdag 13 november 2026, 09:00:00 Nederlandse tijd. Dat is Unix-tijd 1794556800. Gedeeld door 30 geeft dat T = 59818560. HOTP verwacht de teller als acht bytes: 000000000390c240. Ruim genoeg, want RFC 6238 eist dat het ook na 2038 werkt, als T niet meer in 32 bits past.
HMAC: de sleutel door de molen
Met de teller en de sleutel berekent de app een HMAC-SHA-1. Een HMAC is een hash waar een geheime sleutel in meegaat: zonder de sleutel kun je hem niet namaken. Voor mijn voorbeeld:
teller (8 bytes): 000000000390c240
HMAC-SHA1 : ac8be85dd990ade9b664c519f4432339f57785c1
Dat zijn 20 bytes, te veel om over te typen. De RFC staat naast SHA-1 ook SHA-256 en SHA-512 toe. Volgens de documentatie van het URI-formaat negeert Google Authenticator de parameter algorithm echter. Dat SHA-1 als hash verouderd is, maakt hier weinig uit: RFC 4226 legt in een bijlage uit dat HMAC zo is ontworpen dat botsingen in de hashfunctie geen vervalste codes opleveren.
Dynamische truncatie: zes cijfers uit twintig bytes
Het inkorten heet in RFC 4226 dynamic truncation. Het werkt in drie stappen:
- Neem de laatste vier bits van de laatste byte. Dat getal tussen 0 en 15 is de offset.
- Pak vanaf die offset vier bytes en zet het hoogste bit op nul, zodat er een getal van 31 bits overblijft.
- Neem dat getal modulo 10^6 voor zes cijfers.
In het voorbeeld is de laatste byte c1. De laatste vier bits zijn 1, dus de offset is 1. Vanaf byte 1 staan 8b e8 5d d9. Het eerste bit daarvan staat aan (8b is groter dan 7f), dus dat wordt weggemaskeerd: 0b e8 5d d9, ofwel 199777753. Modulo een miljoen blijft over: 777753.
Waarom dat ene bit eraf moet? De RFC legt uit dat processors verschillend omgaan met getallen met en zonder teken. Zonder het tekenbit kan geen implementatie zich daarin vergissen.
Ik heb mijn script gecontroleerd met de testvectoren uit beide RFC's. Alle achttien TOTP-waarden uit RFC 6238 en de HOTP-reeks uit RFC 4226 (755224, 287082, 359152 voor teller 0, 1 en 2) komen er precies uit. De Python-bibliotheek pyotp geeft voor mijn demo-sleutel ook 777753.
Waarom een oude code soms nog werkt
De server kent het exacte moment niet waarop jouw app de code maakte. Typ je hem op het eind van een venster, dan komt hij mogelijk in het volgende binnen. RFC 6238 raadt daarom aan om naast het huidige venster hooguit één eerder venster te accepteren voor de vertraging onderweg. Dat zag ik ook met pyotp: de code van 08:59:30 (969651) wordt om 09:00:00 afgekeurd met de standaardinstelling, en goedgekeurd met valid_window=1.
Klokken lopen ook uit elkaar. De RFC stelt voor dat de server een grens instelt op hoeveel vensters een app ernaast mag zitten, en geeft een rekenvoorbeeld: twee stappen terug bij een venster van 30 seconden betekent maximaal ongeveer 89 seconden afwijking. Telefoons en computers zetten hun klok meestal gelijk via het netwerk, zoals in hoe NTP je klok gelijk zet. Toen ik dit schreef, liep de klok van mijn machine 35 milliseconden achter op time.cloudflare.com, dus daar is ruim marge.
Eén regel is streng: een code die al een keer is goedgekeurd, mag de server binnen hetzelfde venster niet nog eens accepteren. Anders is het geen eenmalig wachtwoord meer.
Hoe sterk zijn zes cijfers?
RFC 4226 geeft voor de kans dat een aanvaller raadt de formule s × v / 10^Digit, met s het aantal tellerwaarden dat de server accepteert en v het aantal pogingen. Bij TOTP zijn die tellerwaarden de vensters. Accepteert de server twee vensters en mag je tien keer proberen, dan is de kans 20 op een miljoen, 0,002 procent. Die kans blijft alleen zo klein als het aantal pogingen klein blijft. Daarom schrijft de RFC voor dat de server pogingen beperkt of steeds langer laat wachten, en dat die teller over sessies heen moet doorlopen, zodat een aanvaller niet in tien sessies tegelijk kan raden.
Er zijn twee zwakke plekken die geen rekensom oplost. De eerste is de server. Een wachtwoord kan een site opslaan als hash, zoals in hoe een wachtwoord wordt opgeslagen, maar de TOTP-sleutel moet de server zelf kunnen gebruiken. RFC 6238 raadt daarom aan de sleutels versleuteld te bewaren en ze alleen te ontsleutelen op het moment van controleren. Wie de database met sleutels steelt, kan voor iedereen codes maken.
De tweede is phishing. In de berekening zitten alleen de sleutel en de tijd, niet het domein waarop je inlogt. Typ je de code in op een nagemaakte inlogpagina, dan kan de aanvaller hem doorzetten naar de echte site zolang hij geldig is. Een passkey is wel aan het domein gekoppeld; hoe je dat in een Microsoft-omgeving inricht, staat in passkeys inrichten in Microsoft Entra ID.
Zelf proberen
Het hele algoritme past in een paar regels Python, zonder extra pakketten:
import hmac, hashlib, struct, base64, time
def totp(secret_b32, t=None, digits=6, step=30):
key = base64.b32decode(secret_b32)
t = int(time.time()) if t is None else t
msg = struct.pack(">Q", t // step) # teller als 8 bytes
hs = hmac.new(key, msg, hashlib.sha1).digest()
off = hs[-1] & 0x0f # laatste 4 bits = offset
num = int.from_bytes(hs[off:off+4], "big") & 0x7fffffff
return "%0*d" % (digits, num % 10**digits)
print(totp("O5QWY3DJMV3WKYRNORXXI4BNMRSW23ZB", 1794556800))
777753
Laat je t weg, dan krijg je de code van nu. Wil je je script naast een echte app leggen, voeg dan de demo-sleutel O5QWY3DJMV3WKYRNORXXI4BNMRSW23ZB toe aan je authenticator-app en vergelijk de code met print(totp("O5QWY3DJMV3WKYRNORXXI4BNMRSW23ZB")). Gebruik daarvoor nooit de sleutel van een echt account. De eerste testvector uit RFC 6238 kun je ook nalopen: totp(base64.b32encode(b"12345678901234567890"), 59, digits=8) geeft 94287082.
Tot slot
Wat me verraste, is hoe weinig er gebeurt: geen verbinding, geen handshake, alleen een HMAC over een getal dat elke dertig seconden een hoger wordt. Ook opvallend: het voorbeeldgeheim in Googles eigen documentatie, JBSWY3DPEHPK3PXP, is maar 10 bytes. Dat is 80 bits, onder het minimum van 128 bits uit RFC 4226. Zet je 2FA aan bij een site en zie je de sleutel als tekst, tel dan eens de tekens: 26 tekens hoort bij het minimum van 128 bits, 32 tekens bij de aanbevolen 160.