9bbeb35c08
Fixed an issue that prevented the password reset tokens from working. Added email templates for password reset success and new account creation. Added more dynamic email template support.
1888 lines
64 KiB
Python
1888 lines
64 KiB
Python
# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
|
|
|
|
# Copyright (C) 2001-2017 Nominum, Inc.
|
|
#
|
|
# Permission to use, copy, modify, and distribute this software and its
|
|
# documentation for any purpose with or without fee is hereby granted,
|
|
# provided that the above copyright notice and this permission notice
|
|
# appear in all copies.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
|
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
|
|
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
|
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
"""DNS Messages"""
|
|
|
|
import contextlib
|
|
import io
|
|
import time
|
|
from typing import Any, Dict, List, Optional, Tuple, Union
|
|
|
|
import dns.edns
|
|
import dns.entropy
|
|
import dns.enum
|
|
import dns.exception
|
|
import dns.flags
|
|
import dns.name
|
|
import dns.opcode
|
|
import dns.rcode
|
|
import dns.rdata
|
|
import dns.rdataclass
|
|
import dns.rdatatype
|
|
import dns.rdtypes.ANY.OPT
|
|
import dns.rdtypes.ANY.TSIG
|
|
import dns.renderer
|
|
import dns.rrset
|
|
import dns.tsig
|
|
import dns.ttl
|
|
import dns.wire
|
|
|
|
|
|
class ShortHeader(dns.exception.FormError):
|
|
"""The DNS packet passed to from_wire() is too short."""
|
|
|
|
|
|
class TrailingJunk(dns.exception.FormError):
|
|
"""The DNS packet passed to from_wire() has extra junk at the end of it."""
|
|
|
|
|
|
class UnknownHeaderField(dns.exception.DNSException):
|
|
"""The header field name was not recognized when converting from text
|
|
into a message."""
|
|
|
|
|
|
class BadEDNS(dns.exception.FormError):
|
|
"""An OPT record occurred somewhere other than
|
|
the additional data section."""
|
|
|
|
|
|
class BadTSIG(dns.exception.FormError):
|
|
"""A TSIG record occurred somewhere other than the end of
|
|
the additional data section."""
|
|
|
|
|
|
class UnknownTSIGKey(dns.exception.DNSException):
|
|
"""A TSIG with an unknown key was received."""
|
|
|
|
|
|
class Truncated(dns.exception.DNSException):
|
|
"""The truncated flag is set."""
|
|
|
|
supp_kwargs = {"message"}
|
|
|
|
# We do this as otherwise mypy complains about unexpected keyword argument
|
|
# idna_exception
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
def message(self):
|
|
"""As much of the message as could be processed.
|
|
|
|
Returns a ``dns.message.Message``.
|
|
"""
|
|
return self.kwargs["message"]
|
|
|
|
|
|
class NotQueryResponse(dns.exception.DNSException):
|
|
"""Message is not a response to a query."""
|
|
|
|
|
|
class ChainTooLong(dns.exception.DNSException):
|
|
"""The CNAME chain is too long."""
|
|
|
|
|
|
class AnswerForNXDOMAIN(dns.exception.DNSException):
|
|
"""The rcode is NXDOMAIN but an answer was found."""
|
|
|
|
|
|
class NoPreviousName(dns.exception.SyntaxError):
|
|
"""No previous name was known."""
|
|
|
|
|
|
class MessageSection(dns.enum.IntEnum):
|
|
"""Message sections"""
|
|
|
|
QUESTION = 0
|
|
ANSWER = 1
|
|
AUTHORITY = 2
|
|
ADDITIONAL = 3
|
|
|
|
@classmethod
|
|
def _maximum(cls):
|
|
return 3
|
|
|
|
|
|
class MessageError:
|
|
def __init__(self, exception: Exception, offset: int):
|
|
self.exception = exception
|
|
self.offset = offset
|
|
|
|
|
|
DEFAULT_EDNS_PAYLOAD = 1232
|
|
MAX_CHAIN = 16
|
|
|
|
IndexKeyType = Tuple[
|
|
int,
|
|
dns.name.Name,
|
|
dns.rdataclass.RdataClass,
|
|
dns.rdatatype.RdataType,
|
|
Optional[dns.rdatatype.RdataType],
|
|
Optional[dns.rdataclass.RdataClass],
|
|
]
|
|
IndexType = Dict[IndexKeyType, dns.rrset.RRset]
|
|
SectionType = Union[int, str, List[dns.rrset.RRset]]
|
|
|
|
|
|
class Message:
|
|
"""A DNS message."""
|
|
|
|
_section_enum = MessageSection
|
|
|
|
def __init__(self, id: Optional[int] = None):
|
|
if id is None:
|
|
self.id = dns.entropy.random_16()
|
|
else:
|
|
self.id = id
|
|
self.flags = 0
|
|
self.sections: List[List[dns.rrset.RRset]] = [[], [], [], []]
|
|
self.opt: Optional[dns.rrset.RRset] = None
|
|
self.request_payload = 0
|
|
self.pad = 0
|
|
self.keyring: Any = None
|
|
self.tsig: Optional[dns.rrset.RRset] = None
|
|
self.request_mac = b""
|
|
self.xfr = False
|
|
self.origin: Optional[dns.name.Name] = None
|
|
self.tsig_ctx: Optional[Any] = None
|
|
self.index: IndexType = {}
|
|
self.errors: List[MessageError] = []
|
|
self.time = 0.0
|
|
|
|
@property
|
|
def question(self) -> List[dns.rrset.RRset]:
|
|
"""The question section."""
|
|
return self.sections[0]
|
|
|
|
@question.setter
|
|
def question(self, v):
|
|
self.sections[0] = v
|
|
|
|
@property
|
|
def answer(self) -> List[dns.rrset.RRset]:
|
|
"""The answer section."""
|
|
return self.sections[1]
|
|
|
|
@answer.setter
|
|
def answer(self, v):
|
|
self.sections[1] = v
|
|
|
|
@property
|
|
def authority(self) -> List[dns.rrset.RRset]:
|
|
"""The authority section."""
|
|
return self.sections[2]
|
|
|
|
@authority.setter
|
|
def authority(self, v):
|
|
self.sections[2] = v
|
|
|
|
@property
|
|
def additional(self) -> List[dns.rrset.RRset]:
|
|
"""The additional data section."""
|
|
return self.sections[3]
|
|
|
|
@additional.setter
|
|
def additional(self, v):
|
|
self.sections[3] = v
|
|
|
|
def __repr__(self):
|
|
return "<DNS message, ID " + repr(self.id) + ">"
|
|
|
|
def __str__(self):
|
|
return self.to_text()
|
|
|
|
def to_text(
|
|
self,
|
|
origin: Optional[dns.name.Name] = None,
|
|
relativize: bool = True,
|
|
**kw: Dict[str, Any],
|
|
) -> str:
|
|
"""Convert the message to text.
|
|
|
|
The *origin*, *relativize*, and any other keyword
|
|
arguments are passed to the RRset ``to_wire()`` method.
|
|
|
|
Returns a ``str``.
|
|
"""
|
|
|
|
s = io.StringIO()
|
|
s.write("id %d\n" % self.id)
|
|
s.write("opcode %s\n" % dns.opcode.to_text(self.opcode()))
|
|
s.write("rcode %s\n" % dns.rcode.to_text(self.rcode()))
|
|
s.write("flags %s\n" % dns.flags.to_text(self.flags))
|
|
if self.edns >= 0:
|
|
s.write("edns %s\n" % self.edns)
|
|
if self.ednsflags != 0:
|
|
s.write("eflags %s\n" % dns.flags.edns_to_text(self.ednsflags))
|
|
s.write("payload %d\n" % self.payload)
|
|
for opt in self.options:
|
|
s.write("option %s\n" % opt.to_text())
|
|
for name, which in self._section_enum.__members__.items():
|
|
s.write(f";{name}\n")
|
|
for rrset in self.section_from_number(which):
|
|
s.write(rrset.to_text(origin, relativize, **kw))
|
|
s.write("\n")
|
|
#
|
|
# We strip off the final \n so the caller can print the result without
|
|
# doing weird things to get around eccentricities in Python print
|
|
# formatting
|
|
#
|
|
return s.getvalue()[:-1]
|
|
|
|
def __eq__(self, other):
|
|
"""Two messages are equal if they have the same content in the
|
|
header, question, answer, and authority sections.
|
|
|
|
Returns a ``bool``.
|
|
"""
|
|
|
|
if not isinstance(other, Message):
|
|
return False
|
|
if self.id != other.id:
|
|
return False
|
|
if self.flags != other.flags:
|
|
return False
|
|
for i, section in enumerate(self.sections):
|
|
other_section = other.sections[i]
|
|
for n in section:
|
|
if n not in other_section:
|
|
return False
|
|
for n in other_section:
|
|
if n not in section:
|
|
return False
|
|
return True
|
|
|
|
def __ne__(self, other):
|
|
return not self.__eq__(other)
|
|
|
|
def is_response(self, other: "Message") -> bool:
|
|
"""Is *other*, also a ``dns.message.Message``, a response to this
|
|
message?
|
|
|
|
Returns a ``bool``.
|
|
"""
|
|
|
|
if (
|
|
other.flags & dns.flags.QR == 0
|
|
or self.id != other.id
|
|
or dns.opcode.from_flags(self.flags) != dns.opcode.from_flags(other.flags)
|
|
):
|
|
return False
|
|
if other.rcode() in {
|
|
dns.rcode.FORMERR,
|
|
dns.rcode.SERVFAIL,
|
|
dns.rcode.NOTIMP,
|
|
dns.rcode.REFUSED,
|
|
}:
|
|
# We don't check the question section in these cases if
|
|
# the other question section is empty, even though they
|
|
# still really ought to have a question section.
|
|
if len(other.question) == 0:
|
|
return True
|
|
if dns.opcode.is_update(self.flags):
|
|
# This is assuming the "sender doesn't include anything
|
|
# from the update", but we don't care to check the other
|
|
# case, which is that all the sections are returned and
|
|
# identical.
|
|
return True
|
|
for n in self.question:
|
|
if n not in other.question:
|
|
return False
|
|
for n in other.question:
|
|
if n not in self.question:
|
|
return False
|
|
return True
|
|
|
|
def section_number(self, section: List[dns.rrset.RRset]) -> int:
|
|
"""Return the "section number" of the specified section for use
|
|
in indexing.
|
|
|
|
*section* is one of the section attributes of this message.
|
|
|
|
Raises ``ValueError`` if the section isn't known.
|
|
|
|
Returns an ``int``.
|
|
"""
|
|
|
|
for i, our_section in enumerate(self.sections):
|
|
if section is our_section:
|
|
return self._section_enum(i)
|
|
raise ValueError("unknown section")
|
|
|
|
def section_from_number(self, number: int) -> List[dns.rrset.RRset]:
|
|
"""Return the section list associated with the specified section
|
|
number.
|
|
|
|
*number* is a section number `int` or the text form of a section
|
|
name.
|
|
|
|
Raises ``ValueError`` if the section isn't known.
|
|
|
|
Returns a ``list``.
|
|
"""
|
|
|
|
section = self._section_enum.make(number)
|
|
return self.sections[section]
|
|
|
|
def find_rrset(
|
|
self,
|
|
section: SectionType,
|
|
name: dns.name.Name,
|
|
rdclass: dns.rdataclass.RdataClass,
|
|
rdtype: dns.rdatatype.RdataType,
|
|
covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
|
|
deleting: Optional[dns.rdataclass.RdataClass] = None,
|
|
create: bool = False,
|
|
force_unique: bool = False,
|
|
idna_codec: Optional[dns.name.IDNACodec] = None,
|
|
) -> dns.rrset.RRset:
|
|
"""Find the RRset with the given attributes in the specified section.
|
|
|
|
*section*, an ``int`` section number, a ``str`` section name, or one of
|
|
the section attributes of this message. This specifies the
|
|
the section of the message to search. For example::
|
|
|
|
my_message.find_rrset(my_message.answer, name, rdclass, rdtype)
|
|
my_message.find_rrset(dns.message.ANSWER, name, rdclass, rdtype)
|
|
my_message.find_rrset("ANSWER", name, rdclass, rdtype)
|
|
|
|
*name*, a ``dns.name.Name`` or ``str``, the name of the RRset.
|
|
|
|
*rdclass*, an ``int`` or ``str``, the class of the RRset.
|
|
|
|
*rdtype*, an ``int`` or ``str``, the type of the RRset.
|
|
|
|
*covers*, an ``int`` or ``str``, the covers value of the RRset.
|
|
The default is ``dns.rdatatype.NONE``.
|
|
|
|
*deleting*, an ``int``, ``str``, or ``None``, the deleting value of the
|
|
RRset. The default is ``None``.
|
|
|
|
*create*, a ``bool``. If ``True``, create the RRset if it is not found.
|
|
The created RRset is appended to *section*.
|
|
|
|
*force_unique*, a ``bool``. If ``True`` and *create* is also ``True``,
|
|
create a new RRset regardless of whether a matching RRset exists
|
|
already. The default is ``False``. This is useful when creating
|
|
DDNS Update messages, as order matters for them.
|
|
|
|
*idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
|
|
encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder
|
|
is used.
|
|
|
|
Raises ``KeyError`` if the RRset was not found and create was
|
|
``False``.
|
|
|
|
Returns a ``dns.rrset.RRset object``.
|
|
"""
|
|
|
|
if isinstance(section, int):
|
|
section_number = section
|
|
section = self.section_from_number(section_number)
|
|
elif isinstance(section, str):
|
|
section_number = self._section_enum.from_text(section)
|
|
section = self.section_from_number(section_number)
|
|
else:
|
|
section_number = self.section_number(section)
|
|
if isinstance(name, str):
|
|
name = dns.name.from_text(name, idna_codec=idna_codec)
|
|
rdtype = dns.rdatatype.RdataType.make(rdtype)
|
|
rdclass = dns.rdataclass.RdataClass.make(rdclass)
|
|
covers = dns.rdatatype.RdataType.make(covers)
|
|
if deleting is not None:
|
|
deleting = dns.rdataclass.RdataClass.make(deleting)
|
|
key = (section_number, name, rdclass, rdtype, covers, deleting)
|
|
if not force_unique:
|
|
if self.index is not None:
|
|
rrset = self.index.get(key)
|
|
if rrset is not None:
|
|
return rrset
|
|
else:
|
|
for rrset in section:
|
|
if rrset.full_match(name, rdclass, rdtype, covers, deleting):
|
|
return rrset
|
|
if not create:
|
|
raise KeyError
|
|
rrset = dns.rrset.RRset(name, rdclass, rdtype, covers, deleting)
|
|
section.append(rrset)
|
|
if self.index is not None:
|
|
self.index[key] = rrset
|
|
return rrset
|
|
|
|
def get_rrset(
|
|
self,
|
|
section: SectionType,
|
|
name: dns.name.Name,
|
|
rdclass: dns.rdataclass.RdataClass,
|
|
rdtype: dns.rdatatype.RdataType,
|
|
covers: dns.rdatatype.RdataType = dns.rdatatype.NONE,
|
|
deleting: Optional[dns.rdataclass.RdataClass] = None,
|
|
create: bool = False,
|
|
force_unique: bool = False,
|
|
idna_codec: Optional[dns.name.IDNACodec] = None,
|
|
) -> Optional[dns.rrset.RRset]:
|
|
"""Get the RRset with the given attributes in the specified section.
|
|
|
|
If the RRset is not found, None is returned.
|
|
|
|
*section*, an ``int`` section number, a ``str`` section name, or one of
|
|
the section attributes of this message. This specifies the
|
|
the section of the message to search. For example::
|
|
|
|
my_message.get_rrset(my_message.answer, name, rdclass, rdtype)
|
|
my_message.get_rrset(dns.message.ANSWER, name, rdclass, rdtype)
|
|
my_message.get_rrset("ANSWER", name, rdclass, rdtype)
|
|
|
|
*name*, a ``dns.name.Name`` or ``str``, the name of the RRset.
|
|
|
|
*rdclass*, an ``int`` or ``str``, the class of the RRset.
|
|
|
|
*rdtype*, an ``int`` or ``str``, the type of the RRset.
|
|
|
|
*covers*, an ``int`` or ``str``, the covers value of the RRset.
|
|
The default is ``dns.rdatatype.NONE``.
|
|
|
|
*deleting*, an ``int``, ``str``, or ``None``, the deleting value of the
|
|
RRset. The default is ``None``.
|
|
|
|
*create*, a ``bool``. If ``True``, create the RRset if it is not found.
|
|
The created RRset is appended to *section*.
|
|
|
|
*force_unique*, a ``bool``. If ``True`` and *create* is also ``True``,
|
|
create a new RRset regardless of whether a matching RRset exists
|
|
already. The default is ``False``. This is useful when creating
|
|
DDNS Update messages, as order matters for them.
|
|
|
|
*idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
|
|
encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder
|
|
is used.
|
|
|
|
Returns a ``dns.rrset.RRset object`` or ``None``.
|
|
"""
|
|
|
|
try:
|
|
rrset = self.find_rrset(
|
|
section,
|
|
name,
|
|
rdclass,
|
|
rdtype,
|
|
covers,
|
|
deleting,
|
|
create,
|
|
force_unique,
|
|
idna_codec,
|
|
)
|
|
except KeyError:
|
|
rrset = None
|
|
return rrset
|
|
|
|
def section_count(self, section: SectionType) -> int:
|
|
"""Returns the number of records in the specified section.
|
|
|
|
*section*, an ``int`` section number, a ``str`` section name, or one of
|
|
the section attributes of this message. This specifies the
|
|
the section of the message to count. For example::
|
|
|
|
my_message.section_count(my_message.answer)
|
|
my_message.section_count(dns.message.ANSWER)
|
|
my_message.section_count("ANSWER")
|
|
"""
|
|
|
|
if isinstance(section, int):
|
|
section_number = section
|
|
section = self.section_from_number(section_number)
|
|
elif isinstance(section, str):
|
|
section_number = self._section_enum.from_text(section)
|
|
section = self.section_from_number(section_number)
|
|
else:
|
|
section_number = self.section_number(section)
|
|
count = sum(max(1, len(rrs)) for rrs in section)
|
|
if section_number == MessageSection.ADDITIONAL:
|
|
if self.opt is not None:
|
|
count += 1
|
|
if self.tsig is not None:
|
|
count += 1
|
|
return count
|
|
|
|
def _compute_opt_reserve(self) -> int:
|
|
"""Compute the size required for the OPT RR, padding excluded"""
|
|
if not self.opt:
|
|
return 0
|
|
# 1 byte for the root name, 10 for the standard RR fields
|
|
size = 11
|
|
# This would be more efficient if options had a size() method, but we won't
|
|
# worry about that for now. We also don't worry if there is an existing padding
|
|
# option, as it is unlikely and probably harmless, as the worst case is that we
|
|
# may add another, and this seems to be legal.
|
|
for option in self.opt[0].options:
|
|
wire = option.to_wire()
|
|
# We add 4 here to account for the option type and length
|
|
size += len(wire) + 4
|
|
if self.pad:
|
|
# Padding will be added, so again add the option type and length.
|
|
size += 4
|
|
return size
|
|
|
|
def _compute_tsig_reserve(self) -> int:
|
|
"""Compute the size required for the TSIG RR"""
|
|
# This would be more efficient if TSIGs had a size method, but we won't
|
|
# worry about for now. Also, we can't really cope with the potential
|
|
# compressibility of the TSIG owner name, so we estimate with the uncompressed
|
|
# size. We will disable compression when TSIG and padding are both is active
|
|
# so that the padding comes out right.
|
|
if not self.tsig:
|
|
return 0
|
|
f = io.BytesIO()
|
|
self.tsig.to_wire(f)
|
|
return len(f.getvalue())
|
|
|
|
def to_wire(
|
|
self,
|
|
origin: Optional[dns.name.Name] = None,
|
|
max_size: int = 0,
|
|
multi: bool = False,
|
|
tsig_ctx: Optional[Any] = None,
|
|
prepend_length: bool = False,
|
|
prefer_truncation: bool = False,
|
|
**kw: Dict[str, Any],
|
|
) -> bytes:
|
|
"""Return a string containing the message in DNS compressed wire
|
|
format.
|
|
|
|
Additional keyword arguments are passed to the RRset ``to_wire()``
|
|
method.
|
|
|
|
*origin*, a ``dns.name.Name`` or ``None``, the origin to be appended
|
|
to any relative names. If ``None``, and the message has an origin
|
|
attribute that is not ``None``, then it will be used.
|
|
|
|
*max_size*, an ``int``, the maximum size of the wire format
|
|
output; default is 0, which means "the message's request
|
|
payload, if nonzero, or 65535".
|
|
|
|
*multi*, a ``bool``, should be set to ``True`` if this message is
|
|
part of a multiple message sequence.
|
|
|
|
*tsig_ctx*, a ``dns.tsig.HMACTSig`` or ``dns.tsig.GSSTSig`` object, the
|
|
ongoing TSIG context, used when signing zone transfers.
|
|
|
|
*prepend_length*, a ``bool``, should be set to ``True`` if the caller
|
|
wants the message length prepended to the message itself. This is
|
|
useful for messages sent over TCP, TLS (DoT), or QUIC (DoQ).
|
|
|
|
*prefer_truncation*, a ``bool``, should be set to ``True`` if the caller
|
|
wants the message to be truncated if it would otherwise exceed the
|
|
maximum length. If the truncation occurs before the additional section,
|
|
the TC bit will be set.
|
|
|
|
Raises ``dns.exception.TooBig`` if *max_size* was exceeded.
|
|
|
|
Returns a ``bytes``.
|
|
"""
|
|
|
|
if origin is None and self.origin is not None:
|
|
origin = self.origin
|
|
if max_size == 0:
|
|
if self.request_payload != 0:
|
|
max_size = self.request_payload
|
|
else:
|
|
max_size = 65535
|
|
if max_size < 512:
|
|
max_size = 512
|
|
elif max_size > 65535:
|
|
max_size = 65535
|
|
r = dns.renderer.Renderer(self.id, self.flags, max_size, origin)
|
|
opt_reserve = self._compute_opt_reserve()
|
|
r.reserve(opt_reserve)
|
|
tsig_reserve = self._compute_tsig_reserve()
|
|
r.reserve(tsig_reserve)
|
|
try:
|
|
for rrset in self.question:
|
|
r.add_question(rrset.name, rrset.rdtype, rrset.rdclass)
|
|
for rrset in self.answer:
|
|
r.add_rrset(dns.renderer.ANSWER, rrset, **kw)
|
|
for rrset in self.authority:
|
|
r.add_rrset(dns.renderer.AUTHORITY, rrset, **kw)
|
|
for rrset in self.additional:
|
|
r.add_rrset(dns.renderer.ADDITIONAL, rrset, **kw)
|
|
except dns.exception.TooBig:
|
|
if prefer_truncation:
|
|
if r.section < dns.renderer.ADDITIONAL:
|
|
r.flags |= dns.flags.TC
|
|
else:
|
|
raise
|
|
r.release_reserved()
|
|
if self.opt is not None:
|
|
r.add_opt(self.opt, self.pad, opt_reserve, tsig_reserve)
|
|
r.write_header()
|
|
if self.tsig is not None:
|
|
(new_tsig, ctx) = dns.tsig.sign(
|
|
r.get_wire(),
|
|
self.keyring,
|
|
self.tsig[0],
|
|
int(time.time()),
|
|
self.request_mac,
|
|
tsig_ctx,
|
|
multi,
|
|
)
|
|
self.tsig.clear()
|
|
self.tsig.add(new_tsig)
|
|
r.add_rrset(dns.renderer.ADDITIONAL, self.tsig)
|
|
r.write_header()
|
|
if multi:
|
|
self.tsig_ctx = ctx
|
|
wire = r.get_wire()
|
|
if prepend_length:
|
|
wire = len(wire).to_bytes(2, "big") + wire
|
|
return wire
|
|
|
|
@staticmethod
|
|
def _make_tsig(
|
|
keyname, algorithm, time_signed, fudge, mac, original_id, error, other
|
|
):
|
|
tsig = dns.rdtypes.ANY.TSIG.TSIG(
|
|
dns.rdataclass.ANY,
|
|
dns.rdatatype.TSIG,
|
|
algorithm,
|
|
time_signed,
|
|
fudge,
|
|
mac,
|
|
original_id,
|
|
error,
|
|
other,
|
|
)
|
|
return dns.rrset.from_rdata(keyname, 0, tsig)
|
|
|
|
def use_tsig(
|
|
self,
|
|
keyring: Any,
|
|
keyname: Optional[Union[dns.name.Name, str]] = None,
|
|
fudge: int = 300,
|
|
original_id: Optional[int] = None,
|
|
tsig_error: int = 0,
|
|
other_data: bytes = b"",
|
|
algorithm: Union[dns.name.Name, str] = dns.tsig.default_algorithm,
|
|
) -> None:
|
|
"""When sending, a TSIG signature using the specified key
|
|
should be added.
|
|
|
|
*key*, a ``dns.tsig.Key`` is the key to use. If a key is specified,
|
|
the *keyring* and *algorithm* fields are not used.
|
|
|
|
*keyring*, a ``dict``, ``callable`` or ``dns.tsig.Key``, is either
|
|
the TSIG keyring or key to use.
|
|
|
|
The format of a keyring dict is a mapping from TSIG key name, as
|
|
``dns.name.Name`` to ``dns.tsig.Key`` or a TSIG secret, a ``bytes``.
|
|
If a ``dict`` *keyring* is specified but a *keyname* is not, the key
|
|
used will be the first key in the *keyring*. Note that the order of
|
|
keys in a dictionary is not defined, so applications should supply a
|
|
keyname when a ``dict`` keyring is used, unless they know the keyring
|
|
contains only one key. If a ``callable`` keyring is specified, the
|
|
callable will be called with the message and the keyname, and is
|
|
expected to return a key.
|
|
|
|
*keyname*, a ``dns.name.Name``, ``str`` or ``None``, the name of
|
|
this TSIG key to use; defaults to ``None``. If *keyring* is a
|
|
``dict``, the key must be defined in it. If *keyring* is a
|
|
``dns.tsig.Key``, this is ignored.
|
|
|
|
*fudge*, an ``int``, the TSIG time fudge.
|
|
|
|
*original_id*, an ``int``, the TSIG original id. If ``None``,
|
|
the message's id is used.
|
|
|
|
*tsig_error*, an ``int``, the TSIG error code.
|
|
|
|
*other_data*, a ``bytes``, the TSIG other data.
|
|
|
|
*algorithm*, a ``dns.name.Name`` or ``str``, the TSIG algorithm to use. This is
|
|
only used if *keyring* is a ``dict``, and the key entry is a ``bytes``.
|
|
"""
|
|
|
|
if isinstance(keyring, dns.tsig.Key):
|
|
key = keyring
|
|
keyname = key.name
|
|
elif callable(keyring):
|
|
key = keyring(self, keyname)
|
|
else:
|
|
if isinstance(keyname, str):
|
|
keyname = dns.name.from_text(keyname)
|
|
if keyname is None:
|
|
keyname = next(iter(keyring))
|
|
key = keyring[keyname]
|
|
if isinstance(key, bytes):
|
|
key = dns.tsig.Key(keyname, key, algorithm)
|
|
self.keyring = key
|
|
if original_id is None:
|
|
original_id = self.id
|
|
self.tsig = self._make_tsig(
|
|
keyname,
|
|
self.keyring.algorithm,
|
|
0,
|
|
fudge,
|
|
b"\x00" * dns.tsig.mac_sizes[self.keyring.algorithm],
|
|
original_id,
|
|
tsig_error,
|
|
other_data,
|
|
)
|
|
|
|
@property
|
|
def keyname(self) -> Optional[dns.name.Name]:
|
|
if self.tsig:
|
|
return self.tsig.name
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def keyalgorithm(self) -> Optional[dns.name.Name]:
|
|
if self.tsig:
|
|
return self.tsig[0].algorithm
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def mac(self) -> Optional[bytes]:
|
|
if self.tsig:
|
|
return self.tsig[0].mac
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def tsig_error(self) -> Optional[int]:
|
|
if self.tsig:
|
|
return self.tsig[0].error
|
|
else:
|
|
return None
|
|
|
|
@property
|
|
def had_tsig(self) -> bool:
|
|
return bool(self.tsig)
|
|
|
|
@staticmethod
|
|
def _make_opt(flags=0, payload=DEFAULT_EDNS_PAYLOAD, options=None):
|
|
opt = dns.rdtypes.ANY.OPT.OPT(payload, dns.rdatatype.OPT, options or ())
|
|
return dns.rrset.from_rdata(dns.name.root, int(flags), opt)
|
|
|
|
def use_edns(
|
|
self,
|
|
edns: Optional[Union[int, bool]] = 0,
|
|
ednsflags: int = 0,
|
|
payload: int = DEFAULT_EDNS_PAYLOAD,
|
|
request_payload: Optional[int] = None,
|
|
options: Optional[List[dns.edns.Option]] = None,
|
|
pad: int = 0,
|
|
) -> None:
|
|
"""Configure EDNS behavior.
|
|
|
|
*edns*, an ``int``, is the EDNS level to use. Specifying ``None``, ``False``,
|
|
or ``-1`` means "do not use EDNS", and in this case the other parameters are
|
|
ignored. Specifying ``True`` is equivalent to specifying 0, i.e. "use EDNS0".
|
|
|
|
*ednsflags*, an ``int``, the EDNS flag values.
|
|
|
|
*payload*, an ``int``, is the EDNS sender's payload field, which is the maximum
|
|
size of UDP datagram the sender can handle. I.e. how big a response to this
|
|
message can be.
|
|
|
|
*request_payload*, an ``int``, is the EDNS payload size to use when sending this
|
|
message. If not specified, defaults to the value of *payload*.
|
|
|
|
*options*, a list of ``dns.edns.Option`` objects or ``None``, the EDNS options.
|
|
|
|
*pad*, a non-negative ``int``. If 0, the default, do not pad; otherwise add
|
|
padding bytes to make the message size a multiple of *pad*. Note that if
|
|
padding is non-zero, an EDNS PADDING option will always be added to the
|
|
message.
|
|
"""
|
|
|
|
if edns is None or edns is False:
|
|
edns = -1
|
|
elif edns is True:
|
|
edns = 0
|
|
if edns < 0:
|
|
self.opt = None
|
|
self.request_payload = 0
|
|
else:
|
|
# make sure the EDNS version in ednsflags agrees with edns
|
|
ednsflags &= 0xFF00FFFF
|
|
ednsflags |= edns << 16
|
|
if options is None:
|
|
options = []
|
|
self.opt = self._make_opt(ednsflags, payload, options)
|
|
if request_payload is None:
|
|
request_payload = payload
|
|
self.request_payload = request_payload
|
|
if pad < 0:
|
|
raise ValueError("pad must be non-negative")
|
|
self.pad = pad
|
|
|
|
@property
|
|
def edns(self) -> int:
|
|
if self.opt:
|
|
return (self.ednsflags & 0xFF0000) >> 16
|
|
else:
|
|
return -1
|
|
|
|
@property
|
|
def ednsflags(self) -> int:
|
|
if self.opt:
|
|
return self.opt.ttl
|
|
else:
|
|
return 0
|
|
|
|
@ednsflags.setter
|
|
def ednsflags(self, v):
|
|
if self.opt:
|
|
self.opt.ttl = v
|
|
elif v:
|
|
self.opt = self._make_opt(v)
|
|
|
|
@property
|
|
def payload(self) -> int:
|
|
if self.opt:
|
|
return self.opt[0].payload
|
|
else:
|
|
return 0
|
|
|
|
@property
|
|
def options(self) -> Tuple:
|
|
if self.opt:
|
|
return self.opt[0].options
|
|
else:
|
|
return ()
|
|
|
|
def want_dnssec(self, wanted: bool = True) -> None:
|
|
"""Enable or disable 'DNSSEC desired' flag in requests.
|
|
|
|
*wanted*, a ``bool``. If ``True``, then DNSSEC data is
|
|
desired in the response, EDNS is enabled if required, and then
|
|
the DO bit is set. If ``False``, the DO bit is cleared if
|
|
EDNS is enabled.
|
|
"""
|
|
|
|
if wanted:
|
|
self.ednsflags |= dns.flags.DO
|
|
elif self.opt:
|
|
self.ednsflags &= ~int(dns.flags.DO)
|
|
|
|
def rcode(self) -> dns.rcode.Rcode:
|
|
"""Return the rcode.
|
|
|
|
Returns a ``dns.rcode.Rcode``.
|
|
"""
|
|
return dns.rcode.from_flags(int(self.flags), int(self.ednsflags))
|
|
|
|
def set_rcode(self, rcode: dns.rcode.Rcode) -> None:
|
|
"""Set the rcode.
|
|
|
|
*rcode*, a ``dns.rcode.Rcode``, is the rcode to set.
|
|
"""
|
|
(value, evalue) = dns.rcode.to_flags(rcode)
|
|
self.flags &= 0xFFF0
|
|
self.flags |= value
|
|
self.ednsflags &= 0x00FFFFFF
|
|
self.ednsflags |= evalue
|
|
|
|
def opcode(self) -> dns.opcode.Opcode:
|
|
"""Return the opcode.
|
|
|
|
Returns a ``dns.opcode.Opcode``.
|
|
"""
|
|
return dns.opcode.from_flags(int(self.flags))
|
|
|
|
def set_opcode(self, opcode: dns.opcode.Opcode) -> None:
|
|
"""Set the opcode.
|
|
|
|
*opcode*, a ``dns.opcode.Opcode``, is the opcode to set.
|
|
"""
|
|
self.flags &= 0x87FF
|
|
self.flags |= dns.opcode.to_flags(opcode)
|
|
|
|
def _get_one_rr_per_rrset(self, value):
|
|
# What the caller picked is fine.
|
|
return value
|
|
|
|
# pylint: disable=unused-argument
|
|
|
|
def _parse_rr_header(self, section, name, rdclass, rdtype):
|
|
return (rdclass, rdtype, None, False)
|
|
|
|
# pylint: enable=unused-argument
|
|
|
|
def _parse_special_rr_header(self, section, count, position, name, rdclass, rdtype):
|
|
if rdtype == dns.rdatatype.OPT:
|
|
if (
|
|
section != MessageSection.ADDITIONAL
|
|
or self.opt
|
|
or name != dns.name.root
|
|
):
|
|
raise BadEDNS
|
|
elif rdtype == dns.rdatatype.TSIG:
|
|
if (
|
|
section != MessageSection.ADDITIONAL
|
|
or rdclass != dns.rdatatype.ANY
|
|
or position != count - 1
|
|
):
|
|
raise BadTSIG
|
|
return (rdclass, rdtype, None, False)
|
|
|
|
|
|
class ChainingResult:
|
|
"""The result of a call to dns.message.QueryMessage.resolve_chaining().
|
|
|
|
The ``answer`` attribute is the answer RRSet, or ``None`` if it doesn't
|
|
exist.
|
|
|
|
The ``canonical_name`` attribute is the canonical name after all
|
|
chaining has been applied (this is the same name as ``rrset.name`` in cases
|
|
where rrset is not ``None``).
|
|
|
|
The ``minimum_ttl`` attribute is the minimum TTL, i.e. the TTL to
|
|
use if caching the data. It is the smallest of all the CNAME TTLs
|
|
and either the answer TTL if it exists or the SOA TTL and SOA
|
|
minimum values for negative answers.
|
|
|
|
The ``cnames`` attribute is a list of all the CNAME RRSets followed to
|
|
get to the canonical name.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
canonical_name: dns.name.Name,
|
|
answer: Optional[dns.rrset.RRset],
|
|
minimum_ttl: int,
|
|
cnames: List[dns.rrset.RRset],
|
|
):
|
|
self.canonical_name = canonical_name
|
|
self.answer = answer
|
|
self.minimum_ttl = minimum_ttl
|
|
self.cnames = cnames
|
|
|
|
|
|
class QueryMessage(Message):
|
|
def resolve_chaining(self) -> ChainingResult:
|
|
"""Follow the CNAME chain in the response to determine the answer
|
|
RRset.
|
|
|
|
Raises ``dns.message.NotQueryResponse`` if the message is not
|
|
a response.
|
|
|
|
Raises ``dns.message.ChainTooLong`` if the CNAME chain is too long.
|
|
|
|
Raises ``dns.message.AnswerForNXDOMAIN`` if the rcode is NXDOMAIN
|
|
but an answer was found.
|
|
|
|
Raises ``dns.exception.FormError`` if the question count is not 1.
|
|
|
|
Returns a ChainingResult object.
|
|
"""
|
|
if self.flags & dns.flags.QR == 0:
|
|
raise NotQueryResponse
|
|
if len(self.question) != 1:
|
|
raise dns.exception.FormError
|
|
question = self.question[0]
|
|
qname = question.name
|
|
min_ttl = dns.ttl.MAX_TTL
|
|
answer = None
|
|
count = 0
|
|
cnames = []
|
|
while count < MAX_CHAIN:
|
|
try:
|
|
answer = self.find_rrset(
|
|
self.answer, qname, question.rdclass, question.rdtype
|
|
)
|
|
min_ttl = min(min_ttl, answer.ttl)
|
|
break
|
|
except KeyError:
|
|
if question.rdtype != dns.rdatatype.CNAME:
|
|
try:
|
|
crrset = self.find_rrset(
|
|
self.answer, qname, question.rdclass, dns.rdatatype.CNAME
|
|
)
|
|
cnames.append(crrset)
|
|
min_ttl = min(min_ttl, crrset.ttl)
|
|
for rd in crrset:
|
|
qname = rd.target
|
|
break
|
|
count += 1
|
|
continue
|
|
except KeyError:
|
|
# Exit the chaining loop
|
|
break
|
|
else:
|
|
# Exit the chaining loop
|
|
break
|
|
if count >= MAX_CHAIN:
|
|
raise ChainTooLong
|
|
if self.rcode() == dns.rcode.NXDOMAIN and answer is not None:
|
|
raise AnswerForNXDOMAIN
|
|
if answer is None:
|
|
# Further minimize the TTL with NCACHE.
|
|
auname = qname
|
|
while True:
|
|
# Look for an SOA RR whose owner name is a superdomain
|
|
# of qname.
|
|
try:
|
|
srrset = self.find_rrset(
|
|
self.authority, auname, question.rdclass, dns.rdatatype.SOA
|
|
)
|
|
min_ttl = min(min_ttl, srrset.ttl, srrset[0].minimum)
|
|
break
|
|
except KeyError:
|
|
try:
|
|
auname = auname.parent()
|
|
except dns.name.NoParent:
|
|
break
|
|
return ChainingResult(qname, answer, min_ttl, cnames)
|
|
|
|
def canonical_name(self) -> dns.name.Name:
|
|
"""Return the canonical name of the first name in the question
|
|
section.
|
|
|
|
Raises ``dns.message.NotQueryResponse`` if the message is not
|
|
a response.
|
|
|
|
Raises ``dns.message.ChainTooLong`` if the CNAME chain is too long.
|
|
|
|
Raises ``dns.message.AnswerForNXDOMAIN`` if the rcode is NXDOMAIN
|
|
but an answer was found.
|
|
|
|
Raises ``dns.exception.FormError`` if the question count is not 1.
|
|
"""
|
|
return self.resolve_chaining().canonical_name
|
|
|
|
|
|
def _maybe_import_update():
|
|
# We avoid circular imports by doing this here. We do it in another
|
|
# function as doing it in _message_factory_from_opcode() makes "dns"
|
|
# a local symbol, and the first line fails :)
|
|
|
|
# pylint: disable=redefined-outer-name,import-outside-toplevel,unused-import
|
|
import dns.update # noqa: F401
|
|
|
|
|
|
def _message_factory_from_opcode(opcode):
|
|
if opcode == dns.opcode.QUERY:
|
|
return QueryMessage
|
|
elif opcode == dns.opcode.UPDATE:
|
|
_maybe_import_update()
|
|
return dns.update.UpdateMessage
|
|
else:
|
|
return Message
|
|
|
|
|
|
class _WireReader:
|
|
"""Wire format reader.
|
|
|
|
parser: the binary parser
|
|
message: The message object being built
|
|
initialize_message: Callback to set message parsing options
|
|
question_only: Are we only reading the question?
|
|
one_rr_per_rrset: Put each RR into its own RRset?
|
|
keyring: TSIG keyring
|
|
ignore_trailing: Ignore trailing junk at end of request?
|
|
multi: Is this message part of a multi-message sequence?
|
|
DNS dynamic updates.
|
|
continue_on_error: try to extract as much information as possible from
|
|
the message, accumulating MessageErrors in the *errors* attribute instead of
|
|
raising them.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
wire,
|
|
initialize_message,
|
|
question_only=False,
|
|
one_rr_per_rrset=False,
|
|
ignore_trailing=False,
|
|
keyring=None,
|
|
multi=False,
|
|
continue_on_error=False,
|
|
):
|
|
self.parser = dns.wire.Parser(wire)
|
|
self.message = None
|
|
self.initialize_message = initialize_message
|
|
self.question_only = question_only
|
|
self.one_rr_per_rrset = one_rr_per_rrset
|
|
self.ignore_trailing = ignore_trailing
|
|
self.keyring = keyring
|
|
self.multi = multi
|
|
self.continue_on_error = continue_on_error
|
|
self.errors = []
|
|
|
|
def _get_question(self, section_number, qcount):
|
|
"""Read the next *qcount* records from the wire data and add them to
|
|
the question section.
|
|
"""
|
|
assert self.message is not None
|
|
section = self.message.sections[section_number]
|
|
for _ in range(qcount):
|
|
qname = self.parser.get_name(self.message.origin)
|
|
(rdtype, rdclass) = self.parser.get_struct("!HH")
|
|
(rdclass, rdtype, _, _) = self.message._parse_rr_header(
|
|
section_number, qname, rdclass, rdtype
|
|
)
|
|
self.message.find_rrset(
|
|
section, qname, rdclass, rdtype, create=True, force_unique=True
|
|
)
|
|
|
|
def _add_error(self, e):
|
|
self.errors.append(MessageError(e, self.parser.current))
|
|
|
|
def _get_section(self, section_number, count):
|
|
"""Read the next I{count} records from the wire data and add them to
|
|
the specified section.
|
|
|
|
section_number: the section of the message to which to add records
|
|
count: the number of records to read
|
|
"""
|
|
assert self.message is not None
|
|
section = self.message.sections[section_number]
|
|
force_unique = self.one_rr_per_rrset
|
|
for i in range(count):
|
|
rr_start = self.parser.current
|
|
absolute_name = self.parser.get_name()
|
|
if self.message.origin is not None:
|
|
name = absolute_name.relativize(self.message.origin)
|
|
else:
|
|
name = absolute_name
|
|
(rdtype, rdclass, ttl, rdlen) = self.parser.get_struct("!HHIH")
|
|
if rdtype in (dns.rdatatype.OPT, dns.rdatatype.TSIG):
|
|
(
|
|
rdclass,
|
|
rdtype,
|
|
deleting,
|
|
empty,
|
|
) = self.message._parse_special_rr_header(
|
|
section_number, count, i, name, rdclass, rdtype
|
|
)
|
|
else:
|
|
(rdclass, rdtype, deleting, empty) = self.message._parse_rr_header(
|
|
section_number, name, rdclass, rdtype
|
|
)
|
|
rdata_start = self.parser.current
|
|
try:
|
|
if empty:
|
|
if rdlen > 0:
|
|
raise dns.exception.FormError
|
|
rd = None
|
|
covers = dns.rdatatype.NONE
|
|
else:
|
|
with self.parser.restrict_to(rdlen):
|
|
rd = dns.rdata.from_wire_parser(
|
|
rdclass, rdtype, self.parser, self.message.origin
|
|
)
|
|
covers = rd.covers()
|
|
if self.message.xfr and rdtype == dns.rdatatype.SOA:
|
|
force_unique = True
|
|
if rdtype == dns.rdatatype.OPT:
|
|
self.message.opt = dns.rrset.from_rdata(name, ttl, rd)
|
|
elif rdtype == dns.rdatatype.TSIG:
|
|
if self.keyring is None:
|
|
raise UnknownTSIGKey("got signed message without keyring")
|
|
if isinstance(self.keyring, dict):
|
|
key = self.keyring.get(absolute_name)
|
|
if isinstance(key, bytes):
|
|
key = dns.tsig.Key(absolute_name, key, rd.algorithm)
|
|
elif callable(self.keyring):
|
|
key = self.keyring(self.message, absolute_name)
|
|
else:
|
|
key = self.keyring
|
|
if key is None:
|
|
raise UnknownTSIGKey("key '%s' unknown" % name)
|
|
self.message.keyring = key
|
|
self.message.tsig_ctx = dns.tsig.validate(
|
|
self.parser.wire,
|
|
key,
|
|
absolute_name,
|
|
rd,
|
|
int(time.time()),
|
|
self.message.request_mac,
|
|
rr_start,
|
|
self.message.tsig_ctx,
|
|
self.multi,
|
|
)
|
|
self.message.tsig = dns.rrset.from_rdata(absolute_name, 0, rd)
|
|
else:
|
|
rrset = self.message.find_rrset(
|
|
section,
|
|
name,
|
|
rdclass,
|
|
rdtype,
|
|
covers,
|
|
deleting,
|
|
True,
|
|
force_unique,
|
|
)
|
|
if rd is not None:
|
|
if ttl > 0x7FFFFFFF:
|
|
ttl = 0
|
|
rrset.add(rd, ttl)
|
|
except Exception as e:
|
|
if self.continue_on_error:
|
|
self._add_error(e)
|
|
self.parser.seek(rdata_start + rdlen)
|
|
else:
|
|
raise
|
|
|
|
def read(self):
|
|
"""Read a wire format DNS message and build a dns.message.Message
|
|
object."""
|
|
|
|
if self.parser.remaining() < 12:
|
|
raise ShortHeader
|
|
(id, flags, qcount, ancount, aucount, adcount) = self.parser.get_struct(
|
|
"!HHHHHH"
|
|
)
|
|
factory = _message_factory_from_opcode(dns.opcode.from_flags(flags))
|
|
self.message = factory(id=id)
|
|
self.message.flags = dns.flags.Flag(flags)
|
|
self.initialize_message(self.message)
|
|
self.one_rr_per_rrset = self.message._get_one_rr_per_rrset(
|
|
self.one_rr_per_rrset
|
|
)
|
|
try:
|
|
self._get_question(MessageSection.QUESTION, qcount)
|
|
if self.question_only:
|
|
return self.message
|
|
self._get_section(MessageSection.ANSWER, ancount)
|
|
self._get_section(MessageSection.AUTHORITY, aucount)
|
|
self._get_section(MessageSection.ADDITIONAL, adcount)
|
|
if not self.ignore_trailing and self.parser.remaining() != 0:
|
|
raise TrailingJunk
|
|
if self.multi and self.message.tsig_ctx and not self.message.had_tsig:
|
|
self.message.tsig_ctx.update(self.parser.wire)
|
|
except Exception as e:
|
|
if self.continue_on_error:
|
|
self._add_error(e)
|
|
else:
|
|
raise
|
|
return self.message
|
|
|
|
|
|
def from_wire(
|
|
wire: bytes,
|
|
keyring: Optional[Any] = None,
|
|
request_mac: Optional[bytes] = b"",
|
|
xfr: bool = False,
|
|
origin: Optional[dns.name.Name] = None,
|
|
tsig_ctx: Optional[Union[dns.tsig.HMACTSig, dns.tsig.GSSTSig]] = None,
|
|
multi: bool = False,
|
|
question_only: bool = False,
|
|
one_rr_per_rrset: bool = False,
|
|
ignore_trailing: bool = False,
|
|
raise_on_truncation: bool = False,
|
|
continue_on_error: bool = False,
|
|
) -> Message:
|
|
"""Convert a DNS wire format message into a message object.
|
|
|
|
*keyring*, a ``dns.tsig.Key`` or ``dict``, the key or keyring to use if the message
|
|
is signed.
|
|
|
|
*request_mac*, a ``bytes`` or ``None``. If the message is a response to a
|
|
TSIG-signed request, *request_mac* should be set to the MAC of that request.
|
|
|
|
*xfr*, a ``bool``, should be set to ``True`` if this message is part of a zone
|
|
transfer.
|
|
|
|
*origin*, a ``dns.name.Name`` or ``None``. If the message is part of a zone
|
|
transfer, *origin* should be the origin name of the zone. If not ``None``, names
|
|
will be relativized to the origin.
|
|
|
|
*tsig_ctx*, a ``dns.tsig.HMACTSig`` or ``dns.tsig.GSSTSig`` object, the ongoing TSIG
|
|
context, used when validating zone transfers.
|
|
|
|
*multi*, a ``bool``, should be set to ``True`` if this message is part of a multiple
|
|
message sequence.
|
|
|
|
*question_only*, a ``bool``. If ``True``, read only up to the end of the question
|
|
section.
|
|
|
|
*one_rr_per_rrset*, a ``bool``. If ``True``, put each RR into its own RRset.
|
|
|
|
*ignore_trailing*, a ``bool``. If ``True``, ignore trailing junk at end of the
|
|
message.
|
|
|
|
*raise_on_truncation*, a ``bool``. If ``True``, raise an exception if the TC bit is
|
|
set.
|
|
|
|
*continue_on_error*, a ``bool``. If ``True``, try to continue parsing even if
|
|
errors occur. Erroneous rdata will be ignored. Errors will be accumulated as a
|
|
list of MessageError objects in the message's ``errors`` attribute. This option is
|
|
recommended only for DNS analysis tools, or for use in a server as part of an error
|
|
handling path. The default is ``False``.
|
|
|
|
Raises ``dns.message.ShortHeader`` if the message is less than 12 octets long.
|
|
|
|
Raises ``dns.message.TrailingJunk`` if there were octets in the message past the end
|
|
of the proper DNS message, and *ignore_trailing* is ``False``.
|
|
|
|
Raises ``dns.message.BadEDNS`` if an OPT record was in the wrong section, or
|
|
occurred more than once.
|
|
|
|
Raises ``dns.message.BadTSIG`` if a TSIG record was not the last record of the
|
|
additional data section.
|
|
|
|
Raises ``dns.message.Truncated`` if the TC flag is set and *raise_on_truncation* is
|
|
``True``.
|
|
|
|
Returns a ``dns.message.Message``.
|
|
"""
|
|
|
|
# We permit None for request_mac solely for backwards compatibility
|
|
if request_mac is None:
|
|
request_mac = b""
|
|
|
|
def initialize_message(message):
|
|
message.request_mac = request_mac
|
|
message.xfr = xfr
|
|
message.origin = origin
|
|
message.tsig_ctx = tsig_ctx
|
|
|
|
reader = _WireReader(
|
|
wire,
|
|
initialize_message,
|
|
question_only,
|
|
one_rr_per_rrset,
|
|
ignore_trailing,
|
|
keyring,
|
|
multi,
|
|
continue_on_error,
|
|
)
|
|
try:
|
|
m = reader.read()
|
|
except dns.exception.FormError:
|
|
if (
|
|
reader.message
|
|
and (reader.message.flags & dns.flags.TC)
|
|
and raise_on_truncation
|
|
):
|
|
raise Truncated(message=reader.message)
|
|
else:
|
|
raise
|
|
# Reading a truncated message might not have any errors, so we
|
|
# have to do this check here too.
|
|
if m.flags & dns.flags.TC and raise_on_truncation:
|
|
raise Truncated(message=m)
|
|
if continue_on_error:
|
|
m.errors = reader.errors
|
|
|
|
return m
|
|
|
|
|
|
class _TextReader:
|
|
"""Text format reader.
|
|
|
|
tok: the tokenizer.
|
|
message: The message object being built.
|
|
DNS dynamic updates.
|
|
last_name: The most recently read name when building a message object.
|
|
one_rr_per_rrset: Put each RR into its own RRset?
|
|
origin: The origin for relative names
|
|
relativize: relativize names?
|
|
relativize_to: the origin to relativize to.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
text,
|
|
idna_codec,
|
|
one_rr_per_rrset=False,
|
|
origin=None,
|
|
relativize=True,
|
|
relativize_to=None,
|
|
):
|
|
self.message = None
|
|
self.tok = dns.tokenizer.Tokenizer(text, idna_codec=idna_codec)
|
|
self.last_name = None
|
|
self.one_rr_per_rrset = one_rr_per_rrset
|
|
self.origin = origin
|
|
self.relativize = relativize
|
|
self.relativize_to = relativize_to
|
|
self.id = None
|
|
self.edns = -1
|
|
self.ednsflags = 0
|
|
self.payload = DEFAULT_EDNS_PAYLOAD
|
|
self.rcode = None
|
|
self.opcode = dns.opcode.QUERY
|
|
self.flags = 0
|
|
|
|
def _header_line(self, _):
|
|
"""Process one line from the text format header section."""
|
|
|
|
token = self.tok.get()
|
|
what = token.value
|
|
if what == "id":
|
|
self.id = self.tok.get_int()
|
|
elif what == "flags":
|
|
while True:
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
self.tok.unget(token)
|
|
break
|
|
self.flags = self.flags | dns.flags.from_text(token.value)
|
|
elif what == "edns":
|
|
self.edns = self.tok.get_int()
|
|
self.ednsflags = self.ednsflags | (self.edns << 16)
|
|
elif what == "eflags":
|
|
if self.edns < 0:
|
|
self.edns = 0
|
|
while True:
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
self.tok.unget(token)
|
|
break
|
|
self.ednsflags = self.ednsflags | dns.flags.edns_from_text(token.value)
|
|
elif what == "payload":
|
|
self.payload = self.tok.get_int()
|
|
if self.edns < 0:
|
|
self.edns = 0
|
|
elif what == "opcode":
|
|
text = self.tok.get_string()
|
|
self.opcode = dns.opcode.from_text(text)
|
|
self.flags = self.flags | dns.opcode.to_flags(self.opcode)
|
|
elif what == "rcode":
|
|
text = self.tok.get_string()
|
|
self.rcode = dns.rcode.from_text(text)
|
|
else:
|
|
raise UnknownHeaderField
|
|
self.tok.get_eol()
|
|
|
|
def _question_line(self, section_number):
|
|
"""Process one line from the text format question section."""
|
|
|
|
section = self.message.sections[section_number]
|
|
token = self.tok.get(want_leading=True)
|
|
if not token.is_whitespace():
|
|
self.last_name = self.tok.as_name(
|
|
token, self.message.origin, self.relativize, self.relativize_to
|
|
)
|
|
name = self.last_name
|
|
if name is None:
|
|
raise NoPreviousName
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
raise dns.exception.SyntaxError
|
|
# Class
|
|
try:
|
|
rdclass = dns.rdataclass.from_text(token.value)
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
raise dns.exception.SyntaxError
|
|
except dns.exception.SyntaxError:
|
|
raise dns.exception.SyntaxError
|
|
except Exception:
|
|
rdclass = dns.rdataclass.IN
|
|
# Type
|
|
rdtype = dns.rdatatype.from_text(token.value)
|
|
(rdclass, rdtype, _, _) = self.message._parse_rr_header(
|
|
section_number, name, rdclass, rdtype
|
|
)
|
|
self.message.find_rrset(
|
|
section, name, rdclass, rdtype, create=True, force_unique=True
|
|
)
|
|
self.tok.get_eol()
|
|
|
|
def _rr_line(self, section_number):
|
|
"""Process one line from the text format answer, authority, or
|
|
additional data sections.
|
|
"""
|
|
|
|
section = self.message.sections[section_number]
|
|
# Name
|
|
token = self.tok.get(want_leading=True)
|
|
if not token.is_whitespace():
|
|
self.last_name = self.tok.as_name(
|
|
token, self.message.origin, self.relativize, self.relativize_to
|
|
)
|
|
name = self.last_name
|
|
if name is None:
|
|
raise NoPreviousName
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
raise dns.exception.SyntaxError
|
|
# TTL
|
|
try:
|
|
ttl = int(token.value, 0)
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
raise dns.exception.SyntaxError
|
|
except dns.exception.SyntaxError:
|
|
raise dns.exception.SyntaxError
|
|
except Exception:
|
|
ttl = 0
|
|
# Class
|
|
try:
|
|
rdclass = dns.rdataclass.from_text(token.value)
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
raise dns.exception.SyntaxError
|
|
except dns.exception.SyntaxError:
|
|
raise dns.exception.SyntaxError
|
|
except Exception:
|
|
rdclass = dns.rdataclass.IN
|
|
# Type
|
|
rdtype = dns.rdatatype.from_text(token.value)
|
|
(rdclass, rdtype, deleting, empty) = self.message._parse_rr_header(
|
|
section_number, name, rdclass, rdtype
|
|
)
|
|
token = self.tok.get()
|
|
if empty and not token.is_eol_or_eof():
|
|
raise dns.exception.SyntaxError
|
|
if not empty and token.is_eol_or_eof():
|
|
raise dns.exception.UnexpectedEnd
|
|
if not token.is_eol_or_eof():
|
|
self.tok.unget(token)
|
|
rd = dns.rdata.from_text(
|
|
rdclass,
|
|
rdtype,
|
|
self.tok,
|
|
self.message.origin,
|
|
self.relativize,
|
|
self.relativize_to,
|
|
)
|
|
covers = rd.covers()
|
|
else:
|
|
rd = None
|
|
covers = dns.rdatatype.NONE
|
|
rrset = self.message.find_rrset(
|
|
section,
|
|
name,
|
|
rdclass,
|
|
rdtype,
|
|
covers,
|
|
deleting,
|
|
True,
|
|
self.one_rr_per_rrset,
|
|
)
|
|
if rd is not None:
|
|
rrset.add(rd, ttl)
|
|
|
|
def _make_message(self):
|
|
factory = _message_factory_from_opcode(self.opcode)
|
|
message = factory(id=self.id)
|
|
message.flags = self.flags
|
|
if self.edns >= 0:
|
|
message.use_edns(self.edns, self.ednsflags, self.payload)
|
|
if self.rcode:
|
|
message.set_rcode(self.rcode)
|
|
if self.origin:
|
|
message.origin = self.origin
|
|
return message
|
|
|
|
def read(self):
|
|
"""Read a text format DNS message and build a dns.message.Message
|
|
object."""
|
|
|
|
line_method = self._header_line
|
|
section_number = None
|
|
while 1:
|
|
token = self.tok.get(True, True)
|
|
if token.is_eol_or_eof():
|
|
break
|
|
if token.is_comment():
|
|
u = token.value.upper()
|
|
if u == "HEADER":
|
|
line_method = self._header_line
|
|
|
|
if self.message:
|
|
message = self.message
|
|
else:
|
|
# If we don't have a message, create one with the current
|
|
# opcode, so that we know which section names to parse.
|
|
message = self._make_message()
|
|
try:
|
|
section_number = message._section_enum.from_text(u)
|
|
# We found a section name. If we don't have a message,
|
|
# use the one we just created.
|
|
if not self.message:
|
|
self.message = message
|
|
self.one_rr_per_rrset = message._get_one_rr_per_rrset(
|
|
self.one_rr_per_rrset
|
|
)
|
|
if section_number == MessageSection.QUESTION:
|
|
line_method = self._question_line
|
|
else:
|
|
line_method = self._rr_line
|
|
except Exception:
|
|
# It's just a comment.
|
|
pass
|
|
self.tok.get_eol()
|
|
continue
|
|
self.tok.unget(token)
|
|
line_method(section_number)
|
|
if not self.message:
|
|
self.message = self._make_message()
|
|
return self.message
|
|
|
|
|
|
def from_text(
|
|
text: str,
|
|
idna_codec: Optional[dns.name.IDNACodec] = None,
|
|
one_rr_per_rrset: bool = False,
|
|
origin: Optional[dns.name.Name] = None,
|
|
relativize: bool = True,
|
|
relativize_to: Optional[dns.name.Name] = None,
|
|
) -> Message:
|
|
"""Convert the text format message into a message object.
|
|
|
|
The reader stops after reading the first blank line in the input to
|
|
facilitate reading multiple messages from a single file with
|
|
``dns.message.from_file()``.
|
|
|
|
*text*, a ``str``, the text format message.
|
|
|
|
*idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
|
|
encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder
|
|
is used.
|
|
|
|
*one_rr_per_rrset*, a ``bool``. If ``True``, then each RR is put
|
|
into its own rrset. The default is ``False``.
|
|
|
|
*origin*, a ``dns.name.Name`` (or ``None``), the
|
|
origin to use for relative names.
|
|
|
|
*relativize*, a ``bool``. If true, name will be relativized.
|
|
|
|
*relativize_to*, a ``dns.name.Name`` (or ``None``), the origin to use
|
|
when relativizing names. If not set, the *origin* value will be used.
|
|
|
|
Raises ``dns.message.UnknownHeaderField`` if a header is unknown.
|
|
|
|
Raises ``dns.exception.SyntaxError`` if the text is badly formed.
|
|
|
|
Returns a ``dns.message.Message object``
|
|
"""
|
|
|
|
# 'text' can also be a file, but we don't publish that fact
|
|
# since it's an implementation detail. The official file
|
|
# interface is from_file().
|
|
|
|
reader = _TextReader(
|
|
text, idna_codec, one_rr_per_rrset, origin, relativize, relativize_to
|
|
)
|
|
return reader.read()
|
|
|
|
|
|
def from_file(
|
|
f: Any,
|
|
idna_codec: Optional[dns.name.IDNACodec] = None,
|
|
one_rr_per_rrset: bool = False,
|
|
) -> Message:
|
|
"""Read the next text format message from the specified file.
|
|
|
|
Message blocks are separated by a single blank line.
|
|
|
|
*f*, a ``file`` or ``str``. If *f* is text, it is treated as the
|
|
pathname of a file to open.
|
|
|
|
*idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
|
|
encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder
|
|
is used.
|
|
|
|
*one_rr_per_rrset*, a ``bool``. If ``True``, then each RR is put
|
|
into its own rrset. The default is ``False``.
|
|
|
|
Raises ``dns.message.UnknownHeaderField`` if a header is unknown.
|
|
|
|
Raises ``dns.exception.SyntaxError`` if the text is badly formed.
|
|
|
|
Returns a ``dns.message.Message object``
|
|
"""
|
|
|
|
if isinstance(f, str):
|
|
cm: contextlib.AbstractContextManager = open(f)
|
|
else:
|
|
cm = contextlib.nullcontext(f)
|
|
with cm as f:
|
|
return from_text(f, idna_codec, one_rr_per_rrset)
|
|
assert False # for mypy lgtm[py/unreachable-statement]
|
|
|
|
|
|
def make_query(
|
|
qname: Union[dns.name.Name, str],
|
|
rdtype: Union[dns.rdatatype.RdataType, str],
|
|
rdclass: Union[dns.rdataclass.RdataClass, str] = dns.rdataclass.IN,
|
|
use_edns: Optional[Union[int, bool]] = None,
|
|
want_dnssec: bool = False,
|
|
ednsflags: Optional[int] = None,
|
|
payload: Optional[int] = None,
|
|
request_payload: Optional[int] = None,
|
|
options: Optional[List[dns.edns.Option]] = None,
|
|
idna_codec: Optional[dns.name.IDNACodec] = None,
|
|
id: Optional[int] = None,
|
|
flags: int = dns.flags.RD,
|
|
pad: int = 0,
|
|
) -> QueryMessage:
|
|
"""Make a query message.
|
|
|
|
The query name, type, and class may all be specified either
|
|
as objects of the appropriate type, or as strings.
|
|
|
|
The query will have a randomly chosen query id, and its DNS flags
|
|
will be set to dns.flags.RD.
|
|
|
|
qname, a ``dns.name.Name`` or ``str``, the query name.
|
|
|
|
*rdtype*, an ``int`` or ``str``, the desired rdata type.
|
|
|
|
*rdclass*, an ``int`` or ``str``, the desired rdata class; the default
|
|
is class IN.
|
|
|
|
*use_edns*, an ``int``, ``bool`` or ``None``. The EDNS level to use; the
|
|
default is ``None``. If ``None``, EDNS will be enabled only if other
|
|
parameters (*ednsflags*, *payload*, *request_payload*, or *options*) are
|
|
set.
|
|
See the description of dns.message.Message.use_edns() for the possible
|
|
values for use_edns and their meanings.
|
|
|
|
*want_dnssec*, a ``bool``. If ``True``, DNSSEC data is desired.
|
|
|
|
*ednsflags*, an ``int``, the EDNS flag values.
|
|
|
|
*payload*, an ``int``, is the EDNS sender's payload field, which is the
|
|
maximum size of UDP datagram the sender can handle. I.e. how big
|
|
a response to this message can be.
|
|
|
|
*request_payload*, an ``int``, is the EDNS payload size to use when
|
|
sending this message. If not specified, defaults to the value of
|
|
*payload*.
|
|
|
|
*options*, a list of ``dns.edns.Option`` objects or ``None``, the EDNS
|
|
options.
|
|
|
|
*idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
|
|
encoder/decoder. If ``None``, the default IDNA 2003 encoder/decoder
|
|
is used.
|
|
|
|
*id*, an ``int`` or ``None``, the desired query id. The default is
|
|
``None``, which generates a random query id.
|
|
|
|
*flags*, an ``int``, the desired query flags. The default is
|
|
``dns.flags.RD``.
|
|
|
|
*pad*, a non-negative ``int``. If 0, the default, do not pad; otherwise add
|
|
padding bytes to make the message size a multiple of *pad*. Note that if
|
|
padding is non-zero, an EDNS PADDING option will always be added to the
|
|
message.
|
|
|
|
Returns a ``dns.message.QueryMessage``
|
|
"""
|
|
|
|
if isinstance(qname, str):
|
|
qname = dns.name.from_text(qname, idna_codec=idna_codec)
|
|
rdtype = dns.rdatatype.RdataType.make(rdtype)
|
|
rdclass = dns.rdataclass.RdataClass.make(rdclass)
|
|
m = QueryMessage(id=id)
|
|
m.flags = dns.flags.Flag(flags)
|
|
m.find_rrset(m.question, qname, rdclass, rdtype, create=True, force_unique=True)
|
|
# only pass keywords on to use_edns if they have been set to a
|
|
# non-None value. Setting a field will turn EDNS on if it hasn't
|
|
# been configured.
|
|
kwargs: Dict[str, Any] = {}
|
|
if ednsflags is not None:
|
|
kwargs["ednsflags"] = ednsflags
|
|
if payload is not None:
|
|
kwargs["payload"] = payload
|
|
if request_payload is not None:
|
|
kwargs["request_payload"] = request_payload
|
|
if options is not None:
|
|
kwargs["options"] = options
|
|
if kwargs and use_edns is None:
|
|
use_edns = 0
|
|
kwargs["edns"] = use_edns
|
|
kwargs["pad"] = pad
|
|
m.use_edns(**kwargs)
|
|
m.want_dnssec(want_dnssec)
|
|
return m
|
|
|
|
|
|
def make_response(
|
|
query: Message,
|
|
recursion_available: bool = False,
|
|
our_payload: int = 8192,
|
|
fudge: int = 300,
|
|
tsig_error: int = 0,
|
|
pad: Optional[int] = None,
|
|
) -> Message:
|
|
"""Make a message which is a response for the specified query.
|
|
The message returned is really a response skeleton; it has all of the infrastructure
|
|
required of a response, but none of the content.
|
|
|
|
The response's question section is a shallow copy of the query's question section,
|
|
so the query's question RRsets should not be changed.
|
|
|
|
*query*, a ``dns.message.Message``, the query to respond to.
|
|
|
|
*recursion_available*, a ``bool``, should RA be set in the response?
|
|
|
|
*our_payload*, an ``int``, the payload size to advertise in EDNS responses.
|
|
|
|
*fudge*, an ``int``, the TSIG time fudge.
|
|
|
|
*tsig_error*, an ``int``, the TSIG error.
|
|
|
|
*pad*, a non-negative ``int`` or ``None``. If 0, the default, do not pad; otherwise
|
|
if not ``None`` add padding bytes to make the message size a multiple of *pad*.
|
|
Note that if padding is non-zero, an EDNS PADDING option will always be added to the
|
|
message. If ``None``, add padding following RFC 8467, namely if the request is
|
|
padded, pad the response to 468 otherwise do not pad.
|
|
|
|
Returns a ``dns.message.Message`` object whose specific class is appropriate for the
|
|
query. For example, if query is a ``dns.update.UpdateMessage``, response will be
|
|
too.
|
|
"""
|
|
|
|
if query.flags & dns.flags.QR:
|
|
raise dns.exception.FormError("specified query message is not a query")
|
|
factory = _message_factory_from_opcode(query.opcode())
|
|
response = factory(id=query.id)
|
|
response.flags = dns.flags.QR | (query.flags & dns.flags.RD)
|
|
if recursion_available:
|
|
response.flags |= dns.flags.RA
|
|
response.set_opcode(query.opcode())
|
|
response.question = list(query.question)
|
|
if query.edns >= 0:
|
|
if pad is None:
|
|
# Set response padding per RFC 8467
|
|
pad = 0
|
|
for option in query.options:
|
|
if option.otype == dns.edns.OptionType.PADDING:
|
|
pad = 468
|
|
response.use_edns(0, 0, our_payload, query.payload, pad=pad)
|
|
if query.had_tsig:
|
|
response.use_tsig(
|
|
query.keyring,
|
|
query.keyname,
|
|
fudge,
|
|
None,
|
|
tsig_error,
|
|
b"",
|
|
query.keyalgorithm,
|
|
)
|
|
response.request_mac = query.mac
|
|
return response
|
|
|
|
|
|
### BEGIN generated MessageSection constants
|
|
|
|
QUESTION = MessageSection.QUESTION
|
|
ANSWER = MessageSection.ANSWER
|
|
AUTHORITY = MessageSection.AUTHORITY
|
|
ADDITIONAL = MessageSection.ADDITIONAL
|
|
|
|
### END generated MessageSection constants
|