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 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 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 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 = ['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 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 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 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:
