def test_noAnswer(self):
"""
If a request returns a L{dns.NS} response, but we can't connect to the
given server, the request fails with the error returned at connection.
"""
def query(self, *args):
# Pop from the message list, so that it blows up if more queries
# are run than expected.
return succeed(messages.pop(0))
def queryProtocol(self, *args, **kwargs):
return defer.fail(socket.gaierror("Couldn't connect"))
resolver = Resolver(servers=[('0.0.0.0', 0)])
resolver._query = query
messages = []
# Let's patch dns.DNSDatagramProtocol.query, as there is no easy way to
# customize it.
self.patch(dns.DNSDatagramProtocol, "query", queryProtocol)
records = [
dns.RRHeader(name='fooba.com', type=dns.NS, cls=dns.IN, ttl=700,
auth=False,
payload=dns.Record_NS(name='ns.twistedmatrix.com',
ttl=700))]
m = dns.Message(id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1,
rCode=0, trunc=0, maxSize=0)
m.answers = records
messages.append(m)
return self.assertFailure(
resolver.getHostByName("fooby.com"), socket.gaierror)
def __init__(self,
postgresListener,
clock=reactor,
retryOnFailure=True,
rbacRetryOnFailureDelay=10):
"""Initialise a new `RegionControllerService`.
:param postgresListener: The `PostgresListenerService` that is running
in this regiond process.
"""
super(RegionControllerService, self).__init__()
self.clock = clock
self.retryOnFailure = retryOnFailure
self.rbacRetryOnFailureDelay = rbacRetryOnFailureDelay
self.processing = LoopingCall(self.process)
self.processing.clock = self.clock
self.processingDefer = None
self.needsDNSUpdate = False
self.needsProxyUpdate = False
self.needsRBACUpdate = False
self.postgresListener = postgresListener
self.dnsResolver = Resolver(resolv=None,
servers=[('127.0.0.1', 53)],
timeout=(1, ),
reactor=clock)
self.previousSerial = None
self.rbacClient = None
self.rbacInit = False
def createResolver(servers=None, resolvconf=None, hosts=None):
if hosts is None:
hosts = b'/etc/hosts' if platform.getType() == 'posix' else r'c:\windows\hosts'
theResolver = Resolver(resolvconf, servers)
hostResolver = hostsModule.Resolver(hosts)
chain = [hostResolver, cache.CacheResolver(), theResolver]
return resolve.ResolverChain(chain)
def test_zoneTransferConnectionFails(self):
"""
A failed AXFR TCP connection errbacks the L{Deferred} returned
from L{Resolver.lookupZone}.
"""
resolver = Resolver(servers=[("nameserver.invalid", 53)])
return self.assertFailure(resolver.lookupZone("impossible.invalid"),
error.DNSLookupError)
def test_a_lookup_ooni_query(self):
def done_query(message, *arg):
answer = message.answers[0]
self.assertEqual(answer.type, 1)
dns_query = [dns.Query('ooni.nu', type=dns.A)]
resolver = Resolver(servers=[('8.8.8.8', 53)])
d = resolver.queryUDP(dns_query)
d.addCallback(done_query)
return d
def performALookup(self, hostname, dns_server):
"""
Performs an A lookup and returns an array containg all the dotted quad
IP addresses in the response.
:hostname: is the hostname to perform the A lookup on
:dns_server: is the dns_server that should be used for the lookup as a
tuple of ip port (ex. ("127.0.0.1", 53))
"""
query = [dns.Query(hostname, dns.IN, dns.A)]
def gotResponse(message):
addrs = []
answers = []
for answer in message.answers:
if answer.type is 1:
addr = answer.payload.dottedQuad()
addrs.append(addr)
# We store the resource record and the answer payload in a
# tuple
r = (repr(answer), repr(answer.payload))
answers.append(r)
result = {}
result['resolver'] = dns_server
result['query_type'] = 'A'
result['query'] = repr(query)
result['answers'] = answers
result['addrs'] = addrs
self.report['queries'].append(result)
return addrs
def gotError(failure):
log.exception(failure)
result = {}
result['resolver'] = dns_server
result['query_type'] = 'A'
result['query'] = repr(query)
result['error'] = str(failure)
return None
resolver = Resolver(servers=[dns_server])
d = resolver.queryUDP(query, timeout=self.queryTimeout)
d.addCallback(gotResponse)
d.addErrback(gotError)
return d
def performPTRLookup(self, address, dns_server):
"""
Does a reverse DNS lookup on the input ip address
:address: the IP Address as a dotted quad to do a reverse lookup on.
:dns_server: is the dns_server that should be used for the lookup as a
tuple of ip port (ex. ("127.0.0.1", 53))
"""
ptr = '.'.join(address.split('.')[::-1]) + '.in-addr.arpa'
query = [dns.Query(ptr, dns.PTR, dns.IN)]
def gotResponse(message):
log.debug("Lookup successful")
log.debug(message)
answers = []
name = ''
for answer in message.answers:
if answer.type is 12:
name = str(answer.payload.name)
answers.append(representAnswer(answer))
DNSTest.addToReport(self,
query,
resolver=dns_server,
query_type='PTR',
answers=answers,
name=name)
return name
def gotError(failure):
log.err("Failed to perform lookup")
log.exception(failure)
failure.trap(gaierror, TimeoutError)
DNSTest.addToReport(self,
query,
resolver=dns_server,
query_type='PTR',
failure=failure)
return None
resolver = Resolver(servers=[dns_server])
d = resolver.queryUDP(query, timeout=self.queryTimeout)
d.addCallback(gotResponse)
d.addErrback(gotError)
return d
def performALookup(self, hostname, dns_server):
"""
Performs an A lookup and returns an array containg all the dotted quad
IP addresses in the response.
:hostname: is the hostname to perform the A lookup on
:dns_server: is the dns_server that should be used for the lookup as a
tuple of ip port (ex. ("127.0.0.1", 53))
"""
query = [dns.Query(hostname, dns.A, dns.IN)]
def gotResponse(message):
addrs = []
answers = []
for answer in message.answers:
if answer.type is 1:
addr = answer.payload.dottedQuad()
addrs.append(addr)
answers.append(representAnswer(answer))
DNSTest.addToReport(self,
query,
resolver=dns_server,
query_type='A',
answers=answers,
addrs=addrs)
return addrs
def gotError(failure):
failure.trap(gaierror, TimeoutError)
DNSTest.addToReport(self,
query,
resolver=dns_server,
query_type='A',
failure=failure)
return failure
resolver = Resolver(servers=[dns_server])
d = resolver.queryUDP(query, timeout=self.queryTimeout)
d.addCallback(gotResponse)
d.addErrback(gotError)
return d
def performPTRLookup(self, address, dns_server):
"""
Does a reverse DNS lookup on the input ip address
:address: the IP Address as a dotted quad to do a reverse lookup on.
:dns_server: is the dns_server that should be used for the lookup as a
tuple of ip port (ex. ("127.0.0.1", 53))
"""
ptr = '.'.join(address.split('.')[::-1]) + '.in-addr.arpa'
query = [dns.Query(ptr, dns.IN, dns.PTR)]
def gotResponse(message):
answers = []
name = None
for answer in message.answers:
if answer.type is 12:
name = answer.payload.name
result = {}
result['resolver'] = dns_server
result['query_type'] = 'PTR'
result['query'] = repr(query)
result['answers'] = answers
result['name'] = name
self.report['queries'].append(result)
return name
def gotError(failure):
log.exception(failure)
result = {}
result['resolver'] = dns_server
result['query_type'] = 'PTR'
result['query'] = repr(query)
result['error'] = str(failure)
return None
resolver = Resolver(servers=[dns_server])
d = resolver.queryUDP(query, timeout=self.queryTimeout)
d.addCallback(gotResponse)
d.addErrback(gotError)
return d
def default(cls, reactor):
"""
Create a consistency checker with resolvers from Google, Cloudflare,
OpenDNS, and Level3.
"""
return cls(
[
Resolver(servers=[(addr, 53)], reactor=reactor) for addr in [
# Google
"8.8.8.8",
"8.8.4.4",
# Level3
"4.2.2.2",
"4.2.2.1",
# OpenDNS
"208.67.222.222",
"208.67.220.220",
# Cloudflare
"1.1.1.1",
"1.0.0.1",
]
],
reactor,
)
import twisted, sys, codecs, traceback
from twisted.words.protocols import irc
from twisted.internet import reactor, protocol, abstract
from twisted.web import resource, server
from twisted.protocols import basic
from twisted.names.client import Resolver
import hmac, time, config, random, qwebirc.config_options as config_options
from config import HMACTEMPORAL
import database
if config.get("CONNECTION_RESOLVER"):
CONNECTION_RESOLVER = Resolver(servers=config.get("CONNECTION_RESOLVER"))
else:
CONNECTION_RESOLVER = None
if hasattr(config, "WEBIRC_MODE") and config.WEBIRC_MODE == "hmac":
HMACKEY = hmac.HMAC(key=config.HMACKEY)
def hmacfn(*args):
h = HMACKEY.copy()
h.update("%d %s" % (int(time.time() / HMACTEMPORAL), " ".join(args)))
return h.hexdigest()
def utf8_iso8859_1(data,
table=dict((x, x.decode("iso-8859-1"))
for x in map(chr, range(0, 256)))):
return (table.get(data.object[data.start]), data.start + 1)
def setUp(self):
# Create a resolver pointed at an invalid server - we won't be hitting
# the network in any of these tests.
self.resolver = Resolver(servers=[('0.0.0.0', 0)])
def dnsLookup(self, hostname, dns_type, dns_server = None):
"""
Performs a DNS lookup and returns the response.
:hostname: is the hostname to perform the DNS lookup on
:dns_type: type of lookup 'NS'/'A'/'SOA'
:dns_server: is the dns_server that should be used for the lookup as a
tuple of ip port (ex. ("127.0.0.1", 53))
"""
types = {
'NS': dns.NS,
'A': dns.A,
'SOA': dns.SOA,
'PTR': dns.PTR
}
dnsType = types[dns_type]
query = [dns.Query(hostname, dnsType, dns.IN)]
def gotResponse(message):
log.debug(dns_type + " Lookup successful")
log.debug(str(message))
if dns_server:
msg = message.answers
else:
msg = message[0]
answers = []
addrs = []
for answer in msg:
addr = None
if answer.type is dns.SOA:
addr = (answer.name.name,answer.payload.serial)
elif answer.type in [dns.NS, dns.PTR, dns.CNAME]:
addr = answer.payload.name.name
elif answer.type is dns.A:
addr = answer.payload.dottedQuad()
else:
log.debug("Unidentified answer %s" % answer)
addrs.append(addr)
answers.append(representAnswer(answer))
if dns_type == 'SOA':
for authority in message.authority:
answers.append(representAnswer(authority))
DNSTest.addToReport(self, query, resolver=dns_server,
query_type=dns_type, answers=answers)
return addrs
def gotError(failure):
failure.trap(gaierror, TimeoutError)
DNSTest.addToReport(self, query, resolver=dns_server,
query_type=dns_type, failure=failure)
return failure
if dns_server:
resolver = Resolver(servers=[dns_server])
d = resolver.queryUDP(query, timeout=self.queryTimeout)
else:
lookupFunction = {
'NS': client.lookupNameservers,
'SOA': client.lookupAuthority,
'A': client.lookupAddress,
'PTR': client.lookupPointer
}
d = lookupFunction[dns_type](hostname)
d.addCallback(gotResponse)
d.addErrback(gotError)
return d
