attr_encryptor 1.0.2 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15fa84f14870e8333f343f5ce8d2e56b71e7c576
+  data.tar.gz: de53d4a0d42aa01b867d29834a056224d4173caf
+SHA512:
+  metadata.gz: 78abb59d5e439b54eb77f7eb4b786669457039a7dcc7724014caed61f941b664e0b2a2fb77f6e22f431c5d70b7fe1b4c38cb0580166725fe166092e4c5da8da5
+  data.tar.gz: ace36c9f963ab74233525b8a2e6ea9a3f41d3db9ec626b298305f30ddddcd94ac51f948fd1582c36a3c693275b4b936e7e916067c26bebd61478827c0031a6b8

data/.ruby-gemset

@@ -0,0 +1 @@
+attr_encrypted

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/Gemfile

@@ -0,0 +1,15 @@
+ruby '2.0.0'
+source 'https://rubygems.org'
+
+
+gem 'encryptor2'
+
+group :development do 
+  gem 'pry'
+  gem 'activerecord'
+  gem 'datamapper'
+  gem 'mocha'
+  gem 'sequel'
+  gem 'dm-sqlite-adapter'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,108 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    addressable (2.3.5)
+    arel (4.0.0)
+    atomic (1.1.10)
+    bcrypt-ruby (3.1.1)
+    builder (3.1.4)
+    coderay (1.0.9)
+    data_objects (0.10.13)
+      addressable (~> 2.1)
+    datamapper (1.2.0)
+      dm-aggregates (~> 1.2.0)
+      dm-constraints (~> 1.2.0)
+      dm-core (~> 1.2.0)
+      dm-migrations (~> 1.2.0)
+      dm-serializer (~> 1.2.0)
+      dm-timestamps (~> 1.2.0)
+      dm-transactions (~> 1.2.0)
+      dm-types (~> 1.2.0)
+      dm-validations (~> 1.2.0)
+    dm-aggregates (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-constraints (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-core (1.2.1)
+      addressable (~> 2.3)
+    dm-do-adapter (1.2.0)
+      data_objects (~> 0.10.6)
+      dm-core (~> 1.2.0)
+    dm-migrations (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-serializer (1.2.2)
+      dm-core (~> 1.2.0)
+      fastercsv (~> 1.5)
+      json (~> 1.6)
+      json_pure (~> 1.6)
+      multi_json (~> 1.0)
+    dm-sqlite-adapter (1.2.0)
+      dm-do-adapter (~> 1.2.0)
+      do_sqlite3 (~> 0.10.6)
+    dm-timestamps (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-transactions (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-types (1.2.2)
+      bcrypt-ruby (~> 3.0)
+      dm-core (~> 1.2.0)
+      fastercsv (~> 1.5)
+      json (~> 1.6)
+      multi_json (~> 1.0)
+      stringex (~> 1.4)
+      uuidtools (~> 2.1)
+    dm-validations (1.2.0)
+      dm-core (~> 1.2.0)
+    do_sqlite3 (0.10.13)
+      data_objects (= 0.10.13)
+    encryptor2 (1.0.0)
+    fastercsv (1.5.5)
+    i18n (0.6.4)
+    json (1.8.0)
+    json_pure (1.8.0)
+    metaclass (0.0.1)
+    method_source (0.8.1)
+    minitest (4.7.5)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.7)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    sequel (4.0.0)
+    slop (3.4.5)
+    sqlite3 (1.3.7)
+    stringex (1.5.1)
+    thread_safe (0.1.0)
+      atomic
+    tzinfo (0.3.37)
+    uuidtools (2.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  datamapper
+  dm-sqlite-adapter
+  encryptor2
+  mocha
+  pry
+  sequel
+  sqlite3

data/README.md

@@ -15,7 +15,7 @@ It works with ANY class, however, you get a few extra features when you're using
 
 Encrypting attributes has never been easier:
 
-### You database
+### Your database
 
 add a `encrypted_ssn`, `encrypted_ssn_salt`, `encrypted_ssn_iv`. All of
 them will be populated automatically
@@ -23,6 +23,7 @@ them will be populated automatically
     create_table :google_apps_admins do |t|
       t.string :username
       t.string :encrypted_password
+      t.string :encrypted_password_salt
       t.string :encrypted_password_iv
       t.string :domain
       t.timestamps
@@ -243,6 +244,14 @@ encrypted string. I've had this problem myself using MySQL. You can simply pass
 
 The default encoding is `m*` (base64). You can change this by setting `:encode => 'some encoding'`. See the `Array#pack` method at http://www.ruby-doc.org/core/classes/Array.html#M002245 for more encoding options.
 
+### String Encoding/Charset
+
+If you are trying to store UTF-8 (or other non-english charsets) strings in your encrypted parameters, you may get the decrypted string back as a US-ASCII or ASCII-8BIT string.
+
+To fix this, add the `:charset => 'UTF-8'` option to your encrypted attribute definitions. 
+This option defaults to whatever your `Encoding.default_internal` is set to. `:charset => :default` will force it to use the default value.
+
+This option only applies to encrypted strings and will be ignored when encrypting marshalled objects.
 
 ### Marshaling
 

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 desc 'Default: run unit tests.'
 task :default => :test

data/attr_encryptor.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
 
   s.author   = 'Daniel Palacio'
   s.email    = 'danpal@gmail.com'
-  s.homepage = 'http://github.com/danpal/attr_encrypted'
+  s.homepage = 'http://github.com/danpal/attr_encryptor'
 
   s.has_rdoc = false
   s.rdoc_options = ['--line-numbers', '--inline-source', '--main', 'README.rdoc']

data/lib/attr_encryptor.rb

@@ -69,6 +69,8 @@ module AttrEncryptor
   #   :unless           => Attributes are only encrypted if this option evaluates to false. If you pass a symbol representing an instance
   #                        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.
+  #   :charset          => Forces the decrypted string to be interpreted as the specified encoding. Does not change the underlying bits.
+  #                        Use :default to use Ruby's default encoding.
   #
   # You can specify your own default options
   #
@@ -111,10 +113,12 @@ module AttrEncryptor
       :load_method      => 'load',
       :encryptor        => Encryptor,
       :encrypt_method   => 'encrypt',
-      :decrypt_method   => 'decrypt'
+      :decrypt_method   => 'decrypt',
+      :charset          => :default
     }.merge!(attr_encrypted_options).merge!(attributes.last.is_a?(Hash) ? attributes.pop : {})
 
     options[:encode] = options[:default_encoding] if options[:encode] == true
+    options[:charset] = Encoding.default_internal if options[:charset] == :default
 
     attributes.each do |attribute|
       encrypted_attribute_name = (options[:attribute] ? options[:attribute] : [options[:prefix], attribute, options[:suffix]].join).to_sym
@@ -122,27 +126,27 @@ module AttrEncryptor
       instance_methods_as_symbols = instance_methods.collect { |method| method.to_sym }
       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}=")
-      
+
       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 )
 
 
 
       define_method(attribute) do
-        
+
         load_iv_for_attribute(attribute,encrypted_attribute_name, options[:algorithm])
-        load_salt_for_attribute(attribute,encrypted_attribute_name) 
+        load_salt_for_attribute(attribute,encrypted_attribute_name)
 
         instance_variable_get("@#{attribute}") || instance_variable_set("@#{attribute}", decrypt(attribute, send(encrypted_attribute_name)))
       end
 
       define_method("#{attribute}=") do |value|
         load_iv_for_attribute(attribute, encrypted_attribute_name, options[:algorithm])
-        load_salt_for_attribute(attribute, encrypted_attribute_name) 
-        
+        load_salt_for_attribute(attribute, encrypted_attribute_name)
+
         #this add's the iv and salt on the options for this instance
         send("#{encrypted_attribute_name}=", encrypt(attribute, value))
         instance_variable_set("@#{attribute}", value)
@@ -195,10 +199,16 @@ module AttrEncryptor
       encrypted_value = encrypted_value.unpack(options[:encode]).first if options[:encode]
       value = options[:encryptor].send(options[:decrypt_method], options.merge!(:value => encrypted_value))
       value = options[:marshaler].send(options[:load_method], value) if options[:marshal]
-      value
+      return_value = value
     else
-      encrypted_value
+      return_value = encrypted_value
     end
+
+    if RUBY_VERSION > '1.9' && options[:charset].present? && return_value.present? && return_value.is_a?(String)
+      return_value.force_encoding(options[:charset])
+    end
+
+    return_value
   end
 
   # Encrypts a value for the attribute specified
@@ -292,10 +302,7 @@ module AttrEncryptor
     def encrypt(attribute, value)
       self.class.encrypt(attribute, value, evaluated_attr_encrypted_options_for(attribute))
     end
-    
-    def foo
 
-    end
     protected
 
       # Returns attr_encrypted options evaluated in the current object's scope for the attribute specified
@@ -319,7 +326,7 @@ module AttrEncryptor
       def load_iv_for_attribute (attribute, encrypted_attribute_name, algorithm)
         iv = send("#{encrypted_attribute_name.to_s + "_iv"}")
           if(iv == nil)
-            begin 
+            begin
               algorithm = algorithm || "aes-256-cbc"
               algo = OpenSSL::Cipher::Cipher.new(algorithm)
               iv = [algo.random_iv].pack("m")
@@ -331,10 +338,10 @@ module AttrEncryptor
       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"}=", Time.now.to_i.to_s) 
+        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_encryptor/adapters/active_record.rb

@@ -4,19 +4,26 @@ if defined?(ActiveRecord::Base)
       module ActiveRecord
         def self.extended(base) # :nodoc:
           base.class_eval do
+            class << self
+              alias_method_chain :attr_encrypted, :defined_attributes
+              alias_method_chain :attr_encryptor, :defined_attributes
+            end
+            
             attr_encrypted_options[:encode] = true
           end
         end
 
         protected
 
-          # Ensures the attribute methods for db fields have been defined before calling the original 
-          # <tt>attr_encrypted</tt> method
-          def attr_encrypted(*attrs)
-            define_attribute_methods rescue nil
-            super
-            attrs.reject { |attr| attr.is_a?(Hash) }.each { |attr| alias_method "#{attr}_before_type_cast", attr }
-          end
+        # Ensures the attribute methods for db fields have been defined before calling the original 
+        # <tt>attr_encrypted</tt> method
+        def attr_encrypted_with_defined_attributes(*attrs)
+          define_attribute_methods rescue nil
+          attr_encrypted_without_defined_attributes *attrs
+          attrs.reject { |attr| attr.is_a?(Hash) }.each { |attr| alias_method "#{attr}_before_type_cast", attr }
+        end
+        
+        alias attr_encryptor_with_defined_attributes attr_encrypted_with_defined_attributes
       end
     end
   end

data/lib/attr_encryptor/version.rb

@@ -1,9 +1,9 @@
 module AttrEncryptor
   # Contains information about this gem's version
   module Version
-    MAJOR = 1
+    MAJOR = 2
     MINOR = 0
-    PATCH = 2
+    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

@@ -30,8 +30,8 @@ create_tables
 ActiveRecord::MissingAttributeError = ActiveModel::MissingAttributeError unless defined?(ActiveRecord::MissingAttributeError)
 
 class Person < ActiveRecord::Base
-  attr_encrypted :email, :key => "secret"
-  attr_encrypted :credentials, :key => Proc.new { |user| Encryptor.encrypt(:value => user.salt, :key => 'secret_key') }, :marshal => true
+  attr_encrypted :email, :key => SECRET_KEY
+  attr_encrypted :credentials, :key => Proc.new { |user| Encryptor.encrypt(:value => user.salt, :key => SECRET_KEY) }, :marshal => true
 
 
   after_initialize :initialize_salt_and_credentials
@@ -39,7 +39,7 @@ class Person < ActiveRecord::Base
   protected
 
   def initialize_salt_and_credentials
-    self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s)
+    self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(1000)).to_s)[0..15]
     self.credentials ||= { :username => 'example', :password => 'test' }
   end
 end
