tttls1.3 0.1.0

data/spec/error_spec.rb

@@ -0,0 +1,18 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ErrorAlerts do
+  let(:error) do
+    ErrorAlerts.new('unexpected_message')
+  end
+
+  let(:alert) do
+    Alert.new(description: ALERT_DESCRIPTION[:unexpected_message])
+  end
+
+  it 'should return alert' do
+    expect(error.to_alert.serialize).to eq alert.serialize
+  end
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,170 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Extensions do
+  context 'empty extensions' do
+    let(:extensions) do
+      Extensions.new
+    end
+
+    it 'should be generated' do
+      expect(extensions).to be_empty
+    end
+
+    it 'should be serialized' do
+      expect(extensions.serialize).to eq "\x00\x00"
+    end
+  end
+
+  let(:supported_versions) do
+    SupportedVersions.new(
+      msg_type: HandshakeType::CLIENT_HELLO,
+      versions: [ProtocolVersion::TLS_1_3]
+    )
+  end
+
+  let(:signature_algorithms) do
+    SignatureAlgorithms.new([SignatureScheme::RSA_PSS_RSAE_SHA256])
+  end
+
+  let(:supported_groups) do
+    SupportedGroups.new([NamedGroup::SECP256R1])
+  end
+
+  let(:key_share) do
+    ec = OpenSSL::PKey::EC.new('prime256v1')
+    ec.generate_key!
+    KeyShare.new(
+      msg_type: HandshakeType::CLIENT_HELLO,
+      key_share_entry: [
+        KeyShareEntry.new(
+          group: NamedGroup::SECP256R1,
+          key_exchange: ec.public_key.to_octet_string(:uncompressed)
+        )
+      ]
+    )
+  end
+
+  let(:server_name) do
+    ServerName.new('example.com')
+  end
+
+  let(:base_exs) do
+    [
+      supported_versions,
+      signature_algorithms,
+      supported_groups,
+      key_share,
+      server_name
+    ]
+  end
+
+  context 'client_hello base extensions' do
+    let(:extensions) do
+      Extensions.new(base_exs)
+    end
+
+    it 'should be generated' do
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_VERSIONS => supported_versions
+      expect(extensions)
+        .to include ExtensionType::SIGNATURE_ALGORITHMS => signature_algorithms
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_GROUPS => supported_groups
+      expect(extensions)
+        .to include ExtensionType::KEY_SHARE => key_share
+      expect(extensions)
+        .to include ExtensionType::SERVER_NAME => server_name
+    end
+  end
+
+  context 'extensions that include pre_shared_key' do
+    let(:pre_shared_key) do
+      PreSharedKey.deserialize(TESTBINARY_PRE_SHARED_KEY_CH,
+                               HandshakeType::CLIENT_HELLO)
+    end
+
+    let(:extensions) do
+      exs = [pre_shared_key] + base_exs
+      Extensions.new(exs)
+    end
+
+    it 'should be generated' do
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_VERSIONS => supported_versions
+      expect(extensions)
+        .to include ExtensionType::SIGNATURE_ALGORITHMS => signature_algorithms
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_GROUPS => supported_groups
+      expect(extensions)
+        .to include ExtensionType::KEY_SHARE => key_share
+      expect(extensions)
+        .to include ExtensionType::SERVER_NAME => server_name
+      expect(extensions)
+        .to include ExtensionType::PRE_SHARED_KEY => pre_shared_key
+    end
+
+    it 'should be serialized end with pre_shared_key' do
+      expect(extensions.serialize).to end_with TESTBINARY_PRE_SHARED_KEY_CH
+    end
+  end
+
+  context 'extensions that include GREASE' do
+    let(:unknown_exs_key_aa) do
+      "\xaa\xaa"
+    end
+
+    let(:unknown_exs_key_bb) do
+      "\xbb\xbb"
+    end
+
+    let(:grease_aa) do
+      UnknownExtension.new(extension_type: unknown_exs_key_aa,
+                           extension_data: '')
+    end
+
+    let(:grease_bb) do
+      UnknownExtension.new(extension_type: unknown_exs_key_bb,
+                           extension_data: "\x00")
+    end
+
+    let(:extensions) do
+      exs = [grease_aa] + base_exs + [grease_bb]
+      Extensions.new(exs)
+    end
+
+    it 'should be generated' do
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_VERSIONS => supported_versions
+      expect(extensions)
+        .to include ExtensionType::SIGNATURE_ALGORITHMS => signature_algorithms
+      expect(extensions)
+        .to include ExtensionType::SUPPORTED_GROUPS => supported_groups
+      expect(extensions)
+        .to include ExtensionType::KEY_SHARE => key_share
+      expect(extensions)
+        .to include ExtensionType::SERVER_NAME => server_name
+      # ignore UnknownExtension, so return nil
+      expect(extensions).to include unknown_exs_key_aa => nil
+      expect(extensions).to include unknown_exs_key_bb => nil
+    end
+  end
+
+  context 'extensions binary' do
+    let(:extensions) do
+      Extensions.deserialize(TESTBINARY_EXTENSIONS,
+                             HandshakeType::CLIENT_HELLO)
+    end
+
+    it 'should generate object' do
+      expect(extensions).to include ExtensionType::SUPPORTED_GROUPS
+      expect(extensions).to include ExtensionType::KEY_SHARE
+      expect(extensions).to include ExtensionType::SUPPORTED_VERSIONS
+      expect(extensions).to include ExtensionType::SIGNATURE_ALGORITHMS
+      expect(extensions).to include ExtensionType::PSK_KEY_EXCHANGE_MODES
+      expect(extensions).to include ExtensionType::RECORD_SIZE_LIMIT
+    end
+  end
+end

