pluginaweek-encrypted_attributes 0.4.0

data/CHANGELOG.rdoc

@@ -0,0 +1,48 @@
+== master
+
+== 0.4.0 / 2009-05-02
+
+* Replace dynamic :salt option with :embed_salt option and utilizing the #encrypts block 
+* Allow a block to be used for dynamically defining encryption options
+* Add :before / :after callbacks for hooking into the encryption process
+* Allow the callback when encryption occurs to be customized [Sergio Salvatore]
+* Define source attribute accessor if different than target and not defined [Sergio Salvatore]
+* Update tests to work with Rails 2.3
+
+== 0.3.0 / 2008-12-14
+
+* Remove the PluginAWeek namespace
+
+== 0.2.0 / 2008-12-4
+
+* Update to be compatible with encrypted_strings 0.2.1
+
+== 0.1.3 / 2008-10-26
+
+* Change how the base module is included to prevent namespacing conflicts
+
+== 0.1.2 / 2008-07-05
+
+* Leave salt stringification up to PluginAWeek::EncryptedString::ShaEncryptor
+
+== 0.1.1 / 2008-06-22
+
+* Remove log files from gems
+
+== 0.1.0 / 2008-05-05
+
+* Don't extend encrypted_string's encryptors, instead creating subclasses
+* Don't assume anything about attribute confirmations
+* Support storing the salt for SHA encryption in the same string as the original value
+* Update documentation
+
+== 0.0.2 / 2007-09-26
+
+* Move test fixtures out of the test application root directory
+* Convert dos newlines to unix newlines
+
+== 0.0.1 / 2007-08-05
+
+* Official public release
+* Add documentation
+* Refactor unit test names

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2009 Aaron Pfeifer
+
+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.rdoc