@@ -58,43 +58,42 @@ class ActiveRecordTest < Test::Unit::TestCase
   def setup
     ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
     create_tables
-    Account.create!(:key => "secret", :password => "password")
+    Account.create!(:key => SECRET_KEY, :password => "password")
   end
 
-  def _test_should_encrypt_email
+  def test_should_encrypt_email
     @person = Person.create :email => 'test@example.com'
     assert_not_nil @person.encrypted_email
     assert_not_equal @person.email, @person.encrypted_email
     assert_equal @person.email, Person.find(:first).email
   end
 
-  def _test_should_marshal_and_encrypt_credentials
+  def test_should_marshal_and_encrypt_credentials
     @person = Person.create
     assert_not_nil @person.encrypted_credentials
     assert_not_equal @person.credentials, @person.encrypted_credentials
     assert_equal @person.credentials, Person.find(:first).credentials
   end
 
-  def _test_should_encode_by_default
+  def test_should_encode_by_default
     assert Person.attr_encrypted_options[:encode]
   end
 
-  def _test_should_validate_presence_of_email
+  def test_should_validate_presence_of_email
     @person = PersonWithValidation.new
     assert !@person.valid?
     assert !@person.errors[:email].empty? || @person.errors.on(:email)
   end
 
-  def _test_should_encrypt_decrypt_with_iv
+  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_create_an_account_regardless_of_arguments_order
-    Account.create!(:key => "secret", :password => "password")
-    Account.create!(:password => "password" , :key => "secret")
+    Account.create!(:key => SECRET_KEY, :password => "password")
+    Account.create!(:password => "password" , :key => SECRET_KEY)
   end
