shrine 3.4.0 → 3.10.0

data/lib/shrine/plugins/delete_raw.rb

@@ -15,8 +15,8 @@ class Shrine
         private
 
         # Deletes the file that was uploaded, unless it's an UploadedFile.
-        def _upload(io, delete: delete_raw?, **options)
-          super(io, delete: delete, **options)
+        def _upload(io, delete: delete_raw?, **)
+          super(io, delete:, **)
         end
 
         def delete_raw?

data/lib/shrine/plugins/derivation_endpoint.rb

@@ -28,8 +28,8 @@ class Shrine
         uploader.opts[:derivation_endpoint] ||= { options: {}, derivations: {} }
         uploader.opts[:derivation_endpoint][:options].merge!(opts)
 
-        unless uploader.opts[:derivation_endpoint][:options][:secret_key]
-          fail Error, "must provide :secret_key option to derivation_endpoint plugin"
+        if !uploader.opts[:derivation_endpoint][:options][:secret_key] && !uploader.opts[:derivation_endpoint][:options][:signer]
+          fail Error, "must provide :secret_key option to derivation_endpoint plugin when no custom signer is set"
         end
 
         # instrumentation plugin integration
@@ -48,7 +48,7 @@ class Shrine
         # It uses a trick where it removes the derivation path prefix from the
         # path info before calling the Rack app, which is what web framework
         # routers do before they're calling a mounted Rack app.
-        def derivation_response(env, **options)
+        def derivation_response(env, **)
           script_name = env["SCRIPT_NAME"]
           path_info   = env["PATH_INFO"]
 
@@ -61,7 +61,7 @@ class Shrine
             env["SCRIPT_NAME"] += match.to_s
             env["PATH_INFO"]    = match.post_match
 
-            derivation_endpoint(**options).call(env)
+            derivation_endpoint(**).call(env)
           ensure
             env["SCRIPT_NAME"] = script_name
             env["PATH_INFO"]   = path_info
@@ -87,15 +87,15 @@ class Shrine
         # Generates a URL to a derivation with the receiver as the source file.
         # Any arguments provided will be included in the URL and passed to the
         # derivation block. Accepts additional URL options.
-        def derivation_url(name, *args, **options)
-          derivation(name, *args).url(**options)
+        def derivation_url(name, *, **)
+          derivation(name, *).url(**)
         end
 
         # Calls the specified derivation with the receiver as the source file,
         # returning a Rack response triple. The derivation endpoint ultimately
         # calls this method.
-        def derivation_response(name, *args, env:, **options)
-          derivation(name, *args, **options).response(env)
+        def derivation_response(name, *, env:, **)
+          derivation(name, *, **).response(env)
         end
 
         # Returns a Shrine::Derivation object created from the provided
@@ -129,14 +129,14 @@ class Shrine
     end
 
     # Returns an URL to the derivation.
-    def url(**options)
+    def url(**)
       Derivation::Url.new(self).call(
         host:       option(:host),
         prefix:     option(:prefix),
         expires_in: option(:expires_in),
         version:    option(:version),
         metadata:   option(:metadata),
-        **options,
+        **,
       )
     end
 
@@ -158,8 +158,8 @@ class Shrine
 
     # Uploads the derivation result to a dedicated destination on the specified
     # Shrine storage.
-    def upload(file = nil, **options)
-      Derivation::Upload.new(self).call(file, **options)
+    def upload(file = nil, **)
+      Derivation::Upload.new(self).call(file, **)
     end
 
     # Returns a Shrine::UploadedFile object pointing to the uploaded derivative
@@ -184,7 +184,7 @@ class Shrine
     end
 
     def self.option(name, default: nil, result: nil)
-      options[name] = { default: default, result: result }
+      options[name] = { default:, result: }
     end
 
     option :cache_control,               default: -> { default_cache_control }
