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)
def start_server(resolver):
server = DNSServer(resolver=resolver, **config['server']['service'])
server.start()
