aws-sdk-s3 1.143.0 → 1.208.0

data/lib/aws-sdk-s3/plugins/endpoints.rb

@@ -15,25 +15,28 @@ module Aws::S3
         :endpoint_provider,
         doc_type: 'Aws::S3::EndpointProvider',
         rbs_type: 'untyped',
-        docstring: 'The endpoint provider used to resolve endpoints. Any '\
-                   'object that responds to `#resolve_endpoint(parameters)` '\
-                   'where `parameters` is a Struct similar to '\
-                   '`Aws::S3::EndpointParameters`'
-      ) do |cfg|
+        docstring: <<~DOCS) do |_cfg|
+The endpoint provider used to resolve endpoints. Any object that responds to
+`#resolve_endpoint(parameters)` where `parameters` is a Struct similar to
+`Aws::S3::EndpointParameters`.
+        DOCS
         Aws::S3::EndpointProvider.new
       end
 
       option(
         :disable_s3_express_session_auth,
-        doc_type: 'Boolean',
-        default: nil,
-        docstring: "Parameter to indicate whether S3Express session auth should be disabled")
+        doc_type: 'boolean',
+        docstring: <<~DOCS) do |cfg|
+Parameter to indicate whether S3Express session auth should be disabled
+        DOCS
+        nil
+      end
 
       # @api private
       class Handler < Seahorse::Client::Handler
         def call(context)
           unless context[:discovered_endpoint]
-            params = parameters_for_operation(context)
+            params = Aws::S3::Endpoints.parameters_for_operation(context)
             endpoint = context.config.endpoint_provider.resolve_endpoint(params)
 
             context.http_request.endpoint = endpoint.url
@@ -46,11 +49,23 @@ module Aws::S3
           context[:auth_scheme] =
             Aws::Endpoints.resolve_auth_scheme(context, endpoint)
 
-          @handler.call(context)
+          with_metrics(context) { @handler.call(context) }
         end
 
         private
 
+        def with_metrics(context, &block)
+          metrics = []
+          metrics << 'ENDPOINT_OVERRIDE' unless context.config.regional_endpoint
+          if context[:auth_scheme] && context[:auth_scheme]['name'] == 'sigv4a'
+            metrics << 'SIGV4A_SIGNING'
+          end
+          if context.config.credentials&.credentials&.account_id
+            metrics << 'RESOLVED_ACCOUNT_ID'
+          end
+          Aws::Plugins::UserAgent.metric(*metrics, &block)
+        end
+
         def apply_endpoint_headers(context, headers)
           headers.each do |key, values|
             value = values
@@ -61,209 +76,6 @@ module Aws::S3
             context.http_request.headers[key] = value
           end
         end
