encrypted_strings 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005 Rick Olson, 2006-2007 Aaron Pfeifer & Neil Abraham
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,97 @@
+= encrypted_strings
+
+encrypted_strings provides dead-simple string encryption/decryption syntax.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/encrypted_strings
+
+Wiki
+
+* http://wiki.pluginaweek.org/Encrypted_strings
+
+Blog
+
+* http://www.pluginaweek.org/
+
+Subversion
+
+* http://svn.pluginaweek.org/trunk/plugins/ruby/string/encrypted_strings
+
+Trac
+
+* http://dev.pluginaweek.org/browse/trunk/plugins/ruby/string/encrypted_strings
+
+== Types of encryption supported
+
+This plugin supports Hashed, Symmetric, and Asymmetric encryption modes.
+
+== How to use
+
+This plugin adds the method 'encrypt' and other supporting methods to the String
+class, giving you the ability to easily encrypt strings.
+
+  >> password = "shhhh"
+  => "shhhh"
+  >> crypted_password = password.encrypt
+  => "66c85d26dadde7e1db27e15a0776c921e27143bd"
+  >> crypted_password.class
+  => String
+  >> crypted_password.encryptor
+  => #<PluginAWeek::EncryptedStrings::ShaEncryptor:0x2b9238889460 @salt="salt">
+  >> crypted_password == "shhhh"
+  => true
+  >> crypted_password.decrypt
+  NotImplementedError: Decryption is not supported using a(n) PluginAWeek::EncryptedStrings::ShaEncryptor
+          from ./script/../config/../config/../vendor/plugins/encrypted_strings/lib/encrypted_strings/encryptor.rb:13:in `decrypt'
+          from ./script/../config/../config/../vendor/plugins/encrypted_strings/lib/encrypted_strings/extensions/string.rb:52:in `decrypt'
+          from (irb):40
+
+When encrypt is called, it creates an encryptor instance which is used for
+future encryption and decryption of the string.  The default encryptor uses
+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:
+
+  >> password = "shhhh"
+  => "shhhh"
+  >> crypted_password = password.encrypt(:symmetric, :key => "my_key")
+  => "jDACXI5hMPI=\n"
+  >> crypted_password.class
+  => String
+  >> crypted_password == "shhhh"
+  => true
+  >> password = crypted_password.decrypt
+  => "shhhh"
+
+=== 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
+  => "shhhh"
+
+== 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.

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+PKG_NAME           = 'encrypted_strings'
+PKG_VERSION        = '0.0.1'
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'pluginaweek'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the encrypted_strings plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  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')
+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,tasks,test}/**/*'].to_a + %w(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.add_dependency    'activesupport', '>= 1.3.1'
+  
+  s.author          = 'Aaron Pfeifer, Neil Abraham'
+  s.email           = 'info@pluginaweek.org'
+  s.homepage        = 'http://www.pluginaweek.org'
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('pluginaweek@pluginaweek.org', '/home/pluginaweek/gems.pluginaweek.org/gems', 'pkg', "#{PKG_FILE_NAME}.gem").upload
+end
+
+desc 'Publish the API documentation'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('pluginaweek@pluginaweek.org', "/home/pluginaweek/api.pluginaweek.org/#{PKG_NAME}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new
+  ruby_forge.login
+  
+  %w( gem tgz zip ).each do |ext|
+    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'encrypted_strings'

data/lib/encrypted_strings.rb

@@ -0,0 +1,5 @@
+require 'encrypted_strings/extensions/string'
+require 'encrypted_strings/encryptor'
+require 'encrypted_strings/symmetric_encryptor'
+require 'encrypted_strings/asymmetric_encryptor'
+require 'encrypted_strings/sha_encryptor'

data/lib/encrypted_strings/asymmetric_encryptor.rb

@@ -0,0 +1,133 @@
+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.
+    # 
+    # http://support.microsoft.com/kb/246071
+    class AsymmetricEncryptor < Encryptor
+      # The default private key to use during encryption.  Default is nil.
+      @@default_private_key_file = nil
+      cattr_accessor :default_private_key_file
+      
+      # The default public key to use during encryption.  Default is nil.
+      @@default_public_key_file = nil
+      cattr_accessor :default_public_key_file
+      
+      # The default algorithm to use.  Default is nil.
+      @@default_algorithm = nil
+      cattr_accessor :default_algorithm
+      
+      attr_reader   :private_key_file
+      attr_reader   :public_key_file
+      attr_accessor :algorithm
+      attr_accessor :key
+      
+      # Configuration options:
+      # * <tt>private_key_file</tt> - Encrypted private key file
+      # * <tt>public_key_file</tt> - Public key file
+      # * <tt>key</tt> - The key to use in the symmetric encryptor
+      # * <tt>algorithm</tt> - Algorithm to use symmetrically encrypted strings
+      def initialize(options = {})
+        options = options.symbolize_keys
+        options.assert_valid_keys(
+          :private_key_file,
+          :public_key_file,
+          :key,
+          :algorithm
+        )
+        options.reverse_merge!(
+          :private_key_file => @@default_private_key_file,
+          :public_key_file => @@default_public_key_file,
+          :algorithm => @@default_algorithm
+        )
+        
+        @public_key = @private_key = nil
+        @key = options[:key]
+        @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
+      def encrypt(data)
+        raise NoPublicKeyError, "Public key file: #{@public_key_file}" unless public?
+        
+        encrypted_data = public_rsa.public_encrypt(data)
+        Base64.encode64(encrypted_data)
+      end
+      
+      # Decrypts the given data
+      def decrypt(data)
+        raise NoPrivateKeyError, "Private key file: #{@private_key_file}" unless private?
+        
+        decrypted_data = Base64.decode64(data)
+        private_rsa.private_decrypt(decrypted_data)
+      end
+      
+      # Sets the location of the private key and loads it
+      def private_key_file=(file)
+        @private_key_file = file and load_private_key
+      end
+      
+      # Sets the location of the public key and loads it
+      def public_key_file=(file)
+        @public_key_file = file and load_public_key
+      end
+      
+      # Is this string encrypted using a public key?
+      def public?
+        return true unless @public_key.nil?
+        
+        load_public_key
+        !@public_key.nil?
+      end
+      
+      # Is this string encrypted using a private key?
+      def private?
+        return true unless @private_key.nil?
+        
+        load_private_key
+        !@private_key.nil?
+      end
+      
+      private
+      def load_private_key #:nodoc:
+        @private_rsa = nil
+        
+        if @private_key_file && File.file?(@private_key_file)
+          @private_key = File.open(@private_key_file) {|f| f.read}
+        end
+      end
+      
+      def load_public_key #:nodoc:
+        @public_rsa = nil
+        
+        if @public_key_file && File.file?(@public_key_file)
+          @public_key = File.open(@public_key_file) {|f| f.read}
+        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)
+      end
+      
+      # Retrieves the public RSA
+      def public_rsa #:nodoc:
+        @public_rsa ||= OpenSSL::PKey::RSA.new(@public_key)
+      end
+    end
+  end
+end