@@ -0,0 +1,110 @@
+= encrypted_attributes
+
++encrypted_attributes+ adds support for automatically encrypting ActiveRecord
+attributes.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/encrypted_attributes
+
+Bugs
+
+* http://pluginaweek.lighthouseapp.com/projects/13269-encrypted_attributes
+
+Development
+
+* http://github.com/pluginaweek/encrypted_attributes
+
+Source
+
+* git://github.com/pluginaweek/encrypted_attributes.git
+
+== Description
+
+Encrypting attributes can be repetitive especially when doing so throughout
+various models and various projects.  encrypted_attributes, in association
+with the encrypted_strings library, helps make encrypting ActiveRecord
+attributes easier by automating the process.
+
+The options that +encrypts+ takes includes all of the encryption options for
+the specific type of cipher being used from the encrypted_strings library.
+Therefore, if setting the key for asymmetric encryption, this would be passed
+into the +encrypts+ method.  Examples of this are show in the Usage section.
+
+== Usage
+
+=== Encryption Modes
+
+SHA, symmetric, and asymmetric encryption modes are supported (default is SHA):
+
+  class User < ActiveRecord::Base
+    encrypts :password, :salt => 'secret'
+    # encrypts :password, :mode => :symmetric, :password => 'secret'
+    # encrypts :password, :mode => :asymmetric, :public_key_file => '/keys/public', :private_key_file => '/keys/private'
+  end
+
+=== Dynamic Configuration
+
+The encryption configuration can be dynamically set like so:
+
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :sha do |user|
+      {:salt => "#{user.login}-#{Time.now}", :embed_salt => true}
+    end
+  end
+
+In this case, the salt and password values are combined and stored in the
+attribute being encrypted.  Therefore, there's no need to add a second column
+for storing the salt value.
+
+To store the dynamic salt in a separate column:
+
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :sha, :before => :create_salt do |user|
+      {:salt => user.salt}
+    end
+    
+    def create_salt
+      self.salt = "#{login}-#{Time.now}"
+    end
+  end
+
+=== Targeted Encryption
+
+If you want to store the encrypted value in a different attribute than the
+attribute being encrypted:
+
+  class User < ActiveRecord::Base
+    encrypts :password, :to => :crypted_password
+  end
+
+=== Conditional Encryption
+
+Like ActiveRecord validations, +encrypts+ can take <tt>:if</tt> and <tt>:unless</tt>
+parameters that determine whether the encryption should occur.  For example,
+
+  class User < ActiveRecord::Base
+    encrypts :password, :if => lambda {Rails.env != 'development'}
+  end
+
+=== Additional information
+
+For more examples of actual migrations and models that encrypt attributes,
+see the actual API and unit tests.  Also, see encrypted_strings for more
+information about the various options that can be passed in.
+
+== Testing
+
+Before you can run any tests, the following gem must be installed:
+* plugin_test_helper[http://github.com/pluginaweek/plugin_test_helper]
+
+To run against a specific version of Rails:
+
+  rake test RAILS_FRAMEWORK_ROOT=/path/to/rails
+
+== Dependencies
+
+* Rails 2.1 or later
+* encrypted_strings[http://github.com/pluginaweek/encrypted_strings]

data/Rakefile

@@ -0,0 +1,97 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'encrypted_attributes'
+  s.version           = '0.4.0'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Adds support for automatically encrypting ActiveRecord attributes'
+  s.description       = s.summary
+  
+  s.files             = FileList['{lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/app_root/{log,log/*,script,script/*}']
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  s.add_dependency    'encrypted_strings', '>= 0.3.0'
+  
+  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 #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+
+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
+
+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
+
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+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('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
+end
+
+desc 'Publish the API documentation.'
+task :pdoc => [:rdoc] do
+  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 => [:pgem, :pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new.configure
+  ruby_forge.login
+  
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
+  end
+end

data/init.rb

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

data/lib/encrypted_attributes/sha_cipher.rb

@@ -0,0 +1,30 @@
+module EncryptedAttributes
+  # Adds support for embedding salts in the encrypted value
+  class ShaCipher < EncryptedStrings::ShaCipher
+    # Encrypts a string using a Secure Hash Algorithm (SHA), specifically SHA-1.
+    # 
+    # Configuration options:
+    # * <tt>:salt</tt> - Random bytes used as one of the inputs for generating
+    #   the encrypted string
+    # * <tt>:embed_salt</tt> - Whether to embed the salt directly within the
+    #   encrypted value.  Default is false.  This is useful for storing both
+    #   the salt and the encrypted value in the same attribute.
+    def initialize(value, options = {}) #:nodoc:
+      if @embed_salt = options.delete(:embed_salt)
+        # The salt is at the end of the value
+        salt = value[40..-1]
+        options[:salt] = salt unless salt.blank?
+      end
+      
+      super(options)
+    end
+    
+    # Encrypts the data, embedding the salt at the end of the string if
+    # configured to do so
+    def encrypt(data)
+      encrypted_data = super
+      encrypted_data << salt if @embed_salt
+      encrypted_data
+    end
+  end
+end

data/lib/encrypted_attributes.rb

@@ -0,0 +1,207 @@
+require 'encrypted_strings'
+require 'encrypted_attributes/sha_cipher'
+
+module EncryptedAttributes
+  module MacroMethods
+    # Encrypts the given attribute.
+    # 
+    # Configuration options:
+    # * <tt>:mode</tt> - The mode of encryption to use.  Default is <tt>:sha</tt>.
+    #   See EncryptedStrings for other possible modes.
+    # * <tt>:to</tt> - The attribute to write the encrypted value to. Default
+    #   is the same attribute being encrypted.
+    # * <tt>:before</tt> - The callback to invoke every time *before* the
+    #   attribute is encrypted
+    # * <tt>:after</tt> - The callback to invoke every time *after* the
+    #   attribute is encrypted
+    # * <tt>:on</tt> - The ActiveRecord callback to use when triggering the
+    #   encryption.  By default, this will encrypt on <tt>before_validation</tt>.
+    #   See ActiveRecord::Callbacks for a list of possible callbacks.
+    # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+    #   if the encryption should occur. The method, proc or string should return
+    #   or evaluate to a true or false value.
+    # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+    #   determine if the encryption should not occur. The method, proc or string
+    #   should return or evaluate to a true or false value. 
+    # 
+    # For additional configuration options used during the actual encryption,
+    # see the individual cipher class for the specified mode.
+    # 
+    # == Encryption timeline
+    # 
+    # By default, attributes are encrypted immediately before a record is
+    # validated.  This means that you can still validate the presence of the
+    # encrypted attribute, but other things like password length cannot be
+    # validated without either (a) decrypting the value first or (b) using a
+    # different encryption target.  For example,
+    # 
+    #   class User < ActiveRecord::Base
+    #     encrypts :password, :to => :crypted_password
+    #     
+    #     validates_presence_of :password, :crypted_password
+    #     validates_length_of :password, :maximum => 16
+    #   end
+    # 
+    # In the above example, the actual encrypted password will be stored in
+    # the +crypted_password+ attribute.  This means that validations can
+    # still run against the model for the original password value.
+    # 
+    #   user = User.new(:password => 'secret')
+    #   user.password             # => "secret"
+    #   user.crypted_password     # => nil
+    #   user.valid?               # => true
+    #   user.crypted_password     # => "8152bc582f58c854f580cb101d3182813dec4afe"
+    #   
+    #   user = User.new(:password => 'longer_than_the_maximum_allowed')
+    #   user.valid?               # => false
+    #   user.crypted_password     # => "e80a709f25798f87d9ca8005a7f64a645964d7c2"
+    #   user.errors[:password]    # => "is too long (maximum is 16 characters)"
+    # 
+    # == Encryption mode examples
+    # 
+    # SHA encryption:
+    # 
+    #   class User < ActiveRecord::Base
+    #     encrypts :password
+    #     # encrypts :password, :salt => 'secret'
+    #   end
+    # 
+    # Symmetric encryption:
+    # 
+    #   class User < ActiveRecord::Base
+    #     encrypts :password, :mode => :symmetric
+    #     # encrypts :password, :mode => :symmetric, :key => 'custom'
+    #   end
+    # 
+    # Asymmetric encryption:
+    # 
+    #   class User < ActiveRecord::Base
+    #     encrypts :password, :mode => :asymmetric
+    #     # encrypts :password, :mode => :asymmetric, :public_key_file => '/keys/public', :private_key_file => '/keys/private'
+    #   end
+    # 
+    # == Dynamic configuration
+    # 
+    # For better security, the encryption options (such as the salt value)
+    # can be based on values in each individual record.  In order to
+    # dynamically configure the encryption options so that individual records
+    # can be referenced, an optional block can be specified.
+    # 
+    # For example,
+    # 
+    #   class User < ActiveRecord::Base
+    #     encrypts :password, :mode => :sha, :before => :create_salt do |user|
+    #       {:salt => user.salt}
+    #     end
+    #     
+    #     private
+    #       def create_salt
+    #         self.salt = "#{login}-#{Time.now}"
+    #       end
+    #   end
+    # 
+    # In the above example, the SHA encryption's <tt>salt</tt> is configured
+    # dynamically based on the user's login and the time at which it was
+    # encrypted.  This helps improve the security of the user's password.
+    def encrypts(attr_name, options = {}, &config)
+      config ||= options
+      attr_name = attr_name.to_s
+      to_attr_name = (options.delete(:to) || attr_name).to_s
+      
+      # Figure out what cipher is being configured for the attribute
+      mode = options.delete(:mode) || :sha
+      class_name = "#{mode.to_s.classify}Cipher"
+      if EncryptedAttributes.const_defined?(class_name)
+        cipher_class = EncryptedAttributes.const_get(class_name)
+      else
+        cipher_class = EncryptedStrings.const_get(class_name)
+      end
+      
+      # Define encryption hooks
+      define_callbacks("before_encrypt_#{attr_name}", "after_encrypt_#{attr_name}")
+      send("before_encrypt_#{attr_name}", options.delete(:before)) if options.include?(:before)
+      send("after_encrypt_#{attr_name}", options.delete(:after)) if options.include?(:after)
+      
+      # Set the encrypted value on the configured callback
+      callback = options.delete(:on) || :before_validation
+      send(callback, :if => options.delete(:if), :unless => options.delete(:unless)) do |record|
+        record.send(:write_encrypted_attribute, attr_name, to_attr_name, cipher_class, config)
+        true
+      end
+      
+      # Define virtual source attribute
+      if attr_name != to_attr_name && !column_names.include?(attr_name)
+        attr_reader attr_name unless method_defined?(attr_name)
+        attr_writer attr_name unless method_defined?("#{attr_name}=")
+      end
+      
+      # Define the reader when reading the encrypted attribute from the database
+      define_method(to_attr_name) do
+        read_encrypted_attribute(to_attr_name, cipher_class, config)
+      end
+      
+      unless included_modules.include?(EncryptedAttributes::InstanceMethods)
+        include EncryptedAttributes::InstanceMethods
+      end
+    end
+  end
+  
+  module InstanceMethods #:nodoc:
+    private
+      # Encrypts the given attribute to a target location using the encryption
+      # options configured for that attribute
+      def write_encrypted_attribute(attr_name, to_attr_name, cipher_class, options)
+        value = send(attr_name)
+        
+        # Only encrypt values that actually have content and have not already
+        # been encrypted
+        unless value.blank? || value.encrypted?
+          callback("before_encrypt_#{attr_name}")
+          
+          # Create the cipher configured for this attribute
+          cipher = create_cipher(cipher_class, options, value)
+          
+          # Encrypt the value
+          value = cipher.encrypt(value)
+          value.cipher = cipher
+          
+          # Update the value based on the target attribute
+          send("#{to_attr_name}=", value)
+          
+          callback("after_encrypt_#{attr_name}")
+        end
+      end
+      
+      # Reads the given attribute from the database, adding contextual
+      # information about how it was encrypted so that equality comparisons
+      # can be used
+      def read_encrypted_attribute(to_attr_name, cipher_class, options)
+        value = read_attribute(to_attr_name)
+        
+        # Make sure we set the cipher for equality comparison when reading
+        # from the database. This should only be done if the value is *not*
+        # blank, is *not* encrypted, and hasn't changed since it was read from
+        # the database. The dirty checking is important when the encypted value
+        # is written to the same attribute as the unencrypted value (i.e. you
+        # don't want to encrypt when a new value has been set)
+        unless value.blank? || value.encrypted? || attribute_changed?(to_attr_name)
+          # Create the cipher configured for this attribute
+          value.cipher = create_cipher(cipher_class, options, value)
+        end
+        
+        value
+      end
+      
+      # Creates a new cipher with the given configuration options
+      def create_cipher(klass, options, value)
+        options = options.is_a?(Proc) ? options.call(self) : options.dup
+        
+        # Only use the contextual information for this plugin's ciphers
+        klass.parent == EncryptedAttributes ? klass.new(value, options) : klass.new(options)
+      end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend EncryptedAttributes::MacroMethods
+end

data/test/app_root/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  validates_presence_of :login
+end

data/test/app_root/config/environment.rb

@@ -0,0 +1,9 @@
+require 'config/boot'
+
+Rails::Initializer.run do |config|
+  config.plugin_paths << '..'
+  config.plugins = %w(encrypted_strings encrypted_attributes)
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
+end

data/test/app_root/db/migrate/001_create_users.rb

@@ -0,0 +1,11 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :login, :password, :crypted_password, :salt
+    end
+  end
+  
+  def self.down
+    drop_table :users
+  end
+end

data/test/factory.rb

@@ -0,0 +1,41 @@
+module Factory
+  # Build actions for the model
+  def self.build(model, &block)
+    name = model.to_s.underscore
+    
+    define_method("#{name}_attributes", block)
+    define_method("valid_#{name}_attributes") {|*args| valid_attributes_for(model, *args)}
+    define_method("new_#{name}")              {|*args| new_record(model, *args)}
+    define_method("create_#{name}")           {|*args| create_record(model, *args)}
+  end
+  
+  # Get valid attributes for the model
+  def valid_attributes_for(model, attributes = {})
+    name = model.to_s.underscore
+    send("#{name}_attributes", attributes)
+    attributes.stringify_keys!
+    attributes
+  end
+  
+  # Build an unsaved record
+  def new_record(model, *args)
+    attributes = valid_attributes_for(model, *args)
+    record = model.new(attributes)
+    attributes.each {|attr, value| record.send("#{attr}=", value) if model.accessible_attributes && !model.accessible_attributes.include?(attr) || model.protected_attributes && model.protected_attributes.include?(attr)}
+    record
+  end
+  
+  # Build and save/reload a record
+  def create_record(model, *args)
+    record = new_record(model, *args)
+    record.save!
+    record.reload
+    record
+  end
+  
+  build User do |attributes|
+    attributes.reverse_merge!(
+      :login => 'admin'
+    )
+  end
+end

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/test_helper.rb

@@ -0,0 +1,13 @@
+# Load the plugin testing framework
+$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
+require 'rubygems'
+require 'plugin_test_helper'
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+# Mixin the factory helper
+require File.expand_path("#{File.dirname(__FILE__)}/factory")
+Test::Unit::TestCase.class_eval do
+  include Factory
+end

data/test/unit/encrypted_attributes_test.rb

@@ -0,0 +1,446 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EncryptedAttributesTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password
+  end
+  
+  def test_should_use_sha_by_default
+    user = create_user(:login => 'admin', :password => 'secret')
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_encrypt_on_invalid_model
+    user = new_user(:login => nil, :password => 'secret')
+    assert !user.valid?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_not_encrypt_if_attribute_is_nil
+    user = create_user(:login => 'admin', :password => nil)
+    assert_nil user.password
+  end
+  
+  def test_should_not_encrypt_if_attribute_is_blank
+    user = create_user(:login => 'admin', :password => '')
+    assert_equal '', user.password
+  end
+  
+  def test_should_not_encrypt_if_already_encrypted
+    user = create_user(:login => 'admin', :password => 'secret'.encrypt)
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_return_encrypted_attribute_for_saved_record
+    user = create_user(:login => 'admin', :password => 'secret')
+    user = User.find(user.id)
+    assert user.password.encrypted?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_not_encrypt_attribute_if_updating_without_any_changes
+    user = create_user(:login => 'admin', :password => 'secret')
+    user.login = 'Administrator'
+    user.save!
+    assert user.password.encrypted?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_encrypt_attribute_if_updating_with_changes
+    user = create_user(:login => 'admin', :password => 'secret')
+    user.password = 'shhh'
+    user.save!
+    assert user.password.encrypted?
+    assert_equal '162cf5debf84cbc2af13da848544c3e2c515b4d3', "#{user.password}"
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithDifferentTargetTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :to => :crypted_password
+  end
+  
+  def test_should_not_encrypt_if_attribute_is_nil
+    user = create_user(:login => 'admin', :password => nil)
+    assert_nil user.password
+    assert_nil user.crypted_password
+  end
+  
+  def test_should_not_encrypt_if_attribute_is_blank
+    user = create_user(:login => 'admin', :password => '')
+    assert_equal '', user.password
+    assert_nil user.crypted_password
+  end
+  
+  def test_should_not_encrypt_if_already_encrypted
+    user = create_user(:login => 'admin', :crypted_password => 'secret'.encrypt)
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.crypted_password}"
+  end
+  
+  def test_should_return_encrypted_attribute_for_saved_record
+    user = create_user(:login => 'admin', :password => 'secret')
+    user = User.find(user.id)
+    assert user.crypted_password.encrypted?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.crypted_password}"
+  end
+  
+  def test_should_not_encrypt_attribute_if_updating_without_any_changes
+    user = create_user(:login => 'admin', :password => 'secret')
+    user.login = 'Administrator'
+    user.save!
+    assert user.crypted_password.encrypted?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.crypted_password}"
+  end
+  
+  def test_should_encrypt_attribute_if_updating_with_changes
+    user = create_user(:login => 'admin', :password => 'secret')
+    user.password = 'shhh'
+    user.save!
+    assert user.crypted_password.encrypted?
+    assert_equal '162cf5debf84cbc2af13da848544c3e2c515b4d3', "#{user.crypted_password}"
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithVirtualAttributeSourceTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :raw_password, :to => :crypted_password
+  end
+  
+  def test_should_define_source_reader
+    assert User.method_defined?(:raw_password)
+  end
+  
+  def test_should_define_source_writer
+    assert User.method_defined?(:raw_password=)
+  end
+  
+  def test_should_encrypt_from_virtual_attribute
+    user = create_user(:login => 'admin', :raw_password => 'secret')
+    assert user.crypted_password.encrypted?
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.crypted_password}"
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+      
+      remove_method(:raw_password)
+      remove_method(:raw_password=)
+    end
+  end
+end
+
+class EncryptedAttributesWithConflictingVirtualAttributeSourceTest < ActiveSupport::TestCase
+  def setup
+    User.class_eval do
+      def raw_password
+        'raw_password'
+      end
+      
+      def raw_password=(value)
+        self.password = value
+      end
+    end
+    
+    User.encrypts :raw_password, :to => :crypted_password
+    @user = User.new
+  end
+  
+  def test_should_not_define_source_reader
+    assert_equal 'raw_password', @user.raw_password
+  end
+  
+  def test_should_not_define_source_writer
+    @user.raw_password = 'raw_password'
+    assert_equal 'raw_password', @user.password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+      
+      remove_method(:raw_password)
+      remove_method(:raw_password=)
+    end
+  end
+end
+
+class EncryptedAttributesWithCustomCallbackTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :on => :before_save
+  end
+  
+  def test_should_not_encrypt_on_validation
+    user = new_user(:login => 'admin', :password => 'secret')
+    user.valid?
+    assert_equal 'secret', user.password
+  end
+  
+  def test_should_encrypt_on_create
+    user = new_user(:login => 'admin', :password => 'secret')
+    user.save
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_save_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithConditionalsTest < ActiveSupport::TestCase
+  def test_should_not_encrypt_if_if_conditional_is_false
+    User.encrypts :password, :if => lambda {|user| false}
+    user = create_user(:login => 'admin', :password => 'secret')
+    assert_equal 'secret', user.password
+  end
+  
+  def test_should_encrypt_if_if_conditional_is_true
+    User.encrypts :password, :if => lambda {|user| true}
+    user = create_user(:login => 'admin', :password => 'secret')
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def test_should_not_encrypt_if_unless_conditional_is_true
+    User.encrypts :password, :unless => lambda {|user| true}
+    user = create_user(:login => 'admin', :password => 'secret')
+    assert_equal 'secret', user.password
+  end
+  
+  def test_should_encrypt_if_unless_conditional_is_false
+    User.encrypts :password, :unless => lambda {|user| false}
+    user = create_user(:login => 'admin', :password => 'secret')
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{user.password}"
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithBeforeCallbacksTest < ActiveSupport::TestCase
+  def setup
+    @password = nil
+    @ran_callback = false
+    User.encrypts :password, :before => lambda {|user| @ran_callback = true; @password = user.password.to_s}
+    
+    create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_run_callback
+    assert @ran_callback
+  end
+  
+  def test_should_not_have_encrypted_yet
+    assert_equal 'secret', @password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+      @before_encrypt_password_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithAfterCallbacksTest < ActiveSupport::TestCase
+  def setup
+    @password = nil
+    @ran_callback = false
+    User.encrypts :password, :after => lambda {|user| @ran_callback = true; @password = user.password.to_s}
+    
+    create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_run_callback
+    assert @ran_callback
+  end
+  
+  def test_should_have_encrypted_already
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', @password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+      @after_encrypt_password_callbacks = nil
+    end
+  end
+end
+
+class EncryptedAttributesWithDynamicConfigurationTest < ActiveSupport::TestCase
+  def setup
+    @salt = nil
+    User.encrypts :password, :before => lambda {|user| user.salt = user.login} do |user|
+      {:salt => @salt = user.salt}
+    end
+    
+    @user = create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_use_dynamic_configuration_during_write
+    assert_equal 'a55d037f385cad22efe7862e07b805938d150154', "#{@user[:password]}"
+  end
+  
+  def test_should_use_dynamic_configuration_during_read
+    user = User.find(@user.id)
+    assert_equal 'a55d037f385cad22efe7862e07b805938d150154', "#{user.password}"
+  end
+  
+  def test_should_build_configuration_after_before_callbacks_invoked
+    assert_equal 'admin', @salt
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+      @before_encrypt_password_callbacks = nil
+    end
+  end
+end
+
+class ShaEncryptionTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :mode => :sha
+    @user = create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_encrypt_password
+    assert_equal '8152bc582f58c854f580cb101d3182813dec4afe', "#{@user.password}"
+  end
+  
+  def test_should_be_encrypted
+    assert @user.password.encrypted?
+  end
+  
+  def test_should_use_sha_cipher
+    assert_instance_of EncryptedAttributes::ShaCipher, @user.password.cipher
+  end
+  
+  def test_should_use_default_salt
+    assert_equal 'salt', @user.password.cipher.salt
+  end
+  
+  def test_should_be_able_to_check_password
+    assert_equal 'secret', @user. password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class ShaWithEmbeddedSaltEncryptionTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :mode => :sha, :salt => 'admin', :embed_salt => true
+    @user = create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_encrypt_password
+    assert_equal 'a55d037f385cad22efe7862e07b805938d150154admin', "#{@user.password}"
+  end
+  
+  def test_should_be_encrypted
+    assert @user.password.encrypted?
+  end
+  
+  def test_should_use_sha_cipher
+    assert_instance_of EncryptedAttributes::ShaCipher, @user.password.cipher
+  end
+  
+  def test_should_use_custom_salt
+    assert_equal 'admin', @user.password.cipher.salt
+  end
+  
+  def test_should_be_able_to_check_password
+    assert_equal 'secret', @user.password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class SymmetricEncryptionTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :mode => :symmetric, :password => 'key'
+    @user = create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_encrypt_password
+    assert_equal "zfKtnSa33tc=\n", @user.password
+  end
+  
+  def test_should_be_encrypted
+    assert @user.password.encrypted?
+  end
+  
+  def test_should_use_sha_cipher
+    assert_instance_of EncryptedStrings::SymmetricCipher, @user.password.cipher
+  end
+  
+  def test_should_use_custom_password
+    assert_equal 'key', @user.password.cipher.password
+  end
+  
+  def test_should_be_able_to_check_password
+    assert_equal 'secret', @user.password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end
+
+class AsymmetricEncryptionTest < ActiveSupport::TestCase
+  def setup
+    User.encrypts :password, :mode => :asymmetric,
+      :private_key_file => File.dirname(__FILE__) + '/../keys/private',
+      :public_key_file => File.dirname(__FILE__) + '/../keys/public'
+    @user = create_user(:login => 'admin', :password => 'secret')
+  end
+  
+  def test_should_encrypt_password
+    assert_not_equal 'secret', "#{@user.password}"
+    assert_equal 90, @user.password.length
+  end
+  
+  def test_should_be_encrypted
+    assert @user.password.encrypted?
+  end
+  
+  def test_should_use_sha_cipher
+    assert_instance_of EncryptedStrings::AsymmetricCipher, @user.password.cipher
+  end
+  
+  def test_should_be_able_to_check_password
+    assert_equal 'secret', @user.password
+  end
+  
+  def teardown
+    User.class_eval do
+      @before_validation_callbacks = nil
+    end
+  end
+end

