aws-sdk-core 2.11.366 → 3.64.0

data/lib/aws-sdk-core/signers/v2.rb

@@ -1,51 +0,0 @@
-module Aws
-  module Signers
-    class V2 < Base
-
-      # @param [Http::Request] http_request
-      def sign(http_request)
-        params = http_request.body.param_list
-        params.set('AWSAccessKeyId', @credentials.access_key_id)
-        params.set('SecurityToken', @credentials.session_token) if
-          @credentials.session_token
-        params.set('Timestamp', Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
-        params.set('SignatureVersion', '2')
-        params.set('SignatureMethod', 'HmacSHA256')
-        params.delete('Signature')
-        params.set('Signature', signature(http_request, params))
-        http_request.body = params.to_io
-      end
-
-      private
-
-      def signature(http_request, params)
-        sha256_hmac(string_to_sign(http_request, params))
-      end
-
-      def string_to_sign(http_request, params)
-        [
-          http_request.http_method,
-          host(http_request.endpoint),
-          path(http_request.endpoint),
-          params.to_s,
-        ].join("\n")
-      end
-
-      def host(endpoint)
-        host = endpoint.host.downcase
-        if
-          (endpoint.scheme == 'http' && endpoint.port != 80) ||
-          (endpoint.scheme == 'https' && endpoint.port != 443)
-        then
-          host += ":#{endpoint.port}"
-        end
-        host
-      end
-
-      def path(endpoint)
-        endpoint.path == '' ? '/' : endpoint.path
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/signers/v3.rb

@@ -1,34 +0,0 @@
-require 'time'
-require 'base64'
-require 'openssl'
-
-module Aws
-  # @api private
-  module Signers
-    class V3 < Base
-
-      def sign(http_req)
-
-        date = Time.now.httpdate
-        http_req.headers['Date'] = date
-
-        if @credentials.session_token
-          http_req.headers['X-Amz-Security-Token'] = @credentials.session_token
-        end
-
-        parts = []
-        parts << "AWS3-HTTPS AWSAccessKeyId=#{@credentials.access_key_id}"
-        parts << "Algorithm=HmacSHA256"
-        parts << "Signature=#{signature(date)}"
-        http_req.headers['X-Amzn-Authorization'] = parts.join(',')
-      end
-
-      private
-
-      def signature(date)
-        sha256_hmac(date)
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/signers/v4.rb

@@ -1,234 +0,0 @@
-require 'time'
-require 'openssl'
-
-module Aws
-  module Signers
-    class V4
-
-      BLACKLIST_HEADERS = [
-        'cache-control',
-        'content-length',
-        'expect',
-        'max-forwards',
-        'pragma',
-        'te',
-        'if-match',
-        'if-none-match',
-        'if-modified-since',
-        'if-unmodified-since',
-        'if-range',
-        'accept',
-        'authorization',
-        'proxy-authorization',
-        'from',
-        'referer',
-        'user-agent',
-        'x-amzn-trace-id'
-      ]
-
-      def self.sign(context)
-        new(
-          context.config.credentials,
-          context.config.sigv4_name,
-          context.config.sigv4_region
-        ).sign(context.http_request)
-      end
-
-      # @param [Credentials] credentials
-      # @param [String] service_name The name used by the service in
-      #   signing signature version 4 requests.  This is generally
-      #   the endpoint prefix.
-      # @param [String] region The region (e.g. 'us-west-1') the request
-      #   will be made to.
-      def initialize(credentials, service_name, region)
-        @service_name = service_name
-        @credentials = credentials.credentials
-        @region = EndpointProvider.signing_region(region, service_name)
-      end
-
-      # @param [Seahorse::Client::Http::Request] req
-      # @return [Seahorse::Client::Http::Request] the signed request.
-      def sign(req)
-        datetime = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
-        body_digest = req.headers['X-Amz-Content-Sha256'] || hexdigest(req.body)
-        req.headers['X-Amz-Date'] = datetime
-        req.headers['Host'] = host(req.endpoint)
-        req.headers['X-Amz-Security-Token'] = @credentials.session_token if
-          @credentials.session_token
-        req.headers['X-Amz-Content-Sha256'] ||= body_digest
-        req.headers['Authorization'] = authorization(req, datetime, body_digest)
-        req
-      end
-
-      # Generates an returns a presigned URL.
-      # @param [Seahorse::Client::Http::Request] request
-      # @option options [required, Integer<Seconds>] :expires_in
-      # @option options [optional, String] :body_digest The SHA256 hexdigest of
-      #   the payload to sign.  For S3, this should be the string literal
-      #   `UNSIGNED-PAYLOAD`.
-      # @return [String]
-      # @api private
-      def presigned_url(request, options = {})
-        now = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
-        body_digest = options[:body_digest] || hexdigest(request.body)
-
-        request.headers['Host'] = host(request.endpoint)
-        request.headers.delete('User-Agent')
-
-        params = Aws::Query::ParamList.new
-
-        request.headers.keys.each do |key|
-          if key.match(/^x-amz/i)
-            params.set(key, request.headers.delete(key))
-          end
-        end
-
-        params.set("X-Amz-Algorithm", "AWS4-HMAC-SHA256")
-        params.set("X-Amz-Credential", credential(now))
-        params.set("X-Amz-Date", now)
-        params.set("X-Amz-Expires", options[:expires_in].to_s)
-        params.set("X-Amz-SignedHeaders", signed_headers(request))
-        params.set('X-Amz-Security-Token', @credentials.session_token) if
-          @credentials.session_token
-
-        endpoint = request.endpoint
-        if endpoint.query
-          endpoint.query += '&' + params.to_s
-        else
-          endpoint.query = params.to_s
-        end
-        endpoint.to_s + '&X-Amz-Signature=' + signature(request, now, body_digest)
-      end
-
-      def authorization(request, datetime, body_digest)
-        parts = []
-        parts << "AWS4-HMAC-SHA256 Credential=#{credential(datetime)}"
-        parts << "SignedHeaders=#{signed_headers(request)}"
-        parts << "Signature=#{signature(request, datetime, body_digest)}"
-        parts.join(', ')
-      end
-
-      def credential(datetime)
-        "#{@credentials.access_key_id}/#{credential_scope(datetime)}"
-      end
-
-      def signature(request, datetime, body_digest)
-        k_secret = @credentials.secret_access_key
-        k_date = hmac("AWS4" + k_secret, datetime[0,8])
-        k_region = hmac(k_date, @region)
-        k_service = hmac(k_region, @service_name)
-        k_credentials = hmac(k_service, 'aws4_request')
-        hexhmac(k_credentials, string_to_sign(request, datetime, body_digest))
-      end
-
-      def string_to_sign(request, datetime, body_digest)
-        parts = []
-        parts << 'AWS4-HMAC-SHA256'
-        parts << datetime
-        parts << credential_scope(datetime)
-        parts << hexdigest(canonical_request(request, body_digest))
-        parts.join("\n")
-      end
-
-      def credential_scope(datetime)
-        parts = []
-        parts << datetime[0,8]
-        parts << @region
-        parts << @service_name
-        parts << 'aws4_request'
-        parts.join("/")
-      end
-
-      def canonical_request(request, body_digest)
-        [
-          request.http_method,
-          path(request.endpoint),
-          normalized_querystring(request.endpoint.query || ''),
-          canonical_headers(request) + "\n",
-          signed_headers(request),
-          body_digest
-        ].join("\n")
-      end
-
-      def path(uri)
-        path = uri.path == '' ? '/' : uri.path
-        if @service_name == 's3'
-          path
-        else
-          Seahorse::Util.uri_path_escape(path)
-        end
-      end
-
-      def normalized_querystring(querystring)
-        params = querystring.split('&')
-        params = params.map { |p| p.match(/=/) ? p : p + '=' }
-        # We have to sort by param name and preserve order of params that
-        # have the same name. Default sort <=> in JRuby will swap members
-        # occasionally when <=> is 0 (considered still sorted), but this
-        # causes our normalized query string to not match the sent querystring.
-        # When names match, we then sort by their original order
-        params = params.each.with_index.sort do |a, b|
-          a, a_offset = a
-          a_name = a.split('=')[0]
-          b, b_offset = b
-          b_name = b.split('=')[0]
-          if a_name == b_name
-            a_offset <=> b_offset
-          else
-            a_name <=> b_name
-          end
-        end.map(&:first).join('&')
-      end
-
-      def signed_headers(request)
-        request.headers.keys.inject([]) do |signed_headers, header_key|
-          header_key = header_key.downcase
-          unless BLACKLIST_HEADERS.include?(header_key)
-            signed_headers << header_key
-          end
-          signed_headers
-        end.sort.join(';')
-      end
-
-      def canonical_headers(request)
-        headers = []
-        request.headers.each_pair do |k,v|
-          k = k.downcase
-          headers << [k,v] unless BLACKLIST_HEADERS.include?(k)
-        end
-        headers = headers.sort_by(&:first)
-        headers.map{|k,v| "#{k}:#{canonical_header_value(v.to_s)}" }.join("\n")
-      end
-
-      def canonical_header_value(value)
-        value.match(/^".*"$/) ? value : value.gsub(/\s+/, ' ').strip
-      end
-
-      def host(uri)
-        if standard_port?(uri)
-          uri.host
-        else
-          "#{uri.host}:#{uri.port}"
-        end
-      end
-
-      def standard_port?(uri)
-        (uri.scheme == 'http' && uri.port == 80) ||
-        (uri.scheme == 'https' && uri.port == 443)
-      end
-
-      def hexdigest(value)
-        Aws::Checksums.sha256_hexdigest(value)
-      end
-
-      def hmac(key, value)
-        OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), key, value)
-      end
-
-      def hexhmac(key, value)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), key, value)
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/simpledb.rb

