dnsruby 1.74.0 → 2.0.0

data/lib/dnsruby/code_mappers.rb

@@ -2,6 +2,31 @@ module Dnsruby
 
   require 'dnsruby/code_mapper'
 
+  # DNS types and classes are unsigned 16-bit values. Other CodeMapper
+  # subclasses may use different value types or ranges.
+  module RRCodeRange #:nodoc: all
+    def self.check(code)
+      unless code.is_a?(Integer) && code.between?(0, 0xffff)
+        raise ArgumentError, "DNS type/class code must be an integer in 0..65535, got #{code.inspect}"
+      end
+      code
+    end
+
+    def initialize(arg)
+      super
+      # Registered names and copies of mutable mapper objects need checking too.
+      RRCodeRange.check(@code)
+      if arg.is_a?(self.class) && arg.string.is_a?(String) &&
+          self.class.to_code(arg.string).nil? &&
+          (is_a?(Classes) ? /\ACLASS\d+\z/i : /\ATYPE\d+\z/i).match?(arg.string)
+        # Keep unregistered numeric spellings on the copy. Registered names
+        # use the current preferred alias from CodeMapper.
+        @string = arg.string
+      end
+    end
+  end
+  private_constant :RRCodeRange
+
   class OpCode < CodeMapper
     Query = 0        # RFC 1035
     IQuery = 1        # RFC 1035
@@ -42,6 +67,8 @@ module Dnsruby
   end
 
   class Classes < CodeMapper
+    include RRCodeRange
+
     IN        = 1       # RFC 1035
     CH        = 3       # RFC 1035
     #     CHAOS        = 3       # RFC 1035
@@ -52,16 +79,20 @@ module Dnsruby
     update()
 
     def unknown_string(arg)
-      if (arg=~/^CLASS/i)
-        Classes.add_pair(arg, arg.gsub('CLASS', '').to_i)
-        set_string(arg)
+      if (match = /\ACLASS(\d+)\z/i.match(arg))
+        # Store one name per code so case and leading-zero variants cannot
+        # fill the global mapping table.
+        unknown_code(match[1].to_i)
+        # Keep the supplied spelling on this object without registering it.
+        @string = arg.dup.freeze
       else
         raise ArgumentError.new("String #{arg} not a member of #{self.class}")
       end
     end
 
     def unknown_code(arg)
-      Classes.add_pair('CLASS' + arg.to_s, arg)
+      RRCodeRange.check(arg)
+      Classes.add_pair('CLASS' + arg.to_s, arg) unless Classes.to_string(arg)
       set_code(arg)
     end
 
@@ -73,37 +104,29 @@ module Dnsruby
       name = name.upcase
 
       if to_code(name)
-        return to_code(name)
+        return RRCodeRange.check(to_code(name))
       end
 
-      if ((name =~/^\s*CLASS(\d+)\s*$/o) == nil)
+      if ((name =~/\A\s*CLASS(\d+)\s*\z/o) == nil)
         raise ArgumentError, "classesbyval() argument is not CLASS### (#{name})"
       end
 
-      val = $1.to_i
-      if val > 0xffff
-        raise ArgumentError, 'classesbyval() argument larger than ' + 0xffff
-      end
-
-      return val;
+      RRCodeRange.check($1.to_i)
     end
 
 
 
     def Classes.classesbyval(val) #:nodoc: all
       if (val.class == String)
-        if ((val =~ /^\s*0*([0-9]+)\s*$/) == nil)
+        if ((val =~ /\A\s*([0-9]+)\s*\z/) == nil)
           raise ArgumentError,  "classesbybal() argument is not numeric (#{val})" # unless  val.gsub!("^\s*0*([0-9]+)\s*$", "$1")
           #           val =~ s/^\s*0*([0-9]+)\s*$/$1/o;#
         end
         val = $1.to_i
       end
 
-      return to_string(val) if to_string(val)
-
-      raise ArgumentError,  'classesbyval() argument larger than ' + 0xffff if val > 0xffff;
-
-      return "CLASS#{val}";
+      RRCodeRange.check(val)
+      to_string(val) || "CLASS#{val}"
     end
   end
 
