aws-sdk-s3 1.136.0 → 1.176.1

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

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+      # @api private
+      class AccessGrants < Seahorse::Client::Plugin
+        @s3control =
+          begin
+            require 'aws-sdk-s3control'
+            true
+          rescue LoadError
+            false
+          end
+
+        option(
+          :access_grants,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS)
+When `true`, the S3 client will use the S3 Access Grants feature to
+authenticate requests. Bucket credentials will be fetched from S3
+Control using the `get_data_access` API.
+          DOCS
+
+        option(:access_grants_credentials_provider,
+          doc_type: 'Aws::S3::AccessGrantsCredentialsProvider',
+          rbs_type: 'untyped',
+          docstring: <<-DOCS) do |_cfg|
+When `access_grants` is `true`, this option can be used to provide
+additional options to the credentials provider, including a privilege
+setting, caching, and fallback behavior.
+          DOCS
+          Aws::S3::AccessGrantsCredentialsProvider.new
+        end
+
+        # @api private
+        class Handler < Seahorse::Client::Handler
+          PERMISSION_MAP = {
+            head_object: 'READ',
+            get_object: 'READ',
+            get_object_acl: 'READ',
+            list_multipart_uploads: 'READ',
+            list_objects_v2: 'READ',
+            list_object_versions: 'READ',
+            list_parts: 'READ',
+            head_bucket: 'READ',
+            get_object_attributes: 'READ',
+            put_object: 'WRITE',
+            put_object_acl: 'WRITE',
+            delete_object: 'WRITE',
+            abort_multipart_upload: 'WRITE',
+            create_multipart_upload: 'WRITE',
+            upload_part: 'WRITE',
+            complete_multipart_upload: 'WRITE',
+            delete_objects: 'WRITE',
+            copy_object: 'READWRITE'
+          }.freeze
+
+          def call(context)
+            provider = context.config.access_grants_credentials_provider
+
+            if access_grants_operation?(context) &&
+               !s3_express_endpoint?(context) &&
+               !credentials_head_bucket_call?(provider)
+              params = context[:endpoint_params]
+              permission = PERMISSION_MAP[context.operation_name]
+
+              key =
+                case context.operation_name
+                when :delete_objects
+                  delete_params = context.params[:delete]
+                  common_prefixes(delete_params[:objects].map { |o| o[:key] })
+                when :copy_object
+                  source_bucket, source_key = params[:copy_source].split('/', 2)
+                  if params[:bucket] != source_bucket
+                    raise ArgumentError,
+                          'source and destination bucket must be the same'
+                  end
+                  common_prefixes([params[:key], source_key])
+                else
+                  params[:key]
+                end
+
+              credentials = provider.access_grants_credentials_for(
+                bucket: params[:bucket],
+                key: key,
+                prefix: params[:prefix],
+                permission: permission
+              )
+              context[:sigv4_credentials] = credentials # Sign will use this
+            end
+
+            with_metric(credentials) { @handler.call(context) }
+          end
+
+          private
+
+          def with_metric(credentials, &block)
+            return block.call unless credentials
+
+            Aws::Plugins::UserAgent.metric('S3_ACCESS_GRANTS', &block)
+          end
+
+          # HeadBucket is a supported call. When fetching credentials,
+          # this plugin is executed again, and becomes recursive.
+          def credentials_head_bucket_call?(provider)
+            provider.instance_variable_get(:@head_bucket_call)
+          end
+
+          def access_grants_operation?(context)
+            params = context[:endpoint_params]
+            params[:bucket] && PERMISSION_MAP[context.operation_name]
+          end
+
+          def s3_express_endpoint?(context)
+            context[:endpoint_properties]['backend'] == 'S3Express'
+          end
+
+          # Return the common prefix of the keys, regardless of the delimiter.
+          # For example, given keys ['foo/bar', 'foo/baz'], the common prefix
+          # is 'foo/ba'.
+          def common_prefixes(keys)
+            return '' if keys.empty?
+
+            first_key = keys[0]
+            common_ancestor = first_key
+            last_prefix = ''
+            keys.each do |k|
+              until common_ancestor.empty?
+                break if k.start_with?(common_ancestor)
+
+                last_index = common_ancestor.rindex('/')
+                return '' if last_index.nil?
+
+                last_prefix = common_ancestor[(last_index + 1)..-1]
+                common_ancestor = common_ancestor[0...last_index]
+              end
+            end
+            new_common_ancestor = "#{common_ancestor}/#{last_prefix}"
+            keys.each do |k|
+              until last_prefix.empty?
+                break if k.start_with?(new_common_ancestor)
+
+                last_prefix = last_prefix[0...-1]
+                new_common_ancestor = "#{common_ancestor}/#{last_prefix}"
+              end
+            end
+            if new_common_ancestor == "#{first_key}/"
+              first_key
+            else
+              new_common_ancestor
+            end
+          end
+        end
+
+        def add_handlers(handlers, config)
+          return unless AccessGrants.s3control? && config.access_grants
+
+          handlers.add(Handler)
+        end
+
+        def after_initialize(client)
+          return unless AccessGrants.s3control? && client.config.access_grants
+
+          provider = client.config.access_grants_credentials_provider
+          provider.s3_client = client unless provider.s3_client
+        end
+
+        class << self
+          def s3control?
+            @s3control
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,35 +14,58 @@ module Aws::S3
       option(
         :endpoint_provider,
         doc_type: 'Aws::S3::EndpointProvider',
-        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|
+        rbs_type: 'untyped',
+        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',
+        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)
-          # If endpoint was discovered, do not resolve or apply the endpoint.
           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
             apply_endpoint_headers(context, endpoint.headers)
