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)
