ddig 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1bcdd660ab21b14d2e5572b27a50f2cc0fe541c64b9c6c8502f85d89a29b28
-  data.tar.gz: 6462363f2b075b9aad78f88a055e1d53af1901054a22c3a010fcdfb0a28e9fde
+  metadata.gz: e1a65973ea90a0410cf7c2bd8846431d1b46f6bfec521cde944deba86c83effc
+  data.tar.gz: 4eaf90cdfabfe53095f4a5f4ca5f034b0d79296e0ff64da53a00cd4c71de6d04
 SHA512:
-  metadata.gz: 785ef898b4f773668131d56ed8596b11de8bfbe9908cc0de7383a2b0cfbb3aaf613dc813b73284382aaa6bbb3d9e89d6e4a45e0d1205aba45361213d6764cc19
-  data.tar.gz: c12f638d1899ddb47e6c482b22b315ea8912bce701243fef37a239566653e5e216c8ed01b910105bc06c28843e9d40ef81d653923e1b95a2e386f18c18f2fc72
+  metadata.gz: 675a844c854c9bb5d63cac33742cc88e7a712356b41dc1fd61c4a646112ee1080a887218b3f8a6c949c0277c2d7f01851d1f30f3258138c2a57c467f4570c448
+  data.tar.gz: bdf9aa4945b93c190716a5809829cc11e2fd58584d0620b48f0793ae5085b3cb5e77b6f0cac2c28303f2dbb3e1c988e3b5f989f80de49049cb6fe5d3420212a8

data/README.md

@@ -7,10 +7,13 @@ ddig is DNS lookup utility for Ruby.
 - DNS Resolvers
   - UDP (Do53)
   - DoT (DNS over TLS)
-    - https://datatracker.ietf.org/doc/html/rfc7858
-  - ~~DoH (DNS over HTTPS)~~
-    - Not yet Supported
-    - https://datatracker.ietf.org/doc/html/rfc8484
+    - https://www.rfc-editor.org/rfc/rfc7858.html
+  - DoH (DNS over HTTPS)
+    - Support only HTTP/1.1
+    - https://www.rfc-editor.org/rfc/rfc8484.html
+  - ~~DoQ (DNS over QUIC)~~
+    - Not Supported
+    - https://www.rfc-editor.org/rfc/rfc9250.html
 - DDR (Discovery of Designated Resolvers)
   - https://www.rfc-editor.org/rfc/rfc9462.html
 
@@ -25,6 +28,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
     $ gem install ddig
 
 ## Usage
+### Ruby
 
 ```ruby
 ddig = Ddig.lookup('dns.google', nameservers: ['8.8.8.8', '2001:4860:4860::8888'])
@@ -83,9 +87,96 @@ ddig[:ddr]
 ]
 ```
 
+- Do53
+```ruby
+do53 = Ddig::Resolver::Do53.new(hostname: 'dns.google', nameservers: '8.8.8.8').lookup
+=> #<Ddig::Resolver::Do53:0x0000000121717b78 @a=["8.8.8.8", "8.8.4.4"], @aaaa=["2001:4860:4860::8844", "2001:4860:4860::8888"], @hostname="dns.google", @ip=nil, @nameserver=#<Ddig::Nameserver:0x00000001211fb108 @nameservers="8.8.8.8", @servers=["8.8.8.8"]>, @nameservers=["8.8.8.8"]>
+
+do53.a
+=> ["8.8.4.4", "8.8.8.8"]
+do53.aaaa
+=> ["2001:4860:4860::8844", "2001:4860:4860::8888"]
+```
+
+- DoT
+```ruby
+dot = Ddig::Resolver::Dot.new(hostname: 'dns.google', server: '8.8.8.8').lookup
+=> #<Ddig::Resolver::Dot:0x000000012145da90 @a=["8.8.8.8", "8.8.4.4"], @aaaa=["2001:4860:4860::8844", "2001:4860:4860::8888"], @hostname="dns.google", @open_timeout=3, @port=853, @server="8.8.8.8", @server_name=nil>
+
+dot.a
+=> ["8.8.4.4", "8.8.8.8"]
+dot.aaaa
+=> ["2001:4860:4860::8844", "2001:4860:4860::8888"]
+```
+
+- DoH (HTTP/1.1)
+```ruby
+doh = Ddig::Resolver::DohH1.new(hostname: 'dns.google', server: 'dns.google', dohpath: '/dns-query{?dns}').lookup
+=> #<Ddig::Resolver::DohH1:0x00000001023ed020 @a=["8.8.4.4", "8.8.8.8"], @aaaa=["2001:4860:4860::8888", "2001:4860:4860::8844"], @address=nil, @dohpath="/dns-query{?dns}", @hostname="dns.google", @open_timeout=10, @port=443, @server="dns.google">
+
+doh.a
+=> ["8.8.4.4", "8.8.8.8"]
+doh.aaaa
+=> ["2001:4860:4860::8844", "2001:4860:4860::8888"]
+```
+
 ### CLI