data/lib/encrypted_strings/encryptor.rb

@@ -0,0 +1,17 @@
+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

data/lib/encrypted_strings/extensions/string.rb

@@ -0,0 +1,108 @@
+require 'openssl'
+require 'base64'
+
+module PluginAWeek #:nodoc:
+  module EncryptedStrings #:nodoc:
+    module Extensions #:nodoc:
+      # Adds encryption/decryption/equality methods
+      module String
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            attr_accessor :encryptor
+            
+            alias_method :equals_without_encryption, :==
+            alias_method :==, :equals_with_encryption
+          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.
+        # The default encryption mode is sha.
+        # 
+        # Configuration options are encryption-specified.  See the encryptor
+        # class for that string to find out the options available.
+        def encrypt(*args)
+          encryptor = encryptor_from_args(*args)
+          encrypted_string = encryptor.encrypt(self)
+          encrypted_string.encryptor = encryptor
+          
+          encrypted_string
+        end
+        
+        # Is this string encrypted?
+        def encrypted?
+          !@encryptor.nil?
+        end
+        
+        # Decrypts this string and replaces it with the decrypted value
+        def decrypt!(*args)
+          replace(decrypt(*args))
+        end
+        
+        # Decrypts this string.  If this is not a string that was previously encrypted,
+        # the encryption algorithm must be specified in the same way the
+        # algorithm is specified when encrypting a string.
+        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)
+        end
+        
+        # Can this string be decrypted?
+        def can_decrypt?
+          !@encryptor.nil? && @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
+        def equals_with_encryption(other)
+          if !(is_equal = equals_without_encryption(other)) && String === other
+            if encrypted?
+              if other.encrypted?
+                is_string_equal?(self, other) || is_string_equal?(other, self) || self.can_decrypt? && is_string_equal?(self.decrypt, other) || other.can_decrypt? && is_string_equal?(other.decrypt, self)
+              else
+                is_string_equal?(other, self)
+              end
+            else
+              if other.encrypted?
+                is_string_equal?(self, other)
+              else
+                false
+              end
+            end
+          else
+            is_equal
+          end
+        end
+        
+        private
+        def is_string_equal?(value, encrypted_value) #:nodoc:
+          if encrypted_value.can_decrypt?
+            encrypted_value.decrypt.equals_without_encryption(value)
+          else
+            encrypted_value.equals_without_encryption(encrypted_value.encryptor.encrypt(value))
+          end
+        end
+        
+        def encryptor_from_args(*args) #:nodoc:
+          options = args.last.is_a?(::Hash) ? args.pop : {}
+          mode = (args.first || :sha).to_sym
+          "PluginAWeek::EncryptedStrings::#{mode.to_s.classify}Encryptor".constantize.new(options)
+        end
+      end
+    end
+  end
+end
+
+::String.class_eval do
+  include PluginAWeek::EncryptedStrings::Extensions::String
+end

