Quel logiciel libre de génération de mots de passe ?

David MENTRE <david.mentre@gmail.com> wrote in
news:87odw08nep.fsf@gmail.com:

Je cherche un logiciel libre de génération aléatoire de mots de passe de
® bonne qualité ¯.

Ce n'est pas un logiciel, mais ça marche très bien :
<http://world.std.com/~reinhold/diceware.html>

Bon, pour générer quelques centaines de mdp, c'est un peu lent, j'en
conviens...

Cornelia

--
Be out and be proud - today is the first day of the rest of your life
Support Transgenre Strasbourg : http://www.sts67.org
BoW : http://www.bownbend.com
GPG key ID 83FF7452, 659C 2B9F 7FD5 5C25 8C30 E723 4423 F8B8 83FF 7452

Un bon commencement ... très facile à modifier.

http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/59873

Philippe




David MENTRE wrote:

Bonjour,

Je cherche un logiciel libre de génération aléatoire de mots de passe de
« bonne qualité ».

Jusqu'à maintenant j'utilisais /pwgen/ mais il y a un peu trop de
répétition à mon goût dans l'algorithme par défaut pour les mots de
passe facilement mémorisables. Il a une option « --secure » (/completely
random, hard-to-memorize paswords/) mais il n'y a pas de doc sur ce que
fait le logiciel dans ce cas.

Est-ce que quelqu'un connait un bon logiciel ou une bonne méthode pour
générer des mots de passe de qualité ? Une solution simple est peut-être
de prendre 48 ou 64 bits de /dev/random et de le passer dans un encodeur
binaire vers ASCII ?

Amicalement,
david
--
David Mentré

On Sat Jul 08 2006 at 11:18, David MENTRE wrote:

Jusqu'à maintenant j'utilisais /pwgen/ mais il y a un peu trop de
répétition à mon goût dans l'algorithme par défaut pour les mots de
passe facilement mémorisables. Il a une option « --secure » (/completely
random, hard-to-memorize paswords/) mais il n'y a pas de doc sur ce que
fait le logiciel dans ce cas.

"Use the source, Luke, be one with the code!"

L'algo ne change qu'avec l'option --sha1.
Avec --secure, c'est seulement l'entropie de l'espace de sortie qui
est modifiée par les options.
Sans --sha1, pwgen lit /dev/urandom (ou /dev/random si le premier est
inaccessible)

--
http://arboi.da.ru/ http://ma75.blogspot.com/
PGP key ID : 0x0BBABA91 - 0x1320924F0BBABA91
Fingerprint: 1048 B09B EEAF 20AA F645 2E1A 1320 924F 0BBA BA91

On Sat, 08 Jul 2006 10:56:26 +0000, Cornelia Schneider wrote:

Ce n'est pas un logiciel, mais ça marche très bien :
<http://world.std.com/~reinhold/diceware.html>

Y a un truc que je ne comprends pas, là :

"When you are done, the words that you have found are your new passphrase.
Memorize them and then either destroy the scrap of paper or keep it in a
really safe place."

Comment des utilisateurs lambda peuvent-ils mémoriser 5 ou 7 mots
différents, sans qu'il n'y ait le moindre lien logique entre ces mots ?


Nicob

Nicob <nicob@I.hate.spammers.com> wrote in
news:pan.2006.07.10.19.27.45.518917@I.hate.spammers.com:

Comment des utilisateurs lambda peuvent-ils mémoriser 5 ou 7 mots
différents, sans qu'il n'y ait le moindre lien logique entre ces mots ?

C'est expliqué : le vocabulaire dans lequel ces mots sont pris est
relativement facile à mémoriser (il existe d'ailleurs dans diférentes
langues, afin de faciliter le boulot selon la langue maternelle de la
personne). Ca marche plutôt bien chez moi. Par ailleurs, le problème est le
même avec toutes les méthodes : plus c'est facile à mémoriser, plus ce sera
aussi facile à "trouver"...

Cornelia

--
Be out and be proud - today is the first day of the rest of your life
Support Transgenre Strasbourg : http://www.sts67.org
BoW : http://www.bownbend.com
GPG key ID 83FF7452, 659C 2B9F 7FD5 5C25 8C30 E723 4423 F8B8 83FF 7452

According to David MENTRE <david.mentre@gmail.com>:

Je cherche un logiciel libre de génération aléatoire de mots de passe de
« bonne qualité ».

Yakademander :

/* =================================================================== */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

