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.")