#!/usr/bin/env python # Mass DNS AXFR - developed by acidvegas in python (https://git.acid.vegas/mdaxfr) import logging import os import re import urllib.request try: import dns.rdatatype import dns.query import dns.zone import dns.resolver except ImportError: raise SystemExit('missing required \'dnspython\' module (pip install dnspython)') # Colours BLUE = '\033[1;34m' CYAN = '\033[1;36m' GREEN = '\033[1;32m' GREY = '\033[1;90m' PINK = '\033[1;95m' PURPLE = '\033[0;35m' RED = '\033[1;31m' YELLOW = '\033[1;33m' RESET = '\033[0m' def attempt_axfr(domain: str, nameserver: str, nameserver_ip: str): ''' Request a zone transfer from a nameserver on a domain. :param domain: The domain to perform the zone transfer on. :param nameserver: The nameserver to perform the zone transfer on. :param nameserver_ip: The IP address of the nameserver. ''' print(f' {YELLOW}Attempting AXFR for {CYAN}{domain}{RESET} on {PURPLE}{nameserver} {GREY}({nameserver_ip}){RESET}') zone = dns.zone.from_xfr(dns.query.xfr(nameserver_ip, domain)) record_count = sum(len(node.rdatasets) for node in zone.nodes.values()) print(f' {GREEN}AXFR successful for {CYAN}{domain}{RESET} on {PURPLE}{nameserver} {GREY}({nameserver_ip}){RESET} - {record_count:,} records') with open(os.path.join('axfrout', f'{domain}_{nameserver}_{nameserver_ip}.log'), 'w') as file: file.write(zone.to_text()) def get_nameservers(domain: str) -> list: ''' Generate a list of the root nameservers. :param target: The target domain to get the nameservers for. ''' ns_records = dns.resolver.resolve(domain, 'NS', lifetime=30) nameservers = [str(rr.target)[:-1] for rr in ns_records] return nameservers def get_root_tlds(output_dir: str) -> list: ''' Get the root TLDs from a root nameservers. :param output_dir: The output directory to use. ''' rndroot = [root for root in os.listdir(output_dir) if root.endswith('.root-servers.net.txt')] if rndroot: rndroot_file = rndroot[0] # Take the first file from the list tlds = sorted(set([item.split()[0][:-1] for item in open(os.path.join(root_dir, rndroot_file)).read().split('\n') if item and 'IN' in item and 'NS' in item])) else: logging.warning('Failed to find root nameserver list...fallback to using IANA list') tlds = urllib.request.urlopen('https://data.iana.org/TLD/tlds-alpha-by-domain.txt').read().decode('utf-8').lower().split('\n')[1:] return tlds def get_psl_tlds() -> list: '''Download the Public Suffix List and return its contents.''' data = urllib.request.urlopen('https://publicsuffix.org/list/public_suffix_list.dat').read().decode() domains = [] for line in data.split('\n'): if line.startswith('//') or not line: continue if '*' in line or '!' in line: continue if '.' not in line: continue domains.append(line) return domains def resolve_nameserver(nameserver: str) -> list: ''' Resolve a nameserver to its IP address. :param nameserver: The nameserver to resolve. ''' data = [] for version in ('A', 'AAAA'): data.extend([ip.address for ip in dns.resolver.resolve(nameserver, version, lifetime=30)]) return data def process_domain(domain: str): domain = re.sub(r'^https?://|^(www\.)|(/.*$)', '', domain) print(f'{PINK}Looking up nameservers for {CYAN}{domain}{RESET}') try: nameservers = get_nameservers(domain) except Exception as ex: print(f' {RED}Error resolving nameservers for {CYAN}{domain} {GREY}({ex}){RESET}') return if not nameservers: print(f' {GREY}No nameservers found for {CYAN}{domain}{RESET}') return print(f' {BLUE}Found {len(nameservers):,} nameservers for {CYAN}{domain}{RESET}') for nameserver in nameservers: print(f' {PINK}Looking up IP addresses for {PURPLE}{nameserver}{RESET}') try: nameserver_ips = resolve_nameserver(nameserver) except Exception as ex: print(f' {RED}Error resolving IP addresses for {PURPLE}{nameserver} {GREY}({ex}){RESET}') continue if not nameserver_ips: print(f' {GREY}No IP addresses found for {PURPLE}{nameserver}{RESET}') continue print(f' {BLUE}Found {len(nameserver_ips):,} IP addresses for {PURPLE}{nameserver}{RESET}') for nameserver_ip in nameserver_ips: attempt_axfr(domain, nameserver, nameserver_ip) if __name__ == '__main__': import argparse import concurrent.futures import sys parser = argparse.ArgumentParser(description='Mass DNS AXFR') parser.add_argument('-d', '--domain', type=str, help='domain to perform AXFR on') parser.add_argument('-i', '--input', type=str, help='input file') parser.add_argument('-t', '--tlds', action='store_true', help='Perform AXFR on all TLDs') parser.add_argument('-p', '--psl', action='store_true', help='use the Public Suffix List') parser.add_argument('-c', '--concurrency', type=int, default=30, help='maximum concurrent tasks') parser.add_argument('-o', '--output', type=str, default='axfrout', help='output directory') args = parser.parse_args() logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') output_dir = args.output # Store the output directory root_dir = os.path.join(output_dir, 'root') # Use the stored output directory # Create output directories os.makedirs(output_dir, exist_ok=True) os.makedirs(root_dir, exist_ok=True) # Set DNS timeout dns.resolver._DEFAULT_TIMEOUT = 30 with concurrent.futures.ThreadPoolExecutor(max_workers=args.concurrency) as executor: if args.domain: # Single domain mode process_domain(args.domain) elif args.input: # Input file mode try: with open(args.input, 'r') as f: domains = [line.strip() for line in f if line.strip()] futures = [executor.submit(process_domain, domain) for domain in domains] for future in concurrent.futures.as_completed(futures): try: future.result() except Exception as e: logging.error(f'Error processing domain: {e}') except FileNotFoundError: logging.error(f'Input file not found: {args.input}') sys.exit(1) elif args.tlds: # TLD mode logging.info('Fetching root nameservers...') # First get root nameservers for root in get_nameservers('.'): try: attempt_axfr('', root, os.path.join(root_dir, f'{root}.txt')) except Exception as e: logging.error(f'Error processing root nameserver {root}: {e}') # Then process TLDs logging.info('Processing TLDs...') tlds = get_root_tlds(root_dir) futures = [] for tld in tlds: try: nameservers = get_nameservers(tld) for ns in nameservers: futures.append(executor.submit(process_domain, tld)) except Exception as e: logging.error(f'Error processing TLD {tld}: {e}') for future in concurrent.futures.as_completed(futures): try: future.result() except Exception as e: logging.error(f'Error in TLD task: {e}') elif args.psl: # PSL mode logging.info('Fetching PSL domains...') psl_dir = os.path.join(output_dir, 'psl') # Use output_dir here too os.makedirs(psl_dir, exist_ok=True) domains = get_psl_tlds() futures = [] for domain in domains: try: futures.append(executor.submit(process_domain, domain)) except Exception as e: logging.error(f'Error processing PSL domain {domain}: {e}') for future in concurrent.futures.as_completed(futures): try: future.result() except Exception as e: logging.error(f'Error in PSL task: {e}') else: parser.print_help() sys.exit(1)