encrypted_strings 0.0.4 → 0.0.5

data/{CHANGELOG → CHANGELOG.rdoc}

@@ -1,23 +1,25 @@
-*SVN*
+== master
 
-*0.0.4* (May 5th, 2008)
+== 0.0.5 / 2008-07-05
+
+* Add automatic stringification of salts for SHA encryption
+* Fix not resetting the encryptor after calling decrypt!
+
+== 0.0.4 / 2008-05-05
 
 * Updated documentation
 
-*0.0.3* (September 18th, 2007)
+== 0.0.3 / 2007-09-18
 
 * Remove gem dependency on activesupport
 
-*0.0.2* (August 23rd, 2007)
+== 0.0.2 / 2007-08-23
 
 * Fix not allowing the decryption mode to be overriden if the string already has an encryptor
-
 * Convert dos newlines to unix newlines
 
-*0.0.1* (August 5th, 2007)
+== 0.0.1 / 2007-08-05
 
 * Official public release
-
 * Add api documentation
-
 * Refactor unit test names

data/{README → README.rdoc}

@@ -4,21 +4,21 @@
 
 == Resources
 
-Wiki
-
-* http://wiki.pluginaweek.org/Encrypted_strings
-
 API
 
 * http://api.pluginaweek.org/encrypted_strings
 
+Bugs
+
+* http://pluginaweek.lighthouseapp.com/projects/13270-encrypted_strings
+
 Development
 
-* http://dev.pluginaweek.org/browse/trunk/encrypted_strings
+* http://github.com/pluginaweek/encrypted_strings
 
 Source
 
-* http://svn.pluginaweek.org/trunk/encrypted_strings
+* git://github.com/pluginaweek/encrypted_strings.git
 
 == Description
 
@@ -85,4 +85,4 @@ None.
 
 == References
 
-* Rick Olson - sentry[http://svn.techno-weenie.net/projects/plugins/sentry]
+* Rick Olson - sentry[http://github.com/technoweenie/sentry]

data/Rakefile

@@ -3,45 +3,54 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/contrib/sshpublisher'
 
-PKG_NAME           = 'encrypted_strings'
-PKG_VERSION        = '0.0.4'
-PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
-RUBY_FORGE_PROJECT = 'pluginaweek'
-
-desc 'Default: run unit tests.'
+spec = Gem::Specification.new do |s|
+  s.name              = 'encrypted_strings'
+  s.version           = '0.0.5'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Dead-simple string encryption/decryption syntax.'
+  
+  s.files             = FileList['{lib,test}/**/*'].to_a + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc)
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  
+  s.author            = 'Aaron Pfeifer'
+  s.email             = 'aaron@pluginaweek.org'
+  s.homepage          = 'http://www.pluginaweek.org'
+  s.rubyforge_project = 'pluginaweek'
+end
+  
+desc 'Default: run all tests.'
 task :default => :test
 
-desc 'Test the encrypted_strings plugin.'
+desc "Test the #{spec.name} plugin."
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
+  t.test_files = spec.test_files
   t.verbose = true
 end
 
-desc 'Generate documentation for the encrypted_strings plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'EncryptedStrings'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
 end
 
-spec = Gem::Specification.new do |s|
-  s.name            = PKG_NAME
-  s.version         = PKG_VERSION
-  s.platform        = Gem::Platform::RUBY
-  s.summary         = 'Dead-simple string encryption/decryption syntax.'
-  
-  s.files           = FileList['{lib,test}/**/*'].to_a + %w(CHANGELOG init.rb MIT-LICENSE Rakefile README)
-  s.require_path    = 'lib'
-  s.autorequire     = 'encrypted_strings'
-  s.has_rdoc        = true
-  s.test_files      = Dir['test/**/*_test.rb']
-  
-  s.author          = 'Aaron Pfeifer'
-  s.email           = 'aaron@pluginaweek.org'
-  s.homepage        = 'http://www.pluginaweek.org'
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
 end
   
 Rake::GemPackageTask.new(spec) do |p|
@@ -50,30 +59,30 @@ Rake::GemPackageTask.new(spec) do |p|
   p.need_zip = true
 end
 
-desc 'Publish the beta gem'
+desc 'Publish the beta gem.'
 task :pgem => [:package] do
-  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{PKG_FILE_NAME}.gem").upload
+  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
 end
 
-desc 'Publish the API documentation'
+desc 'Publish the API documentation.'
 task :pdoc => [:rdoc] do
-  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{PKG_NAME}", 'rdoc').upload
+  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
 end
 
 desc 'Publish the API docs and gem'
-task :publish => [:pdoc, :release]
+task :publish => [:pgem, :pdoc, :release]
 
 desc 'Publish the release files to RubyForge.'
 task :release => [:gem, :package] do
   require 'rubyforge'
   
-  ruby_forge = RubyForge.new
+  ruby_forge = RubyForge.new.configure
   ruby_forge.login
   
-  %w( gem tgz zip ).each do |ext|
-    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
     puts "Releasing #{File.basename(file)}..."
     
-    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
   end
 end

data/lib/encrypted_strings/asymmetric_encryptor.rb

@@ -44,7 +44,7 @@ module PluginAWeek #:nodoc:
     # default values will be used.  You can override the default values like so:
     # 
     #   password = "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
-    #   password.decrypt(:asymmetric, :public_key_file => "./encrypted_private.key", :key => "secret") # => "shhhh"
+    #   password.decrypt(:asymmetric, :public_key_file => "./encrypted_public.key", :key => "secret") # => "shhhh"
     # 
     # An exception will be raised if either the private key file could not be
     # found or the key could not decrypt the private key file.
@@ -61,9 +61,16 @@ module PluginAWeek #:nodoc:
       @@default_algorithm = nil
       cattr_accessor :default_algorithm
       
-      attr_reader   :private_key_file
-      attr_reader   :public_key_file
+      # Private key used for decrypting data
+      attr_reader :private_key_file
+      
+      # Public key used for encrypting data
+      attr_reader :public_key_file
+      
+      # The algorithm to use if the key files are encrypted themselves
       attr_accessor :algorithm
+      
+      # The key used during symmetric decryption of the key files
       attr_accessor :key
       
       # Configuration options:
@@ -80,22 +87,23 @@ module PluginAWeek #:nodoc:
           :algorithm
         )
         options.reverse_merge!(
-          :private_key_file => @@default_private_key_file,
-          :public_key_file => @@default_public_key_file,
-          :algorithm => @@default_algorithm
+          :private_key_file => self.class.default_private_key_file,
+          :public_key_file => self.class.default_public_key_file,
+          :algorithm => self.class.default_algorithm
         )
         
         @public_key = @private_key = nil