+- Usage
+```
+$ ddig --help
+Usage: ddig [options] hostname
+    -d, --dns-type={all|do53|dot}    resolve type (default: all)
+        --udp                        use resolve type of udp(do53)
+        --dot                        use resolve type of dot
+        --doh-h1                     use resolve type of doh (http/1.1)
+        --doh-path=doh-path          doh service path
+    -4, --ipv4                       use IPv4 query transport only
+    -6, --ipv6                       use IPv6 query transport only
+    -@ipaddress|doh-hostname,        nameserver
+        --nameserver
+    -p, --port=port                  port
+        --format={text|json}         output format (default: text)
+
+    -v, --verbose                    run verbosely
+    -h, --help                       show this help message.
+        --version                    show version.
+```
+
+- UDP(Do53)
+```sh
+$ ddig --udp --nameserver 8.8.8.8 dns.google
+dns.google	A	8.8.8.8
+dns.google	A	8.8.4.4
+dns.google	AAAA	2001:4860:4860::8844
+dns.google	AAAA	2001:4860:4860::8888
+
+# SERVER: 8.8.8.8
+```
+
+- DoT
+```sh
+$ ddig --dot --nameserver 8.8.8.8 dns.google
+dns.google	A	8.8.8.8
+dns.google	A	8.8.4.4
+dns.google	AAAA	2001:4860:4860::8888
+dns.google	AAAA	2001:4860:4860::8844
 
-(TBD)
+# SERVER(Address): 8.8.8.8
+# PORT: 853
+```
+
+- DoH (HTTP/1.1)
+```sh
+$ ddig --doh-h1 --nameserver dns.google --doh-path /dns-query{?dns} dns.google
+dns.google	A	8.8.8.8
+dns.google	A	8.8.4.4
+dns.google	AAAA	2001:4860:4860::8888
+dns.google	AAAA	2001:4860:4860::8844
+
+# SERVER(Hostname): dns.google
+# SERVER(Path): /dns-query{?dns}
+# PORT: 443
+```
 
 ## Development
 

data/lib/ddig/cli.rb

@@ -7,6 +7,7 @@ module Ddig
     def initialize(args)
       @args = args
       @options = {
+        dns_type: 'all',
         format: 'text',
       }
 
@@ -22,7 +23,15 @@ module Ddig
       @option_parser = OptionParser.new do |opts|
         opts.banner = "Usage: ddig [options] hostname"
 
-        opts.on("--nameserver=ipaddress", "nameserver ip address") { |v| @options[:nameserver] = v }
+        opts.on("-d", "--dns-type={all|do53|dot}", "resolve type (default: all)") { |v| @options[:dns_type] = v }
+        opts.on("--udp", "use resolve type of udp(do53)") { |v| @options[:dns_type] = 'do53' }
+        opts.on("--dot", "use resolve type of dot") { |v| @options[:dns_type] = 'dot' }
+        opts.on("--doh-h1", "use resolve type of doh (http/1.1)") { |v| @options[:dns_type] = 'doh_h1' }
+        opts.on("--doh-path=doh-path", "doh service path") { |v| @options[:doh_path] = v }
+        opts.on("-4", "--ipv4", "use IPv4 query transport only") { |v| @options[:ipv4] = v }
+        opts.on("-6", "--ipv6", "use IPv6 query transport only") { |v| @options[:ipv6] = v }
+        opts.on("-@", "--nameserver=ipaddress|doh-hostname", "nameserver") { |v| @options[:nameserver] = v }
+        opts.on("-p", "--port=port", "port") { |v| @options[:port] = v }
         opts.on("--format={text|json}", "output format (default: text)") { |v| @options[:format] = v }
 
         opts.separator ""
@@ -38,18 +47,95 @@ module Ddig
     end
 
     def exec
-      @ddig = Ddig.lookup(@hostname, nameservers: [@options[:nameserver]])
+      if @options[:ipv4] || @options[:ipv6]
+        @use_ipv4 = @options[:ipv4] || false
+        @use_ipv6 = @options[:ipv6] || false
+      end
+
+      case @options[:dns_type]
+      when "all"
+        resolve_all
+      when "do53"
+        resolve_do53
+      when "dot"
+        resolve_dot
+      when "doh_h1"
+        resolve_doh_h1
+      end
+    end
+
+    def resolve_all
+      @ddig = Ddig.lookup(@hostname, nameservers: @options[:nameserver], use_ipv4: @use_ipv4, use_ipv6: @use_ipv6)
 
       if @options[:format] == 'json'
         # TODO: to_json
         puts @ddig
       else
