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