+        
         self.key = options[:key]
         self.algorithm  = options[:algorithm]
-        
         self.private_key_file = options[:private_key_file]
         self.public_key_file  = options[:public_key_file]
         
         super()
       end
       
-      # Encrypts the given data
+      # Encrypts the given data. If no public key file has been specified, then
+      # a NoPublicKeyError will be raised.
       def encrypt(data)
         raise NoPublicKeyError, "Public key file: #{public_key_file}" unless public?
         
@@ -103,7 +111,8 @@ module PluginAWeek #:nodoc:
         Base64.encode64(encrypted_data)
       end
       
-      # Decrypts the given data
+      # Decrypts the given data. If no private key file has been specified, then
+      # a NoPrivateKeyError will be raised.
       def decrypt(data)
         raise NoPrivateKeyError, "Private key file: #{private_key_file}" unless private?
         
@@ -121,23 +130,24 @@ module PluginAWeek #:nodoc:
         @public_key_file = file and load_public_key
       end
       
-      # Is this string encrypted using a public key?
+      # Does this encryptor have a public key available?
       def public?
-        return true unless @public_key.nil?
+        return true if @public_key
         
         load_public_key
         !@public_key.nil?
       end
       
-      # Is this string encrypted using a private key?
+      # Does this encryptor have a private key available?
       def private?
-        return true unless @private_key.nil?
+        return true if @private_key
         
         load_private_key
         !@private_key.nil?
       end
       
       private
+        # Loads the private key from the configured file
         def load_private_key
           @private_rsa = nil
           
@@ -146,6 +156,7 @@ module PluginAWeek #:nodoc:
           end
         end
         
+        # Loads the public key from the configured file
         def load_public_key
           @public_rsa = nil
           
@@ -154,7 +165,7 @@ module PluginAWeek #:nodoc:
           end
         end
         
-        # Retrieves private RSA from the private key
+        # Retrieves the private RSA from the private key
         def private_rsa
           if key
             private_key = @private_key.decrypt(:symmetric, :key => key, :algorithm => algorithm)

data/lib/encrypted_strings/encryptor.rb

@@ -1,7 +1,8 @@
 module PluginAWeek #:nodoc:
   module EncryptedStrings
-    # Represents an encryptor for strings.  Certain encryption algorithms
-    # do not allow for strings to be decrypted.
+    # Represents the base class for all encryptors.  By default, all encryptors
+    # are assumed to be able to decrypt strings.  Note, however, that certain
+    # encryption algorithms do not allow decryption.
     class Encryptor
       # Can this string be decrypted?  Default is true.
       def can_decrypt?

data/lib/encrypted_strings/extensions/string.rb

@@ -110,7 +110,9 @@ module PluginAWeek #:nodoc:
         #   password.decrypt!(:symmetric, :key => 'my_key') # => "shhhh"
         #   password                                        # => "shhhh"
         def decrypt!(*args)
-          replace(decrypt(*args))
+          value = replace(decrypt(*args))
+          self.encryptor = nil
+          value
         end
         
         # Can this string be decrypted?  Strings can only be decrypted if they

data/lib/encrypted_strings/sha_encryptor.rb

@@ -32,6 +32,7 @@ module PluginAWeek #:nodoc:
       @@default_salt = 'salt'
       cattr_accessor :default_salt
       
+      # The salt value to use for encryption
       attr_accessor :salt
       
       # Configuration options:
@@ -39,13 +40,14 @@ module PluginAWeek #:nodoc:
       def initialize(options = {})
         options = options.symbolize_keys
         options.assert_valid_keys(:salt)
-        options.reverse_merge!(:salt => @@default_salt)
-        @salt = options[:salt]
+        options.reverse_merge!(:salt => self.class.default_salt)
+        
+        self.salt = options[:salt].to_s
         
         super()
       end
       
-      # Decryption is not supported.
+      # Decryption is not supported
       def can_decrypt?
         false
       end

data/lib/encrypted_strings/symmetric_encryptor.rb

@@ -47,7 +47,10 @@ module PluginAWeek #:nodoc:
       @@default_key = nil
       cattr_accessor :default_key
       
+      # The algorithm to use for encryption/decryption
       attr_accessor :algorithm
+      
+      # The private key that seeds the algorithm
       attr_accessor :key
       
       # Configuration options:
@@ -59,8 +62,8 @@ module PluginAWeek #:nodoc:
           :key,
           :algorithm
         )
-        options.reverse_merge!(:key => @@default_key)
-        options[:algorithm] ||= @@default_algorithm
+        options.reverse_merge!(:key => self.class.default_key)
+        options[:algorithm] ||= self.class.default_algorithm
         
         self.key = options[:key]
         raise NoKeyError if key.nil?

data/test/asymmetric_encryptor_test.rb

@@ -1,97 +1,165 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class AsymmetricEncryptorTest < Test::Unit::TestCase
+class AsymmetricEncryptorByDefaultTest < Test::Unit::TestCase
   def setup
-    @data = 'encrypted_strings'
-    @key = 'secret'
-    @public_key_file = File.dirname(__FILE__) + '/keys/public'
-    @private_key_file = File.dirname(__FILE__) + '/keys/private'
-    @encrypted_public_key_file = File.dirname(__FILE__) + '/keys/encrypted_public'
-    @encrypted_private_key_file = File.dirname(__FILE__) + '/keys/encrypted_private'
-    
-    @encrypted_data = "NMGkkSu8dFdM455ru46b8TIkWQDHVdi4aJFZBCZ5p2VQV88OJnLBnnWYBXZk\n8HcyXzKb1I9lxuVHU/eZorGl7Q==\n"
-    @encrypted_data_with_encrypted_keys = "C6sJrSzSaVZ9gCPanUpUmSir5At6tMfBzPvJO/MXYJVJNxF3uKMy9IsJHqos\nz5tVAdyOUNBr3jroqFK22mdKqw==\n"
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = File.dirname(__FILE__) + '/keys/public'
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = File.dirname(__FILE__) + '/keys/private'
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_algorithm = 'DES-EDE3-CBC'
     
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
+  end
+  
+  def test_should_use_the_default_public_key_file
+    assert_equal File.dirname(__FILE__) + '/keys/public', @asymmetric_encryptor.public_key_file
+  end
+  
+  def test_should_use_the_default_private_key_file
+    assert_equal File.dirname(__FILE__) + '/keys/private', @asymmetric_encryptor.private_key_file
+  end
+  
+  def test_should_use_the_default_algorithm
+    assert_equal 'DES-EDE3-CBC', @asymmetric_encryptor.default_algorithm
+  end
+  
+  def test_should_not_have_a_key
+    assert_nil @asymmetric_encryptor.key
+  end
+  
+  def teardown
     PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = nil
     PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = nil
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_algorithm = nil
+  end
+end
+
+class AsymmetricEncryptorWithInvalidOptionsTest < Test::Unit::TestCase
+  def test_should_throw_an_exception
+    assert_raise(ArgumentError) {PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:invalid => true)}
+  end
+end
+
+class AsymmetricEncryptorTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
   end
   
-  def test_should_not_be_public_without_public_key_file
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
-    assert !encryptor.public?
+  def test_should_be_able_to_decrypt
+    assert @asymmetric_encryptor.can_decrypt?
+  end
+end
+
+class AsymmetricEncryptorWithoutPublicKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:public_key_file => nil)
   end
   
-  def test_should_not_be_private_without_privae_key_file
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
-    assert !encryptor.private?
+  def test_should_not_be_public
+    assert !@asymmetric_encryptor.public?
   end
   
-  def test_should_read_key_files
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
-      :public_key_file => @public_key_file,
-      :private_key_file => @private_key_file
-    )
-    assert encryptor.public?
-    assert encryptor.private?
+  def test_should_not_be_able_to_encrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPublicKeyError) {@asymmetric_encryptor.encrypt('test')}
+  end
+end
+
+class AsymmetricEncryptorWithPublicKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:public_key_file => File.dirname(__FILE__) + '/keys/public')
   end
   
-  def test_should_read_encrypted_key_files
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
-      :public_key_file => @encrypted_public_key_file,
-      :private_key_file => @encrypted_private_key_file
-    )
-    assert encryptor.public?
-    assert encryptor.private?
+  def test_should_be_public
+    assert @asymmetric_encryptor.public?
   end
   