static unsigned
randval(unsigned max)
{
static int r = -1;
unsigned char x;

if (r < 0) {
r = open("/dev/urandom", O_RDONLY);
if (r < 0) {
perror("open");
exit(EXIT_FAILURE);
}
}
for (;;) {
unsigned val;

for (;;) {
if (read(r, &x, 1) <= 0) {
if (errno == EINTR)
continue;
perror("read");
exit(EXIT_FAILURE);
}
break;
}
val = (unsigned)x;
if (val >= max * (256 / max))
continue;
return val % max;
}
}

static int
randletter(void)
{
return "abcdefghijklmnopqrstuvwxyz"[randval(26)];
}

static int
randdigit(void)
{
return "0123456789"[randval(10)];
}

int
main(void)
{
printf("%c%c%c%c%c%c%c%cn",
randletter(), randletter(),
randdigit(), randdigit(),
randletter(), randletter(),
randdigit(), randdigit());
return EXIT_SUCCESS;
}

/* =================================================================== */


Ça tourne sous Linux ou FreeBSD, ou n'importe quel autre unixoïde qui
a un /dev/random. À chaque appel, ça génére un nouveau mot de passe de
huit caractères : deux lettres minuscules, deux chiffres, deux lettres
minuscules, deux chiffres. À l'usage, c'est assez facile à retenir.
Entropie légèrement supérieure à 32 bits ; c'est suffisant pour la
plupart des usages de mots de passe (c'est une question de protocole).

Évidemment, l'entropie n'est atteinte que si on accepte le résultat. Si
on fait tourner le programme plusieurs fois, jusqu'à obtenir un mot de
passe "facilement mémorisable", alors on bousille l'entropie.


--Thomas Pornin

Bonjour Thomas,

Quelques questions supplémentaires sur ton programme.

pornin@nerim.net (Thomas Pornin) writes:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

<string.h> n'est pas nécessaire.

#include <errno.h>

#include <sys/types.h>

<sys/types.h> n'est pas nécessaire.

#include <unistd.h>
#include <fcntl.h>

static unsigned
randval(unsigned max)
{
static int r = -1;
unsigned char x;

if (r < 0) {
r = open("/dev/urandom", O_RDONLY);

1. Tu fais exprès d'ouvrir /dev/urandom à chaque appel de randval() ?

2. J'aurais plutôt ouvert /dev/random que /dev/urandom, histoire
d'avoir de l'aléatoire garanti, même si c'est bloquant. Une raison
particulière pour /dev/urandom ?

if (r < 0) {
perror("open");
exit(EXIT_FAILURE);
}
}
for (;;) {
unsigned val;

for (;;) {
if (read(r, &x, 1) <= 0) {
if (errno == EINTR)
continue;
perror("read");
exit(EXIT_FAILURE);
}
break;
}
val = (unsigned)x;
if (val >= max * (256 / max))
continue;

3. Ce test et la boucle autour du read(), c'est pour être sur que ta
variable "val" a bien une valeur équi-répartie entre 0 et /n/ fois
"max", si bien que l'opération de modulo après n'est pas biaisée ?

return val % max;
}

4. Le descripteur "r" n'est pas fermé (close()).

}

5. Je trouve l'écriture de randval() un peu bizarre, pas « naturel »
(l'utilisation systématique de for(;;) et continue par exemple, au
lieu de do {} while( )). C'est volontaire (par exemple pour éviter
certaines erreurs ou pour augmenter la localité du code) ?

6. Pourquoi déclarer toutes les fonctions static ? Pour éviter que les
symboles fuient au-delà de ce module ?

Amicalement,
david
--
David Mentré

Bonjour,

Je cherche un logiciel libre de génération aléatoire de mots de passe de
« bonne qualité ».

Jusqu'à maintenant j'utilisais /pwgen/ mais il y a un peu trop de
répétition à mon goût dans l'algorithme par défaut pour les mots de
passe facilement mémorisables. Il a une option « --secure » (/completely
random, hard-to-memorize paswords/) mais il n'y a pas de doc sur ce que
fait le logiciel dans ce cas.

Est-ce que quelqu'un connait un bon logiciel ou une bonne méthode pour
générer des mots de passe de qualité ? Une solution simple est peut-être
de prendre 48 ou 64 bits de /dev/random et de le passer dans un encodeur
binaire vers ASCII ?

bonjour

je connait bien un tres tres bon generateur
http://remyaumeunier.chez-alice.fr/

javac psw
java psw 11 3 100 50 10

y1m0zw9cagc
j61a79niyw1
ysmdikvau68
pp5uv178rlt
s914pewukqw
7fldkf1qnv8
5q55k1wu7l9
nupktz1zapj
rpqho1zh0bz
sziu8fvj5g1
rw0wcq6ymjl


