keybox 1.0.0

data/spec/kpg_app_spec.rb

@@ -0,0 +1,132 @@
+require 'keybox'
+require 'keybox/application/password_generator'
+
+context "Keybox Password Generator Application" do
+    setup do
+    end
+
+    specify "nil argv should do nothing" do
+        kpg = Keybox::Application::PasswordGenerator.new(nil)
+        kpg.error_message.should_be nil
+    end
+
+    specify "invalid options set the error message, exit 1 and have output on stderr" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--invalid-option"])
+        kpg.stderr = StringIO.new
+        begin
+            kpg.run
+        rescue SystemExit => se
+            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            se.status.should == 1
+        end
+    end
+
+    specify "can set the algorithm" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--alg", "pron"])
+        kpg.stdout = StringIO.new
+        kpg.run
+        kpg.options.algorithm.should == :pronounceable
+    end
+    
+    specify "can specify the number of passwords created " do
+        kpg = Keybox::Application::PasswordGenerator.new(["--num", "4"])
+        kpg.stdout = StringIO.new
+        kpg.run
+        kpg.options.number_to_generate.should_eql 4
+        kpg.stdout.string.split(/\s+/).size.should == 4
+    end
+
+    specify "help has output on stdout and exits 0" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--h"]) 
+        kpg.stdout = StringIO.new
+        begin
+            kpg.run
+        rescue SystemExit => se
+            se.status.should_eql 0
+            kpg.stdout.string.length.should_be > 0
+        end
+        kpg.stdout.string.should_satisfy { |msg| msg =~ /--help/m }
+    end
+
+    specify "version has output on stdout and exits 0" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--version"]) 
+        kpg.stdout = StringIO.new
+        begin
+            kpg.run
+        rescue SystemExit => se
+            se.status.should_eql 0
+        end
+        kpg.stdout.string.should_satisfy { |msg| msg =~ /version 1.0.0/m }
+    end
+
+    specify "minimum length can be set and all generated passwords will have length >= minimum length" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--min", "4"]) 
+        kpg.stdout = StringIO.new
+        kpg.run
+
+        kpg.options.min_length.should_eql 4
+        kpg.stdout.string.split("\n").each do |pass|
+            pass.length.should_satisfy { |s| s >= kpg.options.min_length }
+        end
+    end
+
+    specify "maximum length can be set and all generated passwords will have length <= maximum length" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--max", "4", "--min", "3"]) 
+        kpg.stdout = StringIO.new
+        kpg.run
+
+        kpg.options.max_length.should_eql 4
+        kpg.stdout.string.split("\n").each do |pass|
+            pass.length.should_satisfy { |s| s <= 4 }
+        end
+    end
+
+    specify "setting an invalid required symbol set exits 1 and outputs data on stderr" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--req","bunk"])
+        kpg.stderr = StringIO.new
+        begin
+            kpg.run
+        rescue SystemExit => se
+            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            se.status.should == 1
+        end
+ 
+    end
+
+    specify "setting an invalid use symbol set exits 1 and outputs data on stderr" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--use","bunk"])
+        kpg.stderr = StringIO.new
+        begin
+            kpg.run
+        rescue SystemExit => se
+            kpg.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            kpg.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
+            se.status.should == 1
+        end
+ 
+    end
+
+    specify "setting an valid use symbol works" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--use","l"])
+        kpg.stdout = StringIO.new
+        kpg.run
+        kpg.options.use_symbols.should_include Keybox::SymbolSet::LOWER_ASCII
+        kpg.stdout.string.split(/\s+/).size.should == 6
+    end
+
+    specify "setting an valid required symbol works" do
+        kpg = Keybox::Application::PasswordGenerator.new(["--req","l"])
+        kpg.stdout = StringIO.new
+        kpg.run
+        kpg.options.require_symbols.should_include Keybox::SymbolSet::LOWER_ASCII
+        kpg.stdout.string.split(/\s+/).size.should == 6
+    end
+
+
+
+
+
+end
+

data/spec/password_hash_spec.rb

@@ -0,0 +1,11 @@
+require 'keybox'
+context "PasswordHash" do
+    setup do 
+        @pwd_hash = Keybox::PasswordHash.new("i love ruby")
+    end
+
+    specify "creates string for password" do
+        pwd = @pwd_hash.password_for_url("http://www.nytimes.com")
+        pwd.should == "2f85a2e2f"
+    end
+end

data/spec/randomizer_spec.rb