-  def test_should_decrypt_files
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
-      :public_key_file => @public_key_file,
-      :private_key_file => @private_key_file
-    )
-    
-    assert_equal @data, encryptor.decrypt(@encrypted_data)
+  def test_should_not_be_private
+    assert !@asymmetric_encryptor.private?
   end
   
-  def test_should_decrypt_files_with_encrypted_key
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
-      :public_key_file => @encrypted_public_key_file,
-      :private_key_file => @encrypted_private_key_file,
-      :key => @key
-    )
-    
-    assert_equal @data, encryptor.decrypt(@encrypted_data_with_encrypted_keys)
+  def test_should_be_able_to_encrypt
+    assert_equal 90, @asymmetric_encryptor.encrypt('test').length
   end
   
-  def test_should_decrypt_files_with_default_key
-    set_default_key_files @public_key_file, @private_key_file
-    assert_equal @data, PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new.decrypt(@encrypted_data)
+  def test_should_not_be_able_to_decrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPrivateKeyError) {@asymmetric_encryptor.decrypt("HbEh0Hwri26S7SWYqO26DBbzfhR1h/0pXYLjSKUpxF5DOaOCtD9oRN748+Na\nrfNaVN5Eg7RUhbRFZE+UnNHo6Q==\n")}
+  end
+end
+
+class AsymmetricEncryptorWithoutPrivateKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:private_key_file => nil)
   end
   
-  def test_should_decrypt_files_with_default_encrypted_key
-    set_default_key_files @encrypted_public_key_file, @encrypted_private_key_file
-    assert_equal @data, PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:key => @key).decrypt(@encrypted_data_with_encrypted_keys)
+  def test_should_not_be_private
+    assert !@asymmetric_encryptor.private?
   end
   
-  def test_should_read_key_files_with_default_key
-    set_default_key_files @public_key_file, @private_key_file
-    
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
-    assert encryptor.private?
-    assert encryptor.public?
+  def test_should_not_be_able_to_decrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPrivateKeyError) {@asymmetric_encryptor.decrypt("NMGkkSu8dFdM455ru46b8TIkWQDHVdi4aJFZBCZ5p2VQV88OJnLBnnWYBXZk\n8HcyXzKb1I9lxuVHU/eZorGl7Q==\n")}
+  end
+end
+
+class AsymmetricEncryptorWithPrivateKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:private_key_file => File.dirname(__FILE__) + '/keys/private')
   end
   
-  def test_should_read_encrypted_key_files_with_default_key
-    set_default_key_files @encrypted_public_key_file, @encrypted_private_key_file
-    
-    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
-    assert encryptor.private?
-    assert encryptor.public?
+  def test_should_not_be_public
+    assert !@asymmetric_encryptor.public?
+  end
+  
+  def test_should_be_private
+    assert @asymmetric_encryptor.private?
+  end
+  
+  def test_not_should_be_able_to_encrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPublicKeyError) {@asymmetric_encryptor.encrypt('test')}
+  end
+  
+  def test_should_be_able_to_decrypt
+    assert_equal 'test', @asymmetric_encryptor.decrypt("HbEh0Hwri26S7SWYqO26DBbzfhR1h/0pXYLjSKUpxF5DOaOCtD9oRN748+Na\nrfNaVN5Eg7RUhbRFZE+UnNHo6Q==\n")
+  end
+end
+
+class AsymmetricEncryptorWithEncryptedPublicKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:public_key_file => File.dirname(__FILE__) + '/keys/encrypted_public')
+  end
+  
+  def test_should_be_public
+    assert @asymmetric_encryptor.public?
   end
   
-  private
-    def set_default_key_files(public_key, private_key)
-      PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = public_key
-      PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = private_key
-    end
+  def test_should_not_be_private
+    assert !@asymmetric_encryptor.private?
+  end
+  
+  def test_should_be_able_to_encrypt
+    assert_equal 90, @asymmetric_encryptor.encrypt('test').length
+  end
+  
+  def test_should_not_be_able_to_decrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPrivateKeyError) {@asymmetric_encryptor.decrypt("NMGkkSu8dFdM455ru46b8TIkWQDHVdi4aJFZBCZ5p2VQV88OJnLBnnWYBXZk\n8HcyXzKb1I9lxuVHU/eZorGl7Q==\n")}
+  end
+end
+
+class AsymmetricEncryptorWithEncryptedPrivateKeyTest < Test::Unit::TestCase
+  def setup
+    @asymmetric_encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(:private_key_file => File.dirname(__FILE__) + '/keys/encrypted_private', :algorithm => 'DES-EDE3-CBC', :key => 'secret')
+  end
+  
+  def test_should_not_be_public
+    assert !@asymmetric_encryptor.public?
+  end
+  
+  def test_should_be_private
+    assert @asymmetric_encryptor.private?
+  end
+  
+  def test_should_not_be_able_to_encrypt
+    assert_raise(PluginAWeek::EncryptedStrings::NoPublicKeyError) {@asymmetric_encryptor.encrypt('test')}
+  end
+  
+  def test_should_be_able_to_decrypt
+    assert_equal 'test', @asymmetric_encryptor.decrypt("oo6gLdPuPGmiAD83EKMiXkod5jvoN4JC8azGbCF/ludwuik4QT58DAsidqsN\n5Xu103JgRIZjRgDEhNhO6szfAA==\n")
+  end
 end

data/test/encryptor_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class EncryptorTest < Test::Unit::TestCase
+class EncryptorByDefaultTest < Test::Unit::TestCase
   def setup
     @encryptor = PluginAWeek::EncryptedStrings::Encryptor.new
   end

data/test/sha_encryptor_test.rb

@@ -1,16 +1,28 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class ShaEncryptorTest < Test::Unit::TestCase
+class ShaEncryptorByDefaulTest < Test::Unit::TestCase
   def setup
-    PluginAWeek::EncryptedStrings::ShaEncryptor.default_salt = 'salt'
+    @sha_encryptor = PluginAWeek::EncryptedStrings::ShaEncryptor.new
   end
   
-  def test_should_encrypt_with_default_salt_if_salt_not_specified
-    assert_equal 'f438229716cab43569496f3a3630b3727524b81b', PluginAWeek::EncryptedStrings::ShaEncryptor.new.encrypt('test')
+  def test_should_use_default_salt
+    assert_equal 'salt', @sha_encryptor.salt
   end
   
-  def test_should_encrypt_with_custom_salt_if_salt_specified
-    assert_equal '18e3256d71529db8fa65b2eef24a69ddad7070f3', PluginAWeek::EncryptedStrings::ShaEncryptor.new(:salt => 'different salt').encrypt('test')
+  def test_should_encrypt_using_default_salt
+    assert_equal 'f438229716cab43569496f3a3630b3727524b81b', @sha_encryptor.encrypt('test')
+  end
+end
+
+class ShaEncryptorWithInvalidOptionsTest < Test::Unit::TestCase
+  def test_should_throw_an_exception
+    assert_raise(ArgumentError) {PluginAWeek::EncryptedStrings::ShaEncryptor.new(:invalid => true)}
+  end
+end
+
+class ShaEncryptorTest < Test::Unit::TestCase
+  def setup
+    @sha_encryptor = PluginAWeek::EncryptedStrings::ShaEncryptor.new
   end
   
   def test_should_not_be_able_to_decrypt
@@ -21,3 +33,27 @@ class ShaEncryptorTest < Test::Unit::TestCase
     assert_raises(NotImplementedError) {PluginAWeek::EncryptedStrings::ShaEncryptor.new.decrypt('test')}
   end
 end
+
+class ShaEncryptorWithCustomSaltTest < Test::Unit::TestCase
+  def setup
+    @sha_encryptor = PluginAWeek::EncryptedStrings::ShaEncryptor.new(:salt => 'different salt')
+  end
+  
+  def test_should_use_custom_salt
+    assert_equal 'different salt', @sha_encryptor.salt
+  end
+  
+  def test_should_encrypt_using_custom_salt
+    assert_equal '18e3256d71529db8fa65b2eef24a69ddad7070f3', @sha_encryptor.encrypt('test')
+  end
+end
+
+class ShaEncryptorWithNonStringSaltTest < Test::Unit::TestCase
+  def setup
+    @sha_encryptor = PluginAWeek::EncryptedStrings::ShaEncryptor.new(:salt => Time.parse('Tue Jan 01 00:00:00 UTC 2008'))
+  end
+  
+  def test_should_stringify_salt
+    assert_equal 'Tue Jan 01 00:00:00 UTC 2008', @sha_encryptor.salt
+  end
+end

data/test/string_test.rb

@@ -1,105 +1,222 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class EncryptedStringsTest < Test::Unit::TestCase
-  def test_should_use_sha_for_default_encryption
-    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, 'test'.encrypt.encryptor
+class StringByDefaultTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt
   end
   
-  def test_should_use_configuration_options_for_default_encryption
-    encrypted_string = 'test'.encrypt(:salt => 'different_salt')
-    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, encrypted_string.encryptor
-    assert_equal 'different_salt', encrypted_string.encryptor.salt
+  def test_should_use_sha
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, @encrypted_string.encryptor
+  end
+end
+
+class StringWithCustomOptionsTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt(:salt => 'different_salt')
   end
   
-  def test_should_use_custom_encryptor_if_mode_specified
-    encrypted_string = 'test'.encrypt(:symmetric, :key => 'key')
-    assert_instance_of PluginAWeek::EncryptedStrings::SymmetricEncryptor, encrypted_string.encryptor
+  def test_should_use_sha
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, @encrypted_string.encryptor
   end
   
-  def test_should_replace_string_with_bang_encryption
-    encrypted_string = 'test'
-    encrypted_string.encrypt!
-    
-    assert !'test'.equals_without_encryption(encrypted_string)
-    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, encrypted_string.encryptor
+  def test_should_use_custom_options
+    assert_equal 'different_salt', @encrypted_string.encryptor.salt
+  end
+end
+
+class StringWithCustomEncryptor
+  def setup
+    @encrypted_string = 'test'.encrypt(:symmetric, :key => 'key')
   end
   
