def test_domain_validation(self, query_mock):
task = HostingAddSecureCustomDomainTask
task.instance = self.instance
query_mock.return_value = []
self.assertRaises(WrongCName, task.validate_domain, TEST_DOMAIN)
query_mock.assert_called_once_with(TEST_DOMAIN, 'CNAME')
query_mock.side_effect = NoAnswer()
query_mock.reset_mock()
self.assertRaises(CNameNotSet, task.validate_domain, TEST_DOMAIN)
query_mock.assert_called_once_with(TEST_DOMAIN, 'CNAME')
query_mock.reset_mock(side_effect=True)
query_mock.return_value = [
Munch(target=Munch(to_unicode=lambda: 'cname.response.'))
]
self.assertRaises(WrongCName, task.validate_domain, TEST_DOMAIN)
query_mock.reset_mock()
expected_cname = '{}{}.'.format(self.instance.name,
settings.HOSTING_DOMAIN)
query_mock.return_value = [
Munch(target=Munch(to_unicode=lambda: expected_cname))
]
# This should not raise any error
task.validate_domain(TEST_DOMAIN)
def test_get_no_answer(self):
with mock.patch('dns.resolver.query') as query:
query.side_effect = NoAnswer()
with app.flask_app.test_client() as client:
response = client.get('/mxrecords/example.com')
json_data = response.get_json()
self.assertEqual(json_data['exception'],
'NoAnswer -- mx record not found')
self.assertEqual(response.status_code, 500)
self.assertRaises(exceptions.InternalServerError)
def fake_query(qname,
rdtype=rdatatype.A,
rdclass=rdataclass.IN,
count=1,
fake_txt=False):
"""Fake a DNS query, returning count responses to the request
Three kinds of lookups are faked:
1. A query for A records for a service will return the count
as requested in the test. This simulates lookups for the
ipa-ca A record. To force a difference in responses one can
vary the count.
2. AAAA records are not yet supported, return no answer
3. TXT queries will return the Kerberos realm
fake_txt will set an invalid Kerberos realm entry to provoke a
warning.
"""
m = message.Message()
if rdtype == rdatatype.A:
fqdn = DNSName(qname)
fqdn = fqdn.make_absolute()
answers = Answer(fqdn,
rdataclass.IN,
rdatatype.A,
m,
raise_on_no_answer=False)
rlist = rrset.from_text_list(fqdn, 86400, rdataclass.IN, rdatatype.A,
gen_addrs(count))
answers.rrset = rlist
elif rdtype == rdatatype.AAAA:
raise NoAnswer(response=Response('no AAAA'))
elif rdtype == rdatatype.TXT:
if fake_txt:
realm = 'FAKE_REALM'
else:
realm = m_api.env.realm
qname = DNSName('_kerberos.' + m_api.env.domain)
qname = qname.make_absolute()
answers = Answer(qname,
rdataclass.IN,
rdatatype.TXT,
m,
raise_on_no_answer=False)
rlist = rrset.from_text_list(qname, 86400, rdataclass.IN,
rdatatype.TXT, [realm])
answers.rrset = rlist
return answers
def test_record_NoAnswer(self):
"""
Tests the method which let us get the PTR record for the case that
we get a NoAnswer exception.
"""
self.dns_lookup.resolver.query = Mock(side_effect=NoAnswer())
expected = None
actual = self.dns_lookup.ptr_record(self.subject)
self.assertEqual(expected, actual)
def ip(self):
# Determine the domain's IP address
try:
req = query(self.dom)
except NXDOMAIN:
raise NXDOMAIN("Check if %r exists." % self.dom)
except NoNameservers:
raise NoNameservers('No Nameservers found for domain: %r' %
self.dom)
except NoAnswer:
raise NoAnswer('No IP available for domain: %s' % self.dom)
self.addr = [str(ip.address) for ip in req]
def test_record_wrong_format(self):
"""
Tests the methods which let us query the PTR record
for the case that the wrong format is given.
"""
self.dns_lookup.resolver.resolve = Mock(side_effect=NoAnswer())
expected = None
actual = self.dns_lookup.ptr_record(self.subject)
self.assertEqual(expected, actual)
def lookup(domain):
'Lookup if domain is using CDN. This is "bad" CDN lookup coz it use known CDN list to find if the domain use CDN.'
print('Looking up via DNS..')
CDNs = []
print('Checking Multiple IP...')
try:
asw = query(domain)
except NXDOMAIN:
raise NXDOMAIN("Are you sure %r exist?" % domain)
except NoNameservers:
raise NoNameservers('No nameserver found for %r' % domain)
except NoAnswer:
raise NoAnswer('No IP for %s!' % domain)
print('Found IP: %s' % [str(a.address) for a in asw])
#print('Probably %s is using CDN (maybe :P)!'%domain)
# check whether domain is using CNAME (but doesn't mean it's use CDN..)
print('Checking CNAME...')
try:
asw = query(domain, 'cname')
domains = [a.to_text() for a in asw]
print('Found that %s have another domains: %s' %
(domain, ','.join(domains)))
for d in domains:
cdn_found = find_cdn(d)
if cdn_found:
print('Got CDN from CNAME!')
if cdn_found not in CDNs:
CDNs.append(cdn_found)
except NoAnswer as err:
print('No CNAME found!')
print('Checking NS...')
try:
asw = query(domain, 'ns')
print('Found Nameservers: %s' % ','.join([a.to_text() for a in asw]))
except NoAnswer:
print('No Nameserver? Perhaps you can try SOA query instead')
else:
print('Checking CDN from NS..')
for a in asw:
ns = a.to_text()
cdn_found = find_cdn(ns)
if cdn_found:
print('Got CDN from NS!')
if cdn_found not in CDNs:
CDNs.append(cdn_found)
if CDNs:
print('CDN used by %s : %s' % (domain, ','.join(CDNs)))
else:
print('No CDN used by %s' % domain)
def test_passes_dns_exception_to_raised_error(mocker):
stub_no_answer = NoAnswer()
mocker.patch('lets_do_dns.dns_tools.lookup.query',
side_effect=stub_no_answer)
mock_lookup_error = mocker.patch(
'lets_do_dns.dns_tools.lookup.RecordLookupError',
autospec=True,
return_value=RecordLookupError)
with pytest.raises(RecordLookupError):
lookup('stub-host.stub-domain')
mock_lookup_error.assert_called_once_with(stub_no_answer)
def asn_to_name(as_number: Union[int, str], quiet: bool = True) -> str:
"""
Look up an integer Autonomous System Number and return the human readable
name of the organization.
Usage:
>>> asn_to_name(210083)
'PRIVEX, SE'
>>> asn_to_name('13335')
'CLOUDFLARENET - Cloudflare, Inc., US'
This helper function requires ``dnspython>=1.16.0``, it will not be visible unless
you install the dnspython package in your virtualenv, or systemwide::
pip3 install dnspython
:param int/str as_number: The AS number as a string or integer, e.g. 210083 or '210083'
:param bool quiet: (default True) If True, returns 'Unknown ASN' if a lookup fails.
If False, raises a KeyError if no results are found.
:raises KeyError: Raised when a lookup returns no results, and ``quiet`` is set to False.
:return str as_name: The name and country code of the ASN, e.g. 'PRIVEX, SE'
"""
try:
res = Resolver().query('AS{}.asn.cymru.com'.format(as_number),
"TXT")
if len(res) > 0:
# res[0] is formatted like such: "15169 | US | arin | 2000-03-30 | GOOGLE - Google LLC, US" with
# literal quotes. we need to strip them, split by pipe, extract the last element, then strip spaces.
asname = str(res[0]).strip('"').split('|')[-1:][0].strip()
return str(asname)
raise NoAnswer(
'privex.helpers.net.asn_to_name returned no results.')
except (NoAnswer, NXDOMAIN):
if quiet:
return 'Unknown ASN'
raise KeyError(
'ASN {} was not found, or server did not respond.'.format(
as_number))
def A(domain):
'this func sometime helpful :)'
print('Checking Multiple IP...')
try:
asw = query(domain)
except NXDOMAIN:
raise NXDOMAIN("Are you sure %r exist?" % domain)
except NoNameservers:
raise NoNameservers('No nameserver found for %r' % domain)
except NoAnswer:
raise NoAnswer('No IP for %s!' % domain)
print('Found IP: %s' % [str(a.address) for a in asw])
print('Checking CNAME...')
try:
asw = query(domain, 'cname')
domains = [a.to_text() for a in asw]
print('Found that %s have another domains: %s' %
(domain, ','.join(domains)))
except Exception as e:
print(e)
print()
def test_rbl():
""" handles failure ok, and handles lookups ok with dns module.
"""
import mock
from dns.resolver import NoAnswer, NXDOMAIN, NoNameservers
from pygameweb.user.rbl import rbl
assert rbl('127.0.0.1') is False
assert rbl('') is False
with mock.patch('dns.resolver.query') as query:
query.side_effect = NoAnswer()
assert rbl('192.168.0.1') is False
query.side_effect = NXDOMAIN()
assert rbl('192.168.0.1') is False
query.side_effect = NoNameservers()
assert rbl('192.168.0.1') is False
with mock.patch('dns.resolver.query') as query:
query.side_effect = '127.0.0.2'
assert rbl('192.168.0.1') is True
assert query.called
_BAD_MX_RECORD = MX("IN", "MX", 10,
Name("bad-response.example.com".split(".")))
_DNE_MX_RECORD = MX("IN", "MX", 10,
Name("does-not-exist.example.com".split(".")))
_MX_RECORDS = [_MX_RECORD_1]
_IP_SET_RECORDS = [RRset()]
_IPV4_RECORD_1 = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("192.0.2.1", 25))
_IPV4_RECORD_2 = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("192.0.2.2", 25))
_IPV6_RECORD = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("2001:db8::1", 25))
_BAD_IP_RECORD = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("BAD", 25))
_IP_RECORDS = [_IPV4_RECORD_1, _IPV6_RECORD]
_POSSIBLE_DNS_RESULTS = {
"test3.com": [_MX_RECORD_2],
"no-mx.example.com": NoAnswer(),
"does-not-exist.example.com": NXDOMAIN(),
"timeout.example.com": Timeout(),
"no-ns-servers.example.com": NoNameservers(),
"bad-response.example.com": [_BAD_MX_RECORD],
"no-lookup.example.com": [_DNE_MX_RECORD],
"no-answer.example.com": [_DNE_MX_RECORD],
"dns-checks.com": [_MX_RECORD_2],
"invalid-mx.com": [_MX_RECORD_3]
}
_POSSIBLE_DNS_RESULTS_NO_MX = {
"does-not-exist.example.com": NXDOMAIN(),
"mx2.example.com": NXDOMAIN(),
"no-lookup.example.com": NXDOMAIN(),
"no-answer.example.com": NoAnswer(),
