def __init__(self, loc_stats, minute_breakdowns=(1, 5, 15, 60)):
self.loc_stats = loc_stats
self.seen_ips = Counter()
self.bot_ips = Counter()
self.non_bot_ips = MultiIntervalCounter(multiples=minute_breakdowns)
self.rdns = MultiIntervalCounter(multiples=minute_breakdowns)
self.resolver = createResolver()
def buildHostMap(ipFile, outFilename):
reactor.installResolver(client.createResolver(servers=[('127.0.0.1', 53), ('8.8.8.8', 53), ('8.8.4.4', 53)]))
CHUNK_SIZE = 20000
ipList = []
with open(ipFile, 'r') as f:
for line in f:
if line[0].isdigit():
ipList.append(line.split(',')[0])
outFile = open(outFilename, 'w')
def ret(dummy, chunk, outFile):
return defer.DeferredList([reverseLookup(ip, outFile) for ip in chunk])
ipList = [ipList[i:i+CHUNK_SIZE] for i in xrange(0, len(ipList), CHUNK_SIZE-1)]
d = defer.Deferred()
for chunk in ipList:
d.addCallback(ret, chunk, outFile)
# cleanup after ourselves
d.addCallback(die, outFile)
d.callback(None)
reactor.run()
def __init__(self, loc_stats):
self.loc_stats = loc_stats
self.seen_ips = Counter()
self.bot_ips = Counter()
self.non_bot_ips = MultiIntervalCounter()
self.rdns = MultiIntervalCounter()
self.resolver = createResolver()
def test_lookup(self):
"""
We perform an A lookup on the DNS test servers for the domains to be
tested and an A lookup on the known good DNS server.
We then compare the results from test_resolvers and that from
control_resolver and see if the match up.
If they match up then no censorship is happening (tampering: false).
If they do not we do a reverse lookup (PTR) on the test_resolvers and
the control resolver for every IP address we got back and check to see
if anyone of them matches the control ones.
If they do then we take not of the fact that censorship is probably not
happening (tampering: reverse-match).
If they do not match then censorship is probably going on (tampering:
true).
"""
log.msg("Doing the test lookups on %s" % self.input)
list_of_ds = []
hostname = self.input
resolver = [(self.localOptions['controlresolver'], 53)]
res = client.createResolver(servers=resolver, resolvconf='')
control_r = res.lookupAddress(hostname, timeout=self.lookupTimeout)
control_r.addCallback(self.process_a_answers, 'control')
control_r.addErrback(self.a_lookup_error, 'control')
for test_resolver in self.test_resolvers:
log.msg("Going for %s" % test_resolver)
resolver = [(test_resolver, 53)]
res = client.createResolver(servers=resolver, resolvconf='')
#res = self.createResolver(servers=resolver)
d = res.lookupAddress(hostname, timeout=self.lookupTimeout)
d.addCallback(self.process_a_answers, test_resolver)
d.addErrback(self.a_lookup_error, test_resolver)
list_of_ds.append(d)
list_of_ds.append(control_r)
dl = defer.DeferredList(list_of_ds)
dl.addCallback(self.do_reverse_lookups)
dl.addBoth(self.compare_results)
return dl
def test_overrideResolvConf(self):
"""
The I{resolvconf} parameter to L{client.createResolver} overrides the
resolver configuration file used by the L{client.Resolver} in the
L{resolve.ResolverChain} it returns.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver(resolvconf=b"/foo/bar")
self._resolvConfTest(resolver, b"/foo/bar")
def test_overrideResolvConf(self):
"""
The I{resolvconf} parameter to L{client.createResolver} overrides the
resolver configuration file used by the L{client.Resolver} in the
L{resolve.ResolverChain} it returns.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver(resolvconf=b"/foo/bar")
self._resolvConfTest(resolver, b"/foo/bar")
def test_defaultHosts(self):
"""
L{client.createResolver} returns a L{resolve.ResolverChain} including a
L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is
specified.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver()
self._hostsTest(resolver, b"/etc/hosts")
def test_cache(self):
"""
L{client.createResolver} returns a L{resolve.ResolverChain} including a
L{cache.CacheResolver}.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver()
res = [r for r in resolver.resolvers if isinstance(r, cache.CacheResolver)]
self.assertEqual(1, len(res))
def __init__(self, resolver=None, clock=None):
self.badMXs = {}
if resolver is None:
from twisted.names.client import createResolver
resolver = createResolver()
self.resolver = resolver
if clock is None:
from twisted.internet import reactor as clock
self.clock = clock
def run(self):
"""Start the monitoring"""
super(DNSQueryMonitoringProtocol, self).run()
# Create a resolver. Use the DNS server IPv4 addresses instead of
# self.server.ip as Twisted's createResolver (< 17.1.0) does not
# support querying a nameserver over IPv6.
self.resolver = client.createResolver([(ip, 53) for ip in self.server.ip4_addresses])
def test_overrideHosts(self):
"""
The I{hosts} parameter to L{client.createResolver} overrides the hosts
file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it
returns.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver(hosts=b"/foo/bar")
self._hostsTest(resolver, b"/foo/bar")
def test_overrideHosts(self):
"""
The I{hosts} parameter to L{client.createResolver} overrides the hosts
file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it
returns.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver(hosts=b"/foo/bar")
self._hostsTest(resolver, b"/foo/bar")
def test_defaultHosts(self):
"""
L{client.createResolver} returns a L{resolve.ResolverChain} including a
L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is
specified.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver()
self._hostsTest(resolver, b"/etc/hosts")
def test_defaultResolvConf(self):
"""
L{client.createResolver} returns a L{resolve.ResolverChain} including a
L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver
configuration file is specified.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver()
self._resolvConfTest(resolver, b"/etc/resolv.conf")
def test_defaultResolvConf(self):
"""
L{client.createResolver} returns a L{resolve.ResolverChain} including a
L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver
configuration file is specified.
"""
with AlternateReactor(Clock()):
resolver = client.createResolver()
self._resolvConfTest(resolver, b"/etc/resolv.conf")
def __init__(self, reactor, iface, options):
from twisted.names.client import createResolver
from stringbuffer import stringBuffer
self.reactor = reactor
self.options = options
self.iface = iface
self.resolver = createResolver()
self.mtu = (( 240 - 2 - options.endpoint.__len__() ) / 4) * 4
# self.mtu = 240 - (((options.endpoint.__len__() + 2)/4)*4)
self.queue = stringBuffer()
def run(self):
"""Start the monitoring"""
super(DNSQueryMonitoringProtocol, self).run()
# Create a resolver
self.resolver = client.createResolver([(self.server.ip, 53)])
if not self.checkCall or not self.checkCall.active():
self.checkCall = reactor.callLater(self.intvCheck, self.check)
def __init__(self, args):
server.DNSServerFactory.__init__(self)
# Create the resolvers
dns_resolver = client.createResolver(resolvconf='/etc/resolv.conf')
filter_resolver = resolvers.FilterResolver(dns_resolver,
self._get_filter(args))
# Override the default resolver for the parent factory
self.resolver = filter_resolver
self.canRecurse = True
def main():
factory = server.DNSServerFactory(clients=[
client.createResolver(servers=[('114.114.114.114', 53)], hosts='hosts')
])
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.listenTCP(53, factory)
reactor.run()
def __init__(self, args):
server.DNSServerFactory.__init__(self)
# Create the resolvers
dns_resolver = client.createResolver(resolvconf='/etc/resolv.conf')
filter_resolver = resolvers.FilterResolver(dns_resolver,
self._get_filter(args))
# Override the default resolver for the parent factory
self.resolver = filter_resolver
self.canRecurse = True
def test_reactor(self):
"""
The L{client.Resolver} included in the L{resolve.ResolverChain} returned
by L{client.createResolver} uses the global reactor.
"""
reactor = Clock()
with AlternateReactor(reactor):
resolver = client.createResolver()
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertIs(reactor, res[0]._reactor)
def test_reactor(self):
"""
The L{client.Resolver} included in the L{resolve.ResolverChain} returned
by L{client.createResolver} uses the global reactor.
"""
reactor = Clock()
with AlternateReactor(reactor):
resolver = client.createResolver()
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertIs(reactor, res[0]._reactor)
def fight_thread(control):
el = ExitList(filename = config.export_file_prefix + ".csv",
status_filename = config.export_file_prefix + ".status")
log.info("Initialized exit list.")
dnsel = client.createResolver()
torbel = client.createResolver(servers = [("localhost", 53)])
log.info("Initialized resolvers.")
def makeResultChecker(router):
return lambda rlist: printResult(router, rlist)
def printResult((source, dest, dest_port, qstr, dnsel_ok2), result_list):
global match, mismatch
dnsel_ok = False
torbel_ok = False
torbel_el_ok = el.tor_exit_search(source, dest, dest_port) is not None
query = ""
for (success, value) in result_list:
if success:
(a_names, auth, cnames) = value
assert len(a_names) == 1
for rec in a_names:
dnsel_ok = dnsel_zone in str(rec.name)
torbel_ok = local_zone in str(rec.name)
q = "%-15s -> %-15s:%-5d - " % (IPAddress(source), IPAddress(dest), dest_port)
if dnsel_ok2 and torbel_el_ok:
log.info(q + "DNSEL and TorBEL agree on YES.")
match += 1
elif not (dnsel_ok2 or torbel_el_ok):
log.info(q + "DNSEL and TorBEL agree on NO.")
match += 1
else:
log.info(q + "mismatch: DNSEL = %s, TorBEL DNS = %s, TorBEL query = %s, q = %s",
"yes" if dnsel_ok2 else "no",
"yes" if torbel_ok else "no",
"yes" if torbel_el_ok else "no",
qstr)
mismatch += 1
def test_overrideServers(self):
"""
Servers passed to L{client.createResolver} are used in addition to any
found in the file given by the I{resolvconf} parameter.
"""
resolvconf = self.path()
resolvconf.setContent(b"nameserver 127.1.2.3\n")
with AlternateReactor(Clock()):
resolver = client.createResolver(servers=[("127.3.2.1", 53)], resolvconf=resolvconf.path)
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertEqual([("127.3.2.1", 53)], res[0].servers)
self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)
def test_defaultServers(self):
"""
If no servers are given, addresses are taken from the file given by the
I{resolvconf} parameter to L{client.createResolver}.
"""
resolvconf = self.path()
resolvconf.setContent(b"nameserver 127.1.2.3\n")
with AlternateReactor(Clock()):
resolver = client.createResolver(resolvconf=resolvconf.path)
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertEqual([], res[0].servers)
self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)
def test_defaultServers(self):
"""
If no servers are given, addresses are taken from the file given by the
I{resolvconf} parameter to L{client.createResolver}.
"""
resolvconf = self.path()
resolvconf.setContent(b"nameserver 127.1.2.3\n")
with AlternateReactor(Clock()):
resolver = client.createResolver(resolvconf=resolvconf.path)
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertEqual([], res[0].servers)
self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)
def run(self):
"""Start the monitoring"""
super(DNSQueryMonitoringProtocol, self).run()
# Create a resolver. Use the DNS server IPv4 addresses instead of
# self.server.ip as Twisted's createResolver (< 17.1.0) does not
# support querying a nameserver over IPv6.
self.resolver = client.createResolver([
(ip, 53) for ip in self.server.ip4_addresses
])
if not self.checkCall or not self.checkCall.active():
self.checkCall = reactor.callLater(self.intvCheck, self.check)
def test_overrideServers(self):
"""
Servers passed to L{client.createResolver} are used in addition to any
found in the file given by the I{resolvconf} parameter.
"""
resolvconf = self.path()
resolvconf.setContent(b"nameserver 127.1.2.3\n")
with AlternateReactor(Clock()):
resolver = client.createResolver(servers=[("127.3.2.1", 53)],
resolvconf=resolvconf.path)
res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)]
self.assertEqual(1, len(res))
self.assertEqual([("127.3.2.1", 53)], res[0].servers)
self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)
def __init__(self, forwarders, savedir):
self.canRecurse = True
self.connections = []
self.forwarders = forwarders
forward_resolver = createResolver(servers=[(x, 53) for x in forwarders])
self.savedir = savedir
if self.savedir is not None:
self.savedir = os.path.expanduser(self.savedir)
if not os.path.exists(self.savedir):
log.msg("Setting up save directory " + savedir)
os.mkdir(self.savedir)
self.resolver = MiniDNSResolverChain([forward_resolver], self.savedir)
self.verbose = False
self.load()
def __init__(self, forwarders, savedir, ent):
self.canRecurse = True
self.connections = []
self.forwarders = forwarders
forward_resolver = createResolver(servers=[(x, 53) for x in forwarders])
self.savedir = savedir
if self.savedir is not None:
self.savedir = os.path.expanduser(self.savedir)
if not os.path.exists(self.savedir):
log.msg("Setting up save directory " + savedir)
os.mkdir(self.savedir)
os.chown(self.savedir, ent.pw_uid, ent.pw_gid)
self.resolver = CallsignResolverChain([forward_resolver], self.savedir)
self.verbose = True
self.load()
def __init__(self, resolver=None, clock=None):
"""
@type resolver: L{IResolver <twisted.internet.interfaces.IResolver>}
provider or L{None}
@param: A resolver.
@type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>}
provider or L{None}
@param clock: A reactor which will be used to schedule timeouts.
"""
self.badMXs = {}
if resolver is None:
from twisted.names.client import createResolver
resolver = createResolver()
self.resolver = resolver
if clock is None:
from twisted.internet import reactor as clock
self.clock = clock
def __init__(self, resolver=None, clock=None):
"""
@type resolver: L{IResolver <twisted.internet.interfaces.IResolver>}
provider or L{None}
@param: A resolver.
@type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>}
provider or L{None}
@param clock: A reactor which will be used to schedule timeouts.
"""
self.badMXs = {}
if resolver is None:
from twisted.names.client import createResolver
resolver = createResolver()
self.resolver = resolver
if clock is None:
from twisted.internet import reactor as clock
self.clock = clock
def lookup_name6(name, server=None):
""" This function performs the lookup for ipv6 """
if server != None:
resolver = client.Resolver(servers=[(server, 53)])
else:
resolver = client.createResolver()
outer_deferred = defer.Deferred()
def wrap_result(result):
""" Wrap result returned by Twisted """
outer_deferred.callback(LookupAnswer(result))
def wrap_error(err):
""" Wrap error returned by Twisted """
outer_deferred.errback(LookupErrors(err))
inner_deferred = resolver.lookupIPV6Address(name=name, timeout=[5, 10, 20])
inner_deferred.addCallbacks(wrap_result, wrap_error)
return outer_deferred
def lookup_name6(name, server=None):
""" This function performs the lookup for ipv6 """
if server != None:
resolver = client.Resolver(servers=[(server, 53)])
else:
resolver = client.createResolver()
outer_deferred = defer.Deferred()
def wrap_result(result):
""" Wrap result returned by Twisted """
outer_deferred.callback(LookupAnswer(result))
def wrap_error(err):
""" Wrap error returned by Twisted """
outer_deferred.errback(LookupErrors(err))
inner_deferred = resolver.lookupIPV6Address(name=name, timeout=[5, 10, 20])
inner_deferred.addCallbacks(wrap_result, wrap_error)
return outer_deferred
def _buildResolvers(self, config):
"""
Build DNS resolver instances in an order which leaves recursive
resolving as a last resort.
@type config: L{Options} instance
@param config: Parsed command-line configuration
@return: Two-item tuple of a list of cache resovers and a list of client
resolvers
"""
from twisted.names import client, cache, hosts
ca, cl = [], []
if config['cache']:
ca.append(cache.CacheResolver(verbose=config['verbose']))
if config['hosts-file']:
cl.append(hosts.Resolver(file=config['hosts-file']))
if config['recursive']:
cl.append(client.createResolver(resolvconf=config['resolv-conf']))
return ca, cl
def _buildResolvers(config):
"""
Build DNS resolver instances in an order which leaves recursive
resolving as a last resort.
@type config: L{Options} instance
@param config: Parsed command-line configuration
@return: Two-item tuple of a list of cache resovers and a list of client
resolvers
"""
from twisted.names import client, cache, hosts
ca, cl = [], []
if config["cache"]:
ca.append(cache.CacheResolver(verbose=config["verbose"]))
if config["hosts-file"]:
cl.append(hosts.Resolver(file=config["hosts-file"]))
if config["recursive"]:
cl.append(client.createResolver(resolvconf=config["resolv-conf"]))
return ca, cl
# POSSIBILITY OF SUCH DAMAGE.
###
import supybot.log as log
import supybot.conf as conf
import supybot.drivers as drivers
import supybot.ircmsgs as ircmsgs
from twisted.names import client
from twisted.internet import reactor, error
from twisted.protocols.basic import LineReceiver
from twisted.internet.protocol import ReconnectingClientFactory
# This hack prevents the standard Twisted resolver from starting any
# threads, which allows for a clean shut-down in Twisted>=2.0
reactor.installResolver(client.createResolver())
try:
from OpenSSL import SSL
from twisted.internet import ssl
except ImportError:
drivers.log.debug('PyOpenSSL is not available, '
'cannot connect to SSL servers.')
SSL = None
class TwistedRunnerDriver(drivers.IrcDriver):
def name(self):
return self.__class__.__name__
def run(self):
import smtplib from twisted.internet import reactor from twisted.names import dns, server, client cl = [] cl.append(client.createResolver()) f = server.DNSServerFactory(client=cl, verbose=2) #~ ltcp = reactor.listenTCP(0, f, interface="192.168.0.1") ltcp = reactor.listenTCP(53, f) f2 = dns.DNSDatagramProtocol(f) port = ltcp.getHost().port print "Port:", port #~ ludp = reactor.listenUDP(port, f2, interface="192.168.0.1") ludp = reactor.listenUDP(port, f2) reactor.run()
def _init_(self, **kwargs):
""" Setups DNS resolver. """
# https://twistedmatrix.com/documents/current/api/twisted.names.client.html#createResolver
self.dns = client.createResolver()
def main():
"""
Run the server.
"""
parser = argparse.ArgumentParser(
description='Resolve DNS queries from Database')
parser.add_argument('-c', '--config',
dest='config_file',
type=str, action='store',
default='./config.yml',
help='Path to the configuration file'
)
parser.add_argument('--port', '-p',
dest='port',
type=int, action='store',
default=10053,
help='Port number for the service'
)
parser.add_argument('--dry-run', '-d',
dest='dry_run',
action='store_true',
help='Dry run, just check the config file'
)
#parser.add_argument('--verbose', '-v',
# dest='verbose',
# action='store_true',
# help='Be verbose'
#)
params = parser.parse_args()
# Log to stdout, as this is intended to run in docker
log.startLogging(sys.stdout)
# Make new logging style compatible to traditional one
def observer(event, log=log):
log.msg(event['log_format'].format(**event))
if 'log_failure' in event:
log.err(event['log_failure'])
logger = Logger(namespace='default', observer=observer)
# Read config file
config = Config(params.config_file, logger)
logger.debug("Running with the following parameters:\n{data}", data=config)
# Dry run
if params.dry_run:
sys.exit(0)
# Build a connection lasting the lifetime of the service
connection = adbapi.ConnectionPool(
config.db_driver,
host=config.db_host,
port=config.db_port,
user=config.db_user,
passwd=config.db_passwd,
db=config.db_name,
cp_reconnect=True
)
# Build a global Resolver lasting the lifetime of the service
resolver = client.createResolver()
customResolver = DynamicResolver(config, connection, resolver, logger)
# Factory and protocol services
factory = server.DNSServerFactory(
caches=[
cache.CacheResolver(),
],
# Use "clients" instead of "authorities", so caching works
clients=[
hosts.Resolver(file=config.dns_hosts, ttl=config.dns_ttl),
customResolver,
]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
# Start polling loop, to avoid timeouts
poller = LoopingCall(customResolver.poll)
poller.start(config.poll_time)
# Listen TCP and UDP
reactor.listenUDP(params.port, protocol)
reactor.listenTCP(params.port, factory)
reactor.run()
###
import supybot.log as log
import supybot.conf as conf
import supybot.drivers as drivers
import supybot.ircmsgs as ircmsgs
from twisted.names import client
from twisted.internet import reactor, error
from twisted.protocols.basic import LineReceiver
from twisted.internet.protocol import ReconnectingClientFactory
# This hack prevents the standard Twisted resolver from starting any
# threads, which allows for a clean shut-down in Twisted>=2.0
reactor.installResolver(client.createResolver())
try:
from OpenSSL import SSL
from twisted.internet import ssl
except ImportError:
drivers.log.debug('PyOpenSSL is not available, '
'cannot connect to SSL servers.')
SSL = None
class TwistedRunnerDriver(drivers.IrcDriver):
def name(self):
return self.__class__.__name__
def run(self):
def __init__(self, resolver = None):
self.badMXs = {}
if resolver is None:
from twisted.names.client import createResolver
resolver = createResolver()
self.resolver = resolver
class MyDNSServer(DNSServerFactory):
"""Factory for building finger instances"""
def __init__(self, authorities=None, caches=None, clients=None, verbose=0):
r = DNSServerFactory.__init__(self, authorities, caches, clients,
verbose)
return r
def connectionMade(self, protocol):
print "Got a connection", protocol
return DNSServerFactory.connectionMade(self, protocol)
def handleQuery(self, message, protocol, address):
print "Got", message.toStr(), protocol, address
return DNSServerFactory.handleQuery(self, message, protocol, address)
if __name__ == '__main__':
port = 1053
f = MyDNSServer([client.createResolver(servers=['192.168.1.40'])],
verbose=True)
p = dns.DNSDatagramProtocol(f)
ret = service.MultiService()
for (klass, arg) in [(internet.TCPServer, f), (internet.UDPServer, p)]:
s = klass(port, arg)
s.setServiceParent(ret)
ret.startService()
reactor.run()
def dnsdone(name, ip):
print "name:", ip
del sends[ip]
for k in name:
for k1 in k:
if k1.type == 1:
print("!!! kk", k1.payload.dottedQuad())
ips.append(k1.payload.dottedQuad())
def dnserr(name, ip):
print "error", ip, name
del sends[ip]
res = client.createResolver([('1.1.1.10', 53)], 1, 1)
def testdns(i):
ip = "a%d.phobos.apple.com" % i
print i
sends[ip] = True
res.lookupAddress(ip, [2]).addCallback(dnsdone, ip).addErrback(dnserr, ip)
testdns(1)
for i in range(2, 1000):
reactor.callLater(i * 3, testdns, i)
def __init__(self, ns_addr):
self.ns = client.createResolver(servers=[ns_addr])
self.log = logging.getLogger('dns2udp.encoder')
ipdevpoll plugin to perform reverse DNS lookups on netbox IP addresses.
Will generate events if there are mismatches between device sysname
and dnsname.
"""
from itertools import cycle
from IPy import IP
from twisted.internet import defer, error
from twisted.names import client, dns
from twisted.names.error import DomainError
from nav.ipdevpoll import Plugin, shadows
_resolvers = cycle([client.createResolver() for i in range(3)])
class DnsName(Plugin):
"""Performs reverse DNS lookup on netbox IP address"""
@classmethod
def can_handle(self, netbox):
"Handles anything, anytime, since we don't query the netbox directly"
return True
def handle(self):
ip = IP(self.netbox.ip)
self._logger.debug("Doing DNS PTR lookup for %s", ip.reverseName())
# Use the OS configured DNS resolver method
resolver = next(_resolvers)
from tests.mockserver import MockServer, MockDNSServer
class LocalhostSpider(Spider):
name = "localhost_spider"
def start_requests(self):
yield Request(self.url)
def parse(self, response):
netloc = urlparse(response.url).netloc
self.logger.info("Host: %s" % netloc.split(":")[0])
self.logger.info("Type: %s" % type(response.ip_address))
self.logger.info("IP address: %s" % response.ip_address)
if __name__ == "__main__":
with MockServer() as mock_http_server, MockDNSServer() as mock_dns_server:
port = urlparse(mock_http_server.http_address).port
url = "http://not.a.real.domain:{port}/echo".format(port=port)
servers = [(mock_dns_server.host, mock_dns_server.port)]
reactor.installResolver(createResolver(servers=servers))
configure_logging()
runner = CrawlerRunner()
d = runner.crawl(LocalhostSpider, url=url)
d.addBoth(lambda _: reactor.stop())
reactor.run()
from twisted.names import client
class MyDNSServer(DNSServerFactory):
"""Factory for building finger instances"""
def __init__(self, authorities = None, caches = None,
clients = None, verbose = 0):
r=DNSServerFactory.__init__(self, authorities, caches, clients, verbose)
return r
def connectionMade(self, protocol):
print "Got a connection", protocol
return DNSServerFactory.connectionMade(self, protocol)
def handleQuery(self, message, protocol, address):
print "Got", message.toStr(), protocol, address
return DNSServerFactory.handleQuery(self, message, protocol, address)
if __name__ == '__main__':
port=1053
f=MyDNSServer([client.createResolver(servers=['192.168.1.40'])],
verbose=True)
p=dns.DNSDatagramProtocol(f)
ret = service.MultiService()
for (klass, arg) in [(internet.TCPServer, f), (internet.UDPServer, p)]:
s = klass(port, arg)
s.setServiceParent(ret)
ret.startService()
reactor.run()
def __init__(self, ns_addr):
self.ns = client.createResolver(servers=[ns_addr])
self.log = logging.getLogger('dns2udp.encoder')
def __init__(self, resolver=None):
self.badMXs = {}
if resolver is None:
from twisted.names.client import createResolver
resolver = createResolver()
self.resolver = resolver
