attr_encrypted 1.2.1 → 1.3.0

data/README.rdoc

@@ -1,4 +1,4 @@
-= attr_encrypted
+= attr_encrypted {<img src="https://travis-ci.org/attr-encrypted/attr_encrypted.png" />}[https://travis-ci.org/attr-encrypted/attr_encrypted]
 
 Generates attr_accessors that encrypt and decrypt attributes transparently
 
@@ -299,4 +299,4 @@ Just like the default options for <tt>ActiveRecord</tt>, the <tt>:encode</tt> op
 * Add tests for it. This is important so I don't break it in a
   future version unintentionally.
 * Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -2,9 +2,6 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-desc 'Default: run unit tests.'
-task :default => :test
-
 desc 'Test the attr_encrypted gem.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
@@ -19,4 +16,18 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.options << '--line-numbers' << '--inline-source'
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
-end
+end
+
+if RUBY_VERSION < '1.9.3'
+  require 'rcov/rcovtask'
+
+  task :rcov do
+    system "rcov -o coverage/rcov --exclude '^(?!lib)' " + FileList[ 'test/**/*_test.rb' ].join(' ')
+  end
+
+  desc 'Default: run unit tests under rcov.'
+  task :default => :rcov
+else
+  desc 'Default: run unit tests.'
+  task :default => :test
+end

data/lib/attr_encrypted.rb

@@ -69,6 +69,12 @@ module AttrEncrypted
   #                        method then the result of the method will be evaluated. Any objects that respond to <tt>:call</tt> are evaluated as well.
   #                        Defaults to false.
   #
+  #   :mode             => Selects encryption mode for attribute: choose <tt>:single_iv_and_salt</tt> for compatibility
+  #                        with the old attr_encrypted API: the default IV and salt of the underlying encryptor object
+  #                        is used; <tt>:per_attribute_iv_and_salt</tt> uses a per-attribute IV and salt attribute and
+  #                        is the recommended mode for new deployments.
+  #                        Defaults to <tt>:single_iv_and_salt</tt>.
+  #
   # You can specify your own default options
   #
   #   class User
@@ -110,7 +116,8 @@ module AttrEncrypted
       :load_method      => 'load',
       :encryptor        => Encryptor,
       :encrypt_method   => 'encrypt',
-      :decrypt_method   => 'decrypt'
+      :decrypt_method   => 'decrypt',
+      :mode             => :single_iv_and_salt
     }.merge!(attr_encrypted_options).merge!(attributes.last.is_a?(Hash) ? attributes.pop : {})
 
     options[:encode] = options[:default_encoding] if options[:encode] == true
@@ -122,11 +129,29 @@ module AttrEncrypted
       attr_reader encrypted_attribute_name unless instance_methods_as_symbols.include?(encrypted_attribute_name)
       attr_writer encrypted_attribute_name unless instance_methods_as_symbols.include?(:"#{encrypted_attribute_name}=")
 
+      if options[:mode] == :per_attribute_iv_and_salt
+        attr_reader (encrypted_attribute_name.to_s + "_iv").to_sym unless instance_methods_as_symbols.include?((encrypted_attribute_name.to_s + "_iv").to_sym )
+        attr_writer (encrypted_attribute_name.to_s + "_iv").to_sym unless instance_methods_as_symbols.include?((encrypted_attribute_name.to_s + "_iv").to_sym )
+
+        attr_reader (encrypted_attribute_name.to_s + "_salt").to_sym unless instance_methods_as_symbols.include?((encrypted_attribute_name.to_s + "_salt").to_sym )
+        attr_writer (encrypted_attribute_name.to_s + "_salt").to_sym unless instance_methods_as_symbols.include?((encrypted_attribute_name.to_s + "_salt").to_sym )
+      end
+
       define_method(attribute) do
+        if options[:mode] == :per_attribute_iv_and_salt
+          load_iv_for_attribute(attribute,encrypted_attribute_name, options[:algorithm])
+          load_salt_for_attribute(attribute,encrypted_attribute_name)
+        end
+
         instance_variable_get("@#{attribute}") || instance_variable_set("@#{attribute}", decrypt(attribute, send(encrypted_attribute_name)))
       end
 
       define_method("#{attribute}=") do |value|