@@ -197,6 +197,7 @@ class Shrine
     option :metadata,                    default: -> { [] }
     option :prefix
     option :secret_key
+    option :signer
     option :type
     option :upload,                      default: -> { false }
     option :upload_location,             default: -> { default_upload_location }, result: -> (o) { upload_location(o) }
@@ -216,7 +217,7 @@ class Shrine
       option_definition = self.class.options.fetch(name)
 
       value = options.fetch(name) { shrine_class.derivation_options[name] }
-      value = instance_exec(&value) if value.is_a?(Proc)
+      value = instance_exec(&value) if value.is_a?(Proc) && value.arity == 0
 
       if value.nil?
         default = option_definition[:default]
@@ -300,20 +301,37 @@ class Shrine
   end
 
   class Derivation::Url < Derivation::Command
-    delegate :name, :args, :source, :secret_key
+    delegate :name, :args, :source, :secret_key, :signer
 
-    def call(host: nil, prefix: nil, **options)
-      [host, *prefix, identifier(**options)].join("/")
+    def call(host: nil, prefix: nil, metadata: [], format: nil, **)
+      base_url = [host, *prefix].join("/")
+      path = path_identifier(metadata:, format:)
+
+      if signer
+        url = [base_url, path].join("/")
+        signer.call(url, **)
+      else
+        signed_part = signed_url("#{path}?#{query(**)}")
+        [base_url, signed_part].join("/")
+      end
     end
 
     private
 
-    def identifier(expires_in: nil,
-                   version: nil,
-                   type: nil,
-                   filename: nil,
-                   disposition: nil,
-                   metadata: [])
+    def path_identifier(metadata: [], format: nil)
+      path = [
+        name,
+        *args,
+        source.urlsafe_dump(metadata:)
+      ].map{|component| Rack::Utils.escape_path(component.to_s)}.join('/')
+      format ? "#{path}.#{format}" : path
+    end
+
+    def query(expires_in: nil,
+              type: nil,
+              filename: nil,
+              disposition: nil,
+              version: nil)
 
       params = {}
       params[:expires_at]  = (Time.now + expires_in).to_i if expires_in
@@ -322,23 +340,7 @@ class Shrine
       params[:filename]    = filename if filename
       params[:disposition] = disposition if disposition
 
-      # serializes the source uploaded file into an URL-safe format
-      source_component = source.urlsafe_dump(metadata: metadata)
-
-      # generate plain URL
-      url = plain_url(name, *args, source_component, params)
-
-      # generate signed URL
-      signed_url(url)
-    end
-
-    def plain_url(*components, params)
-      # When using Rack < 2, Rack::Utils#escape_path will escape '/'.
-      # Escape each component and then join them together.
-      path  = components.map{|component| Rack::Utils.escape_path(component.to_s)}.join('/')
-      query = Rack::Utils.build_query(params)
-
-      "#{path}?#{query}"
+      Rack::Utils.build_query(params)
     end
 
     def signed_url(url)
@@ -364,7 +366,9 @@ class Shrine
         handle_request(request)
       end
 
-      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      headers = Rack::Headers[headers] if Rack.release >= "3"
+      headers["Content-Length"] ||= body.respond_to?(:bytesize) ? body.bytesize.to_s :
+                                                                  body.map(&:bytesize).inject(0, :+).to_s
 
       [status, headers, body]
     end
@@ -379,10 +383,11 @@ class Shrine
     # Returns "404 Not Found" if derivation block is not defined, or if source
     # file was not found on the storage.
     def handle_request(request)
-      verify_signature!(request)
+      verify_signature!(request) if secret_key
       check_expiry!(request)
 
       name, *args, serialized_file = request.path_info.split("/")[1..-1]
+      serialized_file = serialized_file.sub(/\.\w+$/, "")
 
       name          = name.to_sym
       uploaded_file = shrine_class::UploadedFile.urlsafe_load(serialized_file)
