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