echspec 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dff1c822b0e5bef3e79cfbf5d1eb200f8312fb8fd0e0582e34d152dafdb8d810
-  data.tar.gz: 8082a87b962ee5ea9b05589558e4704919c63d69fc69bf4f3e35379164429d80
+  metadata.gz: 3902d0c840b18babccf1c9e7c764c570fd6b29e6f9688e0f9f0c5696bae4e871
+  data.tar.gz: c01a13d625bc07918e8f80db55266019ff3031c597e30e9be0dbd4515755bcb5
 SHA512:
-  metadata.gz: 37c0cfc5bc91f0be87099720490b2870921998f377d88b862152275586492670d4eb26c5ae6023a32345367b608830b4f9005b30a6df7b1fe7aea968769e0177
-  data.tar.gz: c6cf6cbbe9a0607117a173f5d921201a38d18986e37217665d51c2ff1f004ab1784bf6f9b01ac9263f686bf2192e9099b8a9df947ebf6622f3201585c035b255
+  metadata.gz: 22d2c6085da85d18cbbf3d5e52f7f4f8511f2d878da9642ce1ad53817e4a33d8429c132456305592dd37e547c53998aa2db0bc091df276b4a216f4b2283b9492
+  data.tar.gz: 9fa6ac8c64727d9e64418b7bcd3e38a98dc693b59ff52f6c7a42b4c7dc7635420d5dc60ef7f11ecf9837cd8d85a0fe7b5fd59987d81f57539ded979f330c4938

data/README.md

@@ -26,8 +26,11 @@ $ gem install echspec
 $ echspec --help
 Usage: echspec {SUBCOMMAND}
 
-Available subcommands: run, gen_configs, version, help.
+Available subcommands: run, gen_configs, resolve, grease, version, help.
 ```
+
+### run
+
 ```sh-session
 $ echspec run --help
 Usage: echspec run [OPTIONS...] {HOSTNAME}
@@ -75,7 +78,7 @@ Failures:
 1 failure
 ```
 
-By default, `echspec` retrieves ECHConfigs via DNS HTTPS records. You can specify a local PEM file using the `-f, --file FILE` option. To test a server on localhost:
+By default, `echspec` retrieves ECHConfigs via DNS HTTPS resource records. You can specify a local PEM file using the `-f, --file FILE` option. To test a server on localhost:
 
 ```sh-session
 $ echspec run -f fixtures/echconfigs.pem -p 4433 localhost
@@ -282,6 +285,8 @@ $ echspec run -s 7-5 -v research.cloudflare.com 2>&1 > /dev/null | jq .
 
 </details>
 
+### gen_configs
+
 You can generate an ECHConfig PEM file the following:
 
 ```sh-session
@@ -297,6 +302,82 @@ AQALZXhhbXBsZS5jb20AAA==
 -----END ECHCONFIG-----
 ```
 