+
+            context[:endpoint_params] = params
+            context[:endpoint_properties] = endpoint.properties
           end
 
-          context[:endpoint_params] = params
           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
@@ -53,205 +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 :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_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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Aws
+  module S3
+    module Plugins
+      # @api private
+      class ExpressSessionAuth < Seahorse::Client::Plugin
+        # This should be s3_disable_express_auth instead
+        # But this is not a built in. We're overwriting the generated value
+        option(:disable_s3_express_session_auth,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS) do |cfg|
+When `true`, S3 Express session authentication is disabled.
+          DOCS
+          resolve_disable_s3_express_session_auth(cfg)
+        end
+
+        option(:express_credentials_provider,
+          doc_type: 'Aws::S3::ExpressCredentialsProvider',
+          rbs_type: 'untyped',
+          docstring: <<-DOCS) do |_cfg|
+Credential Provider for S3 Express endpoints. Manages credentials
+for different buckets.
+          DOCS
+          Aws::S3::ExpressCredentialsProvider.new
+        end
+
+        # @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 props['backend'] == 'S3Express'
+                if context.operation_name == :put_object || checksum_required?(context)
+                  context[:default_request_checksum_algorithm] = 'CRC32'
+                end
+                context[:s3_express_endpoint] = true
+              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
+            end
+            with_metric(credentials) { @handler.call(context) }
+          end
+
+          private
+
+          def with_metric(credentials, &block)
+            return block.call unless credentials
+
+            Aws::Plugins::UserAgent.metric('S3_EXPRESS_BUCKET', &block)
+          end
+
+          def checksum_required?(context)
+            context.operation.http_checksum_required ||
+              (context.operation.http_checksum &&
+                context.operation.http_checksum['requestChecksumRequired'])
+          end
+        end
+
+        handler(Handler)
+
+        # Optimization - sets this client as the client to create sessions.
+        def after_initialize(client)
+          provider = client.config.express_credentials_provider
+          provider.client = client unless provider.client
+        end
+
+        class << self
+          private
+
+          def resolve_disable_s3_express_session_auth(cfg)
+            value = ENV['AWS_S3_DISABLE_EXPRESS_SESSION_AUTH'] ||
+                    Aws.shared_config.s3_disable_express_session_auth(profile: cfg.profile) ||
+                    'false'
+            value = Aws::Util.str_2_bool(value)
+            # Raise if provided value is not true or false
+            if value.nil?
+              raise ArgumentError,
+                    'Must provide either `true` or `false` for the '\
+                    '`s3_disable_express_session_auth` profile option or for '\
+                    "ENV['AWS_S3_DISABLE_EXPRESS_SESSION_AUTH']."
+            end
+            value
+          end
+        end
+      end
+    end
+  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/location_constraint.rb

@@ -22,7 +22,9 @@ module Aws
 
           def populate_location_constraint(params, region)
             params[:create_bucket_configuration] ||= {}
-            params[:create_bucket_configuration][:location_constraint] ||= region
+            unless params[:create_bucket_configuration][:location]
+              params[:create_bucket_configuration][:location_constraint] ||= region
+            end
           end
 
         end

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

@@ -22,7 +22,8 @@ module Aws
           CHUNK_SIZE = 1 * 1024 * 1024 # one MB
 
           def call(context)
-            if !context[:checksum_algorithms] # skip in favor of flexible checksum
+            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)