aws-sdk-v1 1.52.0

data/lib/aws/core/signers/version_4/chunk_signed_stream.rb

@@ -0,0 +1,191 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'stringio'
+
+module AWS
+  module Core
+    module Signers
+      class Version4
+        class ChunkSignedStream
+
+          # @api private
+          DEFAULT_CHUNK_SIZE = 128 * 1024
+
+          # @api private
+          MAX_BUFFER_SIZE = 256 * 1024
+
+          # @api private
+          CHUNK_SIGNATURE_HEADER = ";chunk-signature="
+
+          # @api private
+          CHUNK_STRING_TO_SIGN_PREFIX = "AWS4-HMAC-SHA256-PAYLOAD"
+
+          # @api private
+          SIGNATURE_LENGTH = 64
+
+          # @api private
+          CLRF = "\r\n"
+
+          # @param [IO] stream The original http request body stream.
+          # @param [Integer] stream_size Size of the original stream in bytes.
+          #   This must be greater than 0.
+          # @param [String] key The derived sigv4 signing key.
+          # @param [String] key_path The scope of the derived key.
+          # @param [String] datetime The iso8601 formatted datetime.
+          # @param [String] signature The computed signature of the request headers.
+          # @return [IO] Returns an IO-like object.
+          def initialize stream, stream_size, key, key_path, datetime, signature
+            @stream = stream || StringIO.new('')
+            @size = self.class.signed_size(stream_size)
+            @key = key
+            @key_path = key_path
+            @datetime = datetime
+            @prev_chunk_signature = signature
+            reset
+          end
+
+          # @return [Integer] the size of the final (signed) stream
+          attr_reader :size
+
+          # @param [Integer] bytes (nil)
+          # @param [String] output_buffer (nil)
+          # @return [String,nil]
+          def read bytes = nil, output_buffer = nil
+            data = read_bytes(bytes || @size)
+            if output_buffer
+              output_buffer.replace(data || '')
+            else
+              (data.nil? and bytes.nil?) ? '' : data
+            end
+          end
+
+          # @return [Integer]
+          def rewind
+            @stream.rewind
+            reset
+          end
+
+          private
+
+          def reset
+            @buffer = ''
+            @more_chunks = true
+          end
+
+          # @param [Integer] num_bytes The maximum number of bytes to return.
+          # @return [String,nil] `nil` once the complete stream has been read
+          def read_bytes num_bytes
+            fill_buffer(num_bytes)
+            bytes = @buffer[0,num_bytes]
+            @buffer = @buffer[num_bytes..-1] || '' # flatten the buffer
+            bytes == '' ? nil : bytes
+          end
+
+          # Fills the internal buffer at least +num_bytes+ of data.
+          # @param [Integer] num_bytes
+          def fill_buffer num_bytes
+            while @buffer.bytesize < num_bytes && more_chunks?
+              @buffer << next_chunk
+            end
+          end
+
+          def more_chunks?
+            @more_chunks
+          end
+
+          def next_chunk
+            chunk = @stream.read(DEFAULT_CHUNK_SIZE)
+            if chunk.nil?
+              chunk = ''
+              @more_chunks = false
+            end
+            sign_chunk(chunk)
+          end
+
+          # Given a chunk of the original stream, this method returns a signed
+          # chunk with the prefixed header.
+          # @param [String] chunk
+          # @return [String]
+          def sign_chunk chunk
+            [
+              chunk.bytesize.to_s(16),
+              CHUNK_SIGNATURE_HEADER,
+              next_chunk_signature(chunk),
+              CLRF,
+              chunk,
+              CLRF,
+            ].join
+          end
+
+          # @param [String] chunk
+          # @return [String]
+          def next_chunk_signature chunk
+            string_to_sign = [
+              "AWS4-HMAC-SHA256-PAYLOAD",
+              @datetime,
+              @key_path,
+              @prev_chunk_signature,
+              hash(''),
+              hash(chunk),
+            ].join("\n")
+            signature = sign(string_to_sign)
+            @prev_chunk_signature = signature
+            signature
+          end
+
+          def sign value
+            @digest ||= OpenSSL::Digest.new('sha256')
+            OpenSSL::HMAC.hexdigest(@digest, @key, value)
+          end
+
+          def hash value
+            OpenSSL::Digest::SHA256.new.update(value).hexdigest
+          end
+
+          class << self
+
+            # Computes the final size of a chunked signed stream.
+            # @param [Integer] size Size of the original, unsigned stream.
+            # @return [Integer]
+            def signed_size size
+              full_sized_chunks = size / DEFAULT_CHUNK_SIZE
+              trailing_bytes = size % DEFAULT_CHUNK_SIZE
+              length = 0
+              length += full_sized_chunks * header_length(DEFAULT_CHUNK_SIZE)
+              length += trailing_bytes > 0 ? header_length(trailing_bytes) : 0
+              length += header_length(0)
+              length
+            end
+
+            private
+
+            # Computes the size of a header that prefixes a chunk.  The size
+            # appears in the header as a string.
+            # @param [Integer] size
+            # @return [Integer]
+            def header_length size
+              size.to_s(16).length +
+              CHUNK_SIGNATURE_HEADER.length +
+              SIGNATURE_LENGTH +
+              CLRF.length +
+              size +
+              CLRF.length
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/core/uri_escape.rb

