sidekiq-encrypted_args 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f84a1b91b3bfb0404cf7bbbd4465adcb5501bc7ebed09a963bc113db8ceee0ef
-  data.tar.gz: 87d0e283dd3041834d1cca5b42a575944c8addfaa55c181351b8dee31daa379a
+  metadata.gz: 8ca6bc1fc5d72297d12bd0f232a87d4ecaa25979c92eba55ea127822fad621c2
+  data.tar.gz: 869bb08e744fa7366e3115a9c1ad7fc8d2d3887a88bee0af7465b0d6b62f5490
 SHA512:
-  metadata.gz: 29315f3d29b7b3baaa40093e31418e5ec7b7acdf128f65c0a9be0c3a7dd0dc6fe9fd5d8f84f68dcfa4d4e4054b68e12b78adcb778d901ef63f8673c13dc5671f
-  data.tar.gz: 1c82169eaa577a5bf375749708381a5f1ac45a1def13e18233f479f491c2927da7e80a8360661b7809fbd418949ad988ba23cb0f580b54f964e7ce02026e0f74
+  metadata.gz: 4fc68145cdcfdc34ee2a07cbfd18357a73de96ac5b14a03a4ff09de3376bbba0e501bff181cbda9c964fa79c8e492637e9c7b40c3c4a5cbb82d348bc72be2654
+  data.tar.gz: 75418905177a4bea81d7995967d24dbcdb500b4ca6dcf6d528110676569e87dd857b33c04b3fd4aa821cc3200d956b9cd8de037730f08efeebca1cdc60e18378

data/CHANGE_LOG.md

@@ -1,4 +1,14 @@
-# Change log
+# Change Log
+
+## 1.1.0
+
+* Use `to_json` if it is defined when serializing encrypted args to JSON.
+* Add client middleware to the server default configuration. This ensures that arguments will be encrypted if a worker enqueues a job with encrypted arguments.
+* Client middleware now reads sidekiq options from the job hash instead of from the worker class so that the list of encrypted arguments is always in sync on the job payload.
+* Don't blow up if class name that is not defined is passed to client middleware.
+* Added additional option to specify encrypted args with array of argument indexes.
+* Deprecated setting encrypted args as hash or array of booleans.
+* Client middleware is prepended while server middleware is appended.
 
 ## 1.0.2
 

data/README.md

@@ -1,6 +1,6 @@
 # Sidekiq Encrypted Args
 
