gratifiant > comp.os.* > comp.os.linux.debats

Sylvain (08/03/2019, 19h10)
Bonjour,

J'utilise /dev/random (et non urandom) pour créer des mots de passe sous
Débian.

J'ai lu que /dev/random exploite l'entropie de l'ordinateur pour la
génération de nombres "pseudo" aléatoires. Mais il n'est pas précisé de
quelles sources d'entropie il s'agit. Parmi ces sources, j'ai compris
qu'il y a les mouvements de la souris et les écritures disques. En
l'absence d'entropie, random ne génère plus de chiffre et bloque le
logiciel. Il suffit alors de bouger la souris pour faire avancer la
génération.

J'aimerais connaître les autres sources d'entropie afin d'éviter que mon
logiciel bloque de temps à autre en attendant que cette entropie soit
suffisante pour générer de nouveaux chiffres. Mon idée est de créer un
fork afin de générer l'entropie attendue par le générateur sans avoir à
bouger la souris.

Merci,
Sylvain
Nicolas George (08/03/2019, 19h49)
Sylvain , dans le message <5c82a206$0$5622$426a74cc>, a
écrit :
> J'aimerais connaître les autres sources d'entropie afin d'éviter que mon


Non portable.

> logiciel bloque de temps à autre en attendant que cette entropie soit
> suffisante pour générer de nouveaux chiffres.


Utilise /dev/urandom. Les cas où on doit utiliser /dev/random sont très
rares et d'usage spécialisé.

> Mon idée est de créer un
> fork afin de générer l'entropie attendue par le générateur sans avoir à
> bouger la souris.


Ça, ça ne peut fondamentalement pas marcher.
Sylvain (08/03/2019, 21h01)
Le 08/03/2019 à 18:49, Nicolas George a écrit :
> Sylvain , dans le message <5c82a206$0$5622$426a74cc>, a
> écrit :
>> J'aimerais connaître les autres sources d'entropie afin d'éviter que mon

> Non portable.


Je sais, mais c'est pour une utilisation personnelle. Mon but n'est pas
la portabilité.

>> logiciel bloque de temps à autre en attendant que cette entropie soit
>> suffisante pour générer de nouveaux chiffres.

> Utilise /dev/urandom. Les cas où on doit utiliser /dev/random sont très
> rares et d'usage spécialisé.


J'ai lu ici et là que /dev/urandom est moins robuste. Je suis sans doute
un peu parano, mais je préfère attendre un peu et avoir un mot de passe
solide.

>> Mon idée est de créer un fork afin de générer l'entropie attendue par le générateur sans avoir à
>> bouger la souris.

> Ça, ça ne peut fondamentalement pas marcher.


Bon, tant pis. Je continuerai à bouger ma souris... :)

Merci pour votre réponse,
Sylvain
Nicolas George (08/03/2019, 22h52)
Sylvain , dans le message <5c82bc1f$0$21589$426a74cc>, a
écrit :
> J'ai lu ici et là que /dev/urandom est moins robuste.


Eh bien jette « ici » et « là » à la poubelle, ils donnent des
informations mal comprises.

Tu peux au contraire t'appuyer sur cette question :



Je connais l'auteur de la meilleure réponse, il sait très bien de quoi
il parle.
Lulu (08/03/2019, 23h25)
Le 08-03-2019, Sylvain <ssecherre> a écrit :

> J'utilise /dev/random (et non urandom) pour créer des mots de passe
> sous Débian.


Il n'y a jamais d'accent sur le 'e' de Debra Lynn
Sylvain (09/03/2019, 11h39)
Le 08/03/2019 à 22:25, Lulu a écrit :
> Le 08-03-2019, Sylvain <ssecherre> a écrit :
>> J'utilise /dev/random (et non urandom) pour créer des mots de passe
>> sous Débian.

> Il n'y a jamais d'accent sur le 'e' de Debra Lynn

Bien vu, cela m'échappe parfois. Mais on sait de quoi on parle.
Sylvain (09/03/2019, 11h46)
Le 08/03/2019 à 21:52, Nicolas George a écrit :
[..]
>
> Je connais l'auteur de la meilleure réponse, il sait très bien de quoi
> il parle.


