Hvordan tidsbaserede engangsadgangskoder fungerer, og hvorfor du skal bruge dem i din app.

Med stigningen i cybersikkerhedstrusler er det blevet mere og mere nødvendigt at opgradere sikkerhedsstandarderne for dine webapplikationer. Du skal sikre dig, at dine brugeres konti er sikre.

I dag beder mange online webapplikationer brugerne om at tilføje et ekstra lag af sikkerhed til deres konto. De gør det ved at aktivere 2-faktor-godkendelse. Der er forskellige metoder til implementering af 2-faktor-godkendelse, og TOTP-godkendelse (den tidsbaserede engangs-adgangskodealgoritme) er en af ​​dem.

Denne artikel forklarer, hvad det er, og hvordan og hvorfor man bruger det. Men inden vi forstår det, lad os først kort se på, hvad tofaktorautentificering betyder.

Hvad er tofaktorautentificering?

To-faktor-godkendelse (eller multifaktorautentificering) er bare et ekstra sikkerhedslag for en brugers konto. Det betyder, at brugeren, efter at have aktiveret tofaktorautentificering, skal gennemgå endnu et trin for at logge ind med succes. For eksempel er de sædvanlige trin til at logge ind på en konto:

Men efter at have aktiveret 2-faktor-godkendelse, ser trinene sådan ud:

Så dette tilføjer endnu et trin til loginprocessen. Denne metode er mere sikker, fordi en kriminel ikke kan få adgang til brugerens konto, medmindre de har adgang til både brugerens almindelige adgangskode og engangsadgangskode.

I øjeblikket er der to vidt anvendte metoder til at få den engangskodeord:

  1. SMS-baseret: I denne metode modtager de hver gang brugeren logger på en tekstbesked til deres registrerede telefonnummer, der indeholder en engangsadgangskode.
  2. TOTP-baseret: I denne metode, mens brugeren aktiverer 2-faktor-godkendelse, bliver brugeren bedt om at scanne et QR-billede ved hjælp af en bestemt smartphone-applikation.

    Denne applikation genererer derefter kontinuerligt One Time Password til brugeren.

Den SMS-baserede metode behøver ikke nogen forklaring. Det er let, men det har sine egne problemer, som at vente på SMS på hvert loginforsøg, sikkerhedsproblemer osv. Den TOTP-baserede metode bliver populær på grund af fordelene i forhold til den SMS-baserede metode. Så lad os forstå, hvordan den TOTP-baserede metode fungerer.

Sådan fungerer den TOTP-baserede metode

Før vi forstår dette, lad os først diskutere, hvilke problemer denne metode vil løse for os.

Ved at bruge TOTP-metoden opretter vi en engangskodeord på brugersiden (i stedet for serversiden) gennem en smartphone-applikation.

Dette betyder, at brugerne altid har adgang til deres engangskodeord. Så det forhindrer serveren i at sende en tekstbesked, hver gang brugeren prøver at logge ind.

Også den genererede adgangskode ændres efter et bestemt tidsinterval, så den opfører sig som en engangskodeord.

Store! Lad os nu forstå funktionen af ​​TOTP-metoden og prøve at implementere ovenstående løsning selv. Vores krav her er at oprette en adgangskode på brugersiden, og den adgangskode skal fortsætte med at ændre sig.

Følgende kan være en måde at implementere denne løsning på:

When the user enables two factor authentication:
1. Backend server creates a secret key for that particular user.2. Server then shares that secret key with the user’s phone application.3. Phone application initializes a counter.4. Phone application generate a one time password using that secret key and counter.5. Phone application changes the counter after a certain interval and regenerates the one time password making it dynamic.

Dette skal fungere, men der er tre hovedproblemer med det:

  1. Hvordan genererer applikationen en engangskodeord ved hjælp af en hemmelig nøgle og tæller?
  2. Hvordan opdateres tælleren? Hvordan holder webserveren styr på tælleren?
  3. Hvordan deler serveren den hemmelige nøgle med telefonens applikation?

Løsningen på det første problem er defineret i HOTP-algoritmen.

Forståelse af HOTP:

HOTP står for “HMAC-Based One-Time Password”. Denne algoritme blev offentliggjort som RFC4226 af Internet Engineering Task Force (IETF). HOTP definerer en algoritme til at oprette en engangskodeord fra en hemmelig nøgle og en tæller.

Du kan bruge denne algoritme i to trin:

  1. Det første trin er at oprette en HMAC-hash fra en hemmelig nøgle og tæller.
// Obtain HMAC hash (using SHA-1 hashing algorithm) by secretKey and counter
hmacHash = HMAC-SHA-1(secretKey, counter);

2. I denne kode vil output være en streng på 20 byte. Den lange streng er ikke egnet som en engangskodeord. Så vi har brug for en måde at afkorte den streng på. HOTP definerer en måde at afkorte den streng til vores ønskede længde.

