DNS Resolver (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: DNS Resolver

Write a program that performs DNS lookups for domain names, supporting multiple record types, reverse lookups, DNS-over-HTTPS, and batch resolution with response time measurements.

FUNCTIONAL REQUIREMENTS:
- Accept a domain name as a command-line argument
- Support querying multiple DNS record types via --type flag: A, AAAA, MX, NS, TXT, CNAME, SOA, PTR, SRV (default: A)
- Support querying all common record types at once via --all flag
- Support reverse DNS lookups (IP to hostname) via --reverse flag
- Allow specifying a custom DNS server via --server flag (default: system DNS resolver)
- Support DNS-over-HTTPS (DoH) via --doh flag using configurable DoH providers
- Measure and display query response time in milliseconds for each lookup
- Support batch resolution of multiple domains from a file via --file flag (one domain per line)
- Display TTL (Time To Live) values for each record
- Support recursive trace mode via --trace flag: show the full resolution path from root servers to authoritative servers
- Print results to console in a structured format showing: domain, record type, value, TTL, response time, and nameserver used
- Save results as JSON with --output flag (default: dns_results.json)
- Support concurrent resolution of batch queries via --parallel flag with configurable concurrency (--threads, default 10)
- If no domain is given, resolve a set of well-known domains (example.com, google.com, github.com, cloudflare.com) across multiple record types and display a formatted comparison table
- Handle errors: NXDOMAIN (non-existent domain), SERVFAIL, timeout, invalid domain names, and unreachable DNS servers

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

import dns.resolver
import dns.reversename
import sys
import argparse
import time
import json
from concurrent.futures import ThreadPoolExecutor

def resolve_dns(domain, rtype='A', server=None):
    resolver = dns.resolver.Resolver()
    if server:
        resolver.nameservers = [server]
    
    start_time = time.time()
    try:
        answers = resolver.resolve(domain, rtype)
        elapsed = (time.time() - start_time) * 1000
        
        results = []
        for rdata in answers:
            results.append({
                "domain": domain,
                "type": rtype,
                "value": str(rdata),
                "ttl": answers.rrset.ttl,
                "time_ms": round(elapsed, 2),
                "server": resolver.nameservers[0]
            })
        return results
    except dns.resolver.NXDOMAIN:
        return [{"domain": domain, "error": "NXDOMAIN"}]
    except dns.resolver.NoAnswer:
        return [{"domain": domain, "error": "No Answer"}]
    except Exception as e:
        return [{"domain": domain, "error": str(e)}]

def main():
    parser = argparse.ArgumentParser(description="DNS Resolver")
    parser.add_argument("domain", nargs="?", help="Domain to resolve")
    parser.add_argument("--type", default="A", help="Record type (A, MX, TXT, etc.)")
    parser.add_argument("--server", help="Custom DNS server")
    parser.add_argument("--output", default="dns_results.json")
    
    args = parser.parse_args()
    
    target = args.domain or "example.com"
    
    print(f"Resolving {target} (Type: {args.type})...")
    results = resolve_dns(target, args.type, args.server)
    
    print(json.dumps(results, indent=4))
    
    with open(args.output, "w") as f:
        json.dump(results, f, indent=4)

if __name__ == "__main__":
    main()

# DNS Resolver (Python)

A comprehensive DNS lookup tool supporting various record types and custom servers.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- **Basic A-record lookup**:
  ```bash
  python dns_resolver.py google.com
  ```
- **Lookup specific type**:
  ```bash
  python dns_resolver.py example.com --type MX
  ```
- **Use custom DNS server**:
  ```bash
  python dns_resolver.py github.com --server 8.8.8.8
  ```

## Features
- **Multiple Types**: Support for A, MX, TXT, CNAME, etc.
- **Latency Measurement**: Reports query time in milliseconds.
- **JSON Output**: Saves results to a structured file.

dnspython==2.6.1
requests==2.31.0