aws-sdk-s3 1.65.0 → 1.69.0

data/lib/aws-sdk-s3/encryptionV2/io_decrypter.rb

@@ -0,0 +1,30 @@
+module Aws
+  module S3
+    module EncryptionV2
+      # @api private
+      class IODecrypter
+
+        # @param [OpenSSL::Cipher] cipher
+        # @param [IO#write] io An IO-like object that responds to `#write`.
+        def initialize(cipher, io)
+          @cipher = cipher.clone
+          # Ensure that IO is reset between retries
+          @io = io.tap { |io| io.truncate(0) if io.respond_to?(:truncate) }
+        end
+
+        # @return [#write]
+        attr_reader :io
+
+        def write(chunk)
+          # decrypt and write
+          @io.write(@cipher.update(chunk))
+        end
+
+        def finalize
+          @io.write(@cipher.final)
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/encryptionV2/io_encrypter.rb

@@ -0,0 +1,67 @@
+require 'stringio'
+require 'tempfile'
+
+module Aws
+  module S3
+    module EncryptionV2
+
+      # Provides an IO wrapper encrypting a stream of data.
+      # @api private
+      class IOEncrypter
+
+        # @api private
+        ONE_MEGABYTE = 1024 * 1024
+
+        def initialize(cipher, io)
+          @encrypted = io.size <= ONE_MEGABYTE ?
+            encrypt_to_stringio(cipher, io.read) :
+            encrypt_to_tempfile(cipher, io)
+          @size = @encrypted.size
+        end
+
+        # @return [Integer]
+        attr_reader :size
+
+        def read(bytes = nil, output_buffer = nil)
+          if @encrypted.is_a?(Tempfile) && @encrypted.closed?
+            @encrypted.open
+            @encrypted.binmode
+          end
+          @encrypted.read(bytes, output_buffer)
+        end
+
+        def rewind
+          @encrypted.rewind
+        end
+
+        # @api private
+        def close
+          @encrypted.close if @encrypted.is_a?(Tempfile)
+        end
+
+        private
+
+        def encrypt_to_stringio(cipher, plain_text)
+          if plain_text.empty?
+            StringIO.new(cipher.final + cipher.auth_tag)
+          else
+            StringIO.new(cipher.update(plain_text) + cipher.final + cipher.auth_tag)
+          end
+        end
+
+        def encrypt_to_tempfile(cipher, io)
+          encrypted = Tempfile.new(self.object_id.to_s)
+          encrypted.binmode
+          while chunk = io.read(ONE_MEGABYTE)
+            encrypted.write(cipher.update(chunk))
+          end
+          encrypted.write(cipher.final)
+          encrypted.write(cipher.auth_tag)
+          encrypted.rewind
+          encrypted
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/encryptionV2/key_provider.rb

@@ -0,0 +1,29 @@
+module Aws
+  module S3
+    module EncryptionV2
+
+      # This module defines the interface required for a {Client#key_provider}.
+      # A key provider is any object that:
+      #
+      # * Responds to {#encryption_materials} with an {Materials} object.
+      #
+      # * Responds to {#key_for}, receiving a JSON document String,
+      #   returning an encryption key. The returned encryption key
+      #   must be one of:
+      #
+      #   * `OpenSSL::PKey::RSA` - for asymmetric encryption
+      #   * `String` - 32, 24, or 16 bytes long, for symmetric encryption
+      #
+      module KeyProvider
+
+        # @return [Materials]
+        def encryption_materials; end
+
+        # @param [String<JSON>] materials_description
+        # @return [OpenSSL::PKey::RSA, String] encryption_key
+        def key_for(materials_description); end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/encryptionV2/kms_cipher_provider.rb

