class ArcTestResolver(object): def __init__(self, records, port=8053, verbose=False): self.records = records self.port = port self.verbose = verbose def __enter__(self): zones = [] for (domain, txt) in self.records.items(): n = 255 frags = [("'" + txt[i:i+n] + "'") for i in range(0, len(txt), n)] zones.append(domain + " IN TXT " + " ".join(frags)) resolver = ZoneResolver("\n".join(zones)) if self.verbose: logger = DNSLogger() else: logger = NullLogger() self.server = DNSServer(resolver, port=self.port, logger=logger) self.server.start_thread() def __exit__(self, type, value, traceback): self.server.stop()
class CatlogResolver(BaseResolver): def __init__(self): self.txtMap = {} self.udp_server = None def setTxt(self, domain: str, value: str) -> None: self.txtMap[domain.lower()] = value def clearTxt(self, domain: str) -> None: del self.txtMap[domain.lower()] def resolve(self, request, handler): """ Respond to DNS request - parameters are request packet & handler. Method is expected to return DNS response """ reply = request.reply() qname = request.q.qname.idna()[:-1].lower() qtype = QTYPE[request.q.qtype] if qtype == 'TXT' and qname in self.txtMap: reply.add_answer(*RR.fromZone('{} IN TXT "{}"'.format( qname, self.txtMap[qname]))) else: reply.header.rcode = RCODE.NXDOMAIN return reply def start(self): self.udp_server = DNSServer(self, port=53, logger=SilentLogger()) self.udp_server.start_thread() def stop(self): self.udp_server.stop()
def serveDNS(logger, status_ctrl, main_frame): resolver = InterceptResolver('8.8.8.8', 53, '60s', status_ctrl, main_frame) DNSHandler.log = { 'log_request', # DNS Request 'log_reply', # DNS Response 'log_truncated', # Truncated 'log_error', # Decoding error } config = wx.ConfigBase.Get() host = config.Read("host") or socket.gethostbyname(socket.gethostname()) dnsport = config.Read("dnsport") or "53" try: udp_server = DNSServer(resolver, port=int(dnsport), address=host, logger=logger) except Exception as e: evt = custom_events.wxStatusEvent( message='Error starting DNS proxy: %s' % e) wx.PostEvent(status_ctrl, evt) return udp_server.start_thread() evt = custom_events.wxStatusEvent(message="proxy started") wx.PostEvent(status_ctrl, evt) try: while udp_server.isAlive(): time.sleep(1) except KeyboardInterrupt: sys.exit()
def run(self): port = int(os.getenv("PORT", 53)) upstream = os.getenv("UPSTREAM", "8.8.8.8") zone_file = Path(C.DNSHOSTS) self.logger_dns = LocalDNSLogger(self.sendRequests) self.resolver = Resolver(upstream, zone_file, self.sendRequests) self.udp_server = DNSServer(self.resolver, port=port, logger=self.logger_dns) self.tcp_server = DNSServer(self.resolver, port=port, logger=self.logger_dns, tcp=True) print( display_messages("starting {}".format(self.objectName()), info=True)) # logger.info('starting DNS server on port %d, upstream DNS server "%s"', port, upstream) self.udp_server.start_thread() self.tcp_server.start_thread() try: while self.udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
class ACMEDNS: def __init__(self, zone: str = ""): LOGGER.debug(f"DNS Server received zones: \n {zone}") self.resolver = ZoneResolver(textwrap.dedent(zone)) self.dns_logger = DNSLogger(prefix=False) self.server = DNSServer(self.resolver, port=10053, address="0.0.0.0", logger=self.dns_logger) def start(self): LOGGER.info("Starting DNS server...") self.server.start_thread() def stop(self): LOGGER.info("Stopping DNS server...") self.server.server.server_close() def update_zone(self, new_zone: str): LOGGER.debug(f"Updating DNS with new zone:\n {new_zone}") self.stop() self.resolver = ZoneResolver(textwrap.dedent(new_zone)) self.server = DNSServer(self.resolver, port=10053, address="0.0.0.0", logger=self.dns_logger) self.start()
def _perform(self, domain, validation_name, validation): if self.resolver is None: self.resolver = _AcmeResolver() self.resolver.addToken(validation) if self.servers is None: self.servers = [] active_udp_server = False error = None for Server in [TCP6Server, TCPServer, UDP6Server, UDPServer]: # Try IPv6 version first since it may listen on IPv4 as well. try: if Server.address_family == AF_INET6: address = self.conf('ipv6-address') else: address = self.conf('address') if address is not None: server = DNSServer(self.resolver, port=int(self.conf('port')), address=address, server=Server, logger=dnsLogger) server.start_thread() self.servers.append(server) if Server.socket_type == SOCK_DGRAM: active_udp_server = True except Exception as e: error = e if not active_udp_server: # Re-raise the exception when no UDP server was started successfully. raise errors.PluginError( 'Error starting DNS server: {0}'.format(error))
def __init__(self, listen_addresses: List[IpAndPort], upstream_dns_server: IpAndPort, dns_domains, default_domain, default_host_ip, handler, cli): super().__init__() self.default_domain = default_domain self.handler = handler self.dns_domains_globs = [ '*%s' % domain if domain.startswith('.') else domain for domain in dns_domains ] self.resolver = ZoneResolver([], glob=True) self.servers = [] resolver = InterceptResolver( self.dns_domains_globs, self.resolver, ProxyResolver(upstream_dns_server.ip.exploded, port=upstream_dns_server.port, timeout=5)) self.handler.log("Unhandled DNS requests will be resolved using %s" % upstream_dns_server) self.handler.log("DNS server listening on %s" % ", ".join(map(lambda x: str(x), listen_addresses))) for ip_and_port in listen_addresses: server = DNSServer(resolver, address=ip_and_port.ip.exploded, port=ip_and_port.port) server.thread_name = "%s:%s" % (ip_and_port.ip, ip_and_port.port) self.servers.append(server) self.watcher = DockerWatcher(self, default_host_ip, cli)
def start_dns_server(proxy, upstream, subscription_server_uri=None): """Start handling DNS requests. """ logger.info("uWSGI-DNS resolver is starting...") resolver = LocalResolver( proxy, upstream ) dns_server = DNSServer( resolver=resolver, address=DNS_HOST, port=DNS_PORT, server=ThreadedUDPServer, logger=LocalDNSLogger() ) # Start the subscription listener BEFORE the server. start_subscription_listener(resolver.add_domain_from_uwsgi) if subscription_server_uri: # Start the subscription checker BEFORE the server. start_subscription_checker(subscription_server_uri, resolver.add_domains) # And start the DNS server. dns_server.start()
class MyDNSServer: server = None @classmethod def start(self, address): my_resolver = MyResolver(address) logger = DNSLogger(prefix=False) self.server = DNSServer(my_resolver, port=10053, address=str(address), logger=logger) self.server.start_thread() print("DNS server is UP") # while server.isAlive(): # time.sleep(1) @classmethod def shut_down(self): print("shutting down the DNS server..\n") self.server.stop()
def start(self): logger = DNSLogger(prefix=False) udp_server = DNSServer(self, port=10053, address=self.address, logger=logger) udp_server.start_thread()
def main(): import argparse import json import time from importlib import import_module from dnslib.server import DNSLogger, DNSServer parser = argparse.ArgumentParser( description="Database lookup based DNS resolver" ) parser.add_argument( "--storage", "-s", default='labDNS.storages.DictStorage' ) parser.add_argument("--config", "-c", type=json.loads, default=dict()) parser.add_argument("--zone", "-z") parser.add_argument("--ttl", "-t", default=10, type=int) parser.add_argument("--log", "-l", default="request,reply,truncated,error") parser.add_argument("--port", "-p", default=53, type=int) parser.add_argument("--address", "-a", default="localhost") parser.add_argument("--keymaker", "-k", default=None) parser.add_argument("--processor", default=None) parser.add_argument("--upstream", "-u", default=None) parser.add_argument("--bypass", "-b", default=[], nargs='+') args = parser.parse_args() config = args.config Storage = locate(args.storage) storage = Storage(config) keymaker = import_module(args.keymaker).keymaker if args.keymaker else None processor = ( import_module(args.processor).processor if args.processor else None ) resolver = DatabaseLookupResolver( storage, args.zone, ttl=args.ttl, keymaker=keymaker, upstream=args.upstream, processor=processor, bypass=args.bypass, ) logger = DNSLogger(args.log) server = DNSServer( resolver, port=args.port, address=args.address, logger=logger, ) server.start_thread() while server.isAlive(): time.sleep(1)
def setUp(self): zone_file = ''' crate.internal. 600 IN SOA localhost localhost ( 2007120710 1d 2h 4w 1h ) crate.internal. 400 IN NS localhost crate.internal. 600 IN A 127.0.0.1''' transport_ports = [bind_port() for _ in range(self.num_nodes)] for port in transport_ports: zone_file += ''' _test._srv.crate.internal. 600 IN SRV 1 10 {port} 127.0.0.1.'''.format( port=port) dns_port = bind_port() self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port) self.dns_server.start_thread() self.nodes = nodes = [] for i in range(self.num_nodes): settings = { 'node.name': f'node-{i}', 'cluster.name': 'crate-dns-discovery', 'psql.port': 0, 'transport.tcp.port': transport_ports[i], "discovery.seed_providers": "srv", "discovery.srv.query": "_test._srv.crate.internal.", "discovery.srv.resolver": "127.0.0.1:" + str(dns_port) } if i is 0: settings['cluster.initial_master_nodes'] = f'node-{i}' node = CrateNode(crate_dir=crate_path(), version=(4, 0, 0), settings=settings, env={'CRATE_HEAP_SIZE': '256M'}) node.start() nodes.append(node)
def start(self): if not self.server: print(" * Starting DNS server on {}:53".format(self.default_ip)) try: self.server = DNSServer(self.resolver, port=53, address=self.default_ip) self.server.start_thread() except Exception as e: print(" * ERROR: Unable to bind to port 53. DNS server could not start: {}".format(e))
def __init__(self, zone: str = ""): LOGGER.debug(f"DNS Server received zones: \n {zone}") self.resolver = ZoneResolver(textwrap.dedent(zone)) self.dns_logger = DNSLogger(prefix=False) self.server = DNSServer(self.resolver, port=10053, address="0.0.0.0", logger=self.dns_logger)
def main(): if DEBUG: logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(name)-24s %(levelname)-8s %(message)s') logger = DNSLogger() resolver = DdnssResolver(UPSTREAM_ADDRESS, UPSTREAM_PORT, API_SERVER, API_SERVER_USERNAME, API_SERVER_PASSWORD, ZONES, TTL, MAPPINGS) server = DNSServer(resolver, port=int(SERVER_PORT), logger=logger, tcp=USE_TCP) print(f'running on 0.0.0.0:{SERVER_PORT}/{USE_TCP and "tcp" or "udp"}') server.start()
class DnsSrvDiscoveryTest(TestCase): num_nodes = 3 def setUp(self): zone_file = ''' crate.internal. 600 IN SOA localhost localhost ( 2007120710 1d 2h 4w 1h ) crate.internal. 400 IN NS localhost crate.internal. 600 IN A 127.0.0.1''' transport_ports = [bind_port() for _ in range(self.num_nodes)] for port in transport_ports: zone_file += ''' _test._srv.crate.internal. 600 IN SRV 1 10 {port} 127.0.0.1.'''.format( port=port) dns_port = bind_port() self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port) self.dns_server.start_thread() self.nodes = nodes = [] for i in range(self.num_nodes): settings = { 'node.name': f'node-{i}', 'cluster.name': 'crate-dns-discovery', 'psql.port': 0, 'transport.tcp.port': transport_ports[i], "discovery.seed_providers": "srv", "discovery.srv.query": "_test._srv.crate.internal.", "discovery.srv.resolver": "127.0.0.1:" + str(dns_port) } if i == 0: settings['cluster.initial_master_nodes'] = f'node-{i}' node = CrateNode(crate_dir=crate_path(), version=(4, 0, 0), settings=settings, env={ 'CRATE_HEAP_SIZE': '256M', 'CRATE_JAVA_OPTS': '-Dio.netty.leakDetection.level=paranoid', }) node.start() nodes.append(node) def tearDown(self): for node in self.nodes: node.stop() self.dns_server.server.server_close() self.dns_server.stop() def test_nodes_discover_each_other(self): with connect(self.nodes[0].http_url) as conn: c = conn.cursor() c.execute('''select count(*) from sys.nodes''') result = c.fetchone() self.assertEqual(result[0], self.num_nodes, 'Nodes must be able to join')
def update_zone(self, new_zone: str): LOGGER.debug(f"Updating DNS with new zone:\n {new_zone}") self.stop() self.resolver = ZoneResolver(textwrap.dedent(new_zone)) self.server = DNSServer(self.resolver, port=10053, address="0.0.0.0", logger=self.dns_logger) self.start()
def __init__(self, server, port=53, queue=None, ifname='eth0'): resolver = PACDNSResolver(server, port, timeout=5, queue=queue, ifname=ifname) handler = DNSHandler logger = DNSLogger("request", False) self.udp_server = DNSServer(resolver, logger=logger, handler=handler)
class DnsServer: def __init__(self, host: str, record: str, url: str): resolver = FixedResolver(record, url) self._server = DNSServer(resolver, port=10053, address=host) def start(self): self._server.start_thread() def shutDown(self): self._server.stop()
def run(self): zones = self.get_zones() upstream = self.get_upstream() api_url = self.get_api_url() api_token = self.get_api_token() port = self.get_port() listen = self.get_listen() resolver = Resolver(zones, upstream, api_url, api_token) udp_server = DNSServer(resolver, address=listen, port=port, logger=DnsLogger()) tcp_server = DNSServer(resolver, address=listen, port=port, tcp=True, logger=DnsLogger()) logger.info( 'starting DNS server on port %d, upstream DNS server "%s", %d zones', port, upstream, len(zones), ) udp_server.start_thread() tcp_server.start_thread() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
class DnsSrvDiscoveryTest(TestCase): num_nodes = 3 def setUp(self): zone_file = ''' crate.internal. 600 IN SOA localhost localhost ( 2007120710 1d 2h 4w 1h ) crate.internal. 400 IN NS localhost crate.internal. 600 IN A 127.0.0.1''' transport_ports = [bind_port() for _ in range(self.num_nodes)] for port in transport_ports: zone_file += ''' _test._srv.crate.internal. 600 IN SRV 1 10 {port} 127.0.0.1.'''.format(port=port) dns_port = bind_port() self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port) self.dns_server.start_thread() self.nodes = nodes = [] for i in range(self.num_nodes): settings = { 'node.name': f'node-{i}', 'cluster.name': 'crate-dns-discovery', 'psql.port': 0, 'transport.tcp.port': transport_ports[i], "discovery.seed_providers": "srv", "discovery.srv.query": "_test._srv.crate.internal.", "discovery.srv.resolver": "127.0.0.1:" + str(dns_port) } if i is 0: settings['cluster.initial_master_nodes'] = f'node-{i}' node = CrateNode( crate_dir=crate_path(), version=(4, 0, 0), settings=settings, env={ 'CRATE_HEAP_SIZE': '256M' } ) node.start() nodes.append(node) def tearDown(self): for node in self.nodes: node.stop() self.dns_server.server.server_close() self.dns_server.stop() def test_nodes_discover_each_other(self): with connect(self.nodes[0].http_url) as conn: c = conn.cursor() c.execute('''select count(*) from sys.nodes''') result = c.fetchone() self.assertEqual(result[0], self.num_nodes, 'Nodes must be able to join')
def main(): resolver = SocksResolver(REAL_SERVER, 53) logger = DNSLogger("request,reply,truncated,error", False) server = DNSServer( resolver, port=53, address=LISTEN_ADDR, logger=logger, ) try: server.start() except KeyboardInterrupt: server.stop()
class PACDNSServer(): def __init__(self, server, port=53, queue=None, ifname='eth0'): resolver = PACDNSResolver(server, port, timeout=5, queue=queue, ifname=ifname) handler = DNSHandler logger = DNSLogger("request", False) self.udp_server = DNSServer(resolver, logger=logger, handler=handler) def start(self, no_exit=False): self.udp_server.start_thread() while no_exit and self.udp_server.isAlive(): time.sleep(1)
def main(): zone = ''' *.{dnsdomain}. IN A {serverip} {dnsdomain}. IN A {serverip} '''.format(dnsdomain=config.DNS_DOMAIN, serverip=config.SERVER_IP) resolver = ZoneResolver(zone, True) logger = MysqlLogger() print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP")) udp_server = DNSServer(resolver, port=53, address='', logger=logger) udp_server.start()
def start_dns_server(): global server logging.info("starting dns server thread ... ") logging.debug("Binding on IP:" + GConfig["dnsserver"]) resolver = DNSListResolver() logger = DNSLogger(log="+send", prefix=False) server = DNSServer(resolver, port=GConfig['port'], address=GConfig['dnsserver'], logger=logger) server.start_thread() return (1)
def __init__(self): resolver = Resolver() self.servers = [ DNSServer(resolver, port=CONFIG.server['port'], address=CONFIG.server['address'], tcp=True), DNSServer(resolver, port=CONFIG.server['port'], address=CONFIG.server['address'], tcp=False), ]
class DNS(object): def __init__(self): self.default_ip = get_default_ip() self.resolver = None self.server = None self.base_zone_data = None self.reset() def wait_for_query(self, record_type, record_name, timeout): self.resolver.wait_for_query(record_type, record_name, timeout) def load_zone(self, api_version, api_protocol, zone_name, port_base): zone_file = open(zone_name).read() template = Template(zone_file) zone_data = template.render(ip_address=self.default_ip, api_ver=api_version, api_proto=api_protocol, domain=CONFIG.DNS_DOMAIN, port_base=port_base) self.resolver = WatchingResolver(self.base_zone_data + zone_data) self.stop() print(" * Loading DNS zone file '{}' with api_ver={}".format( zone_name, api_version)) self.start() def reset(self): zone_file = open("test_data/core/dns_base.zone").read() template = Template(zone_file) self.base_zone_data = template.render(ip_address=self.default_ip, domain=CONFIG.DNS_DOMAIN) self.resolver = WatchingResolver(self.base_zone_data) self.stop() print(" * Loading DNS zone base file") self.start() def start(self): if not self.server: print(" * Starting DNS server on {}:53".format(self.default_ip)) try: self.server = DNSServer(self.resolver, port=53, address=self.default_ip) self.server.start_thread() except Exception as e: print( " * ERROR: Unable to bind to port 53. DNS server could not start: {}" .format(e)) def stop(self): if self.server: print(" * Stopping DNS server on {}:53".format(self.default_ip)) self.server.stop() self.server = None
def start_bind(self): """ 启动监听,udp监听同一个端口时只有第一个有用 :return: """ self.logger.info("\n" + self.zone) resolver = ZoneResolver(textwrap.dedent(self.zone), True) dns_logger = DnsLogger() self.udp_server = DNSServer(resolver, port=self.port, address=self.host, logger=dns_logger) return True
def start(self, address): my_resolver = MyResolver(address) logger = DNSLogger(prefix=False) self.server = DNSServer(my_resolver, port=10053, address=str(address), logger=logger) self.server.start_thread() print("DNS server is UP")
def _reload(cls, first_run=False): from utils import setting, logger # restart threads dns_servers = cls.parse_server_config(setting.conf) for server in dns_servers: resolver = RouterResolver(server) empty_logger = EmptyDNSLogger() _server = DNSServer(resolver, address=server['hostname'], port=server['port'], tcp=server['scheme'] == "tcp", logger=empty_logger) _server.start_thread() cls.servers.append(_server) if not first_run: logger.info('Config file reloaded: ' + ArgumentParser.args['config']) logger.info('Started local DNS server: ' + server['url'], LOGGER_NAME)
class DNSServerThread(QThread): """ Simple DNS server UDP resolver """ sendRequests = pyqtSignal(object) # I'll use this object in future feature def __init__(self, conf): super(DNSServerThread, self).__init__(parent=None) self.resolver = None self.conf = conf def run(self): port = int(os.getenv("PORT", 53)) upstream = os.getenv("UPSTREAM", "8.8.8.8") zone_file = Path(C.DNSHOSTS) self.logger_dns = LocalDNSLogger(self.sendRequests) self.resolver = Resolver(upstream, zone_file, self.sendRequests) self.udp_server = DNSServer(self.resolver, port=port, logger=self.logger_dns) self.tcp_server = DNSServer(self.resolver, port=port, logger=self.logger_dns, tcp=True) print( display_messages("starting {}".format(self.objectName()), info=True)) # logger.info('starting DNS server on port %d, upstream DNS server "%s"', port, upstream) self.udp_server.start_thread() self.tcp_server.start_thread() try: while self.udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass def getpid(self): """ return the pid of current process in background""" return "thread" def getID(self): """ return the name of process in background""" return self.objectName() def stop(self): self.udp_server.stop() self.tcp_server.stop() print( display_messages("thread {} successfully stopped".format( self.objectName()), info=True))
class DNS(object): def __init__(self): self.default_ip = get_default_ip() self.resolver = None self.server = None self.base_zone_data = None self.reset() def load_zone(self, api_version, api_protocol): zone_file = open("test_data/IS0401/dns_records.zone").read() template = Template(zone_file) zone_data = template.render(ip_address=self.default_ip, api_ver=api_version, api_proto=api_protocol, domain=DNS_DOMAIN) self.resolver = ZoneResolver(self.base_zone_data + zone_data) self.stop() print(" * Loading DNS zone file with api_ver={}".format(api_version)) self.start() def reset(self): zone_file = open("test_data/IS0401/dns_base.zone").read() template = Template(zone_file) self.base_zone_data = template.render(ip_address=self.default_ip, domain=DNS_DOMAIN) self.resolver = ZoneResolver(self.base_zone_data) self.stop() print(" * Loading DNS zone base file") self.start() def start(self): if not self.server: print(" * Starting DNS server on {}:53".format(self.default_ip)) try: self.server = DNSServer(self.resolver, port=53, address=self.default_ip) self.server.start_thread() except Exception as e: print( " * ERROR: Unable to bind to port 53. DNS server could not start: {}" .format(e)) def stop(self): if self.server: print(" * Stopping DNS server on {}:53".format(self.default_ip)) self.server.stop() self.server = None
def _perform(self, domain, validation_name, validation): if self.resolver is None: self.resolver = _AcmeResolver() self.resolver.addToken(validation) if self.udp_server is None: try: self.udp_server = DNSServer(self.resolver, port=53, address=self.conf('address'), logger=dnsLogger) self.udp_server.start_thread() except Exception as e: raise errors.PluginError( 'Error starting DNS server: {0}'.format(e))
def main(): zone = ''' *.{dnsdomain}. IN NS {ns1domain}. *.{dnsdomain}. IN NS {ns2domain}. *.{dnsdomain}. IN A {serverip} {dnsdomain}. IN A {serverip} '''.format( dnsdomain=settings.DNS_DOMAIN, ns1domain=settings.NS1_DOMAIN, ns2domain=settings.NS2_DOMAIN, serverip=settings.SERVER_IP) resolver = ZoneResolver(zone, True) logger = MysqlLogger() print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP")) udp_server = DNSServer(resolver, port=53, address='', logger=logger) udp_server.start()
def serveDNS(hostaddr): dnsport = 53 resolver = InterceptResolver('8.8.8.8', dnsport, '60s', hostaddr) try: udp_server = DNSServer(resolver, port=dnsport, address=hostaddr, logger = DNSLogger("-send,-recv,-request,-reply,-truncated,-error", False)) except Exception as e: raise udp_server.start_thread() try: while udp_server.isAlive(): time.sleep(1) except KeyboardInterrupt: sys.exit()
def main(): loadconfig() proxy_server = ThreadingTCPServer(('', 1081), ProxyServer) thread = threading.Thread(target=proxy_server.serve_forever) thread.daemon = True thread.start() print 'proxy running' resolver = DNSProxyResolver(DefaultDNS, 53, 10) logger = DNSLogger(log='-log_request, -log_reply', prefix=False) dns_server = DNSServer(resolver, port=5353, address='127.0.0.1', logger=logger, handler=DNSHandler) dns_server.start_thread() print 'dns running' try: while True: time.sleep(600) sys.stderr.flush() sys.stdout.flush() except socket.error, e: logging.error(e)
def serveDNS(logger, status_ctrl, main_frame): resolver = InterceptResolver('8.8.8.8', 53, '60s', status_ctrl, main_frame) DNSHandler.log = { 'log_request', # DNS Request 'log_reply', # DNS Response 'log_truncated', # Truncated 'log_error', # Decoding error } config = wx.ConfigBase.Get() host = config.Read("host") or socket.gethostbyname(socket.gethostname()) dnsport = config.Read("dnsport") or "53" try: udp_server = DNSServer(resolver, port=int(dnsport), address=host, logger=logger) except Exception as e: evt = custom_events.wxStatusEvent(message='Error starting DNS proxy: %s' % e) wx.PostEvent(status_ctrl,evt) return udp_server.start_thread() evt = custom_events.wxStatusEvent(message="proxy started") wx.PostEvent(status_ctrl,evt) try: while udp_server.isAlive(): time.sleep(1) except KeyboardInterrupt: sys.exit()
def server_start(zone=None, ttl=3600, **kwargs): if zone == None: def zone_builder(): zone = StringIO.StringIO() server_zone_list(zone=zone) zone.seek(0) return zone elif zone == '-': def zone_builder(): return sys.stdin else: def zone_builder(): return open(zone) resolver = ZoneResolver(zone_builder, False, ttl) logger = DNSLogger("request,reply,truncated,error", False) def reload_dns_config(signum, frame): if signum == signal.SIGUSR1: resolver.load() signal.signal(signal.SIGUSR1, reload_dns_config) udp_server = DNSServer(resolver, port=53, address="", logger=logger) udp_server.start()
def start(self): handler = DNSHandler # log options: "recv,send,request,reply,truncated,error,data" # log defaults: "request,reply,truncated,error" # It's just too much stuff! logger = DNSLogger("truncated,error",True) self.log.info("Starting UDP server") if 'udp_server' not in dir(self): self.udp_server = DNSServer(self, port=self.LOCAL_PORT, address=self.LOCAL_IP, logger=logger, handler=handler) self.udp_server.start_thread() if self.TCP: self.log.info("Starting TCP server") if 'tcp_server' not in dir(self): self.tcp_server = DNSServer(self, port=self.LOCAL_PORT, address=self.LOCAL_IP, tcp=True, logger=logger, handler=handler) self.tcp_server.start_thread()
def setUp(self): zone_file = ''' crate.internal. 600 IN SOA localhost localhost ( 2007120710 1d 2h 4w 1h ) crate.internal. 400 IN NS localhost crate.internal. 600 IN A 127.0.0.1''' transport_ports = [bind_port() for _ in range(self.num_nodes)] for port in transport_ports: zone_file += ''' _test._srv.crate.internal. 600 IN SRV 1 10 {port} 127.0.0.1.'''.format(port=port) dns_port = bind_port() self.dns_server = DNSServer(ZoneResolver(zone_file), port=dns_port) self.dns_server.start_thread() self.nodes = nodes = [] for i in range(self.num_nodes): settings = { 'node.name': f'node-{i}', 'cluster.name': 'crate-dns-discovery', 'psql.port': 0, 'transport.tcp.port': transport_ports[i], "discovery.seed_providers": "srv", "discovery.srv.query": "_test._srv.crate.internal.", "discovery.srv.resolver": "127.0.0.1:" + str(dns_port) } if i is 0: settings['cluster.initial_master_nodes'] = f'node-{i}' node = CrateNode( crate_dir=crate_path(), version=(4, 0, 0), settings=settings, env={ 'CRATE_HEAP_SIZE': '256M' } ) node.start() nodes.append(node)
def handle(self, *args, **options): # map django command verbosity to logging options logger = DNSLogger(log={ '0': '-request,-reply,-truncated,-error', '1': '', '2': '+data', '3': '+recv,+send,+data' }[options['verbosity']]) udp_server = DNSServer( resolver=InterceptingResolver(), address=options['address'], port=options['port'], logger=logger ) udp_server.start_thread() try: while udp_server.isAlive(): time.sleep(1) except KeyboardInterrupt: udp_server.stop()
'hello.subnet.lan', rdata=dnslib.A('192.168.0.0') )) return reply if __name__ == '__main__': DBusGMainLoop(set_as_default=True) try: resolver = AvahiBrowser() logger = DNSLogger(prefix=False) server = DNSServer( resolver, port=8053, address='0.0.0.0', # tcp=True, logger=logger) resolver.connect() # scanner.browse_domain("local", "_ssh._tcp") resolver.browse_domain('local') server.start_thread() # server.start() except dbus.DBusException as e: print("Failed to connect to Avahi, is it running?: {}".format(e)) sys.exit(1) loop = gobject.MainLoop()
def main(): global OPTIONS, ARGS parser = OptionParser() parser.add_option("-b", "--bind", dest = "bind", \ type = "string", default = "127.0.0.7:53", \ help = "set bind address/port to IP[:PORT]. " \ "Default value is `127.0.0.7:53'.", \ metavar = "IP[:PORT]") parser.add_option("-t", "--timeout", dest = "timeout", \ type = "int", default = "5", \ help = "set DNS resolving timeout to SECONDS", \ metavar = "SECONDS") parser.add_option("-r", "--retry", dest = "retry", \ type = "int", default = "3", \ help = "set retry count to COUNT", metavar = "COUNT") parser.add_option("-i", "--invalid-resolve", dest = "invalid_resolve", \ type = "string", default = r"10\.10\.34\.\d+", \ help = "REGEX is a an IP address or a regular " \ "expression that will not be prefered on DNS " \ "resolving. Default value is `10.10.34.\\d+'.", \ metavar = "REGEX") parser.add_option("--request-bind", dest = "request_bind", \ type = "string", default = "", \ help = "bind to IP address before sending DNS " \ "requests.", metavar = "IP") parser.add_option("-q", "--quiet", dest = "quiet", \ action = "store_true", default = False, \ help = "do not print any log") parser.set_usage("%s [OPTION]... DNS_SERVER[:PORT]..." % \ sys.argv[0]) parser.set_description(__doc__) OPTIONS, ARGS = parser.parse_args() if len(ARGS) < 1: parser.print_help() exit(1) def get_address_port(arg): address_port = arg if ":" in arg else "%s:53" % arg address_port = address_port.split(":") return address_port[0], int(address_port[1]) bind_address, bind_port = get_address_port(OPTIONS.bind) dns_servers = [get_address_port(arg) for arg in ARGS] resolver = ProxyResolver(dns_servers, request_bind_address = \ (OPTIONS.request_bind or None)) logger = DNSLogger("request,reply,truncated,error", False) \ if not OPTIONS.quiet else \ DNSLogger("-request,-reply,-truncated,-error,-log_recv," \ "-log_send,-log_data", False) udp_server = DNSServer(resolver, port = bind_port, address = bind_address, logger = logger if not OPTIONS.quiet else None, handler = DNSHandler, server = UDPServer) udp_server.start_thread() try: while udp_server.isAlive(): time.sleep(1) except KeyboardInterrupt: if not OPTIONS.quiet: print("Shutting down the server with user request...") udp_server.stop() exit(0)
def start_server(resolver): server = DNSServer(resolver=resolver, **config['server']['service']) server.start()
args=parser.parse_args() if dnslib_imported: try: dns_srv, dns_port=args.dns_server.split(':',1) dns_port=int(dns_port) except Exception as e: display("[-] %s"%e) display("[-] Invalid dns server : %s"%args.dns_server) exit(1) resolver = ProxyResolver(dns_srv,dns_port) handler = PassthroughDNSHandler # if args.passthrough else DNSHandler logger = DNSLogger("request,reply,truncated,error", False) udp_server = DNSServer(resolver, port=args.dns_port, address="127.0.0.1", logger=logger, handler=handler) udp_server.start_thread() display("[+] DNS server started on %s:%s forwarding all DNS trafic to %s:%s using TCP"%("127.0.0.1", args.dns_port, dns_srv, dns_port)) ptype,proxy_addr,proxy_port=args.proxy.split(":",2) t=None if ptype.upper()=="SOCKS5": t=socks.PROXY_TYPE_SOCKS5 elif ptype.upper()=="SOCKS4": t=socks.PROXY_TYPE_SOCKS4 elif ptype.upper()=="HTTP": t=socks.PROXY_TYPE_HTTP else: display("[-] --proxy : unknown proxy type %s"%ptype)
for ns in settings.NAMESERVERS: reply.add_answer(RR(request.q.qname, ttl=settings.TTL, rtype=QTYPE.NS, rdata=NS(ns))) return reply name = str(name.stripSuffix(settings.ROOT_DOMAIN)) match = re.match(r'ip-(\d{1,3})-(\d{1,3})-(\d{1,3})-(\d{1,3})\.?', name) if match is None: return nxdomain() ip = tuple(map(int, match.groups())) for octet in ip: if octet > 255: return nxdomain() # Now we return an empty response for not-A, or an actual response for A. # This is because we should not NXDOMAIN for domains that exist but have no records of # the specified type, so we have to go through the motions of checking validity first. reply = request.reply() if request.q.qtype == QTYPE.A or any_q: reply.add_answer(RR(request.q.qname, ttl=settings.TTL, rdata=A('%d.%d.%d.%d' % ip))) return reply if __name__ == "__main__": server = DNSServer(PebbleResolver(), port=settings.PORT) server.start()
class ParentalControls(BaseResolver): """ Intercepting resolver Proxy requests to upstream server optionally intercepting requests matching local records """ def __init__(self): self.log = logging.getLogger('dnspc.dnspc.ParentalControls') self.rules = [] self.hosts = [] self.LOCAL_IP = settings.DNS['LOCAL_IP'] self.LOCAL_PORT = settings.DNS['LOCAL_PORT'] self.UP_IP = settings.DNS['UP_IP'] self.UP_PORT = settings.DNS['UP_PORT'] self.TCP = settings.DNS['TCP'] self.TTL = parse_time(settings.DNS['TTL']) self.store ={ 'rules': settings.DATA['RULES'], 'hosts': settings.DATA['HOSTS'] } self.load_rules() self.load_hosts() ## Rules def load_rules(self): stored_rules = self.store['rules'].loadRecords() uids = [r['_uid'] for r in self.rules] for sr in stored_rules: if sr['_uid'] in uids: continue rule = PCRule(**sr) self.rules.append(rule) self.log.debug("WTF:rules: {}".format(self.rules)) def update_rule(self,rule): uid = rule._uid idxs = [i for i,c in enumerate(self.rules) if c._uid == uid] if len(idxs) == 0: self.rules.append(rule) else: self.rules[idxs[0]] = rule return rule def save_rule(self,d=None,**kwargs): #print "save_rule({})".format(kwargs) ## Remove angularjs artifacts: kwargs.pop('$$hashKey',None) saved_rule = self.store['rules'].editRecord(kwargs) self.log.debug("WTF: saved_rule: {}".format(saved_rule)) rule = PCRule(**saved_rule) ## Not sure if I should update the rule, or just reload from disk. self.update_rule(rule) return rule def del_rule(self,uid): ''' del_rule(uid) returns: None: uid did not appear in list. True: success False: failure ''' #print "del_rule({})".format(uid) #pp([x._serialize() for x in self.rules]) self.store['rules'].deleteRecord({'_uid':uid}) if uid not in [x._uid for x in self.rules]: return None self.rules = [x for x in self.rules if x._uid != uid] if uid in [x._uid for x in self.rules]: return False return True def get_rules(self): return self.rules def get_matching_rules(self,src_ip,dst_str): rs = [ r for r in self.rules if r.is_match(src_ip,dst_str) ] return rs ## Hosts def load_hosts(self): stored_hosts = self.store['hosts'].loadRecords() uids = [r['_uid'] for r in self.hosts] for sr in stored_hosts: if sr['_uid'] in uids: continue rule = PCHost(**sr) self.hosts.append(rule) def update_host(self,host): uid = host._uid idxs = [i for i,c in enumerate(self.hosts) if c._uid == uid] if len(idxs) == 0: self.hosts.append(host) else: self.hosts[idxs[0]] = host return host def save_host(self,d=None,**kwargs): #print "save_host({})".format(kwargs) ## Key generated by filestore. ## Can't risk overlap. #key = self._genkey(self.hosts) #print "WTF: Created key:",key kwargs.pop('$$hashKey',None) saved_host = self.store['hosts'].editRecord(kwargs) self.log.debug("WTF: saved_host: {}".format(saved_host)) host = PCHost(**saved_host) self.update_host(host) #pp(self.hosts) return host def del_host(self,uid): ''' del_host(uid) returns: None: uid did not appear in list. True: success False: failure ''' #print "del_host({})".format(uid) #pp([x._serialize() for x in self.hosts]) self.store['hosts'].deleteRecord({'_uid':uid}) if uid not in [x._uid for x in self.hosts]: return None self.hosts = [x for x in self.hosts if x._uid != uid] if uid in [x._uid for x in self.hosts]: return False return True def get_hosts(self): return self.hosts def _genkey(self,st): #print "WTF: _genkey()" key = int(time.strftime('%Y%U%w000')) #print "WTF: My key:",key keys = [r._uid for r in st] #print "WTF: keys:",keys #while len([1 for r in st if int(r['_uid']) == key]) > 0: while key in keys: key = key + 1 return key ## DNS Server Methods def start(self): handler = DNSHandler # log options: "recv,send,request,reply,truncated,error,data" # log defaults: "request,reply,truncated,error" # It's just too much stuff! logger = DNSLogger("truncated,error",True) self.log.info("Starting UDP server") if 'udp_server' not in dir(self): self.udp_server = DNSServer(self, port=self.LOCAL_PORT, address=self.LOCAL_IP, logger=logger, handler=handler) self.udp_server.start_thread() if self.TCP: self.log.info("Starting TCP server") if 'tcp_server' not in dir(self): self.tcp_server = DNSServer(self, port=self.LOCAL_PORT, address=self.LOCAL_IP, tcp=True, logger=logger, handler=handler) self.tcp_server.start_thread() def stop(self): self.log.debug( dir(self) ) if 'udp_server' in dir(self): self.log.debug( " Stopping UDP server." ) self.udp_server.stop() if 'tcp_server' in dir(self) and self.TCP: self.log.debug( " Stopping TCP server." ) self.tcp_server.stop() def resolve(self,request,handler): client_ip = handler.client_address[0] #print "Request from IP: {}".format(client_ip) qname = request.q.qname qtype = QTYPE[request.q.qtype] reply = request.reply() self.log.debug("{} request for {} by {}".format(qtype,qname,client_ip)) #print "query: {}".format(qname) #print "query: {}".format(qname.matchGlob("*.yahoo.com")) # Try to resolve locally unless on skip list rules = self.get_matching_rules(client_ip,qname) self.log.debug("Matched rules: {}".format(rules)) if any(rules): ## Collecting info on match for logging match_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') match_name = client_ip match_hosts = [h.name for h in self.hosts if h.ip == client_ip] if any(match_hosts): match_name = ",".join(match_hosts) for rule in rules: if rule.action == 'monitor': monitor.info({'time':match_time,'match_name':match_name,'client_ip':client_ip,'qname':str(qname)}) if rule.action == 'redirect': self.log.debug( "[{}] REDIRECT {}-->{} to {}".format(match_time,match_name,qname,rule.redirect) ) redir = rule.redirect reply.add_answer(*RR.fromZone("{} 3600 IN A {}".format(qname,redir))) return reply if rule.action == 'block': self.log.debug( "[{}] BLOCKED {}({})-->{}".format(match_time,match_name,client_ip,qname) ) return reply if rule.action == 'allow': self.log.debug( "[{}] ALLOWED {}({})-->{}".format(match_time,match_name,client_ip,qname) ) ## If no match or action == 'allow', then proxy the request to IP_UP if handler.protocol == 'udp': proxy_r = request.send(self.UP_IP,self.UP_PORT) else: proxy_r = request.send(self.UP_IP,self.UP_PORT,tcp=True) reply = DNSRecord.parse(proxy_r) return reply
logger = DNSLogger(args.log,args.log_prefix) print("Starting Zone Resolver (%s:%d) [%s]" % ( args.address or "*", args.port, "UDP/TCP" if args.tcp else "UDP")) for rr in resolver.zone: print(" | ",rr[2].toZone(),sep="") print() if args.udplen: DNSHandler.udplen = args.udplen udp_server = DNSServer(resolver, port=args.port, address=args.address, logger=logger) udp_server.start_thread() if args.tcp: tcp_server = DNSServer(resolver, port=args.port, address=args.address, tcp=True, logger=logger) tcp_server.start_thread() while udp_server.isAlive(): time.sleep(1)
qname = request.q.qname if not qname.label[-1] == "salt": # We don't know anything! return reply grain_path = qname.label[0:-1] grain_query = ":".join(reversed(grain_path)) minions = self.caller.sminion.functions["mine.get"]( grain_query, "network.ipaddrs", expr_form="grain" ) random.shuffle(minions) # load balancing! # only return the first three minions for hostname, addrs in minions.items()[0:2]: for addr in addrs: answer = RR(hostname, QTYPE.A, rdata=A(addr), ttl=5) reply.add_answer(answer) return reply if __name__ == "__main__": resolver = SaltResolver() server = DNSServer( resolver, port=5435, address="127.0.0.1" ) server.start_thread() while server.isAlive(): time.sleep(1)