data/lib/encrypted_strings/no_key_error.rb

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

data/lib/encrypted_strings/no_private_key_error.rb

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

data/lib/encrypted_strings/no_public_key_error.rb

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

data/lib/encrypted_strings/sha_encryptor.rb

@@ -0,0 +1,35 @@
+require 'digest/sha1'
+
+module PluginAWeek #:nodoc:
+  module EncryptedStrings #:nodoc:
+    # Encrypts a string using a Secure Hash Algorithm (SHA), specifically SHA-1.
+    class ShaEncryptor < Encryptor
+      # The default salt value to use during encryption
+      @@default_salt = 'salt'
+      cattr_accessor :default_salt
+      
+      attr_accessor :salt
+      
+      # Configuration options:
+      # * <tt>salt</tt> - Salt value to use for encryption
+      def initialize(options = {})
+        options = options.symbolize_keys
+        options.assert_valid_keys(:salt)
+        options.reverse_merge!(:salt => @@default_salt)
+        @salt = options[:salt]
+        
+        super()
+      end
+      
+      # Decryption is not supported.
+      def can_decrypt?
+        false
+      end
+      
+      # Returns the encrypted value of the data
+      def encrypt(data)
+        Digest::SHA1.hexdigest(data + @salt)
+      end
+    end
+  end
+end

data/lib/encrypted_strings/symmetric_encryptor.rb

@@ -0,0 +1,64 @@
+require 'encrypted_strings/no_key_error'
+
+module PluginAWeek #:nodoc:
+  module EncryptedStrings #:nodoc
+    # 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
+    class SymmetricEncryptor < Encryptor
+      # The default algorithm to use for encryption.  Default is DES
+      @@default_algorithm = 'DES-EDE3-CBC'
+      cattr_accessor :default_algorithm
+      
+      # The default key to use.  Default is nil
+      @@default_key = nil
+      cattr_accessor :default_key
+      
+      attr_accessor :algorithm
+      attr_accessor :key
+      
+      # Configuration options:
+      # * <tt>key</tt> - Private key
+      # * <tt>algorithm</tt> - Algorithm to use
+      def initialize(options = {})
+        options = options.symbolize_keys
+        options.assert_valid_keys(
+          :key,
+          :algorithm
+        )
+        options.reverse_merge!(:key => @@default_key)
+        options[:algorithm] ||= @@default_algorithm # Saves us from nil values for algorithm
+        
+        @key = options[:key]
+        raise NoKeyError if @key.nil?
+        
+        @algorithm = options[:algorithm]
+        
+        super()
+      end
+      
+      # Decrypts the current string using the current key and algorithm specified
+      def decrypt(data)
+        cipher.decrypt(@key)
+        decrypted_data = cipher.update(Base64.decode64(data))
+        decrypted_data << cipher.final
+      end
+      
+      # Encrypts the current string using the current key and algorithm specified
+      def encrypt(data)
+        cipher.encrypt(@key)
+        encrypted_data = cipher.update(data)
+        encrypted_data << cipher.final
+        
+        Base64.encode64(encrypted_data)
+      end
+      
+      private
+      def cipher #:nodoc:
+        @cipher ||= OpenSSL::Cipher::Cipher.new(@algorithm)
+      end
+    end
+  end
+end