-  def test_should_be_encrypted_if_string_has_been_encrypted
-    assert 'test'.encrypt.encrypted?
+  def test_should_use_custom_encryptor
+    assert_instance_of PluginAWeek::EncryptedStrings::SymmetricEncryptor, @encrypted_string.encryptor
+  end
+end
+
+class StringTest < Test::Unit::TestCase
+  def setup
+    @string = 'test'
   end
   
-  def test_should_not_be_encrypted_if_string_has_not_been_encrypted
-    assert !'test'.encrypted?
+  def test_should_not_be_encrypted
+    assert !@string.encrypted?
   end
   
-  def test_should_not_be_encrypted_after_being_decrypted
-    encrypted_string = 'test'.encrypt(:symmetric, :key => 'secret')
-    decrypted_string = encrypted_string.decrypt
-    assert !decrypted_string.encrypted?
+  def test_should_not_have_an_encryptor
+    assert_nil @string.encryptor
   end
   
-  def test_should_use_encryptor_for_decryption_by_default
-    encrypted_string = 'test'.encrypt(:symmetric, :key => 'secret')
-    assert 'test'.equals_without_encryption(encrypted_string.decrypt)
+  def test_should_not_be_able_to_decrypt
+    assert !@string.can_decrypt?
+  end
+end
+
+class StringAfterBeingEncryptedTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt
   end
   
-  def test_should_allow_custom_mode_when_decrypting
-    assert_equal 'test', "MU6e/5LvhKA=\n".decrypt(:symmetric, :key => 'secret')
+  def test_should_be_encrypted
+    assert @encrypted_string.encrypted?
+  end
+end
+
+class StringAfterBeingEncryptedAndReplacedTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'string'
+    @encrypted_string.encrypt!
   end
   
-  def test_should_replace_string_with_bang_decryption
-    encrypted_string = "MU6e/5LvhKA=\n"
-    encrypted_string.decrypt!(:symmetric, :key => 'secret')
-    
-    assert !"MU6e/5LvhKA=\n".equals_without_encryption(encrypted_string)
-    assert 'test'.equals_without_encryption(encrypted_string)
+  def test_should_not_be_the_original_value
+    assert !'test'.equals_without_encryption(@encrypted_string)
   end
   
-  def test_should_be_able_to_decrypt_if_encryptor_can_decrypt
-    assert 'test'.encrypt(:symmetric, :key => 'secret').can_decrypt?
+  def test_should_have_an_encryptor
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, @encrypted_string.encryptor
   end
   
-  def test_should_not_be_able_to_decrypt_if_encryptor_cant_decrypt
-    assert !'test'.encrypt(:sha).can_decrypt?
+  def test_should_be_encrypted
+    assert @encrypted_string.encrypted?
+  end
+end
+
+class StringAfterBeingDecryptedTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt(:symmetric, :key => 'secret')
+    @decrypted_string = @encrypted_string.decrypt
   end
   
-  def test_should_not_be_able_to_decrypt_if_never_encrypted
-    assert !'test'.can_decrypt?
+  def test_should_not_be_encrypted
+    assert !@decrypted_string.encrypted?
   end
   
-  def test_should_be_able_to_check_equality_without_decryption_support
-    value = 'test'
-    encrypted_string = 'test'.encrypt(:sha)
-    encrypted_encrypted_string = encrypted_string.encrypt(:sha)
-    
-    assert_equal value, encrypted_string
-    assert_equal encrypted_string, value
-    assert_equal encrypted_string, encrypted_encrypted_string
-    assert_equal encrypted_encrypted_string, encrypted_string
-    assert_equal encrypted_string.to_s, encrypted_string
-    assert_equal encrypted_string, encrypted_string.to_s
-    assert_equal encrypted_string, encrypted_string
+  def test_should_not_have_an_encryptor
+    assert_nil @decrypted_string.encryptor
+  end
+end
+
+class StringAfterBeingDecryptedAndReplacedTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt(:symmetric, :key => 'secret')
+    @encrypted_string.decrypt!
+  end
+  
+  def test_should_not_be_the_original_value
+    assert !"MU6e/5LvhKA=\n".equals_without_encryption(@encrypted_string)
+  end
+  
+  def test_should_be_the_decrypted_value
+    assert 'test'.equals_without_encryption(@encrypted_string)
+  end
+  
+  def test_should_not_have_an_encryptor
+    assert_nil @encrypted_string.encryptor
+  end
+  
+  def test_should_not_be_encrypted
+    assert !@encrypted_string.encrypted?
+  end
+end
+
+class StringWithUndecryptableEncryptorTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt(:sha)
+  end
+  
+  def test_should_not_be_able_to_decrypt
+    assert !@encrypted_string.can_decrypt?
+  end
+  
+  def test_should_raise_exception_if_decrypted
+    assert_raise(NotImplementedError) {@encrypted_string.decrypt}
+  end
+  
+  def test_should_be_able_to_check_equality_with_itself
+    assert_equal @encrypted_string, @encrypted_string
+  end
+  
+  def test_should_be_able_to_check_equality_with_unencrypted_string
+    assert_equal 'test', @encrypted_string
+    assert_equal @encrypted_string, 'test'
+  end
+  
+  def test_should_be_able_to_check_equality_with_encrypted_value_of_encrypted_string
+    encrypted_encrypted_string = @encrypted_string.encrypt(:sha)
     