-![Continuous Integration](https://github.com/bdurand/sidekiq-encrypted_args/workflows/Continuous%20Integration/badge.svg?branch=master)
+[![Continuous Integration](https://github.com/bdurand/sidekiq-encrypted_args/workflows/Continuous%20Integration/badge.svg?branch=master)](https://github.com/bdurand/sidekiq-encrypted_args/actions?query=workflow%3A%22Continuous+Integration%22)
 [![Maintainability](https://api.codeclimate.com/v1/badges/70ab3782e4d5285eb173/maintainability)](https://codeclimate.com/github/bdurand/sidekiq-encrypted_args/maintainability)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
@@ -14,7 +14,7 @@ This can be an even bigger issue if you use scheduled jobs since sensitive data
 
 ## Solution
 
-This gem adds Sidekiq middleware that allows you to specify job arguments for your workers that should be encrypted in Redis. You do this by adding `encrypted_args` to the `sidekiq_options` in the worker. Jobs for these workers will have their arguments encrypted in Redis and decrypted when passed to `perform` method.
+This gem adds Sidekiq middleware that allows you to specify job arguments for your workers that should be encrypted in Redis. You do this by adding `encrypted_args` to the `sidekiq_options` in the worker. Jobs for these workers will have their arguments encrypted in Redis and decrypted when passed to the `perform` method.
 
 To use the gem, you will need to specify a secret that will be used to encrypt the arguments as well as add the middleware to your Sidekiq client and server middleware stacks. You can set that up by adding this to the end of your Sidekiq initialization:
 
@@ -24,14 +24,16 @@ Sidekiq::EncryptedArgs.configure!(secret: "YourSecretKey")
 
 If the secret is not set, the value of the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable will be used as the secret. If this variable is not set, job arguments will not be encrypted.
 
-The call to `Sidekiq::EncryptedArgs.configure!` will append the encryption middleware to the end of the client and server middleware chains. You add the middlewares manually if you need more control over where they appear in the stacks.
+The call to `Sidekiq::EncryptedArgs.configure!` will **prepend** the client encryption middleware and **append** server decryption middleware. By doing this, any other middleware you register will only receive the encrypted parameters (e.g. logging middleware will receive the encrypted parameters).
+
+You can add the middleware manually if you need more control over where they appear in the stacks.
 
 ```ruby
 Sidekiq::EncryptedArgs.secret = "YourSecretKey"
 
 Sidekiq.configure_client do |config|
   config.client_middleware do |chain|
-    chain.add Sidekiq::EncryptedArgs::ClientMiddleware
+    chain.prepend Sidekiq::EncryptedArgs::ClientMiddleware
   end
 end
 
@@ -39,6 +41,12 @@ Sidekiq.configure_server do |config|
   config.server_middleware do |chain|
     chain.add Sidekiq::EncryptedArgs::ServerMiddleware
   end
+
+  # register client middleware on the server so that starting jobs in a Sidekiq::Worker also get encrypted args
+  # https://github.com/mperham/sidekiq/wiki/Middleware#client-middleware-registered-in-both-places
+  config.client_middleware do |chain|
+    chain.prepend Sidekiq::EncryptedArgs::ClientMiddleware
+  end
 end
 ```
 
@@ -59,30 +67,24 @@ class SecretWorker
 end
 ```
 
-You can also encrypt just specific arguments with a hash or an array. This can be useful to preserve visibility into non-sensitive arguments that might be useful for troubleshooting or other reasons. All of these examples will encrypt just the second argument to the `perform` method.
-
-```ruby
-  # Pass in a list of argument names that should be encrypted
-  sidekiq_options encrypted_args: [:arg_2]
-
-  def perform(arg_1, arg_2, arg_3)
-  end
-```
+You can also choose to only encrypt specific arguments with an array of either argument names (symbols or strings) or indexes. This is useful to preserve visibility into non-sensitive arguments for troubleshooting or other reasons. Both of these examples encrypt just the second argument to the `perform` method.
 
 ```ruby
-  # Pass in a hash with values indicating which arguments should be encrypted
-  sidekiq_options encrypted_args: { arg_2: true, arg_1: false }
+# Pass in a list of argument names that should be encrypted
+sidekiq_options encrypted_args: [:arg_2]
+# or
+sidekiq_options encrypted_args: ["arg_2"]
 
-  def perform(arg_1, arg_2, arg_3)
-  end
+def perform(arg_1, arg_2, arg_3)
+end
 ```
 
 ```ruby
-  # Pass in an array of boolean values indicating which argument positions should be encrypted
-  sidekiq_options encrypted_args: [false, true]
+# Pass in an array of integers indicating which argument positions should be encrypted
+sidekiq_options encrypted_args: [1]
 
-  def perform(arg_1, arg_2, arg_3)
-  end
+def perform(arg_1, arg_2, arg_3)
+end
 ```
 
 You don't need to change anything else about your workers. All of the arguments passed to the `perform` method will already be unencrypted when the method is called.
@@ -92,15 +94,15 @@ You don't need to change anything else about your workers. All of the arguments
 If you need to roll your secret, you can simply provide an array when setting the secret.
 
 ```ruby
-Sidekiq::EncryptedArgs.secret = ["CurrentSecret", "OldSecret"]
+Sidekiq::EncryptedArgs.secret = ["CurrentSecret", "OldSecret", "EvenOlderSecret"]
 ```
 
-The left most key will be considered the current key and will be used for encrypting arguments. However, all of the keys will be tried when decrypting. This allows you to switch you secret keys without breaking jobs already enqueued in Redis.
+The first (left most) key will be considered the current key, and is used for encrypting arguments. When decrypting, we iterate over the secrets list until we find the correct one. This allows you to switch you secret keys without breaking jobs already enqueued in Redis.
 
-If you are using the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` envrionment variable to specify your secret, you can delimit multiple keys with a spaces.
+If you are using the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment variable to specify your secret, you can delimit multiple keys with a spaces.
 
 You can also safely add encryption to an existing worker. Any jobs that are already enqueued will still run even without having the arguments encrypted in Redis.
 
 ## Encryption
 
-Encrypted arguments are stored using AES-256-GCM with a key derived from your secret using PBKDF2.
+Encrypted arguments are stored using AES-256-GCM with a key derived from your secret using PBKDF2. For more info on the underlying encryption, refer to the [SecretKeys](https://github.com/bdurand/secret_keys) gem.

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.0

data/lib/sidekiq/encrypted_args.rb

@@ -6,36 +6,44 @@ require "sidekiq"
 
 module Sidekiq
   module EncryptedArgs
-    # Error thrown when the
+    # Error thrown when the secret is invalid
     class InvalidSecretError < StandardError
+      def initialize
+        super("Cannot decrypt. Invalid secret provided.")
+      end
     end
 
     class << self
       # Set the secret key used for encrypting arguments. If this is not set,
       # the value will be loaded from the `SIDEKIQ_ENCRYPTED_ARGS_SECRET` environment
-      # variable. If that value is not set, arguments will not be encypted.
-      #
-      # @param [String] value One or more secrets to use for encypting arguments.
+      # variable. If that value is not set, arguments will not be encrypted.
       #
-      # @note You can set multiple secrets by passing an array if you need to roll your secrets.
+      # You can set multiple secrets by passing an array if you need to roll your secrets.
       # The left most value in the array will be used as the encryption secret, but
       # all the values will be tried when decrypting. That way if you have scheduled
-      # jobs that were encypted with a different secret, you can still make it available
+      # jobs that were encrypted with a different secret, you can still make it available
       # when decrypting the arguments when the job gets run. If you are using the
-      # envrionment variable, separate the keys with spaces.
+      # environment variable, separate the keys with spaces.
+      #
+      # @param [String] value One or more secrets to use for encrypting arguments.
+      # @return [void]
       def secret=(value)
         @encryptors = make_encryptors(value)
       end
 
-      # Calling this method will add the client and server middleware to the Sidekiq
+      # Add the client and server middleware to the Sidekiq
       # middleware chains. If you need to ensure the order of where the middleware is
       # added, you can forgo this method and add it yourself.
+      #
+      # This method prepends client middleware and appends server middleware.
+      #
+      # @param [String] secret optionally set the secret here. See {.secret=}
       def configure!(secret: nil)
         self.secret = secret unless secret.nil?
 
         Sidekiq.configure_client do |config|
           config.client_middleware do |chain|
-            chain.add Sidekiq::EncryptedArgs::ClientMiddleware
+            chain.prepend Sidekiq::EncryptedArgs::ClientMiddleware
           end
         end
 
@@ -43,17 +51,20 @@ module Sidekiq
           config.server_middleware do |chain|
             chain.add Sidekiq::EncryptedArgs::ServerMiddleware
           end
+          config.client_middleware do |chain|
+            chain.prepend Sidekiq::EncryptedArgs::ClientMiddleware
+          end
         end
       end
 
       # Encrypt a value.
       #
-      # @param [Object] data Data to encrypt. You can pass any JSON compatible data types or structures.
+      # @param [#to_json, Object] data Data to encrypt. You can pass any JSON compatible data types or structures.
       #
       # @return [String]
       def encrypt(data)
         return nil if data.nil?
-        json = JSON.dump(data)
+        json = (data.respond_to?(:to_json) ? data.to_json : JSON.generate(data))
         encrypted = encrypt_string(json)
         if encrypted == json
           data
@@ -67,37 +78,55 @@ module Sidekiq
       # @param [String] encrypted_data Data that was previously encrypted. If the value passed in is
       # an unencrypted string, then the string itself will be returned.
       #
-      # @return [String]
+      # @return [Object]
       def decrypt(encrypted_data)
         return encrypted_data unless SecretKeys::Encryptor.encrypted?(encrypted_data)
         json = decrypt_string(encrypted_data)
         JSON.parse(json)
       end
 
-      protected
-
-      # Helper method to get the encrypted args option from an options hash. The value of this option
+      # Private helper method to get the encrypted args option from an options hash. The value of this option
       # can be `true` or an array indicating if each positional argument should be encrypted, or a hash
       # with keys for the argument position and true as the value.
-      def encrypted_args_option(worker_class)
-        sidekiq_options = worker_class.sidekiq_options
-        option = sidekiq_options.fetch(:encrypted_args, sidekiq_options["encrypted_args"])
-
+      #
+      # @private
+      def encrypted_args_option(worker_class, job)
+        option = job["encrypted_args"]
         return nil if option.nil?
-
-        return Hash.new(true) if option == true
-
-        return replace_argument_positions(worker_class, option) if option.is_a?(Hash)
-
-        hash = {}
-        Array(option).each_with_index do |val, position|
-          if val.is_a?(Symbol) || val.is_a?(String)
-            hash[val] = true
-          else
-            hash[position] = val
+        return [] if option == false
+
+        indexes = []
+        if option == true
+          job["args"].size.times { |i| indexes << i }
+        elsif option.is_a?(Hash)
+          deprecation_warning("hash")
+          indexes = replace_argument_positions(worker_class, option)
+        else
+          array_type = nil
+          deprecation_message = nil
+          Array(option).each_with_index do |val, position|
+            current_type = nil
+            if val.is_a?(Integer)
+              indexes << val
+              current_type = :integer
+            elsif val.is_a?(Symbol) || val.is_a?(String)
+              worker_class = constantize(worker_class) if worker_class.is_a?(String)
+              position = perform_method_parameter_index(worker_class, val)
+              indexes << position if position
+              current_type = :symbol
+            else
+              deprecation_message = "boolean array"
+              indexes << position if val
+            end
+            if array_type && current_type
+              deprecation_message = "array of mixed types"
+            else
+              array_type ||= current_type
+            end
           end
+          deprecation_warning(deprecation_message) if deprecation_message
         end
-        replace_argument_positions(worker_class, hash)
+        indexes
       end
 
       private
@@ -135,18 +164,40 @@ module Sidekiq
         Array(secrets).map { |val| val.nil? ? nil : SecretKeys::Encryptor.from_password(val, SALT) }
       end
 
-      def replace_argument_positions(worker_class, encrypt_option)
-        updated = {}
-        encrypt_option.each do |key, value|
+      def deprecation_warning(message)
+        warn("Sidekiq::EncryptedArgs: setting encrypted_args to #{message} is deprecated; support will be removed in version 1.2.")
+      end
+
+      # @param [String] class_name name of a class
+      # @return [Class] class that was referenced by name
+      def constantize(class_name)
+        names = class_name.split("::")
+        # Clear leading :: for root namespace since we're already calling from object
+        names.shift if names.empty? || names.first.empty?
+        # Map reduce to the constant. Use inherit=false to not accidentally search
+        # parent modules
+        names.inject(Object) { |constant, name| constant.const_get(name, false) }
+      end
+
+      def replace_argument_positions(worker_class, encrypt_option_hash)
+        encrypted_indexes = []
+        encrypt_option_hash.each do |key, value|
+          next unless value
           if key.is_a?(Symbol) || key.is_a?(String)
-            key = key.to_sym
-            position = worker_class.instance_method(:perform).parameters.find_index { |_, name| name == key }
-            updated[position] = value if position
+            position = perform_method_parameter_index(worker_class, key)
+            encrypted_indexes << position if position
           elsif key.is_a?(Integer)
-            updated[key] = value
+            encrypted_indexes << key
           end
         end
-        updated
+        encrypted_indexes
+      end
+
+      def perform_method_parameter_index(worker_class, parameter)
+        if worker_class
+          parameter = parameter.to_sym
+          worker_class.instance_method(:perform).parameters.find_index { |_, name| name == parameter }
+        end
       end
     end
   end

data/lib/sidekiq/encrypted_args/client_middleware.rb

@@ -5,17 +5,11 @@ module Sidekiq
     # Sidekiq client middleware for encrypting arguments on jobs for workers
     # with `encrypted_args` set in the `sidekiq_options`.
     class ClientMiddleware
-      # @param [String, Class] worker_class class name or class of worker
+      # Encrypt specified arguments before they're sent off to the queue
       def call(worker_class, job, queue, redis_pool = nil)
-        worker_class = constantize(worker_class) if worker_class.is_a?(String)
-        encrypted_args = EncryptedArgs.send(:encrypted_args_option, worker_class)
-        if encrypted_args
-          new_args = []
-          job["args"].each_with_index do |value, position|
-            value = EncryptedArgs.encrypt(value) if encrypted_args[position]
-            new_args << value
-          end
-          job["args"] = new_args
+        if job.include?("encrypted_args")
+          encrypted_args = EncryptedArgs.encrypted_args_option(worker_class, job)
+          encrypt_job_arguments!(job, encrypted_args)
         end
 
         yield
@@ -23,15 +17,25 @@ module Sidekiq
 
       private
 
-      # @param [String] class_name name of a class
-      # @return [Class] class that was referenced by name
-      def constantize(class_name)
-        names = class_name.split("::")
-        # Clear leading :: for root namespace since we're already calling from object
-        names.shift if names.empty? || names.first.empty?
-        # Map reduce to the constant. Use inherit=false to not accidentally search
-        # parent modules
-        names.inject(Object) { |constant, name| constant.const_get(name, false) }
+      # Encrypt the arguments on job
+      #
+      # Additionally, set `job["encrypted_args"]` to the canonicalized version (i.e. `Array<Integer>`)
+      #
+      # @param [Hash]
+      # @param [Array<Integer>] encrypted_args array of indexes in job to encrypt
+      # @return [void]
+      def encrypt_job_arguments!(job, encrypted_args)
+        if encrypted_args
+          job_args = job["args"]
+          job_args.each_with_index do |value, position|
+            if encrypted_args.include?(position)
+              job_args[position] = EncryptedArgs.encrypt(value)
+            end
+          end
+          job["encrypted_args"] = encrypted_args
+        else
+          job.delete("encrypted_args")
+        end
       end
     end
   end

data/lib/sidekiq/encrypted_args/server_middleware.rb

@@ -2,22 +2,33 @@
 
 module Sidekiq
   module EncryptedArgs
+    # Sidekiq server middleware for decrypting arguments on jobs that have encrypted args.
     class ServerMiddleware
-      # Sidekiq server middleware for encrypting arguments on jobs for workers
-      # with `encrypted_args` set in the `sidekiq_options`.
+      # Wrap the server process to decrypt incoming arguments
       def call(worker, job, queue)
-        encrypted_args = EncryptedArgs.send(:encrypted_args_option, worker.class)
+        encrypted_args = job["encrypted_args"]
         if encrypted_args
-          new_args = []
-          job["args"].each_with_index do |value, position|
-            value = EncryptedArgs.decrypt(value) if encrypted_args[position]
-            new_args << value
+          encrypted_args = backward_compatible_encrypted_args(encrypted_args, worker.class, job)
+          job_args = job["args"]
+          encrypted_args.each do |position|
+            value = job_args[position]
+            job_args[position] = EncryptedArgs.decrypt(value)
           end
-          job["args"] = new_args
         end
 
         yield
       end
+
+      private
+
+      # Ensure that the encrypted args is an array of integers. If not re-read it from the class
+      # definition since gem version 1.0.2 and earlier did not update the encrypted_args on the job.
+      def backward_compatible_encrypted_args(encrypted_args, worker_class, job)
+        unless encrypted_args.is_a?(Array) && encrypted_args.all? { |position| position.is_a?(Integer) }
+          encrypted_args = EncryptedArgs.encrypted_args_option(worker_class, job)
+        end
+        encrypted_args
+      end
     end
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-encrypted_args
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Durand
 - Winston Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-03 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -53,7 +53,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-description: 
+description:
 email:
 - bbdurand@gmail.com
 - me@winstondurand.com
@@ -76,7 +76,7 @@ homepage: https://github.com/bdurand/sidekiq-encrypted_args
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Support for encrypting arguments that contain sensitive information in sidekiq
   jobs.