-        print_result
+        puts @ddig
+      end
+    end
+
+    def resolve_do53
+      ip = Ddig::Ip.new(use_ipv4: @use_ipv4, use_ipv6: @use_ipv6)
+      do53 = Ddig::Resolver::Do53.new(hostname: @hostname, nameservers: @options[:nameserver], ip: ip.ip_type).lookup
+
+      if do53.nil?
+        puts "Error: Could not lookup wit nameserver: #{@options[:nameserver]}"
+        exit
+      end
+
+      do53.a.each do |address|
+        rr_type = 'A'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
+      end
+      do53.aaaa.each do |address|
+        rr_type = 'AAAA'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
       end
+
+      puts
+      puts "# SERVER: #{do53.nameservers.join(', ')}"
+    end
+
+    def resolve_dot
+      dot = Ddig::Resolver::Dot.new(hostname: @hostname, server: @options[:nameserver], port: @options[:port]).lookup
+
+      dot.a.each do |address|
+        rr_type = 'A'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
+      end
+      dot.aaaa.each do |address|
+        rr_type = 'AAAA'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
+      end
+
+      puts
+      puts "# SERVER(Address): #{dot.server}"
+      #puts "# SERVER(Hostname): #{dot.server_name}"
+      puts "# PORT: #{dot.port}"
     end
 
-    def print_result
-      puts @ddig
+    def resolve_doh_h1
+      if @options[:nameserver].nil? || @options[:doh_path].nil?
+        puts 'ddig: doh needs option of --doh-path=doh-path'
+        exit
+      end
+
+      doh = Ddig::Resolver::DohH1.new(hostname: @hostname, server: @options[:nameserver], dohpath: @options[:doh_path], port: @options[:port]).lookup
+
+      doh.a.each do |address|
+        rr_type = 'A'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
+      end
+      doh.aaaa.each do |address|
+        rr_type = 'AAAA'
+        puts "#{@hostname}\t#{rr_type}\t#{address}"
+      end
+
+      puts
+      puts "# SERVER(Hostname): #{doh.server}"
+      puts "# SERVER(Path): #{doh.dohpath}"
+      puts "# PORT: #{doh.port}"
     end
   end
 end

data/lib/ddig/ddr.rb

@@ -68,35 +68,39 @@ module Ddig
           do53_v6 = ::Ddig::Resolver::Do53.new(hostname: target, nameservers: [unencrypted_resolver], ip: :ipv6).lookup
 
           # ipv4
-          unless do53_v4.nil? || do53_v4.a.nil?
-            do53_v4.a.each do |address|
-              designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv4)
-              @designated_resolvers << designated_resolver
+          unless @ip == :ipv6
+            unless do53_v4.nil? || do53_v4.a.nil?
+              do53_v4.a.each do |address|
+                designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv4)
+                @designated_resolvers << designated_resolver
+              end
             end
-          end
-          unless do53_v6.nil? || do53_v6.a.nil?
-            do53_v6.a.each do |address|
-              designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv4)
-              @designated_resolvers << designated_resolver
+            unless do53_v6.nil? || do53_v6.a.nil?
+              do53_v6.a.each do |address|
+                designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv4)
+                @designated_resolvers << designated_resolver
+              end
             end
           end
 
           # ipv6
-          unless do53_v4.nil? || do53_v4.aaaa.nil?
-            do53_v4.aaaa.each do |address|
-              designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv6)
-              @designated_resolvers << designated_resolver
+          unless @ip == :ipv4
+            unless do53_v4.nil? || do53_v4.aaaa.nil?
+              do53_v4.aaaa.each do |address|
+                designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv6)
+                @designated_resolvers << designated_resolver
+              end
             end
-          end
-          unless do53_v6.nil? || do53_v6.aaaa.nil?
-            do53_v6.aaaa.each do |address|
-              designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv6)
-              @designated_resolvers << designated_resolver
+            unless do53_v6.nil? || do53_v6.aaaa.nil?
+              do53_v6.aaaa.each do |address|
+                designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: :ipv6)
+                @designated_resolvers << designated_resolver
+              end
             end
           end
 
           # ipv4hint
-          unless ipv4hint.nil?
+          unless ipv4hint.nil? || @ip == :ipv6
             ipv4hint.each do |address|
               ip = :ipv4
               designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: ip)
@@ -105,7 +109,7 @@ module Ddig
           end
 
           # ipv6hint
-          unless ipv6hint.nil?
+          unless ipv6hint.nil? || @ip == :ipv4
             ipv6hint.each do |address|
               ip = :ipv6
               designated_resolver = ::Ddig::Ddr::DesignatedResolver.new(unencrypted_resolver: unencrypted_resolver, target: target, protocol: protocol, port: port, dohpath: dohpath, address: address.to_s, ip: ip)

data/lib/ddig/ip.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ddig
+  class Ip
+    attr_reader :ip_type
+
+    def initialize(use_ipv4: nil, use_ipv6: nil)
+      @use_ipv4 = use_ipv4
+      @use_ipv6 = use_ipv6
+
+      set_ip_type
+    end
+
+    def set_ip_type
+      if @use_ipv4.nil? && self.class.enable_ipv4?
+        @use_ipv4 = true
+      end
+
+      if @use_ipv6.nil? && self.class.enable_ipv6?
+        @use_ipv6 = true
+      end
+
+      if @use_ipv4 && @use_ipv6
+        @ip_type = :all
+      elsif @use_ipv4
+        @ip_type = :ipv4
+      elsif @use_ipv6
+        @ip_type = :ipv6
+      end
+    end
+
+    def self.enable_ipv4?
+      ip_list.any? { |addr| addr.ipv4? }
+    end
+
+    def self.enable_ipv6?
+      ip_list.any? { |addr| addr.ipv6? }
+    end
+
+    private
+
+    def self.ip_list
+      Socket.ip_address_list.map do |addrinfo|
+        if RUBY_VERSION < '3.1'
+          # for ipaddr gem <= v1.2.2, Not support zone identifiers in IPv6 addresses
+          addr = IPAddr.new(addrinfo.ip_address.split('%').first)
+        else
+          addr = IPAddr.new(addrinfo.ip_address)
+        end
+
+        if !addr.loopback? && !addr.link_local?
+          addr
+        end
+      end.compact
+    end
+  end
+end

data/lib/ddig/resolver/dns_message.rb

@@ -0,0 +1,40 @@
+require 'resolv'
+
+module Ddig
+  module Resolver
+    class DnsMessage
+      def self.encode(hostname, typeclass)
+        if hostname.nil?
+          return nil
+        end
+        if typeclass.nil?
+          return nil
+        end
+
+        message = Resolv::DNS::Message.new
+        message.rd = 1 # recursive query
+        message.add_question(hostname, typeclass)
+
+        message.encode
+      end
+
+      def self.decode(payload)
+        if payload.nil?
+          return nil
+        end
+
+        Resolv::DNS::Message.decode(payload)
+      end
+
+      def self.getresources(payload)
+        if payload.nil?
+          return []
+        end
+
+        response = self.decode(payload)
+
+        return response.answer.map { |name, ttl, resource| resource }
+      end
+    end
+  end
+end

data/lib/ddig/resolver/doh_h1.rb

@@ -0,0 +1,61 @@
+require 'net/http'
+require 'resolv'
+require 'base64'
+
+require_relative 'dns_message'
+
+module Ddig
+  module Resolver
+    # DNS over HTTPS (HTTP/1.1)
+    class DohH1
+      attr_reader :hostname, :server, :address, :dohpath, :port
+      attr_reader :a, :aaaa
+
+      def initialize(hostname:, server:, address: nil, dohpath:, port: 443)
+        @hostname = hostname
+        @server = server
+        @address = address
+        @dohpath = dohpath
+        @port = port || 443
+
+        @open_timeout = 10
+      end
+
+      def lookup
+        if @server.nil?
+          return nil
+        end
+
+        @a = get_resources(@hostname, Resolv::DNS::Resource::IN::A).map { |resource| resource.address.to_s if resource.is_a?(Resolv::DNS::Resource::IN::A) }.compact
+
+        @aaaa = get_resources(@hostname, Resolv::DNS::Resource::IN::AAAA).map { |resource| resource.address.to_s if resource.is_a?(Resolv::DNS::Resource::IN::AAAA) }.compact
+
+        self
+      end
+
+      def get_resources(hostname, typeclass)
+        # send query
+        payload = DnsMessage.encode(hostname, typeclass)
+
+        path_with_query = @dohpath.gsub('{?dns}', '?dns=' + Base64.urlsafe_encode64(payload, padding: false))
+
+        http_response = Net::HTTP.start(@server, @port, use_ssl: true, ipaddr: @address) do |http|
+          header = {}
+          header['Accept'] = 'application/dns-message'
+          #http.open_timeout = @open_timeout
+
+          http.get(path_with_query, header)
+        end
+
+        case http_response
+        when Net::HTTPSuccess
+          # recive answer
+          return DnsMessage.getresources(http_response.body)
+        else
+          http_response.value
+          return []
+        end
+      end
+    end
+  end
+end

