def __init__(self, handler, port=5454, address='0.0.0.0'):
self.handler = handler
self.udp_server = socketserver.UDPServer((address, port), DNSHandler)
self.udp_server.allow_reuse_address = True
self.udp_server.resolver = handler
self.udp_server.logger = DNSLogger(log='log_error',prefix=False)
self.tcp_server = socketserver.TCPServer((address, port), DNSHandler)
self.tcp_server.allow_reuse_address = True
self.tcp_server.resolver = handler
self.tcp_server.logger = DNSLogger(log='log_error',prefix=False)
self.udp_server_thread = Thread(
target=self.udp_server.serve_forever, kwargs={ 'poll_interval': 50000 }
)
self.udp_server_thread.daemon = True
self.tcp_server_thread = Thread(
target=self.tcp_server.serve_forever, kwargs={ 'poll_interval': 50000 }
)
self.tcp_server_thread.daemon = True
self.cleaner = Thread(target=handler.cleanup)
self.cleaner.daemon = True
def __init__(self,
resolver,
address="",
port=53,
tcp=False,
logger=None,
handler=DNSHandler,
server=None,
ipv6=False):
"""
resolver: resolver instance
address: listen address (default: "")
port: listen port (default: 53)
tcp: UDP (false) / TCP (true) (default: False)
logger: logger instance (default: DNSLogger)
handler: handler class (default: DNSHandler)
server: socketserver class (default: UDPServer/TCPServer)
"""
if not server:
if tcp:
server = TCPServer
else:
server = UDPServer
if ipv6:
server.address_family = socket.AF_INET6
self.server = server((address, port), handler)
self.server.resolver = resolver
self.server.logger = logger or DNSLogger()
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 start(self):
logger = DNSLogger(prefix=False)
udp_server = DNSServer(self,
port=10053,
address=self.address,
logger=logger)
udp_server.start_thread()
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()
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):
server = DNSServer(resolver=HTTPResolver(query=import_query(),
cache=SimpleCache()),
address=ConfigParse.listen,
port=ConfigParse.port,
logger=DNSLogger())
server.start_thread()
while self.running:
time.sleep(5)
server.stop()
def __init__(self, server_addresses):
self._servers = []
for sa in server_addresses:
self._servers.append(
DNSServer(
resolver=DcosDnsResolver(),
address=sa[0],
port=sa[1],
logger=DNSLogger("pass"), # Don't log anything to stdout
)
)
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 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 _get_default_servers(self):
address = settings.DNSKEY_DNS_SERVE_HOST
port = settings.DNSKEY_DNS_SERVE_PORT
resolver = DNSkeyResolver()
logger = DNSLogger(log="-send,-recv,-request,-reply,-truncated,-data")
servers = []
for server_cls in [DNSTCPServer, DNSUDPServer]:
server = server_cls((address, port), DNSHandler)
server.resolver = resolver
server.logger = logger
servers.append(server)
return servers
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 run_dns_proxy(self):
resolver = HTTPSResolver()
logger = DNSLogger()
server = DNSServer(resolver,
port=DNS_PORT,
address='localhost',
logger=logger)
server.start_thread()
while self.is_running:
# this just keeps the thing alive...
time.sleep(5)
server.stop()
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)
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 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 runDNSProxy(self):
resolver = CustomDNSResolver()
logger = DNSLogger()
server = DNSServer(resolver,
port=DNS_PORT,
address=DNS_SERVER_IPV4_ADDRESS,
logger=logger)
server.start_thread()
# Usage
self.printUsage()
while True:
inputOption = input("[Input Number] ").strip()
try:
inputOption = inputOption.strip().lower()
except ValueError:
inputOption = 0
if 'q' == inputOption:
break
elif '1' == inputOption:
resolver.enableCustomDNS(True)
print("Custom DNS Server turned on.")
elif '2' == inputOption:
resolver.enableCustomDNS(False)
print("Custom DNS Server turned off.")
elif 'p' == inputOption:
# Print Custom DNS Status
print(" Feature #1 - Custom DNS Server turned ", end='')
if resolver.isCustomDNSEnabled:
print("on.")
else:
print("off.")
print("")
else:
self.printUsage()
server.stop()
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)
import socket
import threading
from multiprocessing import cpu_count, Process
from dnslib.server import UDPServer, TCPServer, DNSLogger, DNSHandler
from django.conf import settings
from django.core.signals import request_started, request_finished
from domain.query import LocalQueryProxy
logger = DNSLogger(log="-send,-recv,-request,-reply,-truncated,-data")
class DNSUDPServer(UDPServer):
address_family = socket.AF_INET6
class DNSTCPServer(TCPServer):
address_family = socket.AF_INET6
class DNSkeyResolver(object):
def __init__(self):
self.query = LocalQueryProxy()
def resolve(self, request, handler):
try:
request_started.send(sender=__name__)
return self.query.query(request,
handler.request[1].getsockname()[0])
finally:
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)
import dnslib
from dnslib.server import DNSServer, DNSLogger
import binascii
from dnslib.dns import RR
'''
packet = binascii.unhexlify(b'd5ad818000010005000000000377777706676f6f676c6503636f6d0000010001c00c0005000100000005000803777777016cc010c02c0001000100000005000442f95b68c02c0001000100000005000442f95b63c02c0001000100000005000442f95b67c02c0001000100000005000442f95b93')
d = dnslib.DNSRecord.parse(packet)
# print(d)
d2 = dnslib.DNSRecord.question("google.com")
print(d2)
'''
class TestResolver:
def resolve(self,request,handler):
print(request)
reply=request.reply()
reply.add_answer(*RR.fromZone("abc.def. 6000 A 1.2.3.4"))
reply.add_answer(*RR.fromZone("blabla 6000 TXT 1.2.3.4"))
return reply
resolver = TestResolver()
logger = DNSLogger(prefix=False)
server = DNSServer(resolver, port=8053, address="localhost", logger=logger, tcp=False)
server.start_thread()
def __init__(self, wxDest):
DNSLogger.__init__(self, "request,reply,truncated,error", False)
self.wxDest = wxDest
def get_dns_logger(self, protocol):
if config.DEBUG and config.DEBUG_VERBOSITY > 7:
return DNSLogger()
else:
return DNSLogger(
"-recv,-send,-request,-reply,-truncated,-error,-data")
def __init__(self, wxDest):
DNSLogger.__init__(self, "request,reply,truncated,error", False)
self.wxDest = wxDest
ret = self.OPERATIONS[operation](api_key, data)
reply.add_answer(RR(qname, QTYPE.CNAME, ttl=0, rdata=CNAME(ret)))
return reply
if __name__ == '__main__':
logging.basicConfig(
format='[%(asctime)s][%(levelname)s] %(name)s: %(message)s',
datefmt='%Y.%m.%d %H:%M:%S',
level=logging.INFO)
logger.info('Started')
captcha_queue = Queue()
dns_resolver = CaptchaDNSResolver(D, NS_IP, NS_TTL, ALLOWED_API_KEYS,
captcha_queue)
udp_server = DNSServer(dns_resolver,
port=PORT,
address=ADDR,
logger=DNSLogger('-request,-reply'))
udp_server.start_thread()
while udp_server.isAlive():
try:
f = captcha_queue.get(True, 0.2)
except Empty:
pass
else:
f()
def __init__(self, container_map, domain_name):
resolver = ContainerResolver(container_map, domain_name)
self.server = dnslib.server.DNSServer(resolver=resolver,
logger=DNSLogger("pass"))
logging.info('Starting container DNS server')
parser.add_argument('--password', default=None, help="Only relevant when a username has been provided")
parser.add_argument('--dns-port', default=1053, type=int, help="dns port to listen on (default 1053)")
parser.add_argument('--dns-server', default="208.67.222.222:53", help="ip:port of the DNS server to forward all DNS requests to using TCP through the proxy (default 208.67.222.222:53)")
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":
"""Standalone DNS Authenticator."""
import logging
import copy
from dnslib import RR
from dnslib.server import DNSServer, DNSHandler, BaseResolver, DNSLogger
import zope.interface
from certbot import errors
from certbot import interfaces
from certbot.plugins import dns_common
logger = logging.getLogger(__name__)
dnsLogger = DNSLogger("truncated,error", False)
@zope.interface.implementer(interfaces.IAuthenticator)
@zope.interface.provider(interfaces.IPluginFactory)
class Authenticator(dns_common.DNSAuthenticator):
"""Standalone DNS Authenticator
This Authenticator uses a standalone DNS server to fulfill a dns-01 challenge.
"""
description = ('Obtain certificates using an integrated DNS server')
def __init__(self, *args, **kwargs):
super(Authenticator, self).__init__(*args, **kwargs)
self.resolver = None
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()
args.dns,_,args.dns_port = args.upstream.partition(':')
args.dns_port = int(args.dns_port or 53)
resolver = InterceptResolver(args.dns,
args.dns_port,
args.ttl,
args.intercept or [],
args.skip or [],
args.nxdomain or [])
logger = DNSLogger(args.log,args.log_prefix)
print("Starting Intercept Proxy (%s:%d -> %s:%d) [%s]" % (
args.address or "*",args.port,
args.dns,args.dns_port,
"UDP/TCP" if args.tcp else "UDP"))
for rr in resolver.zone:
print(" | ",rr[2].toZone(),sep="")
if resolver.nxdomain:
print(" NXDOMAIN:",", ".join(resolver.nxdomain))
if resolver.skip:
print(" Skipping:",", ".join(resolver.skip))
print()
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
