tttls1.3 0.3.6 → 0.3.7

data/spec/ech_spec.rb

@@ -1,122 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-using Refinements
-
-RSpec.describe ECHClientHello do
-  context 'valid ECHClientHello outer binary' do
-    let(:extension) do
-      ECHClientHello.deserialize(TESTBINARY_ECH_OUTER)
-    end
-
-    it 'should generate valid object' do
-      expect(extension.extension_type)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO
-      expect(extension.type).to eq ECHClientHelloType::OUTER
-      expect(extension.cipher_suite.kdf_id.uint16).to eq 1
-      expect(extension.cipher_suite.aead_id.uint16).to eq 1
-      expect(extension.config_id).to eq 32
-      expect(extension.enc.length).to eq 32
-      expect(extension.payload.length).to eq 239
-    end
-
-    it 'should be serialized' do
-      expect(extension.serialize)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO \
-               + 281.to_uint16 \
-               + ECHClientHelloType::OUTER \
-               + 1.to_uint16 \
-               + 1.to_uint16 \
-               + 32.to_uint8 \
-               + extension.enc.prefix_uint16_length \
-               + extension.payload.prefix_uint16_length
-    end
-  end
-
-  context 'valid ECHClientHello inner binary' do
-    let(:extension) do
-      ECHClientHello.deserialize(TESTBINARY_ECH_INNER)
-    end
-
-    it 'should generate valid object' do
-      expect(extension.extension_type)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO
-      expect(extension.type).to eq ECHClientHelloType::INNER
-    end
-
-    it 'should be serialized' do
-      expect(extension.serialize)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO \
-               + 1.to_uint16 \
-               + ECHClientHelloType::INNER \
-    end
-  end
-
-  context 'valid ECHEncryptedExtensions binary' do
-    let(:extension) do
-      ECHEncryptedExtensions.deserialize(TESTBINARY_ECH_EE)
-    end
-
-    it 'should generate valid object' do
-      expect(extension.extension_type)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO
-      expect(extension.retry_configs.is_a?(Array)).to be_truthy
-      expect(extension.retry_configs.length).to eq 1
-      expect(extension.retry_configs.first.is_a?(ECHConfig)).to be_truthy
-    end
-  end
-
-  context 'valid ECHHelloRetryRequest binary' do
-    let(:extension) do
-      ECHHelloRetryRequest.deserialize(TESTBINARY_ECH_HRR)
-    end
-
-    it 'should generate valid object' do
-      expect(extension.extension_type)
-        .to eq ExtensionType::ENCRYPTED_CLIENT_HELLO
-      expect(extension.confirmation).to eq "\x00" * 8
-    end
-  end
-end
-
-RSpec.describe Ech do
-  context 'EncodedClientHelloInner length' do
-    let(:server_name) do
-      'localhost'
-    end
-
-    let(:client) do
-      Client.new(nil, server_name)
-    end
-
-    let(:maximum_name_length) do
-      0
-    end
-
-    let(:encoded) do
-      extensions, = client.send(:gen_ch_extensions)
-      inner_ech = Message::Extension::ECHClientHello.new_inner
-      Message::ClientHello.new(
-        legacy_session_id: '',
-        cipher_suites: CipherSuites.new(DEFAULT_CH_CIPHER_SUITES),
-        extensions: extensions.merge(
-          Message::ExtensionType::ENCRYPTED_CLIENT_HELLO => inner_ech
-        )
-      )
-    end
-
-    let(:padding_encoded_ch_inner) do
-      Ech.padding_encoded_ch_inner(
-        encoded.serialize[4..],
-        server_name.length,
-        maximum_name_length
-      )
-    end
-
-    it 'should be equal placeholder_encoded_ch_inner_len' do
-      expect(Ech.placeholder_encoded_ch_inner_len)
-        .to eq padding_encoded_ch_inner.length
-    end
-  end
-end

data/spec/encrypted_extensions_spec.rb

