Generateur de mots de passe

**johannesb** · 25/06/2010, 20h02

Envoyé par javatwister

le résultat de Math.random() me paraît
imprévisible

C'est vraiment rarement le cas, il faudrait pour cela que le
générateur soit cryptologiquement sûr, ce qu'on ne fait pas,
en général, vu que c'est lent. Il suffit toujours de quelques
résultats successifs de Math.random() pour pouvoir extrapoler toute
la suite. Le nombre de ces résultats dépend de l'algorithme choisi,
parfois, un seul suffit.

et que les chances de tirage d'un élément dans un ensemble
sont équivalentes pour tous les éléments...

Là encore, c'est rarement le cas. Les générateurs utilisés dans
la plupart des mises en oeuvre de Math.random sont plutôt mauvais
quant à leurs propriétés statistiques. J'en ai testé un certain
nombre à partir des sources C ou C++, je n'en ai vu aucun qui
réussisse les tests un peu exigeants comme ceux de L'Ecuyer.

puis le rapport avec javascript, alors là...

Quand même, les propriétés d'une fonction standard du langage...

--
Johannes

**javatwister** · 25/06/2010, 20h55

il y a un certain nombre d'années, j'avais testé à ma façon la qualité "aléatoire" des valeurs générées par Math.random(); sans doute pas grand rapport avec ce que tu soutiens mais je te mets le lien quand même; tu me diras si tu comprends "l'esprit" de l'expérience:
http://javatwist.imingo.net/scoumoune.php

(attention, le code est un peu buggé - vieux, moche et tout -, mais ça marche quand même)

**johannesb** · 26/06/2010, 16h50

Envoyé par javatwister

http://javatwist.imingo.net/scoumoune.php

Oui, je comprends tout à fait l'esprit, et du reste, je cherche un
test facile à comprendre et de préférence un peu ludique qui ferait
bien ressortir les défauts de certaines versions de Math.random -
si quelqu'un avait une idée, elle serait bienvenue !

Mais là, c'est juste la répartition des aléas pris individuellement
qui est testée. Il faudrait vraiment que le Math.random soit très
mauvais pour échouer.

Là où c'est beaucoup plus compliqué, c'est pour des corrélations
entre des pseudo-aléas successifs, quand on utilise les aléas par séries.
Pour prendre un exemple fictif mais plausible, il se peut que la fonction
random retourne toujours un nombre pair (divisé par 2 puissance quelque
chose) la 1025e fois qu'il est appelé, si et seulement si c'était le
cas la première fois, et que de façon générale, la parité du nième
appel soit systématiquement la même que celle du n + 1024-ième.

Pour une application ludique, c'est probablement sans importance, mais
s'il s'agit de faire des jeux d'argent ou de simuler des événements
très peu probables mais non impossibles, ça peut être catastrophique.

**javatwister** · 27/06/2010, 12h13

début de première expérience que je suis bien incapable d'interpréter mais c'est toujours ça:

==> Je génère 100 séries de 4096 random() avec 6 décimales;
==> Je compte le nombre de résultats distincts pour chaque série;
==> Je regarde le nombre de résultats identiques générés au cours des 100 séries.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>...</title>
 
<style type="text/css">
 
</style>
 
<body> 
 
 
 
 
 
<script type="text/javascript">
 
var lg, tot=[], compte=[], fin="";
 
for(j=0;j != 100;j++){// 100 générations...
	if(lg){
		tot.push(lg) // on insère à chaque passage le total de nombres sortis dans tot
	};
	lg=0;
	var tab = []
	 for(i=0;i != 4096;i++){//... de 4096 random()//
		ind=Math.random().toFixed(6)
		tab[ind]=0;
		if(i == 4095){
			for(k in tab){
				if(tab.hasOwnProperty(k)){
					lg++ // si le nombre n'est pas encore sorti
					     // on incrémente lg	
				}
			}
		}
	}
}
 
 
tot.sort(function(a,b){return a - b}) // on trie le tableau tot
 
