def hello(request): if request.is_ajax(): try: domain = request.GET['input_text'] record_type = request.GET['record_type'] # print(domain, record_type) if record_type == 'AAAA' or record_type == 'PTR': resp_from_googledns = pydig.query(str(domain), str(record_type)) # print(resp_from_googledns, 'if work') else: resp_from_googledns = request_to_googledns(request_data = { "name_": domain, "type_": record_type }) #sleep(0.1) resolver = pydig.Resolver( executable='/usr/bin/dig', nameservers=[ '92.53.116.26' #ns timeweb ]) response_from_timeweb_dns = pydig.query(str(domain), str(record_type)) return JsonResponse({'response': resp_from_googledns, 'response_from_timeweb_dns':response_from_timeweb_dns}, status = 200) except Exception as err: html = f"Error {err}." print(html) return JsonResponse({'response':html, }, status = 200) else: html = "Error." return JsonResponse({'response':html, }, status = 500)
def run(config, nameservers): """ Simple program that greets NAME for a total of COUNT times. """ click.secho('Using config: {}'.format(config)) # Load our config from disk try: config = load_validated_yaml(config) except InvalidConfig as e: click.secho(str(e), fg='red', err=True) return # Use the cli nameservers or whatever was defined in the config nameservers = nameservers or config.get('nameservers') if nameservers: click.secho('Using nameservers: {}'.format(', '.join(nameservers))) # Setup out custom resolver with our nameservers resolver = pydig.Resolver(nameservers=nameservers) # Default exit code is a success exit_code = 0 # Loop over the loaded checks for check in config['checks']: # Convert to our check object check = Check(**check) # Log that we are running this check click.secho(str(check), nl=False) # Run all the tests for check results = list(check(resolver)) # Number of successful tests success = results.count(None) # Get any errors out of the results errors = list(filter(None, results)) # Print a dot for each successful test click.secho(' ' + '.' * success, fg='green', nl=False) # Print a F for each failed test click.secho(' ' + 'F' * len(errors), fg='red') # Loop over each error message for error in errors: exit_code = 1 click.secho(str(error), fg='red', err=True) exit(exit_code)
def _get_pydig_result(_domain: str) -> Union[NoReturn, dict]: resolver = pydig.Resolver( nameservers=[ "80.67.169.40", "80.67.169.12", ], additional_args=additional_args, ) return resolver.query(_domain, query_type)
async def _dig(self, ctx, domain, querytype="abc", dnssec="no"): if querytype not in [ 'A', 'AAAA', 'CNAME', 'NS', 'DS', 'DNSKEY', 'SOA', 'TXT', 'PTR', 'MX' ]: await ctx.send( "Requêtes supportées : A, AAAA, CNAME, NS, DS, DNSKEY, SOA, TXT, PTR, MX" ) return if (dnssec == "no"): resolver = pydig.Resolver(nameservers=[ '80.67.169.40', '80.67.169.12', ]) else: resolver = pydig.Resolver(nameservers=[ '80.67.169.40', '80.67.169.12', ], additional_args=[ '+dnssec', ]) resquery = resolver.query(domain, querytype) embed = discord.Embed( title=f"Requête DIG sur {domain} pour une entrée {querytype}", color=0x5858d7) champ_id = 1 for champ in resquery: embed.add_field(name=f"Champ {champ_id} :", value=champ) champ_id = champ_id + 1 if champ_id == 1: embed.add_field(name="Ooops", value="Pas de résultat") await ctx.send(embed=embed)
def main(record_type, domain): errors = [] for ns in nameservers: resolver = pydig.Resolver(nameservers=[ns]) resp = set(resolver.query(domain, record_type)) if len(resp) == 0: errors.append(f"Response from the {ns} is empty") continue prevResp = resp for err in errors: print(err) if len(errors) == 0: print(f'All {len(nameservers)} nameservers responded!')
def test_custom_resolver(monkeypatch): """ Tests that the query returns the values we expect """ resolver = pydig.Resolver(executable='foo', nameservers=['1.1.1.1'], additional_args=['+time=10']) with _resolver(monkeypatch, 'foo @1.1.1.1 example.com A +short +time=10', '127.0.0.1'): assert resolver.query('example.com', 'A') == ['127.0.0.1'] with _resolver(monkeypatch, 'foo @1.1.1.1 example.com TXT +short +time=10', '"1"\n"2"'): assert resolver.query('example.com', 'TXT') == ['"1"', '"2"'] with _resolver(monkeypatch, 'foo @1.1.1.1 example.com CNAME +short +time=10', ''): assert resolver.query('example.com', 'CNAME') == []
def __init__(self): init(autoreset=True) self.target_list = list() self.lock = threading.Lock() self.domain_list = list() if args.stdin and not args.list: [ self.target_list.append(str(x)) for x in sys.stdin.read().split("\n") if x and self.control(x) ] if not self.target_list: print(Fore.RED + "Subdomains Not Found In Stdin") sys.exit() elif args.list and not args.stdin: if not os.path.exists(args.list): print(Fore.RED + "File Not Found:", args.list) sys.exit() with open(args.list, "r", encoding="utf-8") as f: [ self.target_list.append(x) for x in f.read().split("\n") if x and self.control(x) ] else: print( Fore.RED + """ \rYou Used The Wrong Parameter""", Fore.MAGENTA + """ \rUsage: \r------ \rpython3 DnsR.py --list subdomains.txt --output resolved.txt \rcat subdomains.txt | python3 DnsR.py --stdin --output resolved.txt \rpython3 DnsR.py --list subdomains.txt --blacklist 198,55,44,77 \rcat subdomains.txt | python3 DnsR.py --stdin --blacklist 198,55,44,77 \rpython3 DnsR.py --list subdomains.txt --thread 50 --blacklist 198,55,44,77,xx.example.com \rcat subdomains.txt | python3 DnsR.py --stdin --blacklist 198,55,44,77,xx.example.com """) sys.exit() self.target_list = list(set(self.target_list)) self.target_list.sort() self.resolver = pydig.Resolver(nameservers=[ '1.1.1.1', '1.0.0.1', '8.8.8.8', '8.8.4.4', '77.88.8.8', '77.88.8.1', '64.6.64.6', '64.6.65.6', '8.26.56.26', '8.20.247.20', '9.9.9.9', '149.112.112.112', '185.228.168.9', '185.228.169.9', '198.101.242.72', '23.253.163.53', '208.67.222.222', '208.67.220.220', '176.103.130.130', '176.103.130.131' ]) if args.blacklist: if not "," in args.blacklist: x = args.blacklist x = ".*" + x.replace(".", r"\.") + "*." self.BlackList = re.compile(x) else: x = args.blacklist.split(",") y = [] for i in x: if i: i = ".*" + i.replace(".", r"\.") + "*." y.append(i) req = ("|").join(y) self.BlackList = re.compile(req) xyz = self.target_list[0] tld = tldextract.extract(xyz).registered_domain query_ns = pydig.query(tld, "NS") if query_ns: self.ns_ip_address(query_ns) self.domain_list.append(tld) self.domain_list = tuple(self.domain_list) with ThreadPoolExecutor(max_workers=args.thread) as executor: for x in self.target_list: if not x.endswith(self.domain_list): r = tldextract.extract(x).registered_domain self.domain_list = list(self.domain_list) self.domain_list.append(r) self.domain_list = tuple(self.domain_list) query_ns = pydig.query(r, "NS") if query_ns: self.ns_ip_address(query_ns) executor.submit(self.resolve_subs, x)
class TestDNS(unittest.TestCase): real_resolver = pydig.Resolver( nameservers=['8.8.8.8', '8.8.4.4',], ) ext_resolver = pydig.Resolver( nameservers=['external',], ) int_resolver = pydig.Resolver( nameservers=['internal',], ) def select(self, what): for host in inv['hosts']: for record in inv['hosts'][host]: try: if what(record): yield host, record except: pass def test_cname_records(self): def is_cname(record): try: ipaddress.ip_address(record) return False except: pass return True for host, cname in self.select(is_cname): got = self.real_resolver.query(cname, "A") self.assertGreater(len(got), 0, f"Cannot resolve A for {cname} (required by {host}).") def test_a_records(self): for host, addr in self.select(lambda x: ipaddress.ip_address(x) and True): addr = ipaddress.ip_address(addr) if addr.version == 4: query_type = 'A' rev_record = '.'.join(reversed(str(addr).split('.'))) + '.in-addr.arpa' else: query_type = 'AAAA' rev_record = '.'.join(reversed(str(addr.exploded).replace(':',''))) + '.ip6.arpa' if addr.is_private: # Test internal resolution got = self.int_resolver.query(f'{host}.cis.cabrillo.edu', query_type) self.assertGreater(len(got), 0, f"Failed to resolve {host}") self.assertEqual(str(addr), got[0], "Resolution mismatch {addr} != {got[0]}") # External resolution should fail or give an external address got = self.ext_resolver.query(f'{host}.cis.cabrillo.edu', query_type) if len(got) > 0: self.assertNotEqual(str(addr), got[0], "Resolution mismatch {addr} == {got[0]}") # Test the reverse record got = self.int_resolver.query(rev_record, 'PTR') self.assertGreater(len(got), 0, f"Failed to reverse {host} {rev_record}") self.assertEqual(host + '.cis.cabrillo.edu.', got[0], "Reverse resolution mismatch {host} != {got[0]}") else: # Test external resolution got = self.ext_resolver.query(f'{host}.cis.cabrillo.edu', query_type) self.assertGreater(len(got), 0, f"Failed to resolve {host} {addr}") self.assertEqual(str(addr), got[0], "Resolution mismatch {host} != {got[0]}") # Test the reverse record # Have to mangle this record to match the funky CNAME used in reversing this subnet. rev_record = rev_record.replace('187.', '224-27.187.') got = self.ext_resolver.query(rev_record, 'PTR') self.assertGreater(len(got), 0, f"Failed to reverse {host} {rev_record}") self.assertTrue(host + ".cis.cabrillo.edu." in got, f"Reverse resolution mismatch {host} not in {got}") def test_internal_domains(self): for zone in ["cis.cabrillo.edu", "5.30.172.in-addr.arpa", "0.168.192.in-addr.arpa", "5.2.4.f.f.0.8.0.0.8.3.f.7.0.6.2.ip6.arpa", ]: got = self.int_resolver.query(zone, 'SOA') self.assertEqual(len(got), 1, f"Failed to resolve zone {zone}") # Test nameservers got = self.int_resolver.query(zone, 'NS') self.assertEqual(len(got), 2, f"Didn't get two nameservers in zone {zone}") got.sort() self.assertEqual(got[0], 'ns1.cis.cabrillo.edu.', f"Wrong nameserver in zone {zone}: {got[0]}") self.assertEqual(got[1], 'ns2.cis.cabrillo.edu.', f"Wrong nameserver in zone {zone}: {got[1]}") def test_external_domains(self): for zone in ["cis.cabrillo.edu", "224-27.187.62.207.in-addr.arpa", "5.2.4.f.f.0.8.0.0.8.3.f.7.0.6.2.ip6.arpa", ]: got = self.ext_resolver.query(zone, 'SOA') self.assertGreater(len(got), 0, f"Failed to resolve zone {zone}") # Test nameservers got = self.ext_resolver.query(zone, 'NS') self.assertEqual(len(got), 2, f"Didn't get two nameservers in zone {zone}: {got}") got.sort() self.assertEqual(got[0], 'ns1.cis.cabrillo.edu.', f"Wrong nameserver in zone {zone}: {got[0]}") self.assertEqual(got[1], 'ns2.cis.cabrillo.edu.', f"Wrong nameserver in zone {zone}: {got[1]}") def test_internal_forwards(self): got = self.int_resolver.query('www.google.com', 'A') self.assertGreater(len(got), 0, f"Internal zone did not forward a query.") def test_external_not_forwards(self): got = self.ext_resolver.query('www.google.com', 'A') self.assertEqual(len(got), 0, f"External zone DID forward a query.")