encrypt_attributes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54d5d3aa82796fd065586ae0b609832b930a8c29
+  data.tar.gz: 865088b383ee116f2e16a0621209586f0ca856b2
+SHA512:
+  metadata.gz: 2b0b1f47209ca40d8a36c94798f0de32b778c4f787433240920154282701824306ed4a7e9bd9b72d1a2766326edb231b428484bbeac0bceb327de81538392e70
+  data.tar.gz: 76d23dd15a2cf34783a90ea7a6e19f8c1773c4e3f9267c1c34aed82757025ca5783c1b3f6ff033b0ed428df05e364ed2b3402d44e69a38f3dc0ae65b559e847e

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+db/*.sqlite3

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.1.1
+services:
+  - mongodb
+before_script:
+  - cp config/database.yml.travis config/database.yml
+script:
+  - bundle exec rspec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in encrypt_attributes.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Artur Hebda
+
+MIT License
+
+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.md

@@ -0,0 +1,137 @@
+# EncryptedAttributes
+
+[![Build Status](https://travis-ci.org/aenain/encrypted_attributes.svg?branch=master)](https://travis-ci.org/aenain/encrypted_attributes)
+
+This gem provides a dead-simple encryption of string / text attributes of ActiveRecord and Mongoid models.  Encryptor internally uses [ActiveSupport::MessageEncryptor](http://api.rubyonrails.org/classes/ActiveSupport/MessageEncryptor.html) and therefore it uses 'aes-256-cbc' cipher by default. Currently there is no way to pass custom options to the encryptor. Gem does NOT require column with different name. It works just fine without it, but works only with columns of type `string` or `text`. From user perspective encryption is completely transparent - they use decrypted values all the time, but encrypted values are stored in database.
+
+## ORM Support
+
+Integration with ActiveRecord and Mongoid has been tested. Other frameworks should work as expected if they provide `#read_attribute` and `#write_attribute` methods. They are supposed to work in similar way as in ActiveRecord.
+
+## Recommendations
+
+Provided functionality is sufficient for storing oauth tokens and secrets that are not to be searched for. If you are looking for something more sophisticated, then check out my recommendations below.
+
+[attr_encrypted](https://github.com/attr-encrypted/attr_encrypted) extends `Object`, so it works with any Ruby class, but requires an encrypted attribute to have a different name than the regular one.
+
+[CryptKepper](http://jmazzi.github.io/crypt_keeper/) is a perfect solution if you need to search through encrypted fields, but supports ActiveRecord only.
+
+[symmetric-encryption](https://github.com/reidmorrison/symmetric-encryption) is based on RSA-encrypted keys and supports ActiveRecord, MongoMapper and Mongoid. It provides type coercion and can be used to secure configuration files as well. PCI compliant.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'encrypt_attributes'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install encrypt_attributes
+
+## Usage
+
+Provide a secret for `Encryptor`. Create a model with fields of type `string` or `text`, include `EncryptAttributes::Model` and call `encrypt_attrs(*attrs)`.
+
+### Secret
+
+If you are using Rails, secret by default will be set to `Rails.application.secrets.secret_key_base`. If you want to use a different secret, create an initializer:
+
+    # config/initializers/encrypted_attributes.rb
+    EncryptAttributes::Encryptor.secret = "<super-secure-key>"
+
+If you do not use Rails, set the secret before any encryption is done, otherwise an error will be thrown.
+
+### Models
+
+* ActiveRecord
+
+```
+# db/migrate/create_authentications.rb
+class CreateAuthentication < ActiveRecord::Migration
+  def change
+    create_table :authentications, force: true do |t|
+      t.string :token
+      t.string :secret
+    end
+  end
+end
+```
+
+```
+# app/models/authentication.rb
+class Authentication < ActiveRecord::Base
+  include EncryptAttributes::Model
+  encrypt_attrs :token, :secret
+end
+```
+
+* Mongoid
+
+```
+# app/models/authentication.rb
+class Authentication
+  include Mongoid::Document
+  # it is important to include Mongoid::Document before
+  include EncryptAttributes::Model
+
+  field :token,  type: String
+  field :secret, type: String
+
+  encrypt_attrs :token, :secret
+end
+```
+
+### Custom accessors
+
+If you want to define custom accessors for encrypted attributes, create methods you need to override and call `super` to execute encryption / decryption. It will work the same way with all supported ORMs.
+
+    # app/models/authentication.rb
+    class Authentication < ActiveRecord::Base
+      include EncryptAttributes::Model
+      encrypt_attrs :token, :secret
+
+      def secret
+        super.tap do |decrypted|
+          # do whatever you want here
+        end
+      end
+
+      def secret=(new_secret)
+        super
+        # do whatever you want here
+      end
+    end
+
+### Gotchas
+
+Beware that each time encryption is done it returns a different value for the same input argument. Check out the consequences on the example below.
+
+    user = User.create(secret: "secret")
+    user.secret = "secret" # the same value
+    user.secret_changed? # returns true
+
+ORMs will think that the secret has changed, because after setting a value, it gets encoded and a new value is stored in `attributes`.
+
+## Running tests
+
+  Before running entire suite, you have to start Mongo DB, create and migrate database for ActiveRecord. Read more about [Mongo installation](http://docs.mongodb.org/manual/installation/).
+  To prepare database:
+
+    bundle exec rake db:create
+    bundle exec rake db:migrate RACK_ENV=test
+
+  To run tests:
+
+    bundle exec rspec
+
+## Contributing
+
+1. Fork it ( https://github.com/aenain/encrypted_attributes/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+ENV['RACK_ENV'] ||= "development"
+require "bundler/gem_tasks"
+
+Dir[File.join(__dir__, "lib/tasks/**/*.rake")].each { |f| load f }

data/config/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  timeout: 500
+  database: "db/test.sqlite3"

data/config/database.yml.travis

@@ -0,0 +1,4 @@
+test:
+  adapter: sqlite3
+  timeout: 500
+  database: ":memory:"

data/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: encrypt_attributes_test
+      hosts:
+        - localhost:27017

data/db/migrate/20140610120934_create_users.rb

@@ -0,0 +1,8 @@
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users, force: true do |t|
+      t.string :token
+      t.string :secret
+    end
+  end
+end

data/db/schema.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20140610120934) do
+
+  create_table "users", force: true do |t|
+    t.string "token"
+    t.string "secret"
+  end
+
+end

data/encrypt_attributes.gemspec

@@ -0,0 +1,33 @@
+ENV["RACK_ENV"] ||= "test"
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'encrypt_attributes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "encrypt_attributes"
+  spec.version       = EncryptAttributes::VERSION
+  spec.authors       = ["Artur Hebda"]
+  spec.email         = ["arturhebda@gmail.com"]
+  spec.summary       = "Dead-simple attributes encryption for ORMs"
+  spec.description   = "This gem provides a dead-simple encryption of string / text attributes of ActiveRecord and Mongoid models. Encryptor internally uses ActiveSupport::MessageEncryptor and therefore it uses 'aes-256-cbc' cipher by default. Gem does NOT require column with different name. From user perspective encryption is completely transparent - they use decrypted values all the time, but encrypted values are stored in database."
+  spec.homepage      = "https://github.com/aenain/encrypted_attributes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", ">= 4.1"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.rc1"
+  spec.add_development_dependency "rspec-mocks", "~> 3.0.0.rc1"
+
+  spec.add_development_dependency "activerecord", ">= 4.1"
+  spec.add_development_dependency "mongoid", "~> 4.0.0.beta1"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry-byebug"
+end

data/lib/encrypt_attributes.rb

@@ -0,0 +1,29 @@
+require "active_support/core_ext/object/try"
+
+module EncryptAttributes
+  class MissingAdapterError < StandardError; end
+
+  module_function
+
+  def find_adapter(base)
+    adapter = adapters.find do |receiver, adapter|
+      base.ancestors.map(&:to_s).include?(receiver)
+    end.try(:last)
+
+    adapter || (raise MissingAdapterError)
+  end
+
+  def register_adapter(receiver, adapter)
+    adapters[receiver] = adapter
+  end
+
+  def adapters
+    @adapters ||= {}
+  end
+end
+
+require "encrypt_attributes/version"
+require "encrypt_attributes/macros"
+require "encrypt_attributes/encryptor"
+require "encrypt_attributes/model"
+require "encrypt_attributes/adapters"

data/lib/encrypt_attributes/adapters.rb

@@ -0,0 +1,7 @@
+module EncryptAttributes
+  module Adapters
+  end
+end
+
+require "encrypt_attributes/adapters/base"
+Dir[File.join(__dir__, 'adapters', '*.rb')].each { |adapter| require adapter }

data/lib/encrypt_attributes/adapters/active_record.rb

@@ -0,0 +1,10 @@
+module EncryptAttributes
+  module Adapters
+    module ActiveRecord
+      include Base
+    end
+  end
+
+  self.register_adapter("ActiveRecord::Base",
+    EncryptAttributes::Adapters::ActiveRecord)
+end

data/lib/encrypt_attributes/adapters/base.rb