data/test/asymmetric_encryptor_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AsymmetricEncryptorTest < 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 = nil
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = nil
+  end
+  
+  def test_should_not_be_public_without_public_key_file
+    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
+    assert !encryptor.public?
+  end
+  
+  def test_should_not_be_private_without_privae_key_file
+    encryptor = PluginAWeek::EncryptedStrings::AsymmetricEncryptor.new
+    assert !encryptor.private?
+  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?
+  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?
+  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)
+  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)
+  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)
+  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)
+  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?
+  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?
+  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
+end

data/test/encryptor_test.rb

@@ -0,0 +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
+end

data/test/keys/encrypted_private

@@ -0,0 +1,12 @@
+OBNa1q8kbx8pyZZjIpr/pZV0oulE2czh5JlPW/13XsBvoz+A2zxA9gchhi6c
+3yvfqgcZdojcsep+IiTqeg3gOPB2xNbedpP1lm+9tEfgdb9r1CLzRcURh7Hg
+ufWgyEkS0lloz/YLy4hg9YDKetFNF9fnrk3xVwZPwFVuk4l/Unw1FTXLHsrq
+KG27cR8mvNOow4bk4LVhk/avFSM85m3ITySEnyJsQQDzsI/RrWcQ7Js+8Ynv
+esN51E/T0CYtkMEne2zSaD5qUTJlQ7Qtn4UUeZkpYjn4xQZPxw4OjL6zofg7
+lsqElSv1/qP3QI8aKcQQklVsHRc5AgsxOFX4J6g6lo4kOGOwn0Ex8IRDfOej
+pq4SUDh9IXz+6FBieQrObB/xEsKysVwRSzXre6ObHlPFsigg5ekFPyCv5ZTz
+0iP8+xe/FJRrYdR3r3F5pRkOy0pw9EqlrLjmOx3/fgxhLq8FWmcSBbH3h3SG
+GkJlfHNjF77FTJjnHKzRS+5VpdW4IHbsjL+NlI1z9Ol//czYvSGv85NdJvkq
+PmH3o0+uYdwY5PeSMOPV21nJ3dwiKlm5IMFasL3C5yVJNVTVZTS7vWdcgZ4U
+XfWQ9Y266ibbqXPluv4nxt1+kgjxmPbjPdYrlB5t7a2+unzT3oE3f4VGOG+k
+YqFg0ErHN+fu

data/test/keys/encrypted_public

@@ -0,0 +1,4 @@
+-----BEGIN RSA PUBLIC KEY-----
+MEgCQQCvktJgveIcgTH98hAhMjo0g6/GVMJaYdUh+/zQn4RBWASRmwEfJqggsfKT
+pSNendZQMD8kKS8J1YTBr60ToM25AgMBAAE=
+-----END RSA PUBLIC KEY-----

data/test/keys/private

