encrypted_strings 0.0.1 → 0.0.2

data/CHANGELOG

@@ -0,0 +1,15 @@
+*SVN*
+
+*0.0.2* (August 23rd, 2007)
+
+* 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)
+
+* Official public release
+
+* Add api documentation
+
+* Refactor unit test names

data/README

@@ -12,26 +12,28 @@ Wiki
 
 * http://wiki.pluginaweek.org/Encrypted_strings
 
-Blog
+Announcement
 
 * http://www.pluginaweek.org/
 
-Subversion
+Source
 
 * http://svn.pluginaweek.org/trunk/plugins/ruby/string/encrypted_strings
 
-Trac
+Development
 
 * http://dev.pluginaweek.org/browse/trunk/plugins/ruby/string/encrypted_strings
 
-== Types of encryption supported
+== Description
 
-This plugin supports Hashed, Symmetric, and Asymmetric encryption modes.
+Encrypting and decrypting data is not exactly the most straightforward and DRY
+way.  encrypted_strings greatly improves upon this syntax and adds
+straightforward support for encrypting values using SHA-1, Symmetric, and
+Asymmetric modes.
 
-== How to use
+== Usage
 
-This plugin adds the method 'encrypt' and other supporting methods to the String
-class, giving you the ability to easily encrypt strings.
+=== SHA Encryption
 
   >> password = "shhhh"
   => "shhhh"
@@ -55,7 +57,7 @@ SHA-1 encryption.  For encryption modes that do not support decryption, equality
 with other strings is tested by encrypting the other string and checking whether
 the resulting encrypted value is the same.
 
-If you wanted to use symmetric encryption, you could do so with the following:
+=== Symmetric Encryption
 
   >> password = "shhhh"
   => "shhhh"
@@ -70,28 +72,21 @@ If you wanted to use symmetric encryption, you could do so with the following:
 
 === Asymmetric encryption
 
-The public and private key file names can be set via the following:
-
-  PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = "./public.key"
-  PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = "./private.key"
-
-== In-place editing
-
-In addition to generating the encrypted/decrypted strings, you can also
-replace the original string by using the bang:
-
   >> password = "shhhh"
   => "shhhh"
-  >> password.encrypt!(:symmetric, :key => "my_key")
-  => "jDACXI5hMPI=\n"
-  >> password
-  => "jDACXI5hMPI=\n"
-  >> password.decrypt!
-  => "shhhh"
-  >> password
+  >> crypted_password = password.encrypt(:asymmetric, :public_key_file => "./public.key", :private_key_file => "./private.key")
+  => "NEwVzcikYUKfS8HTc9L9eg/dMxBCLZ/nFr7J1aQYjkl3I2MPUD0lmjr/saC6\nTJEPwOl60Ki24H8TUwnGtZy14A==\n"
+  >> crypted_password.class
+  => String
+  >> crypted_password == "shhhh"
+  => true
+  >> password = crypted_password.decrypt
   => "shhhh"
 
+== Dependencies
+
+This plugin does not depend on the presence of any other plugins.
+
 == References
 
-A huge thanks to Rick Olson and his Sentry plugin over at http://svn.techno-weenie.net/projects/plugins/sentry/.
-Much of this plugin's code is based on his work.
+* Rick Olson -  http://svn.techno-weenie.net/projects/plugins/sentry/

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/gempackagetask'
 require 'rake/contrib/sshpublisher'
 
 PKG_NAME           = 'encrypted_strings'
-PKG_VERSION        = '0.0.1'
+PKG_VERSION        = '0.0.2'
 PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
 RUBY_FORGE_PROJECT = 'pluginaweek'
 
@@ -33,7 +33,7 @@ spec = Gem::Specification.new do |s|
   s.platform        = Gem::Platform::RUBY
   s.summary         = 'Dead-simple string encryption/decryption syntax.'
   
-  s.files           = FileList['{lib,tasks,test}/**/*'].to_a + %w(init.rb MIT-LICENSE Rakefile README)
+  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
@@ -77,4 +77,4 @@ task :release => [:gem, :package] do
     
     ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
   end
-end
+end

