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 _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(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 CustomResolver(object):
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 query(self, fqdn, rdatatype=rdt.A, degraded=False):
log.debug('Query %s %s', fqdn, rdatatype)
try:
return self.resolver.query(fqdn, rdatatype)
except NoNameservers:
if degraded:
return self.degraded.query(fqdn, rdatatype)
raise
except NXDOMAIN:
if degraded:
return self.degraded.query(fqdn, rdatatype)
return None
def srv(self, name, domainname, proto='tcp'):
fqdn = '_{}._{}.{}'.format(name, proto, domainname)
return self.query(fqdn, rdt.SRV)
def tlsa(self, hostname, port, proto='tcp'):
fqdn = '_{}._{}.{}'.format(port, proto, hostname)
return self.query(fqdn, rdt.TLSA)
def mx(self, domainname):
return self.query(domainname, rdt.MX)
def smugmug(domain, ARecords, CNAME):
outcome = []
try:
if get("http://" + domain, headers=headers).status_code == 404:
outcome = ["Smugmug", domain, CNAME]
return outcome
except Exception:
pass
try:
if get("https://" + domain, headers=headers,
verify=False).status_code == 404:
outcome = ["Smugmug", domain, CNAME]
return outcome
except Exception:
pass
resolver = Resolver()
resolver.timeout = 1
resolver.lifetime = 1
try:
resolver.query(CNAME)
except NXDOMAIN:
outcome = ["Smugmug", domain, CNAME]
return outcome
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 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 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 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 _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(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_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 add_domain_email(request):
if request.method == 'GET':
form = MailDomainForm()
return render_to_response(
'userdash_add_domain_email.html', {
'user_balance': get_balance(request),
'form': form,
'menu_email': 'active'
}, RequestContext(request))
else:
form = MailDomainForm(request.POST)
if form.is_valid():
try:
local_resolver = Resolver()
name_servers = local_resolver.query(request.POST.get('domain'),
'NS')
uncached_resolver = Resolver(configure=False)
for i in name_servers:
try:
authentic_address = local_resolver.query(str(i), 'A')
uncached_resolver.nameservers.append(
str(authentic_address[0]))
except: # one of the servers was broken?
pass
address = uncached_resolver.query(request.POST.get('domain'),
'MX')
except:
return HttpResponseRedirect(
'/dashboard-cust/email/error-domain')
try:
exchanger = str(address[0])
if not exchanger.endswith(
'bsmsite.com.'
): # NOTE: srv.bsmsite.com and mail.bsmsite.com are both valid
return HttpResponseRedirect(
'/dashboard-cust/email/error-domain')
except:
return HttpResponseRedirect(
'/dashboard-cust/email/error-domain')
instance = MailDomain(user=request.user,
domain=request.POST.get('domain'),
notes=request.POST.get('notes'))
instance.save()
return HttpResponseRedirect('/dashboard-cust/email/domain')
else:
return render_to_response(
'userdash_add_domain_email.html', {
'user_balance': get_balance(request),
'form': form,
'menu_email': 'active'
}, RequestContext(request))
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 test_remove_tsig(minion, resolver: Resolver):
with knotc() as knot:
with knot.zone_edit("example.org"):
knot.set('_acme-challenge 120 TXT "secret"')
minion.mods["acme_dns.remove"](
"example.org",
[{"name": "example.org", "token": "secret"}],
nameserver="127.0.0.153",
tsig="hmac-sha256:acme:opCLn9NMrbY0xKB8lWs2KM2lgQsEW5LdvsVtxnoRJIo=",
)
with pytest.raises(dns.resolver.NXDOMAIN):
resolver.query("_acme-challenge.example.org.", TXT)
def test_remove_zone(minion, resolver: Resolver):
with knotc() as knot:
with knot.zone_edit("example.com"):
knot.set('_acme-challenge 120 TXT "secret"')
minion.mods["acme_dns.remove"](
"default",
[{"name": "example.com", "token": "secret"}],
nameserver="127.0.0.153",
zone="example.com",
)
with pytest.raises(dns.resolver.NXDOMAIN):
resolver.query("_acme-challenge.example.org.", TXT)
def findNX(domainToTry):
resolver = Resolver()
resolver.timeout = 1
resolver.lifetime = 1
try:
resolver.query(domainToTry)
except NXDOMAIN:
return True
except Exception:
pass
return False
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 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 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 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 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 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 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 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 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 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 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 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 takeOver(domain):
A = []
CNAME = []
results = []
resolver = Resolver()
resolver.timeout = 1
resolver.lifetime = 1
types = ["A", "CNAME"]
for type in types:
try:
answers = resolver.query(domain, type)
for answer in answers:
if type == "A":
A.append(answer.address)
if type == "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 _request_from_others(self, id: UUID) -> Buffer:
if _g_service_name is None:
raise NotImplementedError
print(f'Asking other hosts for {id}')
resolver = Resolver()
hosts = []
for answer in resolver.query(f'tasks.{_g_service_name}.'):
answer = str(answer)
hosts.append(answer)
print(f'Got hosts: {hosts!r}')
executor = ThreadPoolExecutor(max_workers=len(hosts))
futures = []
for host in hosts:
future = executor.submit(self._make_request, host, id)
futures.append(future)
for future in as_completed(futures):
try:
data = future.result()
except:
continue
else:
break
for future in futures:
future.cancel()
print(f'Done! Buffer = ', data[0], data[1], data[2], data[3])
return Buffer(id, data)
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 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,
}
class SRVResolverHTTPAdapter(HTTPAdapter):
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 get_connection(self, url, proxies=None):
parsed = urlparse(url)
host, port = self._resolve_srv(parsed.netloc)
redirected_url = urlunparse(
(resolve_scheme(parsed.scheme), '%s:%d' % (host, port),
parsed.path, parsed.params, parsed.query, parsed.fragment))
return super(SRVResolverHTTPAdapter,
self).get_connection(redirected_url, proxies=proxies)
def _resolve_srv(self, service):
try:
answers = self.resolver.query(service, 'SRV')
except DNSException as e:
raise ConnectionError('DNS error: ' + e.__class__.__name__)
return answers[0].target, answers[0].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 get_dnsname(ipaddress):
myresolve = Resolver()
a = from_address(ipaddress)
name = myresolve.query(a, 'PTR')[0]
return str(name)[:-1]
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 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 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 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 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 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 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
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 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 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 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 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
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()
class PyCurlURLGetter(URLGetter):
name = "pycurl"
fp = open(_null_file, "wb")
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 set_rate_limit(self, n):
self.c.setopt(pycurl.MAX_RECV_SPEED_LARGE, int(n))
def set_headers(self, h):
self.headers = h
self.c.setopt(pycurl.HTTPHEADER, self.headers)
def set_debug(self, f):
self.c.setopt(pycurl.VERBOSE, int(f))
def set_timeout(self, n):
LOG.debug("%s set_timeout %d", self._Thread__name, n)
self.c.setopt(pycurl.TIMEOUT, int(n))
def set_dns(self, dns):
self.dns = dns
def set_keepalive(self, f):
if f:
self.headers += ["Connection: Keep-Alive"]
self.c.setopt(pycurl.HTTPHEADER, self.headers)
self.c.setopt(pycurl.FORBID_REUSE, 0)
self.c.setopt(pycurl.FRESH_CONNECT, 0)
else:
self.c.setopt(pycurl.FORBID_REUSE, 1)
self.c.setopt(pycurl.FRESH_CONNECT, 1)
def close(self):
self.c.close()
def get_url(self, url):
if self.dns:
self.resolver.nameservers = [self.dns]
u = urlparse.urlparse(url)
qname = u.hostname
answer = self.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]))
self.c.setopt(pycurl.HTTPHEADER, self.headers + ["Host: %s" % qname])
url = str(url)
self.c.setopt(pycurl.URL, url)
try:
self.c.perform()
except Exception, e:
# to avoid hogging the CPU in case of repeated errors
time.sleep(0.1)
LOG.warn("curl barfed on '%s': %s", url, e)
status = self.c.getinfo(pycurl.RESPONSE_CODE)
size = self.c.getinfo(pycurl.SIZE_DOWNLOAD)
t_total = self.c.getinfo(pycurl.TOTAL_TIME)
t_connect = self.c.getinfo(pycurl.CONNECT_TIME)
t_start = self.c.getinfo(pycurl.STARTTRANSFER_TIME)
t_proc = t_total - t_connect
return Result(t_total, size, status, detail_time=(t_connect, t_proc, t_start))
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)
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))
class ConsulService(object):
"""
Container for a consul service record
Example:
# Consul advertises a service called FOO that is reachable via two URIs:
# http://10.1.1.1:8001 and http://10.1.1.2:8002
cs = ConsulService("consul://tag.FOO.service")
# Set the DNS nameserver to the default docker0 bridge ip
cs = ConsulService("consul://tag.FOO.server", nameservers=['172.17.42.1'])
# returns a random choice from the DNS-advertised routes
# in our case, either http://10.1.1.1:8001 or http://10.1.1.2:8002
cs.base_url
# send an http-get to base_url+'/v1/status', re-resolving and
# re-retrying if that connection failed
cs.get('/v1/status')
#Subsequent http requests will now have the "X-Added" header
cs.session.headers.update({"X-Added": "Value"})
cs.post('/v1/status')
"""
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 _resolve(self):
"""
Query the consul DNS server for the service IP and port
"""
endpoints = {}
r = self.resolver.query(self.service, 'SRV')
for rec in r.response.additional:
name = rec.name.to_text()
addr = rec.items[0].address
endpoints[name] = {'addr': addr}
for rec in r.response.answer[0].items:
name = '.'.join(rec.target.labels)
endpoints[name]['port'] = rec.port
return [
"http://{ip}:{port}".format(
ip=v['addr'], port=v['port']
) for v in endpoints.values()
]
@property
def base_url(self):
"""
get the next endpoint from self.endpoints
"""
return self._resolve().pop()
@with_retry_connections()
def request(self, method, endpoint, **kwargs):
"""
Proxy to requests.request
:param method: str formatted http method
:param endpoint: service endpoint
:param kwargs: kwargs passed directly to requests.request
:return:
"""
kwargs.setdefault('timeout', (1, 30))
return self.session.request(
method,
urljoin(self.base_url, endpoint),
**kwargs
)
def get(self, endpoint, **kwargs):
return self.request('GET', endpoint, **kwargs)
def post(self, endpoint, **kwargs):
return self.request('POST', endpoint, **kwargs)
def delete(self, endpoint, **kwargs):
return self.request('DELETE', endpoint, **kwargs)
def put(self, endpoint, **kwargs):
return self.request('PUT', endpoint, **kwargs)
def options(self, endpoint, **kwargs):
return self.request('OPTIONS', endpoint, **kwargs)
def head(self, endpoint, **kwargs):
return self.request('HEAD', endpoint, **kwargs)
def dns_query(input="", query_type="", server="", timeout=2.0):
"""A unified IPv4 & IPv6 DNS lookup interface; this is essentially just a wrapper around dnspython's API. When you query a PTR record, you can use an IPv4 or IPv6 address (which will automatically be converted into an in-addr.arpa name. This wrapper only supports a subset of DNS records: 'A', 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', and 'TXT'
Kwargs:
- input (str): A string containing the DNS record to lookup
- query_type (str): A string containing the DNS record type (SOA not supported)
- server (str): A string containing the fqdn or IP address of the dns server
- timeout (float): DNS lookup timeout duration (default: 2.0 seconds)
Returns:
A set() of :class:`~ccp_util.DNSResponse` instances
>>> from ciscoconfparse.ccp_util import dns_query
>>> dns_query('www.pennington.net', "A", "4.2.2.2")
set([<DNSResponse "A" result_str="65.19.187.2">])
>>> answer = dns_query('www.pennington.net', 'A', '4.2.2.2')
>>> str(answer.pop())
'65.19.187.2'
>>>
"""
valid_records = set(['A', 'AAAA', 'AXFR', 'CNAME', 'MX', 'NS', 'PTR',
'TXT'])
query_type = query_type.upper()
assert query_type in valid_records
assert server!=""
assert float(timeout)>0
assert input != ""
intput = input.strip()
retval = set([])
resolver = Resolver()
resolver.server = [socket.gethostbyname(server)]
resolver.timeout = float(timeout)
resolver.lifetime = float(timeout)
start = time.time()
if (query_type=="A") or (query_type=="AAAA"):
try:
answer = resolver.query(input, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
duration=duration,
input=input, result_str = str(result.address))
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input,
duration=duration, query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
elif query_type=="AXFR":
"""This is a hack: return text of zone transfer, instead of axfr objs"""
_zone = zone.from_xfr(query.xfr(server, input, lifetime=timeout))
return [_zone[node].to_text(node) for node in _zone.nodes.keys()]
elif query_type=="CNAME":
try:
answer = resolver.query(input, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
duration=duration,
input=input, result_str = str(result.target))
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input, duration=duration,
query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
elif query_type=="MX":
try:
answer = resolver.query(input, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
input=input, result_str = str(result.target))
response.preference = int(result.preference)
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input, duration=duration,
query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
elif query_type=="NS":
try:
answer = resolver.query(input, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
duration=duration,
input=input, result_str = str(result.target))
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input,
duration=duration, query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
elif query_type=="PTR":
if is_valid_ipv4_addr(input) or is_valid_ipv6_addr(input):
inaddr = reversename.from_address(input)
elif 'in-addr.arpa' in input.lower():
inaddr = input
else:
raise ValueError('Cannot query PTR record for "{0}"'.format(input))
try:
answer = resolver.query(inaddr, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
duration=duration,
input=inaddr, result_str = str(result.target))
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input,
duration=duration,
query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
elif query_type=="TXT":
try:
answer = resolver.query(input, query_type)
duration = time.time() - start
for result in answer:
response = DNSResponse(query_type=query_type,
duration=duration,
input=inaddr, result_str = str(result.strings))
retval.add(response)
except DNSException as e:
duration = time.time() - start
response = DNSResponse(input=input,
duration=duration, query_type=query_type)
response.has_error = True
response.error_str = e
retval.add(response)
return retval
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))
if q[ct].lower() in record_types:
rtype = q[ct].lower()
ct+=1
if rtype == '' or record == '':
continue
if not queries.has_key(record):
queries[record] = []
if rtype not in queries[record]:
queries[record].append(rtype)
print queries
dns_server1 = []
dns_server2 = []
for server in dns1:
try:
for item in sys_r.query(server):
dns_server1.append(item.address)
except NXDOMAIN:
dns_server1.append(server)
for server in dns2:
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 = []