@@ -0,0 +1,9 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIBOwIBAAJBAL/xeY6aqFx6z1ThNOwgPgxv3tsonTlCj8VkN3Ikumg6SzBuLxlV
+i9gFQZ7K9Pv9o/7+xUTYODqBpVhwgLBeu2cCAwEAAQJAHyjFMfg7Yp/xLndMzxRA
+3mX+yJckRtpeWo31TktWE3syks1r9OrfmxKiStM9kFRubeBHTihZrW92TYkROLxh
+uQIhAPuftVTJZFDNxeYDKIMIMqwR8KZgtuf25cv4pTxYwPqLAiEAw0gNwDJHBkvo
+da4402pZNQmBA6qCSf0svDXqoEoaShUCIGBma340Oe6LJ0pb42Vv+pnZtazIWMq9
+2IQwmn1oM2bJAiEAhgP869mVRIzzi091UCG79tn+4DU0FPLasI+P5VD1mcECIQDb
+3ndvbPcElVvdJgabxyWJJsNtBBNZYPsuc6NrQyShOw==
+-----END RSA PRIVATE KEY-----

data/test/keys/public

@@ -0,0 +1,4 @@
+-----BEGIN RSA PUBLIC KEY-----
+MEgCQQC/8XmOmqhces9U4TTsID4Mb97bKJ05Qo/FZDdyJLpoOkswbi8ZVYvYBUGe
+yvT7/aP+/sVE2Dg6gaVYcICwXrtnAgMBAAE=
+-----END RSA PUBLIC KEY-----

data/test/no_key_error_test.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class NoKeyErrorTest < Test::Unit::TestCase
+  def test_should_exist
+    assert_not_nil PluginAWeek::EncryptedStrings::NoKeyError
+  end
+end

data/test/no_private_key_error_test.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class NoPrivateKeyErrorTest < Test::Unit::TestCase
+  def test_should_exist
+    assert_not_nil PluginAWeek::EncryptedStrings::NoPrivateKeyError
+  end
+end

data/test/no_public_key_error_test.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class NoPublicKeyErrorTest < Test::Unit::TestCase
+  def test_should_exist
+    assert_not_nil PluginAWeek::EncryptedStrings::NoPublicKeyError
+  end
+end

data/test/sha_encryptor_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class ShaEncryptorTest < Test::Unit::TestCase
+  def setup
+    PluginAWeek::EncryptedStrings::ShaEncryptor.default_salt = 'salt'
+  end
+  
+  def test_should_encrypt_with_default_salt_if_salt_not_specified
+    assert_equal 'f438229716cab43569496f3a3630b3727524b81b', PluginAWeek::EncryptedStrings::ShaEncryptor.new.encrypt('test')
+  end
+  
+  def test_should_encrypt_with_custom_salt_if_salt_specified
+    assert_equal '18e3256d71529db8fa65b2eef24a69ddad7070f3', PluginAWeek::EncryptedStrings::ShaEncryptor.new(:salt => 'different salt').encrypt('test')
+  end
+  
+  def test_should_not_be_able_to_decrypt
+    assert !PluginAWeek::EncryptedStrings::ShaEncryptor.new.can_decrypt?
+  end
+  
+  def test_should_raise_exception_if_trying_to_decrypt
+    assert_raises(NotImplementedError) { PluginAWeek::EncryptedStrings::ShaEncryptor.new.decrypt('test') }
+  end
+end

data/test/string_test.rb

@@ -0,0 +1,77 @@
+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

data/test/symmetric_encryptor_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class SymmetricallyEncryptedStringTest < Test::Unit::TestCase
+  def setup
+    @data = 'test'
+    @key = 'secret'
+    @encrypted = "MU6e/5LvhKA=\n"
+    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = nil
+  end
+  
+  def test_should_raise_exception_if_no_key_specified
+    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_be_able_to_decrypt
+    assert PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).can_decrypt?
+  end
+  
+  def test_should_decrypt_encrypted_string_with_custom_key_if_key_specified
+    assert_equal @data, PluginAWeek::EncryptedStrings::SymmetricEncryptor.new(:key => @key).decrypt(@encrypted)
+  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)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require "#{File.dirname(__FILE__)}/../init"

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: encrypted_strings
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-08-05 00:00:00 -04:00
+summary: Dead-simple string encryption/decryption syntax.
+require_paths: 
+- lib
+email: info@pluginaweek.org
+homepage: http://www.pluginaweek.org
+rubyforge_project: 
+description: 
+autorequire: encrypted_strings
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Aaron Pfeifer, Neil Abraham
+files: 
+- 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/no_public_key_error.rb
+- lib/encrypted_strings/sha_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
+- 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
+- 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
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+    version: