kms_encrypted 1.0.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11c711222f049df42c663c9e68a2822fb7e318d3f3fc02f6346801c998ead328
-  data.tar.gz: 98200a87d8bf02a7398b075aaa6d79dff706a4d15d850584ebd952329980520b
+  metadata.gz: 0d6182ffbaae6402f3cfd620f93242fe457a37aeda8609362d7eb08572f020e0
+  data.tar.gz: e2241d145e0407fcc6238e94ae653dc98de17538b95b4ee7df8c8ff48a94cbf3
 SHA512:
-  metadata.gz: 7b3d37f2739f1a869a8a34c62e9300c3b54b0e8b87b98377883fa252d161aaafcb387044049bf0bfb070e86d481034bcf5c19b0e83d21a4668a513b02f3da151
-  data.tar.gz: b5596bc03466ac15b09d72cd1e00093eda05e2dcd3ca17607484ff678da808647bb7d364be27b5cfc912cdcccb991cbb55b18fd94206a4cb4510d17eaeb4c0da
+  metadata.gz: b696faad41fce6bba45b23f981ec1eb1e557b9048e7e7bc79ebb4f70ee090a0bf0b8dbc68ef9226db88c2d75f3e13a1e04feabba5002a43466b845f9abb30b3c
+  data.tar.gz: 569fc18fcb7d7c7751735310867efd5a8411f1756f539cc2073ed3360ea1ca05a761ef3d67694427ee810f3c556d4ef1c7ea122a88ff9ddb763c480ba60f9b61

data/CHANGELOG.md

@@ -1,4 +1,27 @@
-## 1.0.0
+## 1.2.1 (2020-09-28)
+
+- Fixed `Version not active` error when switching keys
+
+## 1.2.0 (2020-08-18)
+
+- Raise error when trying to rotate key used for encrypted files
+
+## 1.1.1 (2020-04-16)
+
+- Fixed `SystemStackError` with `reload` and CarrierWave
+
+## 1.1.0 (2019-07-09)
+
+- Added support for Lockbox
+- Dropped support for Rails 4.2
+
+## 1.0.1 (2019-01-21)
+
+- Added support for encryption and decryption outside models
+- Added support for dynamic keys
+- Fixed issue with inheritance
+
+## 1.0.0 (2018-12-17)
 
 - Added versioning
 - Added `context_hash` method
@@ -9,38 +32,38 @@ Breaking changes
 - ActiveSupport notifications were changed from `generate_data_key` and `decrypt_data_key` to `encrypt` and `decrypt`
 - AWS KMS uses the `Encrypt` operation instead of `GenerateDataKey`
 
-## 0.3.0
+## 0.3.0 (2018-11-11)
 
 - Added support for Vault
 - Removed `KmsEncrypted.kms_client` and `KmsEncrypted.client_options` in favor of `KmsEncrypted.aws_client`
 - Removed `KmsEncrypted::Google.kms_client` in favor of `KmsEncrypted.google_client`
 
-## 0.2.0
+## 0.2.0 (2018-02-23)
 
 - Added support for Google KMS
 
-## 0.1.4
+## 0.1.4 (2017-12-03)
 
 - Added `kms_keys` method to models
 - Reset data keys when record is reloaded
 - Added `kms_client`
 - Added ActiveSupport notifications
 
-## 0.1.3
+## 0.1.3 (2017-12-01)
 
 - Added test key
 - Added `client_options`
 - Allow private or protected `kms_encryption_context` method
 
-## 0.1.2
+## 0.1.2 (2017-09-25)
 
 - Use `KMS_KEY_ID` env variable by default
 
-## 0.1.1
+## 0.1.1 (2017-09-23)
 
 - Added key rotation
 - Added support for multiple keys per record
 
-## 0.1.0
+## 0.1.0 (2017-09-23)
 
 - First release

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2017-2018 Andrew Kane
+Copyright (c) 2017-2020 Andrew Kane
 
 MIT License
 

data/README.md

@@ -1,34 +1,482 @@
 # KMS Encrypted
 
-Simple, secure key management for [attr_encrypted](https://github.com/attr-encrypted/attr_encrypted)
+Simple, secure key management for [Lockbox](https://github.com/ankane/lockbox) and [attr_encrypted](https://github.com/attr-encrypted/attr_encrypted)
 
 With KMS Encrypted:
 
 - Master encryption keys are not on application servers
+- Encrypt and decrypt permissions can be granted separately
 - There’s an immutable audit log of all activity
 - Decryption can be disabled if an attack is detected
-- Encrypt and decrypt permissions can be granted separately
 - It’s easy to rotate keys
 
 Supports [AWS KMS](https://aws.amazon.com/kms/), [Google Cloud KMS](https://cloud.google.com/kms/), and [Vault](https://www.vaultproject.io/)
 
+Check out [this post](https://ankane.org/sensitive-data-rails) for more info on securing sensitive data with Rails
+
 [![Build Status](https://travis-ci.org/ankane/kms_encrypted.svg?branch=master)](https://travis-ci.org/ankane/kms_encrypted)
 
 ## How It Works
 
-This approach uses a key management service (KMS) to manage encryption keys and attr_encrypted to do the encryption.
+This approach uses a key management service (KMS) to manage encryption keys and Lockbox / attr_encrypted to do the encryption.
+
+To encrypt an attribute, we first generate a data key and encrypt it with the KMS. This is known as [envelope encryption](https://cloud.google.com/kms/docs/envelope-encryption). We pass the unencrypted version to the encryption library and store the encrypted version in the `encrypted_kms_key` column. For each record, we generate a different data key.
+
+To decrypt an attribute, we first decrypt the data key with the KMS. Once we have the decrypted key, we pass it to the encryption library to decrypt the data. We can easily track decryptions since we have a different data key for each record.
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'kms_encrypted'
+```
+
+And follow the instructions for your key management service:
+
+- [AWS KMS](#aws-kms)
+- [Google Cloud KMS](#google-cloud-kms)
+- [Vault](#vault)
+
+### AWS KMS
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'aws-sdk-kms'
+```
+
+Create an [Amazon Web Services](https://aws.amazon.com/) account if you don’t have one. KMS works great whether or not you run your infrastructure on AWS.
+
+Create a [KMS master key](https://console.aws.amazon.com/iam/home#/encryptionKeys) and set it in your environment along with your AWS credentials ([dotenv](https://github.com/bkeepers/dotenv) is great for this)
+
+```sh
+KMS_KEY_ID=arn:aws:kms:...
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+```
+
+You can also use the alias
+
+```sh
+KMS_KEY_ID=alias/my-alias
+```
+
+### Google Cloud KMS
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'google-api-client'
+```
+
+Create a [Google Cloud Platform](https://cloud.google.com/) account if you don’t have one. KMS works great whether or not you run your infrastructure on GCP.
+
+Create a [KMS key ring and key](https://console.cloud.google.com/iam-admin/kms) and set it in your environment along with your GCP credentials ([dotenv](https://github.com/bkeepers/dotenv) is great for this)
+
+```sh
+KMS_KEY_ID=projects/.../locations/.../keyRings/.../cryptoKeys/...
+```
+
+The Google API client logs requests by default. Be sure to turn off the logger in production or it will leak the plaintext.
+
+```ruby
+Google::Apis.logger = Logger.new(nil)
+```
 
-To encrypt an attribute, we first generate a data key and encrypt it with the KMS. This is known as [envelope encryption](https://cloud.google.com/kms/docs/envelope-encryption). We pass the unencrypted version to attr_encrypted and store the encrypted version in the `encrypted_kms_key` column. For each record, we generate a different data key.
+### Vault
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'vault'
+```
+
+Enable the [transit](https://www.vaultproject.io/docs/secrets/transit/index.html) secrets engine
+
+```sh
+vault secrets enable transit
+```
 
-To decrypt an attribute, we first decrypt the data key with the KMS. Once we have the decrypted key, we pass it to attr_encrypted to decrypt the data. We can easily track decryptions since we have a different data key for each record.
+And create a key
+
+```sh
+vault write -f transit/keys/my-key derived=true
+```
+
+Set it in your environment along with your Vault credentials ([dotenv](https://github.com/bkeepers/dotenv) is great for this)
+
+```sh
+KMS_KEY_ID=vault/my-key
+VAULT_ADDR=http://127.0.0.1:8200
+VAULT_TOKEN=secret
+```
 
 ## Getting Started
 
-Follow the instructions for your key management service:
+Create a migration to add a column for the encrypted KMS data keys
+
+```ruby
+add_column :users, :encrypted_kms_key, :text
+```
+
+And update your model
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key
+
+  # Lockbox fields
+  encrypts :email, key: :kms_key
+
+  # Lockbox files
+  encrypts_attached :license, key: :kms_key
+
+  # attr_encrypted fields
+  attr_encrypted :email, key: :kms_key
+end
+```
+
+For each encrypted attribute, use the `kms_key` method for its key.
+
+## Auditing & Alerting
+
+### Context
+
+Encryption context is used in auditing to identify the data being decrypted. This is the model name and id by default. You can customize this with:
+
+```ruby
+class User < ApplicationRecord
+  def kms_encryption_context
+    {
+      model_name: model_name.to_s,
+      model_id: id
+    }
+  end
+end
+```
+
+The context is used as part of the encryption and decryption process, so it must be a value that doesn’t change. Otherwise, you won’t be able to decrypt. You can [rotate the context](#switching-context) without downtime if needed.
+
+### Order of Events
+
+Since the default context includes the id, the data key cannot be encrypted until the record has an id. For new records, the default flow is:
+
+1. Start a database transaction
+2. Insert the record, getting back the id
+3. Call KMS to encrypt the data key, passing the id as part of the context
+4. Update the `encrypted_kms_key` column
+5. Commit the database transaction
+
+With Postgres, you can avoid a network call inside a transaction with:
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key eager_encrypt: :fetch_id
+end
+```
+
+This changes the flow to:
+
+1. Prefetch the id with the Postgres `nextval` function
+2. Call KMS to encrypt the data key, passing the id as part of the context
+3. Insert the record with the id and encrypted data key
+
+If you don’t need the id from the database for context, you can use:
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key eager_encrypt: true
+end
+```
+
+### AWS KMS
+
+[AWS CloudTrail](https://aws.amazon.com/cloudtrail/) logs all decryption calls. You can view them in the [CloudTrail console](https://console.aws.amazon.com/cloudtrail/home#/events?EventName=Decrypt). Note that it can take 20 minutes for events to show up. You can also use the AWS CLI.
+
+```sh
+aws cloudtrail lookup-events --lookup-attributes AttributeKey=EventName,AttributeValue=Decrypt
+```
+
+If you haven’t already, enable CloudTrail storage to S3 to ensure events are accessible after 90 days. Later, you can use Amazon Athena and this [table structure](https://www.1strategy.com/blog/2017/07/25/auditing-aws-activity-with-cloudtrail-and-athena/) to query them.
+
+Read more about [encryption context here](https://docs.aws.amazon.com/kms/latest/developerguide/encryption-context.html).
+
+#### Alerting
+
+Set up alerts for suspicious behavior. To get near real-time alerts (20-30 second delay), use CloudWatch Events.
+
+First, create a new SNS topic with a name like "decryptions". We’ll use this shortly.
+
+Next, open [CloudWatch Events](https://console.aws.amazon.com/cloudwatch/home#rules:) and create a rule to match “Events by Service”. Choose “Key Management Service (KMS)” as the service name and “AWS API Call via CloudTrail” as the event type. For operations, select “Specific Operations” and enter “Decrypt”.
+
+Select the SNS topic created earlier as the target and save the rule.
+
+To set up an alarm, go to [this page](https://console.aws.amazon.com/cloudwatch/home?#metricsV2:graph=%7E();namespace=AWS/Events;dimensions=RuleName) in CloudWatch Metrics. Find the rule and check “Invocations”. On the “Graphed Metrics” tab, change the statistic to “Sum” and the period to “1 minute”. Finally, click the bell icon to create an alarm for high number of decryptions.
+
+While the alarm we created isn’t super sophisticated, this setup provides a great foundation for alerting as your organization grows.
+
+You can use the SNS topic or another target to send events to a log provider or [SIEM](https://en.wikipedia.org/wiki/Security_information_and_event_management), where can you do more advanced anomaly detection.
+
+You should also use other tools to detect breaches, like an [IDS](https://www.alienvault.com/blogs/security-essentials/open-source-intrusion-detection-tools-a-quick-overview). You can use [Amazon GuardDuty](https://aws.amazon.com/guardduty/) if you run infrastructure on AWS.
+
+### Google Cloud KMS
+
+Follow the [instructions here](https://cloud.google.com/kms/docs/logging) to set up data access logging. There is not currently a way to see what data is being decrypted, since the additional authenticated data is not logged. For this reason, we recommend another KMS provider.
+
+### Vault
+
+Follow the [instructions here](https://www.vaultproject.io/docs/audit/) to set up data access logging.
+
+**Note:** Vault will only verify this value if `derived` was set to true when creating the key. If this is not done, the context cannot be trusted.
+
+Context will show up hashed in the audit logs. To get the hash for a record, use:
+
+```ruby
+KmsEncrypted.context_hash(record.kms_encryption_context, path: "file")
+```
+
+The `path` option should point to your audit device. Common paths are `file`, `syslog`, and `socket`.
+
+## Separate Permissions
+
+A great feature of KMS is the ability to grant encryption and decryption permission separately.
 
-- [AWS KMS](guides/Amazon.md)
-- [Google Cloud KMS](guides/Google.md)
-- [Vault](guides/Vault.md)
+Be extremely selective of servers you allow to decrypt.
+
+For servers that can only encrypt, clear out the existing data and data key before assigning new values (otherwise, you’ll get a decryption error).
+
+```ruby
+# Lockbox
+user.email_ciphertext = nil
+user.encrypted_kms_key = nil
+
+# attr_encrypted
+user.encrypted_email = nil
+user.encrypted_email_iv = nil
+user.encrypted_kms_key = nil
+```
+
+### AWS KMS
+
+To encrypt the data, use an IAM policy with:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "EncryptData",
+            "Effect": "Allow",
+            "Action": "kms:Encrypt",
+            "Resource": "arn:aws:kms:..."
+        }
+    ]
+}
+```
+
+To decrypt the data, use an IAM policy with:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "DecryptData",
+            "Effect": "Allow",
+            "Action": "kms:Decrypt",
+            "Resource": "arn:aws:kms:..."
+        }
+    ]
+}
+```
+
+### Google Cloud KMS
+
+todo: document
+
+### Vault
+
+To encrypt the data, use a policy with:
+
+```hcl
+path "transit/encrypt/my-key"
+{
+  capabilities = ["create", "update"]
+}
+```
+
+To decrypt the data, use a policy with:
+
+```hcl
+path "transit/decrypt/my-key"
+{
+  capabilities = ["create", "update"]
+}
+```
+
+Apply a policy with:
+
+```sh
+vault policy write encrypt encrypt.hcl
+```
+
+And create a token with specific policies with:
+
+```sh
+vault token create -policy=encrypt -policy=decrypt -no-default-policy
+```
+
+## Testing
+
+For testing, you can prevent network calls to KMS by setting:
+
+```sh
+KMS_KEY_ID=insecure-test-key
+```
+
+## Key Rotation
+
+Key management services allow you to rotate the master key.
+
+AWS KMS supports [automatic key rotation](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html).
+
+For Google Cloud, use the Google Cloud Console or API.
+
+For Vault, use:
+
+```sh
+vault write -f transit/keys/my-key/rotate
+```
+
+New data will be encrypted with the new master key version. To encrypt existing data with new master key version, run:
+
+```ruby
+User.find_each do |user|
+  user.rotate_kms_key!
+end
+```
+
+**Note:** This method does not rotate encrypted files, so avoid calling `rotate_kms_key!` on models with file uploads for now.
+
+### Switching Keys
+
+You can change keys within your current KMS or move to a different KMS without downtime. Update your model:
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key version: 2, key_id: ENV["KMS_KEY_ID_V2"],
+    previous_versions: {
+      1 => {key_id: ENV["KMS_KEY_ID"]}
+    }
+end
+```
+
+New data will be encrypted with the new key. To update existing data, use:
+
+```ruby
+User.where("encrypted_kms_key NOT LIKE 'v2:%'").find_each do |user|
+  user.rotate_kms_key!
+end
+```
+
+Once all data is updated, you can remove the `previous_versions` option.
+
+### Switching Context
+
+You can change your encryption context without downtime. Update your model:
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key version: 2,
+    previous_versions: {
+      1 => {key_id: ENV["KMS_KEY_ID"]}
+    }
+
+  def kms_encryption_context(version:)
+    if version == 1
+      # previous context method
+    else
+      # new context method
+    end
+  end
+end
+```
+
+New data will be encrypted with the new context. To update existing data, use:
+
+```ruby
+User.where("encrypted_kms_key NOT LIKE 'v2:%'").find_each do |user|
+  user.rotate_kms_key!
+end
+```
+
+Once all data is updated, you can remove the `previous_versions` option.
+
+## Multiple Keys Per Record
+
+You may want to protect different columns with different data keys (or even master keys).
+
+To do this, add another column
+
+```ruby
+add_column :users, :encrypted_kms_key_phone, :text
+```
+
+And update your model
+
+```ruby
+class User < ApplicationRecord
+  has_kms_key
+  has_kms_key name: :phone, key_id: "..."
+
+  # Lockbox
+  encrypts :email, key: :kms_key
+  encrypts :phone, key: :kms_key_phone
+
+  # attr_encrypted
+  attr_encrypted :email, key: :kms_key
+  attr_encrypted :phone, key: :kms_key_phone
+end
+```
+
+To rotate keys, use:
+
+```ruby
+user.rotate_kms_key_phone!
+```
+
+For custom context, use:
+
+```ruby
+class User < ApplicationRecord
+  def kms_encryption_context_phone
+    # some hash
+  end
+end
+```
+
+## Outside Models
+
+To encrypt and decrypt outside of models, create a box:
+
+```ruby
+kms = KmsEncrypted::Box.new
+```
+
+You can pass `key_id`, `version`, and `previous_versions` if needed.
+
+Encrypt
+
+```ruby
+kms.encrypt(message, context: {model_name: "User", model_id: 123})
+```
+
+Decrypt
+
+```ruby
+kms.decrypt(ciphertext, context: {model_name: "User", model_id: 123})
+```
 
 ## Related Projects
 
@@ -74,3 +522,12 @@ Everyone is encouraged to help improve this project. Here are a few ways you can
 - Fix bugs and [submit pull requests](https://github.com/ankane/kms_encrypted/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
+
+To get started with development and testing:
+
+```sh
+git clone https://github.com/ankane/kms_encrypted.git
+cd kms_encrypted
+bundle install
+bundle exec rake test
+```

data/lib/kms_encrypted.rb

@@ -5,6 +5,7 @@ require "json"
 require "securerandom"
 
 # modules
+require "kms_encrypted/box"
 require "kms_encrypted/database"
 require "kms_encrypted/log_subscriber"
 require "kms_encrypted/model"

data/lib/kms_encrypted/box.rb

@@ -0,0 +1,91 @@
+module KmsEncrypted
+  class Box
+    attr_reader :key_id, :version, :previous_versions
+
+    def initialize(key_id: nil, version: nil, previous_versions: nil)
+      @key_id = key_id || ENV["KMS_KEY_ID"]
+      @version = version || 1
+      @previous_versions = previous_versions || {}
+    end
+
+    def encrypt(plaintext, context: nil)
+      context = version_context(context, version)
+      key_id = version_key_id(version)
+      ciphertext = KmsEncrypted::Client.new(key_id: key_id, data_key: true).encrypt(plaintext, context: context)
+      "v#{version}:#{encode64(ciphertext)}"
+    end
+
+    def decrypt(ciphertext, context: nil)
+      m = /\Av(\d+):/.match(ciphertext)
+      if m
+        version = m[1].to_i
+        ciphertext = ciphertext.sub("v#{version}:", "")
+      else
+        version = 1
+        legacy_context = true
+
+        # legacy
+        if ciphertext.start_with?("$gc$")
+          _, _, short_key_id, ciphertext = ciphertext.split("$", 4)
+
+          # restore key, except for cryptoKeyVersion
+          stored_key_id = decode64(short_key_id).split("/")[0..3]
+          stored_key_id.insert(0, "projects")
+          stored_key_id.insert(2, "locations")
+          stored_key_id.insert(4, "keyRings")
+          stored_key_id.insert(6, "cryptoKeys")
+          key_id = stored_key_id.join("/")
+        elsif ciphertext.start_with?("vault:")
+          ciphertext = Base64.encode64(ciphertext)
+        end
+      end
+
+      key_id ||= version_key_id(version)
+      ciphertext = decode64(ciphertext)
+      context = version_context(context, version)
+
+      KmsEncrypted::Client.new(
+        key_id: key_id,
+        data_key: true,
+        legacy_context: legacy_context
+      ).decrypt(ciphertext, context: context)
+    end
+
+    private
+
+    def version_key_id(version)
+      key_id =
+        if previous_versions[version]
+          previous_versions[version][:key_id]
+        elsif self.version == version
+          self.key_id
+        else
+          raise KmsEncrypted::Error, "Version not active: #{version}"
+        end
+
+      raise ArgumentError, "Missing key id" unless key_id
+
+      key_id
+    end
+
+    def version_context(context, version)
+      if context.respond_to?(:call)
+        if context.arity == 0
+          context.call
+        else
+          context.call(version)
+        end
+      else
+        context
+      end
+    end
+
+    def encode64(bytes)
+      Base64.strict_encode64(bytes)
+    end
+
+    def decode64(bytes)
+      Base64.decode64(bytes)
+    end
+  end
+end

data/lib/kms_encrypted/database.rb

@@ -8,32 +8,20 @@ module KmsEncrypted
       @options = record.class.kms_keys[key_method.to_sym]
     end
 
-    def name
-      options[:name]
+    def version
+      @version ||= evaluate_option(:version).to_i
     end
 
-    def current_version
-      @version ||= begin
-        version = options[:version]
-        version = record.instance_exec(&version) if version.respond_to?(:call)
-        version.to_i
-      end
+    def key_id
+      @key_id ||= evaluate_option(:key_id)
     end
 
-    def key_version(version)
-      versions = (options[:previous_versions] || {}).dup
-      versions[current_version] ||= options.slice(:key_id)
-
-      raise KmsEncrypted::Error, "Version not active: #{version}" unless versions[version]
-
-      key_id = versions[version][:key_id]
-
-      raise ArgumentError, "Missing key id" unless key_id
-
-      key_id
+    def previous_versions
+      @previous_versions ||= evaluate_option(:previous_versions)
     end
 
     def context(version)
+      name = options[:name]
       context_method = name ? "kms_encryption_context_#{name}" : "kms_encryption_context"
       if record.method(context_method).arity == 0
         record.send(context_method)
@@ -43,51 +31,34 @@ module KmsEncrypted
     end
 
     def encrypt(plaintext)
-      key_id = key_version(current_version)
-      context = context(current_version)
-      ciphertext = KmsEncrypted::Client.new(key_id: key_id, data_key: true).encrypt(plaintext, context: context)
-      "v#{current_version}:#{encode64(ciphertext)}"
+      context = context(version)
+
+      KmsEncrypted::Box.new(
+        key_id: key_id,
+        version: version,
+        previous_versions: previous_versions
+      ).encrypt(plaintext, context: context)
     end
 
     def decrypt(ciphertext)
+      # determine version for context
       m = /\Av(\d+):/.match(ciphertext)
-      if m
-        version = m[1].to_i
-        ciphertext = ciphertext.sub("v#{version}:", "")
-      else
-        version = 1
-        context = {} if options[:upgrade_context]
-        legacy_context = true
-
-        # legacy
-        if ciphertext.start_with?("$gc$")
-          _, _, short_key_id, ciphertext = ciphertext.split("$", 4)
-
-          # restore key, except for cryptoKeyVersion
-          stored_key_id = decode64(short_key_id).split("/")[0..3]
-          stored_key_id.insert(0, "projects")
-          stored_key_id.insert(2, "locations")
-          stored_key_id.insert(4, "keyRings")
-          stored_key_id.insert(6, "cryptoKeys")
-          key_id = stored_key_id.join("/")
-        elsif ciphertext.start_with?("vault:")
-          ciphertext = Base64.encode64(ciphertext)
-        end
-      end
-
-      key_id ||= key_version(version)
-      context ||= context(version)
-      ciphertext = decode64(ciphertext)
-
-      KmsEncrypted::Client.new(key_id: key_id, data_key: true, legacy_context: legacy_context).decrypt(ciphertext, context: context)
+      ciphertext_version = m ? m[1].to_i : 1
+      context = (options[:upgrade_context] && !m) ? {} : context(ciphertext_version)
+
+      KmsEncrypted::Box.new(
+        key_id: key_id,
+        version: version,
+        previous_versions: previous_versions
+      ).decrypt(ciphertext, context: context)
     end
 
-    def encode64(bytes)
-      Base64.strict_encode64(bytes)
-    end
+    private
 
-    def decode64(bytes)
-      Base64.decode64(bytes)
+    def evaluate_option(key)
+      opt = options[key]
+      opt = record.instance_exec(&opt) if opt.respond_to?(:call)
+      opt
     end
   end
 end

data/lib/kms_encrypted/model.rb

@@ -8,12 +8,22 @@ module KmsEncrypted
       context_method = name ? "kms_encryption_context_#{name}" : "kms_encryption_context"
 
       class_eval do
-        class << self
-          def kms_keys
-            @kms_keys ||= {}
-          end unless respond_to?(:kms_keys)
+        @kms_keys ||= {}
+
+        unless respond_to?(:kms_keys)
+          def self.kms_keys
+            parent_keys =
+              if superclass.respond_to?(:kms_keys)
+                superclass.kms_keys
+              else
+                {}
+              end
+
+            parent_keys.merge(@kms_keys || {})
+          end
         end
-        kms_keys[key_method.to_sym] = {
+
+        @kms_keys[key_method.to_sym] = {
           key_id: key_id,
           name: name,
           version: version,
@@ -21,7 +31,7 @@ module KmsEncrypted
           upgrade_context: upgrade_context
         }
 
-        if kms_keys.size == 1
+        if @kms_keys.size == 1
           after_save :encrypt_kms_keys
 
           # fetch all keys together so only need to update database once
@@ -45,16 +55,17 @@ module KmsEncrypted
             end
           end
 
-          # same pattern as attr_encrypted reload
           if method_defined?(:reload)
-            alias_method :reload_without_kms_encrypted, :reload
-            def reload(*args, &block)
-              result = reload_without_kms_encrypted(*args, &block)
-              self.class.kms_keys.keys.each do |key_method|
-                instance_variable_set("@#{key_method}", nil)
+            m = Module.new do
+              define_method(:reload) do |*args, &block|
+                result = super(*args, &block)
+                self.class.kms_keys.keys.each do |key_method|
+                  instance_variable_set("@#{key_method}", nil)
+                end
+                result
               end
-              result
             end
+            prepend m
           end
         end
 
@@ -96,11 +107,67 @@ module KmsEncrypted
           }
         end
 
+        # automatically detects attributes and files where the encryption key is:
+        # 1. a symbol that matches kms key method exactly
+        # does not detect attributes and files where the encryption key is:
+        # 1. callable (warns)
+        # 2. a symbol that internally calls kms key method
+        # it could try to get the exact key and compare
+        # (there's a very small chance this could have false positives)
+        # but bias towards simplicity for now
+        # TODO possibly raise error for callable keys in 2.0
+        # with option to override/specify attributes
         define_method("rotate_#{key_method}!") do
           # decrypt
           plaintext_attributes = {}
-          self.class.encrypted_attributes.select { |_, v| v[:key] == key_method.to_sym }.keys.each do |key|
-            plaintext_attributes[key] = send(key)
+
+          # attr_encrypted
+          if self.class.respond_to?(:encrypted_attributes)
+            self.class.encrypted_attributes.each do |key, v|
+              if v[:key] == key_method.to_sym
+                plaintext_attributes[key] = send(key)
+              elsif v[:key].respond_to?(:call)
+                warn "[kms_encrypted] Can't detect if encrypted attribute uses this key"
+              end
+            end
+          end
+
+          # lockbox attributes
+          # only checks key, not previous versions
+          if self.class.respond_to?(:lockbox_attributes)
+            self.class.lockbox_attributes.each do |key, v|
+              if v[:key] == key_method.to_sym
+                plaintext_attributes[key] = send(key)
+              elsif v[:key].respond_to?(:call)
+                warn "[kms_encrypted] Can't detect if encrypted attribute uses this key"
+              end
+            end
+          end
+
+          # lockbox attachments
+          # only checks key, not previous versions
+          if self.class.respond_to?(:lockbox_attachments)
+            self.class.lockbox_attachments.each do |key, v|
+              if v[:key] == key_method.to_sym
+                # can likely add support at some point, but may be complicated
+                # ideally use rotate_encryption! from Lockbox
+                # but needs access to both old and new keys
+                # also need to update database atomically
+                raise KmsEncrypted::Error, "Can't rotate key used for encrypted files"
+              elsif v[:key].respond_to?(:call)
+                warn "[kms_encrypted] Can't detect if encrypted attachment uses this key"
+              end
+            end
+          end
+
+          # CarrierWave uploaders
+          if self.class.respond_to?(:uploaders)
+            self.class.uploaders.each do |_, uploader|
+              # for simplicity, only checks if key is callable
+              if uploader.respond_to?(:lockbox_options) && uploader.lockbox_options[:key].respond_to?(:call)
+                warn "[kms_encrypted] Can't detect if encrypted uploader uses this key"
+              end
+            end
           end
 
           # reset key

data/lib/kms_encrypted/version.rb

@@ -1,3 +1,3 @@
 module KmsEncrypted
-  VERSION = "1.0.0"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kms_encrypted
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-17 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lockbox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.7
 - !ruby/object:Gem::Dependency
   name: aws-sdk-kms
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: carrierwave
+  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: 
 email: andrew@chartkick.com
 executables: []
@@ -160,6 +188,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/kms_encrypted.rb
+- lib/kms_encrypted/box.rb
 - lib/kms_encrypted/client.rb
 - lib/kms_encrypted/clients/aws.rb
 - lib/kms_encrypted/clients/base.rb
@@ -182,16 +211,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Simple, secure key management for attr_encrypted
+summary: Simple, secure key management for Lockbox and attr_encrypted
 test_files: []