def resolve(dns, nameserver): global resolved #additional args for ports nameserver_ports = {} for i in nameserver: if ":" in i: #if ports are different remove default port ip, port = i.split(":") port = int(port) ind = nameserver.index(i) nameserver[ind] = i.split(":")[0] nameserver_ports[ip] = port # if dnserver is not reachable exetime = 0 try: resolver = Resolver() resolver._nameservers = nameserver resolver.nameserver_ports = nameserver_ports resolver.timeout = 10 #Starting time c_time = datetime.now() resolver.resolve('example.com', 'A') #Time excuted exetime = int((datetime.now() - c_time).total_seconds() * 1000) except Exception as e: #print(e) pass resolved[dns]['IPv4'] = exetime
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 _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 get_records(email): try: domain = email.split('@')[1] resolve = Resolver() records = resolve.resolve(domain, 'MX') mx = records[0].exchange mx = str(mx) return mx except Exception: return None
def check_dns(hostname, dns_groups=None): """ Check if hostname is reachable by any group of dns servers. :return: tuple of (dns error code, hostname) """ try: from dns.resolver import Resolver, NXDOMAIN except ImportError: return -1, hostname from .config_manager import ConfigManager if dns_groups is None: dns_server_groups = ast.literal_eval(ConfigManager().config.get( "Remote Environment Settings", "DNS_SERVER_GROUPS")) dns_groups = [Resolver().nameservers] + dns_server_groups dns_err_code = 0 for dns_servers in dns_groups: try: my_resolver = Resolver() my_resolver.nameservers = dns_servers if dns_err_code > 0: print( "Could not resolve domain. " f"Trying with nameservers: {dns_servers}", file=sys.stderr, ) answer = my_resolver.resolve(hostname) hostname = answer[0].address dns_err_code = 1 else: my_resolver.resolve(hostname) break except NXDOMAIN: dns_err_code = 2 if dns_err_code == 1: print(f"Found IP: {hostname}") elif dns_err_code == 2: print(f"No IP found for {hostname}", file=sys.stderr) return dns_err_code, hostname
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 lookup(servers, domain): dns_resolver = Resolver() dns_resolver.nameservers = servers dns_resolver.lifetime = 3 try: # python 3.9 query deprecation if sys.version_info.minor < 9: answer = dns_resolver.query(domain) else: answer = dns_resolver.resolve(domain) return [x.to_text() for x in answer] except (DNSException, ValueError) as e: pass return []
def test_add_txt(self): txt_record_text = "simple text" duckdns_client = DuckDNSClient(TEST_DUCKDNS_TOKEN) duckdns_client.set_txt_record(TEST_DOMAIN, txt_record_text) # wait sometime for propagation of the txt update print("wait for the txt record update to propagate...") time.sleep(DEFAULT_PROPAGATION_SECONDS) # get the set txt record from the specified nameserver custom_resolver = Resolver() custom_resolver.nameservers = NAMESERVER txt_value = custom_resolver.resolve(TEST_DOMAIN, "TXT").response.answer[0][0].strings[0].decode("utf-8") self.assertEqual(txt_record_text, txt_value)
def resolve_hostname(self, hostname, max_retries=1, timeout=1): attempt = 0 address = hostname resolver = Resolver() resolver.nameservers = ["8.8.8.8"] while attempt < max_retries: self._logger.debug("Resolve host retry {}, {}".format(attempt, address)) try: address = socket.gethostbyname(hostname) break except Exception: try: address = str(resolver.resolve(hostname)[0]) break except Exception: attempt += 1 attempt < max_retries and time.sleep(timeout) return address
def discover_dorms(source_ip): '''Returns list of dorms server (domain,port), ordered by priority then randomly according to weight''' src = ip_address(source_ip) name = '_dorms._tcp.' + src.reverse_pointer # TBD: dnssec validation - jake 2020-07 # best MIT-licensed example I could find (does not validate expirations): # https://github.com/spesmilo/electrum/blob/6d2aee18d0bc5b68bff4123855f2b77b7efa1f3b/electrum/dnssec.py#L274 # see also: # https://backreference.org/2010/11/17/dnssec-verification-with-dig/ # https://www.internetsociety.org/resources/deploy360/2013/dnssec-test-sites/ dnsr = Resolver() answer = dnsr.resolve(name, 'SRV') rrlist = list(answer.rrset) preference_ordering = [] grouped = [(pri,[rr for rr in gr]) for pri,gr in groupby(rrlist, lambda r: r.priority)] for pri,rrpri in sorted(grouped, key=lambda v: v[0]): preference_ordering.extend([(str(rr.target), str(rr.port)) for rr in weighted_shuffle(rrpri, [it.weight for it in rrpri])]) return preference_ordering
class DnsResolver: def __init__(self): self.resolver = Resolver() self.mappings = {} @staticmethod def from_options(options, target) -> "DnsResolver": self = DnsResolver() # We can't put all possible nameservers in the list of nameservers, since # the resolver will fail if one of them fails nameserver = options.ns if nameserver is None: nameserver = target.dc_ip if nameserver is not None: self.resolver.nameservers = [nameserver] self.use_tcp = options.dns_tcp return self @staticmethod def create(target: "Target" = None, ns: str = None, dns_tcp: bool = False) -> "DnsResolver": self = DnsResolver() # We can't put all possible nameservers in the list of nameservers, since # the resolver will fail if one of them fails nameserver = ns if nameserver is None: nameserver = target.dc_ip if nameserver is not None: self.resolver.nameservers = [nameserver] self.use_tcp = dns_tcp return self def resolve(self, hostname: str) -> str: # Try to resolve the hostname with DNS first, then try a local resolve if hostname in self.mappings: logging.debug("Resolved %s from cache: %s" % (repr(hostname), self.mappings[hostname])) return self.mappings[hostname] if is_ip(hostname): return hostname ip_addr = None if self.resolver.nameservers[0] is None: logging.debug("Trying to resolve %s locally" % repr(hostname)) else: logging.debug("Trying to resolve %s at %s" % (repr(hostname), repr(self.resolver.nameservers[0]))) try: answers = self.resolver.resolve(hostname, tcp=self.use_tcp) if len(answers) == 0: raise Exception() ip_addr = answers[0].to_text() except Exception as err_: logging.debug('Error resolving s% : %s' % (repr(hostname), err_)) if ip_addr is None: try: ip_addr = socket.gethostbyname(hostname) except Exception: ip_addr = None if ip_addr is None: logging.warning("Failed to resolve: %s" % hostname) return hostname self.mappings[hostname] = ip_addr return ip_addr
# Create empty dictionaries names = {} resolved1 = {} resolved2 = {} # Open toresolve.csv file and populate dictionary names with open('toresolve.csv', mode='r') as infile: reader = csv.reader(infile) names = dict((rows[0],0) for rows in reader) infile.close() print("Using server: ",my1_r.nameservers) for x in names: try: hostip = my1_r.resolve(x,raise_on_no_answer=False) except: hostip = 'None' resolved1[x] = str(hostip.rrset[0]) print(resolved1) print("""------- ------- Using server: """,my2_r.nameservers) for x in names: try: hostip = my2_r.resolve(x,raise_on_no_answer=False) except: hostip = 'None'
def get_public_ip(): r = Resolver() r.nameservers = [socket.gethostbyname('resolver1.opendns.com')] return r.resolve('myip.opendns.com', 'A', search=True)[0].to_text()