for(i in tot){
	if(!compte[tot[i]]){
		compte[tot[i]]=1
	}
	else{
		compte[tot[i]]++ // on compte le nombre d'occurrences pour chaque nombre
	}
}
 
for(i in compte){
	fin+=i+" : "+compte[i]+"\n"
}
 
alert(fin);
 
 
</script>
 
 
<div id="zone"></div>
 
 
</body>
</html>

**johannesb** · 29/06/2010, 08h29

Envoyé par javatwister

début de première expérience que je suis bien incapable d'interpréter mais c'est toujours ça:

==> Je génère 100 séries de 4096 random() avec 6 décimales;
==> Je compte le nombre de résultats distincts pour chaque série;
==> Je regarde le nombre de résultats identiques générés au cours des 100 séries.

J'avoue que je ne comprends pas non plus ce que ça pourrait vouloir
montrer...

La plus petite valeur possible renvoyée par Math.random est 0, la
plus grande est 1 - Math.pow(2, -53) puisque la plus grande précision
possible pour un nombre en javascript est de 53 bits significatifs.

Donc, si vous appliquez toFixed(6) à Math.random(), vous pouvez
théoriquement obtenir 1 000 001 Strings différentes, de '0.000000'
à '1.000000'.

Cette dernière sera toutefois plus improbable que le million d'autres
chaînes possibles commençant par '0.' qui, elles, devraient être
équiprobables dès lors que la version de Math.random testée renvoie
au moins 20 bits significatifs - mais peut-être à l'erreur d'arrondi
près sur les derniers bits.

Au total, ça ne me semble pas une bonne idée. Plutôt qu'appliquer
toFixed, multipliez par une puissance de deux parce que ça n'entraîne
jamais d'erreur d'arrondi. Disons Math.pow(2, 20) == 1048576 si vous
voulez une valeur voisine du million. Chaque nombre résultant, de
0 à 1048575, devrait avoir exactement la même chance de sortir.

Dans le même ordre d'idées : dans les boucle for, vous testez la
condition de sortie avec une inégalité : `j != 100`, `i != 4096`.

C'est, par principe, une mauvaise idée - les nombres en javascript
sont toujours en virgule flottante ; si jamais, pour une raison
quelconque, votre indice n'était plus exactement entier,
votre boucle ne s'arrêterait pas. Utilisez plutôt `<`, comme tout le
monde... C'est vrai qu'en l'espèce, ça ne risque rien. Mais plutôt
que se poser à chaque fois la question, appliquons systématiquement
la règle prudente, un peu comme il ne faut jamais pointer une arme
à feu sur quelqu'un par jeu, même si elle n'est pas chargée.

Moyennant quoi, il ne reste plus qu'à déterminer ce que votre test
devrait donner avec une bonne fonction Math.random, et le critère
(disons, genre chi2) qui permettrait de diagnostiquer les mauvaises...
Et j'avoue que je n'en sais rien, il me faudrait un certain temps
pour y réfléchir.

C'est assez compliqué de tester les générateurs de nombres pseudo-
aléatoires, ça ne s'improvise pas... Vous pouvez, par exemple, jeter
un oeil (ou plus...) sur l'excellent résumé par Pierre L'Ecuyer et
Richard Simard ici :
http://www.iro.umontreal.ca/~lecuyer...rs/testu01.pdf

Désolé si c'est un peu décourageant, mais c'est la vérité, et
il n'y a pas de raccourcis en maths... la seule façon de comprendre,
c'est de refaire soi-même le trajet. D'ailleurs, quand on le fait,
on est d'autant plus content à l'arrivée que c'était difficile,
mais qu'on y est quand même arrivé !

**javatwister** · 29/06/2010, 09h22

Envoyé par johannesb

C'est assez compliqué de tester les générateurs de nombres pseudo-
aléatoires, ça ne s'improvise pas... Vous pouvez, par exemple, jeter
un oeil (ou plus...) sur l'excellent résumé par Pierre L'Ecuyer et
Richard Simard ici :
http://www.iro.umontreal.ca/~lecuyer...rs/testu01.pdf

