dnsruby 1.73.1 → 2.0.0

data/lib/dnsruby/resource/NSEC3PARAM.rb

@@ -92,6 +92,7 @@ module Dnsruby
         #         self.salt_length=(salt_length)
 #        self.salt=(salt)
         @salt=salt
+        @salt_length = salt.bytesize
       end
 
       def from_string(input)
@@ -114,10 +115,7 @@ module Dnsruby
 #        s = salt()
         s = @salt
         sl = s.length()
-        if (s == "-")
-          sl == 0
-        end
-        msg.put_pack("ccnc", @hash_alg.code, @flags, @iterations, sl)
+        msg.put_pack("CCnC", @hash_alg.code, @flags, @iterations, sl)
 
         if (sl > 0)
           msg.put_bytes(s)
@@ -125,11 +123,11 @@ module Dnsruby
       end
 
       def self.decode_rdata(msg) #:nodoc: all
-        hash_alg, flags, iterations, salt_length = msg.get_unpack("ccnc")
+        hash_alg, flags, iterations, salt_length = msg.get_unpack("CCnC")
         salt = msg.get_bytes(salt_length)
         return self.new(
           [hash_alg, flags, iterations, salt_length, salt])
       end
     end
   end
-end
+end

data/lib/dnsruby/resource/OPT.rb

@@ -227,13 +227,12 @@ module Dnsruby
         if @options
           @options.each do |opt|
             if opt.code == EDNS_SUBNET_OPTION
-              ret = ret + "CLIENT-SUBNET: #{get_client_subnet(opt)}"
+              ret = ret + "CLIENT-SUBNET: #{get_client_subnet(opt)}\n"
             else
-              ret = ret + " " + opt.to_s
+              ret = ret + "OPT=#{opt.code}: #{opt.data}\n"
             end
           end
         end
-        ret = ret + "\n"
         return ret
       end
 

data/lib/dnsruby/resource/RR.rb

@@ -14,6 +14,7 @@
 #
 
 require 'dnsruby/code_mappers'
+require 'dnsruby/presentation'
 
 module Dnsruby
 class RR
@@ -31,7 +32,7 @@ class RR
   end
 
   #  A regular expression which catches any valid resource record.