@@ -1,94 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-using Refinements
-
-RSpec.describe EncryptedExtensions do
-  context 'valid encrypted_extensions' do
-    let(:server_name) do
-      ServerName.new('')
-    end
-
-    let(:supported_groups) do
-      SupportedGroups.new(
-        [
-          NamedGroup::SECP256R1,
-          NamedGroup::SECP384R1,
-          NamedGroup::SECP521R1
-        ]
-      )
-    end
-
-    let(:extensions) do
-      Extensions.new([server_name, supported_groups])
-    end
-
-    let(:message) do
-      EncryptedExtensions.new(extensions)
-    end
-
-    it 'should be generated' do
-      expect(message.msg_type).to eq HandshakeType::ENCRYPTED_EXTENSIONS
-      expect(message.extensions).to eq extensions
-      expect(message.appearable_extensions?).to be true
-    end
-
-    it 'should be serialized' do
-      expect(message.serialize)
-        .to eq HandshakeType::ENCRYPTED_EXTENSIONS \
-               + extensions.serialize.prefix_uint24_length
-    end
-  end
-
-  context 'invalid encrypted_extensions, including forbidden extension type,' do
-    let(:extensions) do
-      signature_algorithms \
-      = SignatureAlgorithms.new([SignatureScheme::ECDSA_SECP256R1_SHA256])
-      Extensions.new([signature_algorithms])
-    end
-
-    let(:message) do
-      EncryptedExtensions.new(extensions)
-    end
-
-    it 'should be generated' do
-      expect(message.msg_type).to eq HandshakeType::ENCRYPTED_EXTENSIONS
-      expect(message.extensions).to eq extensions
-      expect(message.appearable_extensions?).to be false
-    end
-  end
-
-  context 'valid encrypted_extensions, nil argument,' do
-    let(:message) do
-      EncryptedExtensions.new(nil)
-    end
-
-    it 'should be generated' do
-      expect(message.msg_type).to eq HandshakeType::ENCRYPTED_EXTENSIONS
-      expect(message.extensions).to eq Extensions.new
-      expect(message.appearable_extensions?).to be true
-    end
-
-    it 'should be serialized' do
-      expect(message.serialize)
-        .to eq HandshakeType::ENCRYPTED_EXTENSIONS \
-               + Extensions.new.serialize.prefix_uint24_length
-    end
-  end
-
-  context 'valid encrypted_extensions binary' do
-    let(:message) do
-      EncryptedExtensions.deserialize(TESTBINARY_ENCRYPTED_EXTENSIONS)
-    end
-
-    it 'should generate valid object' do
-      expect(message.msg_type).to eq HandshakeType::ENCRYPTED_EXTENSIONS
-      expect(message.appearable_extensions?).to be true
-    end
-
-    it 'should generate valid serializable object' do
-      expect(message.serialize).to eq TESTBINARY_ENCRYPTED_EXTENSIONS
-    end
-  end
-end

data/spec/end_of_early_data_spec.rb

@@ -1,28 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-using Refinements
-
-RSpec.describe EndOfEarlyData do
-  context 'end_of_early_data' do
-    let(:message) do
-      EndOfEarlyData.new
-    end
-
-    it 'should be serialized' do
-      expect(message.serialize).to eq HandshakeType::END_OF_EARLY_DATA \
-                                      + ''.prefix_uint24_length
-    end
-  end
-
-  context 'valid end_of_early_data binary' do
-    let(:message) do
-      EndOfEarlyData.deserialize(TESTBINARY_0_RTT_END_OF_EARLY_DATA)
-    end
-
-    it 'should generate valid serializable object' do
-      expect(message.serialize).to eq TESTBINARY_0_RTT_END_OF_EARLY_DATA
-    end
-  end
-end

data/spec/endpoint_spec.rb

