def resolve():
"""Resolve a hostname using the resolver """
parser = ArgumentParser(description="DNS Client")
parser.add_argument("hostname", help="hostname to resolve")
parser.add_argument("--timeout", metavar="time", type=int, default=5,
help="resolver timeout")
parser.add_argument("-c", "--caching", action="store_true",
help="Enable caching")
parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0,
help="TTL value of cached entries (if > 0)")
args = parser.parse_args()
cache = RecordCache(args.ttl)
if args.caching:
cache.read_cache_file()
resolver = Resolver(args.timeout, cache)
else:
resolver = Resolver(args.timeout)
hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname)
if args.caching:
cache.write_cache_file()
print(hostname)
print(aliaslist)
print(ipaddrlist)
def _isitup(self, url, return_status=False, redirects=0):
valid_url = self._makeurl(url)
if Resolver is not None:
r = Resolver()
host = urlparse(valid_url).netloc.split(':')[0]
try:
r.query(host)
except NoAnswer:
return (False, valid_url,
u'No DNS A/CNAME-records for that domain')
except NXDOMAIN:
return False, valid_url, u'No such domain'
try:
status, reason, data, headers = self._request(valid_url, 'HEAD')
if 300 <= status < 400 and self._get_header(headers, 'location'):
if redirects > self.max_hops:
return False, valid_url, u'Redirect limit reached'
return self._isitup(self._get_header(headers, 'location'),
return_status, redirects + 1)
up = status < 300
if return_status:
reason = u'%(status)d %(reason)s' % {
u'status': status,
u'reason': reason,
}
return up, valid_url, reason
except HTTPException:
return False, valid_url, u'Server is not responding'
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 create_dns_record(self, domain_name, domain_dns_value):
self.logger.info("create_dns_record")
resolver = Resolver(configure=False)
resolver.nameservers = ["8.8.8.8"]
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 get_response(data, spoofs, spoof_all):
message = from_wire(data)
domain = str(message.question[0].name)[:-1]
rrset = None
response = make_response(message)
if spoofs and message.question[
0].rdtype == dns.rdatatype.A and domain in spoofs:
print('Spoofing query for %s' % domain)
rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN,
dns.rdatatype.A, spoofs[domain])
elif spoof_all and message.question[0].rdtype == dns.rdatatype.A:
print('Spoofing query for %s due to spoof all' % domain)
rrset = from_text(message.question[0].name, 300, dns.rdataclass.IN,
dns.rdatatype.A, spoof_all)
else:
print('Not spoofing %s query for %s' %
(dns.rdatatype.to_text(message.question[0].rdtype), domain))
resolver = Resolver()
try:
rrset = resolver.query(message.question[0].name,
message.question[0].rdtype,
message.question[0].rdclass).rrset
except dns.resolver.NXDOMAIN:
response.set_rcode(dns.rcode.NXDOMAIN)
except dns.resolver.NoAnswer:
response.set_rcode(dns.rcode.NOERROR)
if rrset:
response.answer.append(rrset)
return response
def resolve_googleipranges():
# returns a list of IP ranges for outbound SMTP from Google
from dns.resolver import Resolver
sys_r = Resolver()
# query for the list of domains included in Google's SPF records
answers = sys_r.query('_spf.google.com', 'TXT')
# format the returned answer into a list
rrset = str(answers.rrset)
spfdomains = rrset.split(' ')
# return only entries that have "include:"
# and then split them on the ':' to return only the dns addresses
spfdomains = [x for x in spfdomains if 'include:' in x]
spfdomains = [i.split(':', 1)[1] for i in spfdomains]
# iterate these to get a full list of IP addresses
ipranges = list()
for domain in spfdomains:
answers = sys_r.query(domain, 'TXT')
rrset = str(answers.rrset)
iplist = rrset.split(' ')
iplist = [x for x in iplist if 'ip4' in x]
iplist = [i.split(':', 1)[1] for i in iplist]
ipranges = ipranges + iplist
return ipranges
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 = ['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 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 __init__(self):
super().__init__()
self.resolver = Resolver()
self.session = Session("http://www.crimeflare.com/cgi-bin/")
actions = self.parser.add_mutually_exclusive_group(required=True)
actions.add_argument("-s",
"-cfs",
"--search",
metavar="DOMAIN",
type=str,
help="CloudFlare-Protected-Domain Search ...")
actions.add_argument(
"-l",
"-cfl",
"--list",
metavar="CFL-ID",
type=str,
help=
"List CloudFlare domains using the specified Direct-Connect IP Address ..."
)
self.parser.add_argument(
"-x",
"--proxy",
default="",
type=str,
help=
"Proxify session through this proxy ('proto://a.ddr.es.s:port/') ..."
)
def dns(self, name, qtype):
"""DNS query.
If the result is in cache, return that. Otherwise pull the
result from DNS, and cache ALL answers, so additional info
is available for further queries later.
CNAMEs are followed.
If there is no data, [] is returned.
pre: qtype in ['A', 'AAAA', 'MX', 'PTR', 'TXT', 'SPF']
post: isinstance(__return__, types.ListType)
"""
result = self.cache.get( (name, qtype) )
cname = None
if not result:
req = Resolver()
req.lifetime = self.timeout
resp = req.query(name, qtype)
for a in resp:
# key k: ('wayforward.net', 'A'), value v
k, v = (name, qtype), a
if k == (name, 'CNAME'):
cname = v
self.cache.setdefault(k, []).append(v)
result = self.cache.get( (name, qtype), [])
if not result and cname:
result = self.dns(cname, qtype)
return result
def run(self):
""" Run the handler thread """
print "*Ping* We've got a message!"
# Handle DNS request
resolver = Resolver(self.caching, self.ttl)
aliasRecords = []
addressRecords = []
# Read and resolve the questions one-by-one
questions = self.request.questions
for question in questions:
hostname = question.qname
(hostname, aliases, addresses) = resolver.gethostbyname(hostname)
for alias in aliases:
aliasData = dns.resource.RecordData.create(Type.CNAME, alias)
aliasRecord = dns.resource.ResourceRecord(hostname, Type.CNAME, Class.IN, 9001, aliasData) # TODO fix ttl
aliasRecords.append(aliasRecord)
for address in addresses:
addressData = dns.resource.RecordData.create(Type.A, address)
addressRecord = dns.resource.ResourceRecord(hostname, Type.A, Class.IN, 9001, addressData)
addressRecords.append(addressRecord)
# Crafting of the response
respHeader = self.request.header
respHeader.qr = 1
respHeader.qd_count = 0
respHeader.an_count = 1
respMessage = dns.message.Message(respHeader, [], addressRecords + aliasRecords, [], [])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
respMessageByte = respMessage.to_bytes()
sock.sendto(respMessageByte, self.clientAddr)
print "Ended request: " + hostname
sock.close()
def domain_lookup(q_targets, q_hosts, lock, ips_to_scan):
r = Resolver()
r.timeout = r.lifetime = 8.0
while True:
try:
host = q_hosts.get(timeout=0.1)
except:
break
_schema, _host, _path = parse_url(host)
#print "_schema:{0}\t_host:{1}\t_path:{2}".format(_schema, _host, _path)
#print _host.split(":")[0]
try:
m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0])
if m:
q_targets.put({'file': '', 'url': host})
ips_to_scan.append(m.group(0))
#print "in try->if"
else:
# 无论查不查的到都将这个url放在target中
q_targets.put({'file': '', 'url': host})
answers = r.query(_host.split(':')[0])
if answers:
for _ in answers:
ips_to_scan.append(_.address)
except Exception, e:
lock.acquire()
print '[%s][Warning] Invalid domain: [%s]' % (get_time(), host)
print str(e)
lock.release()
def gethostbyname(host, timeout=DNS_TIMEOUT):
'''Local gethostbyname that uses dns.resolver if available for fast timeouts
Arguments:
host (str): host name to resolve
timeout (float): resolution timeout (defaults to vFXT.service.DNS_TIMEOUT)
Raises: socket.gaierror
'''
try:
from dns.resolver import Resolver
import dns.inet #pylint: disable=import-outside-toplevel
r = Resolver()
r.timeout = r.lifetime = timeout
# if this is an address, return ok
try:
addr = dns.inet.inet_pton(dns.inet.af_for_address(host), host)
if addr:
return host
except Exception:
pass
try:
return r.query(host)[0].to_text()
except Exception as e:
raise socket.gaierror(e)
except ImportError:
return socket.gethostbyname(host)
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))
class RsnServer(object):
def __init__(self, server):
self.logger = logging.getLogger('RsnServer')
self.server = server
self.ipv4 = query(self.server, 'A')[0].address
self.ipv6 = query(self.server, 'AAAA')[0].address
self.resolver = Resolver()
self.size_ipv4 = None
self.size_ipv6 = None
self.size_ipv4_dnssec = None
self.size_ipv6_dnssec = None
self.logger.debug('initiate: {} ({}/{})'.format(self.server, self.ipv4, self.ipv6))
self.update_sizes()
def _update_size(self, server, dnssec):
'''get the response size'''
self.resolver.nameservers = [ server ]
if dnssec:
self.resolver.use_edns(0,DO,4096)
else:
self.resolver.use_edns(0,0,4096)
answer = self.resolver.query('.', 'NS')
size = len(answer.response.to_wire())
self.logger.debug('Size:{}:DNSSEC({}):{}'.format(server, dnssec, size))
return size
def update_sizes(self):
self.size_ipv4 = self._update_size(self.ipv4, False)
self.size_ipv6 = self._update_size(self.ipv6, False)
self.size_ipv4_dnssec = self._update_size(self.ipv4, True)
self.size_ipv6_dnssec = self._update_size(self.ipv6, True)
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 domain_lookup():
r = Resolver()
r.timeout = r.lifetime = 8.0
while True:
try:
host = q_hosts.get(timeout=0.1)
print "[%s] host=> %s" % ("domain_lookup", host)
except:
break
_schema, _host, _path = parse_url(host)
try:
m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0])
if m:
q_targets.put({'file': '', 'url': host})
ips_to_scan.append(m.group(0))
else:
answers = r.query(_host.split(':')[0])
if answers:
q_targets.put({'file': '', 'url': host})
for _ in answers:
ips_to_scan.append(_.address)
except Exception, e:
lock.acquire()
print '[%s][Warning] Invalid domain:', (get_time(), host)
lock.release()
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 resolve():
"""Resolve a hostname using the resolver """
parser = ArgumentParser(description="DNS Client")
parser.add_argument("hostname", help="hostname to resolve")
parser.add_argument("--timeout",
metavar="time",
type=int,
default=5,
help="resolver timeout")
parser.add_argument("-c",
"--caching",
action="store_true",
help="Enable caching")
parser.add_argument("-t",
"--ttl",
metavar="time",
type=int,
default=0,
help="TTL value of cached entries (if > 0)")
args = parser.parse_args()
s = SocketWrapper(53)
s.start()
rc = RecordCache(3600)
resolver = Resolver(args.timeout, args.caching, args.ttl, s, rc)
hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname)
s.shutdown()
rc.write_cache_file()
print(hostname)
print([rr.rdata.address for rr in aliaslist])
print([rr.rdata.address for rr in ipaddrlist])
def dns_lookup(self, hostname, aux):
"""Performs DNS lookup action for the given hostname,
i.e. (in this case) IP address retrieval by hostname.
Args:
hostname: The effective hostname to look up for.
aux: The controller helper object instance.
Returns:
The IP address retrieved for the host analyzed
and the IP version (family) used to look up in DNS.
"""
resolver = Resolver()
# If the host doesn't have the A record (IPv4),
# trying to find its AAAA record (IPv6).
try:
addr = resolver.query(hostname, "A")[0] # <---+
ver = 4 # |
except Exception as e: # From the dnspython lib. --------+
try: # |
addr = resolver.query(hostname, "AAAA")[0] # <---+
ver = 6
except Exception as e:
addr = ver = aux._ERR_PREFIX
return (addr, ver)
def query_host_ns(hostname, rt="NS"):
try:
resolver = Resolver()
ns = resolver.query(hostname, rt)
except NXDOMAIN as e:
return []
except dns.resolver.NoAnswer:
return []
except dns.exception.Timeout:
return []
else:
ns_list = []
if(ns.rrset is not None):
for r in ns.rrset:
a_record = query_A_records(r.to_text())
if(a_record):
a_record = a_record[0]
ns_list.append(
{"ns":r.to_text(),
"ip":a_record.address
}
)
else:
ns_list.append(
{"ns":r.to_text(),
"ip":""
}
)
return ns_list
def test_check_query(self):
res = Resolver(5, False, 3600)
hostname, alias, ips = res.gethostbyname("nickstracke.xyz")
ip1 = ips[0].rdata.address
ip2 = socket.gethostbyname("nickstracke.xyz")
self.assertEqual(ip1, ip2)
res.shutdown()
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 _isitup(self, url, return_status=False, redirects=0):
valid_url = self._makeurl(url)
if Resolver is not None:
r = Resolver()
host = urlparse(valid_url).netloc.split(":")[0]
try:
r.query(host)
except NoAnswer:
return (False, valid_url, u"No DNS A/CNAME-records for that domain")
except NXDOMAIN:
return False, valid_url, u"No such domain"
try:
status, reason, data, headers = self._request(valid_url, "HEAD")
if 300 <= status < 400 and self._get_header(headers, "location"):
if redirects > self.redirect_limit:
return False, valid_url, u"Redirect limit reached"
return self._isitup(self._get_header(headers, "location"), return_status, redirects + 1)
up = status < 300
if return_status:
reason = u"%(status)d %(reason)s" % {u"status": status, u"reason": reason}
return up, valid_url, reason
except HTTPException:
return False, valid_url, u"Server is not responding"
def resolve():
"""Resolve a hostname using the resolver """
parser = ArgumentParser(description="DNS Client")
parser.add_argument("hostname", help="hostname to resolve")
parser.add_argument("--timeout",
metavar="time",
type=int,
default=5,
help="resolver timeout")
parser.add_argument("-c",
"--caching",
action="store_true",
help="Enable caching")
parser.add_argument("-t",
"--ttl",
metavar="time",
type=int,
default=0,
help="TTL value of cached entries (if > 0)")
args = parser.parse_args()
resolver = Resolver(args.timeout, args.caching, args.ttl, True)
(hostname, aliaslist,
ipaddrlist) = resolver.gethostbyname(args.hostname, '127.0.0.1')
print(hostname)
print(aliaslist)
print(ipaddrlist)
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 dns_cache_install():
try:
from dns import resolver as dnspython_resolver_module
from dns_cache.resolver import ExceptionCachingResolver
if not dnspython_resolver_module.default_resolver:
dnspython_resolver_module.default_resolver = ExceptionCachingResolver(
)
del dnspython_resolver_module
except ImportError:
pass
try:
from dns.resolver import (
LRUCache,
Resolver,
_resolver,
default_resolver,
override_system_resolver,
)
except ImportError:
return
if default_resolver:
if not default_resolver.cache:
default_resolver.cache = LRUCache()
resolver = default_resolver
elif _resolver and _resolver.cache:
resolver = _resolver
else:
resolver = Resolver()
resolver.cache = LRUCache()
override_system_resolver(resolver)
def takeOver(domain):
CNAME = []
A = []
results = []
resolver = Resolver()
resolver.timeout = 1
resolver.lifetime = 1
rrtypes = ["A", "CNAME"]
for r in rrtypes:
try:
answers = resolver.query(domain, r)
for answer in answers:
if r == "A":
A.append(answer.address)
if r == "CNAME":
CNAME.append(answer.target)
except (NXDOMAIN, NoAnswer, EmptyLabel, NoNameservers, Timeout,
DNSException):
pass
except Exception:
return None
results = identify(domain, A, CNAME)
return results
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 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 __init__(self):
self.resolver = Resolver()
self.resolver.use_edns(0, 0, 4096)
self.resolver.set_flags(flags.AD + flags.RD)
self.degraded = Resolver()
self.degraded.use_edns(0, 0, 4096)
self.degraded.set_flags(flags.CD + flags.RD)
def dns_resolver():
"""
dns解析器
"""
resolver = Resolver()
resolver.nameservers = config.resolver_nameservers
resolver.timeout = config.resolver_timeout
resolver.lifetime = config.resolver_lifetime
return resolver
def __init__(self, domain, basedir):
self.basedir = basedir
self.domain = domain
self.thread_num = 10
self.names_que = queue.Queue()
self.query_res = []
self.resolver = Resolver()
self.resolver.nameservers = config.resolver_nameservers
self.resolver.timeout = config.resolver_timeout
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 __init__(self, dns_hosts=None, dns_port=None, **kwargs):
self.dns_hosts = dns_hosts
self.dns_port = dns_port
self.resolver = Resolver()
if dns_hosts is not None:
self.resolver.nameservers = dns_hosts
if dns_port is not None:
self.resolver.port = dns_port
super(SRVResolverHTTPAdapter, self).__init__(**kwargs)
def dns_resolver():
"""
dns解析器
"""
resolver = Resolver()
resolver.nameservers = settings.resolver_nameservers
resolver.timeout = settings.resolver_timeout
resolver.lifetime = settings.resolver_lifetime
return resolver
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 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 get_resolver(server=None):
if server is None:
server = Server.self()
resolver = Resolver()
resolver.reset()
resolvconf = StringIO()
if server.ipv4:
resolvconf.write('nameserver %s\n' % (server.ipv4,))
if server.ipv6:
resolvconf.write('nameserver %s\n' % (server.ipv6,))
resolver.read_resolv_conf(resolvconf)
return resolver
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 verify_site(site_id, retry_count=1):
"""Celery task to verify site ownership"""
from .models import Site
site = Site.objects.get(pk=site_id)
key = site.get_verification_key()
valid = False
# Check header, content and files for the verification key in some common
# URL variations
for url_template in url_templates:
url = url_template % {'domain': site.domain, 'key': key}
resp = requests.get(url, timeout=10)
if not resp.ok:
continue
valid = valid or key in resp.headers.get("X-Guardhouse-Verify", "")
valid = valid or key in resp.content
if valid:
break
if not valid:
# Still not valid - check DNS
resolver = Resolver()
try:
result = resolver.query("%s.%s." % (key, site.domain), rdatatype.CNAME)
try:
for answer in result.response.answer:
for item in answer.items:
if (isinstance(item, rdtypes.ANY.CNAME.CNAME) and
"verify.guardhous.es" in item.target.to_text()):
valid = True
raise StopIteration()
except StopIteration:
pass
except NXDOMAIN:
# Domain doesn't exist - nothing we can do
pass
from .models import VERIFY_STATE
if valid:
site.verification_state = VERIFY_STATE.VERIFIED
site.save()
return True
if retry_count >= 4:
# We already tried 3 times - time to give up
site.verification_state = VERIFY_STATE.FAILED
site.save()
# Fall trough - retry
verify_site.retry(countdown=30, args=(site_id, retry_count + 1))
def __init__(self, **kwargs):
super(ResolverThread, self).__init__(name="qdns_resolver", **kwargs)
self.stop_event = threading.Event()
self.resolver = Resolver()
self.resolver.timeout = 5
self.nameservers = self.resolver.nameservers[:]
self.start()
def get_records(host, port, proto='tcp'):
resolver = Resolver()
resolver.set_flags(flags.AD + flags.RD)
name = '_{}._{}.{}'.format(port, proto, host)
try:
rrset = resolver.query(name, rdtype=rdatatype.TLSA)
except NXDOMAIN:
log.debug('No record found for %s', name)
raise
except NoNameservers:
log.debug('No unbroken server for resolving %s', name)
# It may be because there is a bad dnssec key
resolver.set_flags(flags.CD + flags.RD)
rrset = resolver.query(name, rdtype=rdatatype.TLSA)
log.debug('Without validation we have an answer: %s', rrset)
for record in rrset:
log.debug(record)
secure = rrset.response.flags & flags.AD == flags.AD
if not secure:
log.warn('Not DNSSEC signed!')
return TLSAValidator([r for r in rrset], secure)
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 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 __init__(self, name, nameservers=['8.8.8.8', '4.4.4.4',]):
super(Domain, self).__init__()
self.name = unicode(name, 'utf-8').encode('idna')
self.nameservers = []
self.a_records = []
self.mx_records = []
self.ns_records = []
self.resolver = Resolver(configure=True)
self.resolver.nameservers = nameservers
self.resolve()
def __init__(self, signup_list, result_queue):
URLGetter.__init__(self, signup_list, result_queue)
self.c = pycurl.Curl()
self.c.setopt(pycurl.WRITEDATA, self.fp)
self.c.setopt(pycurl.MAXCONNECTS, 1)
self.c.setopt(pycurl.SSL_VERIFYHOST, 0)
self.c.setopt(pycurl.SSL_VERIFYPEER, 0)
self.c.setopt(pycurl.NOSIGNAL, 1)
self.headers = []
self.dns = None
self.resolver = Resolver(configure=False)
def dns_query_function(server=None):
'''
Return a dns query function using the given DNS server address, or
getaddrinfo if none is given.
'''
if server:
from dns.resolver import Resolver, Cache
resolver = Resolver(configure=False)
resolver.cache = Cache()
resolver.nameservers.append(server)
def dns_query(host):
for rr in resolver.query(host):
return rr.address
else:
import socket
def dns_query(host):
for family, socktype, proto, canonname, sockaddr in \
socket.getaddrinfo(host, 0):
return sockaddr[0]
return dns_query
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 __init__(self, ips, query = DEFAULT_QUERY, expected = DEFAULT_IP, threadnum = 500, verbose = 0, recordType = "TXT", includeTimeouts = False ):
self.resolver = Resolver()
self.resolver.timeout=1
self.resolver.lifetime=1
self.query = query
self.expected = expected
self.openresolvers = [] # [address, ...]
self.errors = [] # [(address, errcode), ...]
self.ips = ips
self.threadnum = threadnum
self.verbose = verbose
self.recordType = recordType
self.includeTimeouts = includeTimeouts
def resolve(self, name, rrtype):
domain = dns.name.from_text(name)
dnsResolver = Resolver()
dnsResolver.lifetime = 5
# just an example
result = ''
try:
answers = dnsResolver.query(domain, rrtype)
for answer in answers:
if rrtype == 'MX':
result = answer.exchange
logging.debug('%s is %s' % (rrtype, result))
else:
raise Exception("unsupported type!")
except DNSException as ex:
logging.error("resolve() DNSException: %s" % ex.__class__)
raise Exception(ex.__class__)
except Exception as ex:
logging.error("resolve() exception: %s" % ex)
raise ex
return result
class ResolverThread(threading.Thread):
def __init__(self, **kwargs):
super(ResolverThread, self).__init__(name="qdns_resolver", **kwargs)
self.stop_event = threading.Event()
self.resolver = Resolver()
self.resolver.timeout = 5
self.nameservers = self.resolver.nameservers[:]
self.start()
def gethostsbyname(self, name):
""" собираем ответы от всех серверов в один список """
result = []
for server in self.nameservers:
self.resolver.nameservers = [server]
try:
res = map(str, self.resolver.query(name))
result.extend(res)
except Exception as err:
pass
return name, sorted(set(result))
def run(self):
while True:
if (self.stop_event.is_set() or stop_all.is_set()) and (
not finish_queues or (finish_queues and to_resolve.empty())
):
break
try:
method, arg, callback, kwargs = to_resolve.get(block=True, timeout=2)
result = cache.get(arg)
if not result:
try:
if method == "getaddrinfo":
result = socket.getaddrinfo(arg, None)
elif method == "gethostsbyname":
result = self.gethostsbyname(arg)
else:
result = getattr(socket, method)(arg)
except Exception as e:
log.error("%s failed: %s: %s", method, e.__class__.__name__, str(e))
if result:
cache.put(arg, result)
resolved.put((callback, result, kwargs), block=True)
except Queue.Empty:
pass
except Exception as e:
log.error("Misc. failure in name resolution: %s: %s", e.__class__.__name__, str(e))
def __init__(self, service_uri, nameservers=None):
"""
:param service_uri: string formatted service identifier
(consul://production.solr_service.consul)
:param nameservers: use custom nameservers
:type nameservers: list
"""
assert service_uri.startswith('consul://'), "Invalid consul service URI"
self.service_uri = service_uri
self.service = service_uri.replace('consul://', '')
self.resolver = Resolver()
self.session = requests.Session()
if nameservers is not None:
self.resolver.nameservers = nameservers
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 domain_lookup():
r = Resolver()
r.timeout = r.lifetime = 8.0
while True:
try:
host = q_hosts.get(timeout=0.1)
except:
break
_schema, _host, _path = parse_url(host)
try:
m = re.search('\d+\.\d+\.\d+\.\d+', _host.split(':')[0])
if m:
q_targets.put({'file': '', 'url': host})
ips_to_scan.append(m.group(0))
else:
answers = r.query(_host.split(':')[0])
if answers:
q_targets.put({'file': '', 'url': host})
for _ in answers:
ips_to_scan.append(_.address)
except Exception, e:
lock.acquire()
print '[%s][Warning] Invalid domain:', (get_time(), host)
lock.release()
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