par exemple


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

public class psw
{ static int tab[]={0,0,0,0,0,0,0,0};
static int index=0;
static FileOutputStream file;
static int n0=2;
static int n1=2;
static int ecart;
static int qt=0;
static int nb=0;
static boolean b=true;
static String psw=new String();

public static void main(String args[])
{
if(args.length!=5)
{
System.out.println(" java gene cle_n0 cle_n1 cle_n2 qtDeNb " );
System.out.println(" cle_n0 = nb premier ");
System.out.println(" cle_n1 = nb premier ");
System.out.println(" cle_n2 = nb de bit max des nb premier ");
System.out.println(" cle_n3 = puissance max de l'ecart entre deux nb
premier ");
System.out.println(" qtDeNb =nombre de psw de 10 lettre ");
System.out.println(" ex :java gene 3623 24443 100 50 1000 ");
return;
}
BigInteger p=new BigInteger(args[0]);
if(! p.isProbablePrime(100))
{
System.out.println(p+ "cle_n0 n'est pas un nb premier"); return;
}
BigInteger p1=new BigInteger(args[1]);
if(! p1.isProbablePrime(100))
{
System.out.println(p+ "cle_n1 n'est pas un nb premier"); return;
}

int taille=Integer.parseInt(args[2]);
ecart=Integer.parseInt(args[3]);
qt=Integer.parseInt(args[4]);

try {file=new FileOutputStream ("sortie08.bin");
} catch (FileNotFoundException e){
System.out.println(e);
}

p=newGraine(p,taille);


p1=newGraine(p1,(int)taille/2);

System.out.println("debut ");
alea(p,p1);
}
public static BigInteger newGraine(BigInteger p,int taille )
{
System.out.println("init ");
BigInteger pow=new BigInteger("2");
int n =p.toString(2).length();
pow=pow.pow(n);
while (p.toString(2).length()<taille)
{
p=p.add(pow);

if(p.isProbablePrime(100))
{
System.out.print(".");
n=p.toString(2).length();
pow=new BigInteger("2");
pow=pow.pow(n);
}

}
System.out.println();
return p;
}
public static BigInteger newP(BigInteger p,int puissance)
{
BigInteger pow=new BigInteger("2");
pow=pow.pow(puissance);
boolean test=true;
while (test)
{
p=p.add(pow);
if(p.isProbablePrime(100)){testúlse;}
puissance++;
}
return p;
}
public static void write(String p)
{

int val;
for (int i=0;i<p.length();i++)
{
val=Character.getNumericValue(p.charAt(i));
tab[index]=val;
index++;
if(index==8)
{
calculEntier();
index=0;

}
}


}
public static void calculEntier()
{
int val=0,p=1;

for(int i=0;i<tab.length;i++){
val=val+tab[i]*p;
p=p*2;
}
if((val>96)&&(val<123))
{
psw=psw+(char)val;
if(nb>qt){búlse;}
if(psw.length()>10)
{
System.out.println(psw);
psw=new String();
nb++;
}
}
if((val>47)&&(val<58))
{

psw=psw+(char)val;
if(nb>qt){búlse;}
if(psw.length()>10)
{
System.out.println(psw);
psw=new String();
nb++;
}

}


}
public static void alea(BigInteger p0,BigInteger p1)
{

while(b)
{
write((p0.mod(p1)).toString(2));
n0++;
if (n0>ecart){n0=2;}
p0=newP(p0,n0);
n1++;
if (n1>ecart){n1=2;}
p1=newP(p1,n1);
}
}

}

Amicalement,
david

--
des conneries j'en ai dites oui oui je vous assure...
mais elles n'engagent que votre perception
remy

pour de meilleur résultat

le reste sur http://remyaumeunier.chez-alice.fr/
pour l'alea et quelque resultat


public static void write(String p)
{

int val;
for (int i=5;i<p.length();i++)
{
val=Character.getNumericValue(p.charAt(i));
tab[index]=val;
index++;
if(index==8)
{
calculEntier();
index=0;

}
}


}



--
des conneries j'en ai dites oui oui je vous assure...
mais elles n'engagent que votre perception
remy

David MENTRE <david.mentre@gmail.com> writes:

Quelques questions supplémentaires sur ton programme.

J'ai modifié le programme pour le rendre plus lisible (pas sûr d'y avoir
réussi). Toute critique, même négative, est bienvenue.

http://www.linux-france.org/~dmentre/code/dev-random-pass-gen.c


Amicalement,
d.
--
David Mentré