From: Remi Gacogne Date: Thu, 12 Mar 2020 10:44:01 +0000 (+0100) Subject: rec: Fix EDNS padding regression test in Circle CI (no IPv6 there) X-Git-Tag: rec-4.5.0-beta1~3^2~12 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=b2d3e2b08ff3e5f6744fd8a8f7682045efdcfb21;p=thirdparty%2Fpdns.git rec: Fix EDNS padding regression test in Circle CI (no IPv6 there) --- diff --git a/.circleci/config.yml b/.circleci/config.yml index c43545f02e..6368763ed6 100644 --- a/.circleci/config.yml +++ b/.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 diff --git a/regression-tests.recursor-dnssec/test_EDNSPadding.py b/regression-tests.recursor-dnssec/test_EDNSPadding.py index d00f2cb49e..8effc0090b 100644 --- a/regression-tests.recursor-dnssec/test_EDNSPadding.py +++ b/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 @@ class RecursorEDNSPaddingTest(RecursorTest): 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 @@ class PaddingDefaultTest(RecursorEDNSPaddingTest): 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 @@ edns-padding-tag=7830 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 @@ edns-padding-tag=7830 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 @@ local-address=127.0.0.1, ::1 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 @@ local-address=127.0.0.1, ::1 self.checkPadding(res) self.assertRRsetInAnswer(res, expected) - res = self.sendUDPQueryOverIPv6(query) + res = self.sendUDPQueryTo(query, '::1') self.checkPadding(res) self.assertRRsetInAnswer(res, expected)