data/lib/encrypted_strings/asymmetric_encryptor.rb

@@ -2,14 +2,52 @@ require 'encrypted_strings/no_private_key_error'
 require 'encrypted_strings/no_public_key_error'
 
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
-    # Encryption in which the keys used to encrypt/decrypt come in pairs.  Also known
-    # as public key encryption.  Anything that's encrypted using the public key can
-    # only be decrypted with the same algorithm and a matching private key.
-    # Any message that is encrypted with the private key can only be decrypted
-    # with the matching public key.
+  module EncryptedStrings
+    # Encryption in which the keys used to encrypt/decrypt come in pairs.  Also
+    # known as public key encryption.  Anything that's encrypted using the
+    # public key can only be decrypted with the same algorithm and a matching
+    # private key.  Any message that is encrypted with the private key can only
+    # be decrypted with the matching public key.
     # 
-    # http://support.microsoft.com/kb/246071
+    # Source: http://support.microsoft.com/kb/246071
+    # 
+    # == Encrypting 
+    # 
+    # To encrypt a string using an asymmetric algorithm, the location of the
+    # public key file must be specified.  You can define the default for this
+    # value like so:
+    # 
+    #   PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = "./public.key"
+    # 
+    # If these configuration options are not passed in to #encrypt, then the
+    # default values will be used.  You can override the default values like so:
+    # 
+    #   password = "shhhh"
+    #   password.encrypt(:asymmetic, :public_key_file => "./encrypted_public.key")  # => "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
+    # 
+    # An exception will be raised if either the public key file could not be
+    # found or the key could not decrypt the public key file.
+    # 
+    # == Decrypting
+    # 
+    # To decrypt a string using an asymmetric algorithm, the location of the
+    # private key file must be specified.  If this file is itself encrypted, you
+    # must also specify the algorithm and key used to seed the symmetric
+    # algorithm that will decrypt the plublic key file.  You can define defaults
+    # for these values like so:
+    # 
+    #   PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = "./private.key"
+    #   PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_algorithm = "DES-EDE3-CBC"
+    #   PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = "secret_key"
+    # 
+    # If these configuration options are not passed in to #decrypt, then the
+    # default values will be used.  You can override the default values like so:
+    # 
+    #   password = "INy95irZ8AlHmvc6ZAF/ARsTpbqPIB/4bEAKKOebjsayB7NYWtIzpswvzxqf\nNJ5yyuvxfMODrcg7RimEMFkFlg==\n"
+    #   password.decrypt(:asymmetic, :public_key_file => "./encrypted_private.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.
     class AsymmetricEncryptor < Encryptor
       # The default private key to use during encryption.  Default is nil.
       @@default_private_key_file = nil
@@ -100,7 +138,7 @@ module PluginAWeek #:nodoc:
       end
       
       private
-      def load_private_key #:nodoc:
+      def load_private_key
         @private_rsa = nil
         
         if @private_key_file && File.file?(@private_key_file)
@@ -108,7 +146,7 @@ module PluginAWeek #:nodoc:
         end
       end
       
-      def load_public_key #:nodoc:
+      def load_public_key
         @public_rsa = nil
         
         if @public_key_file && File.file?(@public_key_file)
@@ -116,18 +154,20 @@ module PluginAWeek #:nodoc:
         end
       end
       
-      # Retrieves private RSA from the encrypted private key
-      def private_rsa #:nodoc:
-        return @private_rsa ||= OpenSSL::PKey::RSA.new(@private_key) unless @key
-        
-        private_key = SymmetricEncryptor.new(:key => @key, :algorithm => @algorithm).decrypt(@private_key)
-        OpenSSL::PKey::RSA.new(private_key)
+      # Retrieves private RSA from the private key
+      def private_rsa
+        if @key
+          private_key = @private_key.decrypt(:symmetric, :key => @key, :algorithm => @algorithm)
+          OpenSSL::PKey::RSA.new(private_key)
+        else
+          @private_rsa ||= OpenSSL::PKey::RSA.new(@private_key)
+        end
       end
       
       # Retrieves the public RSA