Merci et bien vue, je me tourne vers urandom.

Sylvain
Yliur (09/03/2019, 13h41)
Le Fri, 08 Mar 2019 18:10:17 +0100, Sylvain a écrit :

> générer l'entropie attendue par le générateur sans avoir à
> bouger la souris.


L'entropie c'est du désordre, du "hasard". À moins qu'il y ait un
dispositif particulier générant des nombres totalement imprédictibles
dans ton ordinateur (il se peut que ça existe, mais pas sur les machines
habituelles), il faut que quelque chose de perceptible par le système
d'exploitation se produise et qui soit considéré comme assez aléatoire
pour servir de source. Ta machine qui ne fait (presque) rien pendant que
tu attends que l'entropie apparaisse, c'est une mauvaise combinaison.
Sylvain (09/03/2019, 16h35)
Le 09/03/2019 à 12:41, Yliur a écrit :
> Le Fri, 08 Mar 2019 18:10:17 +0100, Sylvain a écrit :
> L'entropie c'est du désordre, du "hasard". À moins qu'il y ait un
> dispositif particulier générant des nombres totalement imprédictibles
> dans ton ordinateur (il se peut que ça existe, mais pas sur les machines
> habituelles), il faut que quelque chose de perceptible par le système
> d'exploitation se produise et qui soit considéré comme assez aléatoire
> pour servir de source. Ta machine qui ne fait (presque) rien pendant que
> tu attends que l'entropie apparaisse, c'est une mauvaise combinaison.


Mon idée était de lancer un processus en parallèle de la génération
aléatoire afin de créer cette entropie : copier un gros fichier (c'est
lent mais ça marche), accéder au réseau, voir une autre action que
/dev/random utilise comme source d'entropie. Raison pour laquelle
j'aurais aimé connaître ces sources utilisées par /dev/random.
Eric Masson (09/03/2019, 17h51)
Yliur <yliur> writes:

'Lut,

> L'entropie c'est du désordre, du "hasard". À moins qu'il y ait un
> dispositif particulier générant des nombres totalement imprédictibles
> dans ton ordinateur


Apparemment, d'autres se sont posés la question et y ont répondu :

Slides d'une présentation donnée par l'auteur
zeLittle (09/03/2019, 19h27)
"Eric Masson" a écrit dans le message de groupe de discussion :
514dlf-cmh2.ln1...

>> L'entropie c'est du désordre, du "hasard". À moins qu'il y ait un
>> dispositif particulier générant des nombres totalement imprédictibles
>> dans ton ordinateur


> Apparemment, d'autres se sont posés la question et y ont répondu :
>
> Slides d'une présentation donnée par l'auteur
>


Tous ces dispositifs marchent... pour une *durée maximale donnée de
génération* de nombres considérés comme aléatoires s'il ont été tirés dans
ce temps imparti.
Que ce soit le codage d'un programme informatique utilisant un bête rand()
ou une formule mathématique beaucoup plus compliquée étant eux-même basés
sur la fonctionnement d'un processeur hardware à fréquence continue, ou que
ce soit en plus bas niveau avec de les circuits électroniques (où un quartz)
oscillants amplifié au final par un transistor, étant eux-même aussi basés
sur la fonctionnement d'un processeur hardware à fréquence continue.
Le truc à comprendre, c'est que ceux qui travaillent avec des simulations
nécessitant de grandes cohortes de nombres aléatoires, font tourner tous ces
générateurs différents et regardent le temps maximum où la distribution de
ces nombres (sensés rester aléatoires) reste normale.

Pourquoi? Parce que même en utilisant de la complexité pour déstructurer le
relation entre la fréquence constante originelle du générateur qui est une
variable dans la génération du nombre, il n'en reste pas moins que cette
fréquence apparaitra tôt ou tard... quand la distribution passera
manifestement d'une forme de cloche à celle d'une glace à l'italienne, ou à
autre chose.