data/lib/ddig/resolver/dot.rb

@@ -1,6 +1,8 @@
 require 'openssl'
 require 'resolv'
 
+require_relative 'dns_message'
+
 module Ddig
   module Resolver
     # DNS over TLS/TCP
@@ -12,7 +14,7 @@ module Ddig
         @hostname = hostname
         @server = server
         @server_name = server_name
-        @port = port
+        @port = port || 853
 
         @open_timeout = 3
       end
@@ -33,16 +35,14 @@ module Ddig
         ssl_socket = get_socket
 
         # send query
-        message = dns_message(hostname, typeclass)
+        payload = DnsMessage.encode(hostname, typeclass)
+        request = [payload.length].pack('n') + payload
 
-        request = [message.encode.length].pack('n') + message.encode
         ssl_socket.write(request)
 
         # recive answer
         len = ssl_socket.read(2).unpack1('n')
-        response = Resolv::DNS::Message.decode(ssl_socket.read(len))
-
-        resources = response.answer.map { |name, ttl, resource| resource }
+        resources = DnsMessage.getresources(ssl_socket.read(len))
 
         resources
       end
@@ -74,21 +74,6 @@ module Ddig
           ssl_socket
         end
       end
-
-      def dns_message(hostname, typeclass)
-        if hostname.nil?
-          return nil
-        end
-        if typeclass.nil?
-          return nil
-        end
-
-        message = Resolv::DNS::Message.new
-        message.rd = 1 # recursive query
-        message.add_question(hostname, typeclass)
-
-        message
-      end
     end
   end
 end

data/lib/ddig/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ddig
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ddig.rb

@@ -2,23 +2,28 @@
 
 require_relative "ddig/version"
 require_relative "ddig/nameserver"
+require_relative "ddig/ip"
 require_relative "ddig/resolver/do53"
 require_relative "ddig/resolver/dot"
+require_relative "ddig/resolver/doh_h1"
 require_relative "ddig/ddr"
 
 module Ddig
   class Error < StandardError; end
 
-  def self.lookup(hostname, nameservers: nil)
+  def self.lookup(hostname, nameservers: nil, use_ipv4: nil, use_ipv6: nil)
     @hostname = hostname
     @nameservers = nameservers
+    @use_ipv4 = use_ipv4
+    @use_ipv6 = use_ipv6
 
     @nameserver = Ddig::Nameserver.new(nameservers: @nameservers)
+    @ip = Ddig::Ip.new(use_ipv4: @use_ipv4, use_ipv6: @use_ipv6)
 
-    @do53_ipv4 = Ddig::Resolver::Do53.new(hostname: @hostname, nameservers: @nameserver.servers, ip: :ipv4).lookup
-    @do53_ipv6 = Ddig::Resolver::Do53.new(hostname: @hostname, nameservers: @nameserver.servers, ip: :ipv6).lookup
+    @do53_ipv4 = Ddig::Resolver::Do53.new(hostname: @hostname, nameservers: @nameserver.servers, ip: :ipv4).lookup unless @ip.ip_type == :ipv6
+    @do53_ipv6 = Ddig::Resolver::Do53.new(hostname: @hostname, nameservers: @nameserver.servers, ip: :ipv6).lookup unless @ip.ip_type == :ipv4
 
-    @ddr = Ddig::Ddr.new(nameservers: @nameservers)
+    @ddr = Ddig::Ddr.new(nameservers: @nameservers, ip: @ip.ip_type)
 
     {
       do53: {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddig
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Taketo Takashima
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-16 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resolv
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: DNS lookup utility for Ruby
 email:
 - t.taketo1113@gmail.com
@@ -42,8 +56,11 @@ files:
 - lib/ddig/ddr.rb
 - lib/ddig/ddr/designated_resolver.rb
 - lib/ddig/ddr/verify_cert.rb
+- lib/ddig/ip.rb
 - lib/ddig/nameserver.rb
+- lib/ddig/resolver/dns_message.rb
 - lib/ddig/resolver/do53.rb
+- lib/ddig/resolver/doh_h1.rb
 - lib/ddig/resolver/dot.rb
 - lib/ddig/version.rb
 - sig/ddig.rbs