+        if options[:mode] == :per_attribute_iv_and_salt
+          load_iv_for_attribute(attribute, encrypted_attribute_name, options[:algorithm])
+          load_salt_for_attribute(attribute, encrypted_attribute_name)
+        end
+
         send("#{encrypted_attribute_name}=", encrypt(attribute, value))
         instance_variable_set("@#{attribute}", value)
       end
@@ -300,6 +325,25 @@ module AttrEncrypted
           option
         end
       end
+
+      def load_iv_for_attribute (attribute, encrypted_attribute_name, algorithm)
+        iv = send("#{encrypted_attribute_name.to_s + "_iv"}")
+          if(iv == nil)
+            begin
+              algorithm = algorithm || "aes-256-cbc"
+              algo = OpenSSL::Cipher::Cipher.new(algorithm)
+              iv = [algo.random_iv].pack("m")
+              send("#{encrypted_attribute_name.to_s + "_iv"}=", iv)
+            rescue RuntimeError
+            end
+          end
+        self.class.encrypted_attributes[attribute.to_sym] = self.class.encrypted_attributes[attribute.to_sym].merge(:iv => iv.unpack("m").first) if (iv && !iv.empty?)
+      end
+
+      def load_salt_for_attribute(attribute, encrypted_attribute_name)
+        salt = send("#{encrypted_attribute_name.to_s + "_salt"}") || send("#{encrypted_attribute_name.to_s + "_salt"}=", Digest::SHA256.hexdigest((Time.now.to_i * rand(1000)).to_s)[0..15])
+        self.class.encrypted_attributes[attribute.to_sym] = self.class.encrypted_attributes[attribute.to_sym].merge(:salt => salt)
+      end
   end
 end
 

data/lib/attr_encrypted/adapters/active_record.rb

@@ -6,6 +6,14 @@ if defined?(ActiveRecord::Base)
           base.class_eval do
             attr_encrypted_options[:encode] = true
             class << self; alias_method_chain :method_missing, :attr_encrypted; end
+
+            def assign_attributes_with_attr_encrypted(*args)
+              attributes = args.shift
+              encrypted_attributes = self.class.encrypted_attributes.keys
+              assign_attributes_without_attr_encrypted attributes.except(*encrypted_attributes), *args
+              assign_attributes_without_attr_encrypted attributes.slice(*encrypted_attributes), *args
+            end
+            alias_method_chain :assign_attributes, :attr_encrypted
           end
         end
 
@@ -16,6 +24,7 @@ if defined?(ActiveRecord::Base)
           def attr_encrypted(*attrs)
             define_attribute_methods rescue nil
             super
+            undefine_attribute_methods
             attrs.reject { |attr| attr.is_a?(Hash) }.each { |attr| alias_method "#{attr}_before_type_cast", attr }
           end
 

data/lib/attr_encrypted/version.rb

@@ -2,8 +2,8 @@ module AttrEncrypted
   # Contains information about this gem's version
   module Version
     MAJOR = 1
-    MINOR = 2
-    PATCH = 1
+    MINOR = 3
+    PATCH = 0
 
     # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
     #

data/test/active_record_test.rb

@@ -1,62 +1,71 @@
-# -*- encoding: utf-8 -*-
 require File.expand_path('../test_helper', __FILE__)
 
 ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
 
-def create_people_table
+def create_tables
   silence_stream(STDOUT) do
     ActiveRecord::Schema.define(:version => 1) do
       create_table :people do |t|
         t.string   :encrypted_email
         t.string   :password
         t.string   :encrypted_credentials
-        t.string   :salt
+        t.binary   :salt
+         t.string   :encrypted_email_salt
+        t.string   :encrypted_credentials_salt
+        t.string   :encrypted_email_iv
+        t.string   :encrypted_credentials_iv
+      end
+      create_table :accounts do |t|
+        t.string :encrypted_password
+        t.string :encrypted_password_iv
+        t.string :encrypted_password_salt
       end
     end
   end
 end
 
 # The table needs to exist before defining the class