-
-        def parameters_for_operation(context)
-          case context.operation_name
-          when :abort_multipart_upload
-            Aws::S3::Endpoints::AbortMultipartUpload.build(context)
-          when :complete_multipart_upload
-            Aws::S3::Endpoints::CompleteMultipartUpload.build(context)
-          when :copy_object
-            Aws::S3::Endpoints::CopyObject.build(context)
-          when :create_bucket
-            Aws::S3::Endpoints::CreateBucket.build(context)
-          when :create_multipart_upload
-            Aws::S3::Endpoints::CreateMultipartUpload.build(context)
-          when :create_session
-            Aws::S3::Endpoints::CreateSession.build(context)
-          when :delete_bucket
-            Aws::S3::Endpoints::DeleteBucket.build(context)
-          when :delete_bucket_analytics_configuration
-            Aws::S3::Endpoints::DeleteBucketAnalyticsConfiguration.build(context)
-          when :delete_bucket_cors
-            Aws::S3::Endpoints::DeleteBucketCors.build(context)
-          when :delete_bucket_encryption
-            Aws::S3::Endpoints::DeleteBucketEncryption.build(context)
-          when :delete_bucket_intelligent_tiering_configuration
-            Aws::S3::Endpoints::DeleteBucketIntelligentTieringConfiguration.build(context)
-          when :delete_bucket_inventory_configuration
-            Aws::S3::Endpoints::DeleteBucketInventoryConfiguration.build(context)
-          when :delete_bucket_lifecycle
-            Aws::S3::Endpoints::DeleteBucketLifecycle.build(context)
-          when :delete_bucket_metrics_configuration
-            Aws::S3::Endpoints::DeleteBucketMetricsConfiguration.build(context)
-          when :delete_bucket_ownership_controls
-            Aws::S3::Endpoints::DeleteBucketOwnershipControls.build(context)
-          when :delete_bucket_policy
-            Aws::S3::Endpoints::DeleteBucketPolicy.build(context)
-          when :delete_bucket_replication
-            Aws::S3::Endpoints::DeleteBucketReplication.build(context)
-          when :delete_bucket_tagging
-            Aws::S3::Endpoints::DeleteBucketTagging.build(context)
-          when :delete_bucket_website
-            Aws::S3::Endpoints::DeleteBucketWebsite.build(context)
-          when :delete_object
-            Aws::S3::Endpoints::DeleteObject.build(context)
-          when :delete_object_tagging
-            Aws::S3::Endpoints::DeleteObjectTagging.build(context)
-          when :delete_objects
-            Aws::S3::Endpoints::DeleteObjects.build(context)
-          when :delete_public_access_block
-            Aws::S3::Endpoints::DeletePublicAccessBlock.build(context)
-          when :get_bucket_accelerate_configuration
-            Aws::S3::Endpoints::GetBucketAccelerateConfiguration.build(context)
-          when :get_bucket_acl
-            Aws::S3::Endpoints::GetBucketAcl.build(context)
-          when :get_bucket_analytics_configuration
-            Aws::S3::Endpoints::GetBucketAnalyticsConfiguration.build(context)
-          when :get_bucket_cors
-            Aws::S3::Endpoints::GetBucketCors.build(context)
-          when :get_bucket_encryption
-            Aws::S3::Endpoints::GetBucketEncryption.build(context)
-          when :get_bucket_intelligent_tiering_configuration
-            Aws::S3::Endpoints::GetBucketIntelligentTieringConfiguration.build(context)
-          when :get_bucket_inventory_configuration
-            Aws::S3::Endpoints::GetBucketInventoryConfiguration.build(context)
-          when :get_bucket_lifecycle
-            Aws::S3::Endpoints::GetBucketLifecycle.build(context)
-          when :get_bucket_lifecycle_configuration
-            Aws::S3::Endpoints::GetBucketLifecycleConfiguration.build(context)
-          when :get_bucket_location
-            Aws::S3::Endpoints::GetBucketLocation.build(context)
-          when :get_bucket_logging
-            Aws::S3::Endpoints::GetBucketLogging.build(context)
-          when :get_bucket_metrics_configuration
-            Aws::S3::Endpoints::GetBucketMetricsConfiguration.build(context)
-          when :get_bucket_notification
-            Aws::S3::Endpoints::GetBucketNotification.build(context)
-          when :get_bucket_notification_configuration
-            Aws::S3::Endpoints::GetBucketNotificationConfiguration.build(context)
-          when :get_bucket_ownership_controls
-            Aws::S3::Endpoints::GetBucketOwnershipControls.build(context)
-          when :get_bucket_policy
-            Aws::S3::Endpoints::GetBucketPolicy.build(context)
-          when :get_bucket_policy_status
-            Aws::S3::Endpoints::GetBucketPolicyStatus.build(context)
-          when :get_bucket_replication
-            Aws::S3::Endpoints::GetBucketReplication.build(context)
-          when :get_bucket_request_payment
-            Aws::S3::Endpoints::GetBucketRequestPayment.build(context)
-          when :get_bucket_tagging
-            Aws::S3::Endpoints::GetBucketTagging.build(context)
-          when :get_bucket_versioning
-            Aws::S3::Endpoints::GetBucketVersioning.build(context)
-          when :get_bucket_website
-            Aws::S3::Endpoints::GetBucketWebsite.build(context)
-          when :get_object
-            Aws::S3::Endpoints::GetObject.build(context)
-          when :get_object_acl
-            Aws::S3::Endpoints::GetObjectAcl.build(context)
-          when :get_object_attributes
-            Aws::S3::Endpoints::GetObjectAttributes.build(context)
-          when :get_object_legal_hold
-            Aws::S3::Endpoints::GetObjectLegalHold.build(context)
-          when :get_object_lock_configuration
-            Aws::S3::Endpoints::GetObjectLockConfiguration.build(context)
-          when :get_object_retention
-            Aws::S3::Endpoints::GetObjectRetention.build(context)
-          when :get_object_tagging
-            Aws::S3::Endpoints::GetObjectTagging.build(context)
-          when :get_object_torrent
-            Aws::S3::Endpoints::GetObjectTorrent.build(context)
-          when :get_public_access_block
-            Aws::S3::Endpoints::GetPublicAccessBlock.build(context)
-          when :head_bucket
-            Aws::S3::Endpoints::HeadBucket.build(context)
-          when :head_object
-            Aws::S3::Endpoints::HeadObject.build(context)
-          when :list_bucket_analytics_configurations
-            Aws::S3::Endpoints::ListBucketAnalyticsConfigurations.build(context)
-          when :list_bucket_intelligent_tiering_configurations
-            Aws::S3::Endpoints::ListBucketIntelligentTieringConfigurations.build(context)
-          when :list_bucket_inventory_configurations
-            Aws::S3::Endpoints::ListBucketInventoryConfigurations.build(context)
-          when :list_bucket_metrics_configurations
-            Aws::S3::Endpoints::ListBucketMetricsConfigurations.build(context)
-          when :list_buckets
-            Aws::S3::Endpoints::ListBuckets.build(context)
-          when :list_directory_buckets
-            Aws::S3::Endpoints::ListDirectoryBuckets.build(context)
-          when :list_multipart_uploads
-            Aws::S3::Endpoints::ListMultipartUploads.build(context)
-          when :list_object_versions
-            Aws::S3::Endpoints::ListObjectVersions.build(context)
-          when :list_objects
-            Aws::S3::Endpoints::ListObjects.build(context)
-          when :list_objects_v2
-            Aws::S3::Endpoints::ListObjectsV2.build(context)
-          when :list_parts
-            Aws::S3::Endpoints::ListParts.build(context)
-          when :put_bucket_accelerate_configuration
-            Aws::S3::Endpoints::PutBucketAccelerateConfiguration.build(context)
-          when :put_bucket_acl
-            Aws::S3::Endpoints::PutBucketAcl.build(context)
-          when :put_bucket_analytics_configuration
-            Aws::S3::Endpoints::PutBucketAnalyticsConfiguration.build(context)
-          when :put_bucket_cors
-            Aws::S3::Endpoints::PutBucketCors.build(context)
-          when :put_bucket_encryption
-            Aws::S3::Endpoints::PutBucketEncryption.build(context)
-          when :put_bucket_intelligent_tiering_configuration
-            Aws::S3::Endpoints::PutBucketIntelligentTieringConfiguration.build(context)
-          when :put_bucket_inventory_configuration
-            Aws::S3::Endpoints::PutBucketInventoryConfiguration.build(context)
-          when :put_bucket_lifecycle
-            Aws::S3::Endpoints::PutBucketLifecycle.build(context)
-          when :put_bucket_lifecycle_configuration
-            Aws::S3::Endpoints::PutBucketLifecycleConfiguration.build(context)
-          when :put_bucket_logging
-            Aws::S3::Endpoints::PutBucketLogging.build(context)
-          when :put_bucket_metrics_configuration
-            Aws::S3::Endpoints::PutBucketMetricsConfiguration.build(context)
-          when :put_bucket_notification
-            Aws::S3::Endpoints::PutBucketNotification.build(context)
-          when :put_bucket_notification_configuration
-            Aws::S3::Endpoints::PutBucketNotificationConfiguration.build(context)
-          when :put_bucket_ownership_controls
-            Aws::S3::Endpoints::PutBucketOwnershipControls.build(context)
-          when :put_bucket_policy
-            Aws::S3::Endpoints::PutBucketPolicy.build(context)
-          when :put_bucket_replication
-            Aws::S3::Endpoints::PutBucketReplication.build(context)
-          when :put_bucket_request_payment
-            Aws::S3::Endpoints::PutBucketRequestPayment.build(context)
-          when :put_bucket_tagging
-            Aws::S3::Endpoints::PutBucketTagging.build(context)
-          when :put_bucket_versioning
-            Aws::S3::Endpoints::PutBucketVersioning.build(context)
-          when :put_bucket_website
-            Aws::S3::Endpoints::PutBucketWebsite.build(context)
-          when :put_object
-            Aws::S3::Endpoints::PutObject.build(context)
-          when :put_object_acl
-            Aws::S3::Endpoints::PutObjectAcl.build(context)
-          when :put_object_legal_hold
-            Aws::S3::Endpoints::PutObjectLegalHold.build(context)
-          when :put_object_lock_configuration
-            Aws::S3::Endpoints::PutObjectLockConfiguration.build(context)
-          when :put_object_retention
-            Aws::S3::Endpoints::PutObjectRetention.build(context)
-          when :put_object_tagging
-            Aws::S3::Endpoints::PutObjectTagging.build(context)
-          when :put_public_access_block
-            Aws::S3::Endpoints::PutPublicAccessBlock.build(context)
-          when :restore_object
-            Aws::S3::Endpoints::RestoreObject.build(context)
-          when :select_object_content
-            Aws::S3::Endpoints::SelectObjectContent.build(context)
-          when :upload_part
-            Aws::S3::Endpoints::UploadPart.build(context)
-          when :upload_part_copy
-            Aws::S3::Endpoints::UploadPartCopy.build(context)
-          when :write_get_object_response
-            Aws::S3::Endpoints::WriteGetObjectResponse.build(context)
-          end
-        end
       end
 
       def add_handlers(handlers, _config)

