Gli utenti della rete devono spesso inserire password, ad esempio per accedere a una piat­ta­for­ma social, ef­fet­tua­re acquisti online o usare l’online banking. Le password servono a pro­teg­ge­re i dati sensibili da accessi in­de­si­de­ra­ti. Nell’uti­liz­zar­le spesso, molti utenti tra­scu­ra­no un aspetto im­por­tan­te: le password deboli possono essere craccate dai pro­fes­sio­ni­sti nel giro di pochi secondi. Altri invece non cu­sto­di­sco­no con cura le proprie password, offrendo una porta d’accesso ai criminali in­for­ma­ti­ci. Non sono poi da sot­to­va­lu­ta­re le vul­ne­ra­bi­li­tà dei servizi a cui l’utente accede: se le password non vengono custodite al sicuro, i dati di migliaia di utenti sono in pericolo.

Una pos­si­bi­li­tà per ridurre tale rischio è l’au­ten­ti­ca­zio­ne a due fattori o l’au­ten­ti­ca­zio­ne multi-fattore. Invece di usare un’unica password, è previsto l’in­se­ri­men­to di almeno un’altra chiave di au­ten­ti­ca­zio­ne. L’utente riceve tale password sullo smart­pho­ne o at­tra­ver­so un token hardware, uti­liz­zan­do un fattore ag­giun­ti­vo unico e valido solo per poco tempo: così viene generata una co­sid­det­ta Time-based One-time Password. Ecco come funziona.

A cosa serve una TOTP?

Le password abituali, quelle che forse scegliete anche voi, hanno uno svan­tag­gio: se qualcun altro le conosce, la vostra sicurezza non è più garantita. Una soluzione sarebbe quella di cambiarle spesso, ma anche gli utenti esemplari non lo fanno di certo ogni ora. Ecco che allora viene in aiuto la TOTP: una password valida solo per un breve lasso di tempo dopo il quale scade. Nel 2011 l’Internet En­gi­nee­ring Task Force (IETF) ha pub­bli­ca­to l’algoritmo della Time-based One-time Password nell’RFC 6238 per poter garantire più sicurezza su Internet.

Le password monouso sono par­ti­co­lar­men­te popolari nell’ambito dell’au­ten­ti­ca­zio­ne multi-fattore. Gli utenti uti­liz­za­no la propria password personale per l’accesso al servizio online, ma in aggiunta viene generata una password a tempo per quello specifico processo di accesso. L’utente riceve tale password tramite app o at­tra­ver­so un di­spo­si­ti­vo pre­di­spo­sto (token).

La password scade nel momento in cui viene uti­liz­za­ta una volta o se non viene uti­liz­za­ta per un de­ter­mi­na­to periodo di tempo. Per i criminali quindi sarà molto difficile scoprire questo secondo fattore: anche se co­no­sces­se­ro la password avrebbero infatti poche pos­si­bi­li­tà di scoprire anche la TOTP, ovvero non avrebbero il tempo materiale per craccarla.

Come funziona l’algoritmo della Time-based One-time Password?

La base della TOTP è una funzione hash, ovvero un processo crit­to­gra­fi­co. Da una password segreta e una marcatura temporale viene generata una sequenza di segni cifrata. La password è co­no­sciu­ta dall’utente e dal server. L’in­di­ca­zio­ne temporale è rap­pre­sen­ta­ta in Tempo Unix.

Fatto

Il Tempo Unix è un valore in secondi calcolato rispetto al 1° gennaio 1970.

La TOTP è una versione più svi­lup­pa­ta della HOTP, che sta per “HMAC-based One-time Password”. Anche la TOTP si basa sul metodo HMAC e sull’ope­ra­zio­ne hash. Sia il di­spo­si­ti­vo dell’utente che il server generano un valore hash da una password segreta in com­bi­na­zio­ne con nu­me­ra­to­re. Entrambi i valori sono identici, perciò l’au­ten­ti­ca­zio­ne funziona.

La stessa funzione hash non è fissa: si accede ad esempio allo SHA-1 (o a Google Au­then­ti­ca­tor), che genera un valore hash con una lunghezza di 160 bit. Per sem­pli­fi­ca­re le cose questo valore viene ab­bre­via­to tramite una funzione di com­pres­sio­ne. Alla fine si ha un numero a sei cifre che l’utente può inserire fa­cil­men­te per accedere al servizio online.

N.B.

La password segreta è ancorata al token nel di­spo­si­ti­vo e spesso lo stesso utente non lo sa. Nel caso in cui non fosse così, la SecretKey deve essere con­ser­va­ta in un luogo sicuro, meglio se offline ed even­tual­men­te anche stampata e con­ser­va­ta in sicurezza. Se si perde questa password non è più possibile accedere al servizio.

L’HOTP si basa su un contatore per la seconda parte della funzione, separando il server e l’utente l’uno dall’altro. Il problema è che la password generata è valida fin quando non viene uti­liz­za­ta. La TOTP ha invece una validità limitata: il suo codice può essere uti­liz­za­to solo entro un lasso di tempo stabilito. Come funziona?

Tre sono le formule im­por­tan­ti per l’algoritmo della Time-based-One-time Password:

TOTP = HOTP(SecretKey,Cur­rent­Ti­me)

Questa facile formula sta­bi­li­sce solamente che la TOTP è un processo HOTP con due parametri, la SecretKey e il Cur­rent­Ti­me.

  • SecretKey: è una password generata ca­sual­men­te, co­no­sciu­ta sia al server che al client
  • Cur­rent­Ti­me: orario attuale in Tempo Unix

L’in­di­ca­zio­ne temporale cambia ogni secondo e tale tempo non basta per tra­smet­te­re il codice all’ap­pli­ca­zio­ne. Un secondo più tardi la TOTP non sarebbe più valida, in quanto il server ha già generato un nuovo valore hash. Per questo si ricorre a un’altra formula:

Cur­rent­Ti­me = floor((unixtime(now) – unixtime(T0))/T1)

Viene definito quindi il parametro Cur­rent­Ti­me:

  • unixtime(now): orario attuale in Tempo Unix
  • unixtime(T0): Tempo Unix al momento T0, si calcola nella maggior parte dei casi partendo dalla mez­za­not­te del 1/1/1970 (= 0)
  • T1: l’in­ter­val­lo di tempo nel quale la TOTP deve essere valida, so­li­ta­men­te 30 secondi
  • floor: funzione di ar­ro­ton­da­men­to, per ar­ro­ton­da­re il valore calcolato ad un numero intero
N.B.

Teo­ri­ca­men­te può essere scelto anche un altro valore per T0 che non sia 0. La cosa im­por­tan­te è che client e server scelgano lo stesso valore.

Il risultato cambia a in­ter­val­li a causa di divisione e ar­ro­ton­da­men­to.

Infine il valore hash generato viene ab­bre­via­to per essere più user-friendly:

Result = TOTPmod10d

Il calcolo Modulo genera una somma di controllo:

  • mod 10: Modulo con divisore 10
  • d: numero di cifre che la TOTP dovrebbe avere

Si potenzia quindi la base 10 con quelle cifre che il codice dovrebbe avere, si divide la TOTP con questo valore e si estrae il resto.

Calcolo della TOTP in un esempio

Sup­po­nia­mo che si voglia generare una TOTP con una validità di 30 secondi. È possibile già calcolare il Cur­rent­Ti­me e capire anche come si ga­ran­ti­sce la durata della validità. Sup­po­nia­mo che l’unixtime(now) sia 1548322860, il 24/01/2019 alle ore 10:41. Dividendo questo valore diviso 30 il risultato è 51.610.762. Essendo già un numero intero, non bisogna fare l’ar­ro­ton­da­men­to del risultato. Se si imposta l’orario 15 secondi più tardi (quindi 1.548.322.875), dopo la divisione si ottiene il risultato di 51.610.762,5, che ar­ro­ton­da­to diventa 51.610.762. Quindi il Cur­rent­Ti­me rimane invariato. Nella seguente tabella si può notare come il valore cambia solo po­sti­ci­pan­do di 30 secondi:

unixtime(now) unixtime(now)/30 floor(unixtime(now)/30)
1548322857 51610761,9000 51610761
1548322858 51610761,9333 51610761
1548322859 51610761,9667 51610761
1548322860 51610762,0000 51610762
1548322861 51610762,0333 51610762
1548322862 51610762,0667 51610762
1548322863 51610762,1000 51610762
1548322864 51610762,1333 51610762
1548322865 51610762,1667 51610762
1548322866 51610762,2000 51610762
1548322867 51610762,2333 51610762
1548322868 51610762,2667 51610762
1548322869 51610762,3000 51610762
1548322870 51610762,3333 51610762
1548322871 51610762,3667 51610762
1548322872 51610762,4000 51610762
1548322873 51610762,4333 51610762
1548322874 51610762,4667 51610762
1548322875 51610762,5000 51610762
1548322876 51610762,5333 51610762
1548322877 51610762,5667 51610762
1548322878 51610762,6000 51610762
1548322879 51610762,6333 51610762
1548322880 51610762,6667 51610762
1548322881 51610762,7000 51610762
1548322882 51610762,7333 51610762
1548322883 51610762,7667 51610762
1548322884 51610762,8000 51610762
1548322885 51610762,8333 51610762
1548322886 51610762,8667 51610762
1548322887 51610762,9000 51610762
1548322888 51610762,9333 51610762
1548322889 51610762,9667 51610762
1548322890 51610763,0000 51610763
1548322891 51610763,0333 51610763

È quindi stato stabilito il Cur­rent­Ti­me (51610762). La SecretKey è creata da un ge­ne­ra­to­re di password: >cHSB_UQ#O5m;~b

L’HMAC genera insieme allo SHA-1 un valore hash da password e orario (nella scrittura esa­de­ci­ma­le): c0 62 37 94 dd 37 7a 3a f0 91 22 08 1f 21 6f 9b 17 4b 17 45. Questo valore lungo 160 bit cioè 20 byte viene ridotto a 31 bit con la co­sid­det­ta Dynamic Trun­ca­tion. Per farlo vengono presi in con­si­de­ra­zio­ne gli ultimi 4 bit, cioè il numero 0x5, che anche nella scrittura decimale viene scritto 5. Questo rap­pre­sen­ta il valore offset della Dynamic Trun­ca­tion e significa che dal byte con l’indice 5 (iniziando a contare da sinistra con 0) vengono estratti quattro byte: 0x377a3af0. In questo caso il valore inizia già con un bit che sta su 0. Se però non dovesse essere così, si cambia. Il valore da 31 bit sarà: 0x377a3af0, cioè 930757360.

Per ridurre il codice da nove a sei cifre si utilizza un’ope­ra­zio­ne Modulo e si ag­giun­go­no all’oc­cor­ren­za degli zeri sulla sinistra: 930757360 mod (106) = 757360. Questa è quindi la TOTP, valida 30 secondi. In com­bi­na­zio­ne con un altro fattore si ottiene un processo di accesso ab­ba­stan­za sicuro.

Vai al menu prin­ci­pa­le