dnsruby 1.1

data/test/custom.txt

@@ -0,0 +1,4 @@
+# $Id: custom.txt 264 2005-04-06 09:16:15Z olaf $
+domain t2.dnsruby.validation-test-servers.nominet.org.uk
+search alt.dnsruby.validation-test-servers.nominet.org.uk ext.dnsruby.validation-test-servers.nominet.org.uk
+nameserver 10.0.1.42 10.0.2.42

data/test/resolv.conf

@@ -0,0 +1,4 @@
+# $Id: .resolv.conf 264 2005-04-06 09:16:15Z olaf $
+domain t.dnsruby.validation-test-servers.nominet.org.uk
+search dnsruby.validation-test-servers.nominet.org.uk lib.dnsruby.validation-test-servers.nominet.org.uk
+nameserver 10.0.1.128 10.0.2.128

data/test/tc_axfr.rb

@@ -0,0 +1,32 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+class TestAxfr < Test::Unit::TestCase
+  def test_axfr
+    zt = Dnsruby::ZoneTransfer.new
+    zt.transfer_type = Dnsruby::Types.AXFR
+    zt.server = "ns0.validation-test-servers.nominet.org.uk"
+    zone = zt.transfer("validation-test-servers.nominet.org.uk")
+    assert(zone.length > 0)
+    assert(zt.last_tsigstate==nil)
+  end
+  
+  
+  # NB - test_ixfr is in tc_tsig.rg - this is becuase it requires
+  # TSIG to make an update (which we can then test for with ixfr)
+end

data/test/tc_dns.rb