@@ -111,6 +134,8 @@ module Dnsruby
   # 
   #  New RR types should be added to this set
   class Types < CodeMapper
+    include RRCodeRange
+
     SIGZERO   = 0       # RFC2931 consider this a pseudo type
     A         = 1       # RFC 1035, Section 3.4.1
     NS        = 2       # RFC 1035, Section 3.3.11
@@ -150,7 +175,7 @@ module Dnsruby
     KX        = 36      # RFC 2230
     CERT      = 37      # RFC 2538
     DNAME     = 39      # RFC 2672
-    OPT       = 41      # RFC 2671
+    OPT       = 41      # RFC 6891
     APL       = 42      # RFC 3123
     DS        = 43      # RFC 4034
     SSHFP     = 44      # RFC 4255
@@ -165,13 +190,15 @@ module Dnsruby
     HIP       = 55      # RFC 5205
     CDS       = 59      # RFC 7344
     CDNSKEY   = 60      # RFC 7344
+    SVCB      = 64      # RFC 9460
+    HTTPS     = 65      # RFC 9460
     SPF       = 99      # RFC 4408
     UINFO     = 100     # non-standard
     UID       = 101     # non-standard
     GID       = 102     # non-standard
     UNSPEC    = 103     # non-standard
     TKEY      = 249     # RFC 2930
-    TSIG      = 250     # RFC 2931
+    TSIG      = 250     # RFC 8945, Section 4.1
     IXFR      = 251     # RFC 1995
     AXFR      = 252     # RFC 1035
     MAILB     = 253     # RFC 1035 (MB, MG, MR)
@@ -183,16 +210,18 @@ module Dnsruby
     update()
 
     def unknown_string(arg) #:nodoc: all
-      if (arg=~/^TYPE/i)
-        Types.add_pair(arg, arg.gsub('TYPE', '').to_i)
-        set_string(arg)
+      if (match = /\ATYPE(\d+)\z/i.match(arg))
+        # Store one name per code; keep alternate spellings on this object.
+        unknown_code(match[1].to_i)
+        @string = arg.dup.freeze
       else
         raise ArgumentError.new("String #{arg} not a member of #{self.class}")
       end
     end
 
     def unknown_code(arg) #:nodoc: all
-      Types.add_pair('TYPE' + arg.to_s, arg)
+      RRCodeRange.check(arg)
+      Types.add_pair('TYPE' + arg.to_s, arg) unless Types.to_string(arg)
       set_code(arg)
     end
 
@@ -206,20 +235,15 @@ module Dnsruby
       name = name.upcase
 
       if to_code(name)
-        return to_code(name)
+        return RRCodeRange.check(to_code(name))
       end
 
 
-      if ((name =~/^\s*TYPE(\d+)\s*$/o)==nil)
+      if ((name =~/\A\s*TYPE(\d+)\s*\z/o)==nil)
         raise ArgumentError, "Net::DNS::typesbyname() argument (#{name}) is not TYPE###"
       end
 
-      val = $1.to_i
-      if val > 0xffff
-        raise ArgumentError, 'Net::DNS::typesbyname() argument larger than ' + 0xffff
-      end
-
-      return val;
+      RRCodeRange.check($1.to_i)
     end
 
 
@@ -227,29 +251,17 @@ module Dnsruby
     #  code. If the TYPE mapping is not specified the generic mnemonic
     #  TYPE### is returned.
     def Types.typesbyval(val) #:nodoc: all
-      if (!defined?val)
-        raise ArgumentError,  "Net::DNS::typesbyval() argument is not defined"
-      end
-
       if val.class == String
-        #       if val.gsub!("^\s*0*(\d+)\s*$", "$1")
-        if ((val =~ /^\s*0*(\d+)\s*$", "$1/o) == nil)
+        if ((val =~ /\A\s*(\d+)\s*\z/) == nil)
           raise ArgumentError,  "Net::DNS::typesbyval() argument (#{val}) is not numeric"