data/lib/aws-sdk-s3/plugins/express_session_auth.rb

@@ -29,33 +29,30 @@ for different buckets.
         # @api private
         class Handler < Seahorse::Client::Handler
           def call(context)
-            if (props = context[:endpoint_properties])
-              # S3 Express endpoint - turn off md5 and enable crc32 default
-              if (backend = props['backend']) && backend == 'S3Express'
-                if context.operation_name == :put_object || checksum_required?(context)
-                  context[:default_request_checksum_algorithm] = 'CRC32'
-                end
-                context[:s3_express_endpoint] = true
-              end
+            context[:s3_express_endpoint] = true if s3_express_endpoint?(context)
 
-              # if s3 express auth, use new credentials and sign additional header
-              if context[:auth_scheme]['name'] == 'sigv4-s3express' &&
-                 !context.config.disable_s3_express_session_auth
-                bucket = context.params[:bucket]
-                credentials_provider = context.config.express_credentials_provider
-                credentials = credentials_provider.express_credentials_for(bucket)
-                context[:sigv4_credentials] = credentials # Sign will use this
-              end
+            # if s3 express auth, use new credentials and sign additional header
+            if context[:auth_scheme]['name'] == 'sigv4-s3express' &&
+               !context.config.disable_s3_express_session_auth
+              bucket = context.params[:bucket]
+              credentials_provider = context.config.express_credentials_provider
+              credentials = credentials_provider.express_credentials_for(bucket)
+              context[:sigv4_credentials] = credentials # Sign will use this
             end
