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")
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