@@ -0,0 +1,230 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestDNS < Test::Unit::TestCase
+  def setup
+    Dnsruby::Config.reset
+  end
+  
+  def test_resolv_rb_api
+    DNS.open {|dns|
+      dns.getresources("www.ruby-lang.org", Types.A).each  {|r| assert_equal(r.address.to_s, "221.186.184.68")}
+      r= dns.getresources("ruby-lang.org", Types.MX, Classes.IN).collect {|r| [r.exchange.to_s, r.preference]}
+      assert_equal(r, [["carbon.ruby-lang.org", 10]])
+    }
+    d = DNS.open
+    d.getresources("www.ruby-lang.org", Types.A, Classes.IN).each {|r| assert_equal(r.address.to_s, "221.186.184.68")}
+    assert_equal(d.getaddress("www.ruby-lang.org").to_s, "221.186.184.68")
+    r = d.getaddresses("www.ruby-lang.org")
+    assert_equal(r.length, 1)
+    assert_equal(r[0].to_s, "221.186.184.68")
+    d.each_address("www.ruby-lang.org") {|address| assert_equal(address.to_s, "221.186.184.68")}
+    assert_equal(d.getname("210.251.121.214").to_s, "ci.ruby-lang.org")
+    r = d.getnames("210.251.121.214")
+    assert_equal(r.length, 1)
+    assert_equal(r[0].to_s, "ci.ruby-lang.org")
+    d.each_name("210.251.121.214") {|name| assert_equal(name.to_s, "ci.ruby-lang.org")}
+    r = d.getresource("www.ruby-lang.org", Types.A)
+    assert_equal(r.name.to_s, "carbon.ruby-lang.org")
+    assert_equal(r.address.to_s, "221.186.184.68")
+    assert_equal(r.klass, Classes.IN)
+    assert_equal(r.type, Types.A)
+    r = d.getresources("www.ruby-lang.org", Types.MX)
+    assert(r.length==1)
+    assert_equal(r[0].name.to_s, "carbon.ruby-lang.org")
+    assert_equal(r[0].preference, 10)
+    assert_equal(r[0].exchange.to_s, "carbon.ruby-lang.org")
+    assert_equal(r[0].klass, Classes.IN)
+    assert_equal(r[0].type, Types.MX)
+    r = d.each_resource("www.ruby-lang.org", Types.ANY) {|r|     
+      assert_equal(r.name.to_s, "www.ruby-lang.org")
+      assert_equal(r.domainname.to_s, "carbon.ruby-lang.org")
+      assert_equal(r.klass, Classes.IN)
+      assert_equal(r.type, Types.CNAME)
+    }
+    d.close
+  end
+  
+  def test_async_api
+    #@TODO@ Do we really want an async API for Resolv/DNS?
+    #Or would users be better off with Resolver async API?
+  end
+  
+  def test_concurrent
+    #@TODO@ What kind of concurrent testing are we going to do on the top-level API?
+  end
+  
+  def test_bad_input
+    #
+    # Check that new() is vetting things properly.
+    #
+    Dnsruby::TheLog.level=Logger::FATAL
+    [:nameserver].each do |test|
+      [{}, 'string',1,'\1',nil].each do |input|
+        res=nil
+        begin
+          res = Dnsruby::DNS.new({test => input})
+          assert(false, "Accepted invalid input")
+        rescue
+          assert(res==nil, "No resolver should be returned for #{test} = #{input}")
+        end
+      end
+    end
+  end
+  
+  def test_online
+    res = DNS.new
+    rrs = [
+    {
+      :type   		=> Types.A,
+      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :address 	=> '10.0.1.128'
+    },
+    {
+      :type		=> Types::MX,
+      :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :preference 	=> 10
+    },
+    {
+      :type		=> 'CNAME',
+      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+    },
+    {
+      :type		=> Types.TXT,
+      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :strings		=> ['Net-DNS']
+    }		
+    ]		
+    
+    rrs.each do |data|
+      answer = res.getresource(data[:name], data[:type])
+      assert(answer)
+      assert_equal(answer.klass,    'IN',             'Class correct'           )
+      
+      packet, queried_name = res.send_query(data[:name], data[:type])
+      
+      assert(packet, "Got an answer for #{data[:name]} IN #{data[:type]}")
+      assert_equal(1, packet.header.qdcount, 'Only one question')
+      assert_equal(1, packet.header.ancount, 'Got single answer')
+      
+      question = (packet.question)[0]
+      answer   = (packet.answer)[0]
+      
+      assert(question,                           'Got question'            )
+      assert_equal(data[:name],  question.qname.to_s,  'Question has right name' )
+      assert_equal(data[:name],  queried_name.to_s,  'queried_name has right name' )
+      assert_equal(Types.new(data[:type]),  question.qtype,  'Question has right type' )
+      assert_equal('IN',             question.qclass.string, 'Question has right class')
+      
+      assert(answer)
+      assert_equal(answer.klass,    'IN',             'Class correct'           )
+      
+      
+      data.keys.each do |meth| 
+        if (meth == :type)
+          assert_equal(Types.new(data[meth]).to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
+        else       
+          assert_equal(data[meth].to_s, answer.send(meth).to_s, "#{meth} correct (#{data[:name]})") 
+        end
+      end
+    end # do
+  end # test_online
+  
+  def test_search_query_reverse    
+    #
+    # test that getname() DTRT with reverse lookups
+    #
+    tests = [
+    {
+      :ip => '198.41.0.4',
+      :host => 'a.root-servers.net',
+    },
+    {
+      :ip => '2001:500:1::803f:235',
+      :host => 'h.root-servers.net',
+    },
+    ]
+    
+    res = DNS.new
+    tests.each do |test| 
+      name = res.getname(test[:ip])
+      
+      assert_instance_of(Name,name)
+      
+      next unless name
+      
+      assert_equal(name.to_s, test[:host], "getname(#{test[:ip]}) works")
+    end # do
+  end # test
+  
+  def test_searchlist
+    res = DNS.new(
+                  :domain     => 't.dnsruby.validation-test-servers.nominet.org.uk',
+    :search => ["t.dnsruby.validation-test-servers.nominet.org.uk", "dnsruby.validation-test-servers.nominet.org.uk"]
+    )
+    
+    #
+    # test the send_query() appends the default domain and 
+    # searchlist correctly.
+    #
+    #@TODO@ Should really be done in Config test!
+    
+    tests = [
+    {
+      :method => 'search',
+      :name   => 'a'
+    },
+    {
+      :method => 'search',
+      :name   => 'a.t'
+    },
+    {
+      :method => 'query',
+      :name   => 'a'
+    }
+    ]
+    
+    res.send_query("a.t.dnsruby.validation-test-servers.nominet.org.uk",  "A")
+    res.config.ndots=2
+    
+    tests.each do |test|
+      method = test[:method]
+      
+      if (method=="query")
+        res.config.apply_search_list=false
+      else
+        res.config.apply_search_list=true
+      end
+      
+      ans, query = res.send_query(test[:name])
+      
+      assert_instance_of(Message, ans)
+      
+      assert_equal(1, ans.header.ancount, "Correct answer count (with persistent socket and #{method})")
+      
+      a = ans.answer
+      
+      assert_instance_of(RR::IN::A, a[0])
+      assert_equal(a[0].name.to_s, 'a.t.dnsruby.validation-test-servers.nominet.org.uk',"Correct name (with persistent socket and #{method})")
+    end
+    
+  end
+end

data/test/tc_dnskey.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'dnsruby'
+
+class DnskeyTest < Test::Unit::TestCase
+  INPUT = "example.com. 86400 IN DNSKEY 256 3 5 ( AQPSKmynfzW4kyBv015MUG2DeIQ3" + 
+    "Cbl+BBZH4b/0PY1kxkmvHjcZc8no" + 
+    "kfzj31GajIQKY+5CptLr3buXA10h" +
+    "WqTkF7H6RfoRqXQeogmMHfpftf6z" +
+    "Mv1LyBUgia7za6ZEzOJBOztyvhjL" + 
+    "742iU/TpPSEDhm2SNKLijfUppn1U" +
+    "aNvv4w==  )"
+  def test_dnskey_from_string
+    dnskey = Dnsruby::RR.create(INPUT)
+    assert_equal(3, dnskey.protocol)
+    assert_equal(256, dnskey.flags)
+    assert_equal(Dnsruby::Algorithms::RSASHA1, dnskey.algorithm)
+    assert_equal(Dnsruby::RR::DNSKEY::ZONE_KEY, dnskey.flags & Dnsruby::RR::DNSKEY::ZONE_KEY)
+    assert_equal(0, dnskey.flags & Dnsruby::RR::DNSKEY::SEP_KEY)
+    
+    dnskey2 = Dnsruby::RR.create(dnskey.to_s)
+    assert(dnskey2.to_s == dnskey.to_s, "#{dnskey.to_s} not equal to \n#{dnskey2.to_s}")
+  end
+
+  def test_dnskey_from_data
+    dnskey = Dnsruby::RR.create(INPUT)
+    m = Dnsruby::Message.new
+    m.add_additional(dnskey)
+    data = m.encode
+    m2 = Dnsruby::Message.decode(data)
+    dnskey3 = m2.additional()[0]
+    assert_equal(dnskey.to_s, dnskey3.to_s)
+  end
+  
+  def test_bad_values
+    dnskey = Dnsruby::RR.create(INPUT)
+    begin
+      dnskey.protocol=4
+      fail()
+    rescue Dnsruby::DecodeError
+    end
+    begin
+      dnskey.flags=4
+      fail()
+    rescue Dnsruby::DecodeError
+    end
+    dnskey.flags=256
+    dnskey.flags=257
+    dnskey.flags=1
+    dnskey.protocol=3
+     
+  end
+end

data/test/tc_dnsruby.rb

@@ -0,0 +1,42 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestDnsruby < Test::Unit::TestCase
+  def test_dnsruby
+    a = Resolv.getaddress("www.ruby-lang.org")
+    assert_equal(a.to_s, "221.186.184.68")
+    a = Resolv.getaddresses("www.ruby-lang.org")
+    assert(a.length==1)
+    assert_equal(a[0].to_s, "221.186.184.68")
+    Resolv.each_address("www.ruby-lang.org") {|address| assert_equal(address, "221.186.184.68")}
+    
+    n = Resolv.getname("210.251.121.214")
+    assert_equal(n, "ci.ruby-lang.org")
+    begin
+      ret = Resolv.getname("www.ruby-lang.org")
+      assert(false, ret)
+    rescue Exception => e
+      assert(e.kind_of?(ResolvError))
+    end
+    n = Resolv.getnames("210.251.121.214")
+    assert(n.length==1)
+    assert_equal(n[0], "ci.ruby-lang.org")
+    Resolv.each_name("210.251.121.214") {|name| assert_equal(name, "ci.ruby-lang.org")}
+  end
+end

data/test/tc_dnssec.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+require 'dnsruby'
+
+class DnssecTest < Test::Unit::TestCase
+  def test_follow_chain_of_trust
+    Dnsruby::Dnssec.clear_trusted_keys
+    res = Dnsruby::Resolver.new("dnssec.nominet.org.uk")
+    res.dnssec=true
+
+    trusted_key = Dnsruby::RR.create({:name => "uk-dnssec.nic.uk.",
+        :type => Dnsruby::Types.DNSKEY,
+        :key=> "AQPJO6LjrCHhzSF9PIVV7YoQ8iE31FXvghx+14E+jsv4uWJR9jLrxMYm sFOGAKWhiis832ISbPTYtF8sxbNVEotgf9eePruAFPIg6ZixG4yMO9XG LXmcKTQ/cVudqkU00V7M0cUzsYrhc4gPH/NKfQJBC5dbBkbIXJkksPLv Fe8lReKYqocYP6Bng1eBTtkA+N+6mSXzCwSApbNysFnm6yfQwtKlr75p m+pd0/Um+uBkR4nJQGYNt0mPuw4QVBu1TfF5mQYIFoDYASLiDQpvNRN3 US0U5DEG9mARulKSSw448urHvOBwT9Gx5qF2NE4H9ySjOdftjpj62kjb Lmc8/v+z"
+      })
+    ret = Dnsruby::Dnssec.add_trusted_key(trusted_key)
+
+    r = res.query("uk-dnssec.nic.uk", Dnsruby::Types.ANY)
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec verification failed")
+
+    r = res.query("www.uk-dnssec.nic.uk", Dnsruby::Types.ANY)
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec verification failed")
+
+    r = res.query("bigzone.uk-dnssec.nic.uk", Dnsruby::Types.DS)
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec verification failed")
+    
+    r = res.query("bigzone.uk-dnssec.nic.uk", Dnsruby::Types.ANY)
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec verification failed")
+    
+    r = res.query("aaa.bigzone.uk-dnssec.nic.uk", Dnsruby::Types.ANY)
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec verification failed")
+        
+    rrset = r.answer.rrset('NSEC')
+    ret = Dnsruby::Dnssec.verify_rrset(rrset)
+    assert(ret, "Dnssec verification failed")
+  end
+  
+  def test_se_query
+    # Run some queries on the .se zone
+    Dnsruby::Dnssec.clear_trusted_keys
+    res = Dnsruby::Resolver.new("a.ns.se")
+    r = res.query("se", Dnsruby::Types.ANY)    
+    keys = r.answer.rrset('DNSKEY')
+    keys = Dnsruby::Dnssec::KeyCache.new(keys)
+    nss = r.answer.rrset('NS')
+    ret = Dnsruby::Dnssec.verify_rrset(nss, keys)
+    assert(ret, "Dnssec verification failed")    
+  end
+    
+  def test_verify_message
+    Dnsruby::Dnssec.clear_trusted_keys
+    res = Dnsruby::Resolver.new("a.ns.se")
+    r = res.query("se", Dnsruby::Types.ANY)    
+    # This shouldn't be in the code - but the key is rotated by the .se registry
+    # so we can't keep up with it in the test code.
+    # Oh, for a signed root...
+    Dnsruby::Dnssec.add_trusted_key(r.answer.rrset('DNSKEY'))
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec message verification failed")    
+  end
+  
+  def test_trusted_key
+    Dnsruby::Dnssec.clear_trusted_keys
+    res = Dnsruby::Resolver.new("dnssec.nominet.org.uk")
+    bad_key = Dnsruby::RR.create(
+      "uk-dnssec.nic.uk. 86400 IN DNSKEY 257 3 5 "+
+        "AwEAAbhThsjZqxZDyZLie1BYP+R/G1YRhmuIFCbmuQiF4NB86gpW8EVR l2s+gvNuQw6yh2YdDdyJBselE4znRP1XQbpOTC5UO5CDwge9NYja/jrX lvrX2N048vhIG8uk8yVxJDosxf6nmptsJBp3GAjF25soJs07Bailcr+5 vdZ7GibH")
+    r = res.query("uk-dnssec.nic.uk", Dnsruby::Types.DNSKEY)
+    ret = Dnsruby::Dnssec.verify(r, bad_key)
+    assert(!ret, "Dnssec trusted key message verification should have failed with bad key")    
+    trusted_key = Dnsruby::RR.create({:name => "uk-dnssec.nic.uk.",
+        :type => Dnsruby::Types.DNSKEY,
+        :flags => 257,
+        :protocol => 3,
+        :algorithm => 5,
+        :key=> "AQPJO6LjrCHhzSF9PIVV7YoQ8iE31FXvghx+14E+jsv4uWJR9jLrxMYm sFOGAKWhiis832ISbPTYtF8sxbNVEotgf9eePruAFPIg6ZixG4yMO9XG LXmcKTQ/cVudqkU00V7M0cUzsYrhc4gPH/NKfQJBC5dbBkbIXJkksPLv Fe8lReKYqocYP6Bng1eBTtkA+N+6mSXzCwSApbNysFnm6yfQwtKlr75p m+pd0/Um+uBkR4nJQGYNt0mPuw4QVBu1TfF5mQYIFoDYASLiDQpvNRN3 US0U5DEG9mARulKSSw448urHvOBwT9Gx5qF2NE4H9ySjOdftjpj62kjb Lmc8/v+z"
+      })
+    ret = Dnsruby::Dnssec.verify(r, trusted_key)
+    assert(ret, "Dnssec trusted key message verification failed")    
+
+    # Check that keys have been added to trusted key cache
+    ret = Dnsruby::Dnssec.verify(r)
+    assert(ret, "Dnssec trusted key cache failed")    
+  end
+end