regression-tests.recursor-dnssec/test_DNS64.py

   1 import dns
   2 import os
   3
   4 from recursortests import RecursorTest
   5
   6 class DNS64RecursorTest(RecursorTest):
   7
   8     _confdir = 'DNS64'
   9     _config_template = """
  10     auth-zones=example.dns64=configs/%s/example.dns64.zone
  11     auth-zones+=in-addr.arpa=configs/%s/in-addr.arpa.zone
  12     auth-zones+=ip6.arpa=configs/%s/ip6.arpa.zone
  13
  14     dns64-prefix=64:ff9b::/96
  15     """ % (_confdir, _confdir, _confdir)
  16
  17     @classmethod
  18     def setUpClass(cls):
  19
  20         # we don't need all the auth stuff
  21         cls.setUpSockets()
  22         cls.startResponders()
  23
  24         confdir = os.path.join('configs', cls._confdir)
  25         cls.createConfigDir(confdir)
  26
  27         cls.generateRecursorConfig(confdir)
  28         cls.startRecursor(confdir, cls._recursorPort)
  29
  30     @classmethod
  31     def tearDownClass(cls):
  32         cls.tearDownRecursor()
  33
  34     @classmethod
  35     def generateRecursorConfig(cls, confdir):
  36         authzonepath = os.path.join(confdir, 'example.dns64.zone')
  37         with open(authzonepath, 'w') as authzone:
  38             authzone.write("""$ORIGIN example.dns64
  39 @ 3600 IN SOA {soa}
  40 www 3600 IN A 192.0.2.42
  41 www 3600 IN TXT "does exist"
  42 aaaa 3600 IN AAAA 2001:db8::1
  43 """.format(soa=cls._SOA))
  44
  45         authzonepath = os.path.join(confdir, 'in-addr.arpa.zone')
  46         with open(authzonepath, 'w') as authzone:
  47             authzone.write("""$ORIGIN in-addr.arpa
  48 @ 3600 IN SOA {soa}
  49 42.2.0.192 IN PTR www.example.dns64.
  50 """.format(soa=cls._SOA))
  51
  52         authzonepath = os.path.join(confdir, 'ip6.arpa.zone')
  53         with open(authzonepath, 'w') as authzone:
  54             authzone.write("""$ORIGIN ip6.arpa
  55 @ 3600 IN SOA {soa}
  56 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2 IN PTR aaaa.example.dns64.
  57 """.format(soa=cls._SOA))
  58
  59         super(DNS64RecursorTest, cls).generateRecursorConfig(confdir)
  60
  61     # this type (A) exists for this name
  62     def testExistingA(self):
  63         qname = 'www.example.dns64.'
  64         expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'A', '192.0.2.42')
  65
  66         query = dns.message.make_query(qname, 'A', want_dnssec=True)
  67         for method in ("sendUDPQuery", "sendTCPQuery"):
  68             sender = getattr(self, method)
  69             res = sender(query)
  70             self.assertRcodeEqual(res, dns.rcode.NOERROR)
  71             self.assertRRsetInAnswer(res, expected)
  72
  73     # there is no A record, we should get a NODATA
  74     def testNonExistingA(self):
  75         qname = 'aaaa.example.dns64.'
  76
  77         query = dns.message.make_query(qname, 'A', want_dnssec=True)
  78         for method in ("sendUDPQuery", "sendTCPQuery"):
  79             sender = getattr(self, method)
  80             res = sender(query)
  81             self.assertRcodeEqual(res, dns.rcode.NOERROR)
  82             self.assertEquals(len(res.answer), 0)
  83
  84     # this type (AAAA) does not exist for this name but there is an A record, we should get a DNS64-wrapped AAAA
  85     def testNonExistingAAAA(self):
  86         qname = 'www.example.dns64.'
  87         expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'AAAA', '64:ff9b::c000:22a')
  88
  89         query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
  90         for method in ("sendUDPQuery", "sendTCPQuery"):
  91             sender = getattr(self, method)
  92             res = sender(query)
  93             self.assertRcodeEqual(res, dns.rcode.NOERROR)
  94             self.assertRRsetInAnswer(res, expected)
  95
  96     # this type (AAAA) does not exist for this name and there is no A record either, we should get a NXDomain
  97     def testNonExistingAAAA(self):
  98         qname = 'nxd.example.dns64.'
  99
 100         query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
 101         for method in ("sendUDPQuery", "sendTCPQuery"):
 102             sender = getattr(self, method)
 103             res = sender(query)
 104             self.assertRcodeEqual(res, dns.rcode.NXDOMAIN)
 105
 106     # there is an AAAA record, we should get it
 107     def testExistingAAAA(self):
 108         qname = 'aaaa.example.dns64.'
 109         expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'AAAA', '2001:db8::1')
 110
 111         query = dns.message.make_query(qname, 'AAAA', want_dnssec=True)
 112         for method in ("sendUDPQuery", "sendTCPQuery"):
 113             sender = getattr(self, method)
 114             res = sender(query)
 115             self.assertRcodeEqual(res, dns.rcode.NOERROR)
 116             self.assertRRsetInAnswer(res, expected)
 117
 118     # there is a TXT record, we should get it
 119     def testExistingTXT(self):
 120         qname = 'www.example.dns64.'
 121         expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'TXT', '"does exist"')
 122
 123         query = dns.message.make_query(qname, 'TXT', want_dnssec=True)
 124         for method in ("sendUDPQuery", "sendTCPQuery"):
 125             sender = getattr(self, method)
 126             res = sender(query)
 127             self.assertRcodeEqual(res, dns.rcode.NOERROR)
 128             self.assertRRsetInAnswer(res, expected)
 129
 130     # the PTR records for the DNS64 prefix should be generated
 131     def testNonExistingPTR(self):
 132         qname = 'a.2.2.0.0.0.0.c.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.b.9.f.f.4.6.0.0.ip6.arpa.'
 133         expectedCNAME = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'CNAME', '42.2.0.192.in-addr.arpa.')
 134         expected = dns.rrset.from_text('42.2.0.192.in-addr.arpa.', 0, dns.rdataclass.IN, 'PTR', 'www.example.dns64.')
 135
 136         query = dns.message.make_query(qname, 'PTR', want_dnssec=True)
 137         for method in ("sendUDPQuery", "sendTCPQuery"):
 138             sender = getattr(self, method)
 139             res = sender(query)
 140             print(res)
 141             self.assertRcodeEqual(res, dns.rcode.NOERROR)
 142             self.assertRRsetInAnswer(res, expectedCNAME)
 143             self.assertRRsetInAnswer(res, expected)
 144
 145     # but not for other prefixes
 146     def testExistingPTR(self):
 147         qname = '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.'
 148         expected = dns.rrset.from_text(qname, 0, dns.rdataclass.IN, 'PTR', 'aaaa.example.dns64.')
 149
 150         query = dns.message.make_query(qname, 'PTR', want_dnssec=True)
 151         for method in ("sendUDPQuery", "sendTCPQuery"):
 152             sender = getattr(self, method)
 153             res = sender(query)
 154             self.assertRcodeEqual(res, dns.rcode.NOERROR)
 155             self.assertRRsetInAnswer(res, expected)