@@ -0,0 +1,116 @@
+require 'keybox/randomizer'
+
+context "a random device class" do
+    specify "should have a default source" do
+        Keybox::RandomDevice.default.should_eql "/dev/urandom" 
+    end
+
+    specify "should produce strings" do
+        Keybox::RandomDevice.random_bytes.should_be_an_instance_of(String)
+    end
+
+    specify "should produce strings of a given length" do
+        Keybox::RandomDevice.random_bytes(4).size.should_eql 4 
+    end
+
+    specify "should raise exception when given an invalid device" do
+        Proc.new {Keybox::RandomDevice.default = "/tmp/junk" }.should_raise ArgumentError
+    end
+
+    specify "should be able to assign a new default source" do
+        (Keybox::RandomDevice.default = "/dev/random").should_eql "/dev/random"
+        Keybox::RandomDevice.default = "/dev/urandom"
+    end
+end
+
+context "a random device instance" do
+    setup do
+        @random_device = Keybox::RandomDevice.new
+    end
+    specify "should have a source" do
+        @random_device.source.should_eql "/dev/urandom"
+    end
+
+    specify "should produce strings" do
+        @random_device.random_bytes.should_be_an_instance_of(String)
+    end
+
+    specify "should produce strings of a given length" do
+        @random_device.random_bytes(20).size.should_eql 20 
+    end
+
+    specify "should default to the RandomDevice default when given an invalid device " do 
+        rd = Keybox::RandomDevice.new("/tmp/bad-random-device")
+        rd.source.should_eql Keybox::RandomDevice.default
+    end
+
+    specify "should accept a valid readable device" do
+        rd = Keybox::RandomDevice.new("/dev/random")
+        rd.source.should_eql "/dev/random"
+    end
+end
+
+context "a random source class " do
+    setup do
+        @random_source_class = mock("JunkRandomSource")
+        @random_source_class.should_receive("random_bytes").at_least(0).times
+    end
+    specify "should have a default" do
+        Keybox::RandomSource.source.should_not_equal nil
+    end
+
+    specify "invalid default class should throw exception " do
+        lambda { Keybox::RandomSource.source = String }.should_raise ArgumentError
+    end
+
+    specify "valid class should allow default to be set" do
+        (Keybox::RandomSource.source = @random_source_class).should_eql @random_source_class
+        Keybox::RandomSource.source_classes.should_have(3).entries
+        Keybox::RandomSource.source_classes.delete(@random_source_class)
+        Keybox::RandomSource.source_classes.should_have(2).entries
+        Keybox::RandomSource.source.should_eql ::Keybox::RandomDevice
+    end
+
+    specify "rand with no parameters should return a value between 0 and 1" do
+        r = Keybox::RandomSource.rand
+        r.should_satisfy { |arg| arg >= 0.0 and arg < 1.0 }
+    end
+
+    specify "rand with parameters should return an integer value between 0 and that value" do
+        r = Keybox::RandomSource.rand(42)
+        r.should_be_a_kind_of(Integer)
+        r.should_be < 42
+    end
+end
+
+context "a randomzier instance" do 
+    setup do
+        @randomizer = Keybox::Randomizer.new
+        @hash       = { :stuff => "stuff", :things => "things" }
+        @array      = ["foo", "bar", "baz" ]
+    end
+    specify "should have a default random source" do
+        @randomizer.random_source.should_not_be nil
+    end
+
+    specify "giving an invalid default random source should raise an exception" do
+        lambda { r = Keybox::Randomizer.new(Array) }.should_raise ArgumentError
+    end
+
+    specify "picking from a non-array should raise an exception" do
+        lambda { @randomizer.pick_count_from(@hash) }.should_raise ArgumentError
+    end
+
+    specify "picking one from an array should be okay" do
+        @randomizer.pick_one_from(@array).should_satisfy do |x|
+            @array.include?(x)
+        end
+    end
+
+    specify "picking N from an array should result in an array" do
+        @randomizer.pick_count_from(@array,3).should_have(3).entries
+        @randomizer.pick_count_from(@array,9).each do |arg|
+            @array.should_include(arg)
+        end
+    end
+end

data/spec/storage_container_spec.rb

