diff --git a/lib/dnsresolver.py b/lib/dnsresolver.py index 82f10f7..cfe4245 100644 --- a/lib/dnsresolver.py +++ b/lib/dnsresolver.py @@ -2,406 +2,44 @@ import json import time -import os, sys import requests -import animation import dns.resolver +import dns.exception from datetime import datetime - - -class Domaininfo(object): - +class DomainInfo: def __init__(self, url, resolver_ip): - super(Domaininfo, self).__init__() - self.url = url - self.A = [] - self.MX = [] - self.NS = [] - self.SOA = [] - self.PTR = [] - self.SRV = [] - self.CAA = [] - self.TXT = [] - self.AAAA = [] - self.CNAME = [] - self.GeoIP = 'https://geolocation-db.com/jsonp/' - self.time = datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%f%z') + self.url = url self.resolver = resolver_ip.nameservers[0] - try: - answers = resolver_ip.resolve(self.url, 'A') - self.A = [rdata.address for rdata in answers] - except dns.resolver.NXDOMAIN: - self.A_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.A_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.A_error = "NoAnswer" - except dns.exception.Timeout: - self.A_error = "Timeout" - except: - self.A = None - try: - answers = resolver_ip.resolve(self.url, 'NS') - for rdata in answers: - self.NS.append(rdata.to_text) - except dns.resolver.NXDOMAIN: - self.NS_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.NS_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.NS_error = "NoAnswer" - except dns.exception.Timeout: - self.NS_error = "Timeout" - except: - self.NS = None - try: - answers = resolver_ip.resolve(self.url, 'MX') - for rdata in answers: - self.MX.append(rdata.exchange) - except dns.resolver.NXDOMAIN: - self.MX_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.MX_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.MX_error = "NoAnswer" - except dns.exception.Timeout: - self.MX_error = "Timeout" - except: - self.MX = None - try: - answers = resolver_ip.resolve(self.url, 'AAAA') - for rdata in answers: - self.AAAA.append(rdata.address) - except dns.resolver.NXDOMAIN: - self.AAAA_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.AAAA_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.AAAA_error = "NoAnswer" - except dns.exception.Timeout: - self.AAAA_error = "Timeout" - except: - self.AAAA = None - try: - answers = resolver_ip.resolve(self.url, 'CNAME') - for rdata in answers: - self.CNAME.append(rdata.target) - except dns.resolver.NXDOMAIN: - self.CNAME_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.CNAME_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.CNAME_error = "NoAnswer" - except dns.exception.Timeout: - self.CNAME_error = "Timeout" - except: - self.CNAME = None - try: - answers = resolver_ip.resolve(self.url, 'TXT') - for rdata in answers: - self.TXT.append(rdata) - except dns.resolver.NXDOMAIN: - self.TXT_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.TXT_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.TXT_error = "NoAnswer" - except dns.exception.Timeout: - self.TXT_error = "Timeout" - except: - self.TXT = None - try: - answers = resolver_ip.resolve(self.url, 'SOA') - for rdata in answers: - self.SOA.append(rdata) - except dns.resolver.NXDOMAIN: - self.SOA_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.SOA_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.SOA_error = "NoAnswer" - except dns.exception.Timeout: - self.SOA_error = "Timeout" - except: - self.SOA = None - try: - answers = resolver_ip.resolve(self.url, 'PTR') - for rdata in answers: - self.PTR.append(rdata.target) - except dns.resolver.NXDOMAIN: - self.PTR_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.PTR_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.PTR_error = "NoAnswer" - except dns.exception.Timeout: - self.PTR_error = "Timeout" - except: - self.PTR = None - try: - answers = resolver_ip.resolve(self.url, 'SRV') - for rdata in answers: - self.SRV.append(rdata) - except dns.resolver.NXDOMAIN: - self.SRV_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.SRV_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.SRV_error = "NoAnswer" - except dns.exception.Timeout: - self.SRV_error = "Timeout" - except: - self.SRV = None - try: - answers = resolver_ip.resolve(self.url, 'CAA') - for rdata in answers: - self.CAA.append(rdata) - except dns.resolver.NXDOMAIN: - self.CAA_error = "NXDOMAIN" - except dns.resolver.NoNameservers: - self.CAA_error = "NoNameservers" - except dns.resolver.NoAnswer: - self.CAA_error = "NoAnswer" - except dns.exception.Timeout: - self.CAA_error = "Timeout" - except: - self.CAA = None + self.time = datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%f%z') + self.record_types = ['A', 'MX', 'NS', 'SOA', 'PTR', 'SRV', 'CAA', 'TXT', 'AAAA', 'CNAME'] + self.records = {rtype: [] for rtype in self.record_types} + self.errors = {rtype: None for rtype in self.record_types} + self.GeoIP = 'https://geolocation-db.com/jsonp/' + for rtype in self.record_types: + try: + answers = resolver_ip.resolve(self.url, rtype) + self.records[rtype] = [rdata.to_text() for rdata in answers] + except dns.exception.DNSException as e: + self.errors[rtype] = type(e).__name__ def Geo_ip(self): data = [] - for ip in self.A: + for ip in self.records['A']: try: response = requests.get(self.GeoIP + ip) - result = response.content.decode() - result = result.split("(")[1].strip(")") - result = json.loads(result) - if result["city"] == None: - data.append({"IPV4": ip, - "Country": str(result["country_name"])}) - else: - data.append({"IPV4": ip, - "Country": str(result["country_name"]), - "City":str(result["city"])}) - except (json.decoder.JSONDecodeError, - requests.exceptions.ConnectionError): + result = response.content.decode() + result = result.split("(")[1].strip(")") + result = json.loads(result) + data.append({"IPV4": ip, "Country": str(result.get("country_name")), "City": str(result.get("city"))}) + except Exception: time.sleep(4) return data - - def resolveA(self, json_format=True): - if self.A: - A = {"date_time": self.time, - "domain_name": self.url, - "record_type": "A", - "resolver": self.resolver, - "status": "OK", - "data": self.Geo_ip()} - else: - A = {"date_time": self.time, - "domain_name": self.url, - "record_type": "A", - "resolver": self.resolver, - "status": self.A_error, - "data": ""} - if json_format == False: - return A - else: - json_object = json.dumps(A, indent = 10) - return json_object - - def resolveAAAA(self, json_format=True): - if self.AAAA: - AAAA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "AAAA", - "resolver": self.resolver, - "status": "OK", - "data": str(self.AAAA)} - else: - AAAA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "AAAA", - "resolver": self.resolver, - "status": self.AAAA_error, - "data": ""} - if json_format == False: - return AAAA - else: - json_object = json.dumps(AAAA, indent = 10) - return json_object - - def resolveMX(self, json_format=True): - if self.MX: - MX = {"date_time": self.time, - "domain_name": self.url, - "record_type": "MX", - "resolver": self.resolver, - "status": "OK", - "data": str(self.MX)} - else: - MX = {"date_time": self.time, - "domain_name": self.url, - "record_type": "MX", - "resolver": self.resolver, - "status": self.MX_error, - "data": ""} - if json_format == False: - return MX - else: - json_object = json.dumps(MX, indent = 10) - return json_object - - def resolveTXT(self, json_format=True): - if self.TXT: - TXT = {"date_time": self.time, - "domain_name": self.url, - "record_type": "TXT", - "resolver": self.resolver, - "status": "OK", - "data": str(self.TXT)} - else: - TXT = {"date_time": self.time, - "domain_name": self.url, - "record_type": "TXT", - "resolver": self.resolver, - "status": self.TXT_error, - "data": ""} - if json_format == False: - return TXT - else: - json_object = json.dumps(TXT, indent = 10) - return json_object - - def resolveCNAME(self, json_format=True): - if self.CNAME: - CNAME = {"date_time": self.time, - "domain_name": self.url, - "record_type": "CNAME", - "resolver": self.resolver, - "status": "OK", - "data": str(self.CNAME)} - else: - CNAME = {"date_time": self.time, - "domain_name": self.url, - "record_type": "CNAME", - "resolver": self.resolver, - "status": self.CNAME_error, - "data": ""} - if json_format == False: - return CNAME - else: - json_object = json.dumps(CNAME, indent = 10) - return json_object - - def resolveNS(self, json_format=True): - if self.NS: - NS = {"date_time": self.time, - "domain_name": self.url, - "record_type": "NS", - "resolver": self.resolver, - "status": "OK", - "data": str(self.NS)} - else: - NS = {"date_time": self.time, - "domain_name": self.url, - "record_type": "NS", - "resolver": self.resolver, - "status": self.NS_error, - "data": ""} - if json_format == False: - return NS - else: - json_object = json.dumps(NS, indent = 10) - return json_object - - def resolveSOA(self, json_format=True): - if self.SOA: - SOA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "SOA", - "resolver": self.resolver, - "status": "OK", - "data": str(self.SOA)} - else: - SOA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "SOA", - "resolver": self.resolver, - "status": self.SOA_error, - "data": ""} - if json_format == False: - return SOA - else: - json_object = json.dumps(SOA, indent = 10) - return json_object - - def resolvePTR(self, json_format=True): - if self.PTR: - PTR = {"date_time": self.time, - "domain_name": self.url, - "record_type": "PTR", - "resolver": self.resolver, - "status": "OK", - "data": str(self.PTR)} - else: - PTR = {"date_time": self.time, - "domain_name": self.url, - "record_type": "PTR", - "resolver": self.resolver, - "status": self.PTR_error, - "data": ""} - if json_format == False: - return PTR - else: - json_object = json.dumps(PTR, indent = 10) - return json_object - - def resolveSRV(self, json_format=True): - if self.SRV: - SRV = {"date_time": self.time, - "domain_name": self.url, - "record_type": "SRV", - "resolver": self.resolver, - "status": "OK", - "data": str(self.SRV)} - else: - SRV = {"date_time": self.time, - "domain_name": self.url, - "record_type": "SRV", - "resolver": self.resolver, - "status": self.SRV_error, - "data": ""} - if json_format == False: - return SRV - else: - json_object = json.dumps(SRV, indent = 10) - return json_object - - def resolveCAA(self, json_format=True): - if self.CAA: - CAA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "CAA", - "resolver": self.resolver, - "status": "OK", - "data": str(self.CAA)} - else: - CAA = {"date_time": self.time, - "domain_name": self.url, - "record_type": "CAA", - "resolver": self.resolver, - "status": self.CAA_error, - "data": ""} - if json_format == False: - return CAA - else: - json_object = json.dumps(CAA, indent = 10) - return json_object - -def main(): - message = "This is a module!" - print(message) - -if __name__ == '__main__': - main() + def resolve(self, record_type, json_format=True): + record_data = self.records.get(record_type, []) + error = self.errors.get(record_type) + response = {"date_time": self.time, "domain_name": self.url, "record_type": record_type, + "resolver": self.resolver, "status": "OK" if record_data else error, + "data": self.Geo_ip() if record_type == 'A' else str(record_data)} + return json.dumps(response, indent=10) if json_format else response diff --git a/lib/resolvetype.py b/lib/resolvetype.py index 4117b5d..eb0ddac 100644 --- a/lib/resolvetype.py +++ b/lib/resolvetype.py @@ -1,11 +1,11 @@ #!/usr/bin/env python3 -import time import json +import time +import os import sqlite3 -import os, sys from datetime import datetime -from lib.dnsresolver import Domaininfo +from lib.dnsresolver import DomainInfo import signal @@ -15,195 +15,55 @@ def handle_interrupt(signum, frame): signal.signal(signal.SIGINT, handle_interrupt) -class Makefile(object): + +class Makefile: def __init__(self): - super(Makefile, self).__init__() - self.date = datetime.now().strftime('%Y-%m-%d|%H:%M:%S') + self.date = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') self.file = os.path.join("Domain_list", "dns_domains.txt") + def write_to_file(self, domain_object, file): + record_types = ['A', 'AAAA', 'MX', 'TXT', 'CNAME', 'NS', 'SOA', 'PTR', 'SRV', 'CAA'] + file.write('\n'.join([json.dumps(domain_object.resolve(record_type, json_format=True)) for record_type in record_types]) + '\n') - def single(self, url, dns, output_directory=None, json=True): - domain_object = Domaininfo(url, dns) - if json == False: - resolveA = domain_object.resolveA(json_format=False) - resolveAAAA = domain_object.resolveAAAA(json_format=False) - resolveMX = domain_object.resolveMX(json_format=False) - resolveTXT = domain_object.resolveTXT(json_format=False) - resolveCNAME = domain_object.resolveCNAME(json_format=False) - resolveNS = domain_object.resolveNS(json_format=False) - resolveSOA = domain_object.resolveSOA(json_format=False) - resolvePTR = domain_object.resolvePTR(json_format=False) - resolveSRV = domain_object.resolveSRV(json_format=False) - resolveCAA = domain_object.resolveCAA(json_format=False) - else: - resolveA = domain_object.resolveA(json_format=True) - resolveAAAA = domain_object.resolveAAAA(json_format=True) - resolveMX = domain_object.resolveMX(json_format=True) - resolveTXT = domain_object.resolveTXT(json_format=True) - resolveCNAME = domain_object.resolveCNAME(json_format=True) - resolveNS = domain_object.resolveNS(json_format=True) - resolveSOA = domain_object.resolveSOA(json_format=True) - resolvePTR = domain_object.resolvePTR(json_format=True) - resolveSRV = domain_object.resolveSRV(json_format=True) - resolveCAA = domain_object.resolveCAA(json_format=True) - if output_directory is None: - os.makedirs("Output", exist_ok=True) - file = open(os.path.join("Output", self.date + ".txt"), "a") - else: - file = open(os.path.join(output_directory, self.date + ".txt"), "a") - file.write("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n" % ( - str(resolveA), - str(resolveAAAA), - str(resolveMX), - str(resolveTXT), - str(resolveCNAME), - str(resolveNS), - str(resolveSOA), - str(resolvePTR), - str(resolveSRV), - str(resolveCAA)) - ) - file.close() + def process_domain(self, url, dns, json_format): + domain_object = DomainInfo(url, dns) + output_directory = "Output" + os.makedirs(output_directory, exist_ok=True) + with open(os.path.join(output_directory, self.date + ".txt"), "a") as file: + self.write_to_file(domain_object, file) + def single(self, url, dns, output_directory=None, json=True): + self.process_domain(url, dns, json) def bulk(self, dns, input_file=None, output_directory=None, json=True): - if input_file is None: - input_file = self.file + if not os.path.exists(input_file): + print(f"Error: File not found at '{input_file}'. Please check the file path and try again.") + return + + input_file = input_file or self.file with open(input_file, 'r') as file: - file_content = file.readlines() - for url in file_content: - url = url.strip() - domain_object = Domaininfo(url, dns) - if json == False: - resolveA = domain_object.resolveA(json_format=False) - resolveAAAA = domain_object.resolveAAAA(json_format=False) - resolveMX = domain_object.resolveMX(json_format=False) - resolveTXT = domain_object.resolveTXT(json_format=False) - resolveCNAME = domain_object.resolveCNAME(json_format=False) - resolveNS = domain_object.resolveNS(json_format=False) - resolveSOA = domain_object.resolveSOA(json_format=False) - resolvePTR = domain_object.resolvePTR(json_format=False) - resolveSRV = domain_object.resolveSRV(json_format=False) - resolveCAA = domain_object.resolveCAA(json_format=False) - else: - resolveA = domain_object.resolveA(json_format=True) - resolveAAAA = domain_object.resolveAAAA(json_format=True) - resolveMX = domain_object.resolveMX(json_format=True) - resolveTXT = domain_object.resolveTXT(json_format=True) - resolveCNAME = domain_object.resolveCNAME(json_format=True) - resolveNS = domain_object.resolveNS(json_format=True) - resolveSOA = domain_object.resolveSOA(json_format=True) - resolvePTR = domain_object.resolvePTR(json_format=True) - resolveSRV = domain_object.resolveSRV(json_format=True) - resolveCAA = domain_object.resolveCAA(json_format=True) - if output_directory is None: - os.makedirs("Output", exist_ok=True) - file = open(os.path.join("Output", self.date + ".txt"), "a") - else: - file = open(os.path.join(output_directory, self.date + ".txt"), "a") - file.write("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n" % ( - str(resolveA), - str(resolveAAAA), - str(resolveMX), - str(resolveTXT), - str(resolveCNAME), - str(resolveNS), - str(resolveSOA), - str(resolvePTR), - str(resolveSRV), - str(resolveCAA)) - ) - file.close() - + for url in file: + self.process_domain(url.strip(), dns, json) def database(self, dns, input_file=None, suspended_mode=False): conn = sqlite3.connect('resolver.db') - conn.execute('''CREATE TABLE IF NOT EXISTS dns_records (date_time TEXT, domain_name TEXT, record_type TEXT, resolver TEXT, status TEXT, data TEXT)''') - try: - while True: - if input_file is None: - input_file = self.file - with open(input_file, 'r') as file: - file_content = file.readlines() - for url in file_content: - url = url.strip() - domain_object = Domaininfo(url, dns) - resolveA = domain_object.resolveA(json_format=False) - resolveAAAA = domain_object.resolveAAAA(json_format=False) - resolveMX = domain_object.resolveMX(json_format=False) - resolveTXT = domain_object.resolveTXT(json_format=False) - resolveCNAME = domain_object.resolveCNAME(json_format=False) - resolveNS = domain_object.resolveNS(json_format=False) - resolveSOA = domain_object.resolveSOA(json_format=False) - resolvePTR = domain_object.resolvePTR(json_format=False) - resolveSRV = domain_object.resolveSRV(json_format=False) - resolveCAA = domain_object.resolveCAA(json_format=False) - - for result in resolveA['data']: - data_json = json.dumps(result) + input_file = input_file or self.file + while True: + with open(input_file, 'r') as file: + for url in file: + domain_object = DomainInfo(url.strip(), dns) + for record_type in ['A', 'AAAA', 'MX', 'TXT', 'CNAME', 'NS', 'SOA', 'PTR', 'SRV', 'CAA']: + data = json.dumps(domain_object.resolve(record_type, json_format=False)['data']) conn.execute('''INSERT INTO dns_records (date_time, domain_name, record_type, resolver, status, data) VALUES (?, ?, ?, ?, ?, ?)''', - (resolveA['date_time'], resolveA['domain_name'], resolveA['record_type'], resolveA['resolver'], resolveA['status'], data_json)) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveAAAA['date_time'], resolveAAAA['domain_name'], resolveAAAA['record_type'], resolveAAAA['resolver'], resolveAAAA['status'], resolveAAAA['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveMX['date_time'], resolveMX['domain_name'], resolveMX['record_type'], resolveMX['resolver'], resolveMX['status'], resolveMX['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveTXT['date_time'], resolveTXT['domain_name'], resolveTXT['record_type'], resolveTXT['resolver'], resolveTXT['status'], resolveTXT['data'])) - - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveCNAME['date_time'], resolveCNAME['domain_name'], resolveCNAME['record_type'], resolveCNAME['resolver'], resolveCNAME['status'], resolveCNAME['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveNS['date_time'], resolveNS['domain_name'], resolveNS['record_type'], resolveNS['resolver'], resolveNS['status'], resolveNS['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveSOA['date_time'], resolveSOA['domain_name'], resolveSOA['record_type'], resolveSOA['resolver'], resolveSOA['status'], resolveSOA['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolvePTR['date_time'], resolvePTR['domain_name'], resolvePTR['record_type'], resolvePTR['resolver'], resolvePTR['status'], resolvePTR['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveSRV['date_time'], resolveSRV['domain_name'], resolveSRV['record_type'], resolveSRV['resolver'], resolveSRV['status'], resolveSRV['data'])) - - conn.execute('''INSERT INTO dns_records - (date_time, domain_name, record_type, resolver, status, data) - VALUES (?, ?, ?, ?, ?, ?)''', - (resolveCAA['date_time'], resolveCAA['domain_name'], resolveCAA['record_type'], resolveCAA['resolver'], resolveCAA['status'], resolveCAA['data'])) - - conn.commit() - - if not suspended_mode: - break - - time.sleep(10) - - conn.close() - except KeyboardInterrupt: - print("\nCtrl+C pressed. Exiting...") - exit(0) \ No newline at end of file + (domain_object.time, url, record_type, domain_object.resolver, 'OK', data)) + conn.commit() + if not suspended_mode: + break + time.sleep(10) + conn.close() diff --git a/main.py b/main.py index c7cae9d..0d200ea 100644 --- a/main.py +++ b/main.py @@ -1,76 +1,60 @@ import re -import time +import time import cursor -import os, sys +import os +import sys import inquirer import argparse import animation import dns.resolver import pyfiglet as pf -from datetime import datetime from termcolor import colored +from lib.dnsresolver import DomainInfo # Capitalize the 'I' in 'DomainInfo' from lib.resolvetype import Makefile - -def interactive_mode(): +def interactive_mode(Make): while True: os.system('cls' if os.name == 'nt' else 'clear') - logo_text = pf.figlet_format("DRAST", font='slant') - defenition = colored("DNS Record Analysis and Storage Tool", 'blue') - logo = colored(logo_text, 'blue') + logo_text = pf.figlet_format("DRAST", font='slant') + definition = colored("DNS Record Analysis and Storage Tool", 'blue') + logo = colored(logo_text, 'blue') print(logo) - print(defenition + "\n") - symbol_red = colored("[!]", "red") - processing = colored("Processing", "green") + print(definition + "\n") + symbol_red = colored("[!]", "red") symbol_yellow = colored("[!]", "yellow") - pattern = re.compile('^([A-Za-z0-9]\.|[A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9]\.){1,3}[A-Za-z]{2,6}$') - main_menu = [inquirer.List("main", message="Choose option", choices=["Single domain resolve", "Bulk resolve", "Add to db", "Exit"])] - format_menu = [inquirer.List("format", message="Choose format", choices=["Json" , "Dictionary"])] - suspended_db = [inquirer.List("format", message="Would you like to turn on suspended mode?", choices=["Yes" , "No"])] - wait = animation.Wait(color="green", speed=0.1) - file = Makefile() + pattern = re.compile(r'^([A-Za-z0-9]\.|[A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9]\.){1,3}[A-Za-z]{2,6}$') + main_menu = [inquirer.List("main", message="Choose option", choices=["Single domain resolve", "Bulk resolve", "Exit"])] + format_menu = [inquirer.List("format", message="Choose format", choices=["Json", "Dictionary"])] + wait = animation.Wait(color="green", speed=0.1) cursor.hide() - main_answer = inquirer.prompt(main_menu) + main_answer = inquirer.prompt(main_menu) os.system('cls' if os.name == 'nt' else 'clear') if str(main_answer) == "{'main': 'Exit'}": sys.exit() - os.system('cls' if os.name == 'nt' else 'clear') cursor.show() os.system('cls' if os.name == 'nt' else 'clear') while True: try: - dns_ip = dns.resolver.Resolver() - input_dns = [input('Enter DNS IP or press "Enter" to use the default IP: ')] + dns_ip = dns.resolver.Resolver() + input_dns = input('Enter DNS IP or press "Enter" to use the default IP: ') os.system('cls' if os.name == 'nt' else 'clear') - if input_dns == [""]: - dns_ip - else: - dns_ip.nameservers = input_dns + if input_dns: + dns_ip.nameservers = [input_dns] except ValueError: - print("\n\n\n" + symbol_red + " Invalid DNS ip " + symbol_red + "\n" + - symbol_red + "Please try again" + symbol_red) - time.sleep(2) - os.system('cls' if os.name == 'nt' else 'clear') - continue - break - if str(main_answer) == "{'main': 'Add to db'}": - cursor.hide() - suspended_ansewer = inquirer.prompt(suspended_db) - if str(suspended_ansewer) == "{'format': 'Yes'}": - os.system('cls' if os.name == 'nt' else 'clear') - print(processing) - file.database(dns_ip, suspended_mode=True) - elif str(suspended_ansewer) == "{'format': 'No'}": + print("\n\n\n" + symbol_red + " Invalid DNS IP " + symbol_red + "\n" + + symbol_red + "Please try again" + symbol_red) + time.sleep(2) os.system('cls' if os.name == 'nt' else 'clear') - wait.start() - file.database(dns_ip, suspended_mode=False) + continue + break + if str(main_answer) == "{'main': 'Single domain resolve'}": format_answer = inquirer.prompt(format_menu) while True: os.system('cls' if os.name == 'nt' else 'clear') print("Please write domain in next format: \n\n1: example.com \n\n2: www.example.com\n") domain = input("Please type domain: ") - match = re.search(pattern, domain) + match = re.search(pattern, domain) if match: break else: @@ -81,25 +65,33 @@ def interactive_mode(): os.system('cls' if os.name == 'nt' else 'clear') cursor.hide() wait.start() - if str(format_answer) == "{'format': 'Json'}": - file.single(domain, dns_ip, json=True) - elif str(format_answer) == "{'format': 'Dictionary'}": - file.single(domain, dns_ip, json=False) + domain_info = DomainInfo(domain, dns_ip) + result = domain_info.resolve('A', json_format=str(format_answer) == "{'format': 'Json'}") + print(result) + wait.stop() + time.sleep(1.5) + elif str(main_answer) == "{'main': 'Bulk resolve'}": format_answer = inquirer.prompt(format_menu) cursor.hide() - print(symbol_yellow + " Be sure that you edit domain_list.txt " + symbol_yellow) + print(symbol_yellow + " Be sure to specify the correct domain list file " + symbol_yellow) + + if not input_file: + input_file = input("Please enter the path to your domain list file: ") + if not input_file.strip(): + print(symbol_red + " No file path provided. Returning to main menu. " + symbol_red) + continue + wait.start() if str(format_answer) == "{'format': 'Json'}": - file.bulk(dns_ip, json=True) + Make.bulk(dns_ip, input_file, json=True) elif str(format_answer) == "{'format': 'Dictionary'}": - file.bulk(dns_ip, json=False) - os.system('cls' if os.name == 'nt' else 'clear') - wait.stop() - print("Data saved") - time.sleep(1.5) - os.system('cls' if os.name == 'nt' else 'clear') - + Make.bulk(dns_ip, input_file, json=False) + os.system('cls' if os.name == 'nt' else 'clear') + wait.stop() + print("Data saved") + time.sleep(1.5) + os.system('cls' if os.name == 'nt' else 'clear') def main(): Make = Makefile() drast_description = ( @@ -140,7 +132,7 @@ def main(): if any([args.single, args.output_directory, args.sql, args.bulk, args.suspended, args.json, args.input_file, args.dictionary, args.dns]): print("Error: Interactive mode cannot be used with other flags.") else: - interactive_mode() + interactive_mode(Make) elif args.sql: input_file = args.input_file if args.input_file else None if any([args.single, args.bulk, args.json, args.dictionary, args.output_directory]):