-          #           val =~s/^\s*0*(\d+)\s*$/$1/o;
         end
 
         val = $1.to_i
       end
 
 
-      if to_string(val)
-        return to_string(val)
-      end
-
-      raise ArgumentError,  'Net::DNS::typesbyval() argument larger than ' + 0xffff if
-          val > 0xffff;
-
-      return "TYPE#{val}";
+      RRCodeRange.check(val)
+      to_string(val) || "TYPE#{val}"
     end
   end
 
@@ -264,8 +276,8 @@ module Dnsruby
 
   class MetaTypes < CodeMapper
     TKEY        = 249    # Transaction Key   [RFC2930]
-    TSIG        = 250    # Transaction Signature  [RFC2845]
-    OPT         = 41     # RFC 2671
+    TSIG        = 250    # Transaction Signature  [RFC8945]
+    OPT         = 41     # RFC 6891
   end
 
   #  http://www.iana.org/assignments/dns-sec-alg-numbers/
@@ -279,6 +291,8 @@ module Dnsruby
     RSASHA512  = 10
     ECDSAP256SHA256 = 13
     ECDSAP384SHA384 = 14
+    ED25519 = 15
+    ED448 = 16
     INDIRECT   = 252
     PRIVATEDNS = 253
     PRIVATEOID = 254

data/lib/dnsruby/config.rb

@@ -127,6 +127,19 @@ module Dnsruby
         dom = config_hash[:domain] if config_hash.include? :domain
 
         if (!@configured)
+          # A bad file entry must not hide the other servers or prevent an
+          # explicit resolver override. Keep programmatic configuration strict.
+          unless config_info.kind_of?(Hash) && config_info.key?(:nameserver)
+            ns = ns.select do |server|
+              begin
+                check_ns([server])
+                true
+              rescue ArgumentError, ResolvError => error
+                Dnsruby.log.warn { "Ignoring invalid nameserver #{server.inspect}: #{error.message}" }
+                false
+              end
+            end
+          end
           send("nameserver=",ns)
         end
         @configured = true
@@ -202,6 +215,9 @@ module Dnsruby
       end
       ns.each {|n|
         if (String ===n)
+          if Config.scoped_ipv6_server?(n)
+            next
+          end
           #  Make sure we can make a Name or an address from it
           begin
             IPv4.create(n)
@@ -247,6 +263,52 @@ module Dnsruby
       Dnsruby.log.debug{"Nameservers = #{@nameserver.join(", ")}"}
     end
 
+    # Validate an IPv6 socket endpoint without putting its local interface zone
+    # into a DNS address. Callers must retain the original string for socket I/O.
+    def Config.ipv6_server_address(server) #:nodoc: all
+      if String === server && server.include?('%')
+        address, zone = server.split('%', 2)
+        unless /\A[0-9A-Za-z_.-]+\z/.match?(zone)
+          raise ArgumentError, "invalid IPv6 zone identifier: #{server.inspect}"
+        end
+        return IPv6.create(address)
+      end
+      IPv6.create(server)
+    end
+
+    # DNS labels can contain both ':' and '%'. Recognize an endpoint only
+    # when the complete address and zone are valid; otherwise keep DNS lookup.
+    def Config.scoped_ipv6_server?(server) #:nodoc: all
+      return false unless String === server && server.include?('%')
+      ipv6_server_address(server)
+      true
+    rescue ArgumentError
+      false
+    end
+
+    def Config.nameserver_resolver #:nodoc: all
+      config = Config.default_config_hash
+      # Bootstrap hostname lookups only through servers that need no DNS
+      # lookup themselves. Keep hostnames in the caller's configuration.
+      servers = Array(config[:nameserver]).select do |server|
+        next true if server == 'localhost'
+        begin
+          IPv4.create(server)
+        rescue ArgumentError
+          begin
+            Config.ipv6_server_address(server)
+          rescue ArgumentError
+            next false
+          end
+        end
+        true
+      end
+      if servers.empty?
+        raise ArgumentError, 'No nameserver addresses available for hostname lookup'
+      end
+      Resolver.new(config_info: config.merge(nameserver: servers))
+    end
+
     def Config.resolve_server(ns) #:nodoc: all
       #  Sanity check server
       #  If it's an IP address, then use that for server
@@ -255,6 +317,10 @@ module Dnsruby
       if (Name === ns)
         ns = ns.to_s
       end
+      # Keep the complete endpoint so the OS can choose the interface.
+      if scoped_ipv6_server?(ns)
+        return ns
+      end
       begin
         addr = IPv4.create(ns)
         server = ns
@@ -269,8 +335,8 @@ module Dnsruby
               server = "127.0.0.1"
             else
               #  Use Dnsruby to resolve the servers
-              #  First, try the default resolvers
-              resolver = Resolver.new
+              #  First, try the default resolvers with known addresses
+              resolver = Config.nameserver_resolver
               found = false
               begin
                 ret = resolver.query(ns)
@@ -281,16 +347,18 @@ module Dnsruby
                     found = true
                   end
                 }