-
 end

data/test/attr_encrypted_test.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require File.expand_path('../test_helper', __FILE__)
 
 class SillyEncryptor
@@ -11,22 +12,26 @@ 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
 
-  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_encrypted :utf8, :key => SECRET_KEY, :charset => 'UTF-8'
+  attr_encrypted :default_enc, :key => SECRET_KEY
+  attr_encrypted :us_ascii, :key => SECRET_KEY, :charset => 'US-ASCII'
+
+  attr_encryptor :aliased, :key => SECRET_KEY
 
   attr_accessor :salt
   attr_accessor :should_encrypt
@@ -35,6 +40,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
@@ -158,7 +167,8 @@ class AttrEncryptorTest < 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, :iv => @user.ssn_encrypted_iv.unpack("m").first, :salt => Time.now.to_i.to_s), @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
@@ -166,7 +176,8 @@ class AttrEncryptorTest < 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', :iv => @user.crypted_password_test_iv.unpack("m").first, :salt => Time.now.to_i.to_s), @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
@@ -174,8 +185,9 @@ class AttrEncryptorTest < 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', :iv => @user.crypted_password_test_iv.unpack("m").first, :salt => Time.now.to_i.to_s), @user.crypted_password_test
-  end 
+    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
     assert_equal [User.encrypted_attributes.keys, :testing].flatten.collect { |key| key.to_s }.sort, Admin.encrypted_attributes.keys.collect { |key| key.to_s }.sort