data/test/unit/sha_cipher_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ShaCipherWithoutEmbeddingTest < Test::Unit::TestCase
+  def setup
+    @cipher = EncryptedAttributes::ShaCipher.new('dc0fc7c07bba982a8d8f18fe138dbea912df5e0e', :salt => 'custom_salt')
+  end
+  
+  def test_should_use_configured_salt
+    assert_equal 'custom_salt', @cipher.salt
+  end
+  
+  def test_should_not_embed_salt_in_encrypted_string
+    assert_equal 'dc0fc7c07bba982a8d8f18fe138dbea912df5e0e', @cipher.encrypt('secret')
+  end
+end
+
+class ShaCipherWithNoSaltEmbeddedTest < Test::Unit::TestCase
+  def setup
+    @cipher = EncryptedAttributes::ShaCipher.new('dc0fc7c07bba982a8d8f18fe138dbea912df5e0e', :embed_salt => true, :salt => 'custom_salt')
+  end
+  
+  def test_should_use_configured_salt
+    assert_equal 'custom_salt', @cipher.salt
+  end
+  
+  def test_should_embed_salt_in_encrypted_string
+    assert_equal 'dc0fc7c07bba982a8d8f18fe138dbea912df5e0ecustom_salt', @cipher.encrypt('secret')
+  end
+end
+
+class ShaCipherWithSaltEmbeddedTest < Test::Unit::TestCase
+  def setup
+    @cipher = EncryptedAttributes::ShaCipher.new('dc0fc7c07bba982a8d8f18fe138dbea912df5e0ecustom_salt', :embed_salt => true, :salt => 'ignored_salt')
+  end
+  
+  def test_should_use_remaining_characters_after_password_for_salt
+    assert_equal 'custom_salt', @cipher.salt
+  end
+  
+  def test_should_embed_salt_in_encrypted_string
+    assert_equal 'dc0fc7c07bba982a8d8f18fe138dbea912df5e0ecustom_salt', @cipher.encrypt('secret')
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: pluginaweek-encrypted_attributes
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Aaron Pfeifer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: encrypted_strings
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+description: Adds support for automatically encrypting ActiveRecord attributes
+email: aaron@pluginaweek.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/encrypted_attributes
+- lib/encrypted_attributes/sha_cipher.rb
+- lib/encrypted_attributes.rb
+- test/unit
+- test/unit/encrypted_attributes_test.rb
+- test/unit/sha_cipher_test.rb
+- test/keys
+- test/keys/private
+- test/keys/public
+- test/factory.rb
+- test/app_root
+- test/app_root/app
+- test/app_root/app/models
+- test/app_root/app/models/user.rb
+- test/app_root/db
+- test/app_root/db/migrate
+- test/app_root/db/migrate/001_create_users.rb
+- test/app_root/config
+- test/app_root/config/environment.rb
+- test/test_helper.rb
+- CHANGELOG.rdoc
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://www.pluginaweek.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pluginaweek
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Adds support for automatically encrypting ActiveRecord attributes
+test_files: 
+- test/unit/encrypted_attributes_test.rb
+- test/unit/sha_cipher_test.rb