random(4)

NOM
random, urandom — Périphériques générateurs de nombres aléatoires du noyau

SYNOPSIS
#include <linux/random.h>

int ioctl(fd, RNDrequête, param);

DESCRIPTION
Les fichiers spéciaux en mode caractère /dev/random et /dev/urandom (existants depuis Linux 1.3.30) fournissent une interface pour le générateur de nombres aléatoires du noyau. Le fichier /dev/random a un numéro de périphérique majeur égal à 1 et un numéro mineur égal à 8. Le fichier /dev/urandom a un numéro de périphérique majeur égal à 1 et à 9 pour le périphérique mineur.

Le générateur de nombres aléatoires regroupe du bruit provenant de son environnement par l'intermédiaire des pilotes de périphériques et d'autres sources, et le stocke dans un réservoir d'entropie. Le générateur mémorise également une estimation du nombre de bits de bruit dans son réservoir d'entropie et utilise son contenu pour créer des nombres aléatoires.

Les noyaux Linux 3.17 et postérieurs fournissent une interface getrandom(2) plus sûre et plus simple qui ne requiert aucun fichier spécial. Consulter le manuel de getrandom(2) pour plus de détails.

Lors de sa lecture, le périphérique /dev/urandom renvoie des octets aléatoires en utilisant un générateur de nombres pseudoaléatoires nourri à partir du réservoir d’entropie. Les lectures à partir de ce périphérique ne sont pas bloquantes (c’est-à-dire qu’un « yield » n’est pas imposé au CPU), mais peuvent entrainer un délai notable lors de requêtes d’un grand montant de données.

Lors d’une lecture au tout début du démarrage (boot), /dev/urandom peut renvoyer des données avant que le réservoir d’entropie n’ait été initialisé. Si cela à de l’importance dans votre application, utilisez plutôt getrandom(2) ou /dev/random.

Le périphérique /dev/random est une interface patrimoniale qui remonte aux temps où les primitives de chiffrement utilisées dans les implémentations de /dev/urandom n’étaient pas d’une grande fiabilité. Il renvoyait des octets aléatoires seulement pour un nombre estimé de bits de bruit récent dans le réservoir d’entropie, en bloquant si nécessaire. /dev/random est adapté pour les applications qui nécessitent une haute qualité d’imprévisibilité et qui peuvent supporter des délais indéterminés.

Si le réservoir d’entropie est vide, les lectures dans /dev/random bloqueront jusqu’à ce que du bruit environnemental supplémentaire soit accumulé. Depuis Linux 5.6, le drapeau O_NONBLOCK est ignoré car /dev/random ne bloquera pas sauf pendant le tout début du démarrage. Dans les versions précédentes, si open(2) est appelé pour /dev/random avec le drapeau O_NONBLOCK, un appel ultérieur à read(2) ne bloquera pas si le nombre requis d’octets n’est pas disponible. À la place, les octets disponibles sont renvoyés. Si aucun octet n’est disponible, read(2) renverra -1 et errno sera défini à EAGAIN.

Le drapeau O_NONBLOCK n’a aucun effet lors de l’ouverture de /dev/urandom. Lors de l’appel read(2) pour le périphérique /dev/urandom, des lectures jusqu’à 256 octets renverront autant d'octets que nécessaires et ne seront pas interrompues par un gestionnaire de signal. Les lectures avec un tampon dépassant cette limite peuvent renvoyer un nombre d’octets insuffisant ou échouer avec l’erreur EINTR si elles sont interrompues par un gestionnaire de signal.

Depuis Linux 3.16, un appel read(2) pour /dev/urandom renverra au plus 32 Mo. Un appel read(2) pour /dev/random renverra au plus 512 octets (340 octets avant Linux 2.6.12).

Écrire dans /dev/random ou /dev/urandom mettra à jour le réservoir d'entropie avec les données écrites, mais n'augmentera pas le décompte d'entropie. Cela signifie que le contenu lu des deux fichiers sera affecté, mais que cela ne rendra pas les lectures de /dev/random plus rapides.

  Utilisation
Le périphérique /dev/random est une interface patrimoniale et /dev/urandom est préféré et suffisant dans tous les cas d’utilisation à l’exception des applications qui requièrent des données aléatoires au tout début du démarrage. Pour celles-ci, getrandom(2) doit être utilisé à la place, car il créera un blocage jusqu’à ce que le réservoir d’entropie soit initialisé.

Si un fichier d’ensemencement est sauvegardé d'un redémarrage à l'autre comme recommandé ci-dessous (toutes les distributions majeures de Linux font cela depuis au moins l'an 2000), la sortie est chiffrée de manière sûre vis-à-vis d'attaquants sans accès local comme superutilisateur, à la condition que ce fichier soit rechargé lors du démarrage et parfaitement adapté pour les clés de chiffrement de sessions réseau. Comme la lecture depuis /dev/random peut être bloquante, les utilisateurs l'ouvrent généralement dans un mode non bloquant (ou en effectuant la lecture avec un délai d'expiration) et fournissent un système de notification lorsque l'entropie demandée n'est pas immédiatement disponible.

  Configuration
Si votre système ne dispose pas des fichiers /dev/random et /dev/urandom, vous pouvez les créer avec les commandes suivantes :

    mknod -m 666 /dev/random c 1 8
    mknod -m 666 /dev/urandom c 1 9
    chown root:root /dev/random /dev/urandom