@@ -216,7 +228,8 @@ class AttrEncryptorTest < 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', :iv => @user.encrypted_with_true_if_iv.unpack("m").first, :salt => Time.now.to_i.to_s), @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
@@ -232,7 +245,8 @@ class AttrEncryptorTest < 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', :iv => @user.encrypted_with_false_unless_iv.unpack("m").first, :salt => Time.now.to_i.to_s,), @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
@@ -252,7 +266,7 @@ class AttrEncryptorTest < 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
 
@@ -269,6 +283,29 @@ class AttrEncryptorTest < Test::Unit::TestCase
     assert_equal '3', User.decrypt_email(string_encrypted_email)
   end
 
+  def test_should_force_utf8_charset_on_decrypted_string
+    utf8_str = 'thïs should bé UTF-8'.force_encoding('UTF-8')
+    encrypted_utf8 = User.encrypt_utf8(utf8_str)
+    decrypted_utf8 = User.decrypt_utf8(encrypted_utf8)
+    assert_equal decrypted_utf8.encoding, Encoding::UTF_8
+  end
+
+  def test_should_force_default_encoding_on_decrypted_string
+    Encoding.default_internal = 'ASCII-8BIT' #Provide a default.
+    default_str = 'this is a default encoding'
+    encrypted_def = User.encrypt_default_enc(default_str)
+    decrypted_def = User.decrypt_default_enc(encrypted_def)
+    assert_equal decrypted_def.encoding, Encoding.default_internal
+    Encoding.default_internal = nil
+  end
+
+  def test_should_force_ascii_charset_on_decrypted_string
+    ascii_str = 'this should be US-ASCII'.force_encoding('US-ASCII')
+    encrypted_ascii = User.encrypt_us_ascii(ascii_str)
+    decrypted_ascii = User.decrypt_us_ascii(encrypted_ascii)
+    assert_equal decrypted_ascii.encoding, Encoding::US_ASCII
+  end
+
   def test_should_create_query_accessor
     @user = User.new
     assert !@user.email?

data/test/data_mapper_test.rb

@@ -13,9 +13,9 @@ class Client
   property :encrypted_credentials, Text
   property :encrypted_credentials_iv, Text
   property :encrypted_credentials_salt, Text
