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): 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
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)
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)
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))
def run_server(): p = argparse.ArgumentParser(description="SPF DNS Resolver") p.add_argument("--port","-p",type=int,default=53, metavar="<port>", help="Server port (default:53)") p.add_argument("--address","-a",default="", metavar="<address>", help="Listen address (default:all)") p.add_argument("--udplen","-u",type=int,default=0, metavar="<udplen>", help="Max UDP packet length (default:0)") p.add_argument("--tcp",action='store_true',default=False, help="TCP server (default: UDP only)") p.add_argument("--log",default="request,reply,truncated,error", help="Log hooks to enable (default: +request,+reply,+truncated,+error,-recv,-send,-data)") p.add_argument("--log-prefix",action='store_true',default=False, help="Log prefix (timestamp/handler/resolver) (default: False)") args = p.parse_args() domains = spf.get_domains() resolver = SPFResolver(domains) logger = DNSLogger(args.log,args.log_prefix) print("Starting SPF Resolver ({}:{}) [{}] on domains: {}".format( args.address or "*", args.port, "UDP/TCP" if args.tcp else "UDP", domains)) 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)
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(): if len(RESOLVE_HOSTS_IPV6) + len(RESOLVE_HOSTS_IPV4) == 0: raise RuntimeError("Please set response IPV4/IPV6 addresses!") if len(NS_LIST) == 0 or UPSTREAM_DOMAIN == "": raise RuntimeError( "Please input your upstream domain and Name servers") print('Upstream server:%s' % UPSTREAM_DOMAIN) for x in NS_LIST: print("Name server:%s" % x) update_dns_db() resolver = DomainResolver() udp_server = DNSServer(resolver, port=53) udp_server.start_thread() print("DNS started") while udp_server.isAlive(): time.sleep(1)
def cmd_dnsd(iface, ipv4, ipv6, verbose): if not ipv4 and not ipv6: print('You need to set at least one parameter -4 / -6') sys.exit(1) ifaces = {x[3] for x in conf.route.routes} ifaces = ifaces & {x[3] for x in conf.route6.routes} if not iface: iface = conf.iface if iface not in ifaces: print(iface, 'is an invalid iface, valid ifaces are: ', ifaces) sys.exit(1) if ipv4: addr4 = [ x[4] for x in conf.route.routes if x[2] != '0.0.0.0' and x[3] == iface ][0] if not addr4: print("IPv4 address not found") if ipv6: addr6 = [ x[4] for x in conf.route6.routes if x[1] == 0 and x[3] == iface ][0][-1] if not addr6: print("IPv6 address not found") print(addr4) print(addr6) sys.exit(0) resolver = MyResolver(addr4=addr4, addr6=addr6) server = DNSServer(resolver, port=53, address="0.0.0.0") server.start_thread() #drop_privileges(sys.argv[1]) while server.isAlive(): time.sleep(1) return True
def run(zones): import argparse,sys,time p = argparse.ArgumentParser(description="Fixed DNS Resolver") p.add_argument("--response","-r",default=". 60 IN A 127.0.0.1", metavar="<response>", help="DNS response (zone format) (default: 127.0.0.1)") p.add_argument("--zonefile","-f", metavar="<zonefile>", help="DNS response (zone file, '-' for stdin)") p.add_argument("--port","-p",type=int,default=10053, metavar="<port>", help="Server port (default:53)") p.add_argument("--address","-a",default="", metavar="<address>", help="Listen address (default:all)") p.add_argument("--udplen","-u",type=int,default=0, metavar="<udplen>", help="Max UDP packet length (default:0)") p.add_argument("--tcp",action='store_true',default=False, help="TCP server (default: UDP only)") responses = "\n".join(zones) resolver = FixedResolver(responses) logger = DNSLogger("request,reply,truncated,error", False) print("Starting Fixed Resolver (%s:%d) [%s]" % ( "*", 10053, "UDP")) for rr in resolver.rrs: print(" | ",rr.toZone().strip(),sep="") print() if 0: DNSHandler.udplen = 0 udp_server = DNSServer(resolver, port=10053, address="", logger=logger) udp_server.start_thread() while udp_server.isAlive(): time.sleep(1)
def cli(port, upstream, zonefile): signal.signal(signal.SIGTERM, handle_sig) resolver = Resolver(upstream, zonefile) udp_server = DNSServer(resolver, port=port) tcp_server = DNSServer(resolver, port=port, tcp=True) logger.info('starting DNS server on port %d, upstream DNS server "%s"', port, upstream) udp_server.start_thread() tcp_server.start_thread() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
def main(): with open("config.json") as conf_file: conf = json.load(conf_file) resolver = SubProxy( address=conf["upper_dns"], port=conf["port"], timeout=conf["socket_timeout"], b_list=conf["blacklist"], answer=conf["answer"], host=conf["host"], ) server = DNSServer(resolver, port=conf["port"], address=conf["host"]) server.start_thread() while server.isAlive(): time.sleep(1)
def main(): signal.signal(signal.SIGTERM, handle_sig) ap = argparse.ArgumentParser() ap.add_argument('--ip', type=str, default=DEFAULT_IP, help='serve ip of the DNS server (default: %(default)s)') ap.add_argument('--port', type=int, default=DEFAULT_PORT, help='serve port of the DNS server (default: %(default)d)') ap.add_argument('--upstream', type=str, default=DEFAULT_UPSTREAM, metavar='IP[:PORT]', help='the upstream DNS server (default: %(default)s)') ap.add_argument('--hosts', type=str, default=DEFAULT_HOSTS_FILE, metavar='FILENAME', help='hosts file (default: %(default)s)') arg = ap.parse_args() ip = arg.ip port = arg.port upstream = arg.upstream hosts_file = Path(arg.hosts) resolver = Resolver(upstream, hosts_file) udp_server = DNSServer(resolver, address=ip, port=port) tcp_server = DNSServer(resolver, address=ip, port=port, tcp=True) logger.info('starting DNS server on "%s:%d", upstream DNS server "%s"', ip, port, upstream) udp_server.start_thread() tcp_server.start_thread() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
async def run(self): port = self.get_port() listen = self.get_listen() # TODO: thread issues? api_client = ApiClient(self.get_api_url(), self.get_api_token()) if not api_client.wait_for_up(): logger.critical("could not connect to api. quitting") self.exit(1) if self.option("no_sync"): logger.info("skipping syncing api token") else: api_client.sync() resolver = Resolver(api_client) udp_server = DNSServer( resolver, address=listen, port=port, handler=DNSHandler, logger=DNSLogger(api_client), ) tcp_server = DNSServer( resolver, address=listen, port=port, tcp=True, handler=DNSHandler, logger=DNSLogger(api_client), ) logger.info("starting DNS server on port %d", port) udp_server.start_thread() tcp_server.start_thread() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
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 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()
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()
class SCIONDnsServer(SCIONElement): """ SCION DNS Server. Responsible for starting the DNS resolver threads, and frequently updating the shared instance data from ZK. :cvar float SYNC_TIME: How frequently (in seconds) to update the shared instance data from ZK. :cvar list SRV_TYPES: Service types to monitor/export """ SERVICE_TYPE = DNS_SERVICE SYNC_TIME = 1.0 SRV_TYPES = (BEACON_SERVICE, CERTIFICATE_SERVICE, DNS_SERVICE, PATH_SERVICE, SIBRA_SERVICE) def __init__(self, server_id, conf_dir, setup=False): # pragma: no cover """ :param str server_id: server identifier. :param str conf_dir: configuration directory. :param bool setup: should setup() be called? """ super().__init__(server_id, conf_dir) self.domain = DNSLabel(self.topology.dns_domain) self.lock = threading.Lock() self.services = {} if setup: self.setup() def setup(self): """ Set up various servers and connections required. """ self.resolver = ZoneResolver(self.lock, self.domain) self.udp_server = DNSServer(self.resolver, port=SCION_DNS_PORT, address=str(self.addr.host), server=SCIONDnsUdpServer, logger=SCIONDnsLogger()) self.tcp_server = DNSServer(self.resolver, port=SCION_DNS_PORT, address=str(self.addr.host), server=SCIONDnsTcpServer, logger=SCIONDnsLogger()) self.name_addrs = "\0".join([self.id, str(SCION_DNS_PORT), str(self.addr.host)]) self.zk = Zookeeper(self.topology.isd_as, DNS_SERVICE, self.name_addrs, self.topology.zookeepers) self._parties = {} self._setup_parties() def _setup_parties(self): """ Join all the necessary ZK parties. """ logging.debug("Joining parties") for type_ in self.SRV_TYPES: prefix = "/%s/%s" % (self.addr.isd_as, type_) autojoin = False # Join only the DNS service party, for the rest we just want to # setup the party so we can monitor the members. if type_ == DNS_SERVICE: autojoin = True self._parties[type_] = self.zk.retry( "Joining %s party" % type_, self.zk.party_setup, prefix=prefix, autojoin=autojoin) def _sync_zk_state(self): """ Update shared instance data from ZK. """ # Clear existing state self.services = {} try: self.zk.wait_connected(timeout=10.0) except ZkNoConnection: logging.warning("No connection to Zookeeper, can't update services") return # Retrieve alive instance details from ZK for each service. for srv_type in self.SRV_TYPES: srv_domain = self.domain.add(srv_type) self.services[srv_domain] = [] party = self._parties[srv_type] try: srvs = party.list() except ZkNoConnection: # If the connection drops, don't update return for i in srvs: self._parse_srv_inst(i, srv_domain) # Update DNS zone data with self.lock: self.resolver.services = self.services def _parse_srv_inst(self, inst, srv_domain): """ Parse a server instance block into name/port/addresses, and add them to the services list. :param str inst: Server instance block (null-seperated strings) :param dnslib.DNSLabel srv_domain: service domain """ name, port, *addresses = inst.split("\0") self.services[srv_domain].extend(addresses) def handle_request(self, packet, sender, from_local_socket=True): raise NotImplementedError def run(self): """ Run SCION Dns server. """ self._sync_zk_state() self.udp_server.start_thread() self.tcp_server.start_thread() while self.udp_server.isAlive() and self.tcp_server.isAlive(): self._sync_zk_state() sleep(self.SYNC_TIME)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--ip", "--host", dest="host", required=True, help="Required: Specify host (cluster) for file lists") parser.add_argument("-P", "--port", type=int, dest="port", default=8000, required=False, help="specify port on cluster; defaults to 8000") parser.add_argument( "-u", "--user", default="admin", dest="user", required=False, help="specify user credentials for login; defaults to admin") parser.add_argument("-p", "--pass", default="admin", dest="passwd", required=False, help="specify user pwd for login, defaults to admin") parser.add_argument("-v", "--verbose", default=False, required=False, dest="verbose", help="Echo values to console; defaults to False ", action="store_true") parser.add_argument( "--log", default="request,reply,truncated,error", help= "Log hooks to enable (default: +request,+reply,+truncated,+error,-recv,-send,-data)" ) parser.add_argument( "--log-prefix", action='store_true', default=False, help="Log prefix (timestamp/handler/resolver) (default: False)") parser.add_argument("--dnsname", required=True, dest="dnsname", nargs='+', help="The hostname you wish to respond to.") parser.add_argument( "--vlan-id", type=int, default=0, dest="vlan_id", help="VLAN ID of desired cluster network, defaults to 0 (untagged)") parser.add_argument("--dnsport", type=int, default=53, dest="dnsport", help="Server port (default:53)") parser.add_argument("--address", "-a", default="", dest="address", help="Listen address (default:all)") args = parser.parse_args() resolver = ConnectionCountResolver(args) logger = DNSLogger(args.log, args.log_prefix) udp_server = DNSServer(resolver, port=args.dnsport, address=args.address, logger=logger) udp_server.start_thread() while udp_server.isAlive(): time.sleep(1)
answer.set_rname(self.answer) reply = request.reply() reply.add_answer(answer) # print(reply) # print('-' * 200) return reply else: return ProxyResolver.resolve(self, request, handler) if __name__ == '__main__': import time conf_file = open('config.json') conf = json.load(conf_file) conf_file.close() resolver = SubProxy(address=conf['upper_dns'], port=conf['port'], timeout=conf['socket_timeout'], b_list=conf['blacklist'], answer=conf['answer'], host=conf['host']) server = DNSServer(resolver, port=conf['port'], address=conf['host']) server.start_thread() while server.isAlive(): time.sleep(1)
p.add_argument("--output", "-o",required=False, default="creds.txt", help="Filename to output credentials to (default: creds.txt)") p.add_argument("--key", "-k",required=True, default="key.pem", help="Path to the private key for decryption") args = p.parse_args() print('[+] dns.py Started: %s' % (time.ctime())) # Load private key print('[+] Loading private key...') with open(args.key, 'rb') as k: raw = k.read() try: key = RSA.import_key(raw) except: # Maybe with a passphrase? try: import getpass p = getpass.getpass() key = RSA.import_key(raw, passphrase=p.strip()) except Exception as e: print('[!] Could not read private key: ' + str(e)) sys.exit(1) resolver = ExfilResolver(args.ttl, args.output, key) # logger = DNSLogger("request,reply,truncated,error",False) logger = DNSLogger("error",False) udp_server = DNSServer(resolver, port=args.port, address=args.address, logger=logger) udp_server.start_thread() print('[+] DNS Server started') while udp_server.isAlive(): time.sleep(1)
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 main(): signal.signal(signal.SIGTERM, handle_sig) parser = argparse.ArgumentParser(description='LocalTLS') parser.add_argument('--domain', required=True, help="Your domain or subdomain.") parser.add_argument( '--soa-master', help="Primary master name server for SOA record. You should fill this." ) parser.add_argument( '--soa-email', help= "Email address for administrator for SOA record. You should fill this." ) parser.add_argument('--ns-servers', help="List of ns servers, separated by comma") parser.add_argument('--dns-port', default=53, help="DNS server port") parser.add_argument( '--domain-ipv4', default='', help="The IPV4 for the naked domain. If empty, use this machine's.") parser.add_argument( '--domain-ipv6', default='', help="The IPV6 for the naked domain. If empty, use this machine's.") parser.add_argument('--only-private-ips', action='store_true', default=False, help="Resolve only IPs in private ranges.") parser.add_argument('--no-reserved-ips', action='store_true', default=False, help="If true ignore ips that are reserved.") parser.add_argument('--dns-fallback', default='1.1.1.1', help="DNS fallback server. Default: 1.1.1.1") parser.add_argument( '--http-port', help="HTTP server port. If not set, no HTTP server is started") parser.add_argument('--http-index-file', default='index.html', help="HTTP index.html file.") parser.add_argument('--log-level', default='ERROR', help="INFO|WARNING|ERROR|DEBUG") args = parser.parse_args() # The primary addresses confs.LOCAL_IPV4 = args.domain_ipv4 if args.domain_ipv4 else get_ipv4() confs.LOCAL_IPV6 = args.domain_ipv6 if args.domain_ipv6 else get_ipv6() try: ipaddress.ip_address(confs.LOCAL_IPV4) except: logger.critical('Invalid IPV4 %s', LOCAL_IPV4) sys.exit(1) try: if confs.LOCAL_IPV6: ipaddress.ip_address(confs.LOCAL_IPV6) except: logger.critical('Invalid IPV6 %s', LOCAL_IPV6) sys.exit(1) logger.setLevel(args.log_level) confs.ONLY_PRIVATE_IPS = args.only_private_ips confs.NO_RESERVED_IPS = args.no_reserved_ips confs.BASE_DOMAIN = args.domain confs.SOA_MNAME = args.soa_master confs.SOA_RNAME = args.soa_email if not confs.SOA_MNAME or not confs.SOA_RNAME: logger.error('Setting SOA is strongly recommended') if args.ns_servers: confs.NS_SERVERS = args.ns_servers.split(',') # handle local messages to add TXT records threadMessage = threading.Thread(target=messageListener) threadMessage.start() # open the DNS server port = int(args.dns_port) upstream = args.dns_fallback resolver = Resolver(upstream) if args.log_level == 'debug': logmode = "+request,+reply,+truncated,+error" else: logmode = "-request,-reply,-truncated,+error" dnslogger = DNSLogger(log=logmode, prefix=False) udp_server = DNSServer(resolver, port=port, logger=dnslogger) tcp_server = DNSServer(resolver, port=port, tcp=True, logger=dnslogger) logger.critical( 'starting DNS server on %s/%s on port %d, upstream DNS server "%s"', confs.LOCAL_IPV4, confs.LOCAL_IPV6, port, upstream) udp_server.start_thread() tcp_server.start_thread() # open the HTTP server if args.http_port: logger.critical('Starting httpd...') threadHTTP = threading.Thread(target=httpserver.run, kwargs={ "port": int(args.http_port), "index": args.http_index_file }) threadHTTP.start() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass
# Parse results for A record (can be extended for other record types too) if status == getdns.RESPSTATUS_GOOD: for address in results.just_address_answers: if address['address_type'] == self.desired_addr_type: addr = address['address_data'] zone = "{name} {qtype} {addr}".format( name=name, qtype=request.q.qtype, addr=addr) reply.add_answer(RR(name, QTYPE.A, rdata=A(addr), ttl=60)) return reply if __name__ == '__main__': # Setup listening port and address # defaults to 53 and 0.0.0.0 port = int(os.getenv('DNS_PORT', 53)) address = os.getenv('DNS_LISTEN_ADDRESS', "") resolver = MyResolver() # Start TCP and UDP listeners udp_server = DNSServer(resolver, port=port, address=address) tcp_server = DNSServer(resolver, port=port, address=address, tcp=True) udp_server.start_thread() tcp_server.start_thread() while udp_server.isAlive() or tcp_server.isAlive(): sleep(1) udp_server.stop() tcp_server.stop()
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)
class FakeDNSServer: # pylint: disable=too-many-instance-attributes # pylint: disable=too-many-arguments def __init__(self, listen_addr=const.DEFAULT_LISTEN_ADDR, listen_port=const.DEFAULT_LISTEN_PORT, *, record_life=const.DEFAULT_CACHE_DURATION, subnet=const.DEFAULT_SUBNET, db_path=const.DEFAULT_DB_URI, remove_records=False, logger=None): self.logger = logger or DeliriumDNSLogger() self._addr = listen_addr self._port = listen_port self._resolver = DatabaseResolver(subnet, db_path=db_path, duration=record_life, remove=remove_records, logger=self.logger) self._dns_server = DNSServer(self._resolver, self._addr, self._port, logger=self.logger) @property def addr(self): return self._addr @property def port(self): return self._port @property def duration(self): return self._resolver.duration @duration.setter def duration(self, value): self.logger.debug('Setting cache duration to %s', value) self._resolver.duration = value @property def subnet(self): return self._resolver.subnet @subnet.setter def subnet(self, value): self.logger.debug('Setting cache subnet to %s', value) self._resolver.subnet = value def is_alive(self): return self._dns_server.isAlive() def start(self): self.logger.info('Starting Delirium DNS Server') self._dns_server.start() def start_thread(self): self._dns_server.start_thread() def stop(self): self.logger.info('Stopping Delerium DNS Server') self._resolver.close() self._dns_server.stop()
print(" NXDOMAIN:",", ".join(resolver.nxdomain)) if resolver.skip: print(" Skipping:",", ".join(resolver.skip)) print() DNSHandler.log = { 'log_request', # DNS Request 'log_reply', # DNS Response 'log_truncated', # Truncated 'log_error', # Decoding error } 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)