@@ -0,0 +1,19 @@
+module EncryptAttributes
+  module Adapters
+    module Base
+      def read_encrypted_attribute(attr_name)
+        encryptor.decrypt(read_attribute(attr_name))
+      end
+
+      def write_encrypted_attribute(attr_name, attr_value)
+        write_attribute(attr_name, encryptor.encrypt(attr_value))
+      end
+
+      private
+
+      def encryptor
+        Encryptor.new
+      end
+    end
+  end
+end

data/lib/encrypt_attributes/adapters/mongoid.rb

@@ -0,0 +1,10 @@
+module EncryptAttributes
+  module Adapters
+    module Mongoid
+      include Base
+    end
+  end
+
+  self.register_adapter("Mongoid::Document",
+    EncryptAttributes::Adapters::Mongoid)
+end

data/lib/encrypt_attributes/encryptor.rb

@@ -0,0 +1,27 @@
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/message_encryptor"
+require "encrypt_attributes"
+
+module EncryptAttributes
+  class Encryptor
+    cattr_accessor :secret
+
+    if defined?(Rails)
+      self.secret ||= Rails.application.secrets.secret_key_base
+    end
+
+    def encrypt(value)
+      return value if value.to_s.empty?
+      message_encryptor.encrypt_and_sign(value)
+    end
+
+    def decrypt(value)
+      return value if value.to_s.empty?
+      message_encryptor.decrypt_and_verify(value)
+    end
+
+    def message_encryptor
+      ActiveSupport::MessageEncryptor.new(self.class.secret)
+    end
+  end
+end

data/lib/encrypt_attributes/macros.rb

@@ -0,0 +1,21 @@
+module EncryptAttributes
+  module Macros
+    def encrypt_attrs(*attr_names)
+      mod = Module.new
+      mod.module_eval do
+        attr_names.each do |attr_name|
+          # getter
+          define_method(attr_name) do
+            read_encrypted_attribute(attr_name)
+          end
+
+          # setter
+          define_method("#{attr_name}=") do |value|
+            write_encrypted_attribute(attr_name, value)
+          end
+        end
+      end
+      include mod
+    end
+  end
+end

data/lib/encrypt_attributes/model.rb

@@ -0,0 +1,12 @@
+require "encrypt_attributes"
+
+module EncryptAttributes
+  module Model
+    def self.included(base)
+      base.class_eval do
+        include EncryptAttributes.find_adapter(base)
+      end
+      base.extend(Macros)
+    end
+  end
+end

data/lib/encrypt_attributes/version.rb

@@ -0,0 +1,3 @@
+module EncryptAttributes
+  VERSION = "0.0.1"
+end

data/lib/tasks/active_record.rake

@@ -0,0 +1,21 @@
+# Excerpt from https://github.com/janko-m/sinatra-activerecord/blob/master/lib/sinatra/activerecord/tasks.rake
+require "active_record"
+require "sqlite3"
+
+load "active_record/railties/databases.rake"
+
+ActiveRecord::Base.configurations = YAML.load_file("config/database.yml")
+
+ActiveRecord::Tasks::DatabaseTasks.tap do |config|
+  config.root                   = Rake.application.original_dir
+  config.env                    = "test"
+  config.db_dir                 = "db"
+  config.migrations_paths       = ["db/migrate"]
+  config.database_configuration = ActiveRecord::Base.configurations
+end
+
+namespace :db do
+  task :environment do
+    ActiveRecord::Base.establish_connection(:test)
+  end
+end

data/spec/adapters/active_record_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "support/connections/active_record"
+
+require "encrypt_attributes/model"
+
+class User < ActiveRecord::Base
+  include EncryptAttributes::Model
+  encrypt_attrs :secret
+end unless defined?(User)
+
+describe User do
+  after(:all) { User.delete_all }
+  include_examples "adapter"
+end

data/spec/adapters/mongoid_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "support/connections/mongoid"
+
+require "encrypt_attributes/model"
+
+class MongoidUser
+  include Mongoid::Document
+  include EncryptAttributes::Model
+
+  field :secret, type: String
+
+  encrypt_attrs :secret
+end unless defined?(MongoidUser)
+
+describe MongoidUser do
+  after(:all) { Mongoid.purge! }
+  include_examples "adapter"
+end

data/spec/encryptor_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+require "encrypt_attributes/encryptor"
+
+def set_valid_encryptor_secret
+  EncryptAttributes::Encryptor.secret = EncryptorHelpers::VALID_SECRET
+end
+
+describe EncryptAttributes::Encryptor do
+  include MessageEncryptorHelpers
+
+  it { should respond_to(:secret) }
+  it { should respond_to(:secret=) }
+
+  describe "#message_encryptor" do
+    let(:secret) { "secret" }
+    let(:encryptor_class) { ActiveSupport::MessageEncryptor }
+
+    it "uses secret to instantiate encryptor" do
+      described_class.secret = secret
+      allow(encryptor_class).to receive(:new)
+      described_class.new.message_encryptor
+      expect(encryptor_class).to have_received(:new).with(secret)
+    end
+  end
+
+  describe "#encrypt" do
+    subject { described_class.new }
+
+    before(:each) do
+      set_valid_encryptor_secret
+    end
+
+    context "nil" do
+      it "returns nil" do
+        expect(subject.encrypt(nil)).to be_nil
+      end
+    end
+
+    context "empty string" do
+      it "returns empty string" do
+        expect(subject.encrypt("")).to eq ""
+      end
+    end
+
+    context "not empty value" do
+      let(:decrypted) { "decrypted" }
+
+      it "encrypts correctly" do
+        expect(subject.encrypt(decrypted))
+          .to be_encryption_of(decrypted)
+      end
+    end
+  end
+
+  describe "#decrypt" do
+    subject { described_class.new }
+
+    before(:each) do
+      set_valid_encryptor_secret
+    end
+
+    context "nil" do
+      it "returns nil" do
+        expect(subject.decrypt(nil)).to be_nil
+      end
+    end
+
+    context "empty string" do
+      it "returns empty string" do
+        expect(subject.decrypt("")).to eq ""
+      end
+    end
+
+    context "not empty value" do
+      let(:decrypted) { "decrypted" }
+      let(:encrypted) { subject.encrypt(decrypted) }
+
+      it "decrypts correctly" do
+        expect(subject.decrypt(encrypted)).to eq decrypted
+      end
+    end
+
+    context "tampered value" do
+      it "raises error" do
+        expect {
+          subject.decrypt("tampered")
+        }.to raise_error(ActiveSupport::MessageVerifier::InvalidSignature)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(__dir__, "..", "lib"))
+Dir[File.join(__dir__, "support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+end

data/spec/support/connections/active_record.rb

@@ -0,0 +1,10 @@
+require "rake"
+
+load File.join(__dir__, '..', '..', '..', 'lib', 'tasks', 'active_record.rake')
+
+if ENV['TRAVIS']
+  Rake::Task["db:create"].invoke
+  Rake::Task["db:schema:load"].invoke
+else
+  ActiveRecord::Base.establish_connection(:test)
+end

data/spec/support/connections/mongoid.rb

@@ -0,0 +1,6 @@
+require "mongoid"
+
+Mongoid.configure do |config|
+  raw_config = YAML.load(File.read("config/mongoid.yml"))
+  config.sessions = raw_config["test"]["sessions"]
+end

data/spec/support/encryption_matcher.rb

@@ -0,0 +1,23 @@
+RSpec::Matchers.define :be_encryption_of do |expected|
+  match do |actual|
+    begin
+      secret    = EncryptAttributes::Encryptor.secret
+      encryptor = ActiveSupport::MessageEncryptor.new(secret)
+      encryptor.decrypt_and_verify(actual) == expected
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      false
+    end
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be an encryption of #{expected}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not be an encryption of #{expected}"
+  end
+
+  description do
+    "be an encryption of #{expected}"
+  end
+end

data/spec/support/encryptor_helpers.rb

@@ -0,0 +1,16 @@
+module EncryptorHelpers
+  VALID_SECRET = "14a678aa4a78286d94878d2256f6e591b53707b3f1ec9cdd4cbfde1514670d32".freeze
+
+  def self.included(base)
+    base.class_eval do
+      let(:decrypted) { "decrypted" }
+      let(:encrypted) { encrypt(decrypted) }
+    end
+  end
+
+  def encrypt(value)
+    encryptor = EncryptAttributes::Encryptor.new
+    encryptor.class.secret ||= VALID_SECRET
+    encryptor.encrypt(value)
+  end
+end

data/spec/support/examples/adapter.rb

@@ -0,0 +1,81 @@
+shared_examples_for "adapter:storing" do
+  subject { described_class.new }
+
+  describe "storing" do
+    it "encrypts attributes" do
+      subject.secret = decrypted
+      subject.save
+
+      expect(read_attribute.call(:secret)).to eq encrypted
+    end
+  end
+end
+
+shared_examples_for "adapter:retrieving" do
+  subject { described_class.create(secret: decrypted) }
+
+  describe "retrieving" do
+    it "decrypts specified attributes" do
+      subject.reload
+      expect(subject.secret).to eq decrypted
+    end
+  end
+end
+
+shared_examples_for "adapter:overrides:reader" do
+  subject { described_class.create(secret: decrypted) }
+
+  describe "overriden reader" do
+    it "supports super chain" do
+      def subject.secret
+        super.tap { |v| yield v if block_given? }
+      end
+
+      injection = double(call: nil)
+      subject.secret { |v| injection.call(v) }
+
+      expect(injection).to have_received(:call).with(decrypted)
+    end
+  end
+end
+
+shared_examples_for "adapter:overrides:writer" do
+  subject { described_class.create(secret: decrypted) }
+
+  describe "overriden writer" do
+    let(:injection) { double(call: nil) }
+
+    before(:each) do
+      subject.instance_variable_set(:@injection, injection)
+      def subject.secret=(new_secret)
+        @injection.call
+        super
+      end
+    end
+
+    it "supports super chain" do
+      subject.secret = decrypted
+      subject.save
+
+      expect(injection).to have_received(:call)
+      expect(read_attribute.call(:secret)).to eq encrypted
+    end
+  end
+end
+
+shared_examples_for "adapter" do
+  include EncryptorHelpers
+
+  let(:read_attribute) { subject.public_method(:read_attribute) }
+  let(:encryptor) { double(encrypt: encrypted, decrypt: decrypted) }
+
+  before(:each) do
+    allow(EncryptAttributes::Encryptor)
+      .to receive(:new).and_return(encryptor)
+  end
+
+  include_examples "adapter:storing"
+  include_examples "adapter:retrieving"
+  include_examples "adapter:overrides:reader"
+  include_examples "adapter:overrides:writer"
+end

data/spec/support/message_encryptor_helpers.rb

@@ -0,0 +1,13 @@
+module MessageEncryptorHelpers
+  def stub_message_encryption(input, output)
+    allow_any_instance_of(ActiveSupport::MessageEncryptor)
+      .to receive(:encrypt_and_sign).with(input)
+        .and_return(output)
+  end
+
+  def stub_message_decryption(input, output)
+    allow_any_instance_of(ActiveSupport::MessageEncryptor)
+      .to receive(:decrypt_and_verify).with(input)
+        .and_return(output)
+  end
+end

metadata

@@ -0,0 +1,217 @@
+--- !ruby/object:Gem::Specification
+name: encrypt_attributes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Artur Hebda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides a dead-simple encryption of string / text attributes
+  of ActiveRecord and Mongoid models. Encryptor internally uses ActiveSupport::MessageEncryptor
+  and therefore it uses 'aes-256-cbc' cipher by default. Gem does NOT require column
+  with different name. From user perspective encryption is completely transparent
+  - they use decrypted values all the time, but encrypted values are stored in database.
+email:
+- arturhebda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/database.yml
+- config/database.yml.travis
+- config/mongoid.yml
+- db/migrate/20140610120934_create_users.rb
+- db/schema.rb
+- encrypt_attributes.gemspec
+- lib/encrypt_attributes.rb
+- lib/encrypt_attributes/adapters.rb
+- lib/encrypt_attributes/adapters/active_record.rb
+- lib/encrypt_attributes/adapters/base.rb
+- lib/encrypt_attributes/adapters/mongoid.rb
+- lib/encrypt_attributes/encryptor.rb
+- lib/encrypt_attributes/macros.rb
+- lib/encrypt_attributes/model.rb
+- lib/encrypt_attributes/version.rb
+- lib/tasks/active_record.rake
+- spec/adapters/active_record_spec.rb
+- spec/adapters/mongoid_spec.rb
+- spec/encryptor_spec.rb
+- spec/spec_helper.rb
+- spec/support/connections/active_record.rb
+- spec/support/connections/mongoid.rb
+- spec/support/encryption_matcher.rb
+- spec/support/encryptor_helpers.rb
+- spec/support/examples/adapter.rb
+- spec/support/message_encryptor_helpers.rb
+homepage: https://github.com/aenain/encrypted_attributes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dead-simple attributes encryption for ORMs
+test_files:
+- spec/adapters/active_record_spec.rb
+- spec/adapters/mongoid_spec.rb
+- spec/encryptor_spec.rb
+- spec/spec_helper.rb
+- spec/support/connections/active_record.rb
+- spec/support/connections/mongoid.rb
+- spec/support/encryption_matcher.rb
+- spec/support/encryptor_helpers.rb
+- spec/support/examples/adapter.rb
+- spec/support/message_encryptor_helpers.rb
+has_rdoc: