home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #20 / NN_1992_20.iso / spool / sci / crypt / 3247 < prev    next >
Encoding:
Text File  |  1992-09-15  |  7.7 KB  |  284 lines
  1. Path: sparky!uunet!cs.utexas.edu!torn!cunews!revcan!micor!uuisis!tanda!marc
  2. From: marc@tanda.isis.org (Marc Thibault)
  3. Reply-To: marc@tanda.isis.org
  4. Newsgroups: sci.crypt
  5. Subject: Re: Secure password generation
  6. Message-ID: <256379411DN5.61R@tanda.isis.org>
  7. References: <1992Sep12.020756.17214@morwyn.uucp>
  8. Date: Mon, 14 Sep 92 10:19:15 EDT
  9. Distribution: na
  10. Organization: Thibault & Friends
  11. Lines: 265
  12.  
  13. In article <1992Sep12.020756.17214@morwyn.uucp> 
  14. (Forrie Aldrich) writes: 
  15. > 
  16. > I'm seeking a program/method which will generate pronounceable passwords,
  17. > securely.  Meaning the process by which the actual password is generated
  18. > should be genuinely random enough so an attack at the algorithm (by
  19. > whatever means) would be infeasable.
  20.  
  21.         The C program listed below may be what Forrie is looking for,
  22.         but it needs a cryptographically strong RNG to replace
  23.         qrand().  Maybe one of our experts can post one??
  24.  
  25. ----------------- START CODE -------------------------------------------
  26. /* babble.c
  27.     A program to generate random pronounceable words to be
  28.     used as passwords.
  29.     
  30. Author:     Marc Thibault
  31. Created:    17 January 1988
  32.     
  33. Synopsis:
  34.     BABBLE [text]
  35.  
  36. Description:
  37.     BABBLE, sends 64 random words to STDOUT, each 8 followed by 
  38.     a newline. If the optional [text] argument is provided, the
  39.     argument is used to initialize the random seed. The same argument
  40.     will result in the same words on successive calls.
  41.     
  42.     The word generation is done through a set of arrays which 
  43.     implement a strategy for pronounceability. This improves the 
  44.     mnemonic value of the words without sacrificing randomness
  45.     to any significant degree.
  46.  
  47. Subroutines:
  48.     putns(c)                add character to word
  49.     qrand(a)                random integer between 0 and (a-1)
  50.     putSel(a,b)                add element to word
  51.     selectStrategy ()        random row from strategy matrix
  52.     doSel(n)                add element from set to word
  53.     makeWord()                create random word
  54.     int utime()                return unsigned int function of time
  55.  
  56. /*------------------------------------------------------------------*/
  57.  
  58.  
  59. #include <stdio.h>
  60. #include <string.h>
  61. #include <time.h>
  62. #include <stdlib.h>
  63.  
  64. /*------------------------------------------------------------------*/
  65. /* Global Data Items
  66. /*------------------------------------------------------------------*/
  67.  
  68. char word[16];          /* Babble words will be assembled here      */
  69. int wordCount;          /* Count of characters in word              */
  70.  
  71.                         
  72. /*------------------------------------------------------------------*/
  73. /*            Word Elements                                         */
  74. /*------------------------------------------------------------------*/
  75.  
  76. /* Introductory consonant */
  77. char incon1[] = "bcdfghjklmnpqrstvwzsbbffpptdcst";
  78. char incon2[] = "            u      tlrlrlrrrhhh";
  79.  
  80. /* Middle Consonants      */
  81. char midcon1[] = "bbcdffghjkllmmnpqrrrsssttvnz";
  82. char midcon2[] = " s   f     l m  u mr st t w ";
  83.  
  84.  
  85. /* Ending Consonants      */
  86. char endcon1[] = "bcddfgklmnrssttvz";
  87. char endcon2[] = " k ef       t e y";
  88.  
  89. /* Vowels                 */
  90. char vowels1[] = "aeiouaeieo";
  91. char vowels2[] = "     iaaeo";
  92.  
  93.  
  94.  
  95. /*------------------------------------------------------------------*/
  96. /* put character if not space and wordCount<8                       */
  97. /* Returns 1 if character put, 0 if not                             */
  98. /*------------------------------------------------------------------*/
  99. char blank=32;
  100.  
  101. void putns(c)
  102. char c;
  103.     {
  104.     if ((c != blank)&&(wordCount<8))
  105.     word[wordCount++] = c;
  106.     }
  107.  
  108. /*------------------------------------------------------------------*/
  109. /* Return random number between 0 and argument
  110. /*  This needs a stronger RNG.
  111. /*------------------------------------------------------------------*/
  112.  
  113. int qrand(a)
  114. int a;
  115.     {
  116.     int r;
  117.     r=rand() % a;
  118.     return (r);
  119.     }
  120.  
  121.  
  122. /*------------------------------------------------------------------*/
  123. /* Put from selected array */
  124. /*------------------------------------------------------------------*/
  125.  
  126.  
  127. void putSel(a,b)
  128. char a[], b[];
  129.     {
  130.     int i;
  131.     i=qrand(strlen(a));
  132.     putns(a[i]);
  133.     putns(b[i]);
  134.     }
  135.  
  136.  
  137. /*------------------------------------------------------------------*/
  138. /* Strategy Options
  139. /* Each row is a sequence of choices representing constants
  140. /* or vowels. See doSel for interpretation. The resulting
  141. /* sequence is the template for a babble word. Greater security
  142. /* can be obtained by increasing the size of the template.
  143. /* If number of rows is changed, fix selectStrategy.
  144. /* If number of cols is changed, fix makeWord.
  145. /*------------------------------------------------------------------*/
  146.  
  147. int options[5][5]=
  148.     {
  149.     {1,2,1,4,0},            /* vowel, incon, vowel, endcon */
  150.     {1,3,1,4,0},
  151.     {2,1,3,1,0},
  152.     {2,1,4,1,0},
  153.     {2,1,3,1,4}
  154.     };
  155.  
  156. /*------------------------------------------------------------------*/
  157. /* Return a random row number into options                            */
  158. /*------------------------------------------------------------------*/
  159.  
  160. int selectStrategy ()
  161.     {
  162.     int i;
  163.     i = qrand(5);
  164.     return (i);
  165.     }
  166.  
  167.  
  168. /*------------------------------------------------------------------*/
  169. /* Handle one selection from a strategy
  170. /*------------------------------------------------------------------*/
  171. doSel(n)
  172. int n;
  173.     {
  174.     switch(n)
  175.         {
  176.         case 0:
  177.             break;
  178.         case 1:
  179.             putSel(vowels1,vowels2);
  180.             break;
  181.         case 2:
  182.             putSel(incon1,incon2);
  183.             break;
  184.         case 3:
  185.             putSel(midcon1,midcon2);    
  186.             break;
  187.         case 4:
  188.             putSel(endcon1,endcon2);
  189.             break;
  190.         }
  191.     }
  192.  
  193. /*------------------------------------------------------------------*/
  194. /* Make a word
  195. /* Fill word buffer with 5 option elements from one strategy
  196. /*------------------------------------------------------------------*/
  197.  
  198. void makeWord()
  199.     {
  200.     int s;                      /* strategy selection */
  201.     int i;                      /* strategy element */
  202.     
  203.     s=selectStrategy();            /* get a random strategy */
  204.     wordCount = 0;                /* reset word buffer */
  205.     
  206.     /* get 5 elements from selected strategy */
  207.     for (i=0; i<5; i++)  doSel(options[s][i]);
  208.     
  209.     word[wordCount]=0;            /* terminate with nul */
  210.     }
  211.  
  212. /*------------------------------------------------------------------*/
  213. /* Return daytime function as unsigned int
  214. /*------------------------------------------------------------------*/
  215.  
  216. unsigned int utime()
  217.     {
  218.     return ( (unsigned)(time(NULL)%32768) );
  219.     }
  220.  
  221. /*------------------------------------------------------------------*/
  222. /*                    MAIN PROGRAM                                    */
  223. /*------------------------------------------------------------------*/
  224.  
  225. main(argc,argv)
  226. int argc;
  227. char *argv[];
  228.     {
  229.     unsigned int i;
  230.     int j;
  231.     char *a;                /* arg string for random seed           */
  232.     unsigned int t0;            /* initial time reading
  233.     
  234.     /*--------------------------------------------------------------*/
  235.     /* Initialize Random Seed
  236.     /*  If no argument is provided: use daytime, otherwise
  237.     /*  add up bytes of argument
  238.     /*--------------------------------------------------------------*/
  239.  
  240.     if( argc<2 ) 
  241.         {    
  242.         /* Wait for time to change */
  243.         for (i=utime(); i==utime(););
  244.         
  245.         /* set seed */
  246.         srand(utime());
  247.         }
  248.         
  249.     else
  250.         {
  251.         i=0;
  252.         a=argv[1];
  253.         
  254.         /* add up bytes in argument */
  255.         for (i=0; *a != 0; i += *a++);
  256.         srand(i);
  257.         }    
  258.     
  259.  
  260.     /*--------------------------------------------------------------*/
  261.     /* Send 64 babble words to stdout */
  262.     /*--------------------------------------------------------------*/
  263.     
  264.     for (i=0;i < 8; i++)
  265.         {
  266.         for (j=0; j<8; j++)
  267.             {
  268.             makeWord();
  269.             printf("%s ",word);
  270.             }
  271.         /* CRLF */
  272.         printf("\n");
  273.         }
  274.     
  275.     /*---------------- That's All She Wrote ------------------------*/
  276.     }
  277.  
  278. ---
  279.  
  280.  Marc Thibault        |                              |  Any Warming,
  281.  marc@tanda.isis.org  |  Oxford Mills, Ontario       |  Global or otherwise,
  282.  CIS:71441,2226       |     Canada                   |   appreciated.
  283.  
  284.