Commit 55d98fe776 for bind
commit 55d98fe7767ebf97ef2d0c70e4d430452910aca0
Author: Štěpán Balážik <stepan@isc.org>
Date: Mon Oct 26 14:17:24 2026 +0100
Sign the nsec_wildcard_wrong_zone zones with isctest.zone
ans1 loaded keys from keys.json, signed every answer by hand and picked
its answer with one if-else over the query. The fixture now signs both
zones and the server answers from them; the one forged response turns
the zone's wildcard answer for the attacked name into an NXDOMAIN, with
the other zone's NSEC as the wildcard denial. The self-check of that
response now looks at the NSEC signers instead of owner names, which
come from the zone templates.
Assisted-by: Claude:claude-fable-5-1
diff --git a/bin/tests/system/nsec_wildcard_wrong_zone/ans1/ans.py b/bin/tests/system/nsec_wildcard_wrong_zone/ans1/ans.py
index 60aaeff5c0..ecab610eb2 100644
--- a/bin/tests/system/nsec_wildcard_wrong_zone/ans1/ans.py
+++ b/bin/tests/system/nsec_wildcard_wrong_zone/ans1/ans.py
@@ -9,208 +9,57 @@
# See the COPYRIGHT file distributed with this work for additional
# information regarding copyright ownership.
-from collections.abc import AsyncGenerator
-from dataclasses import dataclass
-from pathlib import Path
-
-import json
-from cryptography.hazmat.primitives import serialization
+from collections.abc import AsyncGenerator
-import dns.dnssec
-import dns.flags
import dns.name
import dns.rcode
-import dns.rdata
-import dns.rdataclass
import dns.rdatatype
-import dns.rrset
from isctest.asyncserver import AsyncDnsServer, QueryContext, ResponseHandler
from isctest.asyncserver.actions import DnsResponseSend
-from isctest.asyncserver.matchers import Domain
-
-TTL = 300
-VICTIM = "victim.example."
-ATTACKER = "abc.example."
-ATTACK = f"foo.{VICTIM}"
-VALID_NXDOMAIN = f"bar.{ATTACKER}"
-CONTROL = f"wild1.{VICTIM}"
-CONTROL_NODATA = f"wild2.{VICTIM}"
-WILDCARD = f"*.{VICTIM}"
-VICTIM_NSEC_OWNER = f"a.{VICTIM}"
-VICTIM_NSEC_NEXT = f"z.{VICTIM}"
-ATTACKER_NSEC_OWNER = f"z.{ATTACKER}"
-ATTACKER_VALID_NSEC_OWNER = f"a.{ATTACKER}"
-CONTROL_A = "192.0.2.1"
-
-
-@dataclass(frozen=True)
-class Key:
- zone: dns.name.Name
- private_key: object
- dnskey: dns.rdata.Rdata
-
-
-def name(text: str) -> dns.name.Name:
- return dns.name.from_text(text)
-
-
-def load_keys() -> dict[str, Key]:
- path = Path(__file__).resolve().parent / "keys.json"
- with path.open(encoding="utf-8") as keys_file:
- raw_keys = json.load(keys_file)
-
- keys = {}
- for zone, raw_key in raw_keys.items():
- private_key = serialization.load_pem_private_key(
- raw_key["private_pem"].encode("ascii"),
- password=None,
- )
- dnskey = dns.rdata.from_text(
- dns.rdataclass.IN, dns.rdatatype.DNSKEY, raw_key["dnskey"]
- )
- keys[zone] = Key(name(zone), private_key, dnskey)
-
- return keys
-
-
-def rrset(owner: str, rdtype: dns.rdatatype.RdataType, rdata: str) -> dns.rrset.RRset:
- return dns.rrset.from_text(owner, TTL, dns.rdataclass.IN, rdtype, rdata)
-
-
-def add_signed(
- section: list[dns.rrset.RRset], covered: dns.rrset.RRset, signer: Key
-) -> None:
- rrsig = dns.dnssec.sign(
- covered,
- signer.private_key,
- signer.zone,
- signer.dnskey,
- lifetime=86400,
- verify=True,
- )
- section.append(covered)
- section.append(dns.rrset.from_rdata(covered.name, covered.ttl, rrsig))
-
-
-def add_dnskey(response, key: Key) -> None:
- dnskey = dns.rrset.from_rdata(key.zone, TTL, key.dnskey)
- add_signed(response.answer, dnskey, key)
-
-
-def soa(zone: str) -> dns.rrset.RRset:
- return rrset(
- zone,
- dns.rdatatype.SOA,
- f"ns.{zone} hostmaster.{zone} 1 3600 600 86400 300",
- )
-
-
-def nsec(owner: str, next_name: str) -> dns.rrset.RRset:
- return rrset(owner, dns.rdatatype.NSEC, f"{next_name} A RRSIG NSEC")
-
-
-def add_wildcard_answer(response, key: Key) -> None:
- wildcard = rrset(WILDCARD, dns.rdatatype.A, CONTROL_A)
- rrsig = dns.dnssec.sign(
- wildcard,
- key.private_key,
- key.zone,
- key.dnskey,
- lifetime=86400,
- verify=True,
- )
- response.answer.append(rrset(CONTROL, dns.rdatatype.A, CONTROL_A))
- response.answer.append(dns.rrset.from_rdata(name(CONTROL), TTL, rrsig))
-
-
-class NsecWildcardWrongZoneHandler(ResponseHandler):
- matcher = Domain(VICTIM, ATTACKER)
-
- def __init__(self, keys: dict[str, Key]) -> None:
- super().__init__()
- self.keys = keys
- self.victim = keys[VICTIM]
- self.attacker = keys[ATTACKER]
+from isctest.asyncserver.dnssec import NonExistenceProver
+from isctest.asyncserver.matchers import Qname, Qtype
+
+
+class AttackNxdomainHandler(ResponseHandler):
+ """
+ Respond to foo.victim.example/A, which the victim's wildcard matches, with
+ a forged NXDOMAIN: the victim's NSEC covering the name (already in the
+ prepared wildcard answer), the victim's SOA, and, as the proof that the
+ wildcard *.victim.example does not exist, an NSEC covering it from the
+ attacker's sibling zone, abc.example.
+
+ A validator that only compares the names takes the second NSEC as the
+ proof that no wildcard matches and marks the NXDOMAIN secure.
+ """
+
+ matcher = Qname("foo.victim.example.") & Qtype(dns.rdatatype.A)
async def get_responses(
self, qctx: QueryContext
) -> AsyncGenerator[DnsResponseSend, None]:
- qctx.prepare_new_response(with_zone_data=False)
- qctx.response.flags |= dns.flags.AA
- qctx.response.set_rcode(dns.rcode.NOERROR)
-
- if qctx.qtype == dns.rdatatype.DNSKEY and qctx.qname in {
- self.victim.zone,
- self.attacker.zone,
- }:
- add_dnskey(qctx.response, self.keys[qctx.qname.to_text()])
- elif qctx.qtype == dns.rdatatype.SOA and qctx.qname in {
- self.victim.zone,
- self.attacker.zone,
- }:
- zone = qctx.qname.to_text()
- add_signed(qctx.response.answer, soa(zone), self.keys[zone])
- elif qctx.qname == name(ATTACK) and qctx.qtype == dns.rdatatype.A:
- qctx.response.set_rcode(dns.rcode.NXDOMAIN)
- add_signed(qctx.response.authority, soa(VICTIM), self.victim)
-
- # This secure terminal NSEC from an unrelated zone sorts across
- # the victim wildcard and used to be accepted as NOWILDCARD.
- add_signed(
- qctx.response.authority,
- nsec(ATTACKER_NSEC_OWNER, ATTACKER),
- self.attacker,
- )
- add_signed(
- qctx.response.authority,
- nsec(VICTIM_NSEC_OWNER, VICTIM_NSEC_NEXT),
- self.victim,
- )
- elif qctx.qname == name(VALID_NXDOMAIN) and qctx.qtype == dns.rdatatype.A:
- qctx.response.set_rcode(dns.rcode.NXDOMAIN)
- add_signed(qctx.response.authority, soa(ATTACKER), self.attacker)
- add_signed(
- qctx.response.authority,
- nsec(ATTACKER_VALID_NSEC_OWNER, ATTACKER_NSEC_OWNER),
- self.attacker,
- )
- add_signed(
- qctx.response.authority,
- nsec(ATTACKER, ATTACKER_VALID_NSEC_OWNER),
- self.attacker,
- )
- elif qctx.qname == name(CONTROL) and qctx.qtype == dns.rdatatype.A:
- add_wildcard_answer(qctx.response, self.victim)
- add_signed(
- qctx.response.authority,
- nsec(VICTIM_NSEC_OWNER, VICTIM_NSEC_NEXT),
- self.victim,
- )
- elif qctx.qname == name(CONTROL_NODATA) and qctx.qtype == dns.rdatatype.AAAA:
- add_signed(qctx.response.authority, soa(VICTIM), self.victim)
- add_signed(
- qctx.response.authority,
- nsec(VICTIM_NSEC_OWNER, VICTIM_NSEC_NEXT),
- self.victim,
- )
- add_signed(
- qctx.response.authority,
- nsec(WILDCARD, VICTIM_NSEC_OWNER),
- self.victim,
- )
- else:
- qctx.response.set_rcode(dns.rcode.NXDOMAIN)
- zone = VICTIM if qctx.qname.is_subdomain(self.victim.zone) else ATTACKER
- add_signed(qctx.response.authority, soa(zone), self.keys[zone])
-
- yield DnsResponseSend(qctx.response, authoritative=True)
+ qctx.response.set_rcode(dns.rcode.NXDOMAIN)
+ qctx.response.answer.clear()
+
+ assert qctx.soa
+ soa_rrsig = qctx.get_rrsig(qctx.soa)
+ assert soa_rrsig
+ qctx.response.authority.extend([qctx.soa, soa_rrsig])
+
+ NonExistenceProver.for_query(
+ zone=qctx.zones[dns.name.from_text("abc.example.")],
+ qname=dns.name.from_text("*.victim.example."),
+ qclass=qctx.qclass,
+ response=qctx.response,
+ ).prove_ent()
+
+ yield DnsResponseSend(qctx.response)
def main() -> None:
server = AsyncDnsServer(default_aa=True)
- server.install_response_handler(NsecWildcardWrongZoneHandler(load_keys()))
+ server.install_response_handlers(AttackNxdomainHandler())
server.run()
diff --git a/bin/tests/system/nsec_wildcard_wrong_zone/ans1/zones/victim.example.db.j2.manual b/bin/tests/system/nsec_wildcard_wrong_zone/ans1/zones/victim.example.db.j2.manual
new file mode 100644
index 0000000000..0b431de5a7
--- /dev/null
+++ b/bin/tests/system/nsec_wildcard_wrong_zone/ans1/zones/victim.example.db.j2.manual
@@ -0,0 +1,4 @@
+{% include "_common/zones/soa.partial.db.j2" %}
+{% include "_common/zones/ns.partial.db.j2" %}
+
+* A 192.0.2.1
diff --git a/bin/tests/system/nsec_wildcard_wrong_zone/ns2/named.conf.j2 b/bin/tests/system/nsec_wildcard_wrong_zone/ns2/named.conf.j2
index 621b552ccd..3973d645f8 100644
--- a/bin/tests/system/nsec_wildcard_wrong_zone/ns2/named.conf.j2
+++ b/bin/tests/system/nsec_wildcard_wrong_zone/ns2/named.conf.j2
@@ -19,7 +19,4 @@ zone "abc.example" {
server-addresses { 10.53.0.1; };
};
-trust-anchors {
- victim.example. static-key 257 3 13 "@VICTIM_DNSKEY@";
- abc.example. static-key 257 3 13 "@ATTACKER_DNSKEY@";
-};
+{% include "_common/trusted.conf.j2" %}
diff --git a/bin/tests/system/nsec_wildcard_wrong_zone/tests_nsec_wildcard_wrong_zone.py b/bin/tests/system/nsec_wildcard_wrong_zone/tests_nsec_wildcard_wrong_zone.py
index 7e7e45aae1..97ef6f4896 100644
--- a/bin/tests/system/nsec_wildcard_wrong_zone/tests_nsec_wildcard_wrong_zone.py
+++ b/bin/tests/system/nsec_wildcard_wrong_zone/tests_nsec_wildcard_wrong_zone.py
@@ -9,21 +9,14 @@
# See the COPYRIGHT file distributed with this work for additional
# information regarding copyright ownership.
-from pathlib import Path
-
-import json
-
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import ec
-
-import dns.dnssec
import dns.name
import dns.rdataclass
import dns.rdatatype
import pytest
import isctest
-import isctest.mark
+import isctest.template
+import isctest.zone
VICTIM = "victim.example."
ATTACKER = "abc.example."
@@ -31,71 +24,41 @@ ATTACK = f"foo.{VICTIM}"
VALID_NXDOMAIN = f"bar.{ATTACKER}"
CONTROL = f"wild1.{VICTIM}"
CONTROL_NODATA = f"wild2.{VICTIM}"
-VICTIM_NSEC_OWNER = f"a.{VICTIM}"
-ATTACKER_NSEC_OWNER = f"z.{ATTACKER}"
CONTROL_A = "192.0.2.1"
AUTH = "10.53.0.1"
RESOLVER = "10.53.0.2"
-pytestmark = [
- isctest.mark.with_ecdsa_deterministic,
- pytest.mark.extra_artifacts(
- [
- "ans*/keys.json",
- ]
- ),
-]
-
-
-def _make_key():
- private_key = ec.generate_private_key(ec.SECP256R1())
- dnskey = dns.dnssec.make_dnskey(
- private_key.public_key(),
- algorithm="ECDSAP256SHA256",
- flags=257,
- )
- private_pem = private_key.private_bytes(
- encoding=serialization.Encoding.PEM,
- format=serialization.PrivateFormat.PKCS8,
- encryption_algorithm=serialization.NoEncryption(),
- ).decode("ascii")
- return {
- "private_pem": private_pem,
- "dnskey": dnskey.to_text(),
- }
+pytestmark = pytest.mark.extra_artifacts(
+ [
+ "ans*/dsset-*",
+ "ans*/zones/*.db",
+ "ans*/zones/*.db.signed",
+ ]
+)
def bootstrap():
- keys = {zone: _make_key() for zone in [VICTIM, ATTACKER]}
- Path("ans1/keys.json").write_text(json.dumps(keys, indent=2), encoding="ascii")
- return {
- "VICTIM_DNSKEY": "".join(keys[VICTIM]["dnskey"].split()[3:]),
- "ATTACKER_DNSKEY": "".join(keys[ATTACKER]["dnskey"].split()[3:]),
- }
-
-
-def _check_nsec_signer(response, owner, signer):
- text = response.to_text()
- nsec = response.get_rrset(
- response.authority, owner, dns.rdataclass.IN, dns.rdatatype.NSEC
- )
- rrsig = response.get_rrset(
- response.authority,
- owner,
- dns.rdataclass.IN,
- dns.rdatatype.RRSIG,
- covers=dns.rdatatype.NSEC,
- )
- assert nsec and rrsig, text
- assert rrsig[0].signer == dns.name.from_text(signer), text
+ trust_anchors = []
+ for name in (VICTIM, ATTACKER):
+ zone = isctest.zone.Zone(name, isctest.template.ANS1, signed=True)
+ zone.configure(csk=True)
+ trust_anchors += zone.trust_anchors()
+ return {"trust_anchors": trust_anchors}
def test_forged_response_contains_cross_zone_nsec():
response = isctest.query.tcp(isctest.query.create(ATTACK, "A"), AUTH)
isctest.check.nxdomain(response)
- _check_nsec_signer(response, ATTACKER_NSEC_OWNER, ATTACKER)
- _check_nsec_signer(response, VICTIM_NSEC_OWNER, VICTIM)
+ signers = {
+ rrsig[0].signer
+ for rrsig in response.authority
+ if rrsig.rdtype == dns.rdatatype.RRSIG and rrsig.covers == dns.rdatatype.NSEC
+ }
+ assert signers == {
+ dns.name.from_text(VICTIM),
+ dns.name.from_text(ATTACKER),
+ }, response.to_text()
def test_resolver_rejects_cross_zone_nowildcard_proof():