-    assert_not_equal value, encrypted_encrypted_string
-    assert_not_equal encrypted_encrypted_string, value
+    assert_equal @encrypted_string, encrypted_encrypted_string
+    assert_equal encrypted_encrypted_string, @encrypted_string
+  end
+  
+  def test_should_be_able_to_check_equality_with_same_string_without_encryptor
+    assert_equal @encrypted_string.to_s, @encrypted_string
+    assert_equal @encrypted_string, @encrypted_string.to_s
   end
   
-  def test_should_be_able_to_check_equality_with_decryption_support
-    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = 'secret'
+  def test_should_not_be_able_to_check_equality_more_than_one_encryption_away
+    encrypted_encrypted_string = @encrypted_string.encrypt(:sha)
     
-    value = 'test'
-    encrypted_string = value.encrypt(:symmetric)
-    encrypted_encrypted_string = encrypted_string.encrypt(:symmetric)
+    assert_not_equal 'test', encrypted_encrypted_string
+    assert_not_equal encrypted_encrypted_string, 'test'
+  end
+end
+
+class StringWithDecryptableEncryptorTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = 'test'.encrypt(:symmetric, :key => 'secret')
+  end
+  
+  def test_should_be_able_to_decrypt
+    assert @encrypted_string.can_decrypt?
+  end
+  
+  def test_should_be_able_to_check_equality_with_itself
+    assert_equal @encrypted_string, @encrypted_string
+  end
+  
+  def test_should_be_able_to_check_equality_with_unencrypted_string
+    assert_equal 'test', @encrypted_string
+    assert_equal @encrypted_string, 'test'
+  end
+  
+  def test_should_be_able_to_check_equality_with_encrypted_value_of_encrypted_string
+    encrypted_encrypted_string = @encrypted_string.encrypt(:symmetric, :key => 'secret')
     
-    assert_equal value, encrypted_string
-    assert_equal encrypted_string, value
-    assert_equal encrypted_string, encrypted_encrypted_string
-    assert_equal encrypted_encrypted_string, encrypted_string
-    assert_equal encrypted_string.to_s, encrypted_string
-    assert_equal encrypted_string, encrypted_string.to_s
-    assert_equal encrypted_string, encrypted_string
+    assert_equal @encrypted_string, encrypted_encrypted_string
+    assert_equal encrypted_encrypted_string, @encrypted_string
+  end
+  
+  def test_should_be_able_to_check_equality_with_same_string_without_encryptor
+    assert_equal @encrypted_string.to_s, @encrypted_string
+    assert_equal @encrypted_string, @encrypted_string.to_s
+  end
+  
+  def test_should_not_be_able_to_check_equality_more_than_one_encryption_away
+    encrypted_encrypted_string = @encrypted_string.encrypt(:symmetric, :key => 'secret')
     
-    assert_not_equal value, encrypted_encrypted_string
-    assert_not_equal encrypted_encrypted_string, value
+    assert_not_equal 'test', encrypted_encrypted_string
+    assert_not_equal encrypted_encrypted_string, 'test'
+  end
+end
+
+class StringPreviouslyEncryptedTest < Test::Unit::TestCase
+  def setup
+    @encrypted_string = "MU6e/5LvhKA=\n"
+  end
+  
+  def test_should_not_be_encrypted
+    assert !@encrypted_string.encrypted?
+  end
+  
+  def test_should_not_have_an_encryptor
+    assert_nil @encrypted_string.encryptor
+  end
+  
+  def test_should_not_be_able_to_decrypt
+    assert !@encrypted_string.can_decrypt?
+  end
+  
+  def test_should_be_able_to_decrypt_with_custom_mode
+    assert_equal 'test', @encrypted_string.decrypt(:symmetric, :key => 'secret')
   end
 end

data/test/symmetric_encryptor_test.rb

@@ -1,36 +1,66 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class SymmetricallyEncryptedStringTest < Test::Unit::TestCase
+class SymmetricEncryptorByDefaultTest < Test::Unit::TestCase
   def setup
-    @data = 'test'
-    @key = 'secret'
-    @encrypted = "MU6e/5LvhKA=\n"
-    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = nil
+    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = 'secret'
+    @symmetric_encryptor = PluginAWeek::EncryptedStrings::SymmetricEncryptor.new
+  end
+  
+  def test_should_use_the_default_key
+    assert_equal 'secret', @symmetric_encryptor.key
   end
   
-  def test_should_raise_exception_if_no_key_specified
-    assert_raises(PluginAWeek::EncryptedStrings::NoKeyError) { PluginAWeek::EncryptedStrings::SymmetricEncryptor.new }
+  def test_should_use_the_default_algorithm
+    assert_equal 'DES-EDE3-CBC', @symmetric_encryptor.algorithm
   end
   
-  def test_encrypt_with_default_key_if_key_not_specified
-    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = @key
-    assert_equal @encrypted, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new.encrypt(@data)
+  def test_should_encrypt_using_the_default_configuration
+    assert_equal "MU6e/5LvhKA=\n", @symmetric_encryptor.encrypt('test')
   end
   
-  def test_should_encrypt_with_custom_key_if_key_specified
-    assert_equal @encrypted, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).encrypt(@data)
+  def test_should_decrypt_encrypted_string_using_the_default_configuration
+    assert_equal 'test', @symmetric_encryptor.decrypt("MU6e/5LvhKA=\n")
+  end
+  
+  def teardown
+    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = nil
+  end
+end
+
+class SymmetricEncryptorWithInvalidOptionsTest < Test::Unit::TestCase
+  def test_should_throw_an_exception
+    assert_raise(ArgumentError) {PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:invalid => true)}
+  end
+end
+
+class SymmetricEncryptorTest < Test::Unit::TestCase
+  def setup
+    @symmetric_encryptor = PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => 'secret')
   end
   
   def test_should_be_able_to_decrypt
-    assert PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).can_decrypt?
+    assert @symmetric_encryptor.can_decrypt?
+  end
+end
+
+class SymmetricEncryptorWithCustomOptionsTest < Test::Unit::TestCase
+  def setup
+    @symmetric_encryptor = PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => 'secret', :algorithm => 'DES-EDE3-CFB')
+  end
+  
+  def test_should_use_custom_key
+    assert_equal 'secret', @symmetric_encryptor.key
+  end
+  
+  def test_should_use_custom_algorithm
+    assert_equal 'DES-EDE3-CFB', @symmetric_encryptor.algorithm
   end
   
-  def test_should_decrypt_encrypted_string_with_custom_key_if_key_specified
-    assert_equal @data, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).decrypt(@encrypted)
+  def test_should_encrypt_using_custom_options
+    assert_equal "C7D9mg==\n", @symmetric_encryptor.encrypt('test')
   end
   
-  def test_should_decrypt_encrypted_string_with_default_key_if_key_not_specified
-    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = @key
-    assert_equal @data, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new.decrypt(@encrypted)
+  def test_should_decrypt_using_custom_options
+    assert_equal 'test', @symmetric_encryptor.decrypt("C7D9mg==\n")
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: encrypted_strings
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Aaron Pfeifer
-autorequire: encrypted_strings
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-05-05 00:00:00 -04:00
+date: 2008-07-05 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -24,34 +24,34 @@ extra_rdoc_files: []
 files: 
 - lib/encrypted_strings.rb
 - lib/encrypted_strings
-- lib/encrypted_strings/no_private_key_error.rb
 - lib/encrypted_strings/no_key_error.rb
+- lib/encrypted_strings/encryptor.rb
+- lib/encrypted_strings/symmetric_encryptor.rb
 - lib/encrypted_strings/no_public_key_error.rb
 - lib/encrypted_strings/asymmetric_encryptor.rb
-- lib/encrypted_strings/symmetric_encryptor.rb
 - lib/encrypted_strings/sha_encryptor.rb
-- lib/encrypted_strings/encryptor.rb
+- lib/encrypted_strings/no_private_key_error.rb
 - lib/encrypted_strings/extensions
 - lib/encrypted_strings/extensions/string.rb
+- test/symmetric_encryptor_test.rb
+- test/no_public_key_error_test.rb
+- test/sha_encryptor_test.rb
 - test/keys
-- test/keys/private
 - test/keys/encrypted_private
+- test/keys/private
 - test/keys/public
 - test/keys/encrypted_public
-- test/no_private_key_error_test.rb
-- test/encryptor_test.rb
-- test/asymmetric_encryptor_test.rb
 - test/no_key_error_test.rb
-- test/sha_encryptor_test.rb
 - test/test_helper.rb
-- test/no_public_key_error_test.rb
 - test/string_test.rb
-- test/symmetric_encryptor_test.rb
-- CHANGELOG
+- test/asymmetric_encryptor_test.rb
+- test/encryptor_test.rb
+- test/no_private_key_error_test.rb
+- CHANGELOG.rdoc
 - init.rb
-- MIT-LICENSE
+- LICENSE
 - Rakefile
-- README
+- README.rdoc
 has_rdoc: true
 homepage: http://www.pluginaweek.org
 post_install_message: 
@@ -73,17 +73,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.1.0
+rubyforge_project: pluginaweek
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: Dead-simple string encryption/decryption syntax.
 test_files: 
-- test/no_private_key_error_test.rb
-- test/encryptor_test.rb
-- test/asymmetric_encryptor_test.rb
-- test/no_key_error_test.rb
-- test/sha_encryptor_test.rb
+- test/symmetric_encryptor_test.rb
 - test/no_public_key_error_test.rb
+- test/sha_encryptor_test.rb
+- test/no_key_error_test.rb
 - test/string_test.rb
-- test/symmetric_encryptor_test.rb
+- test/asymmetric_encryptor_test.rb
+- test/encryptor_test.rb
+- test/no_private_key_error_test.rb