🚀 go-pugleaf

For pronounceable passwords,                                                    
you might consider using a combination
of the MD5 (message digest) algorithm
coupled to one or more of my Moby Lexical
databases:
 
The Pronunciator database will give
you a comprehensive set of individual,
double, and longer phonemes tuples that
are, by definition, pronounceable (using
IPA and 150,000 real words and phrases
in English and adopted into English.)

The Part-of-Speech database would even
permit you to construct grammatically
correct "sentences" for passphrase
generation; the Moby Words database has 560,000
entries in English; good enough for a subsequent
comprehensive scan for stereotyped passwords
or phrases.

The MD5 Algorithm would then collapse the
password or phrase into a well-distributed
bit space that a salt cold be coalesced into
or a  key extracted from.

Although not an endorsement,
Eugene Spafford is in fact using Moby Words
in a similar Internet project;  the NSA
is a licensee of the Part-of-Speech database.

These databases are available world-wide,
with special consideration for educational
and research organizations.

For more information on these data sets, please
e-mail a postal address to:  grady@btr.com
phone (408) 373-1491, or write:

Illumind
571 Belden St.
Monterey, CA  93940  USA
         

-- 
Grady Ward  grady@btr.com  Moby Lexicons

For pronounceable passwords,                                                    
you might consider using a combination
of the MD5 (message digest) algorithm
coupled to one or more of my Moby Lexical
databases:
 
The Pronunciator database will give
you a comprehensive set of individual,
double, and longer phonemes tuples that
are, by definition, pronounceable (using
IPA and 150,000 real words and phrases
in English and adopted into English.)

The Part-of-Speech database would even
permit you to construct grammatically
correct "sentences" for passphrase
generation; the Moby Words database has 560,000
entries in English; good enough for a subsequent
comprehensive scan for stereotyped passwords
or phrases.

The MD5 Algorithm would then collapse the
password or phrase into a well-distributed
bit space that a salt cold be coalesced into
or a  key extracted from.

Although not an endorsement,
Eugene Spafford is in fact using Moby Words
in a similar Internet project;  the NSA
is a licensee of the Part-of-Speech database.

These databases are available world-wide,
with special consideration for educational
and research organizations.

For more information on these data sets, please
e-mail a postal address to:  grady@btr.com
phone (408) 373-1491, or write:

Illumind
571 Belden St.
Monterey, CA  93940  USA
         
~
-- 
Grady Ward  grady@btr.com  Moby Lexicons

In article <1992Sep12.020756.17214@morwyn.uucp> 
(Forrie Aldrich) writes: 
> 
> I'm seeking a program/method which will generate pronounceable passwords,
> securely.  Meaning the process by which the actual password is generated
> should be genuinely random enough so an attack at the algorithm (by
> whatever means) would be infeasable.

        The C program listed below may be what Forrie is looking for,
        but it needs a cryptographically strong RNG to replace
        qrand().  Maybe one of our experts can post one??

----------------- START CODE -------------------------------------------
/* babble.c
    A program to generate random pronounceable words to be
    used as passwords.
    
Author:     Marc Thibault
Created:    17 January 1988
    
Synopsis:
	BABBLE [text]

Description:
	BABBLE, sends 64 random words to STDOUT, each 8 followed by 
	a newline. If the optional [text] argument is provided, the
	argument is used to initialize the random seed. The same argument
	will result in the same words on successive calls.
	
	The word generation is done through a set of arrays which 
	implement a strategy for pronounceability. This improves the 
	mnemonic value of the words without sacrificing randomness
	to any significant degree.

Subroutines:
	putns(c)				add character to word
    qrand(a)                random integer between 0 and (a-1)
	putSel(a,b)				add element to word
	selectStrategy ()		random row from strategy matrix
	doSel(n)				add element from set to word
	makeWord()				create random word
	int utime()				return unsigned int function of time

/*------------------------------------------------------------------*/


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

/*------------------------------------------------------------------*/
/* Global Data Items
/*------------------------------------------------------------------*/

char word[16];          /* Babble words will be assembled here      */
int wordCount;          /* Count of characters in word              */

						
/*------------------------------------------------------------------*/
/*            Word Elements                                         */
/*------------------------------------------------------------------*/

/* Introductory consonant */
char incon1[] = "bcdfghjklmnpqrstvwzsbbffpptdcst";
char incon2[] = "            u      tlrlrlrrrhhh";

/* Middle Consonants      */
char midcon1[] = "bbcdffghjkllmmnpqrrrsssttvnz";
char midcon2[] = " s   f     l m  u mr st t w ";


/* Ending Consonants      */
char endcon1[] = "bcddfgklmnrssttvz";
char endcon2[] = " k ef       t e y";

/* Vowels                 */
char vowels1[] = "aeiouaeieo";
char vowels2[] = "     iaaeo";



/*------------------------------------------------------------------*/
/* put character if not space and wordCount<8                       */
/* Returns 1 if character put, 0 if not                             */
/*------------------------------------------------------------------*/
char blank=32;

void putns(c)
char c;
    {
    if ((c != blank)&&(wordCount<8))
	word[wordCount++] = c;
    }

/*------------------------------------------------------------------*/
/* Return random number between 0 and argument
/*  This needs a stronger RNG.
/*------------------------------------------------------------------*/

int qrand(a)
int a;
	{
	int r;
	r=rand() % a;
	return (r);
	}


/*------------------------------------------------------------------*/
/* Put from selected array */
/*------------------------------------------------------------------*/


void putSel(a,b)
char a[], b[];
    {
    int i;
    i=qrand(strlen(a));
    putns(a[i]);
    putns(b[i]);
    }


/*------------------------------------------------------------------*/
/* Strategy Options
/* Each row is a sequence of choices representing constants
/* or vowels. See doSel for interpretation. The resulting
/* sequence is the template for a babble word. Greater security
/* can be obtained by increasing the size of the template.
/* If number of rows is changed, fix selectStrategy.
/* If number of cols is changed, fix makeWord.
/*------------------------------------------------------------------*/

int options[5][5]=
    {
	{1,2,1,4,0},			/* vowel, incon, vowel, endcon */
	{1,3,1,4,0},
	{2,1,3,1,0},
	{2,1,4,1,0},
	{2,1,3,1,4}
    };

/*------------------------------------------------------------------*/
/* Return a random row number into options							*/
/*------------------------------------------------------------------*/

int selectStrategy ()
    {
    int i;
    i = qrand(5);
    return (i);
    }


/*------------------------------------------------------------------*/
/* Handle one selection from a strategy
/*------------------------------------------------------------------*/
doSel(n)
int n;
    {
    switch(n)
		{
		case 0:
		    break;
		case 1:
		    putSel(vowels1,vowels2);
		    break;
		case 2:
		    putSel(incon1,incon2);
		    break;
		case 3:
		    putSel(midcon1,midcon2);	
		    break;
		case 4:
		    putSel(endcon1,endcon2);
		    break;
		}
    }

/*------------------------------------------------------------------*/
/* Make a word
/* Fill word buffer with 5 option elements from one strategy
/*------------------------------------------------------------------*/

void makeWord()
    {
    int s;              		/* strategy selection */
    int i;              		/* strategy element */
    
    s=selectStrategy();			/* get a random strategy */
    wordCount = 0;				/* reset word buffer */
    
    /* get 5 elements from selected strategy */
    for (i=0; i<5; i++)  doSel(options[s][i]);
    
    word[wordCount]=0;			/* terminate with nul */
    }

/*------------------------------------------------------------------*/
/* Return daytime function as unsigned int
/*------------------------------------------------------------------*/

unsigned int utime()
	{
	return ( (unsigned)(time(NULL)%32768) );
	}

/*------------------------------------------------------------------*/
/*                    MAIN PROGRAM									*/
/*------------------------------------------------------------------*/

main(argc,argv)
int argc;
char *argv[];
    {
    unsigned int i;
    int j;
    char *a;				/* arg string for random seed           */
    unsigned int t0;			/* initial time reading
    
	/*--------------------------------------------------------------*/
    /* Initialize Random Seed
	/*  If no argument is provided: use daytime, otherwise
	/*  add up bytes of argument
	/*--------------------------------------------------------------*/

	if( argc<2 ) 
		{	
		/* Wait for time to change */
		for (i=utime(); i==utime(););
		
		/* set seed */
		srand(utime());
		}
		
	else
		{
		i=0;
		a=argv[1];
		
		/* add up bytes in argument */
		for (i=0; *a != 0; i += *a++);
		srand(i);
		}	
	

	/*--------------------------------------------------------------*/
	/* Send 64 babble words to stdout */
	/*--------------------------------------------------------------*/
	
    for (i=0;i < 8; i++)
		{
		for (j=0; j<8; j++)
			{
			makeWord();
			printf("%s ",word);
			}
		/* CRLF */
		printf("\n");
		}
	
	/*---------------- That's All She Wrote ------------------------*/
    }

---

 Marc Thibault        |                              |  Any Warming,
 marc@tanda.isis.org  |  Oxford Mills, Ontario       |  Global or otherwise,
 CIS:71441,2226       |     Canada                   |   appreciated.

This is not a secure password generator!
If there are no arguments it seeds the pseudo-random number generator
with one of 32k different values.
Trial decryption is thus trivial.
(If there *are* arguments it probably seeds from an even smaller range.)

You don't need a better pseudo-random number generator,
you need a better source of randomness.  A high-resolution clock
might give you 32 unguessable bits, but that is not enough.
Another possibility is to have the user type something and measure
inter-character times with a busy loop:
	/* this is a crude example */
	for (8 times) {
		ask user to type something
		for (i = 0; no_keypress; i++)
			;
		the low-order value of "i" is probably quite random now
	}
This produces 64 unguessable bits (one might hope) that could be used
to seed a good PRNG, or probably even a crummy one by periodically doing:
		srand(rand() ^ some_of_the_unguessable_bits);

It is amazing how easy it is to break most of the posted password generators.
But then again, it is an easy trap to fall into.
Someone please post a really strong generator,
and try and make it widely available, and become famous.

Tom Truscott

In article <BuLCyD.DKG@cs.dal.ca> gauthier@ug.cs.dal.ca (Paul Gauthier) writes:
>In <7982@public.BTR.COM> grady@btr.BTR.COM (Grady Ward  grady@btr.com) writes:
>
>>For pronounceable passwords,
>> [...]
>
>Not relating specifically to this subject, but along the lines of passwords
>and security...
>
>Many system (almost all) provide a facility for the user's password to expire
>after a certain amount of time and then require a new password. What is
>the 'official' rationale concerning this practice?
>
>I assume the main brunt of the argument states that this somehow makes it
>harder for an attacker to guess a password.
>

Actually it does nothing to make it harder for an attacker to get the password.
It reduces the cost to you (value to the attacker) of a guess.
If I do get the password, it limits the amount of time I have to make an
attack.

The attacker may want to delay the attack until a time of his
choosing.  (We got the password into your air defense computer (which
strangely enough has a dial-in line) today, but we're not going to
launch the actual attack until December 7).

If someone really wants your password, then sooner or later they will tap
your line, or put a video camera in your ceiling.  It will be more expensive
for them if they have to maintain the wiretap or keep putting new batteries
in the video camera.

Finally, it may be that the system used to encrypt your password is of
'moderate' strength.  If it takes the bad guy an average of one month to
guess your password, and you change it every two weeks, then the bad guy
won't be able to log in as you most of the time.

Historically, people have placed unwarranted faith in the strength of their
cryptosystems.  Since we know this is a bad thing, we now like to place
unwarranted faith in the value of frequent key changes.
-- 
Any opinions above do not necessarily reflect the views of Stoner
Associates, Inc.