data/spec/finished_spec.rb

@@ -0,0 +1,55 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+using Refinements
+
+RSpec.describe Finished do
+  context 'valid finished' do
+    let(:verify_data) do
+      OpenSSL::Random.random_bytes(128)
+    end
+
+    let(:message) do
+      Finished.new(verify_data)
+    end
+
+    it 'should be generated' do
+      expect(message.msg_type).to eq HandshakeType::FINISHED
+      expect(message.verify_data).to eq verify_data
+    end
+
+    it 'should be serialized' do
+      expect(message.serialize).to eq HandshakeType::FINISHED \
+                                      + verify_data.prefix_uint24_length
+    end
+  end
+
+  context 'valid finished binary' do
+    let(:message) do
+      Finished.deserialize(TESTBINARY_SERVER_FINISHED)
+    end
+
+    it 'should generate valid object' do
+      expect(message.msg_type).to eq HandshakeType::FINISHED
+    end
+
+    it 'should generate serializable object' do
+      expect(message.serialize).to eq TESTBINARY_SERVER_FINISHED
+    end
+  end
+
+  context 'valid finished binary' do
+    let(:message) do
+      Finished.deserialize(TESTBINARY_CLIENT_FINISHED)
+    end
+
+    it 'should generate valid object' do
+      expect(message.msg_type).to eq HandshakeType::FINISHED
+    end
+
+    it 'should generate serializable object' do
+      expect(message.serialize).to eq TESTBINARY_CLIENT_FINISHED
+    end
+  end
+end

data/spec/key_schedule_spec.rb

