dnsruby 1.74.0 → 2.0.0

data/test/tc_escapedchars.rb

@@ -20,6 +20,14 @@ class TestEscapedChars < Minitest::Test
 
   include Dnsruby
 
+  def setup
+    @original_label_limit = Name::Label.class_variable_get(:@@max_length)
+  end
+
+  def teardown
+    Name::Label.set_max_length(@original_label_limit)
+  end
+
   def test_one
     Name::Label.set_max_length(150)
     # 

data/test/tc_final_review_fixes.rb

@@ -0,0 +1,167 @@
+require_relative 'spec_helper'
+
+class FinalReviewFixesTest < Minitest::Test
+  def test_source_port_replacement_is_published_after_enumeration
+    sender = Dnsruby::PacketSender.new(server: '127.0.0.1', src_port: 60_001)
+    ports = Object.new
+    seen = []
+    ports.define_singleton_method(:each) do |&block|
+      [60_002, 60_003].each do |port|
+        seen << sender.get_next_src_port
+        block.call(port)
+      end
+    end
+    sender.src_port = ports
+    assert_equal([60_001, 60_001], seen)
+    assert_equal([60_002, 60_003], sender.src_port)
+    assert_raises(ArgumentError) { sender.src_port = [] }
+    assert_equal([60_002, 60_003], sender.src_port)
+    assert_raises(ArgumentError) { sender.src_port = [60_004, 53] }
+    assert_equal([60_002, 60_003], sender.src_port)
+    sender.src_port << 60_004
+    assert_equal([60_002, 60_003, 60_004], sender.src_port)
+  end
+
+  def test_compression_preserves_label_boundaries_and_case
+    names = ['a\\.b.example.', 'a.b.example.', 'A.B.example.', 'other.example.']
+    message = Dnsruby::Message.new
+    names.each { |name| message.add_question(name, 'A') }
+    decoded = Dnsruby::Message.decode(message.encode)
+    assert_equal(names.map { |name| Dnsruby::Name.create(name).labels.map(&:string) },
+      decoded.question.map { |question| question.qname.labels.map(&:string) })
+  end
+
+  def test_txt_round_trip_preserves_utf8_and_decimal_escape_octets
+    ['café', 'é' * 127, '"café" "\\255"'].each do |text|
+      record = Dnsruby::RR.create(name: 'text.example.', type: 'TXT', strings: text)
+      unless text.start_with?('"')
+        assert_equal(text, record.data)
+        assert_equal(text.encoding, record.data.encoding)
+      end
+      message = Dnsruby::Message.new
+      message.add_answer(record)
+      decoded = Dnsruby::Message.decode(message.encode).answer.first
+      assert_equal(record.strings.map(&:b), decoded.strings)
+      reparsed = Dnsruby::RR.create(decoded.to_s)
+      assert_equal(decoded.strings, reparsed.strings)
+    end
+    commented = Dnsruby::RR.create(name: 'text.example.', type: 'TXT', strings: '"café" ; comment')
+    assert_equal('café', commented.data)
+    assert_equal(Encoding::UTF_8, commented.data.encoding)
+    record = Dnsruby::RR.create(name: 'text.example.', type: 'TXT', strings: 'é' * 128)
+    assert_equal('é' * 128, record.data)
+    message = Dnsruby::Message.new
+    message.add_answer(record)
+    assert_raises(Dnsruby::EncodeError) { message.encode }
+  end
+
+  def test_txt_can_split_a_utf8_sequence_at_a_wire_string_boundary
+    text = 'é' * 128
+    presentation = '"'.b + text.b.byteslice(0, 255) + '" "' + text.b.byteslice(255, 1) + '"'
+    record = Dnsruby::RR.create(name: 'text.example.', type: 'TXT', strings: presentation)
+    assert_equal(text.b, record.data)
+    assert_equal([255, 1], record.strings.map(&:bytesize))
+    message = Dnsruby::Message.new
+    message.add_answer(record)
+    decoded = Dnsruby::Message.decode(message.encode).answer.first
+    assert_equal(text.b, decoded.data)
+    assert_equal(record.strings, decoded.strings)
+  end
+
+  def test_ds_family_preserves_private_algorithm_and_unknown_digest_numbers
+    %w[DS CDS DLV].each do |type|
+      record = Dnsruby::RR.create("example. 60 IN #{type} 12345 253 253 01020304")
+      message = Dnsruby::Message.new
+      message.add_answer(record)
+      decoded = Dnsruby::Message.decode(message.encode).answer.first
+      assert_equal(253, decoded.algorithm.code)
+      assert_equal(253, decoded.digest_type.code)
+      assert_equal(record.digestbin, decoded.digestbin)
+      assert_raises(Dnsruby::DecodeError) { record.algorithm = 256 }
+      assert_raises(Dnsruby::DecodeError) { record.digest_type = -1 }
+    end
+  end
+
+  def test_zone_reader_qualifies_relative_origins_soa_and_literal_final_dots
+    reader = Dnsruby::ZoneReader.new('example.', 60)
+    reader.process_line('$ORIGIN sub')
+    soa = Dnsruby::RR.create(reader.process_line('@ IN SOA ns hostmaster 1 60 60 60 60'))
+    assert_equal('sub.example.', soa.name.to_s(true))
+    assert_equal('ns.sub.example.', soa.mname.to_s(true))
+    assert_equal('hostmaster.sub.example.', soa.rname.to_s(true))
+    record = Dnsruby::RR.create(reader.process_line('owner\\. IN CNAME target\\.'))
+    assert_equal(['owner.', 'sub', 'example'], record.name.labels.map(&:string))
+    assert_equal(['target.', 'sub', 'example'], record.cname.labels.map(&:string))
+    reader.process_line('$ORIGIN elsewhere.')
+    record = Dnsruby::RR.create(reader.process_line('@ IN NS ns'))
+    assert_equal('elsewhere.', record.name.to_s(true))
+    assert_equal('ns.elsewhere.', record.nsdname.to_s(true))
+  end
+
+  def test_zone_reader_preserves_backslashes_when_replacing_names
+    origin = Dnsruby::Name.new(['slash\\origin', 'example'].map { |label| Dnsruby::Name::Label.new(label) }, true)
+    reader = Dnsruby::ZoneReader.new(origin, 60)
+    target = Dnsruby::Name.new([Dnsruby::Name::Label.new('label\\&')], false)
+    record = Dnsruby::RR.create(reader.process_line("#{target.to_s} IN CNAME @"))
+    assert_equal(target.labels + origin.labels, record.name.labels)
+    assert_equal(origin, record.cname)
+    record = Dnsruby::RR.create(reader.process_line('@ IN NS ns'))
+    assert_equal(origin, record.name)
+  end
+
+  def test_positive_cache_scope_separates_upstream_and_request_context
+    sender = Dnsruby::PacketSender.new(server: '192.0.2.53', dnssec: false)
+    query = Dnsruby::Message.new('answer.example.', 'A')
+    sender.make_query_packet(query)
+    scope = sender.positive_cache_scope(query)
+    query.header.id = (query.header.id + 1) % 65_536
+    assert_equal(scope, sender.positive_cache_scope(query))
+    cache = Dnsruby::Cache.new
+    response = Dnsruby::Message.new('answer.example.', 'A')
+    response.add_answer(Dnsruby::RR.create('answer.example. 60 IN A 192.0.2.1'))
+    cache.add(response, scope: scope)
+    assert(cache.find('answer.example.', 'A', scope: sender.positive_cache_scope(query)).cached)
+    sender.port = 5353
+    assert_nil(cache.find('answer.example.', 'A', scope: sender.positive_cache_scope(query)))
+    sender.port = 53
+    sender.server = '192.0.2.54'
+    assert_nil(cache.find('answer.example.', 'A', scope: sender.positive_cache_scope(query)))
+    sender.server = '192.0.2.53'
+    query.get_opt.dnssec_ok = true
+    assert_nil(cache.find('answer.example.', 'A', scope: sender.positive_cache_scope(query)))
+  end
+
+  def test_truncated_answers_are_never_cached
+    cache = Dnsruby::Cache.new
+    response = Dnsruby::Message.new('answer.example.', 'A')
+    response.add_answer(Dnsruby::RR.create('answer.example. 60 IN A 192.0.2.1'))
+    response.header.tc = true
+    assert_nil(cache.add(response))
+    assert_nil(cache.find('answer.example.', 'A'))
+    response.header.tc = false
+    refute_nil(cache.add(response))
+  end
+
+  def test_referral_keeps_one_enclosing_delegation_and_sibling_glue
+    recursor = Dnsruby::Recursor.allocate
+    response = Dnsruby::Message.new('www.child.example.', 'A')
+    response.add_authority(Dnsruby::RR.create('child.example. 60 IN NS ns.sibling.example.'))
+    response.add_authority(Dnsruby::RR.create('other.example. 10 IN NS ns.other.example.'))
+    response.add_additional(Dnsruby::RR.create('ns.sibling.example. 120 IN A 192.0.2.53'))
+    response.add_additional(Dnsruby::RR.create('ns.other.example. 120 IN A 192.0.2.54'))
+    zone, authorities, ttl = recursor.referral_authorities(response, 'example.', 'www.child.example.', 'IN')
+    assert_equal('child.example.', zone)
+    assert_equal(['ns.sibling.example.'], authorities.keys)
+    assert_equal(['192.0.2.53'], authorities.values.first.values)
+    assert_equal(60, ttl)
+    relative = recursor.referral_authorities(response, 'example.', 'www.child.example', 'IN')
+    assert_equal(zone, relative.first)
+    at_delegation = recursor.referral_authorities(response, 'example.', 'child.example', 'IN')
+    assert_equal(zone, at_delegation.first)
+    assert_nil(recursor.referral_authorities(response, 'child.example.', 'www.child.example.', 'IN'))
+    assert_nil(recursor.referral_authorities(response, 'example.', 'www.unrelated.example.', 'IN'))
+    response.authority.clear
+    response.add_authority(Dnsruby::RR.create('child.example. 60 IN SOA ns.child.example. hostmaster.child.example. 1 60 60 60 60'))
+    assert_nil(recursor.referral_authorities(response, 'example.', 'www.child.example.', 'IN'))
+  end
+end

