rec: Fix EDNS padding regression test in Circle CI (no IPv6 there)

.circleci/config.yml

@@ -1269,6 +1269,7 @@ jobs:
         environment:
           UBSAN_OPTIONS: 'print_stacktrace=1:halt_on_error=1'
           ASAN_OPTIONS: detect_leaks=0
+          SKIP_IPV6_TESTS: y
     steps:
       - add-auth-repo
       - run: apt-get --no-install-recommends install -qq -y pdns-server pdns-backend-bind pdns-tools daemontools authbind jq libfaketime lua-posix lua-socket moreutils bc python3-venv protobuf-compiler

regression-tests.recursor-dnssec/test_EDNSPadding.py

@@ -1,6 +1,7 @@
 import dns
 import os
 import socket
+import unittest
 
 import paddingoption
 
@@ -31,41 +32,43 @@ def setUpClass(cls):
         print("Launching tests..")
 
     def checkPadding(self, message, numberOfBytes=None):
-      self.assertEqual(message.edns, 0)
-      self.assertEquals(len(message.options), 1)
-      for option in message.options:
-          self.assertEquals(option.otype, 12)
-          if numberOfBytes:
-              self.assertEquals(option.olen, numberOfBytes)
+        self.assertEqual(message.edns, 0)
+        self.assertEquals(len(message.options), 1)
+        for option in message.options:
+            self.assertEquals(option.otype, 12)
+            if numberOfBytes:
+                self.assertEquals(option.olen, numberOfBytes)
 
     def checkNoPadding(self, message):
-      self.assertEqual(message.edns, 0)
-      self.assertEquals(len(message.options), 0)
+        self.assertEqual(message.edns, 0)
+        self.assertEquals(len(message.options), 0)
 
     def checkNoEDNS(self, message):
-      self.assertEqual(message.edns, -1)
-
-    def sendUDPQueryOverIPv6(self, query, timeout=2.0):
-      sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-      sock.settimeout(2.0)
-      sock.connect(("127.0.0.1", self._recursorPort))
-
-      if timeout:
-        sock.settimeout(timeout)
-
-      try:
-        sock.send(query.to_wire())
-        data = sock.recv(4096)
-      except socket.timeout:
-        data = None
-      finally:
+        self.assertEqual(message.edns, -1)
+
+    def sendUDPQueryTo(self, query, toAddr, v6=True, timeout=2.0):
+        if v6:
+            sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
+        else:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+        sock.settimeout(2.0)
+        sock.connect((toAddr, self._recursorPort))
+
         if timeout:
-          sock.settimeout(None)
+            sock.settimeout(timeout)
 
-      message = None
-      if data:
-        message = dns.message.from_wire(data)
-      return message
+        try:
+            sock.send(query.to_wire())
+            data = sock.recv(4096)
+        except socket.timeout:
+            data = None
+
+        sock.close()
+        message = None
+        if data:
+            message = dns.message.from_wire(data)
+        return message
 
     def testQueryWithoutEDNS(self):
         name = 'secure.example.'
@@ -99,12 +102,39 @@ def testQueryWithoutPadding(self):
         self.checkNoPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
-class PaddingAllowedAlwaysTest(RecursorEDNSPaddingTest):
+class PaddingDefaultNotAllowedTest(RecursorEDNSPaddingTest):
+
+    _confdir = 'PaddingDefaultNotAllowed'
+    _config_template = """edns-padding-from=127.0.0.2
+packetcache-ttl=60
+    """
+
+    def testQueryWithPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        po = paddingoption.PaddingOption(64)
+        query = dns.message.make_query(name, 'A', want_dnssec=True, options=[po])
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+    def testQueryWithoutPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        query = dns.message.make_query(name, 'A', want_dnssec=True)
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+class PaddingAlwaysTest(RecursorEDNSPaddingTest):
 
     _confdir = 'PaddingAlways'
     _config_template = """edns-padding-from=127.0.0.1
 edns-padding-mode=always
 edns-padding-tag=7830
+packetcache-ttl=60
     """
 
     def testQueryWithPadding(self):
@@ -126,12 +156,42 @@ def testQueryWithoutPadding(self):
         self.checkPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
-class PaddingAllowedWhenPaddedTest(RecursorEDNSPaddingTest):
+class PaddingNotAllowedAlwaysTest(RecursorEDNSPaddingTest):
+
+    _confdir = 'PaddingAlwaysNotAllowed'
+    _config_template = """edns-padding-from=127.0.0.2
+edns-padding-mode=always
+edns-padding-tag=7830
+packetcache-ttl=60
+    """
+
+    def testQueryWithPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        po = paddingoption.PaddingOption(64)
+        query = dns.message.make_query(name, 'A', want_dnssec=True, options=[po])
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+    def testQueryWithoutPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        query = dns.message.make_query(name, 'A', want_dnssec=True)
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+class PaddingWhenPaddedTest(RecursorEDNSPaddingTest):
 
     _confdir = 'PaddingWhenPadded'
     _config_template = """edns-padding-from=127.0.0.1
 edns-padding-mode=padded-queries-only
 edns-padding-tag=7830
+local-address=127.0.0.1
+packetcache-ttl=60
     """
 
     def testQueryWithPadding(self):
@@ -153,6 +213,36 @@ def testQueryWithoutPadding(self):
         self.checkNoPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
+class PaddingWhenPaddedNotAllowedTest(RecursorEDNSPaddingTest):
+
+    _confdir = 'PaddingWhenPaddedNotAllowed'
+    _config_template = """edns-padding-from=127.0.0.2
+edns-padding-mode=padded-queries-only
+edns-padding-tag=7830
+local-address=127.0.0.1
+packetcache-ttl=60
+    """
+
+    def testQueryWithPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        po = paddingoption.PaddingOption(64)
+        query = dns.message.make_query(name, 'A', want_dnssec=True, options=[po])
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+    def testQueryWithoutPadding(self):
+        name = 'secure.example.'
+        expected = dns.rrset.from_text(name, 0, dns.rdataclass.IN, 'A', '192.0.2.17')
+        query = dns.message.make_query(name, 'A', want_dnssec=True)
+        query.flags |= dns.flags.CD
+        res = self.sendUDPQuery(query)
+        self.checkNoPadding(res)
+        self.assertRRsetInAnswer(res, expected)
+
+@unittest.skipIf('SKIP_IPV6_TESTS' in os.environ, 'IPv6 tests are disabled')
 class PaddingAllowedAlwaysSameTagTest(RecursorEDNSPaddingTest):
 
     # we use the default tag (0) for padded responses, which will cause
@@ -163,6 +253,7 @@ class PaddingAllowedAlwaysSameTagTest(RecursorEDNSPaddingTest):
 edns-padding-mode=always
 edns-padding-tag=0
 local-address=127.0.0.1, ::1
+packetcache-ttl=60
     """
 
     def testQueryWithPadding(self):
@@ -175,7 +266,7 @@ def testQueryWithPadding(self):
         self.checkPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
-        res = self.sendUDPQueryOverIPv6(query)
+        res = self.sendUDPQueryTo(query, '::1')
         self.checkPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
@@ -188,6 +279,6 @@ def testQueryWithoutPadding(self):
         self.checkPadding(res)
         self.assertRRsetInAnswer(res, expected)
 
-        res = self.sendUDPQueryOverIPv6(query)
+        res = self.sendUDPQueryTo(query, '::1')
         self.checkPadding(res)
         self.assertRRsetInAnswer(res, expected)