lockbox 1.1.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25557e658cab349f0b1e5875b87f3c0a804a5c3aa587171331c5bdbece0ebf2f
-  data.tar.gz: 6d9d0e425c3c2107e9cdce85880c9b11db16062c68e1f87706c8f70afac6eef0
+  metadata.gz: db8c162439dc5376d1aabf48af3925fd2d7a5129e3902b49b973dce9eda16a77
+  data.tar.gz: 2e82dc5026e09fdaee0bb1baddabc9b0f8294f38cf613ee09368d62aa39c4ff4
 SHA512:
-  metadata.gz: 1df5017733e14858ed3bacb5a480bbe43858974b05a74abe0165d680bb4a6a0e700e49990e5cd8004f8b021c33d6ed0c4edfe3bd5d0e7a02dc114d16894cf02d
-  data.tar.gz: 3d51c407d23036699bf2b3a7813eca85c1004e01ba8edda1bc75b5e0e6a1086e3fe1cbd0593f9cab4b0ce7fd16dd1cc320dd6fac8aead84fdfd436530db0ae5a
+  metadata.gz: e8d6d9a2c4661767c01ab8874f29c3fd705712d4f3d6d153e09b4c7ad6441bb0812d45c6cf526d3a59177ae23c44289b1aa375e462303c17fcb952edd4641a8e
+  data.tar.gz: 2e5cd80ddca65447f10a666b5568bbdeff449bf6517c944a67f6fdfdd5ff253e7560569133216a5459d1519ad3bb72b5cabd17065240a2aa1091750e21b4c26c

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.3.0 (2023-07-02)
+
+- Added support for CarrierWave 3
+
+## 1.2.0 (2023-03-20)
+
+- Made it easier to rotate master key
+- Added `associated_data` option for database fields and files
+- Added `decimal` type
+- Added `encode_attributes` option
+- Fixed deprecation warnings with Rails 7.1
+
 ## 1.1.2 (2023-02-01)
 
 - Fixed error when migrating to `array`, `hash`, and `json` types

data/README.md

@@ -117,6 +117,7 @@ class User < ApplicationRecord
   has_encrypted :active, type: :boolean
   has_encrypted :salary, type: :integer
   has_encrypted :latitude, type: :float
+  has_encrypted :longitude, type: :decimal
   has_encrypted :video, type: :binary
   has_encrypted :properties, type: :json
   has_encrypted :settings, type: :hash
@@ -566,51 +567,25 @@ Use `decrypt_str` get the value as UTF-8
 
 To make key rotation easy, you can pass previous versions of keys that can decrypt.
 
-### Active Record & Mongoid
-
-Update your model:
+Create `config/initializers/lockbox.rb` with:
 
 ```ruby
-class User < ApplicationRecord
-  has_encrypted :email, previous_versions: [{master_key: previous_key}]
-end
+Lockbox.default_options[:previous_versions] = [{master_key: previous_key}]
 ```
 
-To rotate existing records, use:
+To rotate existing Active Record & Mongoid records, use:
 
 ```ruby
 Lockbox.rotate(User, attributes: [:email])
 ```
 
-Once all records are rotated, you can remove `previous_versions` from the model.
-
-### Action Text
-
-Update your initializer:
-
-```ruby
-Lockbox.encrypts_action_text_body(previous_versions: [{master_key: previous_key}])
-```
-
-To rotate existing records, use:
+To rotate existing Action Text records, use:
 
 ```ruby
 Lockbox.rotate(ActionText::RichText, attributes: [:body])
 ```
 
-Once all records are rotated, you can remove `previous_versions` from the initializer.
-
-### Active Storage
-
-Update your model:
-
-```ruby
-class User < ApplicationRecord
-  encrypts_attached :license, previous_versions: [{master_key: previous_key}]
-end
-```
-
-To rotate existing files, use:
+To rotate existing Active Storage files, use:
 
 ```ruby
 User.with_attached_license.find_each do |user|
@@ -618,39 +593,31 @@ User.with_attached_license.find_each do |user|
 end
 ```
 
-Once all files are rotated, you can remove `previous_versions` from the model.
-
-### CarrierWave
-
-Update your model:
-
-```ruby
-class LicenseUploader < CarrierWave::Uploader::Base
-  encrypt previous_versions: [{master_key: previous_key}]
-end
-```
-
-To rotate existing files, use:
+To rotate existing CarrierWave files, use:
 
 ```ruby
 User.find_each do |user|
   user.license.rotate_encryption!
+  # or for multiple files
+  user.licenses.map(&:rotate_encryption!)
 end
 ```
 
-For multiple files, use:
+Once everything is rotated, you can remove `previous_versions` from the initializer.
+
+### Individual Fields & Files
+
+You can also pass previous versions to individual fields and files.
 
 ```ruby
-User.find_each do |user|
-  user.licenses.map(&:rotate_encryption!)
+class User < ApplicationRecord
+  has_encrypted :email, previous_versions: [{master_key: previous_key}]
 end
 ```
 
-Once all files are rotated, you can remove `previous_versions` from the model.
-
 ### Local Files & Strings
 
-For local files and strings, use:
+To rotate local files and strings, use:
 
 ```ruby
 Lockbox.new(key: key, previous_versions: [{key: previous_key}])
@@ -928,6 +895,14 @@ lockbox.decrypt(ciphertext, associated_data: "somecontext")  # success
 lockbox.decrypt(ciphertext, associated_data: "othercontext") # fails
 ```
 
+You can also use it with database fields and files.
+
+```ruby
+class User < ApplicationRecord
+  has_encrypted :email, associated_data: -> { code }
+end
+```
+
 ## Binary Columns
 
 You can use `binary` columns for the ciphertext instead of `text` columns.
@@ -948,6 +923,12 @@ class User < ApplicationRecord
 end
 ```
 
+or set it globally:
+
+```ruby
+Lockbox.encode_attributes = false
+```
+
 ## Compatibility
 
 It’s easy to read encrypted data in another language if needed.

data/lib/lockbox/box.rb

@@ -1,6 +1,8 @@
 module Lockbox
   class Box
-    def initialize(key: nil, algorithm: nil, encryption_key: nil, decryption_key: nil, padding: false)
+    NOT_SET = Object.new
+
+    def initialize(key: nil, algorithm: nil, encryption_key: nil, decryption_key: nil, padding: false, associated_data: nil)
       raise ArgumentError, "Cannot pass both key and encryption/decryption key" if key && (encryption_key || decryption_key)
 
       key = Lockbox::Utils.decode_key(key) if key
@@ -32,9 +34,11 @@ module Lockbox
 
       @algorithm = algorithm
       @padding = padding == true ? 16 : padding
+      @associated_data = associated_data
     end
 
-    def encrypt(message, associated_data: nil)
+    def encrypt(message, associated_data: NOT_SET)
+      associated_data = @associated_data if associated_data == NOT_SET
       message = Lockbox.pad(message, size: @padding) if @padding
       case @algorithm
       when "hybrid"
@@ -53,7 +57,8 @@ module Lockbox
       nonce + ciphertext
     end
 
-    def decrypt(ciphertext, associated_data: nil)
+    def decrypt(ciphertext, associated_data: NOT_SET)
+      associated_data = @associated_data if associated_data == NOT_SET
       message =
         case @algorithm
         when "hybrid"

data/lib/lockbox/carrier_wave_extensions.rb

@@ -105,7 +105,7 @@ module Lockbox
   end
 end
 
-if CarrierWave::VERSION.to_i > 2
+if CarrierWave::VERSION.to_i > 3
   raise Lockbox::Error, "CarrierWave #{CarrierWave::VERSION} not supported in this version of Lockbox"
 elsif CarrierWave::VERSION.to_i < 1
   raise Lockbox::Error, "CarrierWave #{CarrierWave::VERSION} not supported"

data/lib/lockbox/encryptor.rb

@@ -9,7 +9,7 @@ module Lockbox
 
       @boxes =
         [Box.new(**options)] +
-        Array(previous_versions).map { |v| Box.new(key: options[:key], **v) }
+        Array(previous_versions).reject { |v| v.key?(:master_key) }.map { |v| Box.new(key: options[:key], **v) }
     end
 
     def encrypt(message, **options)

data/lib/lockbox/log_subscriber.rb

@@ -6,7 +6,7 @@ module Lockbox
       payload = event.payload
       name = "Encrypt File (#{event.duration.round(1)}ms)"
 
-      debug "  #{color(name, YELLOW, true)} Encrypted #{payload[:name]}"
+      debug "  #{color(name, YELLOW, bold: true)} Encrypted #{payload[:name]}"
     end
 
     def decrypt_file(event)
@@ -15,7 +15,7 @@ module Lockbox
       payload = event.payload
       name = "Decrypt File (#{event.duration.round(1)}ms)"
 
-      debug "  #{color(name, YELLOW, true)} Decrypted #{payload[:name]}"
+      debug "  #{color(name, YELLOW, bold: true)} Decrypted #{payload[:name]}"
     end
   end
 end

data/lib/lockbox/model.rb

@@ -19,10 +19,12 @@ module Lockbox
       #   options[:type] = :integer
       # when Float
       #   options[:type] = :float
+      # when BigDecimal
+      #   options[:type] = :decimal
       # end
 
       custom_type = options[:type].respond_to?(:serialize) && options[:type].respond_to?(:deserialize)
-      valid_types = [nil, :string, :boolean, :date, :datetime, :time, :integer, :float, :binary, :json, :hash, :array, :inet]
+      valid_types = [nil, :string, :boolean, :date, :datetime, :time, :integer, :float, :decimal, :binary, :json, :hash, :array, :inet]
       raise ArgumentError, "Unknown type: #{options[:type]}" unless custom_type || valid_types.include?(options[:type])
 
       activerecord = defined?(ActiveRecord::Base) && self < ActiveRecord::Base
@@ -50,7 +52,7 @@ module Lockbox
 
         options[:attribute] = name.to_s
         options[:encrypted_attribute] = encrypted_attribute
-        options[:encode] = true unless options.key?(:encode)
+        options[:encode] = Lockbox.encode_attributes unless options.key?(:encode)
 
         encrypt_method_name = "generate_#{encrypted_attribute}"
         decrypt_method_name = "decrypt_#{encrypted_attribute}"
@@ -321,9 +323,15 @@ module Lockbox
 
               attribute name, attribute_type
 
-              serialize name, JSON if options[:type] == :json
-              serialize name, Hash if options[:type] == :hash
-              serialize name, Array if options[:type] == :array
+              if ActiveRecord::VERSION::STRING.to_f >= 7.1
+                serialize name, coder: JSON if options[:type] == :json
+                serialize name, type: Hash if options[:type] == :hash
+                serialize name, type: Array if options[:type] == :array
+              else
+                serialize name, JSON if options[:type] == :json
+                serialize name, Hash if options[:type] == :hash
+                serialize name, Array if options[:type] == :array
+              end
             elsif !attributes_to_define_after_schema_loads.key?(name.to_s)
               # when migrating it's best to specify the type directly
               # however, we can try to use the original type if its already defined
@@ -531,6 +539,19 @@ module Lockbox
                 message = ActiveRecord::Type::Float.new.serialize(message)
                 # double precision, big endian
                 message = [message].pack("G") unless message.nil?
+              when :decimal
+                message =
+                  if ActiveRecord::VERSION::MAJOR >= 6
+                    ActiveRecord::Type::Decimal.new.serialize(message)
+                  else
+                    # issue with serialize in Active Record < 6
+                    # https://github.com/rails/rails/commit/a741208f80dd33420a56486bd9ed2b0b9862234a
+                    ActiveRecord::Type::Decimal.new.cast(message)
+                  end
+                # Postgres stores 4 decimal digits in 2 bytes
+                # plus 3 to 8 bytes of overhead
+                # but use string for simplicity
+                message = message.to_s("F") unless message.nil?
               when :inet
                 unless message.nil?
                   ip = message.is_a?(IPAddr) ? message : (IPAddr.new(message) rescue nil)
@@ -579,6 +600,8 @@ module Lockbox
                 message = ActiveRecord::Type::Integer.new(limit: 8).deserialize(message.unpack1("q>"))
               when :float
                 message = ActiveRecord::Type::Float.new.deserialize(message.unpack1("G"))
+              when :decimal
+                message = ActiveRecord::Type::Decimal.new.deserialize(message)
               when :string
                 message.force_encoding(Encoding::UTF_8)
               when :binary

data/lib/lockbox/utils.rb

@@ -26,6 +26,10 @@ module Lockbox
           )
       end
 
+      unless options.key?(:previous_versions)
+        options[:previous_versions] = Lockbox.default_options[:previous_versions]
+      end
+
       if options[:previous_versions].is_a?(Array)
         # dup previous versions array (with map) since elements are updated
         # dup each version (with dup) since keys are sometimes deleted

data/lib/lockbox/version.rb

@@ -1,3 +1,3 @@
 module Lockbox
-  VERSION = "1.1.2"
+  VERSION = "1.3.0"
 end

data/lib/lockbox.rb

@@ -5,17 +5,17 @@ require "securerandom"
 require "stringio"
 
 # modules
-require "lockbox/aes_gcm"
-require "lockbox/box"
-require "lockbox/calculations"
-require "lockbox/encryptor"
-require "lockbox/key_generator"
-require "lockbox/io"
-require "lockbox/migrator"
-require "lockbox/model"
-require "lockbox/padding"
-require "lockbox/utils"
-require "lockbox/version"
+require_relative "lockbox/aes_gcm"
+require_relative "lockbox/box"
+require_relative "lockbox/calculations"
+require_relative "lockbox/encryptor"
+require_relative "lockbox/key_generator"
+require_relative "lockbox/io"
+require_relative "lockbox/migrator"
+require_relative "lockbox/model"
+require_relative "lockbox/padding"
+require_relative "lockbox/utils"
+require_relative "lockbox/version"
 
 module Lockbox
   class Error < StandardError; end
@@ -27,10 +27,11 @@ module Lockbox
   extend Padding
 
   class << self
-    attr_accessor :default_options
+    attr_accessor :default_options, :encode_attributes
     attr_writer :master_key
   end
   self.default_options = {}
+  self.encode_attributes = true
 
   def self.master_key
     @master_key ||= ENV["LOCKBOX_MASTER_KEY"]
@@ -87,11 +88,11 @@ module Lockbox
 end
 
 # integrations
-require "lockbox/carrier_wave_extensions" if defined?(CarrierWave)
-require "lockbox/railtie" if defined?(Rails)
+require_relative "lockbox/carrier_wave_extensions" if defined?(CarrierWave)
+require_relative "lockbox/railtie" if defined?(Rails)
 
 if defined?(ActiveSupport::LogSubscriber)
-  require "lockbox/log_subscriber"
+  require_relative "lockbox/log_subscriber"
   Lockbox::LogSubscriber.attach_to :lockbox
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lockbox
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-01 00:00:00.000000000 Z
+date: 2023-07-02 00:00:00.000000000 Z
 dependencies: []
 description:
 email: andrew@ankane.org
@@ -58,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Modern encryption for Ruby and Rails