-      def public_rsa #:nodoc:
+      def public_rsa
         @public_rsa ||= OpenSSL::PKey::RSA.new(@public_key)
       end
     end
   end
-end
+end

data/lib/encrypted_strings/encryptor.rb

@@ -1,17 +1,18 @@
-module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
-    # Represents an encryptor for strings.  Certain encryption algorithms
-    # do not allow for strings to be decrypted.
-    class Encryptor
-      # Can this string be decrypted?
-      def can_decrypt?
-        true
-      end
-      
-      # By default, decryption is not supported
-      def decrypt(data)
-        raise NotImplementedError, "Decryption is not supported using a(n) #{self.class.name}"
-      end
-    end
-  end
-end
+module PluginAWeek #:nodoc:
+  module EncryptedStrings
+    # Represents an encryptor for strings.  Certain encryption algorithms
+    # do not allow for strings to be decrypted.
+    class Encryptor
+      # Can this string be decrypted?  Default is true.
+      def can_decrypt?
+        true
+      end
+      
+      # Attempts to decrypt the given data using the current configuration.  By
+      # default, decryption is not implemented.
+      def decrypt(data)
+        raise NotImplementedError, "Decryption is not supported using a(n) #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/encrypted_strings/extensions/string.rb

@@ -2,9 +2,9 @@ require 'openssl'
 require 'base64'
 
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
+  module EncryptedStrings
     module Extensions #:nodoc:
-      # Adds encryption/decryption/equality methods
+      # Adds support for encryption/decryption of strings
       module String
         def self.included(base) #:nodoc:
           base.class_eval do
@@ -15,19 +15,36 @@ module PluginAWeek #:nodoc:
           end
         end
         
-        # Encrypts this string and replaces it with the encrypted value
-        def encrypt!(*args)
-          encrypted_string = encrypt(*args)
-          self.encryptor = encrypted_string.encryptor
-          
-          replace(encrypted_string)
-        end
-        
-        # Encrypts the current string using the encryption algorithm specified.
+        # Encrypts the current string using the specified encryption mode.
         # The default encryption mode is sha.
         # 
-        # Configuration options are encryption-specified.  See the encryptor
-        # class for that string to find out the options available.
+        # Configuration options are encryption-specific.  See the encryptor
+        # class for that mode to find out the options available.
+        # 
+        # == Example
+        # 
+        # The following uses SHA mode to encrypt the string:
+        # 
+        #   password = "shhhh"
+        #   password.encrypt  # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        # 
+        # == Custom encryption mode
+        # 
+        # The following uses Symmetric mode (with a default key) to encrypt the
+        # string:
+        # 
+        #   PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = "my_key"
+        #   password = "shhhh"
+        #   password.encrypt(:symmetric)  # => "jDACXI5hMPI=\n"
+        # 
+        # == Custom encryption options
+        # 
+        # Some encryption modes also support additional configuration options
+        # that determine how to encrypt the string.  For example, SHA supports
+        # a salt which seeds the algorithm:
+        # 
+        #   password = "shhhh"
+        #   password.encrypt(:sha, :salt => "secret") # => "3b22cbe4acde873c3efc82681096f3ae69aff828"
         def encrypt(*args)
           encryptor = encryptor_from_args(*args)
           encrypted_string = encryptor.encrypt(self)
@@ -36,14 +53,33 @@ module PluginAWeek #:nodoc:
           encrypted_string
         end
         
-        # Is this string encrypted?
-        def encrypted?
-          !@encryptor.nil?
+        # Encrypts this string and replaces it with the encrypted value.  This
+        # takes the same parameters as #encrypt, but returns the same string
+        # instead of a different one.
+        # 
+        # For example,
+        # 
+        #   password = "shhhh"
+        #   password.encrypt!(:symmetric, :key => "my_key") # => "jDACXI5hMPI=\n"
+        #   password                                        # => "jDACXI5hMPI=\n"
+        def encrypt!(*args)
+          encrypted_string = encrypt(*args)
+          self.encryptor = encrypted_string.encryptor
+          
+          replace(encrypted_string)
         end
         