@@ -480,19 +485,18 @@ class Shrine
     # `Content-Type` and `Content-Disposition` response headers from derivation
     # options and file extension of the derivation result.
     def file_response(file, env)
-      response = rack_file_response(file.path, env)
-
-      status = response[0]
+      status, headers, body = rack_file_response(file.path, env)
 
+      headers = Rack::Headers[headers] if Rack.release >= "3"
       headers = {
-        "Content-Type"        => type || response[1]["Content-Type"],
-        "Content-Length"      => response[1]["Content-Length"],
+        "Content-Type"        => type || headers["Content-Type"],
+        "Content-Length"      => headers["Content-Length"],
         "Content-Disposition" => content_disposition(file),
-        "Content-Range"       => response[1]["Content-Range"],
+        "Content-Range"       => headers["Content-Range"],
         "Accept-Ranges"       => "bytes",
       }.compact
 
-      body = Rack::BodyProxy.new(response[2]) { File.delete(file.path) }
+      body = Rack::BodyProxy.new(body) { File.delete(file.path) }
 
       file.close
 
@@ -513,8 +517,10 @@ class Shrine
 
       if upload_redirect
         redirect_url = uploaded_file.url(**upload_redirect_url_options)
+        headers = { "Location" => redirect_url }
+        headers = Rack::Headers[headers] if Rack.release >= "3"
 
-        [302, { "Location" => redirect_url }, []]
+        [302, headers, []]
       else
         if derivative && File.exist?(derivative.path)
           file_response(derivative, env)
@@ -554,7 +560,7 @@ class Shrine
       filename  = self.filename
       filename += File.extname(file.path) if File.extname(filename).empty?
 
-      ContentDisposition.format(disposition: disposition, filename: filename)
+      ContentDisposition.format(disposition:, filename:)
     end
   end
 
@@ -593,9 +599,9 @@ class Shrine
     end
 
     # Calls the derivation block.
-    def derive(*args)
+    def derive(*)
       instrument_derivation do
-        derivation.instance_exec(*args, &derivation_block)
+        derivation.instance_exec(*, &derivation_block)
       end
     end
 
@@ -603,7 +609,7 @@ class Shrine
     def instrument_derivation(&block)
       return yield unless shrine_class.respond_to?(:instrument)
 
-      shrine_class.instrument(:derivation, { derivation: derivation }, &block)
+      shrine_class.instrument(:derivation, { derivation: }, &block)
     end
 
     # Massages the derivation result, ensuring it's opened in binary mode,
@@ -642,22 +648,22 @@ class Shrine
     # Uploads the derivation result to the dedicated location on the storage.
     # If a file object is given, uploads that to the storage, otherwise calls
     # the derivation block and uploads the result.
-    def call(derivative = nil, **options)
+    def call(derivative = nil, **)
       if derivative
-        upload(derivative, **options)
+        upload(derivative, **)
       else
-        upload(derivation.generate, delete: true, **options)
+        upload(derivation.generate, delete: true, **)
       end
     end
 
     private
 
-    def upload(io, **options)
+    def upload(io, **)
       shrine_class.upload io, upload_storage,
         location:       upload_location,
         upload_options: upload_options,
         action:         :derivation,
-        **options
+        **
     end
   end
 

data/lib/shrine/plugins/derivatives.rb

@@ -12,18 +12,18 @@ class Shrine
         }.inspect}"
       end
 
-      def self.load_dependencies(uploader, versions_compatibility: false, **)
+      def self.load_dependencies(uploader, **)
         uploader.plugin :default_url
-
-        AttacherMethods.prepend(VersionsCompatibility) if versions_compatibility
       end
 
-      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
-        uploader.opts[:derivatives] ||= { processors: {}, processor_settings: {}, storage: proc { store_key } }
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, versions_compatibility: false, **opts)
+        uploader.opts[:derivatives] ||= { processors: {}, processor_settings: {}, storage: proc { store_key }, mutex: true }
         uploader.opts[:derivatives].merge!(opts)
 
         # instrumentation plugin integration
         uploader.subscribe(:derivatives, &log_subscriber) if uploader.respond_to?(:subscribe)