@@ -0,0 +1,99 @@
+require 'keybox'
+require 'keybox/storage'
+require 'keybox/error'
+require 'keybox/entry'
+require 'openssl'
+require 'tempfile'
+require 'yaml'
+
+context 'a storage container' do
+    setup do
+        @passphrase  = "i love ruby"
+        @keybox_file = Tempfile.new("keybox").path
+        @testing_file = "/tmp/testing.yml"
+        @container   = Keybox::Storage::Container.new(@passphrase, @keybox_file)
+        @container << Keybox::HostAccountEntry.new("test account","localhost","guest", "rubyrocks")
+        @container << Keybox::URLAccountEntry.new("the times", "http://www.nytimes.com", "rubyhacker")
+        @container.save
+    end
+
+    teardown do
+        File.unlink(@testing_file) if File.exists?(@testing_file)
+        File.unlink(@keybox_file) if File.exists?(@keybox_file)
+    end
+
+    specify 'should have a uuid' do
+        @container.uuid.should_satisfy { |uuid| uuid.to_s.length == 36 }
+    end
+
+    specify 'should have a valid key ' do
+        @container.key_digest.should_satisfy { |kd| kd.length == 64 }
+    end
+
+    specify 'should save correctly to a file' do
+        @container.save(@testing_file)
+        File.size(@testing_file).should_satisfy { |s| s > 0 }
+    end
+
+    specify "should load correctly from a file" do
+        @container.save(@testing_file)
+        new_container = Keybox::Storage::Container.new(@passphrase,@testing_file)
+        new_container.should_be_not_modified
+        new_container.uuid.should == @container.uuid
+    end
+
+    specify "should validate passphrase" do
+        nc = Keybox::Storage::Container.new("i love ruby", @keybox_file)
+        nc.save(@testing_file)
+        nc.key_digest.should_eql @container.key_digest
+        lambda { Keybox::Storage::Container.new("i hate ruby", @testing_file) }.should_raise Keybox::ValidationError
+
+    end
+
+    specify "url accounts should have the correct password after save" do
+        @container.save(@testing_file)
+        new_container = Keybox::Storage::Container.new(@passphrase, @testing_file)
+        recs = new_container.find_by_url("nytimes")
+        new_container.records.size.should_eql 2
+        recs.size.should_eql 1
+        recs[0].password.should == "2f85a2e2f"
+    end
+
+    specify "can find matching records" do
+        matches = @container.find(/times/)
+        matches.size.should_be 1
+    end
+
+    specify "changing the password is safe" do
+        @container.save(@testing_file)
+        copy_of_container= Keybox::Storage::Container.new(@passphrase, @testing_file)
+        times_1 = copy_of_container.find_by_url("nytimes").first
+
+        @container.passphrase = "I love ruby too!"
+        @container.save(@keybox_file)
+        @container = Keybox::Storage::Container.new("I love ruby too!", @keybox_file)
+        times_2 = @container.find_by_url("nytimes").first
+        times_1.should_eql times_2
+    end
+
+    specify "should not be modified upon load" do 
+        @container.modified?.should_eql false
+    end
+
+    specify "a modified db can be detected" do
+        l1 = @container.find("localhost").first
+        l1.username = "new username"
+        @container.modified?.should_eql true
+    end
+
+    specify "deleting an item should modify the container" do
+        ll = @container.find("localhost").first
+        @container.delete(ll)
+        @container.modified?.should_eql true
+    end
+
+    specify "able to see how many items are in the container" do
+        @container.size.should_eql 2
+        @container.length.should_eql 2
+    end
+end

data/spec/storage_record_spec.rb

@@ -0,0 +1,63 @@
+require 'keybox/storage'
+
+context 'a storage record entry' do
+    setup do
+        @data_fields = %w(title username password url additional_data)
+    end
+    specify 'has a creation date set on instantiation' do
+        e = Keybox::Storage::Record.new
+        e.creation_time.should_be_instance_of(Time)
+    end
+
+    specify "assigning to a non-existant field creates the appropriate member " do
+        e = Keybox::Storage::Record.new
+        e.junk = "junk"
+        e.junk.should == "junk"
+    end
+
+    specify 'default values for non-existant fields is nil' do 
+        e = Keybox::Storage::Record.new
+        @data_fields.each do |f|
+            e.send(f).should_be  nil
+        end
+    end
+
+    specify "assigning to a field makes the modification time > creation time" do
+        e = Keybox::Storage::Record.new
+        sleep 1
+        e.testing = "testing"
+        e.modification_time.should_satisfy { |m| m > e.creation_time }
+        e.last_access_time.should == e.modification_time
+    end
+
+    specify "reading a field after assignment the access time > modification time " do
+        e = Keybox::Storage::Record.new
+        e.testing = "testing"
+        sleep 1
+        e.testing
+        e.last_access_time.should_satisfy { |la| la > e.creation_time }
+        e.last_access_time.should_satisfy { |la| la > e.modification_time }
+    end
+
+    specify "assigning to a modification, creation or acces_time should raise and exception " do
+        e = Keybox::Storage::Record.new
+        lambda {e.modification_time = Time.now}.should_raise NoMethodError
+    end
+
+    specify "assiging multiple items should raise an argument exception" do
+        e = Keybox::Storage::Record.new
+        lambda {e.send(:stuff=,1,2)}.should_raise ArgumentError
+    end
+
+    specify "calling a method with arguments should raise exception" do
+        e = Keybox::Storage::Record.new
+        lambda {e.stuff(1,2)}.should_raise NoMethodError
+    end
+
+    specify "comparison between records is valid" do
+        e = Keybox::Storage::Record.new
+        f = e.dup
+        e.should_eql e.uuid
+        e.should_eql f
+    end
+end

