def test_verboseLogQuiet(self):
"""
L{server.DNSServerFactory._verboseLog} does not log messages unless
C{verbose > 0}.
"""
f = server.DNSServerFactory()
assertLogMessage(self, [], f._verboseLog, 'Foo Bar')
def _assertMessageRcodeForError(self, responseError, expectedMessageCode):
"""
L{server.DNSServerFactory.gotResolver} accepts a L{failure.Failure} and
triggers a response message whose rCode corresponds to the DNS error
contained in the C{Failure}.
@param responseError: The L{Exception} instance which is expected to
trigger C{expectedMessageCode} when it is supplied to
C{gotResolverError}
@type responseError: L{Exception}
@param expectedMessageCode: The C{rCode} which is expected in the
message returned by C{gotResolverError} in response to
C{responseError}.
@type expectedMessageCode: L{int}
"""
f = server.DNSServerFactory()
e = self.assertRaises(
RaisingProtocol.WriteMessageArguments,
f.gotResolverError,
failure.Failure(responseError),
protocol=RaisingProtocol(), message=dns.Message(), address=None)
(message,), kwargs = e.args
self.assertEqual(message.rCode, expectedMessageCode)
def test_resolverType(self):
"""
L{server.DNSServerFactory.resolver} is a L{resolve.ResolverChain}
instance
"""
self.assertIsInstance(server.DNSServerFactory().resolver,
resolve.ResolverChain)
def makeMobileService(config=None):
# Set dns service
dnsService = service.MultiService()
hostsResolver = hosts.Resolver('/etc/hosts')
tcpFactory = server.DNSServerFactory([hostsResolver])
internet.TCPServer(3330, tcpFactory,
interface='192.168.0.91').setServiceParent(dnsService)
# Set log file
logfile = DailyLogFile("mobile.log", "/tmp")
#application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
# Set redis service
# Proxy Server
agent = MobileAgent(3333, 2)
agent.setServiceParent(dnsService)
mobileFactory = IProxyServerFactory(agent)
mobileService = internet.TCPServer(3331,
mobileFactory,
interface='192.168.0.91')
mobileService.setServiceParent(dnsService)
return dnsService
def __init__(self, config, test_obj):
"""Initialize and configure the DNS object."""
zones = []
port = config.get('port', 10053)
pyzones = config.get('python-zones', [])
bindzones = config.get('bind-zones', [])
for pyzone in pyzones:
zones.append(authority.PySourceAuthority(
'%s/dns_zones/%s' % (test_obj.test_name, pyzone)))
LOGGER.info("Added Python zone file %s" % (pyzone))
for bindzone in bindzones:
zones.append(authority.BindAuthority(
'%s/dns_zones/%s' % (test_obj.test_name, bindzone)))
LOGGER.info("Added BIND zone file %s" % (bindzone))
factory = server.DNSServerFactory(authorities=zones)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(port, protocol)
reactor.listenTCP(port, factory)
LOGGER.info("Started DNS server (UDP and TCP) on port %d" % (port))
def main():
print "AndroidProxy --- (C) Mathy Vanhoef"
print "This program comes with ABSOLUTELY NO WARRANTY."
print
print "DNS server will listen on localhost:53"
print "HTTP Proxy will listen on localhost:8007"
print
#print "Physical device: Configure your computer dns server and as router (NOT as proxy) and execute"
#print "\tiptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8007"
#print "\tiptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8007"
#print
print "Emulator: start it using: emulator @AvdName -http-proxy http://localhost:8007 -dns-server localhost"
print
print "Don't forget to start your normal proxy on localhost:8080"
print
# Setup custom DNS server
resolvers = []
resolvers.append(ProxyResolver([('8.8.8.8', 53)]))
f = server.DNSServerFactory(clients=resolvers)
p = dns.DNSDatagramProtocol(f)
reactor.listenUDP(53, p)
# Setup TCP proxy server
endpoint = TCP4ServerEndpoint(reactor, 8007)
endpoint.listen(ProxyFactory('localhost', 8080))
# Start DNS and TCP server
reactor.run();
def setUp(self):
config_file = os.path.join(self.config_dir, 'minimal_config.yaml')
self.serv = FakeDnsProxy(config_file)
# setup a DNS resolver that can be used to generate test DNS queries
# the client will point to the port defined in the minimal_config.yaml
# in test_data/main_tester_config/minimal_config.yaml
self.test_dns_client = client.Resolver(servers=[('127.0.0.1',
TEST_DNS_PORT)],
resolv=None)
twisted.internet.base.DelayedCall.debug = True
# setup a fake DNS server that we can use to test DNS forwarding
# this will fail if it cannot open port 40000 on 127.0.0.1
class ResolverStub(object):
def query(self, query, timeout=None):
if query.type == dns.A:
answer = dns.RRHeader(
name=query.name.name,
payload=dns.Record_A(address='1.2.3.4'))
elif query.type == dns.NS:
answer = dns.RRHeader(
name=query.name.name,
payload=dns.Record_NS(name="ns1.foobar.com"))
return defer.succeed(([answer], [], []))
fake_dns_factory = server.DNSServerFactory(clients=[ResolverStub()])
fake_dns_server_protocol = dns.DNSDatagramProtocol(
controller=fake_dns_factory)
self.fake_dns_server_port = reactor.listenUDP(FAKE_DNS_PORT,
fake_dns_server_protocol,
interface='127.0.0.1')
def main():
from twisted.names import cache
dns_cache = [cache.CacheResolver(verbose=config["verbose"])]
dns_clients = []
tcp_f = server.DNSServerFactory(config["zones"], dns_cache, dns_clients,
config["verbose"])
udp_f = dns.DNSDatagramProtocol(tcp_f)
tcp_s = internet.TCPServer(config["dnsport"],
tcp_f,
interface=config["dnsinterface"])
udp_s = internet.UDPServer(config["dnsport"],
udp_f,
interface=config["dnsinterface"])
# Start DNS services
tcp_s.startService()
udp_s.startService()
if WordsController.data:
# Create HTTP server endpoint only if at least a zone is registered
endpoint = endpoints.serverFromString(reactor, config["apiendpoint"])
endpoint.listen(Site(WordsController.app.resource()))
print("Starting reactor")
reactor.run()
def main():
if os.getuid() != 0:
raise Exception("Must run as root")
iptables_flush()
os.close(0)
os.closerange(2 + 1, subprocess.MAXFD)
r, w = os.pipe()
pid = os.fork()
if pid == 0:
run_child(r)
os.close(r)
resolver = Resolver(w)
factory = server.DNSServerFactory(clients=[resolver])
protocol = dns.DNSDatagramProtocol(factory)
reactor.listenUDP(53, protocol)
reactor.listenTCP(53, factory)
drop_privs()
reactor.run()
def test_responseFromMessageCallsMessageFactory(self):
"""
L{server.DNSServerFactory._responseFromMessage} calls
C{dns._responseFromMessage} to generate a response
message from the request message. It supplies the request message and
other keyword arguments which should be passed to the response message
initialiser.
"""
factory = server.DNSServerFactory()
self.patch(dns, "_responseFromMessage", raiser)
request = dns.Message()
e = self.assertRaises(RaisedArguments,
factory._responseFromMessage,
message=request,
rCode=dns.OK)
self.assertEqual(
(
(),
dict(
responseConstructor=factory._messageFactory,
message=request,
rCode=dns.OK,
recAv=factory.canRecurse,
auth=False,
),
),
(e.args, e.kwargs),
)
def test_handleQueryCallback(self):
"""
L{server.DNSServerFactory.handleQuery} adds
L{server.DNSServerFactory.resolver.gotResolverResponse} as a callback to
the deferred returned by L{server.DNSServerFactory.resolver.query}. It
is called with the query response, the original protocol, message and
origin address.
"""
f = server.DNSServerFactory()
d = defer.Deferred()
class FakeResolver(object):
def query(self, *args, **kwargs):
return d
f.resolver = FakeResolver()
gotResolverResponseArgs = []
def fakeGotResolverResponse(*args, **kwargs):
gotResolverResponseArgs.append((args, kwargs))
f.gotResolverResponse = fakeGotResolverResponse
m = dns.Message()
m.addQuery(b'one.example.com')
stubProtocol = NoopProtocol()
dummyAddress = object()
f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress)
dummyResponse = object()
d.callback(dummyResponse)
self.assertEqual(
gotResolverResponseArgs,
[((dummyResponse, stubProtocol, m, dummyAddress), {})])
def setUp(self):
self.factory = server.DNSServerFactory([
test_domain_com, reverse_domain, my_domain_com
], verbose=2)
p = dns.DNSDatagramProtocol(self.factory)
while 1:
listenerTCP = reactor.listenTCP(0, self.factory, interface="127.0.0.1")
# It's simpler to do the stop listening with addCleanup,
# even though we might not end up using this TCP port in
# the test (if the listenUDP below fails). Cleaning up
# this TCP port sooner than "cleanup time" would mean
# adding more code to keep track of the Deferred returned
# by stopListening.
self.addCleanup(listenerTCP.stopListening)
port = listenerTCP.getHost().port
try:
listenerUDP = reactor.listenUDP(port, p, interface="127.0.0.1")
except error.CannotListenError:
pass
else:
self.addCleanup(listenerUDP.stopListening)
break
self.listenerTCP = listenerTCP
self.listenerUDP = listenerUDP
self.resolver = client.Resolver(servers=[('127.0.0.1', port)])
def _messageReceivedTest(self, methodName, message):
"""
Assert that the named method is called with the given message when it is
passed to L{DNSServerFactory.messageReceived}.
@param methodName: The name of the method which is expected to be
called.
@type methodName: L{str}
@param message: The message which is expected to be passed to the
C{methodName} method.
@type message: L{dns.Message}
"""
# Make it appear to have some queries so that
# DNSServerFactory.allowQuery allows it.
message.queries = [None]
receivedMessages = []
def fakeHandler(message, protocol, address):
receivedMessages.append((message, protocol, address))
protocol = NoopProtocol()
factory = server.DNSServerFactory(None)
setattr(factory, methodName, fakeHandler)
factory.messageReceived(message, protocol)
self.assertEqual(receivedMessages, [(message, protocol, None)])
def test_buildProtocolProtocolOverride(self):
"""
L{server.DNSServerFactory.buildProtocol} builds a protocol by calling
L{server.DNSServerFactory.protocol} with its self as a positional
argument.
"""
class FakeProtocol(object):
factory = None
args = None
kwargs = None
stubProtocol = FakeProtocol()
def fakeProtocolFactory(*args, **kwargs):
stubProtocol.args = args
stubProtocol.kwargs = kwargs
return stubProtocol
f = server.DNSServerFactory()
f.protocol = fakeProtocolFactory
p = f.buildProtocol(addr=None)
self.assertEqual(
(stubProtocol, (f,), {}),
(p, p.args, p.kwargs)
)
def main(port=53, domain='xip.io', nameservers=None, mapped_hosts=None):
server_list = []
nameservers = nameservers or '8.8.8.8,8.8.4.4'
for address in nameservers.split(','):
parts = address.strip().split(':')
if len(parts) > 1:
server_list.append((parts[0], int(parts[1])))
elif parts:
server_list.append((parts[0], 53))
factory = server.DNSServerFactory(
clients=[
DynamicResolver(
servers=server_list,
wildcard_domain=domain,
mapped_hosts=mapped_hosts,
)
]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(10053, protocol)
reactor.listenTCP(10053, factory)
reactor.run()
def test_canRecurseDefault(self):
"""
L{server.DNSServerFactory.canRecurse} is a flag indicating that this
server is capable of performing recursive DNS lookups. It defaults to
L{False}.
"""
self.assertFalse(server.DNSServerFactory().canRecurse)
def test_canRecurseOverride(self):
"""
L{server.DNSServerFactory.__init__} sets C{canRecurse} to L{True} if it
is supplied with C{clients}.
"""
self.assertEqual(
server.DNSServerFactory(clients=[None]).canRecurse, True)
def test_handleQueryErrback(self):
"""
L{server.DNSServerFactory.handleQuery} adds
L{server.DNSServerFactory.resolver.gotResolverError} as an errback to
the deferred returned by L{server.DNSServerFactory.resolver.query}. It
is called with the query failure, the original protocol, message and
origin address.
"""
f = server.DNSServerFactory()
d = defer.Deferred()
class FakeResolver(object):
def query(self, *args, **kwargs):
return d
f.resolver = FakeResolver()
gotResolverErrorArgs = []
def fakeGotResolverError(*args, **kwargs):
gotResolverErrorArgs.append((args, kwargs))
f.gotResolverError = fakeGotResolverError
m = dns.Message()
m.addQuery(b'one.example.com')
stubProtocol = NoopProtocol()
dummyAddress = object()
f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress)
stubFailure = failure.Failure(Exception())
d.errback(stubFailure)
self.assertEqual(
gotResolverErrorArgs,
[((stubFailure, stubProtocol, m, dummyAddress), {})])
def main():
config = ConfigParser.ConfigParser()
config.read(["/etc/awsdns.ini", os.path.abspath("./awsdns.ini"), os.path.expanduser("~/awsnds.ini")])
# TODO: what happens if we use more than one DNS server?
resolver = EC2Resolver(
config,
servers=[(config.get('awsdns', 'dns_server'), 53)]
)
f = server.DNSServerFactory(clients=[resolver])
p = dns.DNSDatagramProtocol(f)
reactor.listenUDP(53, p)
reactor.listenTCP(53, f)
try:
loglevel = util.logging_constant(config.get('awsdns', 'loglevel'))
except ConfigParser.NoOptionError:
loglevel = logging.INFO
try:
logfile = config.get('awsdns', 'logfile')
fh = open("awsdns.log", "a")
except ConfigParser.NoOptionError:
fh = sys.stdout
observer = LevelFileLogObserver(fh, loglevel)
log.addObserver(observer)
reactor.run()
def test_sendReplyLoggingWithAnswers(self):
"""
If L{server.DNSServerFactory.sendReply} logs a message for answers,
authority, additional if the supplied a message has records in any of
those sections.
"""
self.patch(server.time, "time", lambda: 86402)
m = dns.Message()
m.answers.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1")))
m.authority.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1")))
m.additional.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1")))
m.timeReceived = 86401
f = server.DNSServerFactory(verbose=2)
assertLogMessage(
self,
[
"Answers are <A address=127.0.0.1 ttl=None>",
"Authority is <A address=127.0.0.1 ttl=None>",
"Additional is <A address=127.0.0.1 ttl=None>",
"Processed query in 1.000 seconds",
],
f.sendReply,
protocol=NoopProtocol(),
message=m,
address=None,
)
def test_resolverDefaultEmpty(self):
"""
L{server.DNSServerFactory.resolver} is an empty L{resolve.ResolverChain}
by default.
"""
self.assertEqual(
server.DNSServerFactory().resolver.resolvers,
[])
def main():
factory = server.DNSServerFactory(
clients=[DynamicResolver()]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(10053, protocol)
reactor.listenTCP(10053, factory)
reactor.run()
def main():
factory = server.DNSServerFactory(clients=[
DynamicResolver(),
client.Resolver(resolv='/etc/resolv.conf')
])
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.run()
def main(pattern, IP):
factory = server.DNSServerFactory(clients=[
DNS_Reslover(pattern, IP),
client.Resolver(resolv='/etc/resolv.conf')
])
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.listenTCP(53, factory)
reactor.run()
def runNameserver(dnsport):
"""Run the DNS server.
:param dnsport: The port on which to listen for dns requests"""
global protocol
logging.debug("Nameserver starts on port %d" % dnsport)
factory = server.DNSServerFactory(clients=[DynamicResolver()])
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(dnsport, protocol)
def test_cacheOverride(self):
"""
L{server.DNSServerFactory.__init__} assigns the last object in the
C{caches} list to L{server.DNSServerFactory.cache}.
"""
dummyResolver = object()
self.assertEqual(
server.DNSServerFactory(caches=[object(), dummyResolver]).cache,
dummyResolver)
def main(port):
factory = server.DNSServerFactory(
clients=[create_resolver(servers=[('114.114.114.114', 53)], hosts='hosts')],
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(port, protocol)
reactor.listenTCP(port, factory)
reactor.run()
def test_clients(self):
"""
L{server.DNSServerFactory.__init__} accepts a C{clients} argument. The
value of this argument is a list and is used to extend the C{resolver}
L{resolve.ResolverChain}.
"""
dummyResolver = object()
self.assertEqual(
server.DNSServerFactory(
clients=[dummyResolver]).resolver.resolvers, [dummyResolver])
def main():
factory = server.DNSServerFactory(clients=[DynamicResolver()], verbose=0)
protocol = TruncatingDNSDatagramProtocol(controller=factory)
reactor.listenUDP(port, protocol)
reactor.listenTCP(port, factory)
log.startLogging(sys.stdout)
reactor.run()
def test_responseFromMessageNewMessage(self):
"""
L{server.DNSServerFactory._responseFromMessage} generates a response
message which is a copy of the request message.
"""
factory = server.DNSServerFactory()
request = dns.Message(answer=False, recAv=False)
response = factory._responseFromMessage(message=request),
self.assertIsNot(request, response)
