is_passgen 1.1.2

data/lib/passgen/strength_analyzer.rb

@@ -0,0 +1,283 @@
+module Passgen
+  class StrengthAnalyzer
+    MIN_LENGTH = 8
+    attr_reader :password, :score, :complexity, :errors
+
+    def initialize(pw)
+      @password   = pw
+      @score      = 0
+      @complexity = "Invalid"
+      @errors     = []
+    end
+
+    def self.analyze(pw)
+      sa = StrengthAnalyzer.new(pw)
+      sa.analyze
+      sa
+    end
+
+    def analyze
+      return self unless check_minimum_requirements
+
+      nScore              = 0
+      nLength             = 0
+      nAlphaUC            = 0
+      nAlphaLC            = 0
+      nNumber             = 0
+      nSymbol             = 0
+      nMidChar            = 0
+      nRequirements       = 0
+      nAlphasOnly         = 0
+      nNumbersOnly        = 0
+      nUnqChar            = 0
+      nRepChar            = 0
+      nRepInc             = 0
+      nConsecAlphaUC      = 0
+      nConsecAlphaLC      = 0
+      nConsecNumber       = 0
+      nConsecSymbol       = 0
+      nConsecCharType     = 0
+      nSeqAlpha           = 0
+      nSeqNumber          = 0
+      nSeqSymbol          = 0
+      nSeqChar            = 0
+      nReqChar            = 0
+      nMultConsecCharType = 0
+      nMultRepChar        = 1
+      nMultConsecSymbol   = 1
+      nMultMidChar        = 2
+      nMultRequirements   = 2
+      nMultConsecAlphaUC  = 2
+      nMultConsecAlphaLC  = 2
+      nMultConsecNumber   = 2
+      nReqCharType        = 3
+      nMultAlphaUC        = 3
+      nMultAlphaLC        = 3
+      nMultSeqAlpha       = 3
+      nMultSeqNumber      = 3
+      nMultSeqSymbol      = 3
+      nMultLength         = 4
+      nMultNumber         = 4
+      nMultSymbol         = 6
+      nTmpAlphaUC         = ""
+      nTmpAlphaLC         = ""
+      nTmpNumber          = ""
+      nTmpSymbol          = ""
+      sAlphas             = 'abcdefghijklmnopqrstuvwxyz'
+      sNumerics           = '01234567890'
+      sSymbols            = '!@#$%&/()+?*'
+      sComplexity         = 'Invalid'
+      sStandards          = 'Below'
+      nMinPwdLen          = MIN_LENGTH
+
+      nScore    = @password.length * nMultLength
+      nLength   = @password.length
+      arrPwd    = @password.gsub(/\s+/, "").split(/\s*/)
+      arrPwdLen = arrPwd.length
+
+      # Loop through password to check for Symbol, Numeric, Lowercase and Uppercase pattern matches
+      arrPwdLen.times do |a|
+        if /[A-Z]/.match(arrPwd[a])
+          if nTmpAlphaUC != ""
+            if (nTmpAlphaUC + 1) == a
+              nConsecAlphaUC  += 1
+              nConsecCharType += 1
+            end
+          end
+          nTmpAlphaUC = a
+          nAlphaUC    += 1
+        elsif /[a-z]/.match(arrPwd[a])
+          if nTmpAlphaLC != ""
+            if (nTmpAlphaLC + 1) == a
+              nConsecAlphaLC  += 1
+              nConsecCharType += 1
+            end
+          end
+          nTmpAlphaLC = a
+          nAlphaLC    += 1
+        elsif /[0-9]/.match(arrPwd[a])
+          if a > 0 && a < (arrPwdLen - 1)
+            nMidChar += 1
+          end
+          if nTmpNumber != ""
+            if (nTmpNumber + 1) == a
+              nConsecNumber   += 1
+              nConsecCharType += 1
+            end
+          end
+          nTmpNumber = a
+          nNumber    += 1
+        elsif /[^a-zA-Z0-9_]/.match(arrPwd[a])
+          if a > 0 && a < (arrPwdLen - 1)
+            nMidChar += 1
+          end
+          if nTmpSymbol != ""
+            if (nTmpSymbol + 1) == a
+              nConsecSymbol   += 1
+              nConsecCharType += 1
+            end
+          end
+          nTmpSymbol = a
+          nSymbol += 1
+        end
+
+        # Internal loop through password to check for repeat characters
+        bCharExists = false
+        arrPwdLen.times do |b|
+          if arrPwd[a] == arrPwd[b] && a != b # repeat character exists
+            bCharExists = true
+            # Calculate increment deduction based on proximity to identical characters
+            # Deduction is incremented each time a new match is discovered
+            # Deduction amount is based on total password length divided by the
+            # difference of distance between currently selected match
+            nRepInc += (arrPwdLen / (b - a)).abs
+          end
+        end
+        if bCharExists
+          nRepChar += 1
+          nUnqChar = arrPwdLen - nRepChar
+          nRepInc = (nUnqChar > 0) ? (nRepInc / nUnqChar).ceil : nRepInc.ceil
+        end
+      end
+
+      # Check for sequential alpha string patterns (forward and reverse)
+      (sAlphas.size - 3).times do |s|
+        sFwd = sAlphas[s...s + 3]
+        sRev = sFwd.reverse
+        if @password.downcase.index(sFwd) || @password.downcase.index(sRev)
+          nSeqAlpha += 1
+          nSeqChar  += 1
+        end
+      end
+
+      # Check for sequential numeric string patterns (forward and reverse)
+      (sNumerics.size - 3).times do |s|
+        sFwd = sNumerics[s...s + 3]
+        sRev = sFwd.reverse
+        if @password.downcase.index(sFwd) || @password.downcase.index(sRev)
+          nSeqNumber += 1
+          nSeqChar   += 1
+        end
+      end
+
+      # Check for sequential symbol string patterns (forward and reverse)
+      (sSymbols.size - 3).times do |s|
+        sFwd = sSymbols[s...s + 3]
+        sRev = sFwd.reverse
+        if @password.downcase.index(sFwd) || @password.downcase.index(sRev)
+          nSeqSymbol += 1
+          nSeqChar   += 1
+        end
+      end
+
+      # Modify overall score value based on usage vs requirements
+      if nAlphaUC > 0 && nAlphaUC < nLength
+        nScore += (nLength - nAlphaUC) * 2
+      end
+
+      if nAlphaLC > 0 && nAlphaLC < nLength
+        nScore += (nLength - nAlphaLC) * 2
+      end
+
+      if nNumber > 0 && nNumber < nLength
+        nScore += nNumber * nMultNumber
+      end
+
+      if nSymbol > 0
+        nScore += nSymbol * nMultSymbol
+      end
+
+      if nMidChar > 0
+        nScore += nMidChar * nMultMidChar
+      end
+
+      # Point deductions for poor practices
+      if (nAlphaLC > 0 || nAlphaUC > 0) && nSymbol == 0 && nNumber == 0 # Only Letters
+        nScore      -= nLength
+        nAlphasOnly = nLength
+      end
+
+      if nAlphaLC === 0 && nAlphaUC === 0 && nSymbol === 0 && nNumber > 0 # Only Numbers
+        nScore       -= nLength
+        nNumbersOnly = nLength
+      end
+
+      if nRepChar > 0 # Same character exists more than once
+        nScore -= nRepInc
+      end
+
+      if nConsecAlphaUC > 0 # Consecutive Uppercase Letters exist
+        nScore -= nConsecAlphaUC * nMultConsecAlphaUC
+      end
+
+      if nConsecAlphaLC > 0 # Consecutive Lowercase Letters exist
+        nScore -= nConsecAlphaLC * nMultConsecAlphaLC
+      end
+
+      if nConsecNumber > 0 # Consecutive Numbers exist
+        nScore -= nConsecNumber * nMultConsecNumber
+      end
+
+      if nSeqAlpha > 0 # Sequential alpha strings exist (3 characters or more)
+        nScore -= nSeqAlpha * nMultSeqAlpha
+      end
+
+      if nSeqNumber > 0 # Sequential numeric strings exist (3 character or more)
+        nScore -= nSeqNumber * nMultSeqNumber
+      end
+
+      if nSeqSymbol > 0 # Sequential symbol strings exist (3 character or more)
+        nScore -= nSeqSymbol * nMultSeqSymbol
+      end
+
+      # Determine if mandatory requirements have been met and set image indicators accordingly
+      arrChars    = [nLength, nAlphaUC, nAlphaLC, nNumber, nSymbol]
+      arrCharsIds = ["nLength", "nAlphaUC", "nAlphaLC", "nNumber", "nSymbol"]
+      arrCharsLen = arrChars.length
+      arrCharsLen.times do |c|
+        minVal = arrCharsIds[c] == "nLength" ? MIN_LENGTH - 1 : 0
+        if arrChars[c] == (minVal + 1)
+          nReqChar += 1
+        elsif arrChars[c] > (minVal + 1)
+          nReqChar += 1
+        end
+      end
+      nRequirements = nReqChar
+      nMinReqChars  = @password.length >= nMinPwdLen ? 3 : 4
+      if nRequirements > nMinReqChars # One or more required characters exist
+        nScore += (nRequirements * 2)
+      end
+
+      # Determine complexity based on overall score
+      if nScore > 100
+        nScore = 100
+      elsif nScore < 0
+        nScore = 0
+      end
+      @complexity = case nScore
+                    when 0...20
+                      "Trivial"
+                    when 20...40
+                      "Weak"
+                    when 40...60
+                      "Good"
+                    when 60...80
+                      "Strong"
+                    else
+                      "Very Strong"
+                    end
+
+      @score = nScore
+    end
+
+    private
+
+    def check_minimum_requirements
+      if @password.length < MIN_LENGTH
+        @errors << "Password must be at least #{MIN_LENGTH} characters long"
+        return false
+      end
+      true
+    end
+  end
+end

data/passgen.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{passgen}
+  s.version = "1.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Erik Lindblad (CrypticE)", "Ronald Brachetti(rbecher)", "Ken Spencer (IotaSpencer)"]
+  s.date = %q{2020-03-31}
+  s.description = %q{A password generation gem for Ruby and Rails applications.}
+  s.email = %q{erik@l2c.se}
+  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc", "lib/passgen.rb", "lib/passgen/probabilities.rb", "lib/passgen/strength_analyzer.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README.rdoc", "Rakefile", "rails/init.rb", "lib/passgen.rb", "lib/passgen/probabilities.rb", "lib/passgen/strength_analyzer.rb", "passgen.gemspec", "spec/passgen/strength_analyzer_spec.rb", "spec/passgen_spec.rb"]
+  s.homepage = %q{http://github.com/cryptice/passgen}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Passgen", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A password generation gem for Ruby and Rails applications.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require 'passgen'
+

data/spec/passgen/strength_analyzer_spec.rb

@@ -0,0 +1,75 @@
+require "./lib/passgen"
+
+describe "Using strength analyzer" do
+
+  before do
+    srand(2)
+  end
+
+  it "should return a StrengthAnalyzer instance" do
+    Passgen.analyze("abcdefg").should be_a(Passgen::StrengthAnalyzer)
+  end
+  
+  it "should require minimum of 8 characters" do
+    sa = Passgen.analyze("abcdefg")
+    sa.score.should == 0
+    sa.complexity.should == "Invalid"
+    sa.errors.should == ["Password must be at least 8 characters long"]
+  end
+
+  it "should analyze aaaaaaaa correctly" do
+    sa = Passgen.analyze("aaaaaaaa")
+    sa.score.should == 0
+    sa.complexity.should == "Trivial"
+    sa.errors.should == []
+  end
+
+  it "should analyze aaaaAAAA correctly" do
+    sa = Passgen.analyze("aaaaAAAA")
+    sa.score.should == 0
+    sa.complexity.should == "Trivial"
+    sa.errors.should == []
+  end
+
+  it "should analyze aaaAAA11 correctly" do
+    sa = Passgen.analyze("aaaAAA11")
+    sa.score.should == 35
+    sa.complexity.should == "Weak"
+    sa.errors.should == []
+  end
+
+  it "should analyze aaa1AAA1 correctly" do
+    sa = Passgen.analyze("aaa1AAA1")
+    sa.score.should == 38
+    sa.complexity.should == "Weak"
+    sa.errors.should == []
+  end
+
+  it "should analyze hht14AAA correctly" do
+    sa = Passgen.analyze("hht14AAA")
+    sa.score.should == 57
+    sa.complexity.should == "Good"
+    sa.errors.should == []
+  end
+  
+  it "should analyze hie14KOL correctly" do
+    sa = Passgen.analyze("hie14KOL")
+    sa.score.should == 62
+    sa.complexity.should == "Strong"
+    sa.errors.should == []
+  end
+  
+  it "should analyze hI&14KoL correctly" do
+    sa = Passgen.analyze("hI&14KoL")
+    sa.score.should == 82
+    sa.complexity.should == "Very Strong"
+    sa.errors.should == []
+  end
+
+  it "should analyze hI&1#4KoL correctly" do
+    sa = Passgen.analyze("hI&1#4KoL")
+    sa.score.should == 100
+    sa.complexity.should == "Very Strong"
+    sa.errors.should == []
+  end
+end

data/spec/passgen_spec.rb

@@ -0,0 +1,150 @@
+require "./lib/passgen"
+
+describe "Using passgen" do
+
+  before do
+    srand(2)
+  end
+  
+  it "should return password with default settings." do
+    Passgen::generate.should eql("OpTiwRslOh")
+  end
+
+  it "should return password with uppercase chars only" do
+    Passgen::generate(:uppercase => :only).should eql("IPNIWLSLIH")
+  end
+  
+  it "should return password with lowercase chars only" do
+    Passgen::generate(:lowercase => :only).should eql("ipniwlslih")
+  end
+
+  it "should return password with digits only" do
+    Passgen::generate(:digits => :only).should eql("8862872154")
+  end
+
+  it "should return password with symbols only" do
+    Passgen::generate(:symbols => :only).should eql("))/*#*)(\#@")
+  end
+
+  it "should return password with lowercase and uppercase chars only" do
+    Passgen::generate(:digits => false).should eql("OpTiwRslOh")
+  end
+
+  it "should return password with lowercase and digit chars only" do
+    Passgen::generate(:uppercase => false).should eql("piwslh85lv")
+  end
+
+  it "should return password with lowercase and symbol chars only" do
+    Passgen::generate(:uppercase => false, :digits => false, :symbols => true).should eql("piwslh)&lv")
+  end
+
+  it "should return password with uppercase and digit chars only" do
+    Passgen::generate(:lowercase => false).should eql("PIWSLH85LV")
+  end
+
+  it "should return password with uppercase and symbol chars only" do
+    Passgen::generate(:lowercase => false, :digits => false, :symbols => true).should eql("PIWSLH)&LV")
+  end
+
+  it "should return password with digit and symbol chars only" do
+    Passgen::generate(:lowercase => false, :uppercase => false, :symbols => true).should eql("8&$8@)@872")
+  end
+
+  it "should return password with lowercase, uppercase and digit chars only" do
+    Passgen::generate.should eql("OpTiwRslOh")
+  end
+
+  it "should return password with lowercase, uppercase and symbol chars only" do
+    srand(3)
+    Passgen::generate(:digits => false, :symbols => true).should eql("Qy&d%iav+t")
+  end
+
+  it "should return password with lowercase, digit and symbol chars only" do
+    srand(4)
+    Passgen::generate(:uppercase => false, :symbols => true).should eql("?fb%xij$+4")
+  end
+
+  it "should return password with uppercase, digit and symbol chars only" do
+    srand(4)
+    Passgen::generate(:lowercase => false, :symbols => true).should eql("?FB%XIJ$+4")
+  end
+  
+  it "should return given number of passwords in an Array" do
+    Passgen::generate(:number => 3).should eql(["OpTiwRslOh", "IXFlvVFAu8", "0LNdMeQRZN"])
+  end
+
+  it "should return a password with given length" do
+    Passgen::generate(:length => 8).should eql("OpTiwRsl")
+  end
+
+  it "should return several passwords of variable length" do
+    Passgen::generate(:length => 3..12, :number => 2).should eql(["pTiwRslOhIX", "VFAu80LN"])
+  end
+
+  it "should use given seed" do
+    pass1 = Passgen::generate(:seed => 5)
+    pass2 = Passgen::generate(:seed => 5)
+    pass1.should eql(pass2)
+  end
+
+  it "should set seed to Time.now + Process.id" do
+    pass1 = Passgen::generate(:seed => :default)
+    pass2 = Passgen::generate(:seed => :default)
+    pass1.should_not eql(pass2)
+  end
+
+  describe "handling tokens" do
+
+    it "should return a-z" do
+      Passgen::LOWERCASE_TOKENS.should eql(("a".."z").to_a)
+    end
+
+    it "should return A-Z" do
+      Passgen::UPPERCASE_TOKENS.should eql(("A".."Z").to_a)
+    end
+
+    it "should return 0-9" do
+      Passgen::DIGIT_TOKENS.should eql(("0".."9").to_a)
+    end
+
+    it "should return default symbols" do
+      Passgen::symbol_tokens.should eql(%w{! @ # $ % & / ( ) + ? *})
+    end
+
+  end
+
+  describe "pronounceable" do
+    it "should return a pronounceable lower case password" do
+      Passgen::generate(:pronounceable => true, :lowercase => :only).should == "ishanghter"
+    end
+
+    it "should return a pronounceable upper case password" do
+      Passgen::generate(:pronounceable => true, :uppercase => :only).should == "ISHANGHTER"
+    end
+
+    it "should return a pronounceable mixed case password" do
+      Passgen::generate(:pronounceable => true).should == "iShfIeRBAt"
+    end
+    
+    it "should return a pronounceable mixed case password of length 7" do
+      Passgen::generate(:pronounceable => true, :length => 7).should == "IShfIeR"
+    end
+    
+    it "should return a pronounceable password with 3 digits in front" do
+      Passgen::generate(:pronounceable => true, :digits_before => 3).should == "886uRApLIN"
+    end
+
+    it "should return a pronounceable password with default 2 digits in front" do
+      Passgen::generate(:pronounceable => true, :digits_before => true).should == "88mpICePED"
+    end
+
+    it "should return a pronounceable password with 3 digits at the end" do
+      Passgen::generate(:pronounceable => true, :digits_after => 3).should == "uRAPLIN886"
+    end
+
+    it "should return a pronounceable password with default 2 digits at the end" do
+      Passgen::generate(:pronounceable => true, :digits_after => true).should == "mPICEPED88"
+    end
+
+  end
+end