// hmacHash[19] means 19th byte of the string.offset = hmacHash[19] & 0xf;
truncatedHash = (hmacHash[offset++] & 0x7f) << 24 | (hmacHash[offset++] & 0xff) << 16 | (hmacHash[offset++] & 0xff) << 8 | (hmacHashh[offset++] & 0xff);
finalOTP = (truncatedHash % (10 ^ numberOfDigitsRequiredInOTP));

Det ser måske skræmmende ud, men det er det ikke. I denne algoritme opnår vi først, offsethvilket er de sidste 4 bits hmacHash[19]. Derefter sammenkæder vi bytes fra hmacHash[offset]til hmacHash[offset+3]og gemmer de sidste 31 bits til truncatedHash. Endelig opnår vi den engangsadgangskode, der er en rimelig længde, ved hjælp af en simpel modulo-operation.

Dette definerer stort set HOTP-algoritmen. RFA4226 doc forklarer, hvorfor dette er den sikreste måde at få en engangskodeord fra disse to værdier.

Store! Så vi har fundet en måde at få en engangskodeord ved hjælp af en hemmelig nøgle og tæller. Men hvad med det andet problem? Hvordan holder du styr på tælleren?

Løsningen på det andet problem findes i TOTP.

Forståelse af TOTP:

TOTP står for "Time-Based One-Time Password". Dette blev offentliggjort som RFC6238 af IETF.

A TOTP uses the HOTP algorithm to obtain the one time password. The only difference is that it uses “Time” in the place of “counter,” and that gives the solution to our second problem.

That means that instead of initializing the counter and keeping track of it, we can use time as a counter in the HOTP algorithm to obtain the OTP. As a server and phone both have access to time, neither of them has to keep track of the counter.

Also, to avoid the problem of different time zones of the server and phone, we can use a Unix timestamp, which is independent of time zones.

However the Unix time is defined in seconds, so it changes every second. That means the generated password will change every second which is not good. Instead, we need to add a significant interval before changing the password. For example, the Google Authenticator App changes the code every 30 seconds.

counter = currentUnixTime / 30

So we have solved the problem of the counter. Now we need to address our third problem: sharing the secret key with the phone application. Here, a QR code can help us.

Using a QR code

Though we can ask the users to type the secret key into their phone application directly, we want to make secret keys quite long for security reasons. Asking the user to type in such a long string would not be a user friendly experience.

Since the majority of smartphones are equipped with a camera, we can use it and ask the user to scan a QR code to obtain the secret key from it. So all we need to do is to convert the secret key in the QR code and show it to the user.

We have solved all three problems! And now you know how TOTP works. Let’s see how to implement it in an application.

How to implement TOTP

There are some free phone applications (like Google Authenticator App, Authy, and so on) available which can generate an OTP for the user. Therefore, in most cases, creating your own phone application is not necessary.

The following pseudo codes explain a way to implement TOTP-based 2-factor authentication in a web application.

When user request to enable 2-factor authentication
// Generate a secret key of length 20.secretKey = generateSecretKey(20);
// Save that secret key in database for this particular user.saveUserSecretKey(userId, secretKey);
// convert that secret key into qr image.qrCode = convertToQrCode(secretKey);
// send the qr image as responseresponse(qrCode);

The user is asked to scan that QR code. When the phone application scans the QR code, it gets the user’s secret key. Using that secret key, the current Unix time, and the HOTP algorithm, the phone application will generate and display the password.

We ask the user to type the generated code after scanning the QR code. This is required, because we want to make sure that the user has successfully scanned the image and the phone application has successfully generated the code.

User types the code displayed in the application.
// Fetch secret key from database.secretKey = getSecretKeyOfUser(userId);
if (codeTypedByUser == getHOTP(secretKey, currentUnixTime / 30)) { enableTwoFactorAuthentication(userId);}

Here we use the HOTP algorithm on the server side to get the OTP-based authentication on the secret key and current unix time. If that OTP is the same as the one typed by the user, then we can enable 2-factor authentication for that user.

Now after every login operation, we need to check if this particular user has 2-factor authentication enabled. If it is enabled, then we ask for the one time password displayed in the phone application. And if that typed code is correct, only then is the user authenticated.

User types the code displayed in the phone application to login
// Fetch secret key from database.secretKey = getSecretKeyOfUser(userId);
if (codeTypedByUser == getHOTP(secretKey, currentUnixTime)) { signIn(userId);}

What happens if the user loses the code?

There are a couple of ways to help the user to recover the code. Usually when they are enabling 2-factor authentication, we can show the secret key to them along with the QR code and ask them to save that code somewhere safely.

Applications like Google Authenticator App let you generate the password by directly entering the secret key. If the user loses the code, they can enter that safely saved secret key in the phone application to generate the OTP again.

Hvis vi har brugerens telefonnummer, kan vi også bruge den SMS-baserede metode til at sende en OTP til brugeren for at hjælpe dem med at gendanne koden.

Afslutter

To-faktor-godkendelse vinder popularitet. En masse webapplikationer implementerer det for ekstra sikkerhed.

I modsætning til den SMS-baserede metode kræver TOTP-metoden heller ikke meget ekstra indsats. Så denne funktion er værd at implementere til enhver applikation.