Provided by: manpages-it_3.73-2_all 
NOME
random, urandom - dispositivi kernel che producono numeri casuali
SINTASSI
#include <linux/random.h>
int ioctl(fd, RNDrequest, param);
DESCRIZIONE
I file speciali a caratteri /dev/random e /dev/urandom (presenti a partire da Linux 1.3.30) forniscono
un'interfaccia al generatore del kernel di numeri casuali. Il file /dev/random ha numero primario 1 e
numero secondario 8. Il file /dev/urandom ha numero primario 1 e numero secondario 9.
Il generatore di numeri casuali raccoglie rumore di fondo dai dispositivi dei driver e da altre sorgenti
nella fonte di entropia. Il generatore mantiene anche una stima del numero di bit di rumore nella fonte
di entropia. Da questa fonte di entropia vengono creati i numeri casuali.
Quando viene letto, il dispositivo /dev/random restituisce solo un numero di byte casuali compatibili con
la stima dei bit di rumore nella fonte di entropia. /dev/random dovrebbe essere adatto ad usi che
richiedono un alto grado di casualità, come la cifratura "one-time pad" e la generazione di chiavi.
Quando la fonte di entropia è vuota, le letture di /dev/random vengono bloccate finché non viene raccolto
abbastanza rumore ambientale.
La lettura del dispositivo /dev/urandom non bloccherà l'attesa di ulteriore entropia. Di conseguenza, se
non c'è abbastanza entropia nella fonte di entropia, i valori restituiti sono teoricamente vulnerabili ad
un attacco crittografico sull'algoritmo usato dal driver. Nella letteratura attualmente non classificata
non c'è prova di un metodo per fare ciò, ma è in teoria possibile che un attacco del genere possa
esistere. Se questo è fonte di problemi per la propria applicazione, si usi invece /dev/random.
La scrittura su /dev/random o /dev/urandom aggiorna la fonte d'entropia con i dati scritti, ma ciò non si
tradurrà in un numero di entropia più alto. Ciò vuo dire che esso influirà sui contenuti letti da
entrambi i file, ma non farà letture da /dev/random più velocemente.
Uso
Se non si è sicuri di quale programma usare, /dev/random o /dev/urandom, probabilmente la scelta migliore
è l'ultimo. Come regola generale, si dovrebbe usare per tutto /dev/urandom, fatta eccezione per chiavi
GPG/SSL/SSH esistenti da molto tempo.
Se si salva un file seed ai riavvii, come si raccomanda più avanti (tutte le più importanti distribuzioni
Linux lo fanno almeno dal 2000), l'output sarà crittograficamente al sicuro dagli attaccanti senza
accesso di root in locale dato che viene ricaricato nella sequenza di boot, e sarà perfettamente adeguato
alle chiavi criptate per le sessioni di rete. Dato che le letture da /dev/random possono bloccarsi, gli
utenti solitamente vorranno aprirlo in modo non bloccante (o eseguire una lettura senza timeout), e
fornire un qualche tipo di notifica se l'entropia desiderata non è immediatamente disponibile.
Il generatore di numeri casuali del kernel è stato sviluppato per produrre un piccolo quantitativo di
materiale di seed di alta qualità, necessario a creare un generatore di numeri pseudo-casuali
crittografico (CPRNG). È stato creato per essere sicuro, non per essere veloce, e non è adatto a generare
grandi quantità di dati casuali. Gli utenti dovrebbero creare una piccola quantità di materiale di seed
da leggere da /dev/urandom (e /dev/random): leggere grandi quantitativi di dati da questi dispositivi
avrà un impatto negativo sugli altri utenti dei dispositivi.
La quantità di materiale di seed richiesto per generare una chiave crittografica è uguale alla dimensione
reale della chiave. Per esempio, una chiave privata RSA a 3072 bit o una Diffie-Hellmann ha una
dimensione effettiva di 128 bit (e richiede circa 2^128 operazioni per essere forzata), quindi un
generatore di chiavi avrà bisogno solo di 128 bit (16 byte) di materiale di seed da /dev/random.
Benché sia ragionevole avere margini di sicurezza superiori a questo minimo come protezione contro le
imperfezioni dell'algoritmo CPRNG, nessuna delle primitive crittografiche oggi esistente può garantire
più di 256 bit di sicurezza; quindi se un programma legge più di 256 bit (32 byte) dalla fonte di
casualità del kernel per ogni chiamata, o per ogni intervallo ragionevole di seed (non meno di un
minuto), vuol dire che la crittografia di quel programma non è stata abilmente implementata.
Configurazione
Se il sistema non comprende già /dev/random né /dev/urandom, li si può creare coi seguenti comandi:
mknod -m 644 /dev/random c 1 8
mknod -m 644 /dev/urandom c 1 9
chown root:root /dev/random /dev/urandom
Quando un sistema Linux viene avviato senza molta interazione da parte di un utente, la fonte di entropia
potrebbe essere in una condizione tutto sommato prevedibile. Questo porta a sovrastimare la quantità di
rumore realmente presente nella fonte di entropia. Per contrastare questo effetto, può aiutare riportare
le informazioni nella fonte di entropia fra un arresto e un riavvio. Per farlo, si aggiungano le righe
seguenti ad uno script appropriato che venga eseguito durante le procedure di avvio di un sistema Linux:
echo "Inizializzazione del generatore di numeri casuali..."
random_seed=/var/run/random-seed
# Porta il seme casuale da un avvio al successivo
# Carica e successivamente salva l'intera fonte di entropia
if [ -f $random_seed ]; then
cat $random_seed >/dev/urandom
else
touch $random_seed
fi
chmod 600 $random_seed
poolfile=/proc/sys/kernel/random/poolsize
[ -r $poolfile ] && bytes=`cat $poolfile` || bytes=512
dd if=/dev/urandom of=$random_seed count=1 bs=$bytes
Inoltre, si aggiungano le righe seguenti ad uno script appropriato da eseguire durante le procedure di
arresto di un sistema Linux:
# Riporta un seme casuale dall'arresto al riavvio.
# Salva l'intera fonte di entropia
echo "Salvataggio del seme casuale..."
random_seed=/var/run/random-seed
touch $random_seed
chmod 600 $random_seed
poolfile=/proc/sys/kernel/random/poolsize
[ -r $poolfile ] && bytes=`cat $poolfile` || bytes=512
dd if=/dev/urandom of=$random_seed count=1 bs=$bytes
Interfaccia /proc
I file nella directory /proc/sys/kernel/random (presente da 2.3.16) forniscono un'interfaccia aggiuntiva
al dispositivo /dev/random.
Il file in sola lettura entropy_avail fornisce l'entropia disponibile. Normalmente questo sarà 4096
(bit), una fonte di entropia piena.
Il file poolsize fornisce la dimensione della fonte di entropia. La semantica di questo file è diversa a
seconda della versione del kernel:
Linux 2.4: Questo file indica la dimensione della fonte di entropia in byte. Normalmente questo
file ha valore 512, ma è scrivibile e può essere cambiato in qualunque valore per il
quale sia disponibile un algoritmo. Le scelte sono: 32, 64, 128, 256, 512, 1024 o
2048.
Linux 2.6: Questo file è di sola lettura, e indica la dimensione della fonte di entropia in bit.
Contiene il valore 4096.
Il file read_wakeup_threshold contiene il numero di bit di entropia richiesti per svegliare i processi
che dormono in attesa dell'entropia da /dev/random. Il valore predefinito è 64. Il file
write_wakeup_threshold contiene il numero di bit di entropia sotto i quali vengono svegliati i processi
che eseguono un select() o poll() per accedere in scrittura a /dev/random. Questi valori possono venire
cambiati scrivendo sui file.
I file in sola lettura uuid e boot_id contengono stringhe casuali come
6fd5a44b-35f4-4ad4-a9b9-6b9be13e1fe9. Il più vecchio è generato di nuovo a ciascuna lettura, l'ultimo
viene generato una volta.
Interfaccia ioctl(2)
Le seguenti richieste ioctl(2) sono definite su descrittori di file connessi o a /dev/random o a
/dev/urandom. Tutte le richieste effettuate interagiscono con la fonte di entropia di input incidendo sia
su /dev/random che su /dev/urandom. La capacità CAP_SYS_ADMIN è necessaria per tutte le richieste eccetto
che per RNDGETENTCNT.
RNDGETENTCNT
Recupera il conteggio di entropia della fonte di input, il contenuto sarà lo stesso del file
entropy_avail sotto proc. Il risultato verrà memorizzato nell'int indicato dall'argomento.
RNDADDTOENTCNT
Incrementa o decrementa il numero di entropia della fonte di input del valore indicato
dall'argomento.
RNDGETPOOL
Rimosso in Linux 2.6.9.
RNDADDENTROPY
Aggiunge ulterire entropia alla fonte di input, incrementando il numero di entropia. Questo
differisce dallo scrivere su /dev/random o /dev/urandom, che aggiunge solo qualche dato ma non
incrementa il numero di entropia. Viene usata la seguente struttura:
struct rand_pool_info {
int entropy_count;
int buf_size;
__u32 buf[0];
};
Dove entropy_count è il valore aggiunto (o sottratto) al numero di entropia, e buf è il buffer di
dimensione buf_size che viene aggiunto alla fonte di entropia.
RNDZAPENTCNT, RNDCLEARPOOL
Azzera il conteggio di entropia di tutte le fonti e aggiunge alcuni dati di sistema (come il
minutaggio) alle fonti.
FILE
/dev/random
/dev/urandom
VEDERE ANCHE
mknod(1)
RFC 1750, "Randomness Recommendations for Security"
COLOPHON
Questa pagina fa parte del rilascio 3.73 del progetto Linux man-pages. Una descrizione del progetto, le
istruzioni per la segnalazione degli errori, e l'ultima versione di questa pagina si trova su
http://www.kernel.org/doc/man-pages/.
La versione italiana fa parte del pacchetto man-pages-it v. 3.73, a cura di: ILDP "Italian Linux
Documentation Project" http://www.pluto.it/ildp
Per la traduzione in italiano si può fare riferimento a http://www.pluto.it/ildp/collaborare/
Segnalare eventuali errori di traduzione a ildp@pluto.it
Linux 2013-03-15 RANDOM(4)