-        # Decrypts this string and replaces it with the decrypted value
-        def decrypt!(*args)
-          replace(decrypt(*args))
+        # Is this string encrypted?  This will return true if the string is the
+        # result of a call to #encrypt or #encrypt! was previously invoked.
+        # 
+        # For example,
+        # 
+        #   password = "shhhh"
+        #   password.encrypted? # => false
+        #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password.encrypted? # => true
+        def encrypted?
+          !@encryptor.nil?
         end
         
         # Decrypts this string.  If this is not a string that was previously encrypted,
@@ -52,18 +88,55 @@ module PluginAWeek #:nodoc:
         def decrypt(*args)
           raise ArgumentError, "An encrypt algorithm must be specified since we can't figure it out" if args.empty? && !@encryptor
           
-          encryptor = @encryptor || encryptor_from_args(*args)
-          encryptor.decrypt(self)
+          encryptor = args.any? ? encryptor_from_args(*args) : (@encryptor || encryptor_from_args(*args))
+          encrypted_string = encryptor.decrypt(self)
+          encrypted_string.encryptor = nil
+          
+          encrypted_string
         end
         
-        # Can this string be decrypted?
+        # Decrypts this string and replaces it with the decrypted value  This
+        # takes the same parameters as #decrypt, but returns the same string
+        # instead of a different one.
+        # 
+        # For example,
+        # 
+        #   password = "jDACXI5hMPI=\n"
+        #   password.decrypt!(:symmetric, :key => "my_key") # => "shhhh"
+        #   password                                        # => "shhhh"
+        def decrypt!(*args)
+          replace(decrypt(*args))
+        end
+        
+        # Can this string be decrypted?  Strings can only be decrypted if they
+        # have previously been decrypted +and+ the encryption algorithm supports
+        # decryption.  To determine whether or not the encryption algorithm
+        # supports decryption, see the api for the algorithm's encryptor class.
         def can_decrypt?
-          !@encryptor.nil? && @encryptor.can_decrypt?
+          encrypted? && @encryptor.can_decrypt?
         end
         
         # Tests whether the other object is equal to this one.  Encrypted strings
         # will be tested not only on their encrypted strings, but also by
-        # decrypting them and running tests against the decrypted value
+        # decrypting them and running tests against the decrypted value.
+        # 
+        # == Equality with strings
+        # 
+        #   password = "shhhh"
+        #   password.encrypt!   # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password            # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password == "shhhh" # => true
+        # 
+        # == Equality with encrypted strings
+        # 
+        #   password = "shhhh"
+        #   password.encrypt!             # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password                      # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password == "shhhh"           # => true
+        #   
+        #   another_password = "shhhh"
+        #   another_password.encrypt!     # => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+        #   password == another_password  # => true
         def equals_with_encryption(other)
           if !(is_equal = equals_without_encryption(other)) && String === other
             if encrypted?
@@ -105,4 +178,4 @@ end
 
 ::String.class_eval do
   include PluginAWeek::EncryptedStrings::Extensions::String
-end
+end

data/lib/encrypted_strings/no_key_error.rb

@@ -1,7 +1,7 @@
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
+  module EncryptedStrings
     # Indicates no key was specified
     class NoKeyError < StandardError
     end
   end
-end
+end

data/lib/encrypted_strings/no_private_key_error.rb

@@ -1,7 +1,7 @@
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
+  module EncryptedStrings
     # Indicates no private key was found
     class NoPrivateKeyError < StandardError
     end
   end
-end
+end

data/lib/encrypted_strings/no_public_key_error.rb

@@ -1,7 +1,7 @@
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
+  module EncryptedStrings
     # Indicates no public key was found
     class NoPublicKeyError < StandardError
     end
   end
-end
+end

data/lib/encrypted_strings/sha_encryptor.rb

@@ -1,8 +1,32 @@
 require 'digest/sha1'
 
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc:
+  module EncryptedStrings
     # Encrypts a string using a Secure Hash Algorithm (SHA), specifically SHA-1.
+    # 
+    # == Encrypting
+    # 
+    # To encrypt a string using an SHA algorithm, the salt used to seed the
+    # encrypting must be specified.  You can define the default for this
+    # value like so:
+    # 
+    #   PluginAWeek::EncryptedStrings::ShaEncryptor.default_salt = "secret"
+    # 
+    # If these configuration options are not passed in to #encrypt, then the
+    # default values will be used.  You can override the default values like so:
+    # 
+    #   password = "shhhh"
+    #   password.encrypt(:sha, :salt => "my_salt")  # => "ae645b35bb5dfea6c9133ac872e6adfa92a3c2bd"
+    # 
+    # == Decrypting
+    # 
+    # SHA-encrypted strings cannot be decrypted.  The only way to determine
+    # whether an unencrypted value is equal to an SHA-encrypted string is to
+    # encrypt the value with the same salt.  For example,
+    # 
+    #   password = "shhhh".encrypt(:sha, :salt => "secret") # => "3b22cbe4acde873c3efc82681096f3ae69aff828"
+    #   input = "shhhh".encrypt(:sha, :salt => "secret")    # => "3b22cbe4acde873c3efc82681096f3ae69aff828"
+    #   password == input                                   # => true
     class ShaEncryptor < Encryptor
       # The default salt value to use during encryption
       @@default_salt = 'salt'
@@ -32,4 +56,4 @@ module PluginAWeek #:nodoc:
       end
     end
   end
-end
+end

data/lib/encrypted_strings/symmetric_encryptor.rb

@@ -1,12 +1,43 @@
 require 'encrypted_strings/no_key_error'
 
 module PluginAWeek #:nodoc:
-  module EncryptedStrings #:nodoc
+  module EncryptedStrings
     # Symmetric encryption uses a key and a specific algorithm to encrypt the
     # string.  As long as the key and algorithm are known, the string can be
     # decrypted.
     # 
-    # http://support.microsoft.com/kb/246071
+    # Source: http://support.microsoft.com/kb/246071
+    # 
+    # == Encrypting 
+    # 
+    # To encrypt a string using a symmetric algorithm, the type of algorithm and
+    # key must be specified.  You can define the defaults for these values like
+    # so:
+    # 
+    #   PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_algorithm = "des-ecb"
+    #   PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = "secret"
+    # 
+    # If these configuration options are not passed in to #encrypt, then the
+    # default values will be used.  You can override the default values like so:
+    # 
+    #   password = "shhhh"
+    #   password.encrypt(:symmetic, :algorithm => "des-ecb", :key => "secret")  # => "sUG6tYSn0mI=\n"
+    # 
+    # An exception will be raised if no key is specified.
+    # 
+    # == Decrypting
+    # 
+    # To decrypt a string using an symmetric algorithm, the type of algorithm
+    # and key must also be specified.  Defaults for these values can be defined
+    # as show above.
+    # 
+    # If these configuration options are not passed in to #decrypt, then the
+    # default values will be used.  You can override the default values like so:
+    # 
+    #   password = "sUG6tYSn0mI=\n"
+    #   password.decrypt(:symmetic, :algorithm => "des-ecb", :key => "secret") # => "shhhh"
+    # 
+    # An exception will be raised if no key is specified.
     class SymmetricEncryptor < Encryptor
       # The default algorithm to use for encryption.  Default is DES
       @@default_algorithm = 'DES-EDE3-CBC'
@@ -29,7 +60,7 @@ module PluginAWeek #:nodoc:
           :algorithm
         )
         options.reverse_merge!(:key => @@default_key)
-        options[:algorithm] ||= @@default_algorithm # Saves us from nil values for algorithm
+        options[:algorithm] ||= @@default_algorithm
         
         @key = options[:key]
         raise NoKeyError if @key.nil?
@@ -61,4 +92,4 @@ module PluginAWeek #:nodoc:
       end
     end
   end
-end
+end

data/test/asymmetric_encryptor_test.rb

@@ -34,7 +34,7 @@ class AsymmetricEncryptorTest < Test::Unit::TestCase
     assert encryptor.public?
     assert encryptor.private?
   end
-#  
+  
   def test_should_read_encrypted_key_files
     encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
       :public_key_file => @encrypted_public_key_file,
@@ -43,7 +43,7 @@ class AsymmetricEncryptorTest < Test::Unit::TestCase
     assert encryptor.public?
     assert encryptor.private?
   end