@@ -1,5 +0,0 @@
-Aws.add_service(:SimpleDB, {
-  api: "#{Aws::API_DIR}/sdb/2009-04-15/api-2.json",
-  docs: "#{Aws::API_DIR}/sdb/2009-04-15/docs-2.json",
-  paginators: "#{Aws::API_DIR}/sdb/2009-04-15/paginators-1.json",
-})

data/lib/aws-sdk-core/sms.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:SMS, {
-  api: "#{Aws::API_DIR}/sms/2016-10-24/api-2.json",
-  docs: "#{Aws::API_DIR}/sms/2016-10-24/docs-2.json",
-  examples: "#{Aws::API_DIR}/sms/2016-10-24/examples-1.json",
-  paginators: "#{Aws::API_DIR}/sms/2016-10-24/paginators-1.json",
-})

data/lib/aws-sdk-core/snowball.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:Snowball, {
-  api: "#{Aws::API_DIR}/snowball/2016-06-30/api-2.json",
-  docs: "#{Aws::API_DIR}/snowball/2016-06-30/docs-2.json",
-  examples: "#{Aws::API_DIR}/snowball/2016-06-30/examples-1.json",
-  paginators: "#{Aws::API_DIR}/snowball/2016-06-30/paginators-1.json",
-})

data/lib/aws-sdk-core/sns.rb