-            @handler.call(context)
+
+            with_metric(credentials) { @handler.call(context) }
           end
 
           private
 
-          def checksum_required?(context)
-            context.operation.http_checksum_required ||
-              (context.operation.http_checksum &&
-                context.operation.http_checksum['requestChecksumRequired'])
+          def with_metric(credentials, &block)
+            return block.call unless credentials
+
+            Aws::Plugins::UserAgent.metric('S3_EXPRESS_BUCKET', &block)
+          end
+
+          def s3_express_endpoint?(context)
+            context[:endpoint_properties]['backend'] == 'S3Express'
           end
         end
 

data/lib/aws-sdk-s3/plugins/http_200_errors.rb

@@ -15,22 +15,67 @@ module Aws
 
           def call(context)
             @handler.call(context).on(200) do |response|
-              if error = check_for_error(context)
-                context.http_response.status_code = 500
-                response.data = nil
-                response.error = error
+              return response if streaming_output?(context.operation.output)
+
+              error = check_for_error(context)
+              return response unless error
+
+              context.http_response.status_code = 500
+              response.data = nil
+              response.error = error
+            end
+          end
+
+          private
+
+          # Streaming outputs are not subject to 200 errors.
+          def streaming_output?(output)
+            if (payload = output[:payload_member])
+              # checking ref and shape
+              payload['streaming'] || payload.shape['streaming'] ||
+                payload.eventstream
+            else
+              false
+            end
+          end
+
+          # Checks if the output shape is a structure shape and has members that
+          # are in the body for the case of a payload and a normal structure. A
+          # non-structure shape will not have members in the body. In the case
+          # of a string or blob, the body contents would have been checked first
+          # before this method is called in incomplete_xml_body?.
+          def members_in_body?(output)
+            shape =
+              if output[:payload_member]
+                output[:payload_member].shape
+              else
+                output.shape
               end