-create_people_table
+create_tables
 
 ActiveRecord::MissingAttributeError = ActiveModel::MissingAttributeError unless defined?(ActiveRecord::MissingAttributeError)
 
 class Person < ActiveRecord::Base
-  attr_encrypted :email, :key => 'a secret key'
-  attr_encrypted :credentials, :key => Proc.new { |user| Encryptor.encrypt(:value => user.salt, :key => 'some private key') }, :marshal => true
+  self.attr_encrypted_options[:mode] = :per_attribute_iv_and_salt
+  attr_encrypted :email, :key => SECRET_KEY
+  attr_encrypted :credentials, :key => Proc.new { |user| Encryptor.encrypt(:value => user.salt, :key => SECRET_KEY) }, :marshal => true
 
-  ActiveSupport::Deprecation.silenced = true
-  def after_initialize; end
-  ActiveSupport::Deprecation.silenced = false
 
   after_initialize :initialize_salt_and_credentials
 
   protected
 
-    def initialize_salt_and_credentials
-      self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s)
-      self.credentials ||= { :username => 'example', :password => 'test' }
-    rescue ActiveRecord::MissingAttributeError
-    end
+  def initialize_salt_and_credentials
+    self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(1000)).to_s)[0..15]
+    self.credentials ||= { :username => 'example', :password => 'test' }
+  end
 end
 
 class PersonWithValidation < Person
   validates_presence_of :email
-  validates_uniqueness_of :encrypted_email
+end
+
+class Account < ActiveRecord::Base
+  attr_accessor :key
+  attr_encrypted :password, :key => Proc.new {|account| account.key}
+end
+
+class PersonWithSerialization < ActiveRecord::Base
+  self.table_name = 'people'
+  attr_encrypted :email, :key => 'a secret key'
+  serialize :password
 end
 
 class ActiveRecordTest < Test::Unit::TestCase
 
   def setup
     ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
-    create_people_table
-  end
-
-  def test_should_decrypt_with_correct_encoding
-    if defined?(Encoding)
-      @person = Person.create :email => 'test@example.com'
-      assert_equal 'UTF-8', Person.find(:first).email.encoding.name
-    end
+    create_tables
+    Account.create!(:key => SECRET_KEY, :password => "password")
   end
 
   def test_should_encrypt_email
@@ -73,28 +82,6 @@ class ActiveRecordTest < Test::Unit::TestCase
     assert_equal @person.credentials, Person.find(:first).credentials
   end
 
-  def test_should_find_by_email
-    @person = Person.create(:email => 'test@example.com')
-    assert_equal @person, Person.find_by_email('test@example.com')
-  end
-
-  def test_should_find_by_email_and_password
-    Person.create(:email => 'test@example.com', :password => 'invalid')
-    @person = Person.create(:email => 'test@example.com', :password => 'test')
-    assert_equal @person, Person.find_by_email_and_password('test@example.com', 'test')
-  end
-
-  def test_should_scope_by_email
-    @person = Person.create(:email => 'test@example.com')
-    assert_equal @person, Person.scoped_by_email('test@example.com').find(:first) rescue NoMethodError
-  end
-
-  def test_should_scope_by_email_and_password
-    Person.create(:email => 'test@example.com', :password => 'invalid')
-    @person = Person.create(:email => 'test@example.com', :password => 'test')
-    assert_equal @person, Person.scoped_by_email_and_password('test@example.com', 'test').find(:first) rescue NoMethodError
-  end
-
   def test_should_encode_by_default
     assert Person.attr_encrypted_options[:encode]
   end
@@ -105,12 +92,21 @@ class ActiveRecordTest < Test::Unit::TestCase
     assert !@person.errors[:email].empty? || @person.errors.on(:email)
   end
 