@@ -0,0 +1,84 @@
+require 'base64'
+
+module Aws
+  module S3
+    module EncryptionV2
+      # @api private
+      class KmsCipherProvider
+
+        def initialize(options = {})
+          @kms_key_id = options[:kms_key_id]
+          @kms_client = options[:kms_client]
+        end
+
+        # @return [Array<Hash,Cipher>] Creates and returns a new encryption
+        #   envelope and encryption cipher.
+        def encryption_cipher
+          cek_alg = 'AES/GCM/NoPadding'
+          encryption_context = {
+            'aws:x-amz-cek-alg' => cek_alg
+          }
+          key_data = @kms_client.generate_data_key(
+            key_id: @kms_key_id,
+            encryption_context: encryption_context,
+            key_spec: 'AES_256',
+          )
+          cipher = Utils.aes_encryption_cipher(:GCM)
+          cipher.key = key_data.plaintext
+          envelope = {
+            'x-amz-key-v2' => encode64(key_data.ciphertext_blob),
+            'x-amz-iv' => encode64(cipher.iv = cipher.random_iv),
+            'x-amz-cek-alg' => cek_alg,
+            'x-amz-tag-len' => 16 * 8,
+            'x-amz-wrap-alg' => 'kms+context',
+            'x-amz-matdesc' => Json.dump(encryption_context)
+          }
+          cipher.auth_data = '' # auth_data must be set after key and iv
+          [envelope, cipher]
+        end
+
+        # @return [Cipher] Given an encryption envelope, returns a
+        #   decryption cipher.
+        def decryption_cipher(envelope)
+          encryption_context = Json.load(envelope['x-amz-matdesc'])
+          key = @kms_client.decrypt(
+            ciphertext_blob: decode64(envelope['x-amz-key-v2']),
+            encryption_context: encryption_context
+          ).plaintext
+          cek_alg = envelope['x-amz-wrap-alg'] == 'kms+context' ?
+            encryption_context['aws:x-amz-cek-alg'] : envelope['x-amz-cek-alg']
+          if cek_alg != envelope['x-amz-cek-alg']
+            raise Errors::DecryptionError, 'Value of cek-alg from envelope'\
+              ' does not match the value in the encryption context'
+          end
+          iv = decode64(envelope['x-amz-iv'])
+          block_mode =
+            case cek_alg
+            when 'AES/CBC/PKCS5Padding'
+              :CBC
+            when 'AES/CBC/PKCS7Padding'
+              :CBC
+            when 'AES/GCM/NoPadding'
+              :GCM
+            else
+              type = envelope['x-amz-cek-alg'].inspect
+              msg = "unsupported content encrypting key (cek) format: #{type}"
+              raise Errors::DecryptionError, msg
+            end
+          Utils.aes_decryption_cipher(block_mode, key, iv)
+        end
+
+        private
+
+        def encode64(str)
+          Base64.encode64(str).split("\n") * ""
+        end
+
+        def decode64(str)
+          Base64.decode64(str)
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/encryptionV2/materials.rb

@@ -0,0 +1,58 @@
+require 'base64'
+
+module Aws
+  module S3
+    module EncryptionV2
+      class Materials
+
+        # @option options [required, OpenSSL::PKey::RSA, String] :key
+        #   The master key to use for encrypting/decrypting all objects.
+        #
+        # @option options [String<JSON>] :description ('{}')
+        #   The encryption materials description. This is must be
+        #   a JSON document string.
+        #
+        def initialize(options = {})
+          @key = validate_key(options[:key])
+          @description = validate_desc(options[:description])
+        end
+
+        # @return [OpenSSL::PKey::RSA, String]
+        attr_reader :key
+
+        # @return [String<JSON>]
+        attr_reader :description
+
+        private
+
+        def validate_key(key)
+          case key
+          when OpenSSL::PKey::RSA then key
+          when String
+            if [32, 24, 16].include?(key.bytesize)
+              key
+            else
+              msg = 'invalid key, symmetric key required to be 16, 24, or '\
+                    '32 bytes in length, saw length ' + key.bytesize.to_s
+              raise ArgumentError, msg
+            end
+          else
+            msg = 'invalid encryption key, expected an OpenSSL::PKey::RSA key '\
+                  '(for asymmetric encryption) or a String (for symmetric '\
+                  'encryption).'
+            raise ArgumentError, msg
+          end
+        end
+
+        def validate_desc(description)
+          Json.load(description)
+          description
+        rescue Json::ParseError, EncodingError
+          msg = 'expected description to be a valid JSON document string'
+          raise ArgumentError, msg
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-s3/encryptionV2/utils.rb

