Class: Milia::Password

Inherits:
Object
  • Object
show all
Defined in:
lib/milia/password_generator.rb

Overview

Provides support generating memorable passwords

Class Method Summary collapse

Class Method Details

.generate(length = 8, flags = nil) ⇒ Object

Generate a memorable password of length characters, using phonemes that a human-being can easily remember. flags is one or more of Password::ONE_DIGIT and Password::ONE_CASE, logically OR’ed together. For example:

password = Password.generate(8, Password::ONE_DIGIT | Password::ONE_CASE)

This would generate an eight character password, containing a digit and an upper-case letter, such as Ug2shoth.

This method was inspired by the pwgen tool, written by Theodore Ts’o.

Generated passwords may contain any of the characters in Password::PASSWD_CHARS.



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/milia/password_generator.rb', line 83

def generate(length = 8, flags = nil)
  password = nil
  ph_flags = flags
  
  loop do
    password = ''
    
    # Separate the flags integer into an array of individual flags
    feature_flags = [flags & ONE_DIGIT, flags & ONE_CASE]
    
    prev = []
    first = true
    desired = Password.get_vowel_or_consonant
    
    # Get an Array of all of the phonemes
    phonemes = PHONEMES.keys.map {|ph| ph.to_s}
    nr_phonemes = phonemes.size
    
    while password.length < length do
      # Get a random phoneme and its length
      phoneme = phonemes[rand(nr_phonemes)]
      ph_len = phoneme.length
      
      # Get its flags as an Array
      ph_flags = PHONEMES[phoneme.to_sym]
      ph_flags = [ph_flags & CONSONANT, ph_flags & VOWEL, ph_flags & DIPHTHONG, ph_flags & NOT_FIRST]
      
      # Filter on the basic type of the next phoneme
      next if ph_flags.include?(desired)
      
      # Handle the NOT_FIRST flag
      next if first && ph_flags.include?(NOT_FIRST)
      
      # Don't allow a VOWEL followed a vowel/diphthong pair
      next if prev.include?(VOWEL) && ph_flags.include?(VOWEL) && ph_flags.include?(DIPHTHONG)
      
      # Don't allow us to go longer than the desired length
      next if ph_len > length - password.length
      
      # We've found a phoneme that meets our criteria
      password << phoneme
      
      # Handle ONE_CASE
      if feature_flags.include?(ONE_CASE)
        if (first || ph_flags.include?(CONSONANT)) && rand(10) < 3
          password[-ph_len, 1] = password[-ph_len, 1].upcase
          feature_flags.delete(ONE_CASE)
        end
      end
      
      # Is password already long enough?
      break if password.length >= length
      
      # Handle ONE_DIGIT
      if feature_flags.include?(ONE_DIGIT)
        if !first && rand(10) < 3
          password << (rand(10) + '0'.ord).chr
          feature_flags.delete(ONE_DIGIT)
          
          first = true
          prev = []
          desired = Password.get_vowel_or_consonant
          next
        end
      end
      
      if desired == CONSONANT
        desired = VOWEL
      elsif prev.include?(VOWEL) || ph_flags.include?(DIPHTHONG) || rand(10) > 3
        desired = CONSONANT
      else
        desired = VOWEL
      end
      
      prev = ph_flags
      first = false
    end
    
    # Try again
    break unless feature_flags.include?(ONE_CASE) || feature_flags.include?(ONE_DIGIT)
    
  end
  
  password
end

.get_vowel_or_consonant ⇒ Object

Determine whether the next character should be a vowel or consonant.



64
65
66
 
# File 'lib/milia/password_generator.rb', line 64

def get_vowel_or_consonant
  rand( 2 ) == 1 ? VOWEL : CONSONANT
end