zxcvbn-ruby 0.0.2 → 0.0.3

data/lib/zxcvbn.rb

@@ -1,3 +1,6 @@
+require 'json'
+require 'pathname'
+
 require 'zxcvbn/version'
 require 'zxcvbn/match'
 require 'zxcvbn/matchers/regex_helpers'
@@ -23,8 +26,14 @@ module Zxcvbn
 
   DATA_PATH = Pathname(File.expand_path('../../data', __FILE__))
   ADJACENCY_GRAPHS = JSON.load(DATA_PATH.join('adjacency_graphs.json').read)
-  FREQUENCY_LISTS = YAML.load(DATA_PATH.join('frequency_lists.yaml').read)
-  RANKED_DICTIONARIES = DictionaryRanker.rank_dictionaries(FREQUENCY_LISTS)
+  FREQUENCY_LISTS_PATH = DATA_PATH.join("frequency_lists")
+  RANKED_DICTIONARIES = DictionaryRanker.rank_dictionaries(
+    "english" =>      FREQUENCY_LISTS_PATH.join("english.txt").read.split,
+    "female_names" => FREQUENCY_LISTS_PATH.join("female_names.txt").read.split,
+    "male_names" =>   FREQUENCY_LISTS_PATH.join("male_names.txt").read.split,
+    "passwords" =>    FREQUENCY_LISTS_PATH.join("passwords.txt").read.split,
+    "surnames" =>     FREQUENCY_LISTS_PATH.join("surnames.txt").read.split
+  )
 
   def test(password, user_inputs = [])
     zxcvbn = PasswordStrength.new

data/lib/zxcvbn/dictionary_ranker.rb

@@ -3,21 +3,16 @@
 module Zxcvbn
   class DictionaryRanker
     def self.rank_dictionaries(lists)
-      dictionaries = {}
-      lists.each do |dict_name, words|
+      lists.each_with_object({}) do |(dict_name, words), dictionaries|
         dictionaries[dict_name] = rank_dictionary(words)
       end
-      dictionaries
     end
 
     def self.rank_dictionary(words)
-      dictionary = {}
-      i = 1
-      words.each do |word|
-        dictionary[word.downcase] = i
-        i += 1
+      words.each_with_index
+           .with_object({}) do |(word, i), dictionary|
+        dictionary[word.downcase] = i + 1
       end
-      dictionary
     end
   end
 end

data/lib/zxcvbn/entropy.rb

@@ -3,24 +3,25 @@ module Zxcvbn::Entropy
 
   def calc_entropy(match)
     return match.entropy unless match.entropy.nil?
-    # debugger
+
     match.entropy = case match.pattern
-    when 'repeat'
-      repeat_entropy(match)
-    when 'sequence'
-      sequence_entropy(match)
-    when 'digits'
-      digits_entropy(match)
-    when 'year'
-      year_entropy(match)
-    when 'date'
-      date_entropy(match)
-    when 'spatial'
-      spatial_entropy(match)
-    when 'dictionary'
-      dictionary_entropy(match)
-    end
-    match.entropy ||= 0
+                    when 'repeat'
+                      repeat_entropy(match)
+                    when 'sequence'
+                      sequence_entropy(match)
+                    when 'digits'
+                      digits_entropy(match)
+                    when 'year'
+                      year_entropy(match)
+                    when 'date'
+                      date_entropy(match)
+                    when 'spatial'
+                      spatial_entropy(match)
+                    when 'dictionary'
+                      dictionary_entropy(match)
+                    else
+                      0
+                    end
   end
 
   def repeat_entropy(match)
@@ -66,7 +67,7 @@ module Zxcvbn::Entropy
       entropy += 2
     end
 
-    entropy    
+    entropy
   end
 
   def dictionary_entropy(match)
@@ -90,7 +91,7 @@ module Zxcvbn::Entropy
     num_upper = word.chars.count{|c| c.match(/[A-Z]/) }
     num_lower = word.chars.count{|c| c.match(/[a-z]/) }
     possibilities = 0
-    (0..min(num_upper, num_lower)).each do |i|
+    (0..[num_upper, num_lower].min).each do |i|
       possibilities += nCk(num_upper + num_lower, i)
     end
     lg(possibilities)
@@ -103,7 +104,7 @@ module Zxcvbn::Entropy
     match.sub.each do |subbed, unsubbed|
       num_subbed = word.chars.count{|c| c == subbed}
       num_unsubbed = word.chars.count{|c| c == unsubbed}
-      (0..min(num_subbed, num_unsubbed)).each do |i|
+      (0..[num_subbed, num_unsubbed].min).each do |i|
         possibilities += nCk(num_subbed + num_unsubbed, i)
       end
     end
