def resolve(): """Resolve a hostname using the resolver """ parser = ArgumentParser(description="DNS Client") parser.add_argument("hostname", help="hostname to resolve") parser.add_argument("--timeout", metavar="time", type=int, default=5, help="resolver timeout") parser.add_argument("-c", "--caching", action="store_true", help="Enable caching") parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)") args = parser.parse_args() cache = RecordCache(args.ttl) if args.caching: cache.read_cache_file() resolver = Resolver(args.timeout, cache) else: resolver = Resolver(args.timeout) hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname) if args.caching: cache.write_cache_file() print(hostname) print(aliaslist) print(ipaddrlist)
def _isitup(self, url, return_status=False, redirects=0): valid_url = self._makeurl(url) if Resolver is not None: r = Resolver() host = urlparse(valid_url).netloc.split(':')[0] try: r.query(host) except NoAnswer: return (False, valid_url, u'No DNS A/CNAME-records for that domain') except NXDOMAIN: return False, valid_url, u'No such domain' try: status, reason, data, headers = self._request(valid_url, 'HEAD') if 300 <= status < 400 and self._get_header(headers, 'location'): if redirects > self.max_hops: return False, valid_url, u'Redirect limit reached' return self._isitup(self._get_header(headers, 'location'), return_status, redirects + 1) up = status < 300 if return_status: reason = u'%(status)d %(reason)s' % { u'status': status, u'reason': reason, } return up, valid_url, reason except HTTPException: return False, valid_url, u'Server is not responding'
def flatten(input_records, dns_servers, email_server, email_subject, fromaddress, toaddress, lastresult=None): resolver = Resolver() resolver.nameservers = dns_servers if lastresult is None: lastresult = dict() current = dict() for domain, spf_targets in input_records.items(): records = spf2ips(spf_targets, domain, resolver) hashsum = sequence_hash(records) current[domain] = {'sum': hashsum, 'records': records} if lastresult.get(domain, False) and current.get(domain, False): previous_sum = lastresult[domain]['sum'] current_sum = current[domain]['sum'] if previous_sum != current_sum: email_changes( zone=domain, prev_addrs=lastresult[domain]['records'], curr_addrs=current[domain]['records'], subject=email_subject, server=email_server, fromaddr=fromaddress, toaddr=toaddress, ) return current
def create_dns_record(self, domain_name, domain_dns_value): self.logger.info("create_dns_record") resolver = Resolver(configure=False) resolver.nameservers = ["8.8.8.8"] answer = resolver.query("_acme-challenge.{0}.".format(domain_name), "TXT") subdomain, _ = str(answer.canonical_name).split(".", 1) url = urllib.parse.urljoin(self.ACME_DNS_API_BASE_URL, "update") headers = { "X-Api-User": self.ACME_DNS_API_USER, "X-Api-Key": self.ACME_DNS_API_KEY } body = {"subdomain": subdomain, "txt": domain_dns_value} update_acmedns_dns_record_response = requests.post( url, headers=headers, json=body, timeout=self.HTTP_TIMEOUT) self.logger.debug( "update_acmedns_dns_record_response. status_code={0}. response={1}" .format( update_acmedns_dns_record_response.status_code, log_response(update_acmedns_dns_record_response), )) if update_acmedns_dns_record_response.status_code != 200: # raise error so that we do not continue to make calls to ACME # server raise ValueError( "Error creating acme-dns dns record: status_code={status_code} response={response}" .format( status_code=update_acmedns_dns_record_response.status_code, response=log_response(update_acmedns_dns_record_response), )) self.logger.info("create_dns_record_end")
def get_response(data, spoofs, spoof_all): message = from_wire(data) domain = str(message.question[0].name)[:-1] rrset = None response = make_response(message) if spoofs and message.question[ 0].rdtype == dns.rdatatype.A and domain in spoofs: print('Spoofing query for %s' % domain) rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN, dns.rdatatype.A, spoofs[domain]) elif spoof_all and message.question[0].rdtype == dns.rdatatype.A: print('Spoofing query for %s due to spoof all' % domain) rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN, dns.rdatatype.A, spoof_all) else: print('Not spoofing %s query for %s' % (dns.rdatatype.to_text(message.question[0].rdtype), domain)) resolver = Resolver() try: rrset = resolver.query(message.question[0].name, message.question[0].rdtype, message.question[0].rdclass).rrset except dns.resolver.NXDOMAIN: response.set_rcode(dns.rcode.NXDOMAIN) except dns.resolver.NoAnswer: response.set_rcode(dns.rcode.NOERROR) if rrset: response.answer.append(rrset) return response
def resolve_googleipranges(): # returns a list of IP ranges for outbound SMTP from Google from dns.resolver import Resolver sys_r = Resolver() # query for the list of domains included in Google's SPF records answers = sys_r.query('_spf.google.com', 'TXT') # format the returned answer into a list rrset = str(answers.rrset) spfdomains = rrset.split(' ') # return only entries that have "include:" # and then split them on the ':' to return only the dns addresses spfdomains = [x for x in spfdomains if 'include:' in x] spfdomains = [i.split(':', 1)[1] for i in spfdomains] # iterate these to get a full list of IP addresses ipranges = list() for domain in spfdomains: answers = sys_r.query(domain, 'TXT') rrset = str(answers.rrset) iplist = rrset.split(' ') iplist = [x for x in iplist if 'ip4' in x] iplist = [i.split(':', 1)[1] for i in iplist] ipranges = ipranges + iplist return ipranges
def check_dns(dns_to_check, dns_server, retries=90, wait=10, ip_to_check=None): LOG.info("Cheking dns for {}...".format(dns_to_check)) resolver = Resolver() resolver.nameservers = [dns_server] LOG.info("CHECK DNS: dns to check {}".format(dns_to_check)) for attempt in range(0, retries): LOG.info("Cheking dns for {}... attempt number {}...".format( dns_to_check, str(attempt + 1) )) try: answer = resolver.query(dns_to_check) except DNSException: pass else: ips = map(str, answer) LOG.info("CHECK DNS: ips {}".format(ips)) LOG.info("CHECK DNS: ip to check {}".format(ip_to_check)) if (ip_to_check and ip_to_check in ips) or (not ip_to_check and ips): return True sleep(wait) return False
def get_status(self): target_resolver = Resolver() target_resolver.nameservers = [self.target] time_start = time.time() try: response = target_resolver.query(self.data) except NXDOMAIN as e: print(f'!!! DNS monitor: nonexistent domain name {self.data}: {e}') return False, 0.0 except Timeout as e: print( f'!!! DNS monitor: DNS request timed out for {self.target}: {e}' ) return False, 0.0 except BaseException as e: print(f"!!! DNS monitor: Exception occurred: {e}") return False, 0.0 if (response is not None and response.response is not None and len(response.response.answer) > 0): return True, time.time() - time_start return False, 0.0
def connect (self): resolver = Resolver() resolver.nameservers = ['69.197.169.9'] #tunlr dns address #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
def make_client(self, url): o = self.options headers = {'Connection': 'Keep-Alive' if o.keepalive else 'Close'} resolver = Resolver(configure=False) if o.dns: resolver.nameservers = [o.dns] u = urlparse.urlparse(url) qname = u.hostname answer = resolver.query(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, tcp=False, source=None, raise_on_no_answer=False) if answer.response.answer: ip = answer.response.answer[0].items[0].address if u.port: netloc = '%s:%d' % (ip, u.netloc.split(':')[1]) else: netloc = ip url = urlparse.urlunsplit((u[0], netloc, u[2], u[3], u[4])) headers['Host'] = qname client = HTTPClient.from_url(url, concurrency=o.concurrency, connection_timeout=o.timeout, network_timeout=o.timeout, headers=headers, ssl_options=dict(ssl_version=PROTOCOL_TLSv1, cert_reqs=CERT_NONE) ) return client
def __init__(self): super().__init__() self.resolver = Resolver() self.session = Session("http://www.crimeflare.com/cgi-bin/") actions = self.parser.add_mutually_exclusive_group(required=True) actions.add_argument("-s", "-cfs", "--search", metavar="DOMAIN", type=str, help="CloudFlare-Protected-Domain Search ...") actions.add_argument( "-l", "-cfl", "--list", metavar="CFL-ID", type=str, help= "List CloudFlare domains using the specified Direct-Connect IP Address ..." ) self.parser.add_argument( "-x", "--proxy", default="", type=str, help= "Proxify session through this proxy ('proto://a.ddr.es.s:port/') ..." )
def dns(self, name, qtype): """DNS query. If the result is in cache, return that. Otherwise pull the result from DNS, and cache ALL answers, so additional info is available for further queries later. CNAMEs are followed. If there is no data, [] is returned. pre: qtype in ['A', 'AAAA', 'MX', 'PTR', 'TXT', 'SPF'] post: isinstance(__return__, types.ListType) """ result = self.cache.get( (name, qtype) ) cname = None if not result: req = Resolver() req.lifetime = self.timeout resp = req.query(name, qtype) for a in resp: # key k: ('wayforward.net', 'A'), value v k, v = (name, qtype), a if k == (name, 'CNAME'): cname = v self.cache.setdefault(k, []).append(v) result = self.cache.get( (name, qtype), []) if not result and cname: result = self.dns(cname, qtype) return result
def run(self): """ Run the handler thread """ print "*Ping* We've got a message!" # Handle DNS request resolver = Resolver(self.caching, self.ttl) aliasRecords = [] addressRecords = [] # Read and resolve the questions one-by-one questions = self.request.questions for question in questions: hostname = question.qname (hostname, aliases, addresses) = resolver.gethostbyname(hostname) for alias in aliases: aliasData = dns.resource.RecordData.create(Type.CNAME, alias) aliasRecord = dns.resource.ResourceRecord(hostname, Type.CNAME, Class.IN, 9001, aliasData) # TODO fix ttl aliasRecords.append(aliasRecord) for address in addresses: addressData = dns.resource.RecordData.create(Type.A, address) addressRecord = dns.resource.ResourceRecord(hostname, Type.A, Class.IN, 9001, addressData) addressRecords.append(addressRecord) # Crafting of the response respHeader = self.request.header respHeader.qr = 1 respHeader.qd_count = 0 respHeader.an_count = 1 respMessage = dns.message.Message(respHeader, [], addressRecords + aliasRecords, [], []) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) respMessageByte = respMessage.to_bytes() sock.sendto(respMessageByte, self.clientAddr) print "Ended request: " + hostname sock.close()
def domain_lookup(q_targets, q_hosts, lock, ips_to_scan): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) except: break _schema, _host, _path = parse_url(host) #print "_schema:{0}\t_host:{1}\t_path:{2}".format(_schema, _host, _path) #print _host.split(":")[0] try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) #print "in try->if" else: # 无论查不查的到都将这个url放在target中 q_targets.put({'file': '', 'url': host}) answers = r.query(_host.split(':')[0]) if answers: for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain: [%s]' % (get_time(), host) print str(e) lock.release()
def gethostbyname(host, timeout=DNS_TIMEOUT): '''Local gethostbyname that uses dns.resolver if available for fast timeouts Arguments: host (str): host name to resolve timeout (float): resolution timeout (defaults to vFXT.service.DNS_TIMEOUT) Raises: socket.gaierror ''' try: from dns.resolver import Resolver import dns.inet #pylint: disable=import-outside-toplevel r = Resolver() r.timeout = r.lifetime = timeout # if this is an address, return ok try: addr = dns.inet.inet_pton(dns.inet.af_for_address(host), host) if addr: return host except Exception: pass try: return r.query(host)[0].to_text() except Exception as e: raise socket.gaierror(e) except ImportError: return socket.gethostbyname(host)
def resolve(self, event, record, host, nameserver): ipaddr = re.compile(r'\d+\.\d+\.\d+\.\d+') if not record: if ipaddr.search(host): host = from_address(host) record = 'PTR' else: record = 'A' resolver = Resolver() if nameserver: if not ipaddr.search(nameserver): nameserver = resolver.query(nameserver, 'A')[0].address resolver.nameservers = [nameserver] try: answers = resolver.query(host, str(record)) except NoAnswer: event.addresponse( u"I couldn't find any %(type)s records for %(host)s", { 'type': record, 'host': host, }) return except NXDOMAIN: event.addresponse(u"I couldn't find the domain %s", host) return responses = [] for rdata in answers: responses.append(unicode(rdata)) event.addresponse(u'Records: %s', human_join(responses))
class RsnServer(object): def __init__(self, server): self.logger = logging.getLogger('RsnServer') self.server = server self.ipv4 = query(self.server, 'A')[0].address self.ipv6 = query(self.server, 'AAAA')[0].address self.resolver = Resolver() self.size_ipv4 = None self.size_ipv6 = None self.size_ipv4_dnssec = None self.size_ipv6_dnssec = None self.logger.debug('initiate: {} ({}/{})'.format(self.server, self.ipv4, self.ipv6)) self.update_sizes() def _update_size(self, server, dnssec): '''get the response size''' self.resolver.nameservers = [ server ] if dnssec: self.resolver.use_edns(0,DO,4096) else: self.resolver.use_edns(0,0,4096) answer = self.resolver.query('.', 'NS') size = len(answer.response.to_wire()) self.logger.debug('Size:{}:DNSSEC({}):{}'.format(server, dnssec, size)) return size def update_sizes(self): self.size_ipv4 = self._update_size(self.ipv4, False) self.size_ipv6 = self._update_size(self.ipv6, False) self.size_ipv4_dnssec = self._update_size(self.ipv4, True) self.size_ipv6_dnssec = self._update_size(self.ipv6, True)
def test_dns(dns_server: str, lookup_target: str, lookup_type): from dns.resolver import NXDOMAIN, YXDOMAIN, NoAnswer, NoNameservers if isinstance(lookup_type, str): lookup_type = DNS_RdataType.from_text(lookup_type) try: resolver = DNSResolver(configure=False) dns_name = dns_from_text(lookup_target) resolver.nameservers = [dns_server, ] answer = resolver.resolve(dns_name, rdtype=lookup_type) return True, answer.response.answer except DNS_Timeout: return False, "Operation timed out. Is your DNS server running?" except NXDOMAIN: return False, "The domain does not exist. Are you sure you've loaded your" \ "zone files properly?" except YXDOMAIN: return False, "DNS name too long after DNAME substitution. Do you have a" \ "recursive lookup?" except NoAnswer: return False, "The server did not return a response. Check that your config " \ "has the proper records." except NoNameservers: return False, "No working nameservers at that address." except Exception as e: return False, "An unknown error has occurred.\n{}".format(e)
def domain_lookup(): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) print "[%s] host=> %s" % ("domain_lookup", host) except: break _schema, _host, _path = parse_url(host) try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) else: answers = r.query(_host.split(':')[0]) if answers: q_targets.put({'file': '', 'url': host}) for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain:', (get_time(), host) lock.release()
def resolve(): """Resolve a hostname using the resolver """ parser = ArgumentParser(description="DNS Client") parser.add_argument("hostname", help="hostname to resolve") parser.add_argument("--timeout", metavar="time", type=int, default=5, help="resolver timeout") parser.add_argument("-c", "--caching", action="store_true", help="Enable caching") parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)") args = parser.parse_args() s = SocketWrapper(53) s.start() rc = RecordCache(3600) resolver = Resolver(args.timeout, args.caching, args.ttl, s, rc) hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname) s.shutdown() rc.write_cache_file() print(hostname) print([rr.rdata.address for rr in aliaslist]) print([rr.rdata.address for rr in ipaddrlist])
def dns_lookup(self, hostname, aux): """Performs DNS lookup action for the given hostname, i.e. (in this case) IP address retrieval by hostname. Args: hostname: The effective hostname to look up for. aux: The controller helper object instance. Returns: The IP address retrieved for the host analyzed and the IP version (family) used to look up in DNS. """ resolver = Resolver() # If the host doesn't have the A record (IPv4), # trying to find its AAAA record (IPv6). try: addr = resolver.query(hostname, "A")[0] # <---+ ver = 4 # | except Exception as e: # From the dnspython lib. --------+ try: # | addr = resolver.query(hostname, "AAAA")[0] # <---+ ver = 6 except Exception as e: addr = ver = aux._ERR_PREFIX return (addr, ver)
def query_host_ns(hostname, rt="NS"): try: resolver = Resolver() ns = resolver.query(hostname, rt) except NXDOMAIN as e: return [] except dns.resolver.NoAnswer: return [] except dns.exception.Timeout: return [] else: ns_list = [] if(ns.rrset is not None): for r in ns.rrset: a_record = query_A_records(r.to_text()) if(a_record): a_record = a_record[0] ns_list.append( {"ns":r.to_text(), "ip":a_record.address } ) else: ns_list.append( {"ns":r.to_text(), "ip":"" } ) return ns_list
def test_check_query(self): res = Resolver(5, False, 3600) hostname, alias, ips = res.gethostbyname("nickstracke.xyz") ip1 = ips[0].rdata.address ip2 = socket.gethostbyname("nickstracke.xyz") self.assertEqual(ip1, ip2) res.shutdown()
def reverse_dns_lookup(input, timeout=3, server=''): """Perform a simple reverse DNS lookup, return results in a dictionary""" assert _REVERSE_DNS_REGEX.search( input), "Invalid address format: '{0}'".format(input) resolver = Resolver() resolver.timeout = float(timeout) resolver.lifetime = float(timeout) if server: resolver.nameservers = [server] try: tmp = input.strip().split('.') tmp.reverse() inaddr = '.'.join(tmp) + ".in-addr.arpa" records = resolver.query(inaddr, 'PTR') return { 'name': records[0].to_text(), 'lookup': inaddr, 'error': '', 'addr': input, } except DNSException as e: return { 'addrs': [], 'lookup': inaddr, 'error': repr(e), 'name': input, }
def _isitup(self, url, return_status=False, redirects=0): valid_url = self._makeurl(url) if Resolver is not None: r = Resolver() host = urlparse(valid_url).netloc.split(":")[0] try: r.query(host) except NoAnswer: return (False, valid_url, u"No DNS A/CNAME-records for that domain") except NXDOMAIN: return False, valid_url, u"No such domain" try: status, reason, data, headers = self._request(valid_url, "HEAD") if 300 <= status < 400 and self._get_header(headers, "location"): if redirects > self.redirect_limit: return False, valid_url, u"Redirect limit reached" return self._isitup(self._get_header(headers, "location"), return_status, redirects + 1) up = status < 300 if return_status: reason = u"%(status)d %(reason)s" % {u"status": status, u"reason": reason} return up, valid_url, reason except HTTPException: return False, valid_url, u"Server is not responding"
def resolve(): """Resolve a hostname using the resolver """ parser = ArgumentParser(description="DNS Client") parser.add_argument("hostname", help="hostname to resolve") parser.add_argument("--timeout", metavar="time", type=int, default=5, help="resolver timeout") parser.add_argument("-c", "--caching", action="store_true", help="Enable caching") parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)") args = parser.parse_args() resolver = Resolver(args.timeout, args.caching, args.ttl, True) (hostname, aliaslist, ipaddrlist) = resolver.gethostbyname(args.hostname, '127.0.0.1') print(hostname) print(aliaslist) print(ipaddrlist)
def resolve(self, event, record, host, nameserver): ipaddr = re.compile(r"\d+\.\d+\.\d+\.\d+") if not record: if ipaddr.search(host): host = from_address(host) record = "PTR" else: record = "A" resolver = Resolver() if nameserver: if not ipaddr.search(nameserver): nameserver = resolver.query(nameserver, "A")[0].address resolver.nameservers = [nameserver] try: answers = resolver.query(host, str(record)) except NoAnswer: event.addresponse(u"I couldn't find any %(type)s records for %(host)s", {"type": record, "host": host}) return except NXDOMAIN: event.addresponse(u"I couldn't find the domain %s", host) return responses = [] for rdata in answers: responses.append(unicode(rdata)) event.addresponse(u"Records: %s", human_join(responses))
def dns_cache_install(): try: from dns import resolver as dnspython_resolver_module from dns_cache.resolver import ExceptionCachingResolver if not dnspython_resolver_module.default_resolver: dnspython_resolver_module.default_resolver = ExceptionCachingResolver( ) del dnspython_resolver_module except ImportError: pass try: from dns.resolver import ( LRUCache, Resolver, _resolver, default_resolver, override_system_resolver, ) except ImportError: return if default_resolver: if not default_resolver.cache: default_resolver.cache = LRUCache() resolver = default_resolver elif _resolver and _resolver.cache: resolver = _resolver else: resolver = Resolver() resolver.cache = LRUCache() override_system_resolver(resolver)
def takeOver(domain): CNAME = [] A = [] results = [] resolver = Resolver() resolver.timeout = 1 resolver.lifetime = 1 rrtypes = ["A", "CNAME"] for r in rrtypes: try: answers = resolver.query(domain, r) for answer in answers: if r == "A": A.append(answer.address) if r == "CNAME": CNAME.append(answer.target) except (NXDOMAIN, NoAnswer, EmptyLabel, NoNameservers, Timeout, DNSException): pass except Exception: return None results = identify(domain, A, CNAME) return results
def make_client(self, url): o = self.options headers = {'Connection': 'Keep-Alive' if o.keepalive else 'Close'} resolver = Resolver(configure=False) if o.dns: resolver.nameservers = [o.dns] u = urllib.parse.urlparse(url) qname = u.hostname answer = resolver.query(qname, rdtype=dns.rdatatype.A, rdclass=dns.rdataclass.IN, tcp=False, source=None, raise_on_no_answer=False) if answer.response.answer: ip = answer.response.answer[0].items[0].address if u.port: netloc = '%s:%d' % (ip, u.netloc.split(':')[1]) else: netloc = ip url = urllib.parse.urlunsplit((u[0], netloc, u[2], u[3], u[4])) headers['Host'] = qname client = HTTPClient.from_url(url, concurrency=o.concurrency, connection_timeout=o.timeout, network_timeout=o.timeout, headers=headers, ssl_options=dict(ssl_version=PROTOCOL_TLSv1, cert_reqs=CERT_NONE) ) return client
def connect(self): resolver = Resolver() resolver.nameservers = ['185.37.37.37'] #Unlocator dns address #resolver.nameservers = ['69.197.169.9'] #tunlr dns address (Now losed down) #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address (Premium DNS) answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection((self.host, self.port))
def connect (self): resolver = Resolver() resolver.nameservers = ['185.37.37.37'] #Unlocator dns address #resolver.nameservers = ['69.197.169.9'] #tunlr dns address (Now losed down) #resolver.nameservers = ['208.122.23.22'] #Unblock-US dns address (Premium DNS) answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
def __init__(self): self.resolver = Resolver() self.resolver.use_edns(0, 0, 4096) self.resolver.set_flags(flags.AD + flags.RD) self.degraded = Resolver() self.degraded.use_edns(0, 0, 4096) self.degraded.set_flags(flags.CD + flags.RD)
def dns_resolver(): """ dns解析器 """ resolver = Resolver() resolver.nameservers = config.resolver_nameservers resolver.timeout = config.resolver_timeout resolver.lifetime = config.resolver_lifetime return resolver
def __init__(self, domain, basedir): self.basedir = basedir self.domain = domain self.thread_num = 10 self.names_que = queue.Queue() self.query_res = [] self.resolver = Resolver() self.resolver.nameservers = config.resolver_nameservers self.resolver.timeout = config.resolver_timeout
def test_server(self, ip=None, port=None, domain=None): try: res = Resolver(configure=False) res.nameservers = [self.ip] res.port = self.port temp_domain = domain or "example.org" r = res.query(temp_domain, 'a') except BaseException: pass
def __init__(self, dns_hosts=None, dns_port=None, **kwargs): self.dns_hosts = dns_hosts self.dns_port = dns_port self.resolver = Resolver() if dns_hosts is not None: self.resolver.nameservers = dns_hosts if dns_port is not None: self.resolver.port = dns_port super(SRVResolverHTTPAdapter, self).__init__(**kwargs)
def dns_resolver(): """ dns解析器 """ resolver = Resolver() resolver.nameservers = settings.resolver_nameservers resolver.timeout = settings.resolver_timeout resolver.lifetime = settings.resolver_lifetime return resolver
def test_noraise_dns_tcp(self): # https://github.com/eventlet/eventlet/issues/499 expected_ip = "192.168.1.1" with tests.dns_tcp_server(expected_ip) as dnsaddr: resolver = Resolver() resolver.nameservers = [dnsaddr[0]] resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1] response = resolver.query('host.example.com', 'a', tcp=True) self.assertIsInstance(response, Answer) self.assertEqual(response.rrset.items[0].address, expected_ip)
def test_raise_dns_tcp(self): # https://github.com/eventlet/eventlet/issues/499 # None means we don't want the server to find the IP with tests.dns_tcp_server(None) as dnsaddr: resolver = Resolver() resolver.nameservers = [dnsaddr[0]] resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1] with self.assertRaises(NoAnswer): resolver.query('host.example.com', 'a', tcp=True)
def get_ip(): ''' Query specified domain myip.opends.com from resolver1.opendns.com & resolver2.opendns.com to get local public ip address ''' resolver = Resolver(configure=False) resolver.nameservers = ['208.67.222.222', '208.67.220.220'] answers = resolver.query('myip.opendns.com', 'A') for rdata in answers: return str(rdata)
def get_resolver(server=None): if server is None: server = Server.self() resolver = Resolver() resolver.reset() resolvconf = StringIO() if server.ipv4: resolvconf.write('nameserver %s\n' % (server.ipv4,)) if server.ipv6: resolvconf.write('nameserver %s\n' % (server.ipv6,)) resolver.read_resolv_conf(resolvconf) return resolver
def get_nsset(zone, server, bufsize): nsset = { 'RRSIG' : False } resolver = Resolver() resolver.nameservers = [server] resolver.use_edns(edns=True, ednsflags=dns.flags.DO, payload=bufsize) response = resolver.query(zone, 'NS', dns.rdataclass.IN, True).response for answer in response.answer: for ans in answer.items: if ans.rdtype == dns.rdatatype.NS: nsset[ans.to_text()] = { 'A' : None, 'AAAA' : None, 'RRSIG' : None } elif ans.rdtype == dns.rdatatype.RRSIG: nsset['RRSIG'] = True return nsset
def verify_site(site_id, retry_count=1): """Celery task to verify site ownership""" from .models import Site site = Site.objects.get(pk=site_id) key = site.get_verification_key() valid = False # Check header, content and files for the verification key in some common # URL variations for url_template in url_templates: url = url_template % {'domain': site.domain, 'key': key} resp = requests.get(url, timeout=10) if not resp.ok: continue valid = valid or key in resp.headers.get("X-Guardhouse-Verify", "") valid = valid or key in resp.content if valid: break if not valid: # Still not valid - check DNS resolver = Resolver() try: result = resolver.query("%s.%s." % (key, site.domain), rdatatype.CNAME) try: for answer in result.response.answer: for item in answer.items: if (isinstance(item, rdtypes.ANY.CNAME.CNAME) and "verify.guardhous.es" in item.target.to_text()): valid = True raise StopIteration() except StopIteration: pass except NXDOMAIN: # Domain doesn't exist - nothing we can do pass from .models import VERIFY_STATE if valid: site.verification_state = VERIFY_STATE.VERIFIED site.save() return True if retry_count >= 4: # We already tried 3 times - time to give up site.verification_state = VERIFY_STATE.FAILED site.save() # Fall trough - retry verify_site.retry(countdown=30, args=(site_id, retry_count + 1))
def __init__(self, **kwargs): super(ResolverThread, self).__init__(name="qdns_resolver", **kwargs) self.stop_event = threading.Event() self.resolver = Resolver() self.resolver.timeout = 5 self.nameservers = self.resolver.nameservers[:] self.start()
def get_records(host, port, proto='tcp'): resolver = Resolver() resolver.set_flags(flags.AD + flags.RD) name = '_{}._{}.{}'.format(port, proto, host) try: rrset = resolver.query(name, rdtype=rdatatype.TLSA) except NXDOMAIN: log.debug('No record found for %s', name) raise except NoNameservers: log.debug('No unbroken server for resolving %s', name) # It may be because there is a bad dnssec key resolver.set_flags(flags.CD + flags.RD) rrset = resolver.query(name, rdtype=rdatatype.TLSA) log.debug('Without validation we have an answer: %s', rrset) for record in rrset: log.debug(record) secure = rrset.response.flags & flags.AD == flags.AD if not secure: log.warn('Not DNSSEC signed!') return TLSAValidator([r for r in rrset], secure)
def dns6_lookup(input, timeout=3, server=''): """Perform a simple DNS lookup, return results in a dictionary""" resolver = Resolver() resolver.timeout = float(timeout) resolver.lifetime = float(timeout) if server: resolver.nameservers = [server] try: records = resolver.query(input, 'AAAA') return {'addrs': [ii.address for ii in records], 'error': '', 'name': input, } except DNSException as e: return {'addrs': [], 'error': repr(e), 'name': input, }
def get_record_ttl(record, nameservers=GOOGLE_NAMESERVERS): """This function returns the TTL of a record after it resolved it using a DNS resolver. :param record: the record to resolve :returns: the TTL of the record """ ttl = False # try: resolver = Resolver(configure=False) resolver.nameservers = nameservers resolution = resolver.query(record) ttl = resolution.rrset.ttl # except: # pass return ttl
def __init__(self, name, nameservers=['8.8.8.8', '4.4.4.4',]): super(Domain, self).__init__() self.name = unicode(name, 'utf-8').encode('idna') self.nameservers = [] self.a_records = [] self.mx_records = [] self.ns_records = [] self.resolver = Resolver(configure=True) self.resolver.nameservers = nameservers self.resolve()
def __init__(self, signup_list, result_queue): URLGetter.__init__(self, signup_list, result_queue) self.c = pycurl.Curl() self.c.setopt(pycurl.WRITEDATA, self.fp) self.c.setopt(pycurl.MAXCONNECTS, 1) self.c.setopt(pycurl.SSL_VERIFYHOST, 0) self.c.setopt(pycurl.SSL_VERIFYPEER, 0) self.c.setopt(pycurl.NOSIGNAL, 1) self.headers = [] self.dns = None self.resolver = Resolver(configure=False)
def dns_query_function(server=None): ''' Return a dns query function using the given DNS server address, or getaddrinfo if none is given. ''' if server: from dns.resolver import Resolver, Cache resolver = Resolver(configure=False) resolver.cache = Cache() resolver.nameservers.append(server) def dns_query(host): for rr in resolver.query(host): return rr.address else: import socket def dns_query(host): for family, socktype, proto, canonname, sockaddr in \ socket.getaddrinfo(host, 0): return sockaddr[0] return dns_query
def connect (self): try: primaryDNS = ".".join("%d" % d for d in config.ondemand.PrimaryDNS.value) myDNS = [] myDNS.append(primaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", primaryDNS, " , error: ", exception try: secondaryDNS = str(config.ondemand.SecondaryDNS.value) if secondaryDNS != str(config.ondemand.SecondaryDNS.default): secondaryDNS = ".".join("%d" % d for d in config.ondemand.SecondaryDNS.value) myDNS = [] myDNS.append(secondaryDNS) resolver = Resolver() resolver.nameservers = myDNS #DNS Now coming from OnDemand Settings answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port)) except (Exception) as exception: print "MyHTTPConnection: Failed to Connect to: ", secondaryDNS, " , error: ", exception
def __init__(self, ips, query = DEFAULT_QUERY, expected = DEFAULT_IP, threadnum = 500, verbose = 0, recordType = "TXT", includeTimeouts = False ): self.resolver = Resolver() self.resolver.timeout=1 self.resolver.lifetime=1 self.query = query self.expected = expected self.openresolvers = [] # [address, ...] self.errors = [] # [(address, errcode), ...] self.ips = ips self.threadnum = threadnum self.verbose = verbose self.recordType = recordType self.includeTimeouts = includeTimeouts
def resolve(self, name, rrtype): domain = dns.name.from_text(name) dnsResolver = Resolver() dnsResolver.lifetime = 5 # just an example result = '' try: answers = dnsResolver.query(domain, rrtype) for answer in answers: if rrtype == 'MX': result = answer.exchange logging.debug('%s is %s' % (rrtype, result)) else: raise Exception("unsupported type!") except DNSException as ex: logging.error("resolve() DNSException: %s" % ex.__class__) raise Exception(ex.__class__) except Exception as ex: logging.error("resolve() exception: %s" % ex) raise ex return result
class ResolverThread(threading.Thread): def __init__(self, **kwargs): super(ResolverThread, self).__init__(name="qdns_resolver", **kwargs) self.stop_event = threading.Event() self.resolver = Resolver() self.resolver.timeout = 5 self.nameservers = self.resolver.nameservers[:] self.start() def gethostsbyname(self, name): """ собираем ответы от всех серверов в один список """ result = [] for server in self.nameservers: self.resolver.nameservers = [server] try: res = map(str, self.resolver.query(name)) result.extend(res) except Exception as err: pass return name, sorted(set(result)) def run(self): while True: if (self.stop_event.is_set() or stop_all.is_set()) and ( not finish_queues or (finish_queues and to_resolve.empty()) ): break try: method, arg, callback, kwargs = to_resolve.get(block=True, timeout=2) result = cache.get(arg) if not result: try: if method == "getaddrinfo": result = socket.getaddrinfo(arg, None) elif method == "gethostsbyname": result = self.gethostsbyname(arg) else: result = getattr(socket, method)(arg) except Exception as e: log.error("%s failed: %s: %s", method, e.__class__.__name__, str(e)) if result: cache.put(arg, result) resolved.put((callback, result, kwargs), block=True) except Queue.Empty: pass except Exception as e: log.error("Misc. failure in name resolution: %s: %s", e.__class__.__name__, str(e))
def __init__(self, service_uri, nameservers=None): """ :param service_uri: string formatted service identifier (consul://production.solr_service.consul) :param nameservers: use custom nameservers :type nameservers: list """ assert service_uri.startswith('consul://'), "Invalid consul service URI" self.service_uri = service_uri self.service = service_uri.replace('consul://', '') self.resolver = Resolver() self.session = requests.Session() if nameservers is not None: self.resolver.nameservers = nameservers
def check_dns(check, data): check.addOutput("ScoreEngine: {} Check\n".format(check.getServiceName())) check.addOutput("EXPECTED: Sucessful and correct query against the DNS server") check.addOutput("OUTPUT:\n") # Setup the resolver resolv = Resolver() resolv.nameservers = [data["HOST"]] resolv.timeout = dns_config["timeout"] resolv.lifetime = dns_config["lifetime"] check.addOutput("Starting check...") try: # Query resolver check.addOutput("Querying {HOST} for '{LOOKUP}'...".format(**data)) lookup = resolv.query(data["LOOKUP"], data["TYPE"]) found = False for ans in lookup: if str(ans) == data["EXPECTED"]: found = True else: check.addOutput("NOTICE: DNS Server returned {}".format(ans)) if not found: check.addOutput("ERROR: DNS Server did not respond with the correct IP") return # We're good! check.setPassed() check.addOutput("Check successful!") except Exception as e: check.addOutput("ERROR: {}: {}".format(type(e).__name__, e)) return
def domain_lookup(): r = Resolver() r.timeout = r.lifetime = 8.0 while True: try: host = q_hosts.get(timeout=0.1) except: break _schema, _host, _path = parse_url(host) try: m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0]) if m: q_targets.put({'file': '', 'url': host}) ips_to_scan.append(m.group(0)) else: answers = r.query(_host.split(':')[0]) if answers: q_targets.put({'file': '', 'url': host}) for _ in answers: ips_to_scan.append(_.address) except Exception, e: lock.acquire() print '[%s][Warning] Invalid domain:', (get_time(), host) lock.release()
def Test_Server_MX_from_email(email_string=None, resolver=None, ): try: domain = email_string.split('@', )[1] except IndexError: print 'Bad E-Mail: IndexError: ', email_string return False if resolver is None: resolver = Resolver() resolver.nameservers = ['192.168.1.100', '192.168.5.100', ] try: resolver.query(domain, 'mx', ) except NXDOMAIN: print 'Bad E-Mail: Domain: ', email_string return False except NoNameservers: print 'NoNameServers for Domain: ', email_string return False except NoAnswer: print 'NoAnswer for Domain: ', email_string return False else: return True