@@ -0,0 +1,44 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'cgi'
+
+module AWS
+  module Core
+
+    # Provides helper methods for URI escaping values and paths.
+    module UriEscape
+
+      # @param [String] value
+      # @return [String] Returns a URI escaped string.
+      def escape value
+        value = value.encode("UTF-8") if value.respond_to?(:encode)
+        CGI::escape(value.to_s).gsub('+', '%20').gsub('%7E', '~')
+      end
+      module_function :escape
+
+      # @param [String] value
+      # @return [String] Returns a URI-escaped path without escaping the
+      #   separators.
+      def escape_path value
+        escaped = ""
+        value.scan(%r{(/*)([^/]*)(/*)}) do |(leading, part, trailing)|
+          escaped << leading + escape(part) + trailing
+        end
+        escaped
+      end
+      module_function :escape_path
+
+    end
+  end
+end

data/lib/aws/core/xml/frame.rb

@@ -0,0 +1,245 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'base64'
+require 'date'
+require 'time'
+
+module AWS
+  module Core
+    module XML
+      class Frame
+
+        TRANSLATE_DIGITS = ['0123456789'.freeze, ('X'*10).freeze]
+
+        EASY_FORMAT = "XXXX-XX-XXTXX:XX:XX.XXXZ".freeze
+
+        DATE_PUNCTUATION = ['-:.TZ'.freeze, (' '*5).freeze]
+
+        def initialize root_frame, parent_frame, element_name, rules
+
+          @root_frame = root_frame
+          @parent_frame = parent_frame
+          @element_name = element_name
+          @rules = rules
+          @rules[:children] ||= {}
+
+          @data = {}.merge(rules[:defaults] || {})
+          @text = nil
+
+          # initialize values for child frames of special types (e.g.
+          # lists, maps, and forced elements)
+          known_child_frames.each do |child_frame|
+            context = data_context_for(child_frame)
+            if child_frame.list?
+              context[child_frame.ruby_name] = []
+            elsif child_frame.map?
+              context[child_frame.ruby_name] = {}
+            elsif child_frame.forced?
+              context[child_frame.ruby_name] = child_frame.value
+            end
+          end
+
+        end
+
+        attr_reader :root_frame
+        attr_reader :parent_frame
+        attr_reader :element_name
+        attr_reader :rules
+
+        def data
+          ignored? ? parent_frame.data : @data
+        end
+
+        def ruby_name
+          rules[:rename] || root_frame.inflect(element_name)
+        end
+
+        def rules_for child_element_name
+          rules[:children][child_element_name] || {}
+        end
+
+        # The list of child frames that have customizations (rules), all
+        # other children will be parsed using standard rules
+        def known_child_frames
+          rules[:children].keys.map {|name| build_child_frame(name) }
+        end
+
+        def build_child_frame element_name
+          # if element_name should be wrapped
+          #   build a frame for the wrapper
+          #   build a child frame from the wrapper
+          # else
+          Frame.new(root_frame, self, element_name, rules_for(element_name))
+        end
+
+        def consume_child_frame child_frame
+
+          child_frame.close
+
+          return if child_frame.ignored?
+
+          ruby_name = child_frame.ruby_name
+          value = child_frame.value
+          context = data_context_for(child_frame)
+
+          if child_frame.list?
+            context[ruby_name] << value
+          elsif map = child_frame.map?
+            context[ruby_name][child_frame.map_key] = child_frame.map_value
+          else
+            context[ruby_name] = value
+          end
+        end
+
+        def close
+          # some xml elements should be indexed at the root level
+          # The :index rule determines the name of this index
+          # and what keys the data should be indexed as (one element
+          # can be indexed under multiple keys).  The index value
+          # is always the element itself.
+          if index = @rules[:index]
+            index_keys_for(index) do |key|
+              root_frame.add_to_index(index[:name], key, data)
+            end
+          end
+        end
+
+        def index_keys_for index_opts, &block
+
+          # simple (single) key
+          if key = index_opts[:key]
+            yield(data[key])
+            return
+          end
+
+          # composite key, joined by ":"
+          if parts = index_opts[:keys]
+            composite_key = parts.map{|part| data[part] }.join(":")
+            yield(composite_key)
+            return
+          end
+
+          # multiple keys, collected from the given path
+          if path = index_opts[:key_path]
+            keys_from_path(data, path.dup, &block)
+            return
+          end
+
+          raise "missing require index rule option, :key, :keys or :key_path"
+
+        end
+
+        def keys_from_path data, path, &block
+
+          step = path.shift
+          value = data[step]
+
+          if path.empty?
+            yield(value)
+            return
+          end
+
+          if value.is_a?(Array)
+            value.each do |v|
+              keys_from_path(v, path.dup, &block)
+            end
+          else
+            keys_from_path(value, path.dup, &block)
+          end
+
+        end
+
+        def add_text chars
+          @text ||= ''
+          @text << chars
+        end
+
+        def value
+          if !data.empty?
+            data[:encoding] == 'base64' ?  Base64.decode64(@text.strip) : data
+          elsif @text.nil?
+            rules[:type] == :boolean ? false : nil
+          else
+            case rules[:type]
+            when nil, :string then @text
+            when :datetime    then datetime_like_value(DateTime, :civil)
+            when :time        then datetime_like_value(Time, :utc)
+            when :integer     then @text.to_i
+            when :float       then @text.to_f
+            when :boolean     then @text == 'true'
+            when :blob        then Base64.decode64(@text)
+            when :symbol      then Core::Inflection.ruby_name(@text).to_sym
+            else raise "unhandled type"
+            end
+          end
+        end
+
+        def ignored?
+          @rules[:ignore]
+        end
+
+        def forced?
+          @rules[:force]
+        end
+
+        def list?
+          @rules[:list]
+        end
+
+        def map?
+          @rules[:map]
+        end
+
+        def wrapped?
+          @rules[:wrap]
+        end
+        alias_method :wrapper, :wrapped?
+
+        protected
+
+        def map_key
+          data[root_frame.inflect(@rules[:map].first)]
+        end
+
+        def map_value
+          data[root_frame.inflect(@rules[:map].last)]
+        end
+
+        def data_context_for child_frame
+          if child_frame.wrapped?
+            data[child_frame.wrapper] ||= {}
+            data[child_frame.wrapper]
+          else
+            data
+          end
+        end
+
+        def datetime_like_value klass, parts_constructor
+          # it's way faster to parse this specific format manually
+          # vs. DateTime#parse, and this happens to be the format
+          # that AWS uses almost (??) everywhere.
+          if @text.tr(*TRANSLATE_DIGITS) == EASY_FORMAT
+            parts = @text.tr(*DATE_PUNCTUATION).chop.split.map {|p| p.to_i }
+            parts[-1] = parts[-1] * 1000
+            klass.send(parts_constructor, *parts)
+          else
+            # fallback in case we have to handle another date format
+            klass.parse(@text)
+          end
+        end
+
+      end
+    end
+  end
+end