+
+        uploader::Attacher.include(VersionsCompatibility) if versions_compatibility
       end
 
       module AttachmentMethods
@@ -109,7 +109,7 @@ class Shrine
           super(**options)
 
           @derivatives       = derivatives
-          @derivatives_mutex = Mutex.new
+          @derivatives_mutex = Mutex.new if shrine_class.derivatives_options[:mutex]
         end
 
         # Convenience method for accessing derivatives.
@@ -139,7 +139,7 @@ class Shrine
         # Allows generating a URL to the derivative by passing the derivative
         # name.
         #
-        #     attacher.add_derivatives(thumb: thumb)
+        #     attacher.add_derivatives({ thumb: thumb })
         #     attacher.url(:thumb) #=> "https://example.org/thumb.jpg"
         def url(*path, **options)
           return super if path.empty?
@@ -161,7 +161,7 @@ class Shrine
         #     attacher.stored?(attacher.derivatives[:thumb]) #=> true
         def promote(**options)
           super
-          promote_derivatives
+          promote_derivatives(**options)
           create_derivatives if create_derivatives_on_promote?
         end
 
@@ -180,7 +180,7 @@ class Shrine
 
         # In addition to deleting the main file it also deletes any derivatives.
         #
-        #     attacher.add_derivatives(thumb: thumb)
+        #     attacher.add_derivatives({ thumb: thumb })
         #     attacher.derivatives[:thumb].exists? #=> true
         #     attacher.destroy
         #     attacher.derivatives[:thumb].exists? #=> false
@@ -208,7 +208,7 @@ class Shrine
         #     # {
         #     #   thumb: #<Shrine::UploadedFile>,
         #     # }
-        #     attacher.add_derivatives(cropped: cropped)
+        #     attacher.add_derivatives({ cropped: cropped })
         #     attacher.derivatives #=>
         #     # {
         #     #   thumb: #<Shrine::UploadedFile>,
@@ -239,7 +239,7 @@ class Shrine
 
         # Uploads given hash of files.
         #
-        #     hash = attacher.upload_derivatives(thumb: thumb)
+        #     hash = attacher.upload_derivatives({ thumb: thumb })
         #     hash[:thumb] #=> #<Shrine::UploadedFile>
         def upload_derivatives(files, **options)
           map_derivative(files) do |path, file|
@@ -298,10 +298,10 @@ class Shrine
         # Deep merges given uploaded derivatives with current derivatives.
         #
         #     attacher.derivatives #=> { one: #<Shrine::UploadedFile> }
-        #     attacher.merge_derivatives(two: uploaded_file)
+        #     attacher.merge_derivatives({ two: uploaded_file })
         #     attacher.derivatives #=> { one: #<Shrine::UploadedFile>, two: #<Shrine::UploadedFile> }
         def merge_derivatives(new_derivatives)
-          @derivatives_mutex.synchronize do
+          derivatives_synchronize do
             merged_derivatives = deep_merge_derivatives(derivatives, new_derivatives)
             set_derivatives(merged_derivatives)
           end
@@ -379,7 +379,7 @@ class Shrine
 
         # Deletes given hash of uploaded files.
         #
-        #     attacher.delete_derivatives(thumb: uploaded_file)
+        #     attacher.delete_derivatives({ thumb: uploaded_file })
         #     uploaded_file.exists? #=> false
         def delete_derivatives(derivatives = self.derivatives)
           map_derivative(derivatives) { |_, derivative| derivative.delete }
@@ -387,7 +387,7 @@ class Shrine
 
         # Sets the given hash of uploaded files as derivatives.
         #
-        #     attacher.set_derivatives(thumb: uploaded_file)
+        #     attacher.set_derivatives({ thumb: uploaded_file })
         #     attacher.derivatives #=> { thumb: #<Shrine::UploadedFile> }
         def set_derivatives(derivatives)
           self.derivatives = derivatives
@@ -398,7 +398,7 @@ class Shrine
         # Adds derivative data into the hash.
         #
         #     attacher.attach(io)
-        #     attacher.add_derivatives(thumb: thumb)
+        #     attacher.add_derivatives({ thumb: thumb })
         #     attacher.data
         #     #=>
         #     # {
@@ -431,12 +431,12 @@ class Shrine
         #     attacher.load_data({
         #       "id" => "...",
         #       "storage" => "store",
-        #       "metadata" => { ... },
+        #       "metadata" => {},
         #       "derivatives" => {
         #         "thumb" => {
         #           "id" => "...",
         #           "storage" => "store",
-        #           "metadata" => { ... },
+        #           "metadata" => {},
         #         }
         #       }
         #     })
@@ -459,15 +459,19 @@ class Shrine
         #     attacher.derivatives #=> { thumb: #<Shrine::UploadedFile> }
         #     attacher.change(file)
         #     attacher.derivatives #=> {}
+        #
+        #     # With keep_derivatives: true
+        #     attacher.change(file)
+        #     attacher.derivatives #=> { thumb: #<Shrine::UploadedFile> }
         def change(*)
           result = super
-          set_derivatives({})
+          set_derivatives({}) unless shrine_class.derivatives_options[:keep_derivatives]
           result
         end
 
         # Sets a hash of derivatives.
         #
-        #     attacher.derivatives = { thumb: Shrine.uploaded_file(...) }
+        #     attacher.derivatives = { thumb: Shrine.uploaded_file(data) }
         #     attacher.derivatives #=> { thumb: #<Shrine::UploadedFile ...> }
         def derivatives=(derivatives)
           unless derivatives.is_a?(Hash)
@@ -479,7 +483,9 @@ class Shrine
 
         # Iterates through nested derivatives and maps results.
         #
-        #     attacher.map_derivative(derivatives) { |path, file| ... }
+        #     attacher.map_derivative(derivatives) do |path, file|
+        #       # ...
+        #     end
         def map_derivative(derivatives, **options, &block)
           shrine_class.map_derivative(derivatives, **options, &block)
         end
@@ -544,6 +550,14 @@ class Shrine
         def create_derivatives_on_promote?
           shrine_class.derivatives_options[:create_on_promote]
         end
+
+        def derivatives_synchronize
+          if @derivatives_mutex
+            @derivatives_mutex.synchronize { yield }
+          else
+            yield
+          end
+        end
       end
 
       module ClassMethods

data/lib/shrine/plugins/download_endpoint.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'openssl'
+require 'base64'
+
 class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/download_endpoint
@@ -16,11 +19,11 @@ class Shrine
 
       module ClassMethods
         # Returns the Rack application that retrieves requested files.
-        def download_endpoint(**options)
+        def download_endpoint(**)
           Shrine::DownloadEndpoint.new(
             shrine_class: self,
             **opts[:download_endpoint],
-            **options,
+            **,
           )
         end
 
@@ -30,7 +33,7 @@ class Shrine
         # It uses a trick where it removes the download path prefix from the
         # path info before calling the Rack app, which is what web framework
         # routers do before they're calling a mounted Rack app.
-        def download_response(env, **options)
+        def download_response(env, **)
           script_name = env["SCRIPT_NAME"]
           path_info   = env["PATH_INFO"]
 
@@ -43,7 +46,7 @@ class Shrine
             env["SCRIPT_NAME"] += match.to_s
             env["PATH_INFO"]    = match.post_match
 
-            download_endpoint(**options).call(env)
+            download_endpoint(**).call(env)
           ensure
             env["SCRIPT_NAME"] = script_name
             env["PATH_INFO"]   = path_info
@@ -53,8 +56,8 @@ class Shrine
 
       module FileMethods
         # Returns file URL on the download endpoint.
-        def download_url(**options)
-          FileUrl.new(self).call(**options)
+        def download_url(**)
+          FileUrl.new(self).call(**)
         end
       end
 
@@ -65,14 +68,36 @@ class Shrine
           @file = file
         end
 
-        def call(host: self.host)
-          [host, *prefix, path].join("/")
+        def call(host: self.host, expires_in: nil)
+          path = file.urlsafe_dump(metadata: %w[filename size mime_type])
+
+          query = signature_as_query(path: path, expires_in: expires_in)
+
+          path = [host, *prefix, path].join("/")
+          path += "?#{query}" if query
+          path
         end
 
         protected
 
-        def path
-          file.urlsafe_dump(metadata: %w[filename size mime_type])
+        def signature_as_query(path:, expires_in:)
+          expires_in = default_expires_in if expires_in.nil?
+          raise(Error, "secret_key is required for expiring URLs") if !secret_key && expires_in
+          raise(Error, "expires_in is required for expiring URLs") if secret_key && !expires_in
+
+          return nil unless expires_in
+
+          expires_at = (Time.now + expires_in).to_i
+          signature = OpenSSL::HMAC.digest(
+            OpenSSL::Digest::SHA256.new,
+            secret_key,
+            "#{path}--#{expires_at}"
+          )
+
+          Rack::Utils.build_query(
+            signature: Base64.urlsafe_encode64(signature),
+            expires_at: expires_at
+          )
         end
 
         def host
@@ -83,6 +108,14 @@ class Shrine
           options[:prefix]
         end
 
+        def default_expires_in
+          options[:expires_in]
+        end
+
+        def secret_key
+          options[:secret_key]
+        end
+
         def options
           file.shrine_class.opts[:download_endpoint]
         end
@@ -113,7 +146,9 @@ class Shrine
         handle_request(request)
       end
 
-      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      headers = Rack::Headers[headers] if Rack.release >= "3"
+      headers["Content-Length"] ||= body.respond_to?(:bytesize) ? body.bytesize.to_s :
+                                                                  body.map(&:bytesize).inject(0, :+).to_s
 
       [status, headers, body]
     end
@@ -127,6 +162,9 @@ class Shrine
 
     def handle_request(request)
       _, serialized, * = request.path_info.split("/")
+      signature, expires_at = request.params.values_at("signature", "expires_at")
+
+      check_signature!(serialized, signature, expires_at) if @secret_key
 
       uploaded_file = get_uploaded_file(serialized)
 
@@ -182,12 +220,35 @@ class Shrine
       @shrine_class::UploadedFile.urlsafe_load(serialized)
     rescue Shrine::Error # storage not found
       not_found!
+    rescue JSON::ParserError, ArgumentError => error # invalid serialized component
+      raise if error.is_a?(ArgumentError) && error.message != "invalid base64"
+      bad_request!("Invalid serialized file")
+    end
+
+    def check_signature!(serialized, signature, expires_at)
+      if expires_at && expires_at.to_i < Time.now.to_i
+        error!(400, "URL has expired")
+      end
+
+      calculated_signature = OpenSSL::HMAC.digest(
+        OpenSSL::Digest::SHA256.new,
+        @secret_key,
+        "#{serialized}--#{expires_at}"
+      )
+
+      if !Rack::Utils.secure_compare(signature, Base64.urlsafe_encode64(calculated_signature))
+        error!(403, "Signature does not match")
+      end
     end
 
     def not_found!
       error!(404, "File Not Found")
     end
 
+    def bad_request!(message)
+      error!(400, message)
+    end
+
     # Halts the request with the error message.
     def error!(status, message)
       throw :halt, [status, { "Content-Type" => "text/plain" }, [message]]