La loterie suisse utilise un système physique complexe dont je ne me
souviens pas de tous les détails, créant grosso-modo un tir de photons
pseudo-aléatoires, sur un biface de verre diffractant le rayon (ajout d'une
complexité).
Mais au final, ils disaient qu'ils avaient réussi à atteindre le biais
originel, c'est à dire une
fréquence de résonnance (en quelque sorte) hautement cachée dans ce
mécanisme,
mais qui est apparue après un certain temps.
Néanmoins, ce temps, pour le mécanisme qu'ils ont choisi et leur activité,
leur convient.
Nicolas George (10/03/2019, 12h09)
Sylvain , dans le message <5c83cf3c$0$20307$426a74cc>, a
écrit :
> Mon idée était de lancer un processus en parallèle de la génération
> aléatoire afin de créer cette entropie


Va jusqu'au bout de ton raisonnement : comment ton processus s'y
prendrait-il pour créer cette entropie ?
Nicolas George (10/03/2019, 12h18)
"zeLittle" , dans le message <5c83f5c3$0$15166$426a74cc>, a
écrit :
> Le truc à comprendre, c'est que ceux qui travaillent avec des simulations
> nécessitant de grandes cohortes de nombres aléatoires, font tourner tous ces
> générateurs différents et regardent le temps maximum où la distribution de
> ces nombres (sensés rester aléatoires) reste normale.


Les gens qui travaillent avec des simulations ont des besoins d'aléa
beaucoup plus faciles à satisfaire que la moindre banque ou n'importe
qui travaillant dans la sécurité. Ils pourraient se contenter d'à peu
près n'importe quel PRNG rapide de qualité quasi-cryptographique. Mais
comme leur domaine d'expertise n'est pas l'informatique, ils prennent
les lanternes pour des vessies et essaient de réinventer les choses
plus près de leur domaine d'expertise.

> La loterie suisse utilise un système physique complexe dont je ne me
> souviens pas de tous les détails, créant grosso-modo un tir de photons
> pseudo-aléatoires, sur un biface de verre diffractant le rayon (ajout d'une
> complexité).


Je te fais confiance sur les faits. Mais ce choix n'a aucune pertinence
pour la sécurité, c'est uniquement du spectacle.
Sylvain (10/03/2019, 15h39)
Le 10/03/2019 à 11:09, Nicolas George a écrit :
> Sylvain , dans le message <5c83cf3c$0$20307$426a74cc>, a
> écrit :
>> Mon idée était de lancer un processus en parallèle de la génération
>> aléatoire afin de créer cette entropie

> Va jusqu'au bout de ton raisonnement : comment ton processus s'y
> prendrait-il pour créer cette entropie ?


Comme a priori mon premier message n'est pas passé, je reposte.

Comme /dev/random attend que l'entropie soit suffisante pour générer des
nombre, et qu'en l'absence d'entropie il bloque le programme, mon idée
est de lancer un processus en parallèle pour générer cette entropie.

Actuellement, le simple fait de bouger la souris suffit pour faire
avancer la génération, mais c'est assez lent, surtout pour des longueurs
de 256 caractères.

D'où mon post initial : qu'elles sont les sources d'entropie utilisées
par /dev/random pour sa génération de nombres ?

Pendant la génération, j'ai essayé avec succès de copier un très gros
fichier vers une clé USB et d'entretenir un flux internet grâce à la
fonction "une page au hasard" de Wikipédia. Mais c'est encore plus lent
qu'en bougeant la souris...

Sylvain
Nicolas George (10/03/2019, 16h28)
Sylvain , dans le message <5c85138d$0$20330$426a74cc>, a
écrit :
>> Va jusqu'au bout de ton raisonnement : comment ton processus s'y
>> prendrait-il pour créer cette entropie ?


> Comme /dev/random attend que l'entropie soit suffisante pour générer des
> nombre, et qu'en l'absence d'entropie il bloque le programme, mon idée
> est de lancer un processus en parallèle pour générer cette entropie.


Et je te re-pose la question : comment ton processus ferait-il pour générer
cette entropie, en pratique.

Je peux la formuler encore plus précisément : imagine que tu aies une
fonction :

int give_entropy_to_kernel(char *data, size_t size);

Ton processus l'appelle avec des données aléatoires dans data. Ma question
est : où vas-tu chercher ces données aléatoires ?

Discussions similaires