+### resolve
+
+You can resolve ECHConfigs for a hostname and print fields using the `resolve` subcommand.
+With `-w`, ECHConfigs are resolved from the well-known URI (`https://{HOSTNAME}/.well-known/origin-svcb`) defined in [draft-ietf-tls-wkech](https://datatracker.ietf.org/doc/html/draft-ietf-tls-wkech-12), instead of DNS HTTPS resource records:
+
+```sh-session
+$ echspec resolve --help
+Usage: echspec resolve [OPTIONS...] [{HOSTNAME}]
+
+Resolve ECHConfigs for a hostname and print fields.
+{HOSTNAME} is required unless -f is specified.
+
+Examples:
+
+  $ echspec resolve localhost
+  $ echspec resolve -w localhost
+  $ echspec resolve -f echconfigs.pem
+
+Options:
+    -f, --file FILE                  path to ECHConfigs PEM file       (default resolve ECHConfigs via DNS)
+    -w, --well-known                 resolve ECHConfigs via well-known URI, instead of DNS
+```
+```sh-session
+$ echspec resolve research.cloudflare.com
+ECHConfig:                                     │ 
+  version(uint16):                             │ fe 0d
+  length(uint16):                              │ 65
+  contents(ECHConfigContents):                 │ 
+    key_config(HpkeKeyConfig):                 │ 
+      config_id(uint8):                        │ 104
+      kem_id(uint16):                          │ 00 20
+      public_key(opaque):                      │ e8 49 25 b3 6c e3 fb 9c 72 c7 71 e2 7a b2 8c 65 84 ba c2 2a 90 c2 cb 59 23 b2 27 d8 c1 85 84 17
+      cipher_suites(HpkeSymmetricCipherSuite): │ 
+        kdf_id(uint16):                        │ 00 01
+        aead_id(uint16):                       │ 00 01
+    maximum_name_length(uint8):                │ 0
+    public_name(opaque):                       │ cloudflare-ech.com
+    extensions(opaque):                        │ 
+```
+
+### grease
+
+You can send a GREASE ECH to a server to trigger `retry_configs` and print the retry ECHConfigs fields using the `grease` subcommand:
+
+```sh-session
+$ echspec grease --help
+Usage: echspec grease [OPTIONS...] {HOSTNAME}
+
+Send GREASE ECH to a server and display retry_configs.
+
+Examples:
+
+  $ echspec grease localhost
+  $ echspec grease -p 4433 localhost
+
+Options:
+    -p, --port VALUE                 server port number                (default 443)
+```
+```sh-session
+$ echspec grease research.cloudflare.com
+ECHConfig:                                     │ 
+  version(uint16):                             │ fe 0d
+  length(uint16):                              │ 65
+  contents(ECHConfigContents):                 │ 
+    key_config(HpkeKeyConfig):                 │ 
+      config_id(uint8):                        │ 72
+      kem_id(uint16):                          │ 00 20
+      public_key(opaque):                      │ 0a 89 2a 9f 05 0a d5 21 da cc 42 65 df cf 70 38 22 7e 85 44 93 1b 68 fa a2 b5 37 ad d8 2c 89 39
+      cipher_suites(HpkeSymmetricCipherSuite): │ 
+        kdf_id(uint16):                        │ 00 01
+        aead_id(uint16):                       │ 00 01
+    maximum_name_length(uint8):                │ 0
+    public_name(opaque):                       │ cloudflare-ech.com
+    extensions(opaque):                        │ 
+```
+
 
 ## Note
 

data/lib/echspec/cli/ech_config_printer.rb

@@ -0,0 +1,55 @@
+module EchSpec
+  class CLI
+    module EchConfigPrinter
+      def print_ech_configs(ech_configs)
+        all_pairs = ech_configs.map { |c| field_pairs(c) }
+        label_width, value_width = evaluate_widths(all_pairs)
+
+        all_pairs.each_with_index do |pairs, i|
+          puts "#{'─' * label_width}┼#{'─' * value_width}" if i.positive?
+          pairs.each { |label, value| print_field(label, value, label_width) }
+        end
+      end
+
+      def evaluate_widths(all_pairs)
+        label_width = all_pairs.flat_map { |pairs| pairs.map { |label, _| label.length } }.max + 1
+        value_width = all_pairs.flat_map { |pairs| pairs.map { |_, value| value.to_s.length } }.max + 1
+        [label_width, value_width]
+      end
+
+      def print_field(label, value, label_width)
+        puts "#{label.ljust(label_width)}│ #{value}"
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      def field_pairs(c)
+        ec = c.echconfig_contents
+        kc = ec.key_config
+        ext = ec.extensions.octet.unpack1('H*').scan(/.{2}/).join(' ')
+        cipher_suite_pairs = kc.cipher_suites.flat_map do |cs|
+          [
+            ['        kdf_id(uint16):', cs.kdf_id.encode.unpack1('H4').scan(/.{2}/).join(' ')],
+            ['        aead_id(uint16):', cs.aead_id.encode.unpack1('H4').scan(/.{2}/).join(' ')]
+          ]
+        end
+
+        [
+          ['ECHConfig:', ''],
+          ['  version(uint16):', c.version.unpack1('H4').scan(/.{2}/).join(' ')],
+          ['  length(uint16):', ec.encode.length],
+          ['  contents(ECHConfigContents):', ''],
+          ['    key_config(HpkeKeyConfig):', ''],
+          ['      config_id(uint8):', kc.config_id],
+          ['      kem_id(uint16):', kc.kem_id.encode.unpack1('H4').scan(/.{2}/).join(' ')],
+          ['      public_key(opaque):', kc.public_key.opaque.unpack1('H*').scan(/.{2}/).join(' ')],
+          ['      cipher_suites(HpkeSymmetricCipherSuite):', ''],
+          *cipher_suite_pairs,
+          ['    maximum_name_length(uint8):', ec.maximum_name_length],
+          ['    public_name(opaque):', ec.public_name],
+          ['    extensions(opaque):', ext]
+        ]
+      end
+      # rubocop: enable Metrics/AbcSize
+    end
+  end
+end

data/lib/echspec/cli/grease.rb

@@ -0,0 +1,73 @@
+module EchSpec
+  class CLI
+    class Grease
+      include EchConfigPrinter
+
+      def execute(argv)
+        port, hostname = parse_options(argv)
+
+        TTTLS13::Logging.logger.level = Logger::WARN
+        socket = TCPSocket.new(hostname, port)
+        recv = TLS13Client.send_ch_with_greased_ech(socket, hostname)
+        ex = recv.extensions[TTTLS13::Message::ExtensionType::ENCRYPTED_CLIENT_HELLO]
+
+        if ex.nil? || ex.retry_configs.nil? || ex.retry_configs.empty?
+          warn "** #{hostname}:#{port} did not send retry_configs"
+          exit 1
+        end
+
+        print_ech_configs(ex.retry_configs)
+      rescue Timeout::Error
+        warn "** #{hostname}:#{port} connection timeout"
+        exit 1
+      rescue Errno::ECONNREFUSED
+        warn "** #{hostname}:#{port} connection refused"
+        exit 1
+      ensure
+        socket&.close
+      end
+
+      def parse_options(argv)
+        op = OptionParser.new
+        port = 443
+
+        op.on(
+          '-p',
+          '--port VALUE',
+          "server port number                (default #{port})"
+        ) do |v|
+          port = v
+        end
+
+        op.banner = <<~USAGE
+          Usage: echspec grease [OPTIONS...] {HOSTNAME}
+
+          Send GREASE ECH to a server and display retry_configs.
+
+          Examples:
+
+            $ echspec grease localhost
+            $ echspec grease -p 4433 localhost
+
+          Options:
+        USAGE
+
+        begin
+          args = op.parse(argv)
+        rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+          warn op
+          warn "** #{e.message}"
+          exit 1
+        end
+
+        if args.length != 1
+          warn op
+          warn '** {HOSTNAME} argument is not specified'
+          exit 1
+        end
+
+        [port, args[0]]
+      end
+    end
+  end
+end

data/lib/echspec/cli/resolve.rb

@@ -0,0 +1,86 @@
+module EchSpec
+  class CLI
+    class Resolve
+      include EchConfigPrinter
+      def execute(argv)
+        fpath, well_known, hostname = parse_options(argv)
+
+        result = if !fpath.nil?
+                   Spec::Spec9.parse_pem(File.read(fpath))
+                 elsif well_known
+                   Spec::Spec9.well_known_origin_svcb(hostname)
+                 else
+                   Spec::Spec9.resolve_ech_configs(hostname)
+                 end
+
+        case result
+        in Ok(ech_configs)
+          print_ech_configs(ech_configs)
+        in Err(details, _)
+          warn "** #{details}"
+          exit 1
+        end
+      end
+
+      # rubocop: disable Metrics/MethodLength
+      def parse_options(argv)
+        op = OptionParser.new
+        fpath = nil
+        well_known = false
+
+        op.on(
+          '-f',
+          '--file FILE',
+          'path to ECHConfigs PEM file       (default resolve ECHConfigs via DNS)'
+        ) do |v|
+          fpath = v
+        end
+
+        op.on(
+          '-w',
+          '--well-known',
+          'resolve ECHConfigs via well-known URI, instead of DNS'
+        ) do
+          well_known = true
+        end
+
+        op.banner = <<~USAGE
+          Usage: echspec resolve [OPTIONS...] [{HOSTNAME}]
+
+          Resolve ECHConfigs for a hostname and print fields.
+          {HOSTNAME} is required unless -f is specified.
+
+          Examples:
+
+            $ echspec resolve localhost
+            $ echspec resolve -w localhost
+            $ echspec resolve -f echconfigs.pem
+
+          Options:
+        USAGE
+
+        begin
+          args = op.parse(argv)
+        rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+          warn op
+          warn "** #{e.message}"
+          exit 1
+        end
+
+        if !fpath.nil? && !File.exist?(fpath)
+          warn '** {FILE} is not found'
+          exit 1
+        end
+
+        if fpath.nil? && args.length != 1
+          warn op
+          warn '** {HOSTNAME} argument is not specified'
+          exit 1
+        end
+
+        [fpath, well_known, args[0]]
+      end
+      # rubocop: enable Metrics/MethodLength
+    end
+  end
+end

data/lib/echspec/cli.rb

@@ -1,4 +1,7 @@
+require_relative 'cli/ech_config_printer'
 require_relative 'cli/gen_configs'
+require_relative 'cli/grease'
+require_relative 'cli/resolve'
 require_relative 'cli/run'
 
 module EchSpec
@@ -6,7 +9,7 @@ module EchSpec
     using Refinements
 
     def execute(argv = ARGV)
-      subcommands = %i[run gen_configs]
+      subcommands = %i[run gen_configs resolve grease]
 
       op = OptionParser.new
 

data/lib/echspec/spec/7.1-14.2.1.rb

@@ -43,7 +43,7 @@ module EchSpec
       # @return [EchSpec::Ok | Err]
       def do_validate_ee_retry_configs(hostname, port)
         with_socket(hostname, port) do |socket|
-          recv = send_ch_with_greased_ech(socket, hostname)
+          recv = TLS13Client.send_ch_with_greased_ech(socket, hostname, @stack)
           ex = recv.extensions[TTTLS13::Message::ExtensionType::ENCRYPTED_CLIENT_HELLO]
           return Err.new('did not send expected alert: encrypted_client_hello', message_stack) \
             unless ex.is_a?(TTTLS13::Message::Extension::ECHEncryptedExtensions)
@@ -53,76 +53,6 @@ module EchSpec
           Ok.new(nil)
         end
       end
-
-      # rubocop: disable Metrics/AbcSize
-      # rubocop: disable Metrics/MethodLength
-      def send_ch_with_greased_ech(socket, hostname)
-        # send ClientHello
-        conn = TLS13Client::Connection.new(socket, :client)
-        inner_ech = TTTLS13::Message::Extension::ECHClientHello.new_inner
-        exs, shared_secret = TLS13Client.gen_ch_extensions(hostname)
-        inner = TTTLS13::Message::ClientHello.new(
-          cipher_suites: TTTLS13::CipherSuites.new(
-            [
-              TTTLS13::CipherSuite::TLS_AES_256_GCM_SHA384,
-              TTTLS13::CipherSuite::TLS_CHACHA20_POLY1305_SHA256,
-              TTTLS13::CipherSuite::TLS_AES_128_GCM_SHA256
-            ]
-          ),
-          extensions: exs.merge(
-            TTTLS13::Message::ExtensionType::ENCRYPTED_CLIENT_HELLO => inner_ech
-          )
-        )
-        @stack << inner
-
-        ch = TTTLS13::Ech.new_greased_ch(inner, TTTLS13::Ech.new_grease_ech)
-        conn.send_record(
-          TTTLS13::Message::Record.new(
-            type: TTTLS13::Message::ContentType::HANDSHAKE,
-            messages: [ch],
-            cipher: TTTLS13::Cryptograph::Passer.new
-          )
-        )
-        @stack << ch
-
-        # receive ServerHello
-        recv, = conn.recv_message(TTTLS13::Cryptograph::Passer.new)
-        @stack << recv
-        raise Error::BeforeTargetSituationError, 'not received ServerHello' \
-          unless recv.is_a?(TTTLS13::Message::ServerHello) && !recv.hrr?
-
-        # receive EncryptedExtensions
-        transcript = TTTLS13::Transcript.new
-        transcript[TTTLS13::CH] = [ch, ch.serialize]
-        sh = recv
-        transcript[TTTLS13::SH] = [sh, sh.serialize]
-        kse = sh.extensions[TTTLS13::Message::ExtensionType::KEY_SHARE]
-                .key_share_entry.first
-        key_schedule = TTTLS13::KeySchedule.new(
-          psk: nil,
-          shared_secret: shared_secret.build(kse.group, kse.key_exchange),
-          cipher_suite: sh.cipher_suite,
-          transcript:
-        )
-        hs_rcipher = TTTLS13::Endpoint.gen_cipher(
-          sh.cipher_suite,
-          key_schedule.server_handshake_write_key,
-          key_schedule.server_handshake_write_iv
-        )
-        recv, = conn.recv_message(hs_rcipher)
-        @stack << recv
-        if recv.is_a?(TTTLS13::Message::ChangeCipherSpec)
-          recv, = conn.recv_message(hs_rcipher)
-          @stack << recv
-        end
-
-        raise Error::BeforeTargetSituationError, 'not received EncryptedExtensions' \
-          unless recv.is_a?(TTTLS13::Message::EncryptedExtensions)
-
-        recv
-      end
-      # rubocop: enable Metrics/AbcSize
-      # rubocop: enable Metrics/MethodLength
     end
   end
 end

data/lib/echspec/spec/9.rb

@@ -83,6 +83,74 @@ module EchSpec
           Ok.new(ECHConfig.decode_vectors(octet.slice(2..)))
         end
 
+        # @param hostname [String]
+        #
+        # @return [EchSpec::Ok<Array<ECHConfig>> | Err]
+        def well_known_origin_svcb(hostname)
+          res = fetch_well_known(hostname)
+          body = case res
+                 in Ok(obj)
+                   obj
+                 in Err
+                   return res
+                 end
+
+          parse_origin_svcb(body)
+        end
+
+        # https://datatracker.ietf.org/doc/html/draft-ietf-tls-wkech-12
+        WK_ECH_PATH = '/.well-known/origin-svcb'.freeze
+        private_constant :WK_ECH_PATH
+
+        # @param hostname [String]
+        #
+        # @return [EchSpec::Ok | Err]
+        def fetch_well_known(hostname)
+          uri = URI("https://#{hostname}#{WK_ECH_PATH}")
+          res = Net::HTTP.get_response(uri)
+          return Err.new("GET #{uri} returned #{res.code}.", nil) unless res.is_a?(Net::HTTPSuccess)
+
+          Ok.new(res.body)
+        rescue StandardError => e
+          Err.new(e.message, nil)
+        end
+
+        # {
+        #   "regeninterval": 3600,
+        #   "endpoints": [
+        #     {
+        #       "priority": 1,
+        #       "params": {
+        #         "ipv4hint": [ "192.0.2.1", "192.0.2.254" ],
+        #         "ech": "AD7+DQA6NAAgACCn3zNTeX/WOD...AAA==",
+        #         "ipv6hint": [ "2001:DB::ec4" ],
+        #         "alpn": [ "h2", "http/1.1" ]
+        #       }
+        #     }
+        #   ]
+        # }
+        #
+        # https://datatracker.ietf.org/doc/html/draft-ietf-tls-wkech-12#section-5
+        #
+        # @param body [String]
+        #
+        # @return [EchSpec::Ok | Err]
+        def parse_origin_svcb(body)
+          h = JSON.parse(body)
+          echs = h['endpoints']&.filter_map { |e| e.dig('params', 'ech') }
+          return Err.new('The origin-svcb well-known resource does NOT have ech SvcParams.', nil) if echs.nil? || echs.empty?
+
+          # if parsing any one of the ech values fails, return Err
+          ech_configs = echs.flat_map do |ech|
+            octet = Base64.decode64(ech)
+            ECHConfig.decode_vectors(octet.slice(2..))
+          end
+
+          Ok.new(ech_configs)
+        rescue StandardError => e
+          Err.new(e.message, nil)
+        end
+
         # @param pem [String]
         #
         # @return [EchSpec::Ok<Array<ECHConfig>> | Err]

data/lib/echspec/tls13_client.rb

@@ -1,4 +1,5 @@
 module EchSpec
+  # rubocop: disable Metrics/ModuleLength
   module TLS13Client
     class Connection < TTTLS13::Connection
       # @param socket [Socket]
@@ -95,6 +96,84 @@ module EchSpec
         ch1.extensions.merge(exs)
       end
 
+      # @param socket [TCPSocket]
+      # @param hostname [String]
+      # @param stack [EchSpec::Log::MessageStack | nil]
+      #
+      # @raise [EchSpec::Error::BeforeTargetSituationError]
+      #
+      # @return [TTTLS13::Message::EncryptedExtensions]
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/MethodLength
+      # rubocop: disable Metrics/PerceivedComplexity
+      def send_ch_with_greased_ech(socket, hostname, stack = nil)
+        conn = TLS13Client::Connection.new(socket, :client)
+        inner_ech = TTTLS13::Message::Extension::ECHClientHello.new_inner
+        exs, shared_secret = TLS13Client.gen_ch_extensions(hostname)
+        inner = TTTLS13::Message::ClientHello.new(
+          cipher_suites: TTTLS13::CipherSuites.new(
+            [
+              TTTLS13::CipherSuite::TLS_AES_256_GCM_SHA384,
+              TTTLS13::CipherSuite::TLS_CHACHA20_POLY1305_SHA256,
+              TTTLS13::CipherSuite::TLS_AES_128_GCM_SHA256
+            ]
+          ),
+          extensions: exs.merge(
+            TTTLS13::Message::ExtensionType::ENCRYPTED_CLIENT_HELLO => inner_ech
+          )
+        )
+        stack << inner if stack
+
+        ch = TTTLS13::Ech.new_greased_ch(inner, TTTLS13::Ech.new_grease_ech)
+        conn.send_record(
+          TTTLS13::Message::Record.new(
+            type: TTTLS13::Message::ContentType::HANDSHAKE,
+            messages: [ch],
+            cipher: TTTLS13::Cryptograph::Passer.new
+          )
+        )
+        stack << ch if stack
+
+        recv, = conn.recv_message(TTTLS13::Cryptograph::Passer.new)
+        stack << recv if stack
+        raise Error::BeforeTargetSituationError, 'not received ServerHello' \
+          unless recv.is_a?(TTTLS13::Message::ServerHello) && !recv.hrr?
+
+        transcript = TTTLS13::Transcript.new
+        transcript[TTTLS13::CH] = [ch, ch.serialize]
+        sh = recv
+        transcript[TTTLS13::SH] = [sh, sh.serialize]
+        kse = sh.extensions[TTTLS13::Message::ExtensionType::KEY_SHARE]
+                .key_share_entry.first
+        key_schedule = TTTLS13::KeySchedule.new(
+          psk: nil,
+          shared_secret: shared_secret.build(kse.group, kse.key_exchange),
+          cipher_suite: sh.cipher_suite,
+          transcript:
+        )
+        hs_rcipher = TTTLS13::Endpoint.gen_cipher(
+          sh.cipher_suite,
+          key_schedule.server_handshake_write_key,
+          key_schedule.server_handshake_write_iv
+        )
+        recv, = conn.recv_message(hs_rcipher)
+        stack << recv if stack
+        if recv.is_a?(TTTLS13::Message::ChangeCipherSpec)
+          recv, = conn.recv_message(hs_rcipher)
+          stack << recv if stack
+        end
+
+        raise Error::BeforeTargetSituationError, 'not received EncryptedExtensions' \
+          unless recv.is_a?(TTTLS13::Message::EncryptedExtensions)
+
+        recv
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/PerceivedComplexity
+
       # @param conf [ECHConfig::ECHConfigContents::HpkeKeyConfig]
       #
       # @return [Boolean]
@@ -164,4 +243,5 @@ module EchSpec
       # rubocop: enable Metrics/MethodLength
     end
   end
+  # rubocop: enable Metrics/ModuleLength
 end

data/lib/echspec/version.rb

@@ -1,3 +1,3 @@
 module EchSpec
-  VERSION = '0.0.6'.freeze
+  VERSION = '0.0.7'.freeze
 end

data/lib/echspec.rb

@@ -1,4 +1,6 @@
 require 'base64'
+require 'json'
+require 'net/http'
 require 'optparse'
 require 'pp'
 require 'resolv'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: echspec
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - thekuwayama
@@ -101,7 +101,10 @@ files:
 - fixtures/server.key
 - lib/echspec.rb
 - lib/echspec/cli.rb
+- lib/echspec/cli/ech_config_printer.rb
 - lib/echspec/cli/gen_configs.rb
+- lib/echspec/cli/grease.rb
+- lib/echspec/cli/resolve.rb
 - lib/echspec/cli/run.rb
 - lib/echspec/error.rb
 - lib/echspec/log.rb