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 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 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 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 check_dns(check): # Setup the resolver resolver = Resolver() resolver.nameservers = [check.config['HOST']] resolver.timeout = dns_config['timeout'] resolver.lifetime = dns_config['lifetime'] # Query resolver check.add_output('Querying {HOST} for "{LOOKUP}"...', **check.config) lookup = resolver.query(check.config['LOOKUP'], check.config['TYPE']) found = False for ans in lookup: if str(ans) == check.config['EXPECTED']: found = True else: check.addOutput('NOTICE: DNS Server returned {}', ans) if not found: check.addOutput( 'ERROR: DNS Server did not respond with the correct IP') return False # We're good! return True
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 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 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 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 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 main(self, min_len=(1, ), max_len=(3, )): """ Main function """ try: min_len = int(min_len[0]) max_len = int(max_len[0]) except TypeError: self._write_result("Min and max length should be integer values.") return if min_len > max_len or min_len <= 0: self._write_result( "Min length should be greater than 0 and less or equal to max length." ) return if not self.host: return if self.host.startswith("www."): self.host = self.host[4:] # collect nameservers r = Resolver() r.lifetime = self.DNS_TIMEOUT name_servers = r.query(self.host, "NS") name_servers = map(lambda x: str(x), name_servers) ns_list = [] for name_server in name_servers: if name_server[-1] == ".": name_server = name_server[:-1] ns_list.append(gethostbyname(name_server)) r = Resolver() r.lifetime = self.DNS_TIMEOUT r.nameservers = ns_list results = set() for sub in self.generate_subdomains(min_len, max_len): domain = "%s.%s" % (sub, self.host) for record in ("A", "CNAME"): try: records = r.query(domain, record) if records: if sub not in results: results.add(sub) self._write_result(domain) break except Exception: pass
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 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 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 create_dns_record(self, domain_name, domain_dns_value): self.logger.info("create_dns_record") resolver = Resolver(configure=False) resolver.nameservers = ["172.31.31.31"] 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 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 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 = ['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 resolve_address(hostname, nameserver): if checkIfIpAddress(hostname): return hostname res = Resolver('', False) res.nameservers = [nameserver] result = res.query(hostname) # type: Answer for item in result.response.answer: if item.rdtype == 1: return item.items[0]
def run(self): while True: if self.queue.empty(): break #grabs host from queue hostname = self.queue.get() try: # Shake things up with some random DNS servers resolver = Resolver() dns = [ '209.244.0.3', '209.244.0.4', '64.6.64.6', '64.6.65.6', '8.8.8.8', '8.8.4.4', '84.200.69.80', '84.200.70.40', '8.26.56.26', '8.20.247.20', '208.67.222.222', '208.67.220.220', '199.85.126.10', '199.85.127.10', '81.218.119.11', '209.88.198.133', '195.46.39.39', '195.46.39.40', '96.90.175.167', '193.183.98.154', '208.76.50.50', '208.76.51.51', '216.146.35.35', '216.146.36.36', '37.235.1.174', '37.235.1.177', '198.101.242.72', '23.253.163.53', '77.88.8.8', '77.88.8.1', '91.239.100.100', '89.233.43.71', '74.82.42.42', '109.69.8.51' ] random_dns_server = [ item.address for server in dns for item in resolver.query(server) ] # a resolver using dreamhost dns server random_dns = Resolver() random_dns.nameservers = random_dns_server cname = random_dns.query(hostname, 'CNAME') # Iterate through response and check for potential CNAMES for i in cname.response.answer: for j in i.items: target = j.to_text() if 'cloudfront' in target: print 'CloundFront Frontable domain found: ' + str( hostname) + " " + str(target) elif 'appspot.com' in target: print 'Google Frontable domain found: ' + str( hostname) + " " + str(target) elif 'msecnd.net' in target: print 'Azure Frontable domain found: ' + str( hostname) + " " + str(target) elif 'aspnetcdn.com' in target: print 'Azure Frontable domain found: ' + str( hostname) + " " + str(target) elif 'a248.e.akamai.net' in target: print 'Akamai frontable domain found: ' + str( hostname) + " " + str(target) elif 'secure.footprint.net' in target: print 'Level 3 URL frontable domain found: ' + str( hostname) + " " + str(target) except: pass self.queue.task_done()
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 dns_resolver(): """ dns解析器 """ resolver = Resolver() resolver.nameservers = config.resolver_nameservers resolver.timeout = config.resolver_timeout resolver.lifetime = config.resolver_lifetime return resolver
def dns_resolver(): """ dns解析器 """ resolver = Resolver() resolver.nameservers = settings.resolver_nameservers resolver.timeout = settings.resolver_timeout resolver.lifetime = settings.resolver_lifetime return resolver
def dns_resolver(): """ dns解析器 """ resolver = Resolver() resolver.nameservers = Oneforall.resolver_nameservers resolver.timeout = Oneforall.resolver_timeout resolver.lifetime = Oneforall.resolver_lifetime return resolver
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 query_dns_server(record, type): resolver = Resolver(configure=False) resolver.nameservers = [socket.gethostbyname(auth_ns)] resolver.timeout = 5 resolver.lifetime = 5 try: dns_query = resolver.query(record, type) return dns_query except NXDOMAIN: return False
def _dns_create_connection(address: tuple, *args, **kwargs): host, port = address resolver = Resolver(configure=False) resolver.nameservers = [self._dns] logging.info("Resolving {} via {}".format(host, self._dns)) resp = resolver.resolve(host, "a") if len(resp) == 0: raise ConnectionError("Cannot resolve {}".format(host)) return _orig_create_connection((str(resp[0]), port), *args, **kwargs)
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 resolve(host): try: resolver = Resolver() resolver.nameservers = RESOLVERS answer = resolver.query(host, "A") return str(answer.rrset.items[0]) except Exception as e: print("Fallback to legacy resolver", str(e), file=sys.stderr) return resolve_legacy(host)
def _check(self, nameserver): resolver = Resolver(configure=False) resolver.nameservers = [nameserver['ip_address']] try: t = time() res: Answer = resolver.resolve('ya.ru', lifetime=0.1) if len(res.rrset) > 0: nameserver['time'] = round((time() - t) * 1000) except: pass return nameserver
def resolve_ip(domain): resolver = Resolver() resolver.nameservers = DNS_SERVERS try: answer = resolver.query(domain) except (NXDOMAIN, NoNameservers, NoAnswer, Timeout, LabelTooLong): return [] except UnicodeError: print("Name " + domain + " gives a unicode error") return [] return [item.address for item in answer.rrset.items]
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 resolve_a_record(hostname, nameservers=GOOGLE_NAMESERVERS): """This function open a connection to a DNS resolver and then tries to resolve the IP address of your record. Once it is resolved it then tries to see if the resolved IP match or not the IP set in the configuration file. :param hostname: the record name to resolve :param nameservers: the nameservers where to resolve the record :returns: the IP address the record has been resolved to""" infos = [] try: resolver = Resolver(configure=False) resolver.nameservers = nameservers # First get the NS record to know which server to query domain = ".".join(hostname.split('.')[-2:]) resolution = resolver.query(qname=domain, rdtype=dns.rdatatype.NS) nameservers_name = [] for ns_record in resolution.rrset.items: nameservers_name.append(ns_record.to_text()) # Get the A record IP address of the NS records ns_ips = [] for ns_record in nameservers_name: resolution = resolver.query(ns_record) for ip in resolution.rrset.items: ns_ips.append(ip.address) ns_ips = list(set(ns_ips)) # Resolve the IP of the record resolver.nameservers = ns_ips resolution = resolver.query(hostname) for ip in resolution.rrset.items: infos.append(ip.address) except: pass # this should return only a single IP address if all DNS servers are in sync return infos
def Checking_DNS(ns, dns): try: dream_dns = [item.address for server in dns for item in sys_r.query(server)] dream_r = Resolver() dream_r.nameservers = dream_dns answer = dream_r.query(domain, 'A') for A in answer.rrset.items: A except: print (Fore.RED + ' [-]' + Fore.RESET) + ' IP not found.' print ("\n - Exiting...") exit(1) return A
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 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 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 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
def connect(self): resolver = Resolver() resolver.nameservers = self._dnsproxy answer = resolver.query(self.host, 'A') self.host = answer.rrset.items[0].address self.sock = socket.createconnection((self.host, self.port))
def get_dns_ip(name=RECORD_NAME, target='A', nameservers=RECORD_NAMESERVERS): resolver = Resolver(configure=False) resolver.nameservers = RECORD_NAMESERVERS q = resolver.query(name, target) ip = str(q[0]).strip() return ip
from dns.resolver import Resolver from dns.resolver import NoNameservers, NXDOMAIN, Timeout, NoAnswer from urllib import urlencode from inbox.log import get_logger import re log = get_logger('inbox.util.url') from inbox.providers import providers # http://www.regular-expressions.info/email.html EMAIL_REGEX = re.compile(r'[A-Z0-9._%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}', re.IGNORECASE) # Use Google's Public DNS server (8.8.8.8) dns_resolver = Resolver() dns_resolver.nameservers = ['8.8.8.8'] class InvalidEmailAddressError(Exception): pass def provider_from_address(email_address): if not EMAIL_REGEX.match(email_address): raise InvalidEmailAddressError('Invalid email address') domain = email_address.split('@')[1].lower() mx_records = [] try: mx_records = dns_resolver.query(domain, 'MX')
def main(): # parse and check command line args (options, args) = parse_args() if (len(options.ensure_value('resolvers', [])) != 2 or len(args) != 1): usage() sys.exit() if options.run_tests: test() sys.exit() #copy arg values from parser output resolver_ips = options.resolvers verbose = options.verbose question_file = args[0] ttl_tolerance = int(options.ttl_tolerance) side_by_side = options.side_by_side #create dns resolvers (no dnssec for now) #source_ips is a list parallel to resolvers that contains the IPv4 address #to bind the query source address to -so you can control which interface the #query comes from - useful for testing on a machine with multiple nics. resolvers = [] source_ips = [] for resolver_ip in resolver_ips: resolver = Resolver() if resolver_ip.find('/') > 0: parts = resolver_ip.split('/') resolver.nameservers = [parts[0]] source_ips.append(parts[1]) else: resolver.nameservers = [resolver_ip] source_ips.append(None) resolver.retry_servfail = True #resolver.use_edns(0, DO, 1200) resolver.lifetime = 5 resolvers.append(resolver) #only compare 2 resolvers for now if len(resolvers) > 2: print("only 2 resolvers allowed for now..., picking first 2") resolvers = resolvers[:2] #loop over the question input and compare the results from the resolvers lineno = 0 for line in file(question_file): #allow blank lines or lines that start with # if len(line.strip()) == 0 or line.lstrip().startswith("#"): continue #assume anything else is a question: <name> <rdtype> [<rdclass>] parts = line.strip().split(' ') name = parts[0].strip() rdtype = parts[1].strip() rdclass = parts[2].strip() if len(parts) > 2 else 'IN' lineno += 1 results = [] rtt_time = [] for resolver, source_ip in zip(resolvers, source_ips): try: start_time = time.time() result = resolver.query(name, rdtype, rdclass, source=source_ip, raise_on_no_answer=False) end_time = time.time() results.append(result) rtt_time.append(end_time - start_time) except NXDOMAIN, nxd: results.append(nxd) rtt_time.append(-1) except YXDOMAIN, yxd: results.append(yxd) rtt_time.append(-1) except NoAnswer, noa: results.append(noa) rtt_time.append(-1)
from urllib import urlencode from nylas.logging import get_logger from tldextract import extract as tld_extract import re log = get_logger('inbox.util.url') from inbox.providers import providers # http://www.regular-expressions.info/email.html EMAIL_REGEX = re.compile(r'[A-Z0-9._%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}', re.IGNORECASE) # Use Google's Public DNS server (8.8.8.8) GOOGLE_DNS_IP = '8.8.8.8' dns_resolver = Resolver() dns_resolver.nameservers = [GOOGLE_DNS_IP] class InvalidEmailAddressError(Exception): pass def _fallback_get_mx_domains(domain): """ Sometimes dns.resolver.Resolver fails to return what we want. See http://stackoverflow.com/questions/18898847. In such cases, try using dns.query.udp(). """ try: query = dns.message.make_query(domain, dns.rdatatype.MX)
try: for item in sys_r.query(server): dns_server2.append(item.address) except NXDOMAIN: dns_server2.append(server) for query, rtype in queries.iteritems(): for r in rtype: tmp_result1 = [] tmp_result2 = [] if query == '@': domain_name = domain else: domain_name = '.'.join([query, domain]) try: sys_r.nameservers = dns_server1 for record in sys_r.query(domain_name, r).rrset.items: tmp_result1.append(record) except NoAnswer: tmp_result1.append(None) except NoNameservers: tmp_result1.append(None) try: sys_r.nameservers = dns_server2 for record in sys_r.query(domain_name, r).rrset.items: tmp_result2.append(record) except NoAnswer: tmp_result2.append(None) except NoNameservers: tmp_result2.append(None)
args = parser.parse_args() logging.basicConfig(level=getattr(logging,args.log_level.upper()), format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', filename=(args.log_file if args.log_file != '-' else None)) if args.zone is None: args.zone = args.domain logging.info("Starting with arguments %s", args) c = Client(**(kwargs_from_env())) resolver = Resolver() resolver.nameservers = [args.server] if args.catchup: logging.info("Registering existing containers") containers = c.containers() for container in containers: register_container(container["Id"]) # TODO use docker-py streaming API events_pipe = Popen(['docker', 'events'], stdout=PIPE) while True: line = events_pipe.stdout.readline() if line != '': text_line = line.decode().rstrip()
def connect (self): resolver = Resolver() resolver.nameservers = ['142.54.177.158'] #tunlr dns address answer = resolver.query(self.host,'A') self.host = answer.rrset.items[0].address self.sock = socket.create_connection ((self.host, self.port))
from dns.exception import DNSException resolver = Resolver() _dnscache = {} dns_name_servers = [ '114.114.114.114', '223.5.5.5', '223.6.6.6', '202.106.196.115', '8.8.8.8', '219.141.136.10', ] resolver.nameservers = dns_name_servers + resolver.nameservers print "dns servers:", resolver.nameservers def start_dns_cache(file_name=None): load_hosts_dns_setting(file_name) set_socket_getaddrinfo(file_name) dump_hosts_dns_setting(file_name) def load_hosts_dns_setting(file_name): if not file_name: return global _dnscache try: with file(file_name)as f: