def checkTXTRecord(query_domain, main_domain): time.sleep(SLEEP) dns_list = [] resolver = dns.resolver.Resolver(configure=False) resolver.nameservers = ['8.8.8.8'] answers = dns.resolver.resolve(main_domain, 'NS') for rdata in answers: rdata = str(rdata)[:-1] dns_list.append(rdata) dns_list.sort() new_dns_list = [] resolver = dns.resolver.Resolver(configure=False) for item in dns_list: answers = dns.resolver.resolve(item, 'A') for rdata in answers: rdata = str(rdata) new_dns_list.append(rdata) resolver = dns.resolver.Resolver(configure=False) i = 1 dns_size = len(dns_list) for server in dns_list: resolver.nameservers = [server] try: resolver.resolve(f'_acme-challenge.{query_domain}', 'TXT') return True except dns.resolver.NXDOMAIN as err: if i >= dns_size: return False i += 1 pass
def main(): parser = argparse.ArgumentParser() parser.add_argument('commandfile', metavar='c', type=str, help='Command file') args = parser.parse_args() resolver = Resolver() with open(args.commandfile, 'r') as f: for line in f: print('COMMAND: ' + line) line = line.split(sep=' ') cmd = line[0] if cmd != 'quit': arg1 = line[1] if cmd == 'print' and arg1 == 'cache\n': resolver.printcache() elif cmd == 'resolve': domain = arg1 record = line[2].replace('\n', '') resolver.resolve(domain, record) else: print('Unknown command.\n') print('***************************************************\n') else: print('Program terminated\n') exit(0)
def ping(resolver, hostname, dnsrecord, ttl, src_ip, use_edns=False): global _ttl reached = False dns.query.socket_factory = CustomSocket _ttl = ttl if use_edns: resolver.use_edns(edns=0, payload=8192, ednsflags=dns.flags.edns_from_text('DO')) try: resolver.resolve(hostname, dnsrecord, source=src_ip, raise_on_no_answer=False) except dns.resolver.NoNameservers as e: if not quiet: print("no or bad response:", e) sys.exit(1) except dns.resolver.NXDOMAIN as e: if not quiet: print("Invalid hostname:", e) sys.exit(1) except dns.resolver.Timeout: pass except dns.resolver.NoAnswer: if not quiet: print("invalid answer") except SystemExit: pass except Exception as e: print("unxpected error: ", e) sys.exit(1) else: reached = True return reached
def trace(self, name, rdtype=dns.rdatatype.A): if isinstance(rdtype,basestring): rdtype = dns.rdatatype.from_text(rdtype) if self.name == '.' and not self.resolvers: self.find_root_resolvers() if not name.endswith('.'): name += '.' for resolver in sorted(self.resolvers.values(), key=lambda x: x.name): resolver.resolve(name, rdtype=rdtype)
def trace(self, name, rdtype=dns.rdatatype.A): if isinstance(rdtype, basestring): rdtype = dns.rdatatype.from_text(rdtype) if self.name == '.' and not self.resolvers: self.find_root_resolvers() if not name.endswith('.'): name += '.' for resolver in sorted(self.resolvers.values(), key=lambda x: x.name): resolver.resolve(name, rdtype=rdtype)
def get_dnstime(fqdn): dns_start = time.time() resolver = dns.resolver.Resolver(configure=False) resolver.nameservers = ['8.8.8.8', '8.8.4.4', '1.1.1.1'] try: resolver.resolve(fqdn, 'A') dns_time = time.time() - dns_start except Exception as e: print(e) dns_time = None return dns_time
def query_dns(domain, record_type, cache=None, nameservers=None, timeout=2.0): """ Queries DNS Args: domain (str): The domain or subdomain to query about record_type (str): The record type to query for cache (ExpiringDict): Cache storage nameservers (list): A list of one or more nameservers to use (Cloudflare's public DNS resolvers by default) timeout (float): Sets the DNS timeout in seconds Returns: list: A list of answers """ domain = str(domain).lower() record_type = record_type.upper() cache_key = "{0}_{1}".format(domain, record_type) if cache: records = cache.get(cache_key, None) if records: return records resolver = dns.resolver.Resolver() timeout = float(timeout) if nameservers is None: nameservers = [ "1.1.1.1", "1.0.0.1", "2606:4700:4700::1111", "2606:4700:4700::1001", ] resolver.nameservers = nameservers resolver.timeout = timeout resolver.lifetime = timeout if record_type == "TXT": resource_records = list( map(lambda r: r.strings, resolver.resolve(domain, record_type, lifetime=timeout))) _resource_record = [ resource_record[0][:0].join(resource_record) for resource_record in resource_records if resource_record ] records = [r.decode() for r in _resource_record] else: records = list( map(lambda r: r.to_text().replace('"', '').rstrip("."), resolver.resolve(domain, record_type, lifetime=timeout))) if cache: cache[cache_key] = records return records
def fetch_ip_from_google(): ns_address, query_address = 'ns1.google.com', 'o-o.myaddr.l.google.com' resolver = dns.resolver.Resolver(configure=True) resp = resolver.resolve(ns_address) ns_ip = resp[0].to_text() resolver.nameservers = [ns_ip] resp_two = resolver.resolve(query_address, 'TXT') ip = resp_two[0].to_text() ip = ip.replace('"', '') return ip
def resolveDomain(dns_list): time.sleep(SLEEP) resolver = dns.resolver.Resolver(configure = False) i = 1 dns_size = len(dns_list) for server in dns_list: resolver.nameservers = [server] try: resolver.resolve(f'_acme-challenge.{CERTBOT_DOMAIN}', 'TXT') return True except dns.resolver.NXDOMAIN as err: if i >= dns_size: return False i += 1 pass
def is_ip_uptodate(self, ip: str, ipv6: str): """check if IP address is up-to-date Some provider will block the domain, if they detect to many update requests without changes. A nameserver of the provider should be set because it will be updated fast. This method compare the ip address of the nameserver with the actual ip address. Args: ip (str): actual IPv4 address ipv6 (str): actual IPv6 address Returns: bool: True, if IP address is uptodate """ resolver = dns.resolver.Resolver() if "Nameservers" in self.Config.keys(): nameservers = self.Config["Nameservers"].split(",") for ns in nameservers: for record in ["A", "AAAA"]: try: nsips = dns.resolver.resolve(ns, record) for nsip in nsips: resolver.nameservers.insert(0, nsip.to_text()) except dns.resolver.NXDOMAIN: self.log.warning("nameserver %s does not exist", ns) except dns.resolver.NoAnswer: pass name = self.Config["Name"] if ip: try: answers = resolver.resolve(name, "A") if not str(answers[0]) == ip: return False except dns.resolver.NoAnswer: return False if ipv6: try: answers = resolver.resolve(name, "AAAA") if not str(answers[0]) == ipv6: return False except dns.resolver.NoAnswer: return False self.log.debug("IP has not changed") return True
def needs_update( self, address_update: Union[IPv4AddressUpdate, IPv6AddressUpdate]) -> bool: """ Checks if the name configured in this updater has a different address than the provided address and thus needs to be updated. Throws an exception if an answer can't be determined. Defaults to a simple DNS resolution, supporting IPv4 and IPv6 addresses. For other classes, or other record types, override this method. It is generally recommended to override this method with an API call to whatever service the updater represents. The DNS will not provide as timely an answer as directly asking the authoritative source. :param address_update: The address being checked. :return True if the address needs updating, False if it does not. :raises If it is unknown whether the address needs updating or not. """ if not isinstance(address_update, IPv4AddressUpdate) or isinstance( address_update, IPv6AddressUpdate): raise DDNSWolfProgramException( f"Unsupported address update for {type(self).__name__}: " f"{address_update}") # Use the system default resolver. answers = resolver.resolve(self.config["name"], address_update.rdtype, RdataClass.IN) for answer in answers: if answer.rdtype == address_update.rdtype: return ipaddress.ip_address( answer.address) != address_update.address # Assume no RR of the correct type means it needs updating. return True
def make_query(resolver: dns.resolver.Resolver, qname: str, qtype: str, use_tcp: bool) -> Dict[str, Any]: q_rdtype = dns.rdatatype.from_text(qtype) q_rdclass = dns.rdataclass.from_text("IN") try: ans = resolver.resolve(qname, q_rdtype, q_rdclass, tcp=use_tcp, lifetime=DNS_QUERY_TTL, raise_on_no_answer=True) except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN): return {} if ans.rrset is None: return {} result: Dict[str, List[str]] = {} result[qtype] = [ rr.to_text() for rr in ans.rrset if (rr is not None and rr.rdtype == q_rdtype and rr.rdclass == q_rdclass) ] return result
def has_dane_record(domain, timeout=10): try: result = resolver.resolve(f'_25._tcp.{domain}', dns.rdatatype.TLSA, dns.rdataclass.IN, lifetime=timeout) if result.response.flags & dns.flags.AD: for record in result: if isinstance(record, dns.rdtypes.ANY.TLSA.TLSA): if record.usage in [2, 3] and record.selector in [ 0, 1 ] and record.mtype in [0, 1, 2]: return True except dns.resolver.NoNameservers: # If the DNSSEC data is invalid and the DNS resolver is DNSSEC enabled # we will receive this non-specific exception. The safe behaviour is to # accept to defer the email. app.logger.warn( f'Unable to lookup the TLSA record for {domain}. Is the DNSSEC zone okay on https://dnsviz.net/d/{domain}/dnssec/?' ) return app.config['DEFER_ON_TLS_ERROR'] except dns.exception.Timeout: app.logger.warn( f'Timeout while resolving the TLSA record for {domain} ({timeout}s).' ) except (dns.resolver.NXDOMAIN, dns.name.EmptyLabel): pass # this is expected, not TLSA record is fine except Exception as e: app.logger.info( f'Error while looking up the TLSA record for {domain} {e}') pass
def test_DNS(): import dns.resolver import dns.exception import dns.flags import dns.rdtypes import dns.rdatatype import dns.rdataclass import time # DNS stub configured to do DNSSEC enabled queries resolver = dns.resolver.Resolver() resolver.use_edns(0, 0, 1232) resolver.flags = dns.flags.AD | dns.flags.RD nameservers = resolver.nameservers for ns in nameservers: resolver.nameservers = [ns] while True: try: result = resolver.resolve('example.org', dns.rdatatype.A, dns.rdataclass.IN, lifetime=10) except Exception as e: log.critical( "Your DNS resolver at %s is not working (%s). Please use another resolver or enable unbound via https://setup.mailu.io.", ns, e) else: if result.response.flags & dns.flags.AD: break log.critical( "Your DNS resolver at %s isn't doing DNSSEC validation; Please use another resolver or enable unbound via https://setup.mailu.io.", ns) time.sleep(5)
def query_data(name, server, query_type): serv_addr = resolver.resolve(server, "A")[0].address name_message = message.make_query(name, query_type) return name_message, serv_addr
def set_secondary_dns(hostnames, env): if len(hostnames) > 0: # Validate that all hostnames are valid and that all zone-xfer IP addresses are valid. resolver = dns.resolver.get_default_resolver() resolver.timeout = 5 for item in hostnames: if not item.startswith("xfr:"): # Resolve hostname. try: response = resolver.resolve(item, "A") except (dns.resolver.NoNameservers, dns.resolver.NXDOMAIN, dns.resolver.NoAnswer): try: response = resolver.query(item, "AAAA") except (dns.resolver.NoNameservers, dns.resolver.NXDOMAIN, dns.resolver.NoAnswer): raise ValueError("Could not resolve the IP address of %s." % item) else: # Validate IP address. try: if "/" in item[4:]: v = ipaddress.ip_network(item[4:]) # raises a ValueError if there's a problem else: v = ipaddress.ip_address(item[4:]) # raises a ValueError if there's a problem except ValueError: raise ValueError("'%s' is not an IPv4 or IPv6 address or subnet." % item[4:]) # Set. set_custom_dns_record("_secondary_nameserver", "A", " ".join(hostnames), "set", env) else: # Clear. set_custom_dns_record("_secondary_nameserver", "A", None, "set", env) # Apply. return do_dns_update(env)
def auto_cdn_check(self): try: cdn_name = "" checked_doamin = [] with open("cname", "r", encoding="utf-8") as cname_file: cname_list = json.load(cname_file) url_list = [] for res_url in self.result: url_list.append(res_url[0]) for url in url_list: domain = self.domain_stripper(url) if len(domain) > 0 and domain not in checked_doamin: checked_doamin.append(domain) # 去重 ans = resolver.resolve(domain, 'CNAME') for i in ans.response.answer: for j in i.items: for cdn in cname_list: if cdn in j.to_text(): cdn_name = cname_list[cdn]['name'] print("""%s 已启用CDN,CDN信息如下 : %s""" % (url, str(cname_list[cdn]))) else: continue if cdn_name == "": print("恭喜, %s 没有启用CDN!" % url) except Exception as e: print(str(e)) logging.warning(str(e))
def main(): try: arguments = docopt.docopt(__doc__) opts = dict() opts["host"] = arguments["--host"] if resolver and "," not in opts["host"]: try: hosts = [] for x in resolver.resolve(opts["host"], "A"): hosts.append(x.to_text()) opts["host"] = ",".join(hosts) except resolver.NXDOMAIN: pass opts["user"] = arguments["--user"] opts["password"] = arguments["--password"] opts["concurrent"] = int(arguments["--concurrent"]) opts["timeout"] = int(arguments["--timeout"]) opts["maxrun"] = int(arguments["--maxrun"]) opts["size"] = int(arguments["--size"]) opts["workdir"] = arguments["<workdir>"] opts["csvfilename"] = arguments["--csv"] opts["fixevery"] = int(arguments["--fixevery"]) opts["countfiles"] = int(arguments["--files"]) except docopt.DocoptExit as e: print(e.message) else: if arguments["login"]: run_bench_login(opts) elif arguments["upload"]: run_bench_upload(opts) elif arguments["download"]: run_bench_download(opts)
def resolve(self, qname, rdtype, rdclass): rdata = None # First try specific methods. if rdclass == "IN": for resolver in self.resolvers: if rdtype == "A": rdata = resolver.resolve_a(qname) elif rdtype == "AAAA": rdata = resolver.resolve_a(qname, True) elif rdtype == "MX": rdata = resolver.resolve_mx(qname) if rdata is not None: return rdata # If that fails, try the generic method. for resolver in self.resolvers: rdata = resolver.resolve(qname, rdtype, rdclass) if rdata is not None: return rdata # None of the resolvers matched. Try resolving using an # actual DNS server. answer = self.fallback.query(qname, rdtype, rdclass) return answer.rrset
def test_DNS(): import dns.resolver import dns.exception import dns.flags import dns.rdtypes import dns.rdatatype import dns.rdataclass import time # DNS stub configured to do DNSSEC enabled queries resolver = dns.resolver.Resolver() resolver.use_edns(0, dns.flags.DO, 1232) resolver.flags = dns.flags.AD | dns.flags.RD nameservers = resolver.nameservers for ns in nameservers: resolver.nameservers=[ns] while True: try: result = resolver.resolve('example.org', dns.rdatatype.A, dns.rdataclass.IN, lifetime=10) except Exception as e: log.critical("Your DNS resolver at %s is not working (%s). Please see https://mailu.io/master/faq.html#the-admin-container-won-t-start-and-its-log-says-critical-your-dns-resolver-isn-t-doing-dnssec-validation", ns, e); else: if result.response.flags & dns.flags.AD: break log.critical("Your DNS resolver at %s isn't doing DNSSEC validation; Please see https://mailu.io/master/faq.html#the-admin-container-won-t-start-and-its-log-says-critical-your-dns-resolver-isn-t-doing-dnssec-validation.", ns) time.sleep(5)
def get_dns_records(name, typ, resolver=None): """Retrieve DNS records for given name and type.""" logger = logging.getLogger("modoboa.admin") if not resolver: resolver = get_dns_resolver() try: dns_answers = resolver.resolve(name, typ, search=True) except dns.resolver.NXDOMAIN as e: logger.error(_("No DNS record found for %s") % name, exc_info=e) except dns.resolver.NoAnswer as e: logger.error(_("No %(type)s record for %(name)s") % { "type": typ, "name": name }, exc_info=e) except dns.resolver.NoNameservers as e: logger.error(_("No working name servers found"), exc_info=e) except dns.resolver.Timeout as e: logger.warning( _("DNS resolution timeout, unable to query %s at the moment") % name, exc_info=e) except dns.name.NameTooLong as e: logger.error(_("DNS name is too long: %s" % name), exc_info=e) else: return dns_answers return None
def get_master_ns(name, server=resolver.get_default_resolver().nameservers[0]): try: response = resolver.resolve(name, "SOA") return response.response.answer[0][0].mname.to_text() except resolver.NoAnswer: try: server_name = gethostbyaddr(server)[0] message, address = query_data(name, server_name, "SOA") response = query.udp(message, address) return response.authority[0].to_rdataset()[0].mname.to_text() except: return False except: return False
def query(number, domains, resolver=None): """Look for NAPTR RRs for the specified number in the specified domains. e.g. lookup('16505551212', ['e164.dnspython.org.', 'e164.arpa.']) *number*, a ``str`` is the number to look for. *domains* is an iterable containing ``dns.name.Name`` values. *resolver*, a ``dns.resolver.Resolver``, is the resolver to use. If ``None``, the default resolver is used. """ if resolver is None: resolver = dns.resolver.get_default_resolver() e_nx = dns.resolver.NXDOMAIN() for domain in domains: if isinstance(domain, str): domain = dns.name.from_text(domain) qname = dns.e164.from_e164(number, domain) try: return resolver.resolve(qname, 'NAPTR') except dns.resolver.NXDOMAIN as e: e_nx += e raise e_nx
def resolve(self, question, resolver): """Resolve ONE question, in the form of (name, rrtype)""" name, rrtype = question try: if rrtype == 'PTR' and self.transform_ptr: answer = resolver.resolve_address(name, lifetime=3, search=False) else: answer = resolver.resolve(name, rrtype, lifetime=3, search=False) return answer except dns.exception.Timeout: self.tcex.log.debug(f'Timeout resolving {name} {rrtype}') except dns.resolver.NXDOMAIN: self.tcex.log.debug(f'NXDOMAIN resolving {name} {rrtype}') except dns.resolver.YXDOMAIN: self.tcex.log.debug(f'YXDOMAIN resolving {name} {rrtype}') except dns.resolver.NoAnswer: self.tcex.log.debug(f'No answer resolving {name} {rrtype}') except dns.resolver.NoNameservers: self.tcex.log.debug(f'No nameservers resolving {name} {rrtype}') except Exception as e: self.tcex.log.error(f'Error resolving question: {e}') self.tcex.log.error(traceback.format_exc()) return None
def query_uri(uri): try: answers = resolve(uri, rdatatype.URI) except DNSException as e: logger.debug("DNS record not found: %s", e.__class__.__name__) answers = [] return answers
def resolveasn(resolver, ip): asn = int([ x.to_text() for x in resolver.resolve( '.'.join(reversed(ip.split('.'))) + '.origin.asn.cymru.com', 'TXT').response.answer ][0].split('\"')[1].split(' ')[0]) return asn
def __dns_query(self, nameserver, domain): resolver = dns.resolver.Resolver() resolver.nameservers = [nameserver] if domain in self.host.blacklist: if (self.host.redirect_ip == None) == False: if len(list(self.host.redirect_ip)) < 1: return "0.0.0.0" else: self.host.log("\nrequest for {}\nblacklisted, redirecting to {}".format(domain, self.host.redirect_ip)) return self.host.redirect_ip return else: try: try: response = self.host.cache[domain] self.host.log("\nrequest for {}\nretrieved {} from cache".format(domain, response)) return response except Exception: response = resolver.resolve(domain, 'A') self.host.log("\nrequest for {}\nresponded with {}".format(domain, str(response[0]))) cache = self.host.add_cache(domain, str(response[0])) self.host.log(cache) return str(response[0]) except Exception as e: print("EXCEPTION, ", e)
def genNetworkList(list): resolver = dns.resolver.Resolver() hostnames = [] networks = [] for key in list: if isIpNetwork(key): networks.append(key) else: hostnames.append(key) for hostname in hostnames: hostname_ips = [] for rdtype in ['A', 'AAAA']: try: answer = resolver.resolve(qname=hostname, rdtype=rdtype, lifetime=3) except dns.exception.Timeout: logInfo('Hostname %s timedout on resolve' % hostname) break except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer): continue except dns.exception.DNSException as dnsexception: logInfo('%s' % dnsexception) continue for rdata in answer: hostname_ips.append(rdata.to_text()) networks.extend(hostname_ips) return set(networks)
def __threaded_query(hostname): """Perform the requests to the DNS server.""" try: answer = resolver.resolve(hostname) return answer except Exception: return None
def resolve(self, host, tries=10, nameserver=None): if nameserver is None: resolver = self.getResolver() else: resolver = dns.resolver.Resolver() resolver.nameservers = [nameserver] self.sf.debug( f"Resolving {host} using nameserver {resolver.nameservers[0]}") ips = set() for recordType in ["A", "AAAA"]: try: for answer in resolver.resolve(host, recordType): ips.add(str(answer)) break except dns.resolver.NXDOMAIN: break except Exception as e: self.sf.debug( f"Error resolving \"{host}\": {e.__class__.__name__}: {e}") if tries > 0: self.sf.debug(f"Retrying \"{host}\"") return self.resolve(host, tries=tries - 1, nameserver=nameserver) else: self.sf.debug( f"Max retries ({tries:,}) exceeded for \"{host}\"") return (host, []) return (host, list(ips))
async def _verify_dns(self, header_uuid: str) -> bool: resolver = dns.resolver.Resolver(configure=False) resolver.nameservers = [self._dns_host] answer = resolver.resolve(header_uuid + ".c", "TXT") if answer[0].strings[0].decode("utf-8") == "true": return True return False
def resolve_dns(dom): """ devulve las ip asociadas al dominio """ try: resolver = dns.resolver.Resolver() answer = resolver.resolve(dom, "A") return answer except DNSException: return None
def resolve(self, name, rdtype=dns.rdatatype.A): if self.name == '.' and not self.resolvers: self.find_root_resolvers() if name in self.root.names: return self.root.names[name].ip if name in self.resolvers: # Misconfiguration a la otenet.gr, ns1.otenet.gr isn't glued anywhere. www.cosmote.gr A lookup triggered it pass for resolver in self.resolvers.values(): if resolver.ip: return resolver.resolve(name, rdtype=rdtype, register=False) else: # No glue at all return self.resolvers.values()[0].resolve(name, rdtype=rdtype, register=False)
def resolve(self): ans = _cache.lookup(self.addr) if ans is not None: return ans deadline = time.time() + self.lifetime for serverconf in self.conf['dns_servers']: if _domain_filtered(self.addr, serverconf): continue resolver = _classdict[serverconf['type']](self.addr, serverconf) resolver.timeout = min(resolver.timeout, deadline - time.time()) ans = resolver.resolve() if ans: _cache.insert(self.addr, ans) return ans raise ProxyException('cannot resolve hostname')
def iplookup(domains): ''' This function is used to lookup all IP addresses assigned to a domain using DNS resolution. :param domains: single domain as a string, or multiple domains as a List type :return: Returns a List of IP Addresses from the domains supplied as Params ''' # convert single string arg to single item list ip_list = [] if isinstance(domains, str): domains = domains.split() elif not isinstance(domains, list): raise TypeError('iplookup only supports strings or lists') for domain in domains: try: answer = resolve(domain) except Exception as e: print("Error occured doing lookup for {}".format(domain)) break ip_list += [ str(ip.to_text()) for ip in answer if not ip == None ] return ip_list