-  def test_should_validate_uniqueness_of_email
-    @person = PersonWithValidation.new :email => 'test@example.com'
-    assert @person.save
-    @person2 = PersonWithValidation.new :email => @person.email
-    assert !@person2.valid?
-    assert !@person2.errors[:encrypted_email].empty? || @person2.errors.on(:encrypted_email)
+  def test_should_encrypt_decrypt_with_iv
+    @person = Person.create :email => 'test@example.com'
+    @person2 = Person.find(@person.id)
+    assert_not_nil @person2.encrypted_email_iv
+    assert_equal 'test@example.com', @person2.email
+  end
+
+  def test_should_ensure_attributes_can_be_deserialized
+    @person = PersonWithSerialization.new :email => 'test@example.com', :password => %w(an array of strings)
+    @person.save
+    assert_equal @person.password, %w(an array of strings)
   end
 
-end
+  def test_should_create_an_account_regardless_of_arguments_order
+    Account.create!(:key => SECRET_KEY, :password => "password")
+    Account.create!(:password => "password" , :key => SECRET_KEY)
+  end
+end

data/test/attr_encrypted_test.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# encoding: UTF-8
 require File.expand_path('../test_helper', __FILE__)
 
 class SillyEncryptor
@@ -12,22 +12,23 @@ class SillyEncryptor
 end
 
 class User
-  self.attr_encrypted_options[:key] = Proc.new { |user| user.class.to_s } # default key
+  self.attr_encrypted_options[:key] = Proc.new { |user| SECRET_KEY } # default key
+  self.attr_encrypted_options[:mode] = :per_attribute_iv_and_salt
 
-  attr_encrypted :email, :without_encoding, :key => 'secret key'
+  attr_encrypted :email, :without_encoding, :key => SECRET_KEY
   attr_encrypted :password, :prefix => 'crypted_', :suffix => '_test'
-  attr_encrypted :ssn, :key => :salt, :attribute => 'ssn_encrypted'
+  attr_encrypted :ssn, :key => :secret_key, :attribute => 'ssn_encrypted'
   attr_encrypted :credit_card, :encryptor => SillyEncryptor, :encrypt_method => :silly_encrypt, :decrypt_method => :silly_decrypt, :some_arg => 'test'
-  attr_encrypted :with_encoding, :key => 'secret key', :encode => true
-  attr_encrypted :with_custom_encoding, :key => 'secret key', :encode => 'm'
-  attr_encrypted :with_marshaling, :key => 'secret key', :marshal => true
-  attr_encrypted :with_true_if, :key => 'secret key', :if => true
-  attr_encrypted :with_false_if, :key => 'secret key', :if => false
-  attr_encrypted :with_true_unless, :key => 'secret key', :unless => true
-  attr_encrypted :with_false_unless, :key => 'secret key', :unless => false
-  attr_encrypted :with_if_changed, :key => 'secret key', :if => :should_encrypt
+  attr_encrypted :with_encoding, :key => SECRET_KEY, :encode => true
+  attr_encrypted :with_custom_encoding, :key => SECRET_KEY, :encode => 'm'
+  attr_encrypted :with_marshaling, :key => SECRET_KEY, :marshal => true
+  attr_encrypted :with_true_if, :key => SECRET_KEY, :if => true
+  attr_encrypted :with_false_if, :key => SECRET_KEY, :if => false
+  attr_encrypted :with_true_unless, :key => SECRET_KEY, :unless => true
+  attr_encrypted :with_false_unless, :key => SECRET_KEY, :unless => false
+  attr_encrypted :with_if_changed, :key => SECRET_KEY, :if => :should_encrypt
 
-  attr_encryptor :aliased, :key => 'secret_key'
+  attr_encryptor :aliased, :key => SECRET_KEY
 
   attr_accessor :salt
   attr_accessor :should_encrypt
@@ -36,6 +37,10 @@ class User
     self.salt = Time.now.to_i.to_s
     self.should_encrypt = true
   end
+
+  def secret_key
+    SECRET_KEY
+  end
 end
 
 class Admin < User
@@ -134,35 +139,20 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
   end
 
-  def test_should_decrypt_utf8_with_encoding
-    encrypted = User.encrypt_with_encoding("test\xC2\xA0utf-8\xC2\xA0text")
-    assert_equal "test\xC2\xA0utf-8\xC2\xA0text", User.decrypt_with_encoding(encrypted)
-    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
-  end
-
   def test_should_encrypt_with_custom_encoding
