ruby-entropy 0.1.0 → 0.1.1

data/lib/ruby-entropy.rb

@@ -1,42 +1,41 @@
-class Password
+class RubyEntropy
 
-  attr_reader :password
+  attr_reader :passphrase
   
-  #lowercase passwords only
-  COMMON_PASSWORDS = ["admin", "administrator", "jesus", "letmein", "master", "open sesame", "opensesame", "password", "sunshine", "trustnoi", "trustnol", "welcome"]
+  #lowercase only
+  COMMON_PASSPHRASES = ["admin", "administrator", "jesus", "letmein", "master", "open sesame", "opensesame", "password", "passphrase", "sunshine", "trustnoi", "trustnol", "welcome"]
   KEY_PATTERNS = ["zxc", "cxz", "bnm", "mnb", "jkl", "lkj", "asd", "dsa", "qwe", "ewq", "iop", "poi"]
 
-  def initialize(password)
-    @password = password
-    @passwords = []
+  def initialize(passphrase)
+    @passphrase = passphrase
   end
 
-  def entropy
-    Math.log2(count ** length)
+  def strength
+    (31 * bad_passphrase_multiplier * Math.log(entropy / 13.62)).round(2)
   end
 
-  def strength
-    (31 * bad_password_multiplier * Math.log(entropy / 13.62)).round(2)
+  def entropy
+    Math.log2(count ** length)
   end
 
   def length
-    @password.length
+    @passphrase.length
   end
 
   def letters
-    26 if @password.match(/[a-z]|[A-Z]/)
+    26 if @passphrase.match(/[a-z]|[A-Z]/)
   end
    
   def multiple_cases
-    26 if @password.match(/[a-z]/) && @password.match(/[A-Z]/)
+    26 if @passphrase.match(/[a-z]/) && @passphrase.match(/[A-Z]/)
   end
 
   def digits
-    10 if @password.match(/\d/) 
+    10 if @passphrase.match(/\d/) 
   end
 
   def symbols
-    33 if @password.match(/\W/)
+    33 if @passphrase.match(/\W/)
   end
 
   def count
@@ -44,12 +43,12 @@ class Password
   end
 
   def key_pattern?
-    KEY_PATTERNS.each { |pattern| return true if @password.downcase.include?(pattern) }
+    KEY_PATTERNS.each { |pattern| return true if @passphrase.downcase.include?(pattern) }
     false
   end
 
   def numerical_pattern?
-    pattern = @password.split('').map(&:to_i)
+    pattern = @passphrase.split('').map(&:to_i)
     pattern.each_with_index do |num, index|
       return true if pattern[index + 1] == num + 1 && pattern[index + 2] == num + 2 && pattern[index + 3] == num + 3
       return true if pattern[index + 1] == num - 1 && pattern[index + 2] == num - 2 && pattern[index + 3] == num - 3
@@ -58,7 +57,7 @@ class Password
   end
 
   def repetitious?
-    characters = @password.split('')
+    characters = @passphrase.split('')
     characters.each_with_index do |character, index|
       return true if characters[index + 1] == character && characters[index + 2] == character
     end
@@ -66,25 +65,26 @@ class Password
   end
 
   def common?
-    @passwords << @password
-    if @password.match(/[@0|1$5]/)
-      @passwords << @password.gsub('@', 'a').gsub('0', 'o').gsub(/[|1!]/, 'l').gsub(/[$5]/, 's')
-      @passwords << @password.gsub('@', 'a').gsub('0', 'o').gsub(/[|1!]/, 'i').gsub(/[$5]/, 's')
+    @passphrases = []
+    @passphrases << @passphrase
+    if @passphrase.match(/[@0|1$5]/)
+      @passphrases << @passphrase.gsub('@', 'a').gsub('0', 'o').gsub(/[|1!]/, 'l').gsub(/[$5]/, 's')
+      @passphrases << @passphrase.gsub('@', 'a').gsub('0', 'o').gsub(/[|1!]/, 'i').gsub(/[$5]/, 's')
     end
-    COMMON_PASSWORDS.each do |commoner|
-      @passwords.each { |password| return true if password.downcase.include?(commoner.downcase) }
+    COMMON_PASSPHRASES.each do |commoner|
+      @passphrases.each { |passphrase| return true if passphrase.downcase.include?(commoner.downcase) }
     end
     false
   end
 
   def uniqueness
-    (@password.downcase.split('').uniq.length/length.to_f) < 0.4
+    (@passphrase.downcase.split('').uniq.length/length.to_f) < 0.4
   end
 
   def repeaters
     mode = []
-    @password.downcase.split('').uniq.each do |character|
-      mode << @password.split('').count(character)
+    @passphrase.downcase.split('').uniq.each do |character|
+      mode << @passphrase.split('').count(character)
     end
     mode.max.downto(2) do |num|
       return true if (mode.count(num)/mode.length.to_f) > 0.75
@@ -92,8 +92,8 @@ class Password
     false
   end
 
-  def bad_password_multiplier
+  def bad_passphrase_multiplier
     repeaters || uniqueness ? (return 0.1) : 1
-    key_pattern? || numerical_pattern? || repetitious? || common? ? @password.length < 12 ? 0.5 : 0.75 : 1
+    key_pattern? || numerical_pattern? || repetitious? || common? ? @passphrase.length < 12 ? 0.5 : 0.75 : 1
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-entropy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-21 00:00:00.000000000 Z
+date: 2013-05-22 00:00:00.000000000 Z
 dependencies: []
 description: Calculates password strength based on standard entropy definition.  Strength
   is reduced based on repeatability and common password test functions