data/test/tc_final_transport_contracts.rb

@@ -0,0 +1,104 @@
+require_relative 'spec_helper'
+require 'minitest/mock'
+require 'open3'
+require 'timeout'
+
+class FinalTransportContractsTest < Minitest::Test
+  def test_single_resolver_replacement_preserves_concurrent_settings
+    resolver = Dnsruby::SingleResolver.new(server: '192.0.2.1', packet_timeout: 5)
+    entered, release = Queue.new, Queue.new
+    replacement = nil
+    original = Dnsruby::PacketSender.method(:new)
+    construct = lambda do |*args|
+      sender = original.call(*args)
+      if sender.server.to_s == '192.0.2.2'
+        entered << true
+        release.pop
+      end
+      sender
+    end
+    Dnsruby::PacketSender.stub(:new, construct) do
+      begin
+        replacement = Thread.new { resolver.server = '192.0.2.2' }
+        Timeout.timeout(5) { entered.pop }
+        resolver.packet_timeout = 9
+        resolver.port = 5353
+        resolver.src_address = '192.0.2.10'
+        resolver.dnssec = false
+      ensure
+        release << true
+        Timeout.timeout(5) { replacement&.value }
+      end
+    end
+    sender = resolver.single_resolvers.first
+    assert_equal('192.0.2.2', resolver.server)
+    [:packet_timeout, :port, :src_address, :dnssec].each do |field|
+      assert_equal(resolver.public_send(field), sender.public_send(field), field)
+    end
+  ensure
+    replacement&.kill if replacement&.alive?
+    resolver&.close
+  end
+
+  def test_tcp_reply_reports_its_message_size
+    # The selector is process-global; isolate its in-memory socket fixture.
+    source = <<~'RUBY'
+      require 'dnsruby'
+      selector_class = Dnsruby::SelectThread
+      selector_class.class_variable_set(:@@mutex, Mutex.new)
+      selector = selector_class.send(:allocate)
+      query = Dnsruby::Message.new('metadata.example.')
+      query.do_validation = query.do_caching = false
+      response = query.clone
+      response.header.qr = true
+      response.add_answer(Dnsruby::RR.create('metadata.example. 60 IN A 192.0.2.1'))
+      wire = response.encode
+      socket = Object.new
+      socket.define_singleton_method(:getsockopt) { |*| Struct.new(:data).new([Socket::SOCK_STREAM].pack('i')) }
+      socket.define_singleton_method(:closed?) { false }
+      selector.define_singleton_method(:tcp_read) { |_| wire }
+      settings = selector_class::QuerySettings.new(query.encode, query, false, Queue.new, :metadata,
+        socket, '192.0.2.53', 53, Dnsruby::TransportClock.now + 1, 512, nil)
+      selector_class.class_variable_set(:@@query_hash, {metadata: settings})
+      selector_class.class_variable_set(:@@socket_hash, {socket => [:metadata]})
+      decoded, = selector.get_incoming_data(socket, 512)
+      raise 'Wrong TCP size' unless decoded.answersize == wire.bytesize
+      raise 'Wrong TCP peer' unless decoded.answerip == '192.0.2.53'
+    RUBY
+    out, err, status = Open3.capture3(RbConfig.ruby, '-Ilib', '-e', source,
+      chdir: File.expand_path('..', __dir__))
+    assert(status.success?, "#{out}\n#{err}")
+  end
+
+  def test_zone_transfer_preserves_authenticated_server_errors
+    [Dnsruby::RCode::BADTIME, 22].each do |error_code|
+      key = Dnsruby::RR.create(name: 'transfer-key.example.', type: 'TSIG', klass: 'ANY',
+        key: ['test-only transfer secret'].pack('m0'), algorithm: 'hmac-sha256')
+      transfer = Dnsruby::ZoneTransfer.new
+      transfer.tsig = key
+      request = Dnsruby::Message.new('example.', 'AXFR')
+      sink = Object.new
+      sink.define_singleton_method(:write_nonblock) { |data| data.bytesize }
+      transfer.send_message(sink, request)
+      response = Dnsruby::Message.new('example.', 'AXFR')
+      response.header.qr = true
+      response.header.rcode = Dnsruby::RCode::NOTAUTH
+      signer = key.dup
+      signer.error = error_code
+      server_time = Time.now.to_i + 3600
+      if error_code == Dnsruby::RCode::BADTIME
+        signer.other_data = [server_time >> 32, server_time & 0xffffffff].pack('nN')
+        signer.other_size = 6
+      end
+      signer.apply(response, request)
+      wire = response.encode
+      frame = [wire.bytesize].pack('n') + wire
+      socket = Object.new
+      socket.define_singleton_method(:read_nonblock) { |size| frame.slice!(0, size) }
+      error = assert_raises(Dnsruby::TsigError) { transfer.receive_message(socket) }
+      assert_equal(:Verified, transfer.last_tsigstate)
+      assert_includes(error.message, error_code == Dnsruby::RCode::BADTIME ? 'BADTIME' : 'BADTRUNC')
+      assert_includes(error.message, server_time.to_s) if error_code == Dnsruby::RCode::BADTIME
+    end
+  end
+end