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()
def run(self, bindAddr, blocking): server = DNSServer(self.resolver, port=53, address=bindAddr, logger=self.logger) if blocking: server.start() else: server.start_thread()
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()
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 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()
def main(): try: resolver = ZoneResolver(ZONE, True) logger = RedisLogger() _dns_logger.info(ZONE) _dns_logger.info("Starting Dns Server (*:53) [UDP]") dns_server = DNSServer(resolver, port=53, address='', logger=logger) dns_server.start() except KeyboardInterrupt: _dns_logger.info("Shutting Down Dns Server (*:53) [UDP]") dns_server.stop()
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 use_dnslog(): global DNS_DOMAIN, NS2_DOMAIN, NS1_DOMAIN, SERVER_IP ZoneResolver = zoneresolver.ZoneResolver #下面的zone的几行不能缩进 zone = ''' *.{dnsdomain}. IN NS {ns1domain}. *.{dnsdomain}. IN NS {ns2domain}. *.{dnsdomain}. IN A {serverip} {dnsdomain}. IN A {serverip} '''.format(dnsdomain=DNS_DOMAIN, ns1domain=NS1_DOMAIN, ns2domain=NS2_DOMAIN, serverip=SERVER_IP) resolver = ZoneResolver(zone, True) logger = Logger() print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP")) udp_server = DNSServer(resolver, port=53, address='', logger=logger) udp_server.start()
def handle(self, *args, **options): 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, ) print("Starting Zone Resolver (%s:%d) [%s]" % ("*", 53, "UDP")) udp_server = DNSServer(ZoneResolver(zone, True), port=53, address="", logger=DjangoDNSLogger()) udp_server.start()
def main(): """ 主函数 :return: """ zone = f"*.{DOMAIN}. IN A {NS_SERVER}" resolver = ZoneResolver(zone, True) dns_logger = MyLogger() logger.info("启动域名解析 %s:%d" % ("0.0.0.0", 53)) udp_server = DNSServer(resolver, port=53, address="0.0.0.0", logger=dns_logger) try: udp_server.start() except KeyboardInterrupt: logger.info("正在关闭域名解析……") udp_server.stop() logger.info("关闭域名解析完成")
def run_dns_server(dns_domain, dns_ip, outfile): """运行dns服务器, 监听53端口""" dnsdomain = dns_domain ns1domain = "ns1." + dnsdomain ns2domain = "ns2." + dnsdomain serverip = dns_ip zone = ''' *.{dnsdomain}. IN NS {ns1domain}. *.{dnsdomain}. IN NS {ns2domain}. *.{dnsdomain}. IN A {serverip} {dnsdomain}. IN A {serverip} '''.format(dnsdomain=dnsdomain, ns1domain=ns1domain, ns2domain=ns2domain, serverip=serverip) resolver = ZoneResolver(zone, True) logger = JsonLogger(dnsdomain, outfile) print("Starting Zone Resolver (%s:%d) [%s] Dns Domain: %s" % ("*", 53, "UDP", dnsdomain)) udp_server = DNSServer(resolver, port=53, address='', logger=logger) udp_server.start()
def main(): parser = ArgumentParser(description='Process detector by DNS usage.') parser.add_argument('-a', '--address', default='127.0.0.1', help='local proxy address, default 127.0.0.1') parser.add_argument('-p', '--port', type=int, default=53, help='local proxy port, default 53') parser.add_argument('-u', '--upstream', default='8.8.8.8:53', help='upstream DNS server, default 8.8.8.8:53') parser.add_argument('-t', '--pattern', metavar='GLOB', default=None, help='glob pattern of query to detect process name on ' 'match. By default, prints the process for each ' 'request.') args = parser.parse_args() DPDHandler.upstream_dns = args.upstream if args.pattern: DPDHandler.dns_pattern = DNSLabel(args.pattern) server = DNSServer( None, # здесь не нужен Resolver address=args.address, port=args.port, tcp=False, handler=DPDHandler) print('Start DNS server on %s:%d...' % (args.address, args.port)) server.start()
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()
class DnsServer(BaseServer): """ DNS服务器,用于部署外网环境,支持回显更多详细信息,需要配置域名,推荐使用,具体配置可以参考文档说明 使用如下: 默认情况下使用 config下的配置 >>> dns_server = DnsServer('0.0.0.0', 53) >>> dns_server.start() web后台重启: >>> dns_server = DnsServer('0.0.0.0', 53) >>> dns_server.set_fake_root_domain(fake_root_domain) >>> dns_server.set_ns1domain(ns1domain) >>> dns_server.set_ns2domain(ns2domain) >>> dns_server.set_serverip(serverip) >>> dns_server.start() """ def __init__(self, host, port=53): """ 开启DNS服务,默认端口是53,不要修改 :param host: :param port: """ super().__init__(host, port, self.__class__.__name__) self.init_zone() self.udp_server = None self.fake_root_domain = None self.ns1domain = None self.ns2domain = None self.serverip = None def set_fake_root_domain(self, fake_root_domain): self.fake_root_domain = fake_root_domain def set_ns1domain(self, ns1domain): self.ns1domain = ns1domain def set_ns2domain(self, ns2domain): self.ns2domain = ns2domain def set_serverip(self, serverip): self.serverip = serverip def init_zone(self): """ 初始化zone,从sqlite数据库中加载配置 :return: """ self.zone = ''' *.{fake_root_domain} IN NS {ns1domain} *.{fake_root_domain} IN NS {ns2domain} *.{fake_root_domain} IN A {serverip} {fake_root_domain} IN A {serverip} '''.format(fake_root_domain=config.FAKE_ROOT_DOMAIN, ns1domain=config.NS1_DOMAIN, ns2domain=config.NS2_DOMAIN, serverip=config.SERVER_IP) 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_engine(self): """ 启动引擎,包含具体逻辑 :return: """ if self.udp_server and isinstance(self.udp_server, DNSServer): self.udp_server.start() def close_server(self): """ 关闭UDP服务 :return: """ pass @staticmethod def restart_server(host, port, fake_root_domain, ns1domain, ns2domain, server_ip): """ 被子进程调用 :param host: :param port: :return: """ dns_server = DnsServer(host, int(port)) dns_server.set_fake_root_domain(fake_root_domain) dns_server.set_ns1domain(ns1domain) dns_server.set_ns2domain(ns2domain) dns_server.set_serverip(server_ip) dns_server.start() @staticmethod def kill_server(host, port): """ 被子进程调用 :param host: :param port: :return: """ DnsServer(host, int(port)).stop()
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()
TRANSFER_HOSTNAME = ".transfer.io" PORT = 8053 OUTPUT_DIRECTORY = "/data" class TransferResolver: def resolve(self, request, handler): qname = str(request.q.qname) reply = request.reply() if request.q.qtype != QTYPE.TXT: return reply if qname.endswith(f"{TRANSFER_HOSTNAME}."): encoded_filepath, encoded_chunk = qname.replace( f"{TRANSFER_HOSTNAME}.", "").split(".") decoded_filepath = base58.b58decode(encoded_filepath) print(f"received chunk for file: {decoded_filepath}") output_filepath = os.path.join(OUTPUT_DIRECTORY, encoded_filepath) with open(output_filepath, "ab") as f: decoded_chunk = base58.b58decode(encoded_chunk) f.write(decoded_chunk) reply.add_answer(*RR.fromZone(f"{qname} 1 TXT OK")) return reply if __name__ == "__main__": resolver = TransferResolver() logger = None server = DNSServer(resolver, logger=logger, address="0.0.0.0", port=PORT) print("starting DNS server!") server.start()
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()
response.rclass = CLASS.IN # These two lines can be deleted if we dont want the original response reply.add_answer(response) response = RR.fromZone(response.toZone())[0] if rewrite: response.rname = rewrite reply.add_answer(response) # print(reply) if success: break return reply class TimeoutException(Exception): pass if __name__ == '__main__': print("""Unicaster mDNS - Copyright © 2018 Santiago Saavedra This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under certain conditions; you can see the full license at https://www.gnu.org/licenses/gpl.html """.encode('utf-8')) resolver = Resolver() s = DNSServer(resolver, os.environ.get('DNS_HOST', ''), int(os.environ.get('DNS_PORT', 5053))) s.start()
def start_server(resolver): server = DNSServer(resolver=resolver, **config['server']['service']) server.start()
else: ip_data = contract.functions.resolveName( _subdomain=label).call() if not ip_data[2]: break ip = ip_data[0] if ip: try: ipaddress.ip_address(ip) except Exception as exc: print(repr(exc)) reply.header.rcode = RCODE.NXDOMAIN return reply print("Name {} found: ip is {}".format('.'.join(labels), ip)) reply.add_answer(RR(qname, QTYPE.AAAA, ttl=1, rdata=AAAA(ip))) mapping[labels_hash] = ip return reply else: proxy_r = request.send('8.8.8.8', 53) return DNSRecord.parse(proxy_r) ethresolver = MapResolver() if __name__ == '__main__': udp_server = DNSServer(ethresolver, port=5353, address='0.0.0.0') udp_server.start() while udp_server.isAlive(): time.sleep(1)