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