Lorsqu'un système Linux démarre sans trop d’interaction avec un opérateur, le réservoir d'entropie peut se trouver dans un état relativement prévisible. Cela réduit la quantité réelle de bruit dans le réservoir d'entropie en dessous de la quantité nécessaire estimée. Afin de contrer cet effet, il est utile de sauvegarder les informations du réservoir d'entropie lors des arrêts et redémarrages du système. Pour réaliser cela, ajoutez les lignes suivantes dans le script de démarrage approprié exécuté lors de la séquence de démarrage du système Linux :

    echo "Initialisation du générateur de nombres aléatoires..."
    random_seed=/var/run/random-seed
    # Transmission d’une graine aléatoire de démarrage en démarrage
    # Chargement puis sauvegarde de tout le réservoir d’entropie.
    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

Également, ajoutez les lignes suivantes dans le script approprié exécuté lors de l’extinction du système Linux.

    # Transmission d’une graine aléatoire de démarrage en démarrage
    # Sauvegarde du réservoir d'entropie en entier
    echo "Sauvegarde de la graine aléatoire..."
    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

Dans les exemples ci-dessus, il est assumé que Linux 2.6.0, ou versions suivantes, est utilisé, où /proc/sys/kernel/random/poolsize renvoie la taille du réservoir d’entropie en bits (voir ci-dessous).

  /proc interfaces
Les fichiers du répertoire /proc/sys/kernel/random (présent depuis Linux 2.3.16) fournissent des informations supplémentaires à propos du périphérique /dev/random.

entropy_avail
    Ce fichier en lecture seule donne l'entropie disponible, en bits. Ce sera un nombre dans l’intervalle 0−4096.

poolsize
    Ce fichier donne la taille de la réserve d'entropie. Sa sémantique varie selon les versions du noyau :

    Linux 2.4 :
        Ce fichier donne la taille de la réserve d'entropie en octets. Normalement, elle sera de 512 (octets), mais le fichier est éditable et peut être modifié à n'importe quelle valeur pour laquelle un algorithme est disponible. Actuellement, les choix sont 32, 64, 128, 256, 512, 1024 ou 2048.

    Linux 2.6 et suivants :
        Ce fichier est en lecture seule et donne la taille de la réserve d'entropie en bits. Il contient la valeur 4096.

read_wakeup_threshold
    Ce fichier fournit le nombre de bits d’entropie requis pour réveiller les processus endormis en attente d’entropie de /dev/random. La valeur par défaut est 64.

write_wakeup_threshold
    Ce fichier fournit le nombre de bits d'entropie en dessous duquel on réveillera les processus ayant effectué un appel à select(2) ou poll(2) pour un accès en écriture à /dev/random. Ces valeurs peuvent être modifiées en écrivant dans les fichiers.

uuid
boot_id
    Ces fichiers en lecture seule fournissent des chaînes aléatoires comme 6fd5a44b-35f4-4ad4-a9b9-6b9be13e1fe9. Le premier est régénéré à chaque lecture, le dernier est généré une seule fois.

  Interface ioctl(2)
Les requêtes ioctl(2) suivantes sont définies sur les descripteurs de fichier connectés à /dev/random ou /dev/urandom. Toutes les requêtes réalisées interagiront avec l'entrée du réservoir d'entropie et auront un effet sur /dev/random et /dev/urandom. La capacité CAP_SYS_ADMIN est nécessaire pour toutes les requêtes sauf RNDGETENTCNT.

RNDGETENTCNT
    Récupérer le décompte d'entropie du réservoir d'entrée, le contenu sera le même que celui du fichier entropy_avail sous proc. Le résultat sera stocké dans l'entier pointé par l'argument.

RNDADDTOENTCNT
    Augmenter ou diminuer le décompte d'entropie du réservoir d'entrée de la valeur pointée par l'argument.

RNDGETPOOL
    Supprimée dans Linux 2.6.9.

RNDADDENTROPY
    Ajouter de l'entropie supplémentaire au réservoir d’entrée en augmentant le décompte d'entropie. Cela diffère de l'écriture dans /dev/random ou /dev/urandom qui ajoute des données mais sans augmenter le décompte d'entropie. La structure suivante est utilisée :

        struct rand_pool_info {
            int    entropy_count;
            int    buf_size;
            __u32  buf[0];
        };

    Ici, entropy_count est la valeur ajoutée au (ou soustraite du) décompte d'entropie, et buf est le tampon de taille buf_size qui est ajouté au réservoir d'entropie.

RNDZAPENTCNT
RNDCLEARPOOL
    Vider les décomptes d'entropie de tous les réservoirs et ajouter des données système (comme le temps réel) aux réservoirs.

FICHIERS
/dev/random
/dev/urandom

NOTES
Pour un aperçu et une comparaison des interfaces utilisables pour produire de l'aléatoire, voir random(7).

BOGUES
Lors du tout début du démarrage (boot), des lectures dans /dev/urandom peuvent renvoyer des données avant que le réservoir d’entropie n’ait été initialisé.

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

RFC 1750, « Randomness Recommendations for Security »

TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Cédric Boutillier <cedric.boutillier@gmail.com>, Frédéric Hantrais <fhantrais@gmail.com> et Jean-Paul Guillonneau <guillonneau.jeanpaul@free.fr>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 (https://www.gnu.org/licenses/gpl-3.0.html) concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à debian-l10n-french@lists.debian.org.