@@ -1,167 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-
-RSpec.describe Endpoint do
-  context 'endpoint, Simple 1-RTT Handshake,' do
-    let(:key) do
-      n = OpenSSL::BN.new(TESTBINARY_PKEY_MODULUS, 2)
-      e = OpenSSL::BN.new(TESTBINARY_PKEY_PUBLIC_EXPONENT, 2)
-      d = OpenSSL::BN.new(TESTBINARY_PKEY_PRIVATE_EXPONENT, 2)
-      p = OpenSSL::BN.new(TESTBINARY_PKEY_PRIME1, 2)
-      q = OpenSSL::BN.new(TESTBINARY_PKEY_PRIME2, 2)
-      dmp1 = d % (p - 1.to_bn)
-      dmq1 = d % (q - 1.to_bn)
-      iqmp = q**-1.to_bn % p
-      asn1 = OpenSSL::ASN1::Sequence(
-        [
-          OpenSSL::ASN1::Integer(0),
-          OpenSSL::ASN1::Integer(n),
-          OpenSSL::ASN1::Integer(e),
-          OpenSSL::ASN1::Integer(d),
-          OpenSSL::ASN1::Integer(p),
-          OpenSSL::ASN1::Integer(q),
-          OpenSSL::ASN1::Integer(dmp1),
-          OpenSSL::ASN1::Integer(dmq1),
-          OpenSSL::ASN1::Integer(iqmp)
-        ]
-      )
-      OpenSSL::PKey::RSA.new(asn1)
-    end
-
-    let(:ct) do
-      Certificate.deserialize(TESTBINARY_CERTIFICATE)
-    end
-
-    let(:cv) do
-      CertificateVerify.deserialize(TESTBINARY_CERTIFICATE_VERIFY)
-    end
-
-    let(:cf) do
-      Finished.deserialize(TESTBINARY_CLIENT_FINISHED)
-    end
-
-    let(:sf) do
-      Finished.deserialize(TESTBINARY_SERVER_FINISHED)
-    end
-
-    let(:transcript) do
-      ch = ClientHello.deserialize(TESTBINARY_CLIENT_HELLO)
-      sh = ServerHello.deserialize(TESTBINARY_SERVER_HELLO)
-      ee = EncryptedExtensions.deserialize(TESTBINARY_ENCRYPTED_EXTENSIONS)
-      transcript = Transcript.new
-      transcript.merge!(
-        CH => [ch, TESTBINARY_CLIENT_HELLO],
-        SH => [sh, TESTBINARY_SERVER_HELLO],
-        EE => [ee, TESTBINARY_ENCRYPTED_EXTENSIONS],
-        CT => [ct, TESTBINARY_CERTIFICATE],
-        CV => [cv, TESTBINARY_CERTIFICATE_VERIFY],
-        CF => [cf, TESTBINARY_CLIENT_FINISHED],
-        SF => [sf, TESTBINARY_SERVER_FINISHED]
-      )
-    end
-
-    let(:digest) do
-      CipherSuite.digest(CipherSuite::TLS_AES_128_GCM_SHA256)
-    end
-
-    it 'should verify server CertificateVerify.signature' do
-      public_key = ct.certificate_list.first.cert_data.public_key
-      signature_scheme = cv.signature_scheme
-      signature = cv.signature
-
-      expect(Endpoint.verified_certificate_verify?(
-               public_key:,
-               signature_scheme:,
-               signature:,
-               context: 'TLS 1.3, server CertificateVerify',
-               hash: transcript.hash(digest, CT)
-             )).to be true
-    end
-
-    it 'should sign client Finished.verify_data' do
-      expect(Endpoint.sign_finished(
-               digest: 'SHA256',
-               finished_key: TESTBINARY_CLIENT_FINISHED_KEY,
-               hash: transcript.hash(digest, EOED)
-             )).to eq cf.verify_data
-    end
-
-    it 'should verify server Finished.verify_data' do
-      expect(Endpoint.verified_finished?(
-               finished: sf,
-               digest: 'SHA256',
-               finished_key: TESTBINARY_SERVER_FINISHED_KEY,
-               hash: transcript.hash(digest, CV)
-             )).to be true
-    end
-
-    it 'should sign server CertificateVerify.signature' do
-      public_key = ct.certificate_list.first.cert_data.public_key
-      signature_scheme = cv.signature_scheme
-
-      # used RSASSA-PSS signature_scheme, salt is a random sequence.
-      # CertificateVerify.signature is random.
-      signature = Endpoint.sign_certificate_verify(
-        key:,
-        signature_scheme:,
-        context: 'TLS 1.3, server CertificateVerify',
-        hash: transcript.hash(digest, CT)
-      )
-      expect(Endpoint.verified_certificate_verify?(
-               public_key:,
-               signature_scheme:,
-               signature:,
-               context: 'TLS 1.3, server CertificateVerify',
-               hash: transcript.hash(digest, CT)
-             )).to be true
-    end
-  end
-
-  context 'endpoint, HelloRetryRequest,' do
-    let(:ct) do
-      Certificate.deserialize(TESTBINARY_HRR_CERTIFICATE)
-    end
-
-    let(:cv) do
-      CertificateVerify.deserialize(TESTBINARY_HRR_CERTIFICATE_VERIFY)
-    end
-
-    let(:transcript) do
-      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)
-      transcript = Transcript.new
-      transcript.merge!(
-        CH1 => [ch1, TESTBINARY_HRR_CLIENT_HELLO1],
-        HRR => [hrr, TESTBINARY_HRR_HELLO_RETRY_REQUEST],
-        CH => [ch, TESTBINARY_HRR_CLIENT_HELLO],
-        SH => [sh, TESTBINARY_HRR_SERVER_HELLO],
-        EE => [ee, TESTBINARY_HRR_ENCRYPTED_EXTENSIONS],
-        CT => [ct, TESTBINARY_HRR_CERTIFICATE],
-        CV => [cv, TESTBINARY_HRR_CERTIFICATE_VERIFY]
-      )
-    end
-
-    let(:digest) do
-      CipherSuite.digest(CipherSuite::TLS_AES_128_GCM_SHA256)
-    end
-
-    it 'should verify server CertificateVerify.signature' do
-      public_key = ct.certificate_list.first.cert_data.public_key
-      signature_scheme = cv.signature_scheme
-      signature = cv.signature
-
-      expect(Endpoint.verified_certificate_verify?(
-               public_key:,
-               signature_scheme:,
-               signature:,
-               context: 'TLS 1.3, server CertificateVerify',
-               hash: transcript.hash(digest, CT)
-             )).to be true
-    end
-  end
-end