-    assert_equal User.encrypt_with_custom_encoding('test'), [User.encrypt_without_encoding('test')].pack('m')
+    assert_equal User.encrypt_with_encoding('test'), [User.encrypt_without_encoding('test')].pack('m')
   end
 
   def test_should_decrypt_with_custom_encoding
-    encrypted = User.encrypt_with_custom_encoding('test')
-    assert_equal 'test', User.decrypt_with_custom_encoding(encrypted)
-    assert_equal User.decrypt_with_custom_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
+    encrypted = User.encrypt_with_encoding('test')
+    assert_equal 'test', User.decrypt_with_encoding(encrypted)
+    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
   end
 
   def test_should_encrypt_with_marshaling
     @user = User.new
     @user.with_marshaling = [1, 2, 3]
     assert_not_nil @user.encrypted_with_marshaling
-    assert_equal User.encrypt_with_marshaling([1, 2, 3]), @user.encrypted_with_marshaling
-  end
-
-  def test_should_decrypt_with_marshaling
-    encrypted = User.encrypt_with_marshaling([1, 2, 3])
-    @user = User.new
-    assert_nil @user.with_marshaling
-    @user.encrypted_with_marshaling = encrypted
-    assert_equal [1, 2, 3], @user.with_marshaling
   end
 
   def test_should_use_custom_encryptor_and_crypt_method_names_and_arguments
@@ -174,7 +164,8 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_nil @user.ssn_encrypted
     @user.ssn = 'testing'
     assert_not_nil @user.ssn_encrypted
-    assert_equal Encryptor.encrypt(:value => 'testing', :key => @user.salt), @user.ssn_encrypted
+    encrypted =  Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.ssn_encrypted_iv.unpack("m").first, :salt => @user.ssn_encrypted_salt )
+    assert_equal encrypted, @user.ssn_encrypted
   end
 
   def test_should_evaluate_a_key_passed_as_a_proc
@@ -182,7 +173,8 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
     assert_not_nil @user.crypted_password_test
-    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'User'), @user.crypted_password_test
+    encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.crypted_password_test_iv.unpack("m").first, :salt =>  @user.crypted_password_test_salt)
+    assert_equal encrypted, @user.crypted_password_test
   end
 
   def test_should_use_options_found_in_the_attr_encrypted_options_attribute
@@ -190,7 +182,8 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_nil @user.crypted_password_test
     @user.password = 'testing'
     assert_not_nil @user.crypted_password_test
-    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'User'), @user.crypted_password_test
+    encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.crypted_password_test_iv.unpack("m").first, :salt => @user.crypted_password_test_salt)
+    assert_equal encrypted, @user.crypted_password_test
   end
 
   def test_should_inherit_encrypted_attributes
@@ -232,7 +225,8 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_nil @user.encrypted_with_true_if
     @user.with_true_if = 'testing'
     assert_not_nil @user.encrypted_with_true_if
-    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_true_if
+    encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.encrypted_with_true_if_iv.unpack("m").first, :salt => @user.encrypted_with_true_if_salt)
+    assert_equal encrypted, @user.encrypted_with_true_if
   end
 
   def test_should_not_encrypt_with_false_if
@@ -248,7 +242,8 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_nil @user.encrypted_with_false_unless
     @user.with_false_unless = 'testing'
     assert_not_nil @user.encrypted_with_false_unless
-    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_false_unless
+    encrypted = Encryptor.encrypt(:value => 'testing', :key => SECRET_KEY, :iv => @user.encrypted_with_false_unless_iv.unpack("m").first, :salt => @user.encrypted_with_false_unless_salt)
+    assert_equal encrypted,  @user.encrypted_with_false_unless
   end
 
   def test_should_not_encrypt_with_true_unless
@@ -268,7 +263,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @user.with_if_changed = "encrypt_stuff"
     @user.stubs(:instance_variable_get).returns(nil)
     @user.stubs(:instance_variable_set).raises("BadStuff")
-    assert_raise RuntimeError do 
+    assert_raise RuntimeError do
       @user.with_if_changed
     end