-              rescue Exception
+              rescue Exception => error
+                raise if ValidationBudget.abort?(error)
               end
               if (!found)
                 #  That didn't work - try recursing from the root
-                recursor = Recursor.new
+                recursor = Recursor.new(resolver)
                 ret = recursor.query(ns)
                 ret.answer.each {|rr|
                   if ([Types::A, Types::AAAA].include?rr.type)
                     addr = rr.address.to_s
                     server = addr
+                    found = true
                   end
                 }
                 if (!found)
@@ -301,9 +369,12 @@ module Dnsruby
               end
             end
           rescue Exception => e
+            raise if ValidationBudget.abort?(e)
             Dnsruby.log.error{"Can't make sense of nameserver : #{server}, exception : #{e}"}
             raise ArgumentError.new("Can't make sense of nameserver : #{server}, exception : #{e}")
             return nil
+          ensure
+            resolver.close if resolver
           end
         end
       end

data/lib/dnsruby/deadline_queue.rb

@@ -0,0 +1,75 @@
+module Dnsruby
+  # Indexed minimum heap. Updating or cancelling a deadline removes its old
+  # entry immediately, so storage never exceeds the number of live owners.
+  # Callers provide synchronization alongside their corresponding query tables.
+  class DeadlineQueue # :nodoc: all
+    def initialize
+      @heap = []
+      @positions = {}
+    end
+
+    def first
+      @heap.first
+    end
+
+    def first_deadline
+      @heap.first&.last
+    end
+
+    def []=(key, deadline)
+      index = @positions[key]
+      if index
+        @heap[index][1] = deadline
+        move_down(move_up(index))
+      else
+        @positions[key] = @heap.length
+        @heap << [key, deadline]
+        move_up(@heap.length - 1)
+      end
+      deadline
+    end
+
+    def delete(key)
+      index = @positions.delete(key)
+      return unless index
+      removed = @heap[index]
+      last = @heap.pop
+      if index < @heap.length
+        @heap[index] = last
+        @positions[last[0]] = index
+        move_down(move_up(index))
+      end
+      removed[1]
+    end
+
+    private
+
+    def swap(left, right)
+      @heap[left], @heap[right] = @heap[right], @heap[left]
+      @positions[@heap[left][0]] = left
+      @positions[@heap[right][0]] = right
+    end
+
+    def move_up(index)
+      while index > 0
+        parent = (index - 1) / 2
+        break if @heap[parent][1] <= @heap[index][1]
+        swap(parent, index)
+        index = parent
+      end
+      index
+    end
+
+    def move_down(index)
+      loop do
+        child = index * 2 + 1
+        break if child >= @heap.length
+        right = child + 1
+        child = right if right < @heap.length && @heap[right][1] < @heap[child][1]
+        break if @heap[index][1] <= @heap[child][1]
+        swap(index, child)
+        index = child
+      end
+    end
+  end
+end