Désolé si c'est un peu décourageant, mais c'est la vérité, et
il n'y a pas de raccourcis en maths...

Oui, c'est clair que je ne me plongerai jamais là-dedans!

Le vrai problème est que je n'ai pas vocation à devenir Einstein maintenant, vu mon âge avancé et que j'ai une vision de javascript disons... beaucoup moins grave que celle d'un informaticien

Pour revenir à ma ptite expérience d'amateur, ça révèle que les valeurs générées, rien qu'à 6 décimales - et désolé pour le toFixed qui est une hérésie caractérisée dans ce contexte - , sont très rarement identiques
et qu'aucune récurrence n'apparaît, quand on capte les valeurs en doublon. Moi, ça me suffit! Et tu noteras l'égocentrisme exacerbé de cette courte phrase.

Pour le test d'inégalité dans les boucles for, c'est encore plus simple, c'est une habitude que j'avais prise pour valider des pages sans extraire le code js

(I don't have a gun...)

**SpaceFrog** · 30/06/2010, 14h11

C'est pas bientôt fini par hasard

**javatwister** · 30/06/2010, 18h31

arrête, rigole pas! du coup, chuis en train de fabriquer mon premier générateur aléatoire sans Math.random()

et je merde grave sur les détails

**javatwister** · 22/12/2010, 09h58

bon, je ressors mon ptit aléaquoi: générateur de mots de passe rigolos et fort improbables;

en fait, je voulais surtout essayer de me passer de Math.random() sans entrer dans les complications...

http://javatwist.imingo.net/alea.htm

là il marche sur 3 syllabes mais c'est encore plus rigolo sur 2;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Aléaquoi?</title>
 
<style type="text/css">
 
#mess{
	font-weight:bold;
	font-size:25px;
}
 
</style>
 
 
 
<script type="text/javascript">
 
 
var tab2=[], n, lettres, bis, cosi, d, h;
 
var plus=1+new Date().getMilliseconds();
 
function random(disp){
 
 
	var dep=parseInt(String(new Date().getMilliseconds()).charAt(0))+3;
	var tab=["b","c","d","f","g","j","l","m","n","p","r","s","t","v","x","z","fr","br","tr","cl","gn","pl","qu","ch"]
	var tab1=["a","e","i","o","u","é","è","ai","au","ou","oi","en","in","an","on","er","y"];
 
	d=parseInt(new Date().getMilliseconds()+""+Math.ceil(new Date().getSeconds()/60*100)+""+Math.ceil(new Date().getMinutes()/60*100)+""+Math.ceil(new Date().getHours()/24*100));
 
 
 
	for(k=0;k<6;k++){// combien de sons?
		d+=plus;
		cosi=Math.cos(d);
		plus+=parseInt(String(d).substring(0,3));
		n=String(Math.abs(cosi));
		n= cosi >0 ? n: "0."+ n.substring(2).split("").reverse().join("");
 
 
		lettres= k%2 == 0 ? tab : tab1;
		h=Math.floor(parseFloat("0."+n.substring(dep))*lettres.length);
 
		if(dep<n.length){dep++}else{dep=3}
 
		tab2[k]=lettres[h];
		bis=lettres[h]
 
		if((" "+tab2.toString()+" ").split(lettres[h]).length==3){
			lettres.splice(h,1)
		}
	}
 
	disp.firstChild.data=tab2.join('');
 
}
 
</script>
 
</head> 
 
<body> 
 
 
<div style="text-align:center;margin-top:100px">
	<span id="mess">?</span>
	<p>
		<input type="button" style="font-size:20px;font-weight:bold;" value="random" onclick="random(document.getElementById('mess'))" /><br />
	</p>
</div>
 
</body>
</html>

Generateur de mots de passe

Contribuez

Discussions similaires

Partager

Partager