Scroll to navigation

RANDOM(4) Device Drivers Manual RANDOM(4)

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.

Linux 3.17 e successivi forniscono la più semplice e sicura interfaccia getrandom(2) che non richiede nessun file speciale; si veda la pagina di manuale di getrandom(2) per i dettagli.

Quando viene letto, il dispositivo /dev/urandom restituisce un numero di byte casuali prodotto da un generatore di numeri pseudocasuali inizializzato tramite la fonte di entropia. Le letture da questo dispositivo non sono bloccanti (cioè, la CPU non viene impegnata/risponde immediatamente), ma si può avere un ritardo apprezzabile qualora vengano richieste grandi quantità di dati.

Quando viene letto durante la fase di inizializzazione del sistema /dev/urandom può restituire dati prima che sia disponibile la fonte di entropia. Se questo è fonte di problemi per la propria applicazione, si usi invece getrandom(2) o /dev/random.

Il dispositivo /dev/random è un'interfaccia disponibile già da molto tempo, risalente a quando le primitive crittografiche usate nell'implementazione di /dev/urandom non erano generalmente ritenute sicure. Esso restituisce solo un numero di byte casuali prendendoli dal numero stimato di bit di rumore recente fornito dalla fonte di entropia, tenendo in attesa il chiamante se necessario. /dev/random è adatto ad usi che richiedono un alto grado di casualità, e può implicare ritardi indeterminati.

When the entropy pool is empty, reads from /dev/random will block until additional environmental noise is gathered. Since Linux 5.6, the O_NONBLOCK flag is ignored as /dev/random will no longer block except during early boot process. In earlier versions, if open(2) is called for /dev/random with the O_NONBLOCK flag, a subsequent read(2) will not block if the requested number of bytes is not available. Instead, the available bytes are returned. If no byte is available, read(2) will return -1 and errno will be set to EAGAIN.

Il flag O_NONBLOCK non ha nessun effetto quando si apre /dev/urandom. Quando si chiama read(2) per il dispositivo /dev/urandom, letture fino a 256 byte retituiranno tanti byte quanti ne vengono richiesti e non verranno interrotti da un gestore di segnali. Letture con un buffer oltre questo limite possono restituire un numero di byte minore di quello richiesto o fallire con l'errore EINTR, se interrotto da un gestore di segnali.

Da Linux 3.16, una chiamata read(2) da /dev/urandom restituirà al massimo 32 MB. Una chiamata read(2) da /dev/random restituirà al massimo 512 byte (340 byte sui kernel Linux antecedenti alla versione 2.6.12).

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

L'interfaccia /dev/random è considerata un'interfaccia da mantenere per compatibilità col passato, mentre /dev/urandom è preferito e sufficiente in tutti i casi d'uso, fatta eccezione per applicazioni che richiedono casualità durante la fase di inizializzazione del sistema; per queste applicazioni si deve usare invece getrandom(2), che non risponderà all'applicazione fino a quando la fonte di entropia non viene inizializzata.

Se si salva un file seed ai riavvii, come si raccomanda più avanti, 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. (Tutte le più importanti distribuzioni Linux hanno salvato il file seed ai riavvii almeno dal 2000.) 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.

Configurazione

Se il sistema non comprende già /dev/random/dev/urandom, li si può creare coi seguenti comandi:


mknod -m 666 /dev/random c 1 8
mknod -m 666 /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 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
# Carry a random seed from start-up to start-up
# Load and then save the whole entropy pool
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 ] && bits=$(cat $poolfile) || bits=4096 bytes=$(expr $bits / 8) 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 ] && bits=$(cat $poolfile) || bits=4096
bytes=$(expr $bits / 8)
dd if=/dev/urandom of=$random_seed count=1 bs=$bytes

Negli esempi visti prima, si presuppone che la versione di Linux sia la 2.6.0 o successiva, dove /proc/sys/kernel/random/poolsize restituisce la dimensione della fonte di entropia in bit (si veda più avanti).

Interfaccia /proc

I file nella directory /proc/sys/kernel/random (presente da 2.3.16) forniscono informazioni aggiuntive aldispositivo /dev/random:

Questo file di sola lettura fornisce l'entropia disponibile, in bit. Questo sarà un numero nell'intervallo da 0 a 4096.
Questo file fornisce la dimensione della fonte di entropia. La semantica di questo file è diversa a seconda della versione del kernel:
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.
Questo file è di sola lettura, e indica la dimensione della fonte di entropia in bit. Contiene il valore 4096.
Questo file 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.
Questo file contiene il numero di bit di entropia sotto i quali vengono svegliati i processi che eseguono un select(2) o poll(2) per accedere in scrittura a /dev/random. Questi valori possono venire cambiati scrivendo sui file.
Questi file di sola lettura 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.

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.
Incrementa o decrementa il numero di entropia della fonte di input del valore indicato dall'argomento.
Rimosso in Linux 2.6.9.
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.
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

NOTE

Per una panoramica e un confronto fra le varie interfacce che possono essere usate per ottenere casualità, si veda random(7).

BUG

Durante la fase di inizializzazione del sistema, le letture da /dev/urandom possono restituire dati prima che la fonte di entropia venga inizializzata.

VEDERE ANCHE

mknod(1), getrandom(2), random(7)

RFC 1750, "Randomness Recommendations for Security"

TRADUZIONE

La traduzione italiana di questa pagina di manuale è stata creata da Ottavio G. Rizzo <rizzo@pluto.linux.it>, Giulio Daprelà <giulio@pluto.it>, Elisabetta Galli <lab@kkk.it> e Marco Curreli <marcocurreli@tiscali.it>

Questa traduzione è documentazione libera; leggere la GNU General Public License Versione 3 o successiva per le condizioni di copyright. Non ci assumiamo alcuna responsabilità.

Per segnalare errori nella traduzione di questa pagina di manuale inviare un messaggio a pluto-ildp@lists.pluto.it.

9 ottobre 2022 Linux man-pages 6.01