-#  
+  
   def test_should_decrypt_files
     encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
       :public_key_file => @public_key_file,
@@ -52,7 +52,7 @@ class AsymmetricEncryptorTest < Test::Unit::TestCase
     
     assert_equal @data, encryptor.decrypt(@encrypted_data)
   end
-#  
+  
   def test_should_decrypt_files_with_encrypted_key
     encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new(
       :public_key_file => @encrypted_public_key_file,
@@ -62,7 +62,7 @@ class AsymmetricEncryptorTest < Test::Unit::TestCase
     
     assert_equal @data, encryptor.decrypt(@encrypted_data_with_encrypted_keys)
   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)
@@ -94,4 +94,4 @@ class AsymmetricEncryptorTest < Test::Unit::TestCase
     PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = public_key
     PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = private_key
   end
-end
+end

data/test/encryptor_test.rb

@@ -1,15 +1,15 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class EncryptorTest < Test::Unit::TestCase
-  def setup
-    @encryptor = PluginAWeek::EncryptedStrings::Encryptor.new
-  end
-  
-  def test_should_be_able_to_decrypt_by_default
-    assert @encryptor.can_decrypt?
-  end
-  
-  def test_should_raise_exception_if_decrypt_not_implemented
-    assert_raises(NotImplementedError) { @encryptor.decrypt('test') }
-  end
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class EncryptorTest < Test::Unit::TestCase
+  def setup
+    @encryptor = PluginAWeek::EncryptedStrings::Encryptor.new
+  end
+  
+  def test_should_be_able_to_decrypt_by_default
+    assert @encryptor.can_decrypt?
+  end
+  
+  def test_should_raise_exception_if_decrypt_not_implemented
+    assert_raises(NotImplementedError) { @encryptor.decrypt('test') }
+  end
 end

data/test/string_test.rb

@@ -1,77 +1,105 @@
-require File.join(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
-    
-    encrypted_string = 'test'.encrypt(:salt => 'different_salt')
-    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, encrypted_string.encryptor
-    assert_equal 'different_salt', encrypted_string.encryptor.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
-  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
-  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)
-  end
-  
-  def test_should_allow_custom_mode_when_decrypting
-    assert_equal 'test', "MU6e/5LvhKA=\n".decrypt(:symmetric, :key => 'secret')
-  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)
-  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
-    
-    assert_not_equal value, encrypted_encrypted_string
-    assert_not_equal encrypted_encrypted_string, value
-  end
-  
-  def test_should_be_able_to_check_equality_with_decryption_support
-    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = 'secret'
-    
-    value = 'test'
-    encrypted_string = value.encrypt(:symmetric)
-    encrypted_encrypted_string = encrypted_string.encrypt(:symmetric)
-    
-    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_not_equal value, encrypted_encrypted_string
-    assert_not_equal encrypted_encrypted_string, value
-  end
-end
+require File.join(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
+  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
+  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
+  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
+  end
+  
+  def test_should_be_encrypted_if_string_has_been_encrypted
+    assert 'test'.encrypt.encrypted?
+  end
+  
+  def test_should_not_be_encrypted_if_string_has_not_been_encrypted
+    assert !'test'.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?
+  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)
+  end
+  
+  def test_should_allow_custom_mode_when_decrypting
+    assert_equal 'test', "MU6e/5LvhKA=\n".decrypt(:symmetric, :key => 'secret')
+  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)
+  end
+  
+  def test_should_be_able_to_decrypt_if_encryptor_can_decrypt
+    assert 'test'.encrypt(:symmetric, :key => 'secret').can_decrypt?
+  end
+  
+  def test_should_not_be_able_to_decrypt_if_encryptor_cant_decrypt
+    assert !'test'.encrypt(:sha).can_decrypt?
+  end
+  
+  def test_should_not_be_able_to_decrypt_if_never_encrypted
+    assert !'test'.can_decrypt?
+  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
+    
+    assert_not_equal value, encrypted_encrypted_string
+    assert_not_equal encrypted_encrypted_string, value
+  end
+  
+  def test_should_be_able_to_check_equality_with_decryption_support
+    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = 'secret'
+    
+    value = 'test'
+    encrypted_string = value.encrypt(:symmetric)
+    encrypted_encrypted_string = encrypted_string.encrypt(:symmetric)
+    
+    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_not_equal value, encrypted_encrypted_string
+    assert_not_equal encrypted_encrypted_string, value
+  end
+end

data/test/symmetric_encryptor_test.rb

@@ -12,15 +12,15 @@ class SymmetricallyEncryptedStringTest < Test::Unit::TestCase
     assert_raises(PluginAWeek::EncryptedStrings::NoKeyError) { PluginAWeek::EncryptedStrings::SymmetricEncryptor.new }
   end
   
-  def test_should_encrypt_with_custom_key_if_key_specified
-    assert_equal @encrypted, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).encrypt(@data)
-  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)
   end
   
+  def test_should_encrypt_with_custom_key_if_key_specified
+    assert_equal @encrypted, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).encrypt(@data)
+  end
+  
   def test_should_be_able_to_decrypt
     assert PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).can_decrypt?
   end
@@ -33,4 +33,4 @@ class SymmetricallyEncryptedStringTest < Test::Unit::TestCase
     PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = @key
     assert_equal @data, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new.decrypt(@encrypted)
   end
-end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.0
 specification_version: 1
 name: encrypted_strings
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-08-05 00:00:00 -04:00
+  version: 0.0.2
+date: 2007-08-23 00:00:00 -04:00
 summary: Dead-simple string encryption/decryption syntax.
 require_paths: 
 - lib
@@ -29,44 +29,45 @@ post_install_message:
 authors: 
 - Aaron Pfeifer, Neil Abraham
 files: 
+- lib/encrypted_strings.rb
 - lib/encrypted_strings
-- lib/encrypted_strings/asymmetric_encryptor.rb
-- lib/encrypted_strings/encryptor.rb
 - lib/encrypted_strings/extensions
-- lib/encrypted_strings/extensions/string.rb
-- lib/encrypted_strings/no_key_error.rb
-- lib/encrypted_strings/no_private_key_error.rb
+- lib/encrypted_strings/asymmetric_encryptor.rb
 - lib/encrypted_strings/no_public_key_error.rb
+- lib/encrypted_strings/no_key_error.rb
 - lib/encrypted_strings/sha_encryptor.rb
+- lib/encrypted_strings/no_private_key_error.rb
+- lib/encrypted_strings/encryptor.rb
 - lib/encrypted_strings/symmetric_encryptor.rb
-- lib/encrypted_strings.rb
-- test/asymmetric_encryptor_test.rb
-- test/encryptor_test.rb
-- test/keys
-- test/keys/encrypted_private
-- test/keys/encrypted_public
-- test/keys/private
-- test/keys/public
-- test/no_key_error_test.rb
+- lib/encrypted_strings/extensions/string.rb
+- test/test_helper.rb
 - test/no_private_key_error_test.rb
 - test/no_public_key_error_test.rb
 - test/sha_encryptor_test.rb
-- test/string_test.rb
 - test/symmetric_encryptor_test.rb
-- test/test_helper.rb
+- test/string_test.rb
+- test/encryptor_test.rb
+- test/asymmetric_encryptor_test.rb
+- test/keys
+- test/no_key_error_test.rb
+- test/keys/private
+- test/keys/public
+- test/keys/encrypted_public
+- test/keys/encrypted_private
+- CHANGELOG
 - init.rb
 - MIT-LICENSE
 - Rakefile
 - README
 test_files: 
-- test/asymmetric_encryptor_test.rb
-- test/encryptor_test.rb
-- test/no_key_error_test.rb
 - test/no_private_key_error_test.rb
 - test/no_public_key_error_test.rb
 - test/sha_encryptor_test.rb
-- test/string_test.rb
 - test/symmetric_encryptor_test.rb
+- test/string_test.rb
+- test/encryptor_test.rb
+- test/asymmetric_encryptor_test.rb
+- test/no_key_error_test.rb
 rdoc_options: []
 
 extra_rdoc_files: []