@@ -1,7 +0,0 @@
-Aws.add_service(:SNS, {
-  api: "#{Aws::API_DIR}/sns/2010-03-31/api-2.json",
-  docs: "#{Aws::API_DIR}/sns/2010-03-31/docs-2.json",
-  examples: "#{Aws::API_DIR}/sns/2010-03-31/examples-1.json",
-  paginators: "#{Aws::API_DIR}/sns/2010-03-31/paginators-1.json",
-  resources: "#{Aws::API_DIR}/sns/2010-03-31/resources-1.json",
-})

data/lib/aws-sdk-core/sqs.rb

@@ -1,7 +0,0 @@
-Aws.add_service(:SQS, {
-  api: "#{Aws::API_DIR}/sqs/2012-11-05/api-2.json",
-  docs: "#{Aws::API_DIR}/sqs/2012-11-05/docs-2.json",
-  examples: "#{Aws::API_DIR}/sqs/2012-11-05/examples-1.json",
-  paginators: "#{Aws::API_DIR}/sqs/2012-11-05/paginators-1.json",
-  resources: "#{Aws::API_DIR}/sqs/2012-11-05/resources-1.json",
-})

data/lib/aws-sdk-core/ssm.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:SSM, {
-  api: "#{Aws::API_DIR}/ssm/2014-11-06/api-2.json",
-  docs: "#{Aws::API_DIR}/ssm/2014-11-06/docs-2.json",
-  examples: "#{Aws::API_DIR}/ssm/2014-11-06/examples-1.json",
-  paginators: "#{Aws::API_DIR}/ssm/2014-11-06/paginators-1.json",
-})

data/lib/aws-sdk-core/states.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:States, {
-  api: "#{Aws::API_DIR}/states/2016-11-23/api-2.json",
-  docs: "#{Aws::API_DIR}/states/2016-11-23/docs-2.json",
-  examples: "#{Aws::API_DIR}/states/2016-11-23/examples-1.json",
-  paginators: "#{Aws::API_DIR}/states/2016-11-23/paginators-1.json",
-})

data/lib/aws-sdk-core/storagegateway.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:StorageGateway, {
-  api: "#{Aws::API_DIR}/storagegateway/2013-06-30/api-2.json",
-  docs: "#{Aws::API_DIR}/storagegateway/2013-06-30/docs-2.json",
-  examples: "#{Aws::API_DIR}/storagegateway/2013-06-30/examples-1.json",
-  paginators: "#{Aws::API_DIR}/storagegateway/2013-06-30/paginators-1.json",
-})

data/lib/aws-sdk-core/sts.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:STS, {
-  api: "#{Aws::API_DIR}/sts/2011-06-15/api-2.json",
-  docs: "#{Aws::API_DIR}/sts/2011-06-15/docs-2.json",
-  examples: "#{Aws::API_DIR}/sts/2011-06-15/examples-1.json",
-  paginators: "#{Aws::API_DIR}/sts/2011-06-15/paginators-1.json",
-})