data/spec/string_generator_spec.rb

@@ -0,0 +1,114 @@
+require 'keybox'
+context "string generator" do
+    setup do
+        @generator = Keybox::StringGenerator.new
+    end
+
+    specify "should not be used alone" do
+        lambda { @generator.generate }.should_raise Keybox::KeyboxError
+    end
+
+    specify "cannot have a min length greater than a max length" do
+        @generator.min_length = 90
+        lambda { @generator.generate }.should_raise Keybox::ValidationError
+        @generator.min_length = 8
+    end
+    
+    specify "cannot have a max length less than a min length" do
+        @generator.max_length = 2
+        lambda { @generator.generate }.should_raise Keybox::ValidationError
+        @generator.max_length = 10
+    end
+
+    specify "initially there are no chunks" do
+        @generator.chunks.should_have(0).entries
+    end
+end
+
+context "chargram generator" do
+    setup do 
+        @generator = Keybox::CharGramGenerator.new
+    end
+
+    specify "should have a positive size" do
+        @generator.size.should_be > 26
+    end
+
+    specify "should emit a string with length > 0" do
+        @generator.generate_chunk.size.should_be > 0
+    end
+
+    specify "should emit an array " do
+        @generator.generate_chunk.should_be_instance_of String
+    end
+
+    specify "2 succesive emits should have a common first and last character" do
+        one = @generator.generate_chunk
+        two = @generator.generate_chunk
+        one[-1].should == two[0]
+    end
+
+    specify "2 calls to generate_chunk should have a string that is 1 less than the 2 chunks" do
+        one = @generator.generate_chunk
+        two = @generator.generate_chunk
+        @generator.to_s.length.should == (one.length + two.length - 1)
+    end
+end
+
+context "SymbolSetGenerator" do
+    setup do 
+        @generator = Keybox::SymbolSetGenerator.new
+    end
+
+    specify "symbol sets have the right number or characters" do
+        Keybox::SymbolSetGenerator::ALL.size.should == 92
+    end
+
+    specify "generating chunks should produce an array" do
+        12.times do 
+            @generator.generate_chunk
+        end
+        @generator.chunks.should_have(12).entries
+    end
+
+    specify "generate should produce a string" do
+        @generator.generate.should_be_instance_of(String)
+        @generator.to_s.size.should_be > 0
+    end
+
+    specify "generating chunks can be cleared" do
+        @generator.generate
+        @generator.clear
+        @generator.chunks.should_have(0).entries
+    end
+
+    specify "min and max lengths are respected" do
+        @generator.max_length = 25
+        @generator.min_length = 25
+        @generator.generate.size.should_be == 25
+    end
+
+    specify "required sets are utilized" do
+        gen = Keybox::SymbolSetGenerator.new([Keybox::SymbolSet::NUMERAL_ASCII, Keybox::SymbolSet::LOWER_ASCII])
+        gen.required_sets << Keybox::SymbolSet::UPPER_ASCII
+        p = gen.generate
+        gen.required_sets.flatten.uniq.should_include(p[0].chr)
+    end
+    specify "required sets are merged with symbol sets" do
+        gen = Keybox::SymbolSetGenerator.new([Keybox::SymbolSet::NUMERAL_ASCII, Keybox::SymbolSet::LOWER_ASCII])
+        gen.required_sets << Keybox::SymbolSet::UPPER_ASCII
+        gen.required_sets.flatten.uniq.each do |c|
+            gen.symbols.should_include(c)
+        end
+    end
+
+    specify "generated passwords autoclear" do
+        @generator.generate.should_not == @generator.generate
+    end
+
+    specify "setting min and max should not affect " do
+        g = Keybox::SymbolSetGenerator.new(Keybox::SymbolSet::ALL)
+        g.generate.should_be_instance_of(String)
+    end
+
+end