activerecord 5.2.8 → 7.0.2

data/lib/active_record/encryption/cipher/aes256_gcm.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module ActiveRecord
+  module Encryption
+    class Cipher
+      # A 256-GCM cipher.
+      #
+      # By default it will use random initialization vectors. For deterministic encryption, it will use a SHA-256 hash of
+      # the text to encrypt and the secret.
+      #
+      # See +Encryptor+
+      class Aes256Gcm
+        CIPHER_TYPE = "aes-256-gcm"
+
+        class << self
+          def key_length
+            OpenSSL::Cipher.new(CIPHER_TYPE).key_len
+          end
+
+          def iv_length
+            OpenSSL::Cipher.new(CIPHER_TYPE).iv_len
+          end
+        end
+
+        # When iv not provided, it will generate a random iv on each encryption operation (default and
+        # recommended operation)
+        def initialize(secret, deterministic: false)
+          @secret = secret
+          @deterministic = deterministic
+        end
+
+        def encrypt(clear_text)
+          # This code is extracted from +ActiveSupport::MessageEncryptor+. Not using it directly because we want to control
+          # the message format and only serialize things once at the +ActiveRecord::Encryption::Message+ level. Also, this
+          # cipher is prepared to deal with deterministic/non deterministic encryption modes.
+
+          cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+          cipher.encrypt
+          cipher.key = @secret
+
+          iv = generate_iv(cipher, clear_text)
+          cipher.iv = iv
+
+          encrypted_data = clear_text.empty? ? clear_text.dup : cipher.update(clear_text)
+          encrypted_data << cipher.final
+
+          ActiveRecord::Encryption::Message.new(payload: encrypted_data).tap do |message|
+            message.headers.iv = iv
+            message.headers.auth_tag = cipher.auth_tag
+          end
+        end
+
+        def decrypt(encrypted_message)
+          encrypted_data = encrypted_message.payload
+          iv = encrypted_message.headers.iv
+          auth_tag = encrypted_message.headers.auth_tag
+
+          # Currently the OpenSSL bindings do not raise an error if auth_tag is
+          # truncated, which would allow an attacker to easily forge it. See
+          # https://github.com/ruby/openssl/issues/63
+          raise ActiveRecord::Encryption::Errors::EncryptedContentIntegrity if auth_tag.nil? || auth_tag.bytes.length != 16
+
+          cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+
+          cipher.decrypt
+          cipher.key = @secret
+          cipher.iv = iv
+
+          cipher.auth_tag = auth_tag
+          cipher.auth_data = ""
+
+          decrypted_data = encrypted_data.empty? ? encrypted_data : cipher.update(encrypted_data)
+          decrypted_data << cipher.final
+
+          decrypted_data
+        rescue OpenSSL::Cipher::CipherError, TypeError, ArgumentError
+          raise ActiveRecord::Encryption::Errors::Decryption
+        end
+
+        private
+          def generate_iv(cipher, clear_text)
+            if @deterministic
+              generate_deterministic_iv(clear_text)
+            else
+              cipher.random_iv
+            end
+          end
+
+          def generate_deterministic_iv(clear_text)
+            OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, @secret, clear_text)[0, ActiveRecord::Encryption.cipher.iv_length]
+          end
+      end
+    end
+  end
+end

data/lib/active_record/encryption/cipher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # The algorithm used for encrypting and decrypting +Message+ objects.
+    #
+    # It uses AES-256-GCM. It will generate a random IV for non deterministic encryption (default)
+    # or derive an initialization vector from the encrypted content for deterministic encryption.
+    #
+    # See +Cipher::Aes256Gcm+.
+    class Cipher
+      DEFAULT_ENCODING = Encoding::UTF_8
+
+      # Encrypts the provided text and return an encrypted +Message+.
+      def encrypt(clean_text, key:, deterministic: false)
+        cipher_for(key, deterministic: deterministic).encrypt(clean_text).tap do |message|
+          message.headers.encoding = clean_text.encoding.name unless clean_text.encoding == DEFAULT_ENCODING
+        end
+      end
+
+      # Decrypt the provided +Message+.
+      #
+      # When +key+ is an Array, it will try all the keys raising a
+      # +ActiveRecord::Encryption::Errors::Decryption+ if none works.
+      def decrypt(encrypted_message, key:)
+        try_to_decrypt_with_each(encrypted_message, keys: Array(key)).tap do |decrypted_text|
+          decrypted_text.force_encoding(encrypted_message.headers.encoding || DEFAULT_ENCODING)
+        end
+      end
+
+      def key_length
+        Aes256Gcm.key_length
+      end
+
+      def iv_length
+        Aes256Gcm.iv_length
+      end
+
+      private
+        def try_to_decrypt_with_each(encrypted_text, keys:)
+          keys.each.with_index do |key, index|
+            return cipher_for(key).decrypt(encrypted_text)
+          rescue ActiveRecord::Encryption::Errors::Decryption
+            raise if index == keys.length - 1
+          end
+        end
+
+        def cipher_for(secret, deterministic: false)
+          Aes256Gcm.new(secret, deterministic: deterministic)
+        end
+    end
+  end
+end

data/lib/active_record/encryption/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # Container of configuration options
+    class Config
+      attr_accessor :primary_key, :deterministic_key, :store_key_references, :key_derivation_salt,
+                    :support_unencrypted_data, :encrypt_fixtures, :validate_column_size, :add_to_filter_parameters,
+                    :excluded_from_filter_parameters, :extend_queries, :previous_schemes, :forced_encoding_for_deterministic_encryption
+
+      def initialize
+        set_defaults
+      end
+
+      # Configure previous encryption schemes.
+      #
+      #   config.active_record.encryption.previous = [ { key_provider: MyOldKeyProvider.new } ]
+      def previous=(previous_schemes_properties)
+        previous_schemes_properties.each do |properties|
+          add_previous_scheme(**properties)
+        end
+      end
+
+      private
+        def set_defaults
+          self.store_key_references = false
+          self.support_unencrypted_data = false
+          self.encrypt_fixtures = false
+          self.validate_column_size = true
+          self.add_to_filter_parameters = true
+          self.excluded_from_filter_parameters = []
+          self.previous_schemes = []
+          self.forced_encoding_for_deterministic_encryption = Encoding::UTF_8
+
+          # TODO: Setting to false for now as the implementation is a bit experimental
+          self.extend_queries = false
+        end
+
+        def add_previous_scheme(**properties)
+          previous_schemes << ActiveRecord::Encryption::Scheme.new(**properties)
+        end
+    end
+  end
+end

data/lib/active_record/encryption/configurable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # Configuration API for +ActiveRecord::Encryption+
+    module Configurable
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_reader :config, default: Config.new
+        mattr_accessor :encrypted_attribute_declaration_listeners
+      end
+
+      class_methods do
+        # Expose getters for context properties
+        Context::PROPERTIES.each do |name|
+          delegate name, to: :context
+        end
+
+        def configure(primary_key:, deterministic_key:, key_derivation_salt:, **properties) # :nodoc:
+          config.primary_key = primary_key
+          config.deterministic_key = deterministic_key
+          config.key_derivation_salt = key_derivation_salt
+
+          context.key_provider = ActiveRecord::Encryption::DerivedSecretKeyProvider.new(primary_key)
+
+          properties.each do |name, value|
+            [:context, :config].each do |configurable_object_name|
+              configurable_object = ActiveRecord::Encryption.send(configurable_object_name)
+              configurable_object.send "#{name}=", value if configurable_object.respond_to?("#{name}=")
+            end
+          end
+        end
+
+        # Register callback to be invoked when an encrypted attribute is declared.
+        #
+        # === Example:
+        #
+        #   ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, attribute_name|
+        #     ...
+        #   end
+        def on_encrypted_attribute_declared(&block)
+          self.encrypted_attribute_declaration_listeners ||= Concurrent::Array.new
+          self.encrypted_attribute_declaration_listeners << block
+        end
+
+        def encrypted_attribute_was_declared(klass, name) # :nodoc:
+          self.encrypted_attribute_declaration_listeners&.each do |block|
+            block.call(klass, name)
+          end
+        end
+
+        def install_auto_filtered_parameters_hook(application) # :nodoc:
+          ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, encrypted_attribute_name|
+            application.config.filter_parameters << encrypted_attribute_name unless ActiveRecord::Encryption.config.excluded_from_filter_parameters.include?(encrypted_attribute_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/encryption/context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # An encryption context configures the different entities used to perform encryption:
+    #
+    # * A key provider
+    # * A key generator
+    # * An encryptor, the facade to encrypt data
+    # * A cipher, the encryption algorithm
+    # * A message serializer
+    class Context
+      PROPERTIES = %i[ key_provider key_generator cipher message_serializer encryptor frozen_encryption ]
+
+      PROPERTIES.each do |name|
+        attr_accessor name
+      end
+
+      def initialize
+        set_defaults
+      end
+
+      alias frozen_encryption? frozen_encryption
+
+      private
+        def set_defaults
+          self.frozen_encryption = false
+          self.key_generator = ActiveRecord::Encryption::KeyGenerator.new
+          self.cipher = ActiveRecord::Encryption::Cipher.new
+          self.encryptor = ActiveRecord::Encryption::Encryptor.new
+          self.message_serializer = ActiveRecord::Encryption::MessageSerializer.new
+        end
+    end
+  end
+end

data/lib/active_record/encryption/contexts.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # +ActiveRecord::Encryption+ uses encryption contexts to configure the different entities used to
+    # encrypt/decrypt at a given moment in time.
+    #
+    # By default, the library uses a default encryption context. This is the +Context+ that gets configured
+    # initially via +config.active_record.encryption+ options. Library users can define nested encryption contexts
+    # when running blocks of code.
+    #
+    # See +Context+.
+    module Contexts
+      extend ActiveSupport::Concern
+
+      included do
+        mattr_reader :default_context, default: Context.new
+        thread_mattr_accessor :custom_contexts
+      end
+
+      class_methods do
+        # Configures a custom encryption context to use when running the provided block of code.
+        #
+        # It supports overriding all the properties defined in +Context+.
+        #
+        # Example:
+        #
+        #     ActiveRecord::Encryption.with_encryption_context(encryptor: ActiveRecord::Encryption::NullEncryptor.new) do
+        #       ...
+        #     end
+        #
+        # Encryption contexts can be nested.
+        def with_encryption_context(properties)
+          self.custom_contexts ||= []
+          self.custom_contexts << default_context.dup
+          properties.each do |key, value|
+            self.current_custom_context.send("#{key}=", value)
+          end
+
+          yield
+        ensure
+          self.custom_contexts.pop
+        end
+
+        # Runs the provided block in an encryption context where encryption is disabled:
+        #
+        # * Reading encrypted content will return its ciphertexts.
+        # * Writing encrypted content will write its clear text.
+        def without_encryption(&block)
+          with_encryption_context encryptor: ActiveRecord::Encryption::NullEncryptor.new, &block
+        end
+
+        # Runs the provided block in an encryption context where:
+        #
+        # * Reading encrypted content will return its ciphertext.
+        # * Writing encrypted content will fail.
+        def protecting_encrypted_data(&block)
+          with_encryption_context encryptor: ActiveRecord::Encryption::EncryptingOnlyEncryptor.new, frozen_encryption: true, &block
+        end
+
+        # Returns the current context. By default it will return the current context.
+        def context
+          self.current_custom_context || self.default_context
+        end
+
+        def current_custom_context
+          self.custom_contexts&.last
+        end
+      end
+    end
+  end
+end

data/lib/active_record/encryption/derived_secret_key_provider.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A +KeyProvider+ that derives keys from passwords.
+    class DerivedSecretKeyProvider < KeyProvider
+      def initialize(passwords)
+        super(Array(passwords).collect { |password| Key.derive_from(password) })
+      end
+    end
+  end
+end

data/lib/active_record/encryption/deterministic_key_provider.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # A +KeyProvider+ that derives keys from passwords.
+    class DeterministicKeyProvider < DerivedSecretKeyProvider
+      def initialize(password)
+        passwords = Array(password)
+        raise ActiveRecord::Encryption::Errors::Configuration, "Deterministic encryption keys can't be rotated" if passwords.length > 1
+        super(passwords)
+      end
+    end
+  end
+end

data/lib/active_record/encryption/encryptable_record.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Encryption
+    # This is the concern mixed in Active Record models to make them encryptable. It adds the +encrypts+
+    # attribute declaration, as well as the API to encrypt and decrypt records.
+    module EncryptableRecord
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :encrypted_attributes
+
+        validate :cant_modify_encrypted_attributes_when_frozen, if: -> { has_encrypted_attributes? && ActiveRecord::Encryption.context.frozen_encryption? }
+      end
+
+      class_methods do
+        # Encrypts the +name+ attribute.
+        #
+        # === Options
+        #
+        # * <tt>:key_provider</tt> - Configure a +KeyProvider+ for serving the keys to encrypt and
+        #   decrypt this attribute. If not provided, it will default to +ActiveRecord::Encryption.key_provider+.
+        # * <tt>:key</tt> - A password to derive the key from. It's a shorthand for a +:key_provider+ that
+        #   serves derivated keys. Both options can't be used at the same time.
+        # * <tt>:key_provider</tt> - Set a +:key_provider+ to provide encryption and decryption keys. If not
+        #   provided, it will default to the key provider set with `config.key_provider`.
+        # * <tt>:deterministic</tt> - By default, encryption is not deterministic. It will use a random
+        #   initialization vector for each encryption operation. This means that encrypting the same content
+        #   with the same key twice will generate different ciphertexts. When set to +true+, it will generate the
+        #   initialization vector based on the encrypted content. This means that the same content will generate
+        #   the same ciphertexts. This enables querying encrypted text with Active Record. Deterministic encryption
+        #   will use the oldest encryption scheme to encrypt new data by default. You can change this by setting
+        #   +deterministic: { fixed: false }+. That will make it use the newest encryption scheme for encrypting new
+        #   data.
+        # * <tt>:downcase</tt> - When true, it converts the encrypted content to downcase automatically. This allows to
+        #   effectively ignore case when querying data. Notice that the case is lost. Use +:ignore_case+ if you are interested
+        #   in preserving it.
+        # * <tt>:ignore_case</tt> - When true, it behaves like +:downcase+ but, it also preserves the original case in a specially
+        #   designated column +original_<name>+. When reading the encrypted content, the version with the original case is
+        #   served. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
+        #   is true.
+        # * <tt>:context_properties</tt> - Additional properties that will override +Context+ settings when this attribute is
+        #   encrypted and decrypted. E.g: +encryptor:+, +cipher:+, +message_serializer:+, etc.
+        # * <tt>:previous</tt> - List of previous encryption schemes. When provided, they will be used in order when trying to read
+        #   the attribute. Each entry of the list can contain the properties supported by #encrypts. Also, when deterministic
+        #   encryption is used, they will be used to generate additional ciphertexts to check in the queries.
+        def encrypts(*names, key_provider: nil, key: nil, deterministic: false, downcase: false, ignore_case: false, previous: [], **context_properties)
+          self.encrypted_attributes ||= Set.new # not using :default because the instance would be shared across classes
+          scheme = scheme_for key_provider: key_provider, key: key, deterministic: deterministic, downcase: downcase, \
+              ignore_case: ignore_case, previous: previous, **context_properties
+
+          names.each do |name|
+            encrypt_attribute name, scheme
+          end
+        end
+
+        # Returns the list of deterministic encryptable attributes in the model class.
+        def deterministic_encrypted_attributes
+          @deterministic_encrypted_attributes ||= encrypted_attributes&.find_all do |attribute_name|
+            type_for_attribute(attribute_name).deterministic?
+          end
+        end
+
+        # Given a attribute name, it returns the name of the source attribute when it's a preserved one.
+        def source_attribute_from_preserved_attribute(attribute_name)
+          attribute_name.to_s.sub(ORIGINAL_ATTRIBUTE_PREFIX, "") if /^#{ORIGINAL_ATTRIBUTE_PREFIX}/.match?(attribute_name)
+        end
+
+        private
+          def scheme_for(key_provider: nil, key: nil, deterministic: false, downcase: false, ignore_case: false, previous: [], **context_properties)
+            ActiveRecord::Encryption::Scheme.new(key_provider: key_provider, key: key, deterministic: deterministic,
+                                                 downcase: downcase, ignore_case: ignore_case, **context_properties).tap do |scheme|
+              scheme.previous_schemes = global_previous_schemes_for(scheme) +
+                Array.wrap(previous).collect { |scheme_config| ActiveRecord::Encryption::Scheme.new(**scheme_config) }
+            end
+          end
+
+          def global_previous_schemes_for(scheme)
+            ActiveRecord::Encryption.config.previous_schemes.collect do |previous_scheme|
+              scheme.merge(previous_scheme)
+            end
+          end
+
+          def encrypt_attribute(name, attribute_scheme)
+            encrypted_attributes << name.to_sym
+
+            attribute name do |cast_type|
+              ActiveRecord::Encryption::EncryptedAttributeType.new scheme: attribute_scheme, cast_type: cast_type
+            end
+
+            preserve_original_encrypted(name) if attribute_scheme.ignore_case?
+            ActiveRecord::Encryption.encrypted_attribute_was_declared(self, name)
+          end
+
+          def preserve_original_encrypted(name)
+            original_attribute_name = "#{ORIGINAL_ATTRIBUTE_PREFIX}#{name}".to_sym
+
+            if !ActiveRecord::Encryption.config.support_unencrypted_data && !column_names.include?(original_attribute_name.to_s)
+              raise Errors::Configuration, "To use :ignore_case for '#{name}' you must create an additional column named '#{original_attribute_name}'"
+            end
+
+            encrypts original_attribute_name
+            override_accessors_to_preserve_original name, original_attribute_name
+          end
+
+          def override_accessors_to_preserve_original(name, original_attribute_name)
+            include(Module.new do
+              define_method name do
+                if ((value = super()) && encrypted_attribute?(name)) || !ActiveRecord::Encryption.config.support_unencrypted_data
+                  send(original_attribute_name)
+                else
+                  value
+                end
+              end
+
+              define_method "#{name}=" do |value|
+                self.send "#{original_attribute_name}=", value
+                super(value)
+              end
+            end)
+          end
+
+          def load_schema!
+            super
+
+            add_length_validation_for_encrypted_columns if ActiveRecord::Encryption.config.validate_column_size
+          end
+
+          def add_length_validation_for_encrypted_columns
+            encrypted_attributes&.each do |attribute_name|
+              validate_column_size attribute_name
+            end
+          end
+
+          def validate_column_size(attribute_name)
+            if limit = columns_hash[attribute_name.to_s]&.limit
+              validates_length_of attribute_name, maximum: limit
+            end
+          end
+      end
+
+      # Returns whether a given attribute is encrypted or not.
+      def encrypted_attribute?(attribute_name)
+        ActiveRecord::Encryption.encryptor.encrypted? ciphertext_for(attribute_name)
+      end
+
+      # Returns the ciphertext for +attribute_name+.
+      def ciphertext_for(attribute_name)
+        read_attribute_before_type_cast(attribute_name)
+      end
+
+      # Encrypts all the encryptable attributes and saves the changes.
+      def encrypt
+        encrypt_attributes if has_encrypted_attributes?
+      end
+
+      # Decrypts all the encryptable attributes and saves the changes.
+      def decrypt
+        decrypt_attributes if has_encrypted_attributes?
+      end
+
+      private
+        ORIGINAL_ATTRIBUTE_PREFIX = "original_"
+
+        def encrypt_attributes
+          validate_encryption_allowed
+
+          update_columns build_encrypt_attribute_assignments
+        end
+
+        def decrypt_attributes
+          validate_encryption_allowed
+
+          decrypt_attribute_assignments = build_decrypt_attribute_assignments
+          ActiveRecord::Encryption.without_encryption { update_columns decrypt_attribute_assignments }
+        end
+
+        def validate_encryption_allowed
+          raise ActiveRecord::Encryption::Errors::Configuration, "can't be modified because it is encrypted" if ActiveRecord::Encryption.context.frozen_encryption?
+        end
+
+        def has_encrypted_attributes?
+          self.class.encrypted_attributes.present?
+        end
+
+        def build_encrypt_attribute_assignments
+          Array(self.class.encrypted_attributes).index_with do |attribute_name|
+            self[attribute_name]
+          end
+        end
+
+        def build_decrypt_attribute_assignments
+          Array(self.class.encrypted_attributes).collect do |attribute_name|
+            type = type_for_attribute(attribute_name)
+            encrypted_value = ciphertext_for(attribute_name)
+            new_value = type.deserialize(encrypted_value)
+            [attribute_name, new_value]
+          end.to_h
+        end
+
+        def cant_modify_encrypted_attributes_when_frozen
+          self.class&.encrypted_attributes.each do |attribute|
+            errors.add(attribute.to_sym, "can't be modified because it is encrypted") if changed_attributes.include?(attribute)
+          end
+        end
+    end
+  end
+end