+
+            if structure_shape?(shape)
+              shape.members.any? { |_, k| k.location.nil? }
+            else
+              false
             end
           end
 
+          def structure_shape?(shape)
+            shape.is_a?(Seahorse::Model::Shapes::StructureShape)
+          end
+
+          # Must have a member in the body and have the start of an XML Tag.
+          # Other incomplete xml bodies will result in an XML ParsingError.
+          def incomplete_xml_body?(xml, output)
+            members_in_body?(output) && !xml.match(/<\w/)
+          end
+
           def check_for_error(context)
             xml = context.http_response.body_contents
-            if xml.match(/<Error>/)
-              error_code = xml.match(/<Code>(.+?)<\/Code>/)[1]
-              error_message = xml.match(/<Message>(.+?)<\/Message>/)[1]
+            if xml.match(/<\?xml\s[^>]*\?>\s*<Error>/)
+              error_code = xml.match(%r{<Code>(.+?)</Code>})[1]
+              error_message = xml.match(%r{<Message>(.+?)</Message>})[1]
               S3::Errors.error_class(error_code).new(context, error_message)
-            elsif !xml.match(/<\w/) # Must have the start of an XML Tag
-              # Other incomplete xml bodies will result in XML ParsingError
+            elsif incomplete_xml_body?(xml, context.operation.output)
               Seahorse::Client::NetworkingError.new(
                 S3::Errors
                   .error_class('InternalError')
@@ -40,15 +85,7 @@ module Aws
           end
         end
 
-        handler(
-          Handler,
-          step: :sign,
-          operations: [
-            :complete_multipart_upload,
-            :copy_object,
-            :upload_part_copy,
-          ]
-        )
+        handler(Handler, step: :sign)
       end
     end
   end

data/lib/aws-sdk-s3/plugins/md5s.rb

@@ -6,81 +6,20 @@ module Aws
   module S3
     module Plugins
       # @api private
-      # This plugin is effectively deprecated in favor of modeled
+      # This plugin is deprecated in favor of modeled
       # httpChecksumRequired traits.
       class Md5s < Seahorse::Client::Plugin
-        # These operations allow Content MD5 but are not required by
-        # httpChecksumRequired. This list should not grow.
-        OPTIONAL_OPERATIONS = [
-          :put_object,
-          :upload_part
-        ]
-
-        # @api private
-        class Handler < Seahorse::Client::Handler
-
-          CHUNK_SIZE = 1 * 1024 * 1024 # one MB
-
-          def call(context)
-            if !context[:checksum_algorithms] && # skip in favor of flexible checksum
-               !context[:s3_express_endpoint] # s3 express endpoints do not support md5
-              body = context.http_request.body
-              if body.respond_to?(:size) && body.size > 0
-                context.http_request.headers['Content-Md5'] ||= md5(body)
-              end
-            end
-            @handler.call(context)
-          end
-
-          private
-
-          # @param [File, Tempfile, IO#read, String] value
-          # @return [String<MD5>]
-          def md5(value)
-            if (File === value || Tempfile === value) && !value.path.nil? && File.exist?(value.path)
-              OpenSSL::Digest::MD5.file(value).base64digest
-            elsif value.respond_to?(:read)
-              md5 = OpenSSL::Digest::MD5.new
-              update_in_chunks(md5, value)
-              md5.base64digest
-            else
-              OpenSSL::Digest::MD5.digest(value).base64digest
-            end
-          end
-
-          def update_in_chunks(digest, io)
-            loop do
-              chunk = io.read(CHUNK_SIZE)
-              break unless chunk
-              digest.update(chunk)
-            end
-            io.rewind
-          end
-
-        end
-
         option(:compute_checksums,
-          default: true,
-          doc_type: 'Boolean',
-          docstring: <<-DOCS)
-When `true` a MD5 checksum will be computed and sent in the Content Md5
-header for :put_object and :upload_part. When `false`, MD5 checksums
-will not be computed for these operations. Checksums are still computed
-for operations requiring them. Checksum errors returned by Amazon S3 are
-automatically retried up to `:retry_limit` times.
-          DOCS
-
-        def add_handlers(handlers, config)
-          if config.compute_checksums
-            # priority set low to ensure md5 is computed AFTER the request is
-            # built but before it is signed
-            handlers.add(
-              Handler,
-              priority: 10, step: :build, operations: OPTIONAL_OPERATIONS
-            )
-          end
+               default: true,
+               doc_type: 'Boolean',
+               docstring: <<~DOCS)
+                 This option is deprecated. Please use `:request_checksum_calculation` instead.
+                 When `false`, `request_checksum_calculation` is overridden to `when_required`.
+               DOCS
+
+        def after_initialize(client)
+          client.config.request_checksum_calculation = 'when_required' unless client.config.compute_checksums
         end
