Provided by: manpages-it_4.23.1-1_all bug

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.

       Quando la fonte di entropia è vuota, le letture di /dev/random vengono bloccate finché non
       viene  raccolto  abbastanza  rumore ambientale. Da Linux 5.6 il flag O_NONBLOCK è ignorato
       poiché /dev/random non si blocca più eccetto durante la  fase  iniziale  del  processo  di
       avvio.  Nelle  versioni  precedenti,  se  open(2)  è  chiamato  su  /dev/random  col  flag
       O_NONBLOCK, una successiva lettura di read(2) non verrà bloccata  se  il  numero  di  byte
       richiesti  non è disponibile. Vengono invece restituiti i byte disponibili. Se nessun byte
       è disponibile, read(2) restituirà -1 e errno verrà impostato a 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) su  /dev/urandom  restituirà  al  massimo  32 MB.  Una
       chiamata  read(2) su /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 Linux 2.3.16) forniscono
       informazioni aggiuntive sul dispositivo /dev/random:

       entropy_avail
              Questo file di sola lettura fornisce l'entropia disponibile, in bit. Questo sarà un
              numero nell'intervallo da 0 a 4096.

       poolsize
              Questo  file 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 e successivo:
                     Questo  file  è  di  sola  lettura,  e  indica  la dimensione della fonte di
                     entropia in bit. Contiene il valore 4096.

       read_wakeup_threshold
              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.

       write_wakeup_threshold
              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.

       uuid e boot_id
              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.

       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

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>,
       Marco Curreli <marcocurreli@tiscali.it> e Giuseppe Sacco <eppesuig@debian.org>

       Questa  traduzione è documentazione libera; leggere la GNU General Public License Versione
       3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ 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⟩.