@@ -0,0 +1,198 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe KeySchedule do
+  context 'key_schedule, Simple 1-RTT Handshake,' do
+    let(:key_schedule) do
+      transcript = Transcript.new
+      transcript.merge!(
+        CH => ClientHello.deserialize(TESTBINARY_CLIENT_HELLO),
+        SH => ServerHello.deserialize(TESTBINARY_SERVER_HELLO),
+        EE => EncryptedExtensions.deserialize(TESTBINARY_ENCRYPTED_EXTENSIONS),
+        CT => Certificate.deserialize(TESTBINARY_CERTIFICATE),
+        CV => CertificateVerify.deserialize(TESTBINARY_CERTIFICATE_VERIFY),
+        SF => Finished.deserialize(TESTBINARY_SERVER_FINISHED),
+        CF => Finished.deserialize(TESTBINARY_CLIENT_FINISHED)
+      )
+      KeySchedule.new(shared_secret: TESTBINARY_SHARED_SECRET,
+                      cipher_suite: CipherSuite::TLS_AES_128_GCM_SHA256,
+                      transcript: transcript)
+    end
+
+    it 'should generate secret' do
+      expect(key_schedule.client_handshake_traffic_secret)
+        .to eq TESTBINARY_C_HS_TRAFFIC
+      expect(key_schedule.server_handshake_traffic_secret)
+        .to eq TESTBINARY_S_HS_TRAFFIC
+      expect(key_schedule.client_application_traffic_secret)
+        .to eq TESTBINARY_C_AP_TRAFFIC
+      expect(key_schedule.server_application_traffic_secret)
+        .to eq TESTBINARY_S_AP_TRAFFIC
+      expect(key_schedule.exporter_master_secret)
+        .to eq TESTBINARY_EXP_MASTER
+      expect(key_schedule.resumption_master_secret)
+        .to eq TESTBINARY_RES_MASTER
+    end
+
+    it 'should generate server finished_key' do
+      expect(key_schedule.server_finished_key)
+        .to eq TESTBINARY_SERVER_FINISHED_KEY
+    end
+
+    it 'should generate server parameters write_key, iv' do
+      expect(key_schedule.server_handshake_write_key)
+        .to eq TESTBINARY_SERVER_PARAMETERS_WRITE_KEY
+      expect(key_schedule.server_handshake_write_iv)
+        .to eq TESTBINARY_SERVER_PARAMETERS_WRITE_IV
+    end
+
+    it 'should generate client finished_key' do
+      expect(key_schedule.client_finished_key)
+        .to eq TESTBINARY_CLIENT_FINISHED_KEY
+    end
+
+    it 'should generate client finished write_key, iv' do
+      expect(key_schedule.client_handshake_write_key)
+        .to eq TESTBINARY_CLIENT_FINISHED_WRITE_KEY
+      expect(key_schedule.client_handshake_write_iv)
+        .to eq TESTBINARY_CLIENT_FINISHED_WRITE_IV
+    end
+
+    it 'should generete server application write_key, iv' do
+      expect(key_schedule.server_application_write_key)
+        .to eq TESTBINARY_SERVER_APPLICATION_WRITE_KEY
+      expect(key_schedule.server_application_write_iv)
+        .to eq TESTBINARY_SERVER_APPLICATION_WRITE_IV
+    end
+
+    it 'should generete client application write_key, iv' do
+      expect(key_schedule.client_application_write_key)
+        .to eq TESTBINARY_CLIENT_APPLICATION_WRITE_KEY
+      expect(key_schedule.client_application_write_iv)
+        .to eq TESTBINARY_CLIENT_APPLICATION_WRITE_IV
+    end
+  end
+
+  context 'key_schedule, Resumed 0-RTT Handshake,' do
+    let(:key_schedule) do
+      transcript = Transcript.new
+      transcript.merge!(
+        CH => ClientHello.deserialize(TESTBINARY_0_RTT_CLIENT_HELLO),
+        SH => ServerHello.deserialize(TESTBINARY_0_RTT_SERVER_HELLO),
+        EE =>
+        EncryptedExtensions.deserialize(TESTBINARY_0_RTT_ENCRYPTED_EXTENSIONS),
+        SF => Finished.deserialize(TESTBINARY_0_RTT_SERVER_FINISHED),
+        EOED => EndOfEarlyData.deserialize(TESTBINARY_0_RTT_END_OF_EARLY_DATA),
+        CF => Finished.deserialize(TESTBINARY_0_RTT_CLIENT_FINISHED)
+      )
+      KeySchedule.new(psk: TESTBINARY_0_RTT_PSK,
+                      shared_secret: TESTBINARY_0_RTT_SHARED_SECRET,
+                      cipher_suite: CipherSuite::TLS_AES_128_GCM_SHA256,
+                      transcript: transcript)
+    end
+
+    it 'should generate server parameters write_key, iv' do
+      expect(key_schedule.server_handshake_write_key)
+        .to eq TESTBINARY_0_RTT_SERVER_PARAMETERS_WRITE_KEY
+      expect(key_schedule.server_handshake_write_iv)
+        .to eq TESTBINARY_0_RTT_SERVER_PARAMETERS_WRITE_IV
+    end
+
+    it 'should generete client application write_key, iv' do
+      expect(key_schedule.client_application_write_key)
+        .to eq TESTBINARY_0_RTT_CLIENT_APPLICATION_WRITE_KEY
+      expect(key_schedule.client_application_write_iv)
+        .to eq TESTBINARY_0_RTT_CLIENT_APPLICATION_WRITE_IV
+    end
+  end
+
+  context 'key_schedule, Resumed 0-RTT Handshake, ' \
+          'not negotiated shared_secret yet,' do
+    let(:key_schedule) do
+      transcript = Transcript.new
+      transcript[CH] = ClientHello.deserialize(TESTBINARY_0_RTT_CLIENT_HELLO)
+      KeySchedule.new(psk: TESTBINARY_0_RTT_PSK,
+                      shared_secret: nil,
+                      cipher_suite: CipherSuite::TLS_AES_128_GCM_SHA256,
+                      transcript: transcript)
+    end
+
+    it 'should generate binder key for resumption PSKs' do
+      expect(key_schedule.binder_key_res)
+        .to eq TESTBINARY_0_RTT_BINDER_KEY_RES
+    end
+
+    it 'should generate client_early_traffic_secret' do
+      expect(key_schedule.client_early_traffic_secret)
+        .to eq TESTBINARY_0_RTT_C_E_TRAFFIC
+    end
+
+    it 'should generate 0-RTT application write_key, iv' do
+      expect(key_schedule.early_data_write_key)
+        .to eq TESTBINARY_0_RTT_EARLY_DATA_WRITE_KEY
+      expect(key_schedule.early_data_write_iv)
+        .to eq TESTBINARY_0_RTT_EARLY_DATA_WRITE_IV
+    end
+  end
+
+  context 'key_schedule, HelloRetryRequest,' do
+    let(:key_schedule) do
+      transcript = Transcript.new
+      transcript.merge!(
+        CH1 => ClientHello.deserialize(TESTBINARY_HRR_CLIENT_HELLO1),
+        HRR => ServerHello.deserialize(TESTBINARY_HRR_HELLO_RETRY_REQUEST),
+        CH => ClientHello.deserialize(TESTBINARY_HRR_CLIENT_HELLO),
+        SH => ServerHello.deserialize(TESTBINARY_HRR_SERVER_HELLO),
+        EE =>
+        EncryptedExtensions.deserialize(TESTBINARY_HRR_ENCRYPTED_EXTENSIONS),
+        CT => Certificate.deserialize(TESTBINARY_HRR_CERTIFICATE),
+        CV => CertificateVerify.deserialize(TESTBINARY_HRR_CERTIFICATE_VERIFY),
+        SF => Finished.deserialize(TESTBINARY_HRR_SERVER_FINISHED),
+        CF => Finished.deserialize(TESTBINARY_HRR_CLIENT_FINISHED)
+      )
+      KeySchedule.new(shared_secret: TESTBINARY_HRR_SHARED_SECRET,
+                      cipher_suite: CipherSuite::TLS_AES_128_GCM_SHA256,
+                      transcript: transcript)
+    end
+
+    it 'should generate server finished_key' do
+      expect(key_schedule.server_finished_key)
+        .to eq TESTBINARY_HRR_SERVER_FINISHED_KEY
+    end
+
+    it 'should generate server parameters write_key, iv' do
+      expect(key_schedule.server_handshake_write_key)
+        .to eq TESTBINARY_HRR_SERVER_PARAMETERS_WRITE_KEY
+      expect(key_schedule.server_handshake_write_iv)
+        .to eq TESTBINARY_HRR_SERVER_PARAMETERS_WRITE_IV
+    end
+
+    it 'should generate client finished_key' do
+      expect(key_schedule.client_finished_key)
+        .to eq TESTBINARY_HRR_CLIENT_FINISHED_KEY
+    end
+
+    it 'should generate client finished write_key, iv' do
+      expect(key_schedule.client_handshake_write_key)
+        .to eq TESTBINARY_HRR_CLIENT_FINISHED_WRITE_KEY
+      expect(key_schedule.client_handshake_write_iv)
+        .to eq TESTBINARY_HRR_CLIENT_FINISHED_WRITE_IV
+    end
+
+    it 'should generete server application write_key, iv' do
+      expect(key_schedule.server_application_write_key)
+        .to eq TESTBINARY_HRR_SERVER_APPLICATION_WRITE_KEY
+      expect(key_schedule.server_application_write_iv)
+        .to eq TESTBINARY_HRR_SERVER_APPLICATION_WRITE_IV
+    end
+
+    it 'should generete client application write_key, iv' do
+      expect(key_schedule.client_application_write_key)
+        .to eq TESTBINARY_HRR_CLIENT_APPLICATION_WRITE_KEY
+      expect(key_schedule.client_application_write_iv)
+        .to eq TESTBINARY_HRR_CLIENT_APPLICATION_WRITE_IV
+    end
+  end
+end

