pog19 1.1.1

data/test/tc_password_tests.rb

@@ -0,0 +1,209 @@
+# Copyright (c) 2007 Operis Systems, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'test/unit'
+require File.join( File.dirname(__FILE__), '..', 'lib', 'pog.rb' )
+
+class TC_PasswordTests < Test::Unit::TestCase
+  def test_length
+    tests = get_password_tests({ :bad => 'fubar', :good => 'foobar', :extra_good => 'foobar0' }, 
+                               { :test_length => 6 })
+                      
+    make_assertions_on_tests tests, :test_length
+  end
+  
+  def test_minimum_alphas
+    tests = get_password_tests({ :bad => 'f00', :good => 'fo0', :extra_good => 'foo' }, 
+                               { :test_minimum_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_alphas
+  end
+  
+  def test_maximum_alphas
+    tests = get_password_tests({ :bad => 'foo', :good => 'fo0', :extra_good => 'f00' }, 
+                               { :test_maximum_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_alphas
+  end
+  
+  def test_minimum_upper_alphas
+    tests = get_password_tests({ :bad => 'Foo', :good => 'FOo', :extra_good => 'FOO' }, 
+                               { :test_minimum_upper_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_upper_alphas
+  end
+  
+  def test_maximum_upper_alphas
+    tests = get_password_tests({ :bad => 'FOO', :good => 'FOo', :extra_good => 'Foo' }, 
+                               { :test_maximum_upper_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_upper_alphas
+  end
+  
+  def test_minimum_lower_alphas
+    tests = get_password_tests({ :bad => 'FOo', :good => 'Foo', :extra_good => 'foo' }, 
+                               { :test_minimum_lower_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_lower_alphas
+  end
+  
+  def test_maximum_lower_alphas
+    tests = get_password_tests({ :bad => 'foo', :good => 'Foo', :extra_good => 'FOo' }, 
+                               { :test_maximum_lower_alphas => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_lower_alphas
+  end
+  
+  def test_minimum_numerals
+    tests = get_password_tests({ :bad => 'fo0', :good => 'f00', :extra_good => '000' }, 
+                               { :test_minimum_numerals => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_numerals
+  end
+  
+  def test_maximum_numerals
+    tests = get_password_tests({ :bad => '000', :good => 'f00', :extra_good => 'fo0' }, 
+                               { :test_maximum_numerals => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_numerals
+  end
+  
+  def test_minimum_non_alphanumeric
+    tests = get_password_tests({ :bad => 'fo@', :good => 'f@@', :extra_good => '@@@' }, 
+                               { :test_minimum_non_alphanumeric => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_non_alphanumeric
+  end
+  
+  def test_maximum_non_alphanumeric
+    tests = get_password_tests({ :bad => '@@@', :good => 'f@@', :extra_good => 'fo@' }, 
+                               { :test_maximum_non_alphanumeric => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_non_alphanumeric
+  end
+  
+  def test_maximum_non_alpha
+    tests = get_password_tests({ :bad => '@@@', :good => 'f@@', :extra_good => 'fo@' }, 
+                               { :test_maximum_non_alpha => 2 })
+                      
+    make_assertions_on_tests tests, :test_maximum_non_alpha
+  end
+  
+  def test_minimum_non_alpha
+    tests = get_password_tests({ :bad => 'foo', :good => 'f@@', :extra_good => 'fo@b#$' }, 
+                               { :test_minimum_non_alpha => 2 })
+                      
+    make_assertions_on_tests tests, :test_minimum_non_alpha
+  end
+  
+  def test_run
+    tests = PasswordTests.new( 'FooBar', :test_length => 8, 
+                                         :test_minimum_alphas => 2 )
+
+    assert_equal({ :test_length => false, 
+                   :test_minimum_alphas => true }, tests.run)
+  end
+  
+  def test_repetitions
+    assert PasswordTests.repetitions('fobar').empty?
+    
+    assert_equal( {'o'=>1}, 
+                  PasswordTests.repetitions('foobar') )
+    
+    assert_equal( {'o'=>3, 'oo'=>1}, 
+                  PasswordTests.repetitions('fooboo') )
+    
+    assert_equal( {'f' => 1, 'o'=>3, 'oo'=>1, 'foo'=>1}, 
+                  PasswordTests.repetitions('foofoo') )
+  end
+  
+  def test_qualitative_strength
+    assert_operator 0, :== , PasswordTests.qualitative_strength( '123456' )
+    
+    assert_operator 0, :== , PasswordTests.qualitative_strength( 'foo' )
+    
+    assert_operator 0, :<= , PasswordTests.qualitative_strength( 'fooo' )
+  end
+  
+  def test_entropy
+    assert_operator 3.3, :< , PasswordTests.entropy( '1' )
+    
+    assert_operator 4.7, :< , PasswordTests.entropy( 'f' )
+    
+    assert_operator 5.0, :< ,PasswordTests.entropy( '$' )
+    
+    assert_operator 6.6, :< ,PasswordTests.entropy( '12' )
+  end
+  
+  def test_default_levels
+    # low
+    assert_equal({:test_length=>true, :test_minimum_alphas=>false}, PasswordTests.new('123456', :low).run)
+    assert_equal({:test_length=>true, :test_minimum_alphas=>true}, PasswordTests.new('f123456', :low).run)
+    assert_equal({:test_length=>true, :test_minimum_alphas=>true}, PasswordTests.new('fo0bar', :low).run)
+
+    # medium-low
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>false, :test_minimum_alphas=>true}, 
+                 PasswordTests.new('abcdefgh', :medium_low).run)
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>true, :test_minimum_alphas=>true}, 
+                 PasswordTests.new('abcdefgh0', :medium_low).run)
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>true, :test_minimum_alphas=>true}, 
+                 PasswordTests.new('fo0barf00', :medium_low).run)
+
+    # medium-high
+    assert_equal({:test_length=>true, :test_minimum_upper_alphas=>false, :test_minimum_non_alpha=>false, :test_minimum_lower_alphas=>true},
+                 PasswordTests.new('abcdefgh', :medium_high).run)
+    assert_equal({:test_length=>true, :test_minimum_upper_alphas=>true, :test_minimum_non_alpha=>true, :test_minimum_lower_alphas=>true},
+                 PasswordTests.new('Abcdefgh0', :medium_high).run)
+    assert_equal({:test_length=>true, :test_minimum_upper_alphas=>true, :test_minimum_non_alpha=>true, :test_minimum_lower_alphas=>true},
+                 PasswordTests.new('fo0barF00', :medium_high).run)
+
+    # The default level should be medium_low
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>false, :test_minimum_alphas=>true}, PasswordTests.new('abcdefgh').run)
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>true, :test_minimum_alphas=>true}, PasswordTests.new('abcdefgh0').run)
+    assert_equal({:test_length=>true, :test_minimum_non_alpha=>true, :test_minimum_alphas=>true}, PasswordTests.new('fo0barf00').run)
+
+    # high
+    assert_equal({:test_minimum_numerals=>false, :test_length=>true, :test_minimum_upper_alphas=>false, :test_minimum_lower_alphas=>true,
+                  :test_minimum_non_alphanumeric=>false}, PasswordTests.new('abcdefgh', :high).run)
+    assert_equal({:test_minimum_numerals=>true, :test_length=>true, :test_minimum_upper_alphas=>true, :test_minimum_lower_alphas=>true,
+                  :test_minimum_non_alphanumeric=>true}, PasswordTests.new('Abcdefgh0#', :high).run)
+    assert_equal({:test_minimum_numerals=>true, :test_length=>true, :test_minimum_upper_alphas=>true, :test_minimum_lower_alphas=>true,
+                  :test_minimum_non_alphanumeric=>true}, PasswordTests.new('fo0barF##', :high).run)
+    
+    # invalid level
+    assert_raise(RuntimeError) { PasswordTests.new('fooey', :foobar) }
+  end
+  
+  private
+  
+  ##
+  # Gets a hash of PasswordTests classes for each of the given passwords in the
+  # test_password_hash with the given test_hash
+  #
+  def get_password_tests( test_password_hash , test_hash )
+    tests = Hash.new { |hash, key| 
+      hash[key] = PasswordTests.new( test_password_hash[key], test_hash ) }
+    test_password_hash.each_key { |name| tests[name] }
+    return tests
+  end
+  
+  ##
+  # Executes the given method on the cases :bad, :good, and :extra_good and 
+  # asserts that :bad is false, and :good and :extra_good are true
+  #
+  def make_assertions_on_tests( tests, method )
+    assert_equal false, tests[:bad].__send__(        method )
+    assert_equal true,  tests[:good].__send__(       method )
+    assert_equal true,  tests[:extra_good].__send__( method )
+  end
+end

data/test/tc_random_string_generator.rb

@@ -0,0 +1,133 @@
+# Copyright (c) 2007 Operis Systems, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'test/unit'
+require File.join( File.dirname(__FILE__), '..', 'lib', 'pog.rb' )
+
+class TC_PasswordTests < Test::Unit::TestCase
+  def test_shuffle_string
+    str = "qwertyuiopQWERTYUIOP"
+    str_freq = frequencies(str)
+    str_2 = RandomStringGenerator.shuffle_string str
+    assert_not_equal str_2, str
+    assert_equal frequencies(str_2), frequencies(str)
+  end
+  
+  def frequencies( str )
+    r = {}
+    for i in 0...str.length do
+      c = str[i]
+      if r[c]
+        r[c] += 1
+      else
+        r[c] = 1
+      end
+    end
+  end
+  
+  def test_rand_char
+    rsg = RandomStringGenerator.new
+    rsg.set_characters_array
+    assert_not_nil rsg.rand_char
+  end
+  
+  def test_rand_char_with_delete
+    rsg = RandomStringGenerator.new(2, :special => 'abd')
+    rsg.set_characters_array
+    3.times do
+      assert_not_nil rsg.rand_char( true )
+    end
+    
+    rsg = RandomStringGenerator.new(2, :special => 'abd')
+    rsg.set_characters_array
+    3.times do
+      assert_nothing_raised { rsg.rand_char( true ) }
+    end
+    assert_raise RuntimeError do 
+      rsg.rand_char( true )
+    end 
+  end
+  
+  def test_noduplicates_safety
+    rsg = RandomStringGenerator.new(3, :special => 'ab', :no_duplicates => true)
+    assert_raise RuntimeError do
+      rsg.generate
+    end
+  end
+  
+  def test_generation
+    rsg = RandomStringGenerator.new
+    assert_not_nil rsg.generate
+    
+    rsg.set_option :single_quotes => true, :double_quotes => true, :backtick => true
+    
+    assert_not_nil rsg.generate
+    assert_equal rsg.generate.length, 8
+    
+    rsg = RandomStringGenerator.new(9, :all => true)
+
+    assert_not_nil rsg.generate
+    assert_equal rsg.generate.length, 9
+
+    rsg = RandomStringGenerator.new(10, :all_except_quotes => true)
+
+    assert_not_nil rsg.generate
+    assert_equal rsg.generate.length, 10
+
+    rsg.set_option :special => 5
+    assert_raise(ArgumentError) { rsg.set_characters_array }
+  end
+  
+  def test_bad_range
+    rsg = RandomStringGenerator.new
+    assert_raise(ArgumentError) { rsg.range('foo') }
+  end
+  
+  def test_wep_generation
+    ascii64_wep = RandomStringGenerator.generate_wep(64,:ascii)
+    ascii128_wep = RandomStringGenerator.generate_wep(128,:ascii)
+    hex152_wep  = RandomStringGenerator.generate_wep(152)
+    hex256_wep  = RandomStringGenerator.generate_wep(256)
+    
+    assert_not_nil ascii64_wep
+    assert_not_nil ascii128_wep
+    assert_not_nil hex152_wep
+    assert_not_nil hex256_wep
+    
+    assert_equal ascii64_wep.length, 5
+    assert_equal ascii128_wep.length, 13
+    assert_equal hex152_wep.length, 32
+    assert_equal hex256_wep.length, 58
+    
+    assert_raise(RuntimeError) { RandomStringGenerator.generate_wep(152, :not_a_type) }
+  end
+  
+  def test_attrs
+    rsg = RandomStringGenerator.new
+    
+    assert_equal rsg.length, 8
+    rsg.length = 7
+    assert_equal rsg.length, 7
+
+    assert_equal rsg.options, {:lower_alphas => true,
+                               :upper_alphas => true,
+                               :numerals     => true,
+                               :no_duplicates=> false }
+    rsg.set_option :symbols => false, :no_duplicates=> true
+    assert_equal rsg.options, {:lower_alphas => true,
+                               :upper_alphas => true,
+                               :numerals     => true,
+                               :no_duplicates=> true,
+                               :symbols => false }
+  end
+end

data/test/tc_salt.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2007 Operis Systems, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'test/unit'
+require 'base64'
+require File.join( File.dirname(__FILE__), '..', 'lib', 'pog.rb' )
+
+TEST_PASS = '/O0op;G75wu3saMv|N9&DA?I*/!3-gqHUe9{VZL{M3YVoYUQ]6q{]Poz%c)V#T,i=g.G8>&'
+TEST_SALT = 'foobar'
+
+class TC_Salt < Test::Unit::TestCase
+  
+  def test_new
+    salt = Salt.new( TEST_SALT )
+    assert_equal :end, salt.placement
+    
+    salt = Salt.new( TEST_SALT, :beginning )
+    assert_equal :beginning, salt.placement
+    
+    salt = Salt.new( :new, :end, :length => 8 )
+    assert_not_nil salt.string
+    assert_equal 8, salt.string.length
+    assert_equal :end, salt.placement
+  end
+  
+  def test_generate_str
+    for len in -32..32
+      salt = Salt.generate_str( len )
+      assert salt.length == (len >= 0 ? len : 0), "test_generate_salt failed for length #{len}"
+    end
+  end
+  
+  def test_salt_password
+    salt = Salt.new( TEST_SALT, :beginning )
+    assert_equal  TEST_SALT + TEST_PASS, 
+                  salt.salt_password( TEST_PASS ),
+                  "test_salt_password failed for beginning"
+    
+    salt = Salt.new( TEST_SALT, :end )
+    assert_equal  TEST_PASS + TEST_SALT, 
+                  salt.salt_password( TEST_PASS ),
+                  "test_salt_password failed for end"
+    
+    salt = Salt.new( "foobar", :split )
+    assert_equal  'foo' + TEST_PASS + 'bar',
+                  salt.salt_password( TEST_PASS ),
+                  "test_salt_password failed for even split"
+    
+    salt = Salt.new( 'fooba', :split )
+    assert_equal  'fo' + TEST_PASS + 'oba',
+                  salt.salt_password( TEST_PASS ),
+                  "test_salt_password failed for odd split"
+   
+  end
+ 
+  def test_setters
+    salt = Salt.new
+    salt.string = TEST_SALT
+    assert_equal salt.string, TEST_SALT
+    
+    salt.placement = 'foo'
+    assert_equal salt.placement, :foo
+    
+    assert_raise RuntimeError do 
+      salt.salt_password 'foo'
+    end 
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: pog19
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 1
+  version: 1.1.1
+platform: ruby
+authors: 
+- Operis Systems, LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-06 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A Ruby gem for simplifying random password generation, password strength testing, password hashing and salting, and password-hash authentication.
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- lib/character_ranges.rb
+- lib/encoding_translation.rb
+- lib/password.rb
+- lib/password_tests.rb
+- lib/pog.rb
+- lib/random_string_generator.rb
+- lib/salt.rb
+- lib/string.rb
+- LICENSE
+- NOTICE
+- pog1-9.gemspec
+- Rakefile
+- README
+- SECURITY
+- test/tc_password.rb
+- test/tc_password_tests.rb
+- test/tc_random_string_generator.rb
+- test/tc_salt.rb
+- VERSION
+has_rdoc: true
+homepage: http://pog.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --all
+- --inline-source
+- --main
+- lib/*.rb
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pog
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby gem for simplifying random password generation
+test_files: []
+