@@ -0,0 +1,116 @@
+require 'openssl'
+
+module Aws
+  module S3
+    module EncryptionV2
+      # @api private
+      module Utils
+
+        UNSAFE_MSG = "unsafe encryption, data is longer than key length"
+
+        class << self
+
+          def encrypt(key, data)
+            case key
+            when OpenSSL::PKey::RSA # asymmetric encryption
+              warn(UNSAFE_MSG) if key.public_key.n.num_bits < cipher_size(data)
+              key.public_encrypt(data)
+            when String # symmetric encryption
+              warn(UNSAFE_MSG) if cipher_size(key) < cipher_size(data)
+              cipher = aes_encryption_cipher(:ECB, key)
+              cipher.update(data) + cipher.final
+            end
+          end
+
+          def encrypt_aes_gcm(key, data, auth_data)
+            warn(UNSAFE_MSG) if cipher_size(key) < cipher_size(data)
+            cipher = aes_encryption_cipher(:GCM, key)
+            cipher.iv = (iv = cipher.random_iv)
+            cipher.auth_data = auth_data
+
+            iv + cipher.update(data) + cipher.final + cipher.auth_tag
+          end
+
+          def encrypt_rsa(key, data, auth_data)
+            # Plaintext must be KeyLengthInBytes (1 Byte) + DataKey + AuthData
+            buf = [data.bytesize] + data.unpack('C*') + auth_data.unpack('C*')
+            key.public_encrypt(buf.pack('C*'), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
+          end
+
+          def decrypt(key, data)
+            begin
+              case key
+              when OpenSSL::PKey::RSA # asymmetric decryption
+                key.private_decrypt(data)
+              when String # symmetric Decryption
+                cipher = aes_cipher(:decrypt, :ECB, key, nil)
+                cipher.update(data) + cipher.final
+              end
+            rescue OpenSSL::Cipher::CipherError
+              msg = 'decryption failed, possible incorrect key'
+              raise Errors::DecryptionError, msg
+            end
+          end
+
+          def decrypt_aes_gcm(key, data, auth_data)
+            # data is iv (12B) + key + tag (16B)
+            buf = data.unpack('C*')
+            iv = buf[0,12].pack('C*') # iv will always be 12 bytes
+            tag = buf[-16, 16].pack('C*') # tag is 16 bytes
+            enc_key = buf[12, buf.size - (12+16)].pack('C*')
+            cipher = aes_cipher(:decrypt, :GCM, key, iv)
+            cipher.auth_tag = tag
+            cipher.auth_data = auth_data
+            cipher.update(enc_key) + cipher.final
+          end
+
+          # returns the decrypted data + auth_data
+          def decrypt_rsa(key, enc_data)
+            # Plaintext must be KeyLengthInBytes (1 Byte) + DataKey + AuthData
+            buf = key.private_decrypt(enc_data, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING).unpack('C*')
+            key_length = buf[0]
+            data = buf[1, key_length].pack('C*')
+            auth_data = buf[key_length+1, buf.length - key_length].pack('C*')
+            [data, auth_data]
+          end
+
+          # @param [String] block_mode "CBC" or "ECB"
+          # @param [OpenSSL::PKey::RSA, String, nil] key
+          # @param [String, nil] iv The initialization vector
+          def aes_encryption_cipher(block_mode, key = nil, iv = nil)
+            aes_cipher(:encrypt, block_mode, key, iv)
+          end
+
+          # @param [String] block_mode "CBC" or "ECB"
+          # @param [OpenSSL::PKey::RSA, String, nil] key
+          # @param [String, nil] iv The initialization vector
+          def aes_decryption_cipher(block_mode, key = nil, iv = nil)
+            aes_cipher(:decrypt, block_mode, key, iv)
+          end
+
+          # @param [String] mode "encrypt" or "decrypt"
+          # @param [String] block_mode "CBC" or "ECB"
+          # @param [OpenSSL::PKey::RSA, String, nil] key
+          # @param [String, nil] iv The initialization vector
+          def aes_cipher(mode, block_mode, key, iv)
+            cipher = key ?
+              OpenSSL::Cipher.new("aes-#{cipher_size(key)}-#{block_mode.downcase}") :
+              OpenSSL::Cipher.new("aes-256-#{block_mode.downcase}")
+            cipher.send(mode) # encrypt or decrypt
+            cipher.key = key if key
+            cipher.iv = iv if iv
+            cipher
+          end
+
+          # @param [String] key
+          # @return [Integer]
+          # @raise ArgumentError
+          def cipher_size(key)
+            key.bytesize * 8
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'aws-sdk-s3/encryptionV2/client'
+require 'aws-sdk-s3/encryptionV2/decrypt_handler'
+require 'aws-sdk-s3/encryptionV2/default_cipher_provider'
+require 'aws-sdk-s3/encryptionV2/encrypt_handler'
+require 'aws-sdk-s3/encryptionV2/errors'
+require 'aws-sdk-s3/encryptionV2/io_encrypter'
+require 'aws-sdk-s3/encryptionV2/io_decrypter'
+require 'aws-sdk-s3/encryptionV2/io_auth_decrypter'
+require 'aws-sdk-s3/encryptionV2/key_provider'
+require 'aws-sdk-s3/encryptionV2/kms_cipher_provider'
+require 'aws-sdk-s3/encryptionV2/materials'
+require 'aws-sdk-s3/encryptionV2/utils'
+require 'aws-sdk-s3/encryptionV2/default_key_provider'
+
+module Aws
+  module S3
+    module EncryptionV2; end
+  end
+end
+

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # WARNING ABOUT GENERATED CODE
 #
 # This file is generated. See the contributing guide for more information:

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # WARNING ABOUT GENERATED CODE
 #
 # This file is generated. See the contributing guide for more information:
@@ -41,6 +43,10 @@ module Aws::S3
         @event_emitter.on(:initial_response, block) if block_given?
       end
 
+      def on_unknown_event(&block)
+        @event_emitter.on(:unknown_event, block) if block_given?
+      end
+
       def on_event(&block)
         on_records_event(&block)
         on_stats_event(&block)
@@ -49,6 +55,7 @@ module Aws::S3
         on_end_event(&block)
         on_error_event(&block)
         on_initial_response_event(&block)
+        on_unknown_event(&block)
       end
 
       # @api private

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'thread'
 require 'set'