encrypted_attributes 0.0.1

data/MIT-LICENSE

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

data/README

@@ -0,0 +1,116 @@
+= encrypted_attributes
+
+encrypted_attributes adds support for automatically encrypting ActiveRecord
+attributes.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/encrypted_attributes
+
+Wiki
+
+* http://wiki.pluginaweek.org/Encrypted_attributes
+
+Announcement
+
+* http://www.pluginaweek.org/
+
+Source
+
+* http://svn.pluginaweek.org/trunk/plugins/active_record/miscellaneous/encrypted_attributes
+
+Development
+
+* http://dev.pluginaweek.org/browser/trunk/plugins/active_record/miscellaneous/encrypted_attributes
+
+== Description
+
+Encrypting attributes can be repetitive especially when doing so throughout
+various models and various projects.  encrypted_attributes, in association
+with the encrypted_strings plugin, 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 encryptor being used in the encrypted_strings plugin.
+Therefore, if setting the key for asymmetric encryption, this would be passed
+into the #encrypts method.  Examples of this are shown below.
+
+=== SHA Encryption
+
+For SHA encryption, you can either use the default salt, a custom salt, or
+generate one based on the attributes of the model.  If the latter option is
+being used, a column in the table should be created to store the salt that is
+generated.
+
+With the default salt:
+  class User < ActiveRecord::Base
+    encrypts :password
+  end
+
+With a custom salt:
+  class User < ActiveRecord::Base
+    encrypts :password, :salt => true
+    
+    def create_salt
+      "#{login}_salt"
+    end
+  end
+
+=== Symmetric Encryption
+
+With the default key:
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :symmetric
+  end
+
+With a custom key:
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :symmetric, :key => 'custom'
+  end
+
+=== Asymmetric Encryption
+
+With default key files:
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :asymmetric
+  end
+
+With custom key files:
+  class User < ActiveRecord::Base
+    encrypts :password, :mode => :asymmetric, :public_key_file => '/keys/public', :private_key_file => '/keys/private'
+  end
+
+=== The crypted attribute
+
+The attribute which stores the unencrypted value is a "virtual" attribute.
+This means that there is no column with the same name in the database.
+Instead, the encrypted value is stored in the crypted attributed.  By default,
+this is assumed to be "crypted_#{attr_name}".  Therefore, if you are encrypting
+the "password" attribute, the encrypted value would be stored in
+"crypted_password".
+
+The crypted attribute name can be customized like so:
+
+  class User < ActiveRecord::Base
+    encrypts :password, :crypted_name => 'protected_password'
+  end
+
+=== Additional information
+
+For more examples of actual migrations and models that encrypt attributes,
+see the unit tests.  Also, see encrypted_strings for more information about
+the various options that can be passed in.
+
+== Testing
+
+This plugin requires that the plugin_test_helper gem be installed in order to
+run the unit tests.  To install this gem:
+
+  gem install plugin_test_helper
+
+== Dependencies
+
+This plugin depends on the presence of the following plugins:
+# encrypted_strings - http://wiki.pluginaweek.org/Encrypted_strings

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+PKG_NAME           = 'encrypted_attributes'
+PKG_VERSION        = '0.0.1'
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'pluginaweek'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the encrypted_attributes plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the encrypted_attributes plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'EncryptedAttributes'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name            = PKG_NAME
+  s.version         = PKG_VERSION
+  s.platform        = Gem::Platform::RUBY
+  s.summary         = ''
+  
+  s.files           = FileList['{lib,tasks,test}/**/*'].to_a + %w(init.rb MIT-LICENSE Rakefile README)
+  s.require_path    = 'lib'
+  s.autorequire     = 'encrypted_attributes'
+  s.has_rdoc        = true
+  s.add_dependency  'encrypted_strings', '>= 0.0.1'
+  s.test_files      = Dir['test/**/*_test.rb']
+  
+  s.author          = 'Aaron Pfeifer, Neil Abraham'
+  s.email           = 'info@pluginaweek.org'
+  s.homepage        = 'http://www.pluginaweek.org'
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('pluginaweek@pluginaweek.org', '/home/pluginaweek/gems.pluginaweek.org/gems', 'pkg', "#{PKG_FILE_NAME}.gem").upload
+end
+
+desc 'Publish the API documentation'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('pluginaweek@pluginaweek.org', "/home/pluginaweek/api.pluginaweek.org/#{PKG_NAME}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new
+  ruby_forge.login
+
+  %w( gem tgz zip ).each do |ext|
+    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+  end
+end

data/init.rb

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

data/lib/encrypted_attributes/extensions/encryptor.rb

@@ -0,0 +1,14 @@
+module PluginAWeek #:nodoc:
+  module EncryptedAttributes #:nodoc:
+    module Extensions #:nodoc:
+      module Encryptor #:nodoc:
+        def process_options(model, operation, options)
+        end
+      end
+    end
+  end
+end
+
+PluginAWeek::EncryptedStrings::Encryptor.class_eval do
+  extend PluginAWeek::EncryptedAttributes::Extensions::Encryptor
+end

data/lib/encrypted_attributes/extensions/sha_encryptor.rb

@@ -0,0 +1,28 @@
+module PluginAWeek #:nodoc:
+  module EncryptedAttributes #:nodoc:
+    module Extensions #:nodoc:
+      module ShaEncryptor
+        # Adds support for using a salt that is generated based on the model and
+        # stored in an attribute.
+        def process_options(model, operation, options)
+          if (salt_attr_name = options[:salt]) && (salt_attr_name == true || salt_attr_name.is_a?(Symbol))
+            salt_attr_name = 'salt' if salt_attr_name == true
+            
+            if operation == :write
+              salt_value = model.send("create_#{salt_attr_name}").to_s
+              model.send("#{salt_attr_name}=", salt_value)
+            else
+              salt_value = model.send(salt_attr_name)
+            end
+            
+            options[:salt] = salt_value
+          end
+        end
+      end
+    end
+  end
+end
+
+PluginAWeek::EncryptedStrings::ShaEncryptor.class_eval do
+  extend PluginAWeek::EncryptedAttributes::Extensions::ShaEncryptor
+end

data/lib/encrypted_attributes.rb

@@ -0,0 +1,73 @@
+require 'encrypted_strings'
+require 'encrypted_attributes/extensions/encryptor'
+require 'encrypted_attributes/extensions/sha_encryptor'
+
+module PluginAWeek #:nodoc:
+  module EncryptedAttributes
+    def self.included(base) #:nodoc:
+      base.extend(MacroMethods)
+    end
+    
+    module MacroMethods
+      # Encrypts the specified attribute.
+      # 
+      # Configuration options:
+      # * <tt>mode</tt> - The mode of encryption to use.  Default is sha.
+      # * <tt>crypted_name</tt> - The name of the attribute to store the crypted value in.  Default is "crypted_#{attr_name}".
+      # 
+      # For additional configuration options, see the individual encryptor class.
+      def encrypts(attr_name, options = {})
+        mode = options.delete(:mode) || :sha
+        encryptor_class = "PluginAWeek::EncryptedStrings::#{mode.to_s.classify}Encryptor".constantize
+        
+        options.reverse_merge!(
+          :crypted_name => "crypted_#{attr_name}"
+        )
+        crypted_attr_name = options.delete(:crypted_name)
+        raise ArgumentError, 'Attribute name cannot be same as crypted name' if attr_name == crypted_attr_name
+        
+        # Creator accessor for the virtual attribute
+        attr_accessor attr_name
+        
+        # Define the reader when reading the crypted value from the db
+        crypted_var_name = "@#{crypted_attr_name}"
+        define_method(crypted_attr_name) do
+          if (value = read_attribute(crypted_attr_name)) && !value.encrypted?
+            encryptor_options = options.dup
+            encryptor_class.process_options(self, :read, encryptor_options)
+            value.encryptor = encryptor_class.new(encryptor_options)
+          end
+          
+          value
+        end
+        
+        # Set the value immediately before validation takes place
+        before_validation do |model|
+          value = model.send(attr_name)
+          
+          if !value.blank?
+            unless value.encrypted?
+              encryptor_options = options.dup
+              encryptor_class.process_options(model, :write, encryptor_options)
+              value = value.encrypt(mode, encryptor_options)
+            end
+            
+            model.send("#{crypted_attr_name}=", value)
+          end
+        end
+        
+        # After saving, be sure to reset the virtual attribute value.  This also
+        # supported resetting the confirmation field if, for example, the plugin
+        # is being used for passwords
+        after_save do |model|
+          model.send("#{attr_name}=", nil)
+          model.send("#{attr_name}_confirmation=", nil) if model.respond_to?("#{attr_name}_confirmation=")
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include PluginAWeek::EncryptedAttributes
+end

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

@@ -0,0 +1,3 @@
+class AsymmetricUser < User
+  encrypts :password, :mode => :asymmetric
+end

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

@@ -0,0 +1,13 @@
+class ConfirmedShaUser < ShaUser
+  with_options(:if => :password_required?) do |klass|
+    validates_presence_of     :password,
+                              :crypted_password
+    validates_length_of       :password,
+                                :in => 4..40
+    validates_confirmation_of :password
+  end
+  
+  def password_required?
+    crypted_password.blank? || !password.blank?
+  end
+end

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

@@ -0,0 +1,3 @@
+class ShaUser < User
+  encrypts :password
+end

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

@@ -0,0 +1,3 @@
+class ShaUserWithCustomCryptedAttr < User
+  encrypts :password, :crypted_name => 'protected_password'
+end

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

@@ -0,0 +1,7 @@
+class ShaUserWithCustomSalt < User
+  encrypts :password, :salt => :salt_value
+  
+  def create_salt_value
+    "#{login}_salt_value"
+  end
+end

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

@@ -0,0 +1,7 @@
+class ShaUserWithSalt < User
+  encrypts :password, :salt => true
+  
+  def create_salt
+    "#{login}_salt"
+  end
+end

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

@@ -0,0 +1,3 @@
+class SymmetricUser < User
+  encrypts :password, :mode => :symmetric
+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/db/migrate/001_create_users.rb

@@ -0,0 +1,16 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users, :force => true do |t|
+      t.column :protected_password, :string, :limit => 255
+      t.column :crypted_password,   :string, :limit => 255
+      t.column :salt,               :string, :limit => 50
+      t.column :salt_value,         :string, :limit => 50
+      t.column :login,              :string, :limit => 50
+      t.column :type,               :string, :limit => 20
+    end
+  end
+  
+  def self.down
+    drop_table :users
+  end
+end

data/test/app_root/test/fixtures/users.yml

@@ -0,0 +1,8 @@
+bob:
+  id: 1
+  login: bob
+  crypted_password: "0XlmUuNpE2k=\n"
+  type: SymmetricUser
+fred:
+  id: 2
+  login: fred

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,10 @@
+# Load local repository plugin paths
+$:.unshift("#{File.dirname(__FILE__)}/../../../../ruby/string/encrypted_strings/lib")
+
+# Load the plugin testing framework
+$:.unshift("#{File.dirname(__FILE__)}/../../../../test/plugin_test_helper/lib")
+require 'rubygems'
+require 'plugin_test_helper'
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{RAILS_ROOT}/db/migrate")

data/test/unit/encrypted_attributes_test.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class EncryptedAttributesTest < Test::Unit::TestCase
+  def setup
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_private_key_file = File.join(File.dirname(__FILE__), '..', 'keys', 'private')
+    PluginAWeek::EncryptedStrings::AsymmetricEncryptor.default_public_key_file = File.join(File.dirname(__FILE__), '..', 'keys', 'public')
+    
+    PluginAWeek::EncryptedStrings::SymmetricEncryptor.default_key = 'key'
+  end
+  
+  def test_encryption_with_default_options
+    {
+      ShaUser => PluginAWeek::EncryptedStrings::ShaEncryptor,
+      AsymmetricUser => PluginAWeek::EncryptedStrings::AsymmetricEncryptor,
+      SymmetricUser => PluginAWeek::EncryptedStrings::SymmetricEncryptor
+    }.each do |user_class, encryptor_class|
+      user = user_class.new
+      user.login = 'john doe'
+      user.password = 'secret'
+      
+      assert user.save
+      assert_not_nil user.crypted_password
+      assert user.crypted_password.encrypted?
+      assert_instance_of encryptor_class, user.crypted_password.encryptor
+    end
+  end
+  
+  def test_encryption_with_custom_crypted_attribute
+    user = ShaUserWithCustomCryptedAttr.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    
+    assert user.save
+    assert_nil user.crypted_password
+    assert_not_nil user.protected_password
+    assert user.protected_password.encrypted?
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, user.protected_password.encryptor
+  end
+  
+  def test_should_encrypt_on_invalid_model
+    user = ShaUser.new
+    user.login = nil
+    user.password = 'secret'
+    
+    assert !user.save
+    assert_not_nil user.password
+    assert_not_nil user.crypted_password
+    assert user.crypted_password.encrypted?
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, user.crypted_password.encryptor
+  end
+  
+  def test_should_not_encrypt_if_attribute_is_blank
+    user = ShaUser.new
+    user.login = 'john doe'
+    user.password = nil
+    user.save
+    assert_nil user.crypted_password
+    
+    user.password = ''
+    assert user.save
+    assert_nil user.crypted_password
+  end
+  
+  def test_should_not_encrypt_if_already_encrypted
+    encrypted_password = 'secret'.encrypt
+    
+    user = ShaUser.new
+    user.login = 'john doe'
+    user.password = encrypted_password
+    
+    assert user.save
+    assert_equal encrypted_password, user.crypted_password
+  end
+  
+  def test_should_hide_attribute_after_save
+    user = ShaUser.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    
+    assert user.save
+    assert_nil user.password
+  end
+  
+  def test_should_hide_confirmation_attribute_after_save
+    user = ConfirmedShaUser.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    user.password_confirmation = 'secret'
+    
+    assert user.save
+    assert_nil user.password
+    assert_nil user.password_confirmation
+  end
+  
+  def test_sha_encryption_with_generated_salt
+    user = ShaUserWithSalt.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    
+    assert user.save
+    assert_not_nil user.salt
+    assert_equal 'john doe_salt', user.salt
+    assert_equal 'secret', user.crypted_password
+  end
+  
+  def test_sha_encryption_with_custom_generated_salt
+    user = ShaUserWithCustomSalt.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    
+    assert user.save
+    assert_not_nil user.salt_value
+    assert_equal 'john doe_salt_value', user.salt_value
+    assert_equal 'secret', user.crypted_password
+  end
+  
+  def test_should_return_encrypted_attribute_for_saved_record
+    user = ShaUser.new
+    user.login = 'john doe'
+    user.password = 'secret'
+    
+    assert user.save
+    
+    user = ShaUser.find(user.id)
+    assert_nil user.password
+    assert_not_nil user.crypted_password
+    assert user.crypted_password.encrypted?
+    assert_instance_of PluginAWeek::EncryptedStrings::ShaEncryptor, user.crypted_password.encryptor
+  end
+end

data/test/unit/encryptor_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class EncryptorTest < Test::Unit::TestCase
+  def test_should_not_make_any_changes_on_process_options
+    assert PluginAWeek::EncryptedStrings::Encryptor.respond_to?(:process_options)
+    
+    options = {:salt => 'test'}
+    expected_options = options.dup
+    PluginAWeek::EncryptedStrings::Encryptor.process_options(User.new, :read, options)
+    
+    assert_equal expected_options, options
+  end
+end

data/test/unit/sha_encryptor_test.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+
+class ShaEncryptorTest < Test::Unit::TestCase
+  def test_should_respond_to_process_options
+    assert PluginAWeek::EncryptedStrings::ShaEncryptor.respond_to?(:process_options)
+  end
+  
+  def test_process_options_should_not_make_changes_for_salt_string
+    options = {:salt => 'my_salt_value'}
+    expected_options = {:salt => 'my_salt_value'}
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(User.new, :read, options)
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(User.new, :write, options)
+    
+    assert_equal expected_options, options
+  end
+  
+  def test_process_options_should_use_salt_attribute_for_salt_on_read
+    user = ShaUserWithSalt.new
+    user.login = 'test'
+    user.salt = 'existing_salt'
+    
+    options = {:salt => true}
+    expected_options = {:salt => 'existing_salt'}
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(user, :read, options)
+    
+    assert_equal expected_options, options
+  end
+  
+  def test_process_options_should_generate_new_salt_on_write
+    user = ShaUserWithSalt.new
+    user.login = 'test'
+    user.salt = 'existing_salt'
+    
+    options = {:salt => true}
+    expected_options = {:salt => 'test_salt'}
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(user, :write, options)
+    
+    assert_equal expected_options, options
+  end
+  
+  def test_process_options_should_use_custom_attribute_for_salt_on_read
+    user = ShaUserWithCustomSalt.new
+    user.login = 'test'
+    user.salt_value = 'existing_salt_value'
+    
+    options = {:salt => :salt_value}
+    expected_options = {:salt => 'existing_salt_value'}
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(user, :read, options)
+    
+    assert_equal expected_options, options
+  end
+  
+  def test_process_options_should_generate_new_salt_from_custom_method_on_write
+    user = ShaUserWithCustomSalt.new
+    user.login = 'test'
+    user.salt_value = 'existing_salt_value'
+    
+    options = {:salt => :salt_value}
+    expected_options = {:salt => 'test_salt_value'}
+    PluginAWeek::EncryptedStrings::ShaEncryptor.process_options(user, :write, options)
+    
+    assert_equal expected_options, options
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: encrypted_attributes
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-08-05 00:00:00 -04:00
+summary: ""
+require_paths: 
+- lib
+email: info@pluginaweek.org
+homepage: http://www.pluginaweek.org
+rubyforge_project: 
+description: 
+autorequire: encrypted_attributes
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Aaron Pfeifer, Neil Abraham
+files: 
+- lib/encrypted_attributes
+- lib/encrypted_attributes/extensions
+- lib/encrypted_attributes/extensions/encryptor.rb
+- lib/encrypted_attributes/extensions/sha_encryptor.rb
+- lib/encrypted_attributes.rb
+- test/app_root
+- test/app_root/app
+- test/app_root/app/models
+- test/app_root/app/models/asymmetric_user.rb
+- test/app_root/app/models/confirmed_sha_user.rb
+- test/app_root/app/models/sha_user.rb
+- test/app_root/app/models/sha_user_with_custom_crypted_attr.rb
+- test/app_root/app/models/sha_user_with_custom_salt.rb
+- test/app_root/app/models/sha_user_with_salt.rb
+- test/app_root/app/models/symmetric_user.rb
+- 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/test
+- test/app_root/test/fixtures
+- test/app_root/test/fixtures/users.yml
+- test/keys
+- test/keys/private
+- test/keys/public
+- test/test_helper.rb
+- test/unit
+- test/unit/encrypted_attributes_test.rb
+- test/unit/encryptor_test.rb
+- test/unit/sha_encryptor_test.rb
+- init.rb
+- MIT-LICENSE
+- Rakefile
+- README
+test_files: 
+- test/unit/encrypted_attributes_test.rb
+- test/unit/encryptor_test.rb
+- test/unit/sha_encryptor_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: encrypted_strings
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: