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_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_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 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 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 __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 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, resolver=None): self.badMXs = {} if resolver is None: from twisted.names.client import createResolver resolver = createResolver() self.resolver = resolver