[Password Generation] Start using pronouncable passwords

third_party/fips181/fips181.cc

 /*
 ** This module uses code from the NIST implementation of  FIPS-181,
 ** but the algorythm is CHANGED and I think that I CAN
 ** copyright it. See copiright notes below.
 */
 
 /*
 ** Copyright (c) 1999, 2000, 2001, 2002, 2003
 ** Adel I. Mirzazhanov. All rights reserved
 **
@@ skipping 24 matching lines @@
 
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
 #include <strings.h> 
 #endif
 #include <time.h>
 #include <sys/types.h>
-#include "pronpass.h"
+#include "base/rand_util.h"
+#include "fips181.h"
 #include "randpass.h"
 #include "convert.h"
-#include "errs.h"
 
 struct unit
 {
     char    unit_code[5];
     USHORT  flags;
 };
 
 static struct unit  rules[] =
 {   {"a", VOWEL},
     {"b", NO_SPECIAL_RULE},
@@ skipping 1227 matching lines @@
     if (maxlen == 0)
     {
      word[0] = '\0';
      hyphenated_word[0] = '\0';
      return (0);
     }
 
  /* 
   * Find password.
   */
-    pwlen = gen_word (word, hyphenated_word, get_random (minlen, maxlen), pass_mode);
+    pwlen = gen_word (word, hyphenated_word, base::RandInt(minlen, maxlen),
+                      pass_mode);
     return (pwlen);
 }
 
 
 /*
  * This is the routine that returns a Random word -- as
  * yet unchecked against the passwd file or the dictionary.
  * It collects Random syllables until a predetermined
  * word length is found.  If a retry threshold is reached,
  * another word is tried.  Given that the Random number
@@ skipping 50 matching lines @@
 
     /*
      * Find syllables until the entire word is constructed.
      */
     while (word_length < pwlen)
     {
      /*
       * Get the syllable and find its length.
       */
      (void) gen_syllable (new_syllable, pwlen - word_length, syllable_units, &syllable_size);
-     syllable_length = strlen (new_syllable);
+     syllable_length = (USHORT) strlen (new_syllable);
      
      /*
       * Append the syllable units to the word units.
       */
      for (word_place = 0; word_place <= syllable_size; word_place++)
          word_units[word_size + word_place] = syllable_units[word_place];
      word_size += syllable_size + 1;
 
      /* 
       * If the word has been improperly formed, throw out
       * the syllable.  The checks performed here are those
       * that must be formed on a word basis.  The other
       * tests are performed entirely within the syllable.
       * Otherwise, append the syllable to the word and
       * append the syllable to the hyphenated version of
       * the word.
       */
      if (improper_word (word_units, word_size) ||
         ((word_length == 0) && have_initial_y (syllable_units, syllable_size)) ||
         ((word_length + syllable_length == pwlen) && have_final_split (syllable_units, syllable_size)))
            word_size -= syllable_size + 1;
      else
      {
          if (word_length == 0)
          {
           /*
           ** Modify syllable for numeric or capital symbols required
           ** Should be done after word quality check. 
           */
-          dsd = randint(2);
+          dsd = base::RandInt(0, 1);
           if ( ((pass_mode & S_NB) > 0) && (syllable_length == 1) && dsd == 0)
             {
              numerize(new_syllable);
              ch_flag = TRUE;
             }
           if ( ((pass_mode & S_SS) > 0) && (syllable_length == 1) && (dsd == 1))
             {
               specialize(new_syllable);
               ch_flag = TRUE;
             }
@@ skipping 13 matching lines @@
              }
           (void)memset ( (void *)new_syllable, 0, (size_t)(pwlen * sizeof(USHORT)+1));
           (void)memset ( (void *)syllable_for_hyph, 0, 20);
          }
          else
          {
           /*
           ** Modify syllable for numeric or capital symbols required
           ** Should be done after word quality check.
           */
-          dsd = randint(2);
+          dsd = base::RandInt(0, 1);
           if ( ((pass_mode & S_NB) > 0) && (syllable_length == 1) && (dsd == 0))
             {
              numerize(new_syllable);
              ch_flag = TRUE;
             }
           if ( ( (pass_mode & S_SS) > 0) && (syllable_length == 1) && (dsd == 1))
             {
              specialize(new_syllable);
              ch_flag = TRUE;
             }
@@ skipping 285 matching lines @@
                * syllable) to be valid.  We ignore the checks
                * and place it in this syllable manually.
                */
               if (saved_unit == 2)
               {
                units_in_syllable[0] = saved_pair[1];
                if (rules[saved_pair[1]].flags & VOWEL)
                    vowel_count++;
                current_unit++;
                (void) strcpy (syllable, rules[saved_pair[1]].unit_code);
-               length_left -= strlen (syllable);
+               length_left -= (short) strlen (syllable);
               }
 
               /* 
                * The unit becomes the last unit checked in the
                * previous syllable.
                */
               unit = saved_pair[0];
 
               /*
                * The saved units have been used.  Do not try to
@@ skipping 494 matching lines @@
 /*
  * Select a unit (a letter or a consonant group).  If a vowel is
  * expected, use the vowel_numbers array rather than looping through
  * the numbers array until a vowel is found.
  */
 USHORT
 random_unit (USHORT type)
 {
      USHORT number;
 
-    /* 
+    /*
      * Sometimes, we are asked to explicitly get a vowel (i.e., if
      * a digram pair expects one following it).  This is a shortcut
      * to do that and avoid looping with rejected consonants.
      */
     if (type & VOWEL)
-     number = vowel_numbers[get_random (0, (sizeof (vowel_numbers) / sizeof (USHORT))-1)];
+      number = vowel_numbers[
+          base::RandInt(0, (sizeof (vowel_numbers) / sizeof (USHORT))-1)];
     else
-     /* 
+     /*
       * Get any letter according to the English distribution.
       */
-     number = numbers[get_random (0, (sizeof (numbers) / sizeof (USHORT))-1)];
+      number = numbers[
+          base::RandInt(0, (sizeof (numbers) / sizeof (USHORT))-1)];
     return (number);
 }
-
-
-/*
-** get_random() -
-** This routine should return a uniformly distributed Random number between
-** minlen and maxlen inclusive.  The Electronic Code Book form of CAST is
-** used to produce the Random number.  The inputs to CAST are the old pass-
-** word and a pseudoRandom key generated according to the procedure out-
-** lined in Appendix C of ANSI X9.17.
-** INPUT:
-**   USHORT - minimum
-**   USHORT - maximum
-** OUTPUT:
-**   USHORT - random number
-** NOTES:
-**   none.
-*/
-
-USHORT
-get_random (USHORT minlen, USHORT maxlen)
-{
- USHORT ret = 0;
- ret = minlen + (USHORT) randint ((int) (maxlen - minlen + 1));
- return (ret);
-}