data/spec/error_spec.rb

@@ -1,18 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative '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

@@ -1,250 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require_relative 'spec_helper'
-using Refinements
-
-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.generate('prime256v1')
-    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
-
-  context 'duplicated extension_type' do
-    let(:server_name) do
-      ServerName.new('example.com')
-    end
-
-    let(:testbinary) do
-      server_name.serialize * 2
-    end
-
-    it 'should raise error, if extension_type get duplicated' do
-      expect { Extensions.deserialize(testbinary, HandshakeType::CLIENT_HELLO) }
-        .to raise_error(ErrorAlerts)
-    end
-  end
-
-  context 'removing and replacing extensions from EncodedClientHelloInner' do
-    let(:extensions) do
-      extensions, = Client.new(nil, 'localhost').send(:gen_ch_extensions)
-      extensions
-    end
-
-    let(:no_key_share_exs) do
-      Extensions.new(
-        extensions.filter { |k, _| k != ExtensionType::KEY_SHARE }.values
-      )
-    end
-
-    it 'should be equal remove_and_replace! with []' do
-      expected = extensions.clone
-      got = extensions.remove_and_replace!([])
-
-      expect(got.keys).to eq expected.keys
-      expect(got[ExtensionType::ECH_OUTER_EXTENSIONS]).to eq nil
-      expect(extensions.keys - got.keys).to eq []
-    end
-
-    it 'should be equal remove_and_replace! with [key_share]' do
-      expected = extensions.filter { |k, _| k != ExtensionType::KEY_SHARE }
-      expected[ExtensionType::ECH_OUTER_EXTENSIONS] = \
-        Extension::ECHOuterExtensions.new([ExtensionType::KEY_SHARE])
-      got = extensions.remove_and_replace!([ExtensionType::KEY_SHARE])
-
-      expect(got.keys).to eq expected.keys
-      expect(got[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions)
-        .to eq expected[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions
-      expect(extensions.keys - got.keys)
-        .to eq expected[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions
-    end
-
-    it 'should be equal remove_and_replace! with' \
-       ' [key_share,supported_versions]' do
-      outer_extensions = [
-        ExtensionType::KEY_SHARE,
-        ExtensionType::SUPPORTED_VERSIONS
-      ]
-      expected = extensions.filter { |k, _| !outer_extensions.include?(k) }
-      expected[ExtensionType::ECH_OUTER_EXTENSIONS] = \
-        Extension::ECHOuterExtensions.new(
-          extensions.filter { |k, _| outer_extensions.include?(k) }.keys
-        )
-      got = extensions.remove_and_replace!(outer_extensions)
-
-      expect(got.keys).to eq expected.keys
-      expect(got[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions)
-        .to eq expected[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions
-      expect(extensions.keys - got.keys)
-        .to eq expected[ExtensionType::ECH_OUTER_EXTENSIONS].outer_extensions
-    end
-
-    it 'should be equal remove_and_replace! with no key_share extensions' \
-       ' & [key_share]' do
-      expected = no_key_share_exs.clone
-      got = no_key_share_exs.remove_and_replace!([ExtensionType::KEY_SHARE])
-
-      expect(got).to eq expected
-      expect(got[ExtensionType::ECH_OUTER_EXTENSIONS]).to eq nil
-      expect(no_key_share_exs.keys - got.keys).to eq []
-    end
-  end
-end