-  @@RR_REGEX = Regexp.new("^\\s*(\\S+)\\s*(\\d+)?\\s*(#{Classes.regexp +
+  @@RR_REGEX = Regexp.new("^\\s*((?:\\\\.|\\S)+)\\s*(\\d+)?\\s*(#{Classes.regexp +
       "|CLASS\\d+"})?\\s*(#{Types.regexp + '|TYPE\\d+'})?\\s*([\\s\\S]*)\$") #:nodoc: all
 
   @@implemented_rr_map = nil
@@ -74,7 +75,11 @@ class RR
 
   def clone
     encoded = MessageEncoder.new { |encoder| encoder.put_rr(self, true) }.to_s
-    MessageDecoder.new(encoded).get_rr
+    copy = MessageDecoder.new(encoded).get_rr
+    [:@dnsruby_received_at, :@dnsruby_authenticated_expiration, :@dnsruby_learned_trust].each do |field|
+      copy.instance_variable_set(field, instance_variable_get(field)) if instance_variable_defined?(field)
+    end
+    copy
   end
 
 
@@ -178,11 +183,20 @@ class RR
   #
   #
   def RR.new_from_string(rrstring)
-    #  strip out comments
-    #  Test for non escaped ";" by means of the look-behind assertion
-    #  (the backslash is escaped)
-    rrstring = rrstring.gsub(/(\?<!\\);.*/o, '')
+    # Standalone records allow unmatched parentheses, as in 1.74.0; ZoneReader
+    # requires balanced continuations. Skip the scanner for records without
+    # quotes, escapes, comments, parentheses or line breaks.
+    if /[\\'"();\r\n]/.match?(rrstring)
+      rrstring, = Presentation.scan(rrstring, allow_unbalanced: true,
+        single_quoted_from: rrstring.include?("'") ? Presentation.single_quoted_start(rrstring) : nil)
+    end
+    new_from_normalised_string(rrstring)
+  end
 
+  # ZoneReader already handles comments, grouping and quoted continuations.
+  # Keep this internal path separate from the public string constructors so
+  # normalized records need not run through the lexical scanner again.
+  def RR.new_from_normalised_string(rrstring) #:nodoc: all
     matches = (/#{@@RR_REGEX}/xo).match(rrstring)
     unless matches
       raise "#{rrstring} did not match RR pattern. Please report this to the author!"
@@ -194,7 +208,9 @@ class RR
     rrtype  = matches[4] || ''
     rdata   = matches[5] || ''
 
-    rdata.gsub!(/\s+$/o, '') if rdata
+    # Only remove trailing record layout. `$` also matches before an embedded
+    # newline and would delete spaces that belong to a quoted TXT value.
+    rdata.sub!(/\s+\z/o, '') if rdata
 
     #  RFC3597 tweaks
     #  This converts to known class and type if specified as TYPE###
@@ -216,60 +232,93 @@ class RR
       rrtype = 'ANY'
     end
 
-    unless %w(NAPTR TXT).include?(rrtype)
-      if rdata
-        rdata.gsub!('(', '')
-        rdata.gsub!(')', '')
-      end
+    if ttl == 0 && rdata.empty? && empty_update_type?(rrtype, rrclass)
+      return empty_update_record(name, rrtype, rrclass)
     end
 
-    test_length = ->(hexdump, rdlength) do
-      if hexdump.length != rdlength * 2
-        raise "#{rdata} is inconsistent; length should be #{rdlength * 2} but is #{hexdump.length}."
+    if /\A\s*\\#/.match?(rdata)
+      # RFC 3597 section 5 permits zero octets with no hexadecimal field.
+      # Validate before packing: pack('H*') alone also accepts non-hex input.
+      generic = /\A\s*\\#\s+(\d+)(?:\s+([0-9a-fA-F\s]*))?\z/.match(rdata)
+      raise DecodeError, 'Expected RFC3597 representation of RDATA' unless generic
+      rdlength = generic[1].to_i
+      hexdump = (generic[2] || '').gsub(/\s+/, '')
+      if rdlength > 0xffff || hexdump.length != rdlength * 2
+        raise DecodeError, "#{rdata} is inconsistent with its RDATA length #{rdlength}."
       end
-    end
-
-    pack_rdata = ->(regex) do
-      rdata =~ regex
-      matches = regex.match(rdata)
-      rdlength = matches[1].to_i
-      hexdump  = matches[2].gsub(/\s*/, '')
-
-      test_length.(hexdump, rdlength)
-      packed_rdata = [hexdump].pack('H*')
-
-      [packed_rdata, rdlength]
-    end
-
-    if implemented_rrs.include?(rrtype) && rdata !~/^\s*\\#/o
+      return new_from_data(name, rrtype, rrclass, ttl, rdlength, [hexdump].pack('H*'), 0)
+    elsif implemented_rrs.include?(rrtype)
       return _get_subclass(name, rrtype, rrclass, ttl, rdata)
-    elsif implemented_rrs.include?(rrtype)   # A known RR type starting with \#
-      packed_rdata, rdlength = pack_rdata.(/\\#\s+(\d+)\s+(.*)$/o)
-      return new_from_data(name, rrtype, rrclass, ttl, rdlength, packed_rdata, 0) # rdata.length() - rdlength);
-    elsif rdata =~ /\s*\\#\s+\d+\s+/o
-      regex = /\\#\s+(\d+)\s+(.*)$/o
-      # We are now dealing with the truly unknown.
-      raise 'Expected RFC3597 representation of RDATA' unless rdata =~ regex
-      packed_rdata, rdlength = pack_rdata.(regex)
-      return new_from_data(name, rrtype, rrclass, ttl, rdlength, packed_rdata, 0) # rdata.length() - rdlength);
     else
       # God knows how to handle these...
       return _get_subclass(name, rrtype, rrclass, ttl, '')
     end
   end
+  private_class_method :new_from_normalised_string
 
   def RR.new_from_data(*args) #:nodoc: all
     name, rrtype, rrclass, ttl, rdlength, data, offset = args
     rdata = data ? data[offset, rdlength] : []
     decoder = MessageDecoder.new(rdata)
-    record = get_class(rrtype, rrclass).decode_rdata(decoder)
+    record_class = get_class(rrtype, rrclass)
+    record = if rdlength == 0 && ttl == 0 && empty_update_type?(rrtype, rrclass)
+      empty_update_record(name, rrtype, rrclass)
+    else
+      record_class.decode_rdata(decoder)
+    end
     record.name = Name.create(name)
     record.ttl = ttl
     record.type = rrtype
     record.klass = Classes.new(rrclass)
+    record.validate_decoded_rdata
     record
   end
 
+  # Some formats depend on the actual RR class, which is assigned after the
+  # format-specific decoder runs (notably ANY/NONE UPDATE markers).
+  def validate_decoded_rdata #:nodoc: all
+  end
+
+  # RFC 2136 prerequisites and whole-RRset deletes carry no RDATA, including
+  # for types whose ordinary records require fields. Keep the familiar typed
+  # record while representing this operation separately from an empty value.
+  module EmptyUpdateData #:nodoc: all
+    def rdata_to_string
+      ''
+    end
+
+    def data
+      ''
+    end
+
+    def rdlength
+      0
+    end
+
+    def encode_rdata(_encoder, _canonical = false)
+      unless ttl == 0 && RR.empty_update_type?(type, klass)
+        raise EncodeError, 'Empty UPDATE records require TTL zero and class ANY or NONE'
+      end
+    end
+
+    def validate_decoded_rdata
+    end
+  end
+
+  def self.empty_update_type?(type, klass) #:nodoc: all
+    code = Types.new(type).code
+    [Classes::ANY, Classes::NONE].include?(Classes.new(klass)) &&
+      code > 0 && code != Types::OPT && !(128..254).cover?(code)
+  end
+
+  def self.empty_update_record(name, type, klass) #:nodoc: all
+    raise ArgumentError, 'Invalid empty UPDATE record type or class' unless empty_update_type?(type, klass)
+    record_class = get_class(type, klass)
+    record = record_class <= RR::DomainName ? record_class.new(Name.new([])) : record_class.new
+    record.name, record.type, record.klass, record.ttl, record.rdata = name, type, klass, 0, ''
+    record.extend(EmptyUpdateData)
+  end
+
   # Return an array of all the currently implemented RR types
   def RR.implemented_rrs
     @@implemented_rr_map ||= ClassHash.keys.map { |key| Dnsruby::Types.to_string(key[0]) }
@@ -319,30 +368,21 @@ class RR
     raise DecodeError.new("#{self.class} is RR.")
   end
 
+  # Metadata and alternate presentations are not part of record identity.
+  def equality_fields #:nodoc:
+    fields = instance_variables - [:@ttl, :@rdata, :@dnsruby_learned_trust,
+      :@dnsruby_authenticated_expiration, :@dnsruby_received_at]
+    fields.delete(:@digest) if is_a?(RR::DS)
+    fields.sort
+  end
+  protected :equality_fields
+
   def ==(other)
     return false unless self.class == other.class
-
-    ivars_to_compare = ->(object) do
-      ivars = object.instance_variables.map { |var| var.to_s }
-      ivars.delete '@ttl' # RFC 2136 section 1.1
-      ivars.delete '@rdata'
-      if self.type == Types.DS
-        ivars.delete '@digest'
-      end
-      ivars.sort
-    end
-
-    get_instance_var_values = ->(object, ivar_names) do
-      ivar_names.map { |ivar_name| object.instance_variable_get(ivar_name) }
+    fields = equality_fields
+    fields == other.equality_fields && fields.all? do |field|
+      instance_variable_get(field) == other.instance_variable_get(field)
     end
-
-    self_ivars  = ivars_to_compare.(self)
-    other_ivars = ivars_to_compare.(other)
-    return false unless self_ivars == other_ivars
-
-    self_values  = get_instance_var_values.(self, self_ivars)
-    other_values = get_instance_var_values.(other, other_ivars)
-    self_values == other_values
   end
 
   def eql?(other) #:nodoc:
@@ -350,22 +390,25 @@ class RR
   end
 
   def hash # :nodoc:
-    vars = (self.instance_variables - [:@ttl, :@rdata]).sort
-    vars.inject(0) do |hash_value, var_name|
-      hash_value ^ self.instance_variable_get(var_name).hash
+    equality_fields.inject(0) do |hash_value, field|
+      hash_value ^ instance_variable_get(field).hash
     end
   end
 
   def self.find_class(type_value, class_value) # :nodoc: all
     if !! (ret = ClassHash[[type_value, class_value]])
       return ret
+    elsif !! (ret = GenericCache.find(type_value, class_value))
+      return ret
     elsif !! (val = ClassInsensitiveTypes[type_value])
       klass = Class.new(val)
       klass.const_set(:TypeValue, type_value)
       klass.const_set(:ClassValue, class_value)
       return klass
     else
-      return Generic.create(type_value, class_value)
+      return GenericCache.factory(type_value, class_value) do
+        Generic.create(type_value, class_value)
+      end
     end
   end
 

data/lib/dnsruby/resource/RRSIG.rb

@@ -240,15 +240,15 @@ module Dnsruby
 
       def encode_rdata(msg, canonical=false) #:nodoc: all
         #  2 octets, then 2 sets of 1 octet
-        msg.put_pack('ncc', @type_covered.to_i, @algorithm.to_i, @labels)
+        msg.put_pack('nCC', @type_covered.to_i, @algorithm.to_i, @labels)
         msg.put_pack("NNN", @original_ttl, @expiration, @inception)
         msg.put_pack("n", @key_tag)
-        msg.put_name(@signers_name, canonical, false)
+        msg.put_name(@signers_name, true, false)
         msg.put_bytes(@signature)
       end
 
       def self.decode_rdata(msg) #:nodoc: all
-        type_covered, algorithm, labels = msg.get_unpack('ncc')
+        type_covered, algorithm, labels = msg.get_unpack('nCC')
         original_ttl, expiration, inception = msg.get_unpack('NNN')
         key_tag, = msg.get_unpack('n')
         signers_name = msg.get_name
@@ -263,7 +263,7 @@ module Dnsruby
         # with the Signer's Name field in canonical form and
         # the Signature field excluded;
         data = MessageEncoder.new { |msg|
-          msg.put_pack('ncc', @type_covered.to_i, @algorithm.to_i, @labels)
+          msg.put_pack('nCC', @type_covered.to_i, @algorithm.to_i, @labels)
           msg.put_pack("NNN", @original_ttl, @expiration, @inception)
           msg.put_pack("n", @key_tag)
           msg.put_name(@signers_name, true)
@@ -272,4 +272,4 @@ module Dnsruby
       end
     end
   end
-end
+end

data/lib/dnsruby/resource/RRSet.rb

@@ -16,7 +16,12 @@ class RRSet
     end
     @rrs = []
     @num_sigs = 0
+    # During construction all entries are private wire copies. Discard this
+    # temporary index before exposing the set: public RR objects are mutable.
+    @membership_index = {}
     rrs.each {|rr| add(rr)}
+  ensure
+    @membership_index = nil
   end
   def self.new_from_string(string)
     rr_strings = string.split("\n")
@@ -32,7 +37,14 @@ class RRSet
     return @rrs[0, @rrs.length-@num_sigs]
   end
   def privateAdd(r) #:nodoc:
-    if @rrs.include?r
+    budget = ValidationBudget.current if defined?(ValidationBudget)
+    duplicate = if @membership_index
+      budget&.check!(1)
+      @membership_index.key?(r)
+    else
+      @rrs.any? { |existing| budget&.check!(1); existing == r }
+    end
+    if duplicate
       return true
     end
     new_pos = @rrs.length - @num_sigs
@@ -47,6 +59,7 @@ class RRSet
       @num_sigs += 1
     end
     @rrs.insert(new_pos, r)
+    @membership_index[r] = true if @membership_index
     return true
   end
 
@@ -56,25 +69,19 @@ class RRSet
   def add(rin, do_clone = true)
     if (rin.instance_of?RRSet)
       ret = false
-      [rin.rrs, rin.sigs].each {|rr| ret = add(rr)}
+      (rin.rrs + rin.sigs).each {|rr| ret = add(rr, do_clone)}
       return ret
     end
-    #       r = RR.create(r.to_s) # clone the record
-    r = nil
-    if do_clone
-      r = rin.clone
-    else
-      r = rin
-    end
-    if (@rrs.size() == 0) #  && !(r.type == Types.RRSIG))
-      return privateAdd(r)
-    end
-    #  Check the type, klass and ttl are correct
-    first = @rrs[0]
-    if (!r.sameRRset(first))
-      return false
-      #         raise ArgumentError.new("record does not match rrset")
-    end
+    @membership_index = nil unless do_clone
+    add_record(rin, do_clone)
+  end
+
+  private def add_record(rin, do_clone)
+    # Reject unrelated records before copying their wire data.
+    first = @rrs.first
+    return false if first && !rin.sameRRset(first)
+    r = do_clone ? rin.clone : rin
+    return privateAdd(r) unless first
 
     if (!(r.type == Types::RRSIG) && (!(first.type == Types::RRSIG)))
       if (r.ttl != first.ttl) # RFC2181, section 5.2
@@ -114,12 +121,19 @@ class RRSet
     end
 
     return_rrs = RRSet.new
-    canonical_rrs.keys.sort.each { |rdata|
-      return_rrs.add(canonical_rrs[rdata], false)
-    }
+    return_rrs.send(:add_canonical_records, canonical_rrs.keys.sort.map { |rdata| canonical_rrs[rdata] })
     return return_rrs
   end
 
+  private def add_canonical_records(records)
+    # Preserve the original references and TTL normalization of add(rr, false).
+    # The index exists only while building; callers can mutate records later.
+    @membership_index = {}
+    records.each { |record| add_record(record, false) }
+  ensure
+    @membership_index = nil
+  end
+
   def ==(other)
     return false unless other.instance_of?RRSet
     return false if (other.sigs.length != self.sigs.length)
@@ -137,7 +151,9 @@ class RRSet
   end
   # Delete the RR from this RRSet
   def delete(rr)
-    @rrs.delete(rr)
+    removed = @rrs.delete(rr)
+    @num_sigs = @rrs.count { |record| record.type == Types::RRSIG } if removed
+    removed
   end
   def each
     @rrs.each do |rr|

data/lib/dnsruby/resource/SRV.rb

@@ -96,7 +96,7 @@ module Dnsruby
           msg.put_pack("n", @priority)
           msg.put_pack("n", @weight)
           msg.put_pack("n", @port)
-          msg.put_name(@target,canonical)
+          msg.put_name(@target, true, canonical)
         end
 
         def self.decode_rdata(msg) #:nodoc: all
@@ -109,4 +109,4 @@ module Dnsruby
       end
     end
   end
-end
+end