data/spec/key_share_spec.rb

@@ -0,0 +1,199 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'spec_helper'
+using Refinements
+
+RSpec.describe KeyShare do
+  context 'valid key_share, KeyShareClientHello,' do
+    let(:public_key_secp384r1) do
+      "\x04" + OpenSSL::Random.random_bytes(96)
+    end
+
+    let(:public_key_secp256r1) do
+      "\x04" + OpenSSL::Random.random_bytes(64)
+    end
+
+    let(:extension) do
+      KeyShare.new(
+        msg_type: HandshakeType::CLIENT_HELLO,
+        key_share_entry: [
+          KeyShareEntry.new(
+            group: NamedGroup::SECP384R1,
+            key_exchange: public_key_secp384r1
+          ),
+          KeyShareEntry.new(
+            group: NamedGroup::SECP256R1,
+            key_exchange: public_key_secp256r1
+          )
+        ]
+      )
+    end
+
+    it 'should be generated' do
+      expect(extension.msg_type).to eq HandshakeType::CLIENT_HELLO
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP384R1
+      expect(extension.key_share_entry[0].key_exchange)
+        .to eq public_key_secp384r1
+      expect(extension.key_share_entry[1].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[1].key_exchange)
+        .to eq public_key_secp256r1
+    end
+
+    it 'should be serialized' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + 172.to_uint16 \
+               + 170.to_uint16 \
+               + NamedGroup::SECP384R1 \
+               + NamedGroup.key_exchange_len(NamedGroup::SECP384R1).to_uint16 \
+               + public_key_secp384r1 \
+               + NamedGroup::SECP256R1 \
+               + NamedGroup.key_exchange_len(NamedGroup::SECP256R1).to_uint16 \
+               + public_key_secp256r1
+    end
+  end
+
+  context 'valid key_share, empty KeyShare.client_shares vector' do
+    let(:extension) do
+      KeyShare.new(
+        msg_type: HandshakeType::CLIENT_HELLO,
+        key_share_entry: []
+      )
+    end
+
+    it 'should be generated' do
+      expect(extension.msg_type).to eq HandshakeType::CLIENT_HELLO
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry).to be_empty
+    end
+
+    it 'should be serialized' do
+      expect(extension.serialize).to eq ExtensionType::KEY_SHARE \
+                                        + 2.to_uint16 \
+                                        + 0.to_uint16
+    end
+  end
+
+  context 'valid key_share, KeyShareServerHello,' do
+    let(:public_key_secp256r1) do
+      "\x04" + OpenSSL::Random.random_bytes(64)
+    end
+
+    let(:extension) do
+      KeyShare.new(
+        msg_type: HandshakeType::SERVER_HELLO,
+        key_share_entry: [
+          KeyShareEntry.new(
+            group: NamedGroup::SECP256R1,
+            key_exchange: public_key_secp256r1
+          )
+        ]
+      )
+    end
+
+    it 'should be generated' do
+      expect(extension.msg_type).to eq HandshakeType::SERVER_HELLO
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[0].key_exchange)
+        .to eq public_key_secp256r1
+    end
+
+    it 'should be serialized' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + 69.to_uint16 \
+               + NamedGroup::SECP256R1 \
+               + public_key_secp256r1.prefix_uint16_length
+    end
+  end
+
+  context 'valid key_share, KeyShareHelloRetryRequest,' do
+    let(:extension) do
+      KeyShare.new(
+        msg_type: HandshakeType::HELLO_RETRY_REQUEST,
+        key_share_entry: [
+          KeyShareEntry.new(
+            group: NamedGroup::SECP256R1,
+            key_exchange: nil
+          )
+        ]
+      )
+    end
+
+    it 'should be generated' do
+      expect(extension.msg_type).to eq HandshakeType::HELLO_RETRY_REQUEST
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[0].key_exchange).to be_empty
+    end
+
+    it 'should be serialized' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + NamedGroup::SECP256R1.prefix_uint16_length
+    end
+  end
+
+  context 'valid key_share binary, KeyShareClientHello,' do
+    let(:extension) do
+      KeyShare.deserialize(TESTBINARY_KEY_SHARE_CH, HandshakeType::CLIENT_HELLO)
+    end
+
+    it 'should generate valid object' do
+      expect(extension.msg_type).to eq HandshakeType::CLIENT_HELLO
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[0].key_exchange.length)
+        .to eq NamedGroup.key_exchange_len(NamedGroup::SECP256R1)
+    end
+
+    it 'should generate serializable object' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + TESTBINARY_KEY_SHARE_CH.prefix_uint16_length
+    end
+  end
+
+  context 'valid key_share binary, KeyShareServerHello,' do
+    let(:extension) do
+      KeyShare.deserialize(TESTBINARY_KEY_SHARE_SH, HandshakeType::SERVER_HELLO)
+    end
+
+    it 'should generate valid object' do
+      expect(extension.msg_type).to eq HandshakeType::SERVER_HELLO
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[0].key_exchange.length)
+        .to eq NamedGroup.key_exchange_len(NamedGroup::SECP256R1)
+    end
+
+    it 'should generate serializable object' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + TESTBINARY_KEY_SHARE_SH.prefix_uint16_length
+    end
+  end
+
+  context 'valid key_share binary, KeyShareHelloRetryRequest,' do
+    let(:extension) do
+      KeyShare.deserialize(TESTBINARY_KEY_SHARE_HRR,
+                           HandshakeType::HELLO_RETRY_REQUEST)
+    end
+
+    it 'should generate valid object' do
+      expect(extension.msg_type).to eq HandshakeType::HELLO_RETRY_REQUEST
+      expect(extension.extension_type).to eq ExtensionType::KEY_SHARE
+      expect(extension.key_share_entry[0].group).to eq NamedGroup::SECP256R1
+      expect(extension.key_share_entry[0].key_exchange).to be_empty
+    end
+
+    it 'should generate serializable object' do
+      expect(extension.serialize)
+        .to eq ExtensionType::KEY_SHARE \
+               + TESTBINARY_KEY_SHARE_HRR.prefix_uint16_length
+    end
+  end
+end