data/lib/aws-sdk-core/support.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:Support, {
-  api: "#{Aws::API_DIR}/support/2013-04-15/api-2.json",
-  docs: "#{Aws::API_DIR}/support/2013-04-15/docs-2.json",
-  examples: "#{Aws::API_DIR}/support/2013-04-15/examples-1.json",
-  paginators: "#{Aws::API_DIR}/support/2013-04-15/paginators-1.json",
-})

data/lib/aws-sdk-core/swf.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:SWF, {
-  api: "#{Aws::API_DIR}/swf/2012-01-25/api-2.json",
-  docs: "#{Aws::API_DIR}/swf/2012-01-25/docs-2.json",
-  examples: "#{Aws::API_DIR}/swf/2012-01-25/examples-1.json",
-  paginators: "#{Aws::API_DIR}/swf/2012-01-25/paginators-1.json",
-})

data/lib/aws-sdk-core/textract.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:Textract, {
-  api: "#{Aws::API_DIR}/textract/2018-06-27/api-2.json",
-  docs: "#{Aws::API_DIR}/textract/2018-06-27/docs-2.json",
-  examples: "#{Aws::API_DIR}/textract/2018-06-27/examples-1.json",
-  paginators: "#{Aws::API_DIR}/textract/2018-06-27/paginators-1.json",
-})

data/lib/aws-sdk-core/transcribeservice.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:TranscribeService, {
-  api: "#{Aws::API_DIR}/transcribe/2017-10-26/api-2.json",
-  docs: "#{Aws::API_DIR}/transcribe/2017-10-26/docs-2.json",
-  examples: "#{Aws::API_DIR}/transcribe/2017-10-26/examples-1.json",
-  paginators: "#{Aws::API_DIR}/transcribe/2017-10-26/paginators-1.json",
-})

data/lib/aws-sdk-core/transfer.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:Transfer, {
-  api: "#{Aws::API_DIR}/transfer/2018-11-05/api-2.json",
-  docs: "#{Aws::API_DIR}/transfer/2018-11-05/docs-2.json",
-  examples: "#{Aws::API_DIR}/transfer/2018-11-05/examples-1.json",
-  paginators: "#{Aws::API_DIR}/transfer/2018-11-05/paginators-1.json",
-})

data/lib/aws-sdk-core/translate.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:Translate, {
-  api: "#{Aws::API_DIR}/translate/2017-07-01/api-2.json",
-  docs: "#{Aws::API_DIR}/translate/2017-07-01/docs-2.json",
-  examples: "#{Aws::API_DIR}/translate/2017-07-01/examples-1.json",
-  paginators: "#{Aws::API_DIR}/translate/2017-07-01/paginators-1.json",
-})

data/lib/aws-sdk-core/tree_hash.rb

@@ -1,69 +0,0 @@
-require 'openssl'
-
-module Aws
-
-  # Used for computing a tree hash SHA256 checksum of an object.
-  #
-  #    tree_hash = TreeHash.new
-  #    tree_hash.update(file.read(1024 * 1024)) until file.eof?
-  #    tree_hash.digest
-  #
-  # == Limitations and Notes
-  #
-  # There are two main limitations to be aware of when using TreeHash:
-  #
-  # * TreeHash is not thread safe. Use multiple TreeHash objects to concurrently
-  #   compute a tree hash of a large object.  Join their hashes at the end into
-  #   a single TreeHash and then call {#digest}
-  #
-  #      TreeHash.new(tree_hashes.map(&:hashes).flatten)
-  #
-  # * You must call {#update} with 1MB chunks of data.  Only the final
-  #   chunk may be smaller than 1MB.
-  #
-  # If you have a large object/file, and you would like to compute the
-  # chunks concurrently, you must break the original file/data into sections
-  # that are evenly divisible by 1MB.  Each section of data requires
-  # a seperate TreeHash object to compute hashes.  Once all sections of
-  # data are complete, you can rejoin their {#hashes} in sequential order
-  # into a single TreeHash, then call {#digest} on the final tree hash.
-  #
-  class TreeHash
-
-    def initialize(hashes = [])
-      @digest = OpenSSL::Digest.new('sha256')
-      @hashes = hashes
-    end
-
-    # @return [Array<String>] The built up list of hashes.  Each hash is
-    #   a sha255 digest of a 1MB chunk.
-    attr_accessor :hashes
-
-    # @param [String] chunk
-    # @return [String] Returns the computed SHA256 digest of the chunk.
-    def update(chunk)
-      @hashes << @digest.update(chunk).digest
-      @digest.reset
-      @hashes.last
-    end
-
-    def digest
-      hashes = @hashes
-      digest = OpenSSL::Digest.new('sha256')
-      until hashes.count == 1
-        hashes = hashes.each_slice(2).map do |h1,h2|
-          digest.reset
-          if h2
-            digest.update(h1)
-            digest.update(h2)
-            digest.digest
-          else
-            h1
-          end
-        end
-      end
-      hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2, '0')}.join('')
-    end
-
-  end
-end