DNS Resolver (python, written by Claude Code)

Claude Code 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

[]

# DNS Resolver - Python (Trial 1)

A comprehensive DNS lookup tool supporting multiple record types, reverse DNS lookups, DNS-over-HTTPS (DoH), and batch resolution.

## Dependencies

- **dnspython** (2.5.0) - Full-featured DNS toolkit for Python

## Features

- DNS lookups for A, AAAA, MX, NS, TXT, CNAME, SOA, PTR, SRV, and CAA record types
- Reverse DNS lookups (PTR) for IPv4 and IPv6 addresses
- DNS-over-HTTPS (DoH) queries via Google, Cloudflare, and Quad9
- Batch resolution of multiple domains
- Mixed batch queries with different record types per domain
- JSON-formatted output
- Configurable nameservers and timeout

## Setup

```bash
pip install -r requirements.txt
```

## Usage

```bash
python resolver.py
```

The script demonstrates all resolver capabilities including standard lookups, reverse DNS, DoH queries, and batch resolution.

## API

```python
from resolver import DnsResolver

resolver = DnsResolver(nameservers=["8.8.8.8"], timeout=10.0)

# Standard lookup
result = resolver.lookup("example.com", "A")

# Reverse DNS
result = resolver.reverse_lookup("8.8.8.8")

# DNS-over-HTTPS
result = resolver.doh_lookup("example.com", "A", "google")

# Batch resolution
results = resolver.batch_resolve(["google.com", "github.com"], "A")
```

dnspython==2.5.0

#!/usr/bin/env python3
"""
DNS Resolver - A comprehensive DNS lookup tool supporting multiple record types,
reverse DNS lookups, DNS-over-HTTPS, and batch resolution.

Uses dnspython for all DNS operations.
"""

import sys
import json
import socket
import struct
import urllib.request
import urllib.error
import base64
from typing import Dict, List, Optional, Any

import dns.resolver
import dns.reversename
import dns.rdatatype
import dns.message
import dns.query
import dns.name


# Supported DNS record types
SUPPORTED_RECORD_TYPES = [
    "A", "AAAA", "MX", "NS", "TXT", "CNAME", "SOA", "PTR", "SRV", "CAA"
]

# Well-known DNS-over-HTTPS providers
DOH_PROVIDERS = {
    "google": "https://dns.google/dns-query",
    "cloudflare": "https://cloudflare-dns.com/dns-query",
    "quad9": "https://dns.quad9.net/dns-query",
}


class DnsResolver:
    """A full-featured DNS resolver with support for multiple query methods."""

    def __init__(self, nameservers: Optional[List[str]] = None, timeout: float = 10.0):
        """
        Initialize the DNS resolver.

        Args:
            nameservers: Optional list of DNS server IP addresses to use.
            timeout: Timeout in seconds for each query.
        """
        self.resolver = dns.resolver.Resolver()
        self.timeout = timeout

        if nameservers:
            self.resolver.nameservers = nameservers

        self.resolver.lifetime = timeout

    def lookup(self, domain: str, record_type: str = "A") -> Dict[str, Any]:
        """
        Perform a DNS lookup for a specific record type.

        Args:
            domain: The domain name to look up.
            record_type: The DNS record type (A, AAAA, MX, etc.).

        Returns:
            A dictionary containing the query results.
        """
        record_type = record_type.upper()
        if record_type not in SUPPORTED_RECORD_TYPES:
            return {
                "domain": domain,
                "record_type": record_type,
                "error": f"Unsupported record type: {record_type}. "
                         f"Supported: {', '.join(SUPPORTED_RECORD_TYPES)}",
                "records": [],
            }

        result = {
            "domain": domain,
            "record_type": record_type,
            "records": [],
            "ttl": None,
            "nameserver": self.resolver.nameservers[0] if self.resolver.nameservers else None,
        }

        try:
            answers = self.resolver.resolve(domain, record_type)
            result["ttl"] = answers.rrset.ttl

            for rdata in answers:
                record = self._parse_record(rdata, record_type)
                result["records"].append(record)

        except dns.resolver.NXDOMAIN:
            result["error"] = f"Domain '{domain}' does not exist (NXDOMAIN)"
        except dns.resolver.NoAnswer:
            result["error"] = f"No {record_type} records found for '{domain}'"
        except dns.resolver.NoNameservers:
            result["error"] = "No nameservers available to answer the query"
        except dns.exception.Timeout:
            result["error"] = f"Query timed out after {self.timeout} seconds"
        except Exception as e:
            result["error"] = str(e)

        return result

    def lookup_all(self, domain: str) -> Dict[str, Any]:
        """
        Look up all supported record types for a domain.

        Args:
            domain: The domain name to look up.

        Returns:
            A dictionary containing results for all record types.
        """
        results = {
            "domain": domain,
            "results": {},
        }

        for rtype in SUPPORTED_RECORD_TYPES:
            lookup_result = self.lookup(domain, rtype)
            if lookup_result.get("records"):
                results["results"][rtype] = lookup_result

        return results

    def reverse_lookup(self, ip_address: str) -> Dict[str, Any]:
        """
        Perform a reverse DNS lookup for an IP address.

        Args:
            ip_address: The IP address (IPv4 or IPv6) to look up.

        Returns:
            A dictionary containing the reverse DNS results.
        """
        result = {
            "ip_address": ip_address,
            "hostnames": [],
        }

        try:
            rev_name = dns.reversename.from_address(ip_address)
            result["ptr_domain"] = str(rev_name)

            answers = self.resolver.resolve(rev_name, "PTR")
            result["ttl"] = answers.rrset.ttl

            for rdata in answers:
                result["hostnames"].append(str(rdata.target))

        except dns.resolver.NXDOMAIN:
            result["error"] = f"No reverse DNS entry for '{ip_address}'"
        except dns.resolver.NoAnswer:
            result["error"] = f"No PTR records found for '{ip_address}'"
        except dns.exception.Timeout:
            result["error"] = f"Reverse lookup timed out after {self.timeout} seconds"
        except Exception as e:
            result["error"] = str(e)

        return result

    def doh_lookup(
        self, domain: str, record_type: str = "A", provider: str = "google"
    ) -> Dict[str, Any]:
        """
        Perform a DNS lookup using DNS-over-HTTPS (DoH).

        Args:
            domain: The domain name to look up.
            record_type: The DNS record type.
            provider: The DoH provider name or a full URL.

        Returns:
            A dictionary containing the DoH query results.
        """
        record_type = record_type.upper()
        doh_url = DOH_PROVIDERS.get(provider.lower(), provider)

        result = {
            "domain": domain,
            "record_type": record_type,
            "provider": provider,
            "doh_url": doh_url,
            "records": [],
        }

        try:
            # Build DNS wire-format query
            q = dns.message.make_query(domain, record_type)
            wire_data = q.to_wire()

            # Encode as base64url for GET request
            dns_param = base64.urlsafe_b64encode(wire_data).rstrip(b"=").decode("ascii")
            request_url = f"{doh_url}?dns={dns_param}"

            req = urllib.request.Request(
                request_url,
                headers={
                    "Accept": "application/dns-message",
                },
            )

            with urllib.request.urlopen(req, timeout=self.timeout) as response:
                response_data = response.read()

            # Parse the DNS response
            dns_response = dns.message.from_wire(response_data)

            for rrset in dns_response.answer:
                result["ttl"] = rrset.ttl
                for rdata in rrset:
                    record = self._parse_record(rdata, dns.rdatatype.to_text(rdata.rdtype))
                    result["records"].append(record)

            if not result["records"]:
                # Check the response code
                rcode = dns_response.rcode()
                if rcode == dns.rcode.NXDOMAIN:
                    result["error"] = f"Domain '{domain}' does not exist (NXDOMAIN)"
                else:
                    result["error"] = f"No {record_type} records in DoH response"

        except urllib.error.URLError as e:
            result["error"] = f"DoH request failed: {e}"
        except Exception as e:
            result["error"] = f"DoH lookup error: {e}"

        return result

    def batch_resolve(
        self, domains: List[str], record_type: str = "A"
    ) -> List[Dict[str, Any]]:
        """
        Resolve multiple domains in batch.

        Args:
            domains: List of domain names to resolve.
            record_type: The DNS record type to query for each domain.

        Returns:
            A list of result dictionaries, one per domain.
        """
        results = []
        for domain in domains:
            domain = domain.strip()
            if not domain:
                continue
            lookup_result = self.lookup(domain, record_type)
            results.append(lookup_result)
        return results

    def batch_resolve_mixed(
        self, queries: List[Dict[str, str]]
    ) -> List[Dict[str, Any]]:
        """
        Resolve a batch of mixed queries (different domains and record types).

        Args:
            queries: List of dicts with 'domain' and optionally 'record_type' keys.

        Returns:
            A list of result dictionaries.
        """
        results = []
        for query in queries:
            domain = query.get("domain", "").strip()
            record_type = query.get("record_type", "A").strip().upper()
            if not domain:
                continue
            lookup_result = self.lookup(domain, record_type)
            results.append(lookup_result)
        return results

    def _parse_record(self, rdata: Any, record_type: str) -> Dict[str, Any]:
        """Parse a DNS record into a dictionary based on its type."""
        record_type = record_type.upper()
        record: Dict[str, Any] = {"type": record_type}

        try:
            if record_type == "A":
                record["address"] = str(rdata)
            elif record_type == "AAAA":
                record["address"] = str(rdata)
            elif record_type == "MX":
                record["preference"] = rdata.preference
                record["exchange"] = str(rdata.exchange)
            elif record_type == "NS":
                record["nameserver"] = str(rdata.target)
            elif record_type == "TXT":
                # TXT records can have multiple strings
                txt_parts = []
                for s in rdata.strings:
                    txt_parts.append(s.decode("utf-8", errors="replace"))
                record["text"] = " ".join(txt_parts)
            elif record_type == "CNAME":
                record["target"] = str(rdata.target)
            elif record_type == "SOA":
                record["mname"] = str(rdata.mname)
                record["rname"] = str(rdata.rname)
                record["serial"] = rdata.serial
                record["refresh"] = rdata.refresh
                record["retry"] = rdata.retry
                record["expire"] = rdata.expire
                record["minimum"] = rdata.minimum
            elif record_type == "PTR":
                record["target"] = str(rdata.target)
            elif record_type == "SRV":
                record["priority"] = rdata.priority
                record["weight"] = rdata.weight
                record["port"] = rdata.port
                record["target"] = str(rdata.target)
            elif record_type == "CAA":
                record["flags"] = rdata.flags
                record["tag"] = rdata.tag.decode("utf-8", errors="replace")
                record["value"] = rdata.value.decode("utf-8", errors="replace")
            else:
                record["data"] = str(rdata)
        except AttributeError:
            record["data"] = str(rdata)

        return record


def format_results(results: Any, indent: int = 2) -> str:
    """Format results as pretty-printed JSON."""
    return json.dumps(results, indent=indent, default=str)


def print_lookup_result(result: Dict[str, Any]) -> None:
    """Print a single lookup result in a human-readable format."""
    domain = result.get("domain", "N/A")
    rtype = result.get("record_type", "N/A")
    print(f"\n--- {domain} ({rtype}) ---")

    if "error" in result:
        print(f"  Error: {result['error']}")
        return

    ttl = result.get("ttl")
    if ttl is not None:
        print(f"  TTL: {ttl}")

    for rec in result.get("records", []):
        rec_type = rec.get("type", "")
        if rec_type in ("A", "AAAA"):
            print(f"  {rec_type}: {rec.get('address')}")
        elif rec_type == "MX":
            print(f"  MX: {rec.get('exchange')} (priority: {rec.get('preference')})")
        elif rec_type == "NS":
            print(f"  NS: {rec.get('nameserver')}")
        elif rec_type == "TXT":
            print(f"  TXT: {rec.get('text')}")
        elif rec_type == "CNAME":
            print(f"  CNAME: {rec.get('target')}")
        elif rec_type == "SOA":
            print(f"  SOA: mname={rec.get('mname')}, serial={rec.get('serial')}")
        elif rec_type == "PTR":
            print(f"  PTR: {rec.get('target')}")
        elif rec_type == "SRV":
            print(
                f"  SRV: {rec.get('target')}:{rec.get('port')} "
                f"(priority={rec.get('priority')}, weight={rec.get('weight')})"
            )
        elif rec_type == "CAA":
            print(f"  CAA: {rec.get('flags')} {rec.get('tag')} {rec.get('value')}")
        else:
            print(f"  {rec_type}: {rec.get('data', str(rec))}")