-
       end
     end
   end

data/lib/aws-sdk-s3/plugins/s3_signer.rb

@@ -4,6 +4,11 @@ require 'aws-sigv4'
 
 module Aws
   module S3
+    # @api private
+    def self.bucket_region_cache
+      @bucket_region_cache ||= BucketRegionCache.new
+    end
+
     module Plugins
       # This plugin used to have a V4 signer but it was removed in favor of
       # generic Sign plugin that uses endpoint auth scheme.
@@ -51,7 +56,7 @@ module Aws
           private
 
           def check_for_cached_region(context, bucket)
-            cached_region = S3::BUCKET_REGIONS[bucket]
+            cached_region = Aws::S3.bucket_region_cache[bucket]
             if cached_region &&
                cached_region != context.config.region &&
                !S3Signer.custom_endpoint?(context)
@@ -97,7 +102,7 @@ module Aws
           end
 
           def update_bucket_cache(context, actual_region)
-            S3::BUCKET_REGIONS[context.params[:bucket]] = actual_region
+            Aws::S3.bucket_region_cache[context.params[:bucket]] = actual_region
           end
 
           def fips_region?(resp)

data/lib/aws-sdk-s3/plugins/streaming_retry.rb

@@ -62,18 +62,16 @@ module Aws
         class Handler < Seahorse::Client::Handler
 
           def call(context)
-            target = context.params[:response_target] || context[:response_target]
-
             # retry is only supported when range is NOT set on the initial request
-            if supported_target?(target) && !context.params[:range]
-              add_event_listeners(context, target)
+            if supported_target?(context) && !context.params[:range]
+              add_event_listeners(context)
             end
             @handler.call(context)
           end
 
           private
 
-          def add_event_listeners(context, target)
+          def add_event_listeners(context)
             context.http_response.on_headers(200..299) do
               case context.http_response.body
               when Seahorse::Client::BlockIO then
@@ -123,8 +121,8 @@ module Aws
               context.http_response.body.is_a?(RetryableManagedFile)
           end
 
-          def supported_target?(target)
-            case target
+          def supported_target?(context)
+            case context[:response_target]
             when Proc, String, Pathname then true
             else false
             end

data/lib/aws-sdk-s3/plugins/url_encoded_keys.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'uri'
-require 'cgi'
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 
 module Aws
   module S3

data/lib/aws-sdk-s3/presigner.rb

@@ -193,13 +193,14 @@ module Aws
         req, expires_in, secure, time, unsigned_headers, hoist = true
       )
         x_amz_headers = {}
-
         http_req = req.context.http_request
-
-        req.handlers.remove(Aws::S3::Plugins::S3Signer::LegacyHandler)
-        req.handlers.remove(Aws::Plugins::Sign::Handler)
         req.handlers.remove(Seahorse::Client::Plugins::ContentLength::Handler)
-
+        req.handlers.remove(Aws::Rest::ContentTypeHandler)
+        req.handlers.remove(Aws::Plugins::ChecksumAlgorithm::OptionHandler)
+        req.handlers.remove(Aws::Plugins::ChecksumAlgorithm::ChecksumHandler)
+        req.handlers.remove(Aws::Plugins::InvocationId::Handler)
+        req.handlers.remove(Aws::Plugins::Sign::Handler)
+        req.handlers.remove(Aws::S3::Plugins::S3Signer::LegacyHandler)
         req.handle(step: :send) do |context|
           # if an endpoint was not provided, force secure or insecure
           if context.config.regional_endpoint
@@ -236,6 +237,7 @@ module Aws
             credentials_provider: context[:sigv4_credentials] || context.config.credentials,
             signing_algorithm: scheme_name.to_sym,
             uri_escape_path: !!!auth_scheme['disableDoubleEncoding'],
+            normalize_path: !!!auth_scheme['disableNormalizePath'],
             unsigned_headers: unsigned_headers,
             apply_checksum_header: false
           )