
In “Come generare una password o un keyfile sicuri” abbiamo visto come generare password e keyfile che si basassero su dati il più possibile casuali.
La verifica matematica di una password si basa sulla determinazione del numero di tentativi necessari a un attaccante per indovinarla.
Esistono due approcci: quello teorico (brute force) e quello realistico (pattern matching).
Calcolo teorico (Entropia di Shannon)
Un primo strumento per la valutazione di una password è dato dall'entropia di Shannon, che chiunque abbia usato un password manager certamente conoscerà.
Questo calcolo assume che l'attaccante non sappia nulla della nostra password e debba provare ogni possibile combinazione (forza bruta).
Dato un alfabeto di R simboli e una password di lunghezza L, l'entropia E sarà pari a:
E = log2 ( RL ) = L * log2 ( R )
L'entropia è un valore numerico espresso in bit (gli “Shannon”) che rappresenta una misura, non tanto della robustezza, quanto della “densità” della password, ossia di quanto lavoro richieda ad un calcolatore per essere indovinata. Più è alta, meglio è.
Spiegazione dell'entropia di Shannon
Innanzitutto notiamo che RL è la dimensione dello spazio di possibilità in cui esiste la mia password e, per R e L sufficientemente grandi, è un numero talmente enorme da essere difficilmente comprensibile.
L'equivalente E, che non è altro che l'esponente della potenza di 2 tale per cui 2E = RL, risulta invece molto più gestibile e confrontabile.
Semplificando, se alla mia password lunga L corrisponde quindi un'analoga chiave in bit lunga E, un attaccante che voglia scoprire la mia password, invece che indovinare gli L simboli da un alfabeto R, compirà lo stesso sforzo rispondendo correttamente ad un numero di domande binarie (SI / NO) pari a E, per ricostruire la giusta sequenza binaria.
Quanto costa ricostruire la sequenza?
O, in altre parole, qual è lo sforzo computazionale richiesto?
Si parla di caso medio ottimale corrispondente ad una ricerca binaria in cui ogni domanda dimezza lo spazio di possibilità fino ad azzerarlo completamente.
E = L * log2 ( R ), è quel numero di bit che mi dice quant'è profondo l'albero delle decisioni che il calcolatore deve percorrere, albero in cui il numero dei possibili cammini radice-foglia (equivalenti a tutte le possibili password) è 2E = RL.
- Nel caso migliore, rispondo correttamente a tutte le E domande al primo tentativo (trovo subito il mio cammino sull'albero).
- Nel caso peggiore, mi occorreranno 2E risposte (percorro tutti i cammini dell'albero) equivalente proprio a RL.
Possiamo allora definire formalmente l'entropia come quella quantità minima di informazione necessaria ad azzerare l'incertezza legata all'identificazione della password. Per questo motivo è espressa in bit.
Una misurazione di questo tipo ha senso solo se ipotizziamo che i simboli siano tutti equiprobabili.
La formula di Shannon misura, sì, l'entropia, ma al suo massimo potenziale, quando la distribuzione dei simboli nella sequenza è omogenea e assolutamente casuale.
Esempi d'uso
Facciamo l'esempio di una password lunga 20, costruita su un alfabeto di 66 simboli (alfanumerico con maiuscole e minuscole più 4 simboli speciali).
La dimensione di questo spazio di possibilità è pari a:
Sp = RL = 6620 = 2,46 * 1036
Tentare un attacco di forza bruta su un oggetto del genere è semplicemente impensabile.
Faccio un esempio.
Per forzare la nostra password, supponiamo di avere a disposizione il più potente supercomputer del mondo, El Capitan ad oggi, dotato di una potenza di calcolo spaventosa, in media 2.000 exaFLOPS con picchi di 2.746 exaFLOPS, dove 1 exaFLOPS è un quintilione (1018) di operazioni al secondo.
Il calcolo di una password si misura in Hash al secondo, H/s per usare una notazione compatta, che è più dispendiosa della singola operazione.
Approssimando per eccesso con molto ottimismo e nell'ipotesi di usare algoritmi estrememente deboli e poco costosi dal punto di vista computazionale come NTLM o MD5, possiamo pensare che il nostro sistema possa arrivare a calcolare, in queste condizioni, circa 1,5 quintilioni ( 1,5 * 1018 ) H/s.
Per algoritmi come bcrypt o argon2, progettati per essere molto dispendiosi, tale potenza si riduce drasticamente di molti ordini di grandezza. Da 1018 a 109 – 106. Ma consideriamo il caso più favorevole perché sembra appunto una potenza enorme.
Ma anche questa tremenda esibizione di potenza annichilisce di fronte al numero di calcoli da compiere nel nosro spazio di possibilità.
Dato Sp lo spazio di possibilità (il numero di possibili combinazioni), il tempo T espresso in secondi necessario ad eseguire tutte le operazioni sarà:
Sp = 6620 = 2,46 * 1036
T = 2,46 * 36 / 1,5 * 1018 = 1,64 * 1018
Che equivale a circa 52 miliardi di anni.
Per avere un'idea di questa grandezza cosmica, si pensi che l'età del nostro universo è di circa 13,8 miliardi di anni. Quindi il calcolo della nostra password potrebbe richiedere un tempo che è grossomodo 3,8 volte l'età dell'universo.
I 120 bit di entropia, sono dunque la misura di questo sforzo potenziale, interpretabile equivalentemente in due modi differenti:
- la probabilità di riuscire a trovare la password tirando a indovinare, probabilità che è 1 su 2120
oppure
- la capacità di rispondere correttamente e consecutivamente a 120 domande di tipo (SI / NO) (ricerca del giusto cammino in un albero decisionale binario profondo 120 livelli)
Allungando la nostra password di altri due caratteri, l'entropia arriva a circa 133 e il calcolo delle possibili combinazioni, posto che fosse possibile ignorando le leggi della termodinamica, richiederebbe circa 16.500 di volte l'età dell'universo.
Considerazione a margine: è la lunghezza della password ad incidere più che la complessità dell'alfabeto. E lo vediamo dalla formula dell'entropia, perché, in una funzione di elevamento a potenza RL, aumentare l'esponente L fa crescere molto più rapidamente la funzione che non aumentando la base R.
Calcolo realistico (pattern matching)
L'entropia di Shannon fornisce un riscontro utilizzabile solo ipotizzando che:
- le scelte siano indipendenti
- la distribuzione sia uniforme
e in uno scenario di questo tipo, l'attacco di forza bruta non è una via percorribile.
Allo stesso tempo, se non vengono rispettati questi vincoli, l'entropia dà una falsa sicurezza perché la formula di Shannon “standard” non tiene conto della ridondanza:
Consideriamo questa password: Password12345678
- teoria: la formula E = L * log2R direbbe che la sua entropia sia 95, ottima.
- realtà: poiché è una sequenza ovvia, l'attaccante la proverà per prima. La sua entropia reale sarà vicina a 0 bit.
L'entropia quindi misura la “densità” della password, la sua imprevedibilità potenziale ma non dà nessuna informazione sulla presenza di schemi ripetuti e sul pattern matching.
Ent
L'essere umano come generatore di entropia fa schifo.
Ecco perché, per un attaccante, prima ancora di provare tutte le possibili combinazioni di caratteri, un attacco a dizionario può far risparmiare un sacco di tempo.
Infatti sempre Shannon ci dice che nelle parole dei linguaggi naturali alcune lettere ricorrono più di altre, non serve lo stesso numero di domanda ma molto meno e così l'entropia media diminuisce.
Per prevenire questi effetti collaterali, il nostro metodo di generazione e quindi ciò che viene generato, deve essere testato con qualcos'altro che non sia la semplice entropia.
ent è un tool a linea di comando che fa 4 valutazioni differenti:
- entropia
- Chi-quadrato
- Media aritmetica
- Monte Carlo Pi
N.B. ent non è adatto alla valutazione della singola password perché ha bisogno di migliaia di dati (almeno 1K). Una singola password di 24 caratteri per es. (24 byte) non ha materiale casuale sufficiente affinché ent converga verso un giudizio oggettivo.
Entropia
L'entropia misura la densità di informazione. In ent, viene calcolata in bit per carattere (byte).
- Il valore: Si analizza il file byte per byte, il valore massimo è 8.0 (ogni byte è totalmente imprevedibile).
- Interpretazione: Più il valore è vicino a 8, più la casualità è “densa” e difficile da indovinare tramite attacchi basati su dizionario. Se il valore è basso (es. 2.0 o 3.0), significa che ci sono molte ripetizioni o uno schema prevedibile.
- Compressione: ent ti dice anche quanto il file potrebbe essere compresso. Un'entropia di 8.0 significa che il file è già “puro caos” e non può essere compresso ulteriormente.
Chi-quadrato
Il test del chi-quadrato prova a capire se il disordine presente nel file sia veramente equo o se si preferiscono certi caratteri ad altri. Esamina la distribuzione dei caratteri e la confronta con una distribuzione uniforme teorica. Il risultato viene presentato come percentuale con questi scaglioni:
- 10% < chi2 < 90%: La sequenza è considerata casuale. Il 50% è il valore “perfetto”.
- chi2 < 1% o chi2 > 99%: È quasi certamente non casuale.
- chi2 = 99.99%: i dati sono sospettosamente regolari;
- chi2 = 0.01%: i dati sono “troppo” casuali per essere naturali (sospetta manipolazione)
Media aritmetica
Per capire se la distribuzione è sufficientemente omogenea, si fa la somma dei valori dei byte del file e si fa una media.
Poiché i byte vanno da 0 a 255, il valore ideale della media sarebbe 127,5.
Se è troppo lontano dalla media avvcinandosi ad uno dei due estremi (ad es. 50 o 190), vuol dire che si sta usando solo un piccola parte dei caratteri a disposizione e questo, a suo modo di vedere, rende le password più prevedibili.
Monte Carlo Pi
È il metodo più fantasioso di tutti.
I dati casuali vengono trasformati in una serie di “dardi” virtuali che vanno a colpire un bersaglio. L'obiettivo non è quello di colpire un ipotico centro ma di verificare che i “dardi” si distribuiscano uniformemente nel bersaglio.
Tutto ciò si realizza immaginando di avere un quadrato 1x1 e ¼ di cerchio al suo interno di raggio 1 e area π/4
I dati della sequenza casuale vengono prelevati a gruppi di n byte e supponiamo n = 3 per ora.
Ogni gruppo di 3 byte sarà un numero compreso tra 0 e 224-1.
Se normalizziamo questo numero dividendolo per 224, otteniamo un numero compreso fra 0 e 1.
Calcolando le coordinate in questo modo, col teorema di Pitagora possiamo verificare se la coordinata (X,Y) “cada” nel quarto di cerchio oppure no e ciò succede se:
X2 + Y2 ≤ 1
Lanciando un migliaio di queste “frecce”, accumuliamo dati sufficiente per fare una stima.
Se indichiamo con In il numero di “lanci” con successo e con Total il numero totale di lanci effettuati:
4 * (ln/Total) si avvicinerà a π solo se la distribuzione dei caratteri sarà uniforme (indice di una casualità omogenea), altrimenti divergerà in maniera significativa (indice della presenza di pattern o di ripetizioni).
zxcvbn
ent fa un'analisi statistica della distribuzione dei bit in un generatore di casualità.
zxcvbn invece fa un'analisi di tipo euristico, è verticale sulla verifica delle password in particolare nel rilevare se vi sono schemi o ripetizioni di caratteri che renderebbero le password violabili.
Il suo algoritmo scompone le password in pezzi dei quali cerca corrispondenze in dizionari o schemi come:
- dizionari: controlla la presenza di parole di uso comune
- sequenze: controlla la presenza di serie di caratteri prevedibili come “123456”, “abcde”
- pattern spaziali: controlla la presenza di percorsi sulla tastiera come “qwerty”, “asdfg”, “zcvbn” o sequenze diagonali
- ripetizioni: ripetizione di caratteri come “kkkkkkkkkk” o “12121212”
- l33t: una parola come “p4$$w0rd” viene subito riconosciuta come “password”
- date: riconosce giorni, mesi, anni, anche composti come “15062026”
Il suo uso è molto semplice.
Le si dà in pasto la password e zxcvbn restituisce diverse informazioni utili:
- uno score da “0” (terribile) a “4 (ottima);
- la stima di quanto tempo impiegherebbe un hacker a violarla in base a vari scenari di attacco;
- suggerimenti su come migliorare eventualmente la password.
zxcvbn era una libreria javascript orginariamente sviluppata da Dropbox e ora disponibile in tante forme: go, python, c++.
L'originale Dropbox in javascript, non più manutenuto, può essere trovata qui: https://github.com/dropbox/zxcvbn.
Benché esistano diversi porting in python, se c'è l'esigenza di usare la versione legacy, gli stessi sviluppatori dell'originale zxcvbn consigliano questa versione: https://github.com/dwolfhub/zxcvbn-python, che può essere installata con pip.
In realtà la versione migliore è un fork in typescript, zxcvbn-ts che offre modularità (a differenza della versione python che è monolitica), maggior sicurezza, risoluzione di bug, aggiornamento continuo dizionari compresi.
Per capirci, mentre ent usa l'entropia di Shannon per valutare la probabilità statistica dei byte, zxcvbn cerca di calcolare una stima dei tempi necessari per indovinare la password.
Una passphrase su ent avrebbe un punteggio risibile perché le entropie di parole comuni sono molto basse. Su zxcvbn invece avrebbe un punteggio molto alto perché l'entropia di una parola viene calcolata sulla posizione del dizionario che la contiene per cui un hacker dovrebbe provare milioni di combinazioni prima di trovarla.
Allo stesso modo, password che per ent sarebbero ottime, per zxcvbn sarebbero da evitare perché legate a pattern o a ripetizioni.
Riassumendo
Se si deve testare una password / passphrase, sicuramente zxcvbn.
Se si deve testare un generatore di casualità o un keyfile di almeno 2k, sicuramente ent.
Metodo Diceware
Visto che nell'ultima parte abbiamo evidenziato l'anomalia che sorge nel momento in cui si valuta un oggetto casuale o dal punto di vista puramente statistico o dal punto di vista euristico, vale la pena di spendere due parole sulla modalità di creazione delle passphrase usando il metodo Diceware.
Usando come password parole estratte dal linguaggio naturale bisogna fare i conti col problema della prevedibilità.
Shannon ha dimostrato che la lingua italiana (o inglese) ha un'entropia molto bassa (circa 1-1.5 bit per lettera) perché dopo una “q” ci si aspetta quasi sempre una “u”, e dopo un soggetto ci si aspetta un verbo. E così via.
Ecco perché, piuttosto che valutare l'entropia nel suo complesso e provare ogni possibile combinazione, un moderno calcolatore inzia col far ricorso a “pattern” umani per violare password in pochi minuti invece che millenni.
Per unire la sicurezza del calcolo casuale alla comodità di una password menmonica, si ricorre al metodo Diceware che consiste nel far uso di un dizionario di migliaia di parole.
Quello classico, di 7776 parole inglesi, curato dall EFF si può trovare qui:
curl -L https://www.eff.org/files/2016/07/18/eff_large_wordlist.txt > dic_diceware.txt
Altrimenti Tarin Gamberini espone il suo dizionario diceware , aggiornato al 2019, qui: https://www.taringamberini.com/downloads/diceware_it_IT/lista-di-parole-diceware-in-italiano/4/word_list_diceware_it-IT-4.txt.
Questo dizionario contiene 65 parole numerate da 11111 a 66666.
La passphrase è composta da n di queste parole il cui indice è ricavato lanciando un dado (o un analogo virtuale) per 5 volte.
In questo modo le parole non sono correlate fra di loro come si potrebbero trovare in una frase, vanificando ogni possibile speculazione sulla sua composizione.
Volendo fare un calcolo dell'entropia, supponendo di costruire una passphrase di 6 parole:
E = L * log2 R = 6 * log2 7776 ~ 77,6
Nella password classiche basate su un alfabeto di R simboli, il mattoncino è rappresentato dal singolo carattere che ha una probabilità 1/R di essere estratto.
Con Diceware, il mattoncino è la parola che ha una probabilità su 7776 di essere estratta. Ogni parola in più, aggiunge una quantità enorme di incertezza.
Ecco perché con sole 6 parole abbiamo già una passphrase molto robusta e con 10 parole siamo di fronte ad una passphrase inattacabile, almeno dal punto di vista dell'analisi statistica (E > 129) e imperforabile anche ricorrendo ad analisi euristiche.
Regola aurea: la scelta delle parole deve essere realmente casuale e non seguire regole grammaticali o preferenze personali. Altrimenti sarà un gioco da ragazzi violarla con un approccio a-là zxcvbn.
#entropy #shannon #bruteforce #ent #zxcvbn #diceware #passphrase #PatternMatching