@@ -131,16 +132,16 @@ module Zxcvbn::Entropy
         possibilities += nCk(i - 1, j - 1) * starting_positions * average_degree ** j
       end
     end
-        
+
     entropy = lg possibilities
     # add extra entropy for shifted keys. (% instead of 5, A instead of a.)
     # math is similar to extra entropy from uppercase letters in dictionary matches.
-    
+
     if match.shifted_count
       shiffted_count  = match.shifted_count
       unshifted_count = match.token.length - match.shifted_count
       possibilities   = 0
-      
+
       (0..[shiffted_count, unshifted_count].min).each do |i|
         possibilities += nCk(shiffted_count + unshifted_count, i)
       end
@@ -148,4 +149,4 @@ module Zxcvbn::Entropy
     end
     entropy
   end
-end
+end

data/lib/zxcvbn/match.rb

@@ -3,11 +3,9 @@ require 'ostruct'
 module Zxcvbn
   class Match < OpenStruct
     def to_hash
-      hash = @table.dup
-      hash.keys.sort.each do |key|
-        hash[key.to_s] = hash.delete(key)
+      @table.keys.sort.each_with_object({}) do |key, hash|
+        hash[key.to_s] = @table[key]
       end
-      hash
     end
   end
-end
+end

data/lib/zxcvbn/matchers/date.rb

@@ -22,23 +22,23 @@ module Zxcvbn
       WITHOUT_SEPARATOR = /\d{4,8}/
 
       def matches(password)
-        result = []
-        result += match_with_separator(password)
-        result += match_without_separator(password)
-        result
+        match_with_separator(password) + match_without_separator(password)
       end
 
       def match_with_separator(password)
         result = []
         re_match_all(YEAR_SUFFIX, password) do |match, re_match|
           match.pattern = 'date'
-          match.day = re_match[1].to_i
           match.separator = re_match[2]
-          match.month = re_match[3].to_i
           match.year = re_match[4].to_i
 
-          day, month = match.day, match.month
-          if month > 12
+          day = re_match[1].to_i
+          month = re_match[3].to_i
+
+          if month <= 12
+            match.day = day
+            match.month = month
+          else
             match.day = month
             match.month = day
           end
@@ -54,7 +54,6 @@ module Zxcvbn
           extract_dates(match.token).each do |candidate|
             day, month, year = candidate[:day], candidate[:month], candidate[:year]
 
-            match = match.dup
             match.pattern = 'date'
             match.day = day
             match.month = month
@@ -80,9 +79,9 @@ module Zxcvbn
           candidate.each do |component, value|
             candidate[component] = value.to_i
           end
-          
+
           candidate[:year] = expand_year(candidate[:year])
-          
+
           if valid_date?(candidate[:day], candidate[:month], candidate[:year]) && !matches_year?(token)
             dates << candidate
           end
@@ -131,4 +130,4 @@ module Zxcvbn
       end
     end
   end
-end
+end

data/lib/zxcvbn/matchers/digits.rb

@@ -15,4 +15,4 @@ module Zxcvbn
       end
     end
   end
-end
+end

data/lib/zxcvbn/matchers/regex_helpers.rb

@@ -2,20 +2,20 @@ module Zxcvbn
   module Matchers
     module RegexHelpers
       def re_match_all(regex, password)
-        loop do
-          re_match = regex.match(password)
-          break unless re_match
+        pos = 0
+        while re_match = regex.match(password, pos)
           i, j = re_match.offset(0)
+          pos = j
           j -= 1
+
           match = Match.new(
             :i => i,
             :j => j,
             :token => password[i..j]
           )
           yield match, re_match
-          password = password.sub(re_match[0], ' ' * re_match[0].length)
         end
       end
     end
   end
-end
+end

data/lib/zxcvbn/matchers/repeat.rb

@@ -5,28 +5,26 @@ module Zxcvbn
         result = []
         i = 0
         while i < password.length
+          cur_char = password[i]
           j = i + 1
-          loop do
-            prev_char, cur_char = password[j-1..j]
-            if password[j-1] == password[j]
-              j += 1
-            else
-              if j - i > 2 # don't consider length 1 or 2 chains.
-                result << Match.new(
-                  :pattern => 'repeat',
-                  :i => i,
-                  :j => j-1,
-                  :token => password[i...j],
-                  :repeated_char => password[i]
-                )
-              end
-              break
-            end
+          while cur_char == password[j]
+            j += 1
           end
+
+          if j - i > 2 # don't consider length 1 or 2 chains.
+            result << Match.new(
+              :pattern => 'repeat',
+              :i => i,
+              :j => j-1,
+              :token => password[i...j],
+              :repeated_char => cur_char
+            )
+          end
+
           i = j
         end
         result
       end
     end
   end