-  
-  attr_encrypted :email, :key => 'a secret key'
-  attr_encrypted :credentials, :key => 'some private key', :marshal => true
+
+  attr_encrypted :email, :key => SECRET_KEY
+  attr_encrypted :credentials, :key => SECRET_KEY, :marshal => true
 
   def initialize(attrs = {})
     super attrs

data/test/sequel_test.rb

@@ -13,9 +13,9 @@ DB.create_table :humans do
   column :encrypted_credentials_salt, String
 end
 
-class Human < Sequel::Model(:humans)  
-  attr_encrypted :email, :key => 'a secret key'
-  attr_encrypted :credentials, :key => 'some private key', :marshal => true
+class Human < Sequel::Model(:humans)
+  attr_encrypted :email, :key => SECRET_KEY
+  attr_encrypted :credentials, :key => SECRET_KEY, :marshal => true
 
   def after_initialize(attrs = {})
     self.credentials ||= { :username => 'example', :password => 'test' }
@@ -29,7 +29,6 @@ class SequelTest < Test::Unit::TestCase
   end
 
   def test_should_encrypt_email
-    require 'ruby-debug' 
     @human = Human.new :email => 'test@example.com'
     assert @human.save
     assert_not_nil @human.encrypted_email
@@ -39,7 +38,7 @@ class SequelTest < Test::Unit::TestCase
 
   def test_should_marshal_and_encrypt_credentials
 
-    @human = Human.new
+    @human = Human.new :credentials => { :username => 'example', :password => 'test' }
     assert @human.save
     assert_not_nil @human.encrypted_credentials
     assert_not_equal @human.credentials, @human.encrypted_credentials

data/test/test_helper.rb

@@ -5,10 +5,12 @@ gem 'activerecord', ENV['ACTIVE_RECORD_VERSION'] if ENV['ACTIVE_RECORD_VERSION']
 require 'active_record'
 require 'data_mapper'
 require 'sequel'
-require 'mocha'
+require 'mocha/setup'
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $:.unshift(File.dirname(__FILE__))
 require 'attr_encryptor'
 
 puts "\nTesting with ActiveRecord #{ActiveRecord::VERSION::STRING rescue ENV['ACTIVE_RECORD_VERSION']}"
+
+SECRET_KEY = 4.times.map { Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s) }.join

metadata

@@ -1,93 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: attr_encryptor
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Daniel Palacio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-07 00:00:00.000000000Z
+date: 2013-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: encryptor2
-  requirement: &70193477683240 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70193477683240
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70193477682720 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *70193477682720
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: datamapper
-  requirement: &70193477682340 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193477682340
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70193477702100 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193477702100
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sequel
-  requirement: &70193477701680 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193477701680
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dm-sqlite-adapter
-  requirement: &70193477701260 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193477701260
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70193477700840 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70193477700840
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Generates attr_accessors that encrypt and decrypt attributes transparently
 email: danpal@gmail.com
 executables: []
@@ -95,7 +115,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- .rvmrc
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.md
 - Rakefile
@@ -111,8 +134,9 @@ files:
 - test/debug_order.rb
 - test/sequel_test.rb
 - test/test_helper.rb
-homepage: http://github.com/danpal/attr_encrypted
+homepage: http://github.com/danpal/attr_encryptor
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --line-numbers
@@ -122,22 +146,20 @@ rdoc_options:
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Encrypt and decrypt attributes
 test_files:
 - test/active_record_test.rb
@@ -146,4 +168,3 @@ test_files:
 - test/debug_order.rb
 - test/sequel_test.rb
 - test/test_helper.rb
-has_rdoc: false

data/.rvmrc

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-# This is an RVM Project .rvmrc file, used to automatically load the ruby
-# development environment upon cd'ing into the directory
-
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
-environment_id="ruby-1.9.2-p290@attr_encrypted"
-
-#
-# Uncomment following line if you want options to be set only for given project.
-#
-# PROJECT_JRUBY_OPTS=( --1.9 )
-
-#
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-#
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-
-  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
-  then
-    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
-  fi
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  if ! rvm --create  "$environment_id"
-  then
-    echo "Failed to create RVM environment '${environment_id}'."
-    exit 1
-  fi
-fi
-
-#
-# If you use an RVM gemset file to install a list of gems (*.gems), you can have
-# it be automatically loaded. Uncomment the following and adjust the filename if
-# necessary.
-#
-# filename=".gems"
-# if [[ -s "$filename" ]] ; then
-#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
-# fi
-