mirror of
https://github.com/morpheus65535/bazarr
synced 2024-12-27 18:17:46 +00:00
1152 lines
42 KiB
Python
1152 lines
42 KiB
Python
# Copyright (C) 2001-2007, 2009-2011 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"""
|
|
|
|
from __future__ import absolute_import
|
|
|
|
from io import StringIO
|
|
import struct
|
|
import time
|
|
|
|
import dns.edns
|
|
import dns.exception
|
|
import dns.flags
|
|
import dns.name
|
|
import dns.opcode
|
|
import dns.entropy
|
|
import dns.rcode
|
|
import dns.rdata
|
|
import dns.rdataclass
|
|
import dns.rdatatype
|
|
import dns.rrset
|
|
import dns.renderer
|
|
import dns.tsig
|
|
import dns.wiredata
|
|
|
|
from ._compat import long, xrange, string_types
|
|
|
|
|
|
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):
|
|
|
|
"""OPT record occurred somewhere other than the start of
|
|
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 Message(object):
|
|
|
|
"""A DNS message.
|
|
|
|
@ivar id: The query id; the default is a randomly chosen id.
|
|
@type id: int
|
|
@ivar flags: The DNS flags of the message. @see: RFC 1035 for an
|
|
explanation of these flags.
|
|
@type flags: int
|
|
@ivar question: The question section.
|
|
@type question: list of dns.rrset.RRset objects
|
|
@ivar answer: The answer section.
|
|
@type answer: list of dns.rrset.RRset objects
|
|
@ivar authority: The authority section.
|
|
@type authority: list of dns.rrset.RRset objects
|
|
@ivar additional: The additional data section.
|
|
@type additional: list of dns.rrset.RRset objects
|
|
@ivar edns: The EDNS level to use. The default is -1, no Edns.
|
|
@type edns: int
|
|
@ivar ednsflags: The EDNS flags
|
|
@type ednsflags: long
|
|
@ivar payload: The EDNS payload size. The default is 0.
|
|
@type payload: int
|
|
@ivar options: The EDNS options
|
|
@type options: list of dns.edns.Option objects
|
|
@ivar request_payload: The associated request's EDNS payload size.
|
|
@type request_payload: int
|
|
@ivar keyring: The TSIG keyring to use. The default is None.
|
|
@type keyring: dict
|
|
@ivar keyname: The TSIG keyname to use. The default is None.
|
|
@type keyname: dns.name.Name object
|
|
@ivar keyalgorithm: The TSIG algorithm to use; defaults to
|
|
dns.tsig.default_algorithm. Constants for TSIG algorithms are defined
|
|
in dns.tsig, and the currently implemented algorithms are
|
|
HMAC_MD5, HMAC_SHA1, HMAC_SHA224, HMAC_SHA256, HMAC_SHA384, and
|
|
HMAC_SHA512.
|
|
@type keyalgorithm: string
|
|
@ivar request_mac: The TSIG MAC of the request message associated with
|
|
this message; used when validating TSIG signatures. @see: RFC 2845 for
|
|
more information on TSIG fields.
|
|
@type request_mac: string
|
|
@ivar fudge: TSIG time fudge; default is 300 seconds.
|
|
@type fudge: int
|
|
@ivar original_id: TSIG original id; defaults to the message's id
|
|
@type original_id: int
|
|
@ivar tsig_error: TSIG error code; default is 0.
|
|
@type tsig_error: int
|
|
@ivar other_data: TSIG other data.
|
|
@type other_data: string
|
|
@ivar mac: The TSIG MAC for this message.
|
|
@type mac: string
|
|
@ivar xfr: Is the message being used to contain the results of a DNS
|
|
zone transfer? The default is False.
|
|
@type xfr: bool
|
|
@ivar origin: The origin of the zone in messages which are used for
|
|
zone transfers or for DNS dynamic updates. The default is None.
|
|
@type origin: dns.name.Name object
|
|
@ivar tsig_ctx: The TSIG signature context associated with this
|
|
message. The default is None.
|
|
@type tsig_ctx: hmac.HMAC object
|
|
@ivar had_tsig: Did the message decoded from wire format have a TSIG
|
|
signature?
|
|
@type had_tsig: bool
|
|
@ivar multi: Is this message part of a multi-message sequence? The
|
|
default is false. This variable is used when validating TSIG signatures
|
|
on messages which are part of a zone transfer.
|
|
@type multi: bool
|
|
@ivar first: Is this message standalone, or the first of a multi
|
|
message sequence? This variable is used when validating TSIG signatures
|
|
on messages which are part of a zone transfer.
|
|
@type first: bool
|
|
@ivar index: An index of rrsets in the message. The index key is
|
|
(section, name, rdclass, rdtype, covers, deleting). Indexing can be
|
|
disabled by setting the index to None.
|
|
@type index: dict
|
|
"""
|
|
|
|
def __init__(self, id=None):
|
|
if id is None:
|
|
self.id = dns.entropy.random_16()
|
|
else:
|
|
self.id = id
|
|
self.flags = 0
|
|
self.question = []
|
|
self.answer = []
|
|
self.authority = []
|
|
self.additional = []
|
|
self.edns = -1
|
|
self.ednsflags = 0
|
|
self.payload = 0
|
|
self.options = []
|
|
self.request_payload = 0
|
|
self.keyring = None
|
|
self.keyname = None
|
|
self.keyalgorithm = dns.tsig.default_algorithm
|
|
self.request_mac = ''
|
|
self.other_data = ''
|
|
self.tsig_error = 0
|
|
self.fudge = 300
|
|
self.original_id = self.id
|
|
self.mac = ''
|
|
self.xfr = False
|
|
self.origin = None
|
|
self.tsig_ctx = None
|
|
self.had_tsig = False
|
|
self.multi = False
|
|
self.first = True
|
|
self.index = {}
|
|
|
|
def __repr__(self):
|
|
return '<DNS message, ID ' + repr(self.id) + '>'
|
|
|
|
def __str__(self):
|
|
return self.to_text()
|
|
|
|
def to_text(self, origin=None, relativize=True, **kw):
|
|
"""Convert the message to text.
|
|
|
|
The I{origin}, I{relativize}, and any other keyword
|
|
arguments are passed to the rrset to_wire() method.
|
|
|
|
@rtype: string
|
|
"""
|
|
|
|
s = StringIO()
|
|
s.write(u'id %d\n' % self.id)
|
|
s.write(u'opcode %s\n' %
|
|
dns.opcode.to_text(dns.opcode.from_flags(self.flags)))
|
|
rc = dns.rcode.from_flags(self.flags, self.ednsflags)
|
|
s.write(u'rcode %s\n' % dns.rcode.to_text(rc))
|
|
s.write(u'flags %s\n' % dns.flags.to_text(self.flags))
|
|
if self.edns >= 0:
|
|
s.write(u'edns %s\n' % self.edns)
|
|
if self.ednsflags != 0:
|
|
s.write(u'eflags %s\n' %
|
|
dns.flags.edns_to_text(self.ednsflags))
|
|
s.write(u'payload %d\n' % self.payload)
|
|
is_update = dns.opcode.is_update(self.flags)
|
|
if is_update:
|
|
s.write(u';ZONE\n')
|
|
else:
|
|
s.write(u';QUESTION\n')
|
|
for rrset in self.question:
|
|
s.write(rrset.to_text(origin, relativize, **kw))
|
|
s.write(u'\n')
|
|
if is_update:
|
|
s.write(u';PREREQ\n')
|
|
else:
|
|
s.write(u';ANSWER\n')
|
|
for rrset in self.answer:
|
|
s.write(rrset.to_text(origin, relativize, **kw))
|
|
s.write(u'\n')
|
|
if is_update:
|
|
s.write(u';UPDATE\n')
|
|
else:
|
|
s.write(u';AUTHORITY\n')
|
|
for rrset in self.authority:
|
|
s.write(rrset.to_text(origin, relativize, **kw))
|
|
s.write(u'\n')
|
|
s.write(u';ADDITIONAL\n')
|
|
for rrset in self.additional:
|
|
s.write(rrset.to_text(origin, relativize, **kw))
|
|
s.write(u'\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.
|
|
@rtype: bool"""
|
|
if not isinstance(other, Message):
|
|
return False
|
|
if self.id != other.id:
|
|
return False
|
|
if self.flags != other.flags:
|
|
return False
|
|
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
|
|
for n in self.answer:
|
|
if n not in other.answer:
|
|
return False
|
|
for n in other.answer:
|
|
if n not in self.answer:
|
|
return False
|
|
for n in self.authority:
|
|
if n not in other.authority:
|
|
return False
|
|
for n in other.authority:
|
|
if n not in self.authority:
|
|
return False
|
|
return True
|
|
|
|
def __ne__(self, other):
|
|
"""Are two messages not equal?
|
|
@rtype: bool"""
|
|
return not self.__eq__(other)
|
|
|
|
def is_response(self, other):
|
|
"""Is other a response to self?
|
|
@rtype: 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 dns.rcode.from_flags(other.flags, other.ednsflags) != \
|
|
dns.rcode.NOERROR:
|
|
return True
|
|
if dns.opcode.is_update(self.flags):
|
|
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):
|
|
if section is self.question:
|
|
return 0
|
|
elif section is self.answer:
|
|
return 1
|
|
elif section is self.authority:
|
|
return 2
|
|
elif section is self.additional:
|
|
return 3
|
|
else:
|
|
raise ValueError('unknown section')
|
|
|
|
def find_rrset(self, section, name, rdclass, rdtype,
|
|
covers=dns.rdatatype.NONE, deleting=None, create=False,
|
|
force_unique=False):
|
|
"""Find the RRset with the given attributes in the specified section.
|
|
|
|
@param section: the section of the message to look in, e.g.
|
|
self.answer.
|
|
@type section: list of dns.rrset.RRset objects
|
|
@param name: the name of the RRset
|
|
@type name: dns.name.Name object
|
|
@param rdclass: the class of the RRset
|
|
@type rdclass: int
|
|
@param rdtype: the type of the RRset
|
|
@type rdtype: int
|
|
@param covers: the covers value of the RRset
|
|
@type covers: int
|
|
@param deleting: the deleting value of the RRset
|
|
@type deleting: int
|
|
@param create: If True, create the RRset if it is not found.
|
|
The created RRset is appended to I{section}.
|
|
@type create: bool
|
|
@param force_unique: If True and create is also True, create a
|
|
new RRset regardless of whether a matching RRset exists already.
|
|
@type force_unique: bool
|
|
@raises KeyError: the RRset was not found and create was False
|
|
@rtype: dns.rrset.RRset object"""
|
|
|
|
key = (self.section_number(section),
|
|
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.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, name, rdclass, rdtype,
|
|
covers=dns.rdatatype.NONE, deleting=None, create=False,
|
|
force_unique=False):
|
|
"""Get the RRset with the given attributes in the specified section.
|
|
|
|
If the RRset is not found, None is returned.
|
|
|
|
@param section: the section of the message to look in, e.g.
|
|
self.answer.
|
|
@type section: list of dns.rrset.RRset objects
|
|
@param name: the name of the RRset
|
|
@type name: dns.name.Name object
|
|
@param rdclass: the class of the RRset
|
|
@type rdclass: int
|
|
@param rdtype: the type of the RRset
|
|
@type rdtype: int
|
|
@param covers: the covers value of the RRset
|
|
@type covers: int
|
|
@param deleting: the deleting value of the RRset
|
|
@type deleting: int
|
|
@param create: If True, create the RRset if it is not found.
|
|
The created RRset is appended to I{section}.
|
|
@type create: bool
|
|
@param force_unique: If True and create is also True, create a
|
|
new RRset regardless of whether a matching RRset exists already.
|
|
@type force_unique: bool
|
|
@rtype: dns.rrset.RRset object or None"""
|
|
|
|
try:
|
|
rrset = self.find_rrset(section, name, rdclass, rdtype, covers,
|
|
deleting, create, force_unique)
|
|
except KeyError:
|
|
rrset = None
|
|
return rrset
|
|
|
|
def to_wire(self, origin=None, max_size=0, **kw):
|
|
"""Return a string containing the message in DNS compressed wire
|
|
format.
|
|
|
|
Additional keyword arguments are passed to the rrset to_wire()
|
|
method.
|
|
|
|
@param origin: The origin to be appended to any relative names.
|
|
@type origin: dns.name.Name object
|
|
@param max_size: The maximum size of the wire format output; default
|
|
is 0, which means 'the message's request payload, if nonzero, or
|
|
65536'.
|
|
@type max_size: int
|
|
@raises dns.exception.TooBig: max_size was exceeded
|
|
@rtype: string
|
|
"""
|
|
|
|
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)
|
|
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)
|
|
if self.edns >= 0:
|
|
r.add_edns(self.edns, self.ednsflags, self.payload, self.options)
|
|
for rrset in self.additional:
|
|
r.add_rrset(dns.renderer.ADDITIONAL, rrset, **kw)
|
|
r.write_header()
|
|
if self.keyname is not None:
|
|
r.add_tsig(self.keyname, self.keyring[self.keyname],
|
|
self.fudge, self.original_id, self.tsig_error,
|
|
self.other_data, self.request_mac,
|
|
self.keyalgorithm)
|
|
self.mac = r.mac
|
|
return r.get_wire()
|
|
|
|
def use_tsig(self, keyring, keyname=None, fudge=300,
|
|
original_id=None, tsig_error=0, other_data='',
|
|
algorithm=dns.tsig.default_algorithm):
|
|
"""When sending, a TSIG signature using the specified keyring
|
|
and keyname should be added.
|
|
|
|
@param keyring: The TSIG keyring to use; defaults to None.
|
|
@type keyring: dict
|
|
@param keyname: The name of the TSIG key to use; defaults to None.
|
|
The key must be defined in the keyring. If a keyring is specified
|
|
but a keyname is not, then 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 keyring is used, unless
|
|
they know the keyring contains only one key.
|
|
@type keyname: dns.name.Name or string
|
|
@param fudge: TSIG time fudge; default is 300 seconds.
|
|
@type fudge: int
|
|
@param original_id: TSIG original id; defaults to the message's id
|
|
@type original_id: int
|
|
@param tsig_error: TSIG error code; default is 0.
|
|
@type tsig_error: int
|
|
@param other_data: TSIG other data.
|
|
@type other_data: string
|
|
@param algorithm: The TSIG algorithm to use; defaults to
|
|
dns.tsig.default_algorithm
|
|
"""
|
|
|
|
self.keyring = keyring
|
|
if keyname is None:
|
|
self.keyname = list(self.keyring.keys())[0]
|
|
else:
|
|
if isinstance(keyname, string_types):
|
|
keyname = dns.name.from_text(keyname)
|
|
self.keyname = keyname
|
|
self.keyalgorithm = algorithm
|
|
self.fudge = fudge
|
|
if original_id is None:
|
|
self.original_id = self.id
|
|
else:
|
|
self.original_id = original_id
|
|
self.tsig_error = tsig_error
|
|
self.other_data = other_data
|
|
|
|
def use_edns(self, edns=0, ednsflags=0, payload=1280, request_payload=None,
|
|
options=None):
|
|
"""Configure EDNS behavior.
|
|
@param edns: 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'.
|
|
@type edns: int or bool or None
|
|
@param ednsflags: EDNS flag values.
|
|
@type ednsflags: int
|
|
@param payload: The EDNS sender's payload field, which is the maximum
|
|
size of UDP datagram the sender can handle.
|
|
@type payload: int
|
|
@param request_payload: The EDNS payload size to use when sending
|
|
this message. If not specified, defaults to the value of payload.
|
|
@type request_payload: int or None
|
|
@param options: The EDNS options
|
|
@type options: None or list of dns.edns.Option objects
|
|
@see: RFC 2671
|
|
"""
|
|
if edns is None or edns is False:
|
|
edns = -1
|
|
if edns is True:
|
|
edns = 0
|
|
if request_payload is None:
|
|
request_payload = payload
|
|
if edns < 0:
|
|
ednsflags = 0
|
|
payload = 0
|
|
request_payload = 0
|
|
options = []
|
|
else:
|
|
# make sure the EDNS version in ednsflags agrees with edns
|
|
ednsflags &= long(0xFF00FFFF)
|
|
ednsflags |= (edns << 16)
|
|
if options is None:
|
|
options = []
|
|
self.edns = edns
|
|
self.ednsflags = ednsflags
|
|
self.payload = payload
|
|
self.options = options
|
|
self.request_payload = request_payload
|
|
|
|
def want_dnssec(self, wanted=True):
|
|
"""Enable or disable 'DNSSEC desired' flag in requests.
|
|
@param wanted: Is DNSSEC desired? If True, EDNS is enabled if
|
|
required, and then the DO bit is set. If False, the DO bit is
|
|
cleared if EDNS is enabled.
|
|
@type wanted: bool
|
|
"""
|
|
if wanted:
|
|
if self.edns < 0:
|
|
self.use_edns()
|
|
self.ednsflags |= dns.flags.DO
|
|
elif self.edns >= 0:
|
|
self.ednsflags &= ~dns.flags.DO
|
|
|
|
def rcode(self):
|
|
"""Return the rcode.
|
|
@rtype: int
|
|
"""
|
|
return dns.rcode.from_flags(self.flags, self.ednsflags)
|
|
|
|
def set_rcode(self, rcode):
|
|
"""Set the rcode.
|
|
@param rcode: the rcode
|
|
@type rcode: int
|
|
"""
|
|
(value, evalue) = dns.rcode.to_flags(rcode)
|
|
self.flags &= 0xFFF0
|
|
self.flags |= value
|
|
self.ednsflags &= long(0x00FFFFFF)
|
|
self.ednsflags |= evalue
|
|
if self.ednsflags != 0 and self.edns < 0:
|
|
self.edns = 0
|
|
|
|
def opcode(self):
|
|
"""Return the opcode.
|
|
@rtype: int
|
|
"""
|
|
return dns.opcode.from_flags(self.flags)
|
|
|
|
def set_opcode(self, opcode):
|
|
"""Set the opcode.
|
|
@param opcode: the opcode
|
|
@type opcode: int
|
|
"""
|
|
self.flags &= 0x87FF
|
|
self.flags |= dns.opcode.to_flags(opcode)
|
|
|
|
|
|
class _WireReader(object):
|
|
|
|
"""Wire format reader.
|
|
|
|
@ivar wire: the wire-format message.
|
|
@type wire: string
|
|
@ivar message: The message object being built
|
|
@type message: dns.message.Message object
|
|
@ivar current: When building a message object from wire format, this
|
|
variable contains the offset from the beginning of wire of the next octet
|
|
to be read.
|
|
@type current: int
|
|
@ivar updating: Is the message a dynamic update?
|
|
@type updating: bool
|
|
@ivar one_rr_per_rrset: Put each RR into its own RRset?
|
|
@type one_rr_per_rrset: bool
|
|
@ivar ignore_trailing: Ignore trailing junk at end of request?
|
|
@type ignore_trailing: bool
|
|
@ivar zone_rdclass: The class of the zone in messages which are
|
|
DNS dynamic updates.
|
|
@type zone_rdclass: int
|
|
"""
|
|
|
|
def __init__(self, wire, message, question_only=False,
|
|
one_rr_per_rrset=False, ignore_trailing=False):
|
|
self.wire = dns.wiredata.maybe_wrap(wire)
|
|
self.message = message
|
|
self.current = 0
|
|
self.updating = False
|
|
self.zone_rdclass = dns.rdataclass.IN
|
|
self.question_only = question_only
|
|
self.one_rr_per_rrset = one_rr_per_rrset
|
|
self.ignore_trailing = ignore_trailing
|
|
|
|
def _get_question(self, qcount):
|
|
"""Read the next I{qcount} records from the wire data and add them to
|
|
the question section.
|
|
@param qcount: the number of questions in the message
|
|
@type qcount: int"""
|
|
|
|
if self.updating and qcount > 1:
|
|
raise dns.exception.FormError
|
|
|
|
for i in xrange(0, qcount):
|
|
(qname, used) = dns.name.from_wire(self.wire, self.current)
|
|
if self.message.origin is not None:
|
|
qname = qname.relativize(self.message.origin)
|
|
self.current = self.current + used
|
|
(rdtype, rdclass) = \
|
|
struct.unpack('!HH',
|
|
self.wire[self.current:self.current + 4])
|
|
self.current = self.current + 4
|
|
self.message.find_rrset(self.message.question, qname,
|
|
rdclass, rdtype, create=True,
|
|
force_unique=True)
|
|
if self.updating:
|
|
self.zone_rdclass = rdclass
|
|
|
|
def _get_section(self, section, count):
|
|
"""Read the next I{count} records from the wire data and add them to
|
|
the specified section.
|
|
@param section: the section of the message to which to add records
|
|
@type section: list of dns.rrset.RRset objects
|
|
@param count: the number of records to read
|
|
@type count: int"""
|
|
|
|
if self.updating or self.one_rr_per_rrset:
|
|
force_unique = True
|
|
else:
|
|
force_unique = False
|
|
seen_opt = False
|
|
for i in xrange(0, count):
|
|
rr_start = self.current
|
|
(name, used) = dns.name.from_wire(self.wire, self.current)
|
|
absolute_name = name
|
|
if self.message.origin is not None:
|
|
name = name.relativize(self.message.origin)
|
|
self.current = self.current + used
|
|
(rdtype, rdclass, ttl, rdlen) = \
|
|
struct.unpack('!HHIH',
|
|
self.wire[self.current:self.current + 10])
|
|
self.current = self.current + 10
|
|
if rdtype == dns.rdatatype.OPT:
|
|
if section is not self.message.additional or seen_opt:
|
|
raise BadEDNS
|
|
self.message.payload = rdclass
|
|
self.message.ednsflags = ttl
|
|
self.message.edns = (ttl & 0xff0000) >> 16
|
|
self.message.options = []
|
|
current = self.current
|
|
optslen = rdlen
|
|
while optslen > 0:
|
|
(otype, olen) = \
|
|
struct.unpack('!HH',
|
|
self.wire[current:current + 4])
|
|
current = current + 4
|
|
opt = dns.edns.option_from_wire(
|
|
otype, self.wire, current, olen)
|
|
self.message.options.append(opt)
|
|
current = current + olen
|
|
optslen = optslen - 4 - olen
|
|
seen_opt = True
|
|
elif rdtype == dns.rdatatype.TSIG:
|
|
if not (section is self.message.additional and
|
|
i == (count - 1)):
|
|
raise BadTSIG
|
|
if self.message.keyring is None:
|
|
raise UnknownTSIGKey('got signed message without keyring')
|
|
secret = self.message.keyring.get(absolute_name)
|
|
if secret is None:
|
|
raise UnknownTSIGKey("key '%s' unknown" % name)
|
|
self.message.keyname = absolute_name
|
|
(self.message.keyalgorithm, self.message.mac) = \
|
|
dns.tsig.get_algorithm_and_mac(self.wire, self.current,
|
|
rdlen)
|
|
self.message.tsig_ctx = \
|
|
dns.tsig.validate(self.wire,
|
|
absolute_name,
|
|
secret,
|
|
int(time.time()),
|
|
self.message.request_mac,
|
|
rr_start,
|
|
self.current,
|
|
rdlen,
|
|
self.message.tsig_ctx,
|
|
self.message.multi,
|
|
self.message.first)
|
|
self.message.had_tsig = True
|
|
else:
|
|
if ttl < 0:
|
|
ttl = 0
|
|
if self.updating and \
|
|
(rdclass == dns.rdataclass.ANY or
|
|
rdclass == dns.rdataclass.NONE):
|
|
deleting = rdclass
|
|
rdclass = self.zone_rdclass
|
|
else:
|
|
deleting = None
|
|
if deleting == dns.rdataclass.ANY or \
|
|
(deleting == dns.rdataclass.NONE and
|
|
section is self.message.answer):
|
|
covers = dns.rdatatype.NONE
|
|
rd = None
|
|
else:
|
|
rd = dns.rdata.from_wire(rdclass, rdtype, self.wire,
|
|
self.current, rdlen,
|
|
self.message.origin)
|
|
covers = rd.covers()
|
|
if self.message.xfr and rdtype == dns.rdatatype.SOA:
|
|
force_unique = True
|
|
rrset = self.message.find_rrset(section, name,
|
|
rdclass, rdtype, covers,
|
|
deleting, True, force_unique)
|
|
if rd is not None:
|
|
rrset.add(rd, ttl)
|
|
self.current = self.current + rdlen
|
|
|
|
def read(self):
|
|
"""Read a wire format DNS message and build a dns.message.Message
|
|
object."""
|
|
|
|
l = len(self.wire)
|
|
if l < 12:
|
|
raise ShortHeader
|
|
(self.message.id, self.message.flags, qcount, ancount,
|
|
aucount, adcount) = struct.unpack('!HHHHHH', self.wire[:12])
|
|
self.current = 12
|
|
if dns.opcode.is_update(self.message.flags):
|
|
self.updating = True
|
|
self._get_question(qcount)
|
|
if self.question_only:
|
|
return
|
|
self._get_section(self.message.answer, ancount)
|
|
self._get_section(self.message.authority, aucount)
|
|
self._get_section(self.message.additional, adcount)
|
|
if not self.ignore_trailing and self.current != l:
|
|
raise TrailingJunk
|
|
if self.message.multi and self.message.tsig_ctx and \
|
|
not self.message.had_tsig:
|
|
self.message.tsig_ctx.update(self.wire)
|
|
|
|
|
|
def from_wire(wire, keyring=None, request_mac='', xfr=False, origin=None,
|
|
tsig_ctx=None, multi=False, first=True,
|
|
question_only=False, one_rr_per_rrset=False,
|
|
ignore_trailing=False):
|
|
"""Convert a DNS wire format message into a message
|
|
object.
|
|
|
|
@param keyring: The keyring to use if the message is signed.
|
|
@type keyring: dict
|
|
@param request_mac: If the message is a response to a TSIG-signed request,
|
|
I{request_mac} should be set to the MAC of that request.
|
|
@type request_mac: string
|
|
@param xfr: Is this message part of a zone transfer?
|
|
@type xfr: bool
|
|
@param origin: If the message is part of a zone transfer, I{origin}
|
|
should be the origin name of the zone.
|
|
@type origin: dns.name.Name object
|
|
@param tsig_ctx: The ongoing TSIG context, used when validating zone
|
|
transfers.
|
|
@type tsig_ctx: hmac.HMAC object
|
|
@param multi: Is this message part of a multiple message sequence?
|
|
@type multi: bool
|
|
@param first: Is this message standalone, or the first of a multi
|
|
message sequence?
|
|
@type first: bool
|
|
@param question_only: Read only up to the end of the question section?
|
|
@type question_only: bool
|
|
@param one_rr_per_rrset: Put each RR into its own RRset
|
|
@type one_rr_per_rrset: bool
|
|
@param ignore_trailing: Ignore trailing junk at end of request?
|
|
@type ignore_trailing: bool
|
|
@raises ShortHeader: The message is less than 12 octets long.
|
|
@raises TrailingJunk: There were octets in the message past the end
|
|
of the proper DNS message.
|
|
@raises BadEDNS: An OPT record was in the wrong section, or occurred more
|
|
than once.
|
|
@raises BadTSIG: A TSIG record was not the last record of the additional
|
|
data section.
|
|
@rtype: dns.message.Message object"""
|
|
|
|
m = Message(id=0)
|
|
m.keyring = keyring
|
|
m.request_mac = request_mac
|
|
m.xfr = xfr
|
|
m.origin = origin
|
|
m.tsig_ctx = tsig_ctx
|
|
m.multi = multi
|
|
m.first = first
|
|
|
|
reader = _WireReader(wire, m, question_only, one_rr_per_rrset,
|
|
ignore_trailing)
|
|
reader.read()
|
|
|
|
return m
|
|
|
|
|
|
class _TextReader(object):
|
|
|
|
"""Text format reader.
|
|
|
|
@ivar tok: the tokenizer
|
|
@type tok: dns.tokenizer.Tokenizer object
|
|
@ivar message: The message object being built
|
|
@type message: dns.message.Message object
|
|
@ivar updating: Is the message a dynamic update?
|
|
@type updating: bool
|
|
@ivar zone_rdclass: The class of the zone in messages which are
|
|
DNS dynamic updates.
|
|
@type zone_rdclass: int
|
|
@ivar last_name: The most recently read name when building a message object
|
|
from text format.
|
|
@type last_name: dns.name.Name object
|
|
"""
|
|
|
|
def __init__(self, text, message):
|
|
self.message = message
|
|
self.tok = dns.tokenizer.Tokenizer(text)
|
|
self.last_name = None
|
|
self.zone_rdclass = dns.rdataclass.IN
|
|
self.updating = False
|
|
|
|
def _header_line(self, section):
|
|
"""Process one line from the text format header section."""
|
|
|
|
token = self.tok.get()
|
|
what = token.value
|
|
if what == 'id':
|
|
self.message.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.message.flags = self.message.flags | \
|
|
dns.flags.from_text(token.value)
|
|
if dns.opcode.is_update(self.message.flags):
|
|
self.updating = True
|
|
elif what == 'edns':
|
|
self.message.edns = self.tok.get_int()
|
|
self.message.ednsflags = self.message.ednsflags | \
|
|
(self.message.edns << 16)
|
|
elif what == 'eflags':
|
|
if self.message.edns < 0:
|
|
self.message.edns = 0
|
|
while True:
|
|
token = self.tok.get()
|
|
if not token.is_identifier():
|
|
self.tok.unget(token)
|
|
break
|
|
self.message.ednsflags = self.message.ednsflags | \
|
|
dns.flags.edns_from_text(token.value)
|
|
elif what == 'payload':
|
|
self.message.payload = self.tok.get_int()
|
|
if self.message.edns < 0:
|
|
self.message.edns = 0
|
|
elif what == 'opcode':
|
|
text = self.tok.get_string()
|
|
self.message.flags = self.message.flags | \
|
|
dns.opcode.to_flags(dns.opcode.from_text(text))
|
|
elif what == 'rcode':
|
|
text = self.tok.get_string()
|
|
self.message.set_rcode(dns.rcode.from_text(text))
|
|
else:
|
|
raise UnknownHeaderField
|
|
self.tok.get_eol()
|
|
|
|
def _question_line(self, section):
|
|
"""Process one line from the text format question section."""
|
|
|
|
token = self.tok.get(want_leading=True)
|
|
if not token.is_whitespace():
|
|
self.last_name = dns.name.from_text(token.value, None)
|
|
name = self.last_name
|
|
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)
|
|
self.message.find_rrset(self.message.question, name,
|
|
rdclass, rdtype, create=True,
|
|
force_unique=True)
|
|
if self.updating:
|
|
self.zone_rdclass = rdclass
|
|
self.tok.get_eol()
|
|
|
|
def _rr_line(self, section):
|
|
"""Process one line from the text format answer, authority, or
|
|
additional data sections.
|
|
"""
|
|
|
|
deleting = None
|
|
# Name
|
|
token = self.tok.get(want_leading=True)
|
|
if not token.is_whitespace():
|
|
self.last_name = dns.name.from_text(token.value, None)
|
|
name = self.last_name
|
|
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
|
|
if rdclass == dns.rdataclass.ANY or rdclass == dns.rdataclass.NONE:
|
|
deleting = rdclass
|
|
rdclass = self.zone_rdclass
|
|
except dns.exception.SyntaxError:
|
|
raise dns.exception.SyntaxError
|
|
except Exception:
|
|
rdclass = dns.rdataclass.IN
|
|
# Type
|
|
rdtype = dns.rdatatype.from_text(token.value)
|
|
token = self.tok.get()
|
|
if not token.is_eol_or_eof():
|
|
self.tok.unget(token)
|
|
rd = dns.rdata.from_text(rdclass, rdtype, self.tok, None)
|
|
covers = rd.covers()
|
|
else:
|
|
rd = None
|
|
covers = dns.rdatatype.NONE
|
|
rrset = self.message.find_rrset(section, name,
|
|
rdclass, rdtype, covers,
|
|
deleting, True, self.updating)
|
|
if rd is not None:
|
|
rrset.add(rd, ttl)
|
|
|
|
def read(self):
|
|
"""Read a text format DNS message and build a dns.message.Message
|
|
object."""
|
|
|
|
line_method = self._header_line
|
|
section = 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
|
|
elif u == 'QUESTION' or u == 'ZONE':
|
|
line_method = self._question_line
|
|
section = self.message.question
|
|
elif u == 'ANSWER' or u == 'PREREQ':
|
|
line_method = self._rr_line
|
|
section = self.message.answer
|
|
elif u == 'AUTHORITY' or u == 'UPDATE':
|
|
line_method = self._rr_line
|
|
section = self.message.authority
|
|
elif u == 'ADDITIONAL':
|
|
line_method = self._rr_line
|
|
section = self.message.additional
|
|
self.tok.get_eol()
|
|
continue
|
|
self.tok.unget(token)
|
|
line_method(section)
|
|
|
|
|
|
def from_text(text):
|
|
"""Convert the text format message into a message object.
|
|
|
|
@param text: The text format message.
|
|
@type text: string
|
|
@raises UnknownHeaderField:
|
|
@raises dns.exception.SyntaxError:
|
|
@rtype: 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().
|
|
|
|
m = Message()
|
|
|
|
reader = _TextReader(text, m)
|
|
reader.read()
|
|
|
|
return m
|
|
|
|
|
|
def from_file(f):
|
|
"""Read the next text format message from the specified file.
|
|
|
|
@param f: file or string. If I{f} is a string, it is treated
|
|
as the name of a file to open.
|
|
@raises UnknownHeaderField:
|
|
@raises dns.exception.SyntaxError:
|
|
@rtype: dns.message.Message object"""
|
|
|
|
str_type = string_types
|
|
opts = 'rU'
|
|
|
|
if isinstance(f, str_type):
|
|
f = open(f, opts)
|
|
want_close = True
|
|
else:
|
|
want_close = False
|
|
|
|
try:
|
|
m = from_text(f)
|
|
finally:
|
|
if want_close:
|
|
f.close()
|
|
return m
|
|
|
|
|
|
def make_query(qname, rdtype, rdclass=dns.rdataclass.IN, use_edns=None,
|
|
want_dnssec=False, ednsflags=None, payload=None,
|
|
request_payload=None, options=None):
|
|
"""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.
|
|
|
|
@param qname: The query name.
|
|
@type qname: dns.name.Name object or string
|
|
@param rdtype: The desired rdata type.
|
|
@type rdtype: int
|
|
@param rdclass: The desired rdata class; the default is class IN.
|
|
@type rdclass: int
|
|
@param use_edns: The EDNS level to use; the default is None (no EDNS).
|
|
See the description of dns.message.Message.use_edns() for the possible
|
|
values for use_edns and their meanings.
|
|
@type use_edns: int or bool or None
|
|
@param want_dnssec: Should the query indicate that DNSSEC is desired?
|
|
@type want_dnssec: bool
|
|
@param ednsflags: EDNS flag values.
|
|
@type ednsflags: int
|
|
@param payload: The EDNS sender's payload field, which is the maximum
|
|
size of UDP datagram the sender can handle.
|
|
@type payload: int
|
|
@param request_payload: The EDNS payload size to use when sending
|
|
this message. If not specified, defaults to the value of payload.
|
|
@type request_payload: int or None
|
|
@param options: The EDNS options
|
|
@type options: None or list of dns.edns.Option objects
|
|
@see: RFC 2671
|
|
@rtype: dns.message.Message object"""
|
|
|
|
if isinstance(qname, string_types):
|
|
qname = dns.name.from_text(qname)
|
|
if isinstance(rdtype, string_types):
|
|
rdtype = dns.rdatatype.from_text(rdtype)
|
|
if isinstance(rdclass, string_types):
|
|
rdclass = dns.rdataclass.from_text(rdclass)
|
|
m = Message()
|
|
m.flags |= dns.flags.RD
|
|
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 = {}
|
|
if ednsflags is not None:
|
|
kwargs['ednsflags'] = ednsflags
|
|
if use_edns is None:
|
|
use_edns = 0
|
|
if payload is not None:
|
|
kwargs['payload'] = payload
|
|
if use_edns is None:
|
|
use_edns = 0
|
|
if request_payload is not None:
|
|
kwargs['request_payload'] = request_payload
|
|
if use_edns is None:
|
|
use_edns = 0
|
|
if options is not None:
|
|
kwargs['options'] = options
|
|
if use_edns is None:
|
|
use_edns = 0
|
|
kwargs['edns'] = use_edns
|
|
m.use_edns(**kwargs)
|
|
m.want_dnssec(want_dnssec)
|
|
return m
|
|
|
|
|
|
def make_response(query, recursion_available=False, our_payload=8192,
|
|
fudge=300):
|
|
"""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.
|
|
|
|
@param query: the query to respond to
|
|
@type query: dns.message.Message object
|
|
@param recursion_available: should RA be set in the response?
|
|
@type recursion_available: bool
|
|
@param our_payload: payload size to advertise in EDNS responses; default
|
|
is 8192.
|
|
@type our_payload: int
|
|
@param fudge: TSIG time fudge; default is 300 seconds.
|
|
@type fudge: int
|
|
@rtype: dns.message.Message object"""
|
|
|
|
if query.flags & dns.flags.QR:
|
|
raise dns.exception.FormError('specified query message is not a query')
|
|
response = dns.message.Message(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:
|
|
response.use_edns(0, 0, our_payload, query.payload)
|
|
if query.had_tsig:
|
|
response.use_tsig(query.keyring, query.keyname, fudge, None, 0, '',
|
|
query.keyalgorithm)
|
|
response.request_mac = query.mac
|
|
return response
|