-end
+end

data/lib/zxcvbn/matchers/sequences.rb

@@ -7,58 +7,59 @@ module Zxcvbn
         'digits' => '01234567890'
       }
 
+      def seq_match_length(password, from, direction, seq)
+        index_from = seq.index(password[from])
+        j = 1
+        while from + j < password.length &&
+              password[from + j] == seq[index_from + direction * j]
+          j+= 1
+        end
+        j
+      end
+
+      # find the first matching sequence, and return with
+      # direction, if characters are one apart in the sequence
+      def applicable_sequence(password, i)
+        SEQUENCES.each do |name, sequence|
+          index1 = sequence.index(password[i])
+          index2 = sequence.index(password[i+1])
+          if index1 and index2
+            seq_direction = index2 - index1
+            if [-1, 1].include?(seq_direction)
+              return [name, sequence, seq_direction]
+            else
+              return nil
+            end
+          end
+        end
+      end
+
       def matches(password)
         result = []
         i = 0
-        while i < password.length-1
-          j = i + 1
-          seq = nil # either lower, upper, or digits
-          seq_name = nil
-          seq_direction = nil # 1 for ascending seq abcd, -1 for dcba
-          SEQUENCES.each do |seq_candidate_name, seq_candidate|
-            seq = nil
+        while i < password.length - 1
+          seq_name, seq, seq_direction = applicable_sequence(password, i)
 
-            i_n, j_n = [password[i], password[j]].map do |chr|
-              chr ? seq_candidate.index(chr) : nil
-            end
-
-            if i_n && j_n && i_n > -1 && j_n > -1
-              direction = j_n - i_n
-              if [1, -1].include?(direction)
-                seq = seq_candidate
-                seq_name = seq_candidate_name
-                seq_direction = direction
-              end
-            end
-            if seq
-              loop do
-                prev_char, cur_char = password[(j-1)], password[j]
-                prev_n, cur_n = [prev_char, cur_char].map do |chr|
-                  chr ? seq_candidate.index(chr) : nil
-                end
-                if prev_n && cur_n && cur_n - prev_n == seq_direction
-                  j += 1
-                else
-                  if j - i > 2 # don't consider length 1 or 2 chains.
-                    result << Match.new(
-                      :pattern => 'sequence',
-                      :i => i,
-                      :j => j-1,
-                      :token => password[i...j],
-                      :sequence_name => seq_name,
-                      :sequence_space => seq.length,
-                      :ascending => seq_direction == 1
-                    )
-                  end
-                  break
-                end
-              end
+          if seq
+            length = seq_match_length(password, i, seq_direction, seq)
+            if length > 2
+              result << Match.new(
+                :pattern => 'sequence',
+                :i => i,
+                :j => i + length - 1,
+                :token => password[i, length],
+                :sequence_name => seq_name,
+                :sequence_space => seq.length,
+                :ascending => seq_direction == 1
+              )
             end
+            i += length - 1
+          else
+            i += 1
           end
-          i = j
         end
         result
       end
     end
   end
-end
+end

data/lib/zxcvbn/math.rb

@@ -40,24 +40,15 @@ module Zxcvbn
       r
     end
 
-    def min(a, b)
-      a < b ? a : b
-    end
-
     def average_degree_for_graph(graph_name)
-      graph   = Zxcvbn::ADJACENCY_GRAPHS[graph_name]
-      average = 0.0
-
-      graph.each do |key, neighbors|
-        average += neighbors.compact.length
-      end
-
-      average /= graph.keys.length
-      average
+      graph = Zxcvbn::ADJACENCY_GRAPHS[graph_name]
+      degrees = graph.map { |_, neighbors| neighbors.compact.size }
+      sum = degrees.inject(0, :+)
+      sum.to_f / graph.size
     end
 
     def starting_positions_for_graph(graph_name)
       Zxcvbn::ADJACENCY_GRAPHS[graph_name].length
     end
   end
-end
+end

data/lib/zxcvbn/omnimatch.rb

@@ -1,7 +1,3 @@
-require 'json'
-require 'yaml'
-require 'pathname'
-
 module Zxcvbn
   class Omnimatch
     def initialize
@@ -9,11 +5,10 @@ module Zxcvbn
     end
 
     def matches(password, user_inputs = [])
-      result = []
-      (@matchers + user_input_matchers(user_inputs)).each do |matcher|
-        result += matcher.matches(password)
-      end
-      result
+      matchers = @matchers + user_input_matchers(user_inputs)
+      matchers.map do |matcher|
+        matcher.matches(password)
+      end.inject(&:+)
     end
 
     private
@@ -46,4 +41,4 @@ module Zxcvbn
       matchers
     end
   end
-end
+end