def main():
    """Main entry point demonstrating all DNS resolver capabilities."""
    print("=" * 60)
    print("  DNS Resolver - Comprehensive DNS Lookup Tool")
    print("=" * 60)

    resolver = DnsResolver()

    # 1. Standard DNS lookups for multiple record types
    print("\n[1] Standard DNS Lookups")
    print("-" * 40)
    test_domain = "google.com"

    for rtype in ["A", "AAAA", "MX", "NS", "TXT", "SOA"]:
        result = resolver.lookup(test_domain, rtype)
        print_lookup_result(result)

    # 2. Look up all record types for a domain
    print("\n\n[2] All Record Types for 'example.com'")
    print("-" * 40)
    all_results = resolver.lookup_all("example.com")
    for rtype, res in all_results.get("results", {}).items():
        print_lookup_result(res)

    # 3. Reverse DNS lookup
    print("\n\n[3] Reverse DNS Lookup")
    print("-" * 40)
    test_ips = ["8.8.8.8", "1.1.1.1"]
    for ip in test_ips:
        rev_result = resolver.reverse_lookup(ip)
        print(f"\n  IP: {rev_result['ip_address']}")
        if "error" in rev_result:
            print(f"  Error: {rev_result['error']}")
        else:
            print(f"  PTR domain: {rev_result.get('ptr_domain')}")
            for hostname in rev_result.get("hostnames", []):
                print(f"  Hostname: {hostname}")

    # 4. DNS-over-HTTPS
    print("\n\n[4] DNS-over-HTTPS (DoH)")
    print("-" * 40)
    for provider in ["google", "cloudflare"]:
        doh_result = resolver.doh_lookup("example.com", "A", provider)
        print(f"\n  Provider: {provider} ({doh_result.get('doh_url')})")
        if "error" in doh_result:
            print(f"  Error: {doh_result['error']}")
        else:
            for rec in doh_result.get("records", []):
                print(f"  {rec.get('type')}: {rec.get('address', rec)}")

    # 5. Batch resolution
    print("\n\n[5] Batch Resolution")
    print("-" * 40)
    batch_domains = [
        "google.com",
        "github.com",
        "stackoverflow.com",
        "python.org",
        "example.com",
    ]
    batch_results = resolver.batch_resolve(batch_domains, "A")
    for res in batch_results:
        domain = res.get("domain")
        if "error" in res:
            print(f"  {domain}: {res['error']}")
        else:
            addresses = [r.get("address") for r in res.get("records", [])]
            print(f"  {domain}: {', '.join(addresses)}")

    # 6. Batch mixed queries
    print("\n\n[6] Batch Mixed Queries")
    print("-" * 40)
    mixed_queries = [
        {"domain": "google.com", "record_type": "A"},
        {"domain": "google.com", "record_type": "MX"},
        {"domain": "github.com", "record_type": "AAAA"},
        {"domain": "example.com", "record_type": "NS"},
    ]
    mixed_results = resolver.batch_resolve_mixed(mixed_queries)
    for res in mixed_results:
        print_lookup_result(res)

    # 7. JSON output
    print("\n\n[7] JSON Output (google.com A record)")
    print("-" * 40)
    json_result = resolver.lookup("google.com", "A")
    print(format_results(json_result))

    print("\n" + "=" * 60)
    print("  DNS Resolution Complete")
    print("=" * 60)


if __name__ == "__main__":
    main()