Scuola Politecnica e delle Scienze di Base
Corso di Laurea in Ingegneria Informatica
Elaborato finale in Elettronica Generale
Random Number Generation Techniques
Anno Accademico 2015/2016
Candidato:
Giuseppe Primo
matr. N46001089
Alla mia Famiglia
2
Indice
Random Number Generation Tecniques .................................................................................. 1
Indice .................................................................................................................................................... 3
Introduzione ......................................................................................................................................... 4
Capitolo 1: True Random Number Generator...................................................................................... 6
1.1 Direct Amplification .................................................................................................................. 8
1.2 Oscillator Sampling .................................................................................................................. 10
1.3 Discrete-Time Chaos ................................................................................................................ 11
Capitolo 2: Pseudo-Random Number Generator ............................................................................... 14
2.1 Middle Square Method............................................................................................................. 15
2.1.1 Esempio MSM: ................................................................................................................. 15
2.2 Linear Congruential Generator ................................................................................................ 16
2.2.1 Esempio LCG: .................................................................................................................. 17
2.3 Lagged Fibonacci Generator .................................................................................................... 18
2.4 Mersenne Twister ..................................................................................................................... 19
2.6 Blum Blum Shub ...................................................................................................................... 20
2.1.1 Esempio BBS: ................................................................................................................... 21
2.7 Fortuna ..................................................................................................................................... 21
Capitolo 3: TRNGs VS. PRNGs ........................................................................................................ 24
Capitolo 4: Conclusioni ..................................................................................................................... 28
Bibliografia ........................................................................................................................................ 30
3
Introduzione
I generatori di numeri casuali o Random Number Generators (RNGs) sono dispositivi
hardware o componenti software in grado di generare sequenze di numeri casuali.
Un numero casuale può essere visto come una singola osservazione di una specifica
variabile aleatoria. Una sequenza di numeri, per essere definita casuale, deve soddisfare
almeno due caratteristiche:
I numeri appartenenti alla suddetta sequenza devono essere uniformemente
distribuiti (equiprobabili).
Ogni numero deve essere statisticamente indipendente dagli altri numeri della
sequenza
Gli studiosi concentrano le loro ricerche ed il loro lavoro nel campo della generazioni di
numeri in maniera casuale perché i RNGs sono impiegati in molti scenari: giochi e lotterie,
crittografia, generazione di dati per test, simulazioni al computer (ad esempio simulazione
di Monte Carlo), videogiochi e, in generale, in tutte quelle applicazioni in cui sono richiesti
eventi casuali.
Nella maggior parte delle applicazioni è desiderabile avere un generatore veloce e che
produca sequenze di numeri quanto più “casuali” possibile. Tuttavia, queste due proprietà
sono, di solito, inversamente proporzionali tra di loro: RNGs di buona qualità sono spesso
lenti, mentre RNGs di bassa qualità sono, tipicamente, veloci.
Per valutare la qualità di un generatore di numeri casuali, si effettuano una serie di test
statistici applicati alle sequenze di numeri ottenute. Attualmente, esistono molti test statistici
ed ognuno di essi, in generale, mira a dimostrare la presenza o l’assenza di “pattern” (o
correlazione) all’interno della sequenza generata. La presenza di correlazione all’interno
4
della sequenza potrebbe indicare che la sequenza stessa non soddisfi le due proprietà citate
e quindi, il generatore, sarà considerato di bassa qualità. E` importante tenere a mente che
un numero finito di test statistici non può dimostrare che la sequenza generata sia casuale,
è solo possibile dimostrare che la sequenza non è casuale.
Dunque, poiché i test sono di natura statistica, non sarà possibile dare per certo il loro esito
ma, ovviamente, più saranno i test che il generatore supera maggiore sarà la possibilità che
il generatore sia un buon generatore.
Si distinguono, a partire dal tipo di implementazione adottata, due principali famiglie di
generatori: True Random Number Generator - TRNG e Pseudo-Random Number Generator
- PRNG.
5
Capitolo 1: True Random Number Generator
Chiamati anche Physical RNG o Hardware RNG lavorano sulla base di alcuni fenomeni
fisici i quali ci si aspetta che siano puramente casuali. In particolare essi “estraggono” la
casualità da processi fisici che si comportano, in linea di principio, in maniera non
deterministica e quindi non predicibile.
I fenomeni fisici su cui si basano questo tipo di generatori sono fenomeni microscopici
come: il rumore termico, rumore atmosferico, effetto fotoelettrico, fenomeni quantistici o
altri fenomeni.
Un TRNG è un componente hardware spesso separato dal computer o dal dispositivo
“ospitante”, connesso ad esso tramite USB o PCI bus.
Si intuisce allora che la sorgente di rumore in ingresso al generatore deve spesso seguire un
forte processo di digitalizzazione.
In generale, l’architettura di un TRNG (Fig. 3) prevede:
Un segnale analogico n(t) generato dalla sorgente di rumore (Noise Source) in
ingresso, sulla base di processi fisici non deterministici, al Digitizer. Una sorgente
di rumore ideale genera un segnale con distribuzione di probabilità uniforme.
Il Digitizer campiona il segnale analogico (ad es. con un comparatore) e lo converte
in uno stream di bit random s[i] (segnale analogico digitalizzato). Il Digitizer,
insieme al Noise Source forma il Digitizer Noise Source.
Il segnale digitalizzato s[i] è dato in input al Post-Processing Unit il quale produce
words composte da m-bit (Internal Random Numbers – r[i]).
6
Questo blocco risolve due problemi: c’è la possibilità che la distribuzione di
probabilità dei random bits generati non sia puramente uniforme ed inoltre si
potrebbe verificare una bassa entropia.
In particolare, il Post-Processing block consente di ottenere sequenze
uniformemente distribuite di “0” e “1”.
Questo componente hardware è implementato con diverse tecniche, tra le più diffuse
si individuano: quella basata su un concetto proposto da John Von Neumann (Von
Neumann Corrector, Fig.1) e quella basata su un operazione di OR esclusivo (XOR
Corrector, Fig. 2).
1. Von Neumann Corrector converte coppie di bit in un solo output. In
particolare converte la coppia [1, 0] in 0 e la coppia [0, 1] in 1. Per le coppie
[0, 0] e [1, 1] non corrisponderà nessun output.
[Fig. 1 Von Neumann Corrector]
2. XOR Corrector è basato sul concetto di OR Esclusivo descritto dalla tabella
di verità in Fig. 2.
[Fig. 2 Tabella di Verità XOR]
Con l’ausilio di questo componente, dunque, sarà possibile incrementare l’entropia
della sequenza in uscita ma il bit-rate complessivo del generatore, ovviamente,
tenderà a diminuire.
7
Output Interface è un modulo che consente di avere una rappresentazione del
numero generato in uno specifico formato. Quindi, tale blocco, converte la sequenza
r[i] in una sequenza “richiesta” r_out[i] (External Random Number).
[Fig. 3 Architettura generale di un TRNG]
Le tecniche TRNG più diffuse sono tre:
Direct Amplification
Oscillator Sampling
Discrete-Time Chaos
1.1 Direct Amplification
La tecnica di generazione di numeri casuali più popolare è quella dell’amplificazione diretta,
mostrata in Fig.1.1. E` caratterizzata da un amplificatore operazionale per amplificare il
segnale (rumore) prodotto dalla sorgente di rumore. La sorgente di rumore può essere, ad
esempio:
rumore termico (generato dal movimento degli elettroni in un resistore)
shot noise (generato dal flusso di corrente che attraversa una giunzione p-n).
8
[Fig. 1.1 Tecnica di Amplificazione Diretta]
Il rumore deve essere amplificato per consentire al comparatore di operare riducendo i
margini di errore.
Il comparatore, a partire dagli input, converte il segnale analogico in un bitstream che
rappresenta il numero digitale generato.
Nello specifico, la tecnica dell’amplificazione diretta, consiste nel moltiplicare il segnale
rumore w(n) col guadagno costante dell’amplificatore K e, successivamente, comparare il
risultato con una tensione di offset 𝑉𝑜𝑓𝑓 in modo da ottenere, in output, una sequenza di bit
𝑏𝐷𝐴 (𝑛) come descritto di seguito:
𝑏𝐷𝐴 (𝑛) = {
1,
0,
𝐾 𝑤(𝑛) < 𝑉𝑜𝑓𝑓
𝑎𝑙𝑡𝑟𝑖𝑚𝑒𝑛𝑡𝑖
Per via della semplicità di realizzazione e del basso consumo di potenza, questa tecnica è
adatta a soluzioni basate su singoli chip solo se è possibile schermare il rumore.
Infatti è sensibile a variazioni deterministiche causate, in generale, da fenomeni di natura
elettromagnetica o dalle particolari caratteristiche dell’amplificatore stesso. Pertanto, il
segnale ottenuto in output dall’amplificatore sarà un segnale predicibile.
La soluzione più efficiente potrebbe essere quella di schermare l’intero circuito al fine di
preservare il segnale di rumore. Questa soluzione però richiederebbe grandi sforzi, sia in
termini di progettazione e sia in termini economici.
9
1.2 Oscillator Sampling
La maggior parte dei TRNGs sono basati su oscillatori. In questo tipo di generatori, due o
più oscillatori sono combinati al fine di produrre una sequenza random di bit.
Un tipico esempio di questi generatori è mostrato in Fig. 1.2.
I componenti fondamentali sono:
Un oscillatore a bassa frequenza
Un oscillatore ad alta frequenza
Flip-Flop D
L’oscillatore a bassa frequenza fornisce un segnale di clock al Flip-Flop D in modo da
campionare, sul fronte di salita, il segnale ad alta frequenza generato dall’oscillatore ad alta
frequenza.
Di fondamentale importanza è il periodo di jitter delle oscillazioni in quanto comportano
incertezza nel momento di cui si va a campionare in un determinato istante. La “robustezza”
di tale generatore può essere incrementata definendo opportunamente la frequenza dei due
oscillatori.
La probabilità di generare numeri puramente casuali dipende, dunque, dal periodo di jitter.
[Fig. 1.2 Basic oscillator-based Random Number Generator]
Questa tecnica, a differenza del Direct Amplification, è più robusta in presenza di rumore
non “schermato”. Inoltre è possibile, stabilendo il periodo degli oscillatori, la qualità dei
numeri generati.
10
Ma è stato dimostrato che, a partire solamente jitter degli oscillatori, non è sufficiente
generare sequenze puramente casuali. Inoltre, il bit-rate di un generatore di questo tipo è
circa 100 kbps e, dunque, sarà difficile utilizzarlo in sistema crittografici ad alta velocita`.
1.3 Discrete-Time Chaos
Una soluzione a questi problemi potrebbe essere quella basata sulla teoria del chaos.
Il “chaos” può essere visto come un comportamento non periodico, a lungo termine e non
prevedibile generato da un certo sistema dinamico non lineare.
Un sistema caotico è, dunque, un sistema fisico dominato dal caos nel quale anche piccole
sollecitazioni del sistema potrebbero avere notevoli conseguenze sullo stato futuro del
sistema stesso.
I sistemi caotici, dato lo stato iniziale del sistema, sono per natura deterministici. Se si
conosce esattamente lo stato iniziale del sistema, l’output del sistema potrebbe essere
prevedibile. La particolarità di questo tipo di sistemi è che, in pratica, è difficile stimare lo
stato iniziale del sistema e tale caratteristica li rende impredicibili.
Possono essere utilizzate, ad esempio, le chaotic maps che sono una sottoclasse di sistemi
dinamici non lineari a tempo discreto.
Una tipica implementazione è la mappa shift di Bernoulli la quale esibisce un
comportamento caotico mostrato in Fig. 1.3.1.
All’interno della mappa si genera:
0 se 𝑥𝑛 < 1/2
1 se 𝑥𝑛 > 1/2.
11
Le probabilità di tutte le transizioni è uguale ad ½ a prescindere dallo stato corrente del
sistema.
[Fig. 1.3.1 Bernoulli shift map]
Generatori che implementano soluzioni di questo tipo sono simili ai convertitori A/D (Fig.
1.3.2) in quanto sono composti da N-moduli in cascata (N-bit A/D Converter). L’output di
un modulo è dato in input al modulo successivo.
[Fig. 1.3.2 Esempio di una tecnica discrete-time chaos]
L’inserimento di più moduli in sequenza, consente di aumentare la velocità dell’intero
sistema e di conseguenza di migliorare la qualità dei bit casuali generati.
Quindi l’alta velocità, capacità di integrazione e l’alta qualità dei bit generati rendono questo
tipo di soluzione un candidato eccellente per la realizzazione di sistemi embedded basati su
generatori di numeri casuali.
I TRNGs basati su chaos sono molto più veloci dei TRNGs basati su oscillatori e possono
essere facilmente integrati in altri circuiti. Come le tecniche basate su oscillatori, anche le
tecniche discrete-time chaos sono robuste a influenze deterministiche (interferenze).
12
E` stato dimostrato, inoltre, che la non idealità delle mappe caotiche permettono di
migliorare l’efficienza del Post-Processing Unit.
13
Capitolo 2: Pseudo-Random Number Generator
Numeri casuali possono essere ottenuti anche da algoritmi i quali dovrebbero produrre, in
linea generale, una sequenza di numeri avente le stesse proprietà statistiche di una sequenza
generata da un TRNG.
L’utilizzo di algoritmi però implica che i numeri verranno generati in modo completamente
deterministico. Sarà quasi sempre necessario fornire un valore iniziale detto seme al fine di
inizializzare l’algoritmo.
A parità di seme e di interazioni, questi metodi forniscono sempre la stessa identica
sequenza. Per tale motivo questo tipo di generatori sono detti generatori Pseudo-Casuali.
Nei PRNGs vengono generati, nella maggior parte dei casi, sequenze di numeri interi
uniformemente distribuiti tra 0 e un numero massimo prestabilito, oppure sequenze di
numeri reali compresi tra 0 e 1.
Esistono numerosi tipi di PRNG che si differenziano in base al tipo di algoritmo
implementato, tra i più importanti ed utilizzati si individuano:
Middle Square Method
Linear Congruential Generator
Lagged Fibonacci Generator
Mersenne Twister
Blum Blum Shub
Fortuna
Gli ultimi due metodi, in particolare, sono utilizzati in tutte quelle applicazioni critiche
basate su crittografia. Per tali generatori c’è il bisogno di definire, oltre alle due proprietà
citate precedentemente, un’altra importante proprietà`: la non predicibilità. Ovvero,
14
l’algoritmo usato per generare numeri casuali non deve permettere di ricostruire l’intera
sequenza di numeri a partire dalla conoscenza di una parte di essa o dal seme.
Tutti i generatori che soddisfano questo requisito sono detti generatori crittograficamente
sicuri (Cryptographically Secure Pseudo-Random Number Generator – CSPRNG).
2.1 Middle Square Method
Uno dei primi metodi proposti fu il Middle Square Method - MSM. Questo metodo fu
inventato da John Von Neumann e descritto in una conferenza nel 1949. L’algoritmo si basa
su un’idea sostanzialmente semplice:
1) Si stabilisce valore iniziale (seme) 𝑥0 di M cifre
2) Tale valore è elevato al quadrato, aggiungendo degli 0 se necessario
3) L’elemento successivo della sequenza in output sarà quello individuato dalle M cifre
centrali di tale numero.
4) Il numero individuato farà da nuovo input all’algoritmo ed iterando il processo è
possibile ottenere una sequenza di numeri pseudo-random di M cifre.
2.1.1 Esempio MSM:
𝑥𝑛 = 945726
𝑥𝑛 2 = 894397667076
𝑥𝑛+1 = 397667
𝑥𝑛+1 2 = 158139042889
𝑥𝑛+2 = 139042
…
Sono molte però le problematiche legate a questo tipo di algoritmo:
Nel caso in cui le M cifre centrali siano tutte 0, il generatore produrrà solamente
numeri ad M cifre nulle.
Nel caso in cui almeno la metà delle cifre ottenute fosse composta da 0, tutti i
successivi output decrescerebbero fino a 0.
15
Particolari valori iniziali potrebbero produrre sempre gli stessi output.
Nonostante le carenze, questo metodo risulta comunque molto rapido.
2.2 Linear Congruential Generator
La metodologia più utilizzata è quella degli algoritmi a congruenza lineare. Questo tipo di
algoritmi permettono, in modo analogo all’algoritmo Middle Square, di generare una
sequenza di numeri casuali a partire da un seme. In più risolve il problema della comparsa
degli zeri introdotto nel Middle Square Method.
Il generatore lineare congruenziale - LCG fu introdotto intorno agli anni 50’ dal matematico
D.H. Lemer ed è ancora oggi molto utilizzato.
Si basa su un concetto molto semplice da comprendere e da implementare. Il generatore
implementa la seguente relazione matematica:
𝑥𝑛+1 = (𝑎𝑥𝑛 + 𝑐) mod 𝑚
In cui:
𝑥0 è il seme o valore iniziale
𝑥𝑛 è un valore della sequenza
𝑚 coefficiente intero strettamente maggiore di 0 chiamato modulo
𝑎 coefficiente intero strettamente maggiore di 0 chiamato moltiplicatore
𝑐 e` detto incremento ed è non negativo. Nel caso in cui 𝑐 = 0 si parla di ParkMiller RNG o RNG moltiplicativo)
Il periodo di un LCG può essere al più pari ad 𝑚 e una scelta errata dei valori di 𝑎 e 𝑐 può
influire negativamente sulla lunghezza della sequenza ottenuta.
E` stato necessario, dunque, definire dei criteri per assegnare dei valori ad 𝑎, 𝑐, 𝑚 e ad 𝑥0
al fine di garantire periodo massimo. In particolare è stato dimostrato che converrebbe
scegliere in parametri in questo modo:
1. 𝑐 e 𝑚 devono essere coprimi (𝑀𝐶𝐷 (𝑐, 𝑚) = 1)
2. 𝑎 − 1 è divisibile per tutti i fattori primi di 𝑚
3. Se 𝑎 − 1 è multiplo di 4 anche 𝑚 dovrà essere un multiplo di 4
16
2.2.1 Esempio LCG:
Un esempio può essere mostrato scegliendo i parametri in questo modo:
𝑎=3
𝑐=6
𝑚=5
𝑥0 = 1
L’output è raffigurato in Fig. 2.2.1 dove si evince che, in questo caso, il periodo è uguale a
4. La relazione che caratterizza il generatore diventa:
𝑥𝑖+1 = (3 ∙ 𝑥𝑖 + 6) mod 5
La sequenza generata sarà dunque:
𝑥1 = (3 ∙ 𝑥0 + 6) mod 5 = 4
𝑥2 = (3 ∙ 𝑥1 + 6) mod 5 = 3
𝑥3 = (3 ∙ 𝑥2 + 6) mod 5 = 0
𝑥4 = (3 ∙ 𝑥3 + 6) mod 5 = 1
𝑥5 = (3 ∙ 𝑥4 + 6) mod 5 = 4
𝑥6 = (3 ∙ 𝑥5 + 6) mod 5 = 3
[Fig. 2.1.1 Sequenza generata dal LCG]
Alcune librerie di vari compilatori implementano la funzione rand(), basata sul LCG, con
parametri differenti. Tra le più importanti troviamo:
17
GNU C Library (glibc) che seleziona: 𝑚 = 232 , 𝑎 = 1103515245, 𝑐 = 12345 e
si considerano i bit ottenuti dal 30 a 0
Java.Util.Random che seleziona: 𝑚 = 248 , 𝑎 = 25214903917, 𝑐 = 11 e si
considerano i bit ottenuti dal 47 a 16
I vantaggi di questo tipo di approccio sono sicuramente la semplicità di realizzazione e la
velocità di generazione dei numeri (complessità computazionale molto bassa).
Queste caratteristiche gli permettono di essere utilizzati in tutti quei sistemi, con potenzialità
di calcolo e memoria limitate, come i sistemi embedded e spesso nei videogiochi.
Tuttavia, si può ottenere una sequenza periodica di periodo al più pari ad 𝑚, quindi occorre
scegliere 𝑚 elevato e valore di 𝑎, 𝑐 e 𝑥0 tali da avere periodo massimo.
I valori 𝑥𝑖 generati sono determinati da questi ultimi quattro parametri rendendo le sequenze
in uscita predicibili. Inoltre le sequenze generate risultano correlate, pertanto non si presta
a tutte le applicazioni basate su crittografia e simulazione.
2.3 Lagged Fibonacci Generator
Il generatore di Fibonacci ritardato è stato introdotto per cercare di allungare il periodo del
generatore. E` basato sulla generalizzazione della successione di Fibonacci:
𝐹𝑘 = 𝐹𝑘−1 + 𝐹𝑘−2
Similmente, il generatore è definito dalla relazione:
𝐹𝑘 = (𝐹𝑘−𝑝 ⊗ 𝐹𝑘−𝑝+𝑞 ) mod 𝑚
In cui:
𝐹𝑘 e` l’n-esimo termine della successione di numeri pseudo-casuali generati
𝑝 e` chiamato lag del generatore
⊗ e` una qualsiasi operazione (addizione, sottrazione, divisione, moltiplicazione o
un operazione logica)
𝑚 = 2𝑙 è detto modulo
Con tale algoritmo si generano numeri random formati da 𝑙 bit.
Nel generatore di Fibonacci, il periodo varia a seconda dell’operatore utilizzato.
Ad esempio, nel caso di somma o sottrazione, il generatore avrà periodo 𝑇 tale che:
18
𝑇 ≤ (2𝑝 − 1) ∙ 2𝑙−1
Nel caso della moltiplicazione, il generatore avrà periodo 𝑇 tale che:
𝑇 ≤ (2𝑝 − 1) ∙ 2𝑙−3
Nel caso dell’ OR esclusivo, il periodo 𝑇 diventera`:
𝑇 ≤ (2𝑝 − 1)
Tutti i generatori di Fibonacci hanno numerosi vantaggi rispetto ai generatori lineari
congruenziali. Un aspetto di rilievo è il periodo relativamente più lungo rispetto ai LCGs in
quanto può essere aumentato scegliendo un valore di 𝑝 sufficientemente grande.
E` stato dimostrato che con i generatori basati su addizione, sottrazione e moltiplicazione si
ottengono buoni risultati sulla maggior parte dei test statistici anche con valori piccoli di 𝑝.
Valori tipici della coppia (𝑝, 𝑞) sono: (17, 5), (31, 13), (55, 24).
E` però raccomandato scegliere valori di 𝑝 sempre sufficientemente grandi al fine di
migliorare la qualità del generatore stesso.
Generatori basati su OR Esclusivo sono inefficienti per valori di 𝑝 piccoli, mentre per valori
grandi, riescono a superare tutti i test statistici.
Per questi generatori è consigliato, inoltre, assegnare a 𝑝 numeri primi di Mersenne.
2.4 Mersenne Twister
E` un algoritmo sviluppato da M. Matsumoto e T.Nishimura nel 1997. Questo algoritmo
viene proposto al fine di porre rimedio alle varie mancanze delle precedenti soluzioni.
La prima cosa che bisogna osservare è che il periodo viene aumentato a 219937 − 1, tale
periodo non e` una casualita` in quanto, il generatore MT, e` stato progettato apposta per
ovviare ai problemi introdotti dai generatori con periodo breve. Inoltre e` molto simile al
LCG usato nel linguaggio C in termini di velocità di generazione.
Il nome di questo metodo deriva dal fatto che la lunghezza del periodo scelto deve essere
un numero primo di Mersenne.
19
Un numero primo di Mersenne è un numero primo esprimibile come:
𝑀𝑝 = 2𝑝 − 1
𝑝 è un numero intero positivo primo
Nonostante sia trascurabile la correlazione tra valori successivi della sequenza, questo
algoritmo, non è considerato ottimale in ambito crittografico ma si presta molto bene nei
metodi Monte Carlo.
In seguito però, sono state introdotte nuove varianti dell’algoritmo in grado di lavorare
anche in ambito crittografico. Si rimanda, per l’implementazione di tale algoritmo, al sito
ufficiale [11].
2.6 Blum Blum Shub
Questo algoritmo, facendo parte dei CSPRNGs, possiede proprietà che lo rendono
particolarmente adatto in ambito della crittografia. Il Blum Blum Shub generator o anche
BBS o generator 𝑥 2 mod 𝑛 e` definito come:
𝑏𝑖 = 𝑥𝑖 𝑚𝑜𝑑 2
Dove:
𝑥𝑖 = 𝑥𝑖−1 2 mod 𝑛
𝑛 = 𝑝𝑞 è un numero intero chiamato Blum Integer
𝑝 e 𝑞 sono due numeri primi distinti con 𝑝 = 3 (mod 4) e 𝑞 = 3 (mod 4)
Step eseguiti dall’algoritmo:
1. Vengono scelti due numeri primi casuali molto grandi (𝑝 e 𝑞) e si calcola il Blum
Integer: 𝑛 = 𝑝𝑞
2. Viene scelto un numero casuale, 𝑠0 detto seme, primo con 𝑛 ed appartenente
all’intervallo [1, 𝑛 − 1]. Si calcola allora 𝑥0 = 𝑠0 2 mod 𝑛
3. Per 𝑖 che va da 1 a 𝑙, con 𝑙 numero di generazioni da effettuare, si esegue:
a. 𝑥𝑖 = 𝑥𝑖−1 2 mod 𝑛
b. Si calcola 𝑏𝑖
20
2.1.1 Esempio BBS:
𝑛 = 𝑝 ∙ 𝑞 = 7 ∙ 19 = 133 → 𝑠 = 100
𝑥0 = 1002 mod 133 = 25 → 𝑏𝑜 = 1
𝑥1 = 252 mod 133 = 93 → 𝑏1 = 0
𝑥2 = 932 mod 133 = 4 → 𝑏2 = 0
𝑥3 = 42 mod 133 = 16 → 𝑏3 = 1
𝑥4 = 162 mod 133 = 123 → 𝑏4 = 1
L’output sarà: [1, 0, 0, 1, 1]
Questo algoritmo è poco efficiente nelle simulazioni in quanto potrebbe essere laborioso il
calcolo dei numeri. Inoltre, la sequenza prodotta da questo algoritmo non è bilanciata (le
frequenze con cui si verificano gli 0 e gli 1 non sono uguali).
Tuttavia, è stato dimostrato che, questa non uniformità non è poi così differente dalle
sequenze generate da un TRNG della stessa lunghezza. Per tale motivo si presta molto bene
in ambito crittografico.
2.7 Fortuna
Fortuna è un algoritmo di generazione di numeri pseudo-casuali creato da B.Schneier e N.
Ferguson. Il nome deriva dalla Dea del caso e del destino nella mitologia Romana.
Questo algoritmo tende a svincolarsi dal concetto di seme come visto finora.
Il generatore si articola in tre parti:
1. Accumulatore di entropia: raccoglie dati provenienti da varie sorgenti esterne (es.
tastiera, mouse, scheda audio ecc…) e li usa come seme del generatore. I dati
provenienti dalle sorgenti esterne sono uniformemente distribuiti tra 32 pool
chiamati, rispettivamente, 𝑃0 , 𝑃1 , … , 𝑃31 . In teoria, un singolo pool, potrebbe
contenere infiniti dati e, se accumula sufficiente entropia, verrà aggiornato
rinnovando così il seed del generatore. Sarà presente un contatore che tiene traccia
del pool correntemente utilizzato per l’aggiornamento del seme del generatore.
21
[Fig. Fortuna’s 32 Entropy Pools]
2. Generatore: viene inizializzato con un seed proveniente dall’accumulatore di
entropia e genera sequenze di lunghezza arbitrarie di numeri pseudo-casuali.
Il generatore è realizzato tramite un cifrario a blocchi (ad esempio AES). Lo stato
interno del generatore è caratterizzato da una chiave a 256-bit (quella proveniente
dall’accumulatore) e da un contatore a 128-bit.
Dopo ogni richiesta di dati casuali, si generano 256-bit supplementari e si utilizzano
come nuova chiave (next key) del codice a blocchi al fine di rendere l’algoritmo
crittograficamente sicuro.
[Fig. Fortuna’s Generator Core]
3. Seed File Manager: una volta avviato l’algoritmo, si crea un seed file usato per
memorizzare un certo quantitativo di dati casuali per inizializzare il generatore all’avvio
22
del dispositivo. Questo per far sì che l’algoritmo generi dati casuali sin dall’inizio, in
quanto i livelli di entropia raccolto dall’accumulatore, all’avvio dell’algoritmo, non sono
ancora sufficienti per la generazione di numeri random.
Allo start-up il seed file è letto, immediatamente un seed è generato e scritto all’interno
del file. Quindi se si riavvia il dispositivo, non bisogna attendere che le fonti di casualità
generino un numero di eventi sufficiente ad effettuare il primo rinnovo del seme.
Un tipico problema potrebbe sorgere nel momento in cui si verifica uno spegnimento
anomalo della macchina. Si cerca allora di tenere sempre aggiornato il file del seme
quando si accumula sufficiente entropia. E` consigliato aggiornare il file ogni 10 minuti
circa ma questo dipende dal tipo di applicazione che si sta progettando e dalla velocità
dell’accumulatore nel raccogliere entropia.
Questo generatore riesce a produrre sequenze casuali di qualità molto alta ed inoltre è
relativamente facile implementarlo.
Ciò lo rende un ottimo candidato in tutte le applicazioni basate su crittografia.
23
Capitolo 3: TRNGs VS. PRNGs
Finora abbiamo analizzato le tecniche di generazione di numeri casuali più diffuse, sia
quelle basate su TRNG sia quelle basate su PRNG, cercando di porre in risalto i vantaggi e
svantaggi di ogni tecnica.
Lo scopo di questo capitolo è di mettere a confronto, anche sulla base di un esempio pratico,
le più significative differenze tra le due famiglie di generatori.
Si parte dal presupposto che un modo semplice per esaminare un generatore di numeri è,
senza effettuare test statistici, mostrare una visualizzazione grafica dei numeri prodotti in
quanto risulta più semplice dedurre qualcosa osservando semplicemente un’immagine.
Questo approccio ovviamente non è esaustivo come l’insieme dei test statistici ma consente,
rapidamente, di farsi un’idea su cosa si sta cercando di dimostrare.
Sono state generate, a tal fine, due bitmap: una tramite il tool Bitmap Generator basato su
un TRNG del sito web [15] e l’altra tramite un algoritmo implementato in C++ (basato
dunque su un PRNG) mostrato in Fig.3.1.
Il Bitmap Generator si avvale di un TRNG il quale utilizza, come sorgente, il rumore
atmosferico.
L’algoritmo implementato, invece, genera numeri casuali, nell’intervallo [0, 1], con
l’ausilio della funzione rand() della libreria <cstdlib> del C++. La funzione rand() è
inizializzata da un seme tramite la chiamata della funzione srand().
La bitmap è caratterizzata da uno sfondo bianco e nel caso in cui venga generato un 1 allora
si va a colorare di nero un pixel all’interno della bitmap. Alla fine dell’algoritmo la bitmap
è salvata su un file “PRNG_bitmap1.bmp”. Il programma è stato compilato col MinGW
GCC ed eseguito sulla piattaforma Microsoft Windows 10 e processore AMD A8.
24
[Fig. 3.1 Codice sorgente del bitmap generator in C++]
Una volta generate, le due bitmap, sono state messe a confronto Fig. 3.2 e Fig. 3.3
25
[Fig.3.2 Bitmap generata col Bitmap Generator]
[Fig.3.3 Bitmap generata con la funzione rand() del C++]
Come si può notare dalle immagini, la bitmap generata con C++/Windows presenta una
certa correlazione tra i pixel rispetto a quella generata col Bitmap Generator. Questo
dimostra la sostanziale differenza tra le due famiglie di generatori. Ovvero, a partire da un
determinato seme, i PRNGs generano sequenze di numeri di bassa qualità e periodiche a
differenza dei TRNGs.
Inoltre cambiando il seme, ad es. srand(9), la bitmap generata sarà del tutto simile a quella
in Fig.3.3 e la correlazione tra i pixel persiste.
E` interessante notare che questo algoritmo genera una grande sequenza di numeri in
pochissimo tempo (ovviamente la velocità di esecuzione varia sulla base di molti fattori). Nello
specifico sono stati generati 262144 numeri in 0.043 s.
Sulla base di tutte le osservazioni fatte si deduce allora che i PRNGs sono:
Efficienti, perché riescono a produrre moltissimi numeri in tempi ridotti
Deterministici, perché se si conosce lo stato iniziale, una certa sequenza di numeri
può essere riprodotta in un secondo momento
Periodici, perché le sequenze generate potrebbero ripetersi nel tempo. Anche se
attualmente, con i moderni generatori, sono stati raggiunti periodi talmente lunghi
che possono essere considerati aperiodici in diversi scenari applicativi.
26
D’altro canto, i TRNGs sono:
Inefficienti, perché, paragonati ai PRNGs, necessitano di molto più tempo per
produrre sequenze di numeri casuali
Non deterministici, perché una certa sequenza di numeri non può essere riprodotta
Aperiodici
Queste caratteristiche sono riassunte nella tabella in Fig.3.4
[Fig. 3.4 Confronto tra PRNGs e TRNGs]
27
Capitolo 4: Conclusioni
A questo punto è lecito porsi la seguente domanda: quale generatore, tra tutti quelli
osservati, è il migliore?
Ancora una volta la risposta a questa domanda è: dipende.
La scelta di utilizzare uno specifico RNG consegue dal tipo di scenario applicativo e dai
requisiti che bisogna soddisfare. Non è possibile, dunque, dire che una soluzione è migliore
rispetto ad un’altra.
Si può solamente dire che, a partire dai requisiti di progetto che bisogna soddisfare, una
soluzione potrebbe essere più adatta rispetto ad un’altra.
Quindi, avendo analizzato gli aspetti più significativi delle due famiglie di generatori è
possibile affermare che:
I PRNGs sono adatti in tutte quelle applicazioni che richiedono, in tempi ridotti, grandi
sequenze di numeri e una certa periodicità come ne caso della generazione di sequenze di
spreading nelle tecniche spread spectrum come, ad esempio, frequency hopping.
I TRNGs sono utili in tutte le applicazioni che richiedono una certa qualità di sequenze
generate. Sono utilizzati in particolar modo nel campo della crittografia in quanto la
robustezza dei sistemi crittografici è determinata dalla loro capacità di generare, tramite un
RNG, una keystream non predicibile e non riproducibile.
I TRNGs sono però difficili da progettare, da integrare e sono costosi. Per questi motivi, in
ambito crittografico sono stati proposti i così detti CSPRNGs i quali, nonostante siano
classificati come PRNGs, soddisfano i requisiti di sicurezza.
28
Soluzioni alternative ed innovative sono rappresentate dagli Hybrid Random Number
Generator – HRNG in Fig. 4.0. Questa soluzione è osservata con grande interesse dagli
studiosi in quanto potrebbe risolvere numerosi problemi in termini di qualità di sequenze e
velocità di generazione.
[Fig. 4.0 Implementazione più popolare di un Hybrid RNG]
Infatti si cerca di combinare i TRNGs con i PRNGs tra di loro: si genera un seme con un
TRNG, questo seme va ad inizializzare un PRNG in modo da avere un generatore che
produce sequenze puramente casuali (grazie al rinnovo periodico del seme col TRNG)
generate in modo estremamente rapido (grazie all’algoritmo efficiente del PRNG).
29
Bibliografia
[1] Craig S. Petrie and J. Alvin Connelly, A Noise-Based IC Random Number Generator for
Applications in Cryptography, IEEE Transactions on Circuits and Systems — I:
Fundamental Theory and Applications, VOL. 47, NO. 5, 05/2000
[2] Benjamin Jun and Paul Kocher, The Intel ® Random Number Generator, Cryptography
Research, Inc. White Paper Prepared For Intel Corporation, 22/04/1999
[3] V. Kote, V. Molata, J. Jakovenko1, Improved Structure of True Random Number Generator
with Direct Amplification of Analog Noise, 2012
[4] G. Bucci and R. Luzzi, "Design of Testable Random Bit Generators," in Cryptographic
Hardware and Embedded Systems – CHES 2005, 7th International Workshop, Edinburgh,
Scotland, August 29 – September 1, 2005, Proceedings, ser. Lecture Notes in Computer
Science, J. R. Rao and B. Sunar, Eds., vol. 3659. pp. 147 – 156, Springer, 2005.
[5] Dries Schellekens, Bart Preneel, and Ingrid Verbauwhede, FPGA Vendor Agnostic True
Random Number Generator
[6] Hamid Nejati, Ahmad Beirami, and Warsame H. Ali, Discrete-Time Chaotic-Map Truly
Random Number Generators: Design, Implementation, and Variability Analysis of the
Zigzag Map, 5/06/2012
[7] Wikipedia, https://it.wikipedia.org/wiki/Generatore_lineare_congruenziale, 07/04/2016
[8] Srinivas Aluru1, Lagged Fibonacci Random Number Generators for Distributed Memory
Parallel Computers, Journal of Parallel and Distributed Computing 45, 1–12-1997 article
no. PC971363
[9] Wikipedia, https://en.wikipedia.org/wiki/Mersenne_Twister, 08/04/2016
30
[10]
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/eindex.html , 19/04/2016
[11]
Thomas W. Cusick, Properties of the x2 mod N Pseudorandom Number Generator,
IEEE Transaction on Information Theory, vol. 41, no. 4, July 1995
[12]
Wikipedia, https://it.wikipedia.org/wiki/Fortuna_(PRNG), 09/04/2016
[13]
Robert McEvoyt, James Curran, Paul Cotter, and Colin Murphyt, Fortuna:
Cryptographically Secure Pseudo-Random Numnber Generation In Software And
Hardware, 28/06/2006
[14]
https://www.random.org/ , 21/04/2016
[15]
N. M. Thamrin1, G. Witjaksono , A. Nuruddin , M. S. Abdullah, An Enhanced
Hardware-based Hybrid Random Number Generator for Cryptosystem
31
