nspack 0.1.0__tar.gz

nspack-0.1.0/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: nspack
+Version: 0.1.0
+Summary: Simple DNS resolver and file-over-DNS transfer toolkit
+Keywords: dns,resolver,file-transfer,txt-records
+Author: geekennedy
+Author-email: geekennedy <gkennedy@gcloudns.net>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: Name Service (DNS)
+Requires-Dist: dnspython>=2.7.0
+Requires-Dist: click>=8.1.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# gcnspack
+
+[![PyPI version](https://img.shields.io/pypi/v/gcnspack.svg)](https://pypi.org/project/gcnspack/)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13%2B-blue.svg)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Simple DNS resolver and file-over-DNS transfer toolkit.
+
+![gcnspack overview](docs/overview.svg)
+
+## Features
+
+- **DNS Resolver** - Simple, batteries-included DNS resolution with sensible defaults (Cloudflare, Google, Quad9 fallbacks)
+- **File-over-DNS** - Encode arbitrary files into DNS TXT records and reconstruct them from DNS queries
+- **CLI** - Command-line interface for resolving DNS and managing file transfers
+- **Protocol** - Chunked base32/base64 encoding scheme with SHA-256 integrity verification
+
+## Installation
+
+```bash
+pip install gcnspack
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add gcnspack
+```
+
+## Quick Start
+
+### DNS Resolution
+
+```python
+from gcnspack import resolve, resolve_all, create_resolver
+
+# Simple A record lookup
+ips = resolve("example.com")
+# ['93.184.216.34']
+
+# Query specific record types
+mx = resolve("example.com", "MX")
+txt = resolve("example.com", "TXT")
+
+# Query multiple record types at once
+all_records = resolve_all("example.com")
+# {'A': [...], 'AAAA': [...], 'MX': [...], 'TXT': [...], 'NS': [...], 'CNAME': [...]}
+
+# Use a custom resolver
+r = create_resolver(nameservers=["1.1.1.1"], timeout=10.0)
+result = resolve("example.com", "A", resolver=r)
+```
+
+### File-over-DNS Transfer
+
+#### Encoding a File
+
+```python
+from gcnspack import encode_file, generate_zone_records
+
+# Read a file and generate DNS zone records
+with open("payload.bin", "rb") as f:
+    data = f.read()
+
+# Generate zone-file TXT records
+records = generate_zone_records(data, "files.example.com")
+for record in records:
+    print(record)
+```
+
+Output:
+
+```
+0.files.example.com  IN  TXT  "GAYTEMZUGU3DOOB..."
+1.files.example.com  IN  TXT  "GAYTEMZUGU3DOOC..."
+_meta.files.example.com  IN  TXT  "ON2HE2LOM4QHO..."
+```
+
+#### Fetching a File from DNS
+
+```python
+from gcnspack import save_txt_file
+
+# Pull TXT records, decode, verify hash, and save
+save_txt_file("files.example.com", "output.bin")
+```
+
+## Protocol
+
+Files are transferred over DNS using this encoding scheme:
+
+```
+                    +-------------------+
+                    |   Original File   |
+                    +-------------------+
+                            |
+                      Split into chunks
+                       (150 bytes each)
+                            |
+                    +-------+-------+
+                    |       |       |
+                    v       v       v
+               Chunk 0  Chunk 1  Chunk N
+                    |       |       |
+               Base64 encode each chunk
+                    |       |       |
+              Add header: "idx:total:base64data"
+                    |       |       |
+              Base32 encode entire string
+                    |       |       |
+                    v       v       v
+          +-------------------------------------------+
+          |  DNS TXT Records                          |
+          |  0.sub.example.com  TXT  "<base32>"       |
+          |  1.sub.example.com  TXT  "<base32>"       |
+          |  N.sub.example.com  TXT  "<base32>"       |
+          |  _meta.sub.example.com  TXT  "<meta_b32>" |
+          +-------------------------------------------+
+```
+
+**Metadata record** (`_meta.<subdomain>`): Contains `sha256:<hash>:chunks:<count>`, base32-encoded.
+
+**Chunk records** (`<n>.<subdomain>`): Each contains `<index>:<total>:<base64_data>`, base32-encoded.
+
+Reconstruction:
+1. Fetch `_meta.<subdomain>` to get chunk count and expected SHA-256 hash
+2. Fetch chunks `0` through `N-1` from `<n>.<subdomain>`
+3. Decode each chunk (base32 -> parse header -> base64 decode payload)
+4. Sort by index, concatenate
+5. Verify SHA-256 hash matches
+
+## CLI Usage
+
+### Resolve DNS Records
+
+```bash
+# A record (default)
+gcnspack resolve example.com
+
+# Specific record type
+gcnspack resolve example.com -t MX
+
+# Custom nameserver
+gcnspack resolve example.com -n 1.1.1.1
+```
+
+![resolve demo](docs/resolve-demo.svg)
+
+### Encode a File for DNS
+
+```bash
+# Print zone records to stdout
+gcnspack encode payload.bin -s files.example.com
+
+# Write to a zone file
+gcnspack encode payload.bin -s files.example.com -o records.zone
+```
+
+![encode demo](docs/encode-demo.svg)
+
+### Fetch a File from DNS
+
+```bash
+gcnspack fetch files.example.com -o output.bin
+```
+
+![fetch demo](docs/fetch-demo.svg)
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/geekennedy/gcnspack.git
+cd gcnspack
+uv sync
+
+# Run unit tests
+uv run pytest -q -m "not integration"
+
+# Run integration tests (requires live DNS)
+uv run pytest -q -m integration
+
+# Run all tests
+uv run pytest -q
+
+# Lint and format
+uv run ruff check src/ tests/
+uv run ruff format src/ tests/
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Author
+
+**geekennedy** - [gkennedy@gcloudns.net](mailto:gkennedy@gcloudns.net)

nspack-0.1.0/README.md

@@ -0,0 +1,197 @@
+# gcnspack
+
+[![PyPI version](https://img.shields.io/pypi/v/gcnspack.svg)](https://pypi.org/project/gcnspack/)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13%2B-blue.svg)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Simple DNS resolver and file-over-DNS transfer toolkit.
+
+![gcnspack overview](docs/overview.svg)
+
+## Features
+
+- **DNS Resolver** - Simple, batteries-included DNS resolution with sensible defaults (Cloudflare, Google, Quad9 fallbacks)
+- **File-over-DNS** - Encode arbitrary files into DNS TXT records and reconstruct them from DNS queries
+- **CLI** - Command-line interface for resolving DNS and managing file transfers
+- **Protocol** - Chunked base32/base64 encoding scheme with SHA-256 integrity verification
+
+## Installation
+
+```bash
+pip install gcnspack
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add gcnspack
+```
+
+## Quick Start
+
+### DNS Resolution
+
+```python
+from gcnspack import resolve, resolve_all, create_resolver
+
+# Simple A record lookup
+ips = resolve("example.com")
+# ['93.184.216.34']
+
+# Query specific record types
+mx = resolve("example.com", "MX")
+txt = resolve("example.com", "TXT")
+
+# Query multiple record types at once
+all_records = resolve_all("example.com")
+# {'A': [...], 'AAAA': [...], 'MX': [...], 'TXT': [...], 'NS': [...], 'CNAME': [...]}
+
+# Use a custom resolver
+r = create_resolver(nameservers=["1.1.1.1"], timeout=10.0)
+result = resolve("example.com", "A", resolver=r)
+```
+
+### File-over-DNS Transfer
+
+#### Encoding a File
+
+```python
+from gcnspack import encode_file, generate_zone_records
+
+# Read a file and generate DNS zone records
+with open("payload.bin", "rb") as f:
+    data = f.read()
+
+# Generate zone-file TXT records
+records = generate_zone_records(data, "files.example.com")
+for record in records:
+    print(record)
+```
+
+Output:
+
+```
+0.files.example.com  IN  TXT  "GAYTEMZUGU3DOOB..."
+1.files.example.com  IN  TXT  "GAYTEMZUGU3DOOC..."
+_meta.files.example.com  IN  TXT  "ON2HE2LOM4QHO..."
+```
+
+#### Fetching a File from DNS
+
+```python
+from gcnspack import save_txt_file
+
+# Pull TXT records, decode, verify hash, and save
+save_txt_file("files.example.com", "output.bin")
+```
+
+## Protocol
+
+Files are transferred over DNS using this encoding scheme:
+
+```
+                    +-------------------+
+                    |   Original File   |
+                    +-------------------+
+                            |
+                      Split into chunks
+                       (150 bytes each)
+                            |
+                    +-------+-------+
+                    |       |       |
+                    v       v       v
+               Chunk 0  Chunk 1  Chunk N
+                    |       |       |
+               Base64 encode each chunk
+                    |       |       |
+              Add header: "idx:total:base64data"
+                    |       |       |
+              Base32 encode entire string
+                    |       |       |
+                    v       v       v
+          +-------------------------------------------+
+          |  DNS TXT Records                          |
+          |  0.sub.example.com  TXT  "<base32>"       |
+          |  1.sub.example.com  TXT  "<base32>"       |
+          |  N.sub.example.com  TXT  "<base32>"       |
+          |  _meta.sub.example.com  TXT  "<meta_b32>" |
+          +-------------------------------------------+
+```
+
+**Metadata record** (`_meta.<subdomain>`): Contains `sha256:<hash>:chunks:<count>`, base32-encoded.
+
+**Chunk records** (`<n>.<subdomain>`): Each contains `<index>:<total>:<base64_data>`, base32-encoded.
+
+Reconstruction:
+1. Fetch `_meta.<subdomain>` to get chunk count and expected SHA-256 hash
+2. Fetch chunks `0` through `N-1` from `<n>.<subdomain>`
+3. Decode each chunk (base32 -> parse header -> base64 decode payload)
+4. Sort by index, concatenate
+5. Verify SHA-256 hash matches
+
+## CLI Usage
+
+### Resolve DNS Records
+
+```bash
+# A record (default)
+gcnspack resolve example.com
+
+# Specific record type
+gcnspack resolve example.com -t MX
+
+# Custom nameserver
+gcnspack resolve example.com -n 1.1.1.1
+```
+
+![resolve demo](docs/resolve-demo.svg)
+
+### Encode a File for DNS
+
+```bash
+# Print zone records to stdout
+gcnspack encode payload.bin -s files.example.com
+
+# Write to a zone file
+gcnspack encode payload.bin -s files.example.com -o records.zone
+```
+
+![encode demo](docs/encode-demo.svg)
+
+### Fetch a File from DNS
+
+```bash
+gcnspack fetch files.example.com -o output.bin
+```
+
+![fetch demo](docs/fetch-demo.svg)
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/geekennedy/gcnspack.git
+cd gcnspack
+uv sync
+
+# Run unit tests
+uv run pytest -q -m "not integration"
+
+# Run integration tests (requires live DNS)
+uv run pytest -q -m integration
+
+# Run all tests
+uv run pytest -q
+
+# Lint and format
+uv run ruff check src/ tests/
+uv run ruff format src/ tests/
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Author
+
+**geekennedy** - [gkennedy@gcloudns.net](mailto:gkennedy@gcloudns.net)

nspack-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "nspack"
+version = "0.1.0"
+description = "Simple DNS resolver and file-over-DNS transfer toolkit"
+readme = "README.md"
+authors = [
+    { name = "geekennedy", email = "gkennedy@gcloudns.net" }
+]
+requires-python = ">=3.13"
+license = "MIT"
+keywords = ["dns", "resolver", "file-transfer", "txt-records"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: Name Service (DNS)",
+]
+dependencies = [
+    "dnspython>=2.7.0",
+    "click>=8.1.0",
+]
+
+[project.scripts]
+gcnspack = "gcnspack.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.7,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "gcnspack"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.15.6",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "integration: marks tests requiring live DNS (deselect with '-m \"not integration\"')",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP"]

nspack-0.1.0/src/gcnspack/__init__.py

@@ -0,0 +1,16 @@
+"""gcnspack - Simple DNS resolver and file-over-DNS transfer toolkit."""
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "create_resolver",
+    "decode_chunks",
+    "encode_file",
+    "generate_zone_records",
+    "resolve",
+    "resolve_all",
+    "save_txt_file",
+]
+
+from gcnspack.filedns import decode_chunks, encode_file, generate_zone_records, save_txt_file
+from gcnspack.resolver import create_resolver, resolve, resolve_all

nspack-0.1.0/src/gcnspack/cli.py

@@ -0,0 +1,63 @@
+"""CLI for gcnspack - DNS resolver and file-over-DNS toolkit."""
+
+import sys
+from pathlib import Path
+
+import click
+
+from gcnspack.filedns import generate_zone_records, save_txt_file
+from gcnspack.resolver import create_resolver, resolve
+
+
+@click.group()
+@click.version_option()
+def main():
+    """gcnspack - Simple DNS resolver and file-over-DNS transfer toolkit."""
+
+
+@main.command()
+@click.argument("domain")
+@click.option("-t", "--type", "rdtype", default="A", help="DNS record type")
+@click.option("-n", "--nameserver", multiple=True, help="Custom nameserver(s)")
+def resolve_cmd(domain: str, rdtype: str, nameserver: tuple[str, ...]):
+    """Resolve DNS records for DOMAIN."""
+    r = create_resolver(nameservers=list(nameserver)) if nameserver else None
+    results = resolve(domain, rdtype, resolver=r)
+    if not results:
+        click.echo(f"No {rdtype} records found for {domain}", err=True)
+        sys.exit(1)
+    for record in results:
+        click.echo(record)
+
+
+# Register with the name "resolve" (click doesn't allow reusing Python names)
+resolve_cmd.name = "resolve"
+
+
+@main.command()
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--subdomain", "-s", required=True, help="Base subdomain for TXT records")
+@click.option("--output", "-o", type=click.Path(), help="Write zone records to file")
+def encode(file: str, subdomain: str, output: str | None):
+    """Encode FILE into DNS TXT zone records."""
+    data = Path(file).read_bytes()
+    records = generate_zone_records(data, subdomain)
+    text = "\n".join(records) + "\n"
+    if output:
+        Path(output).write_text(text)
+        click.echo(f"Wrote {len(records)} records to {output}")
+    else:
+        click.echo(text)
+
+
+@main.command()
+@click.argument("subdomain")
+@click.option("--output", "-o", required=True, help="Output file path")
+def fetch(subdomain: str, output: str):
+    """Fetch and reconstruct a file from DNS TXT records at SUBDOMAIN."""
+    try:
+        save_txt_file(subdomain, output)
+        click.echo(f"Saved file to {output}")
+    except RuntimeError as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)

nspack-0.1.0/src/gcnspack/filedns.py

@@ -0,0 +1,166 @@
+"""File-over-DNS encoding and decoding via TXT records.
+
+Protocol:
+    Each file chunk is stored as a TXT record at <chunk_idx>.<subdomain>.
+    The TXT record value is base32-encoded, containing: "idx:total:base64data"
+    A metadata record at _meta.<subdomain> stores: "sha256:<hash>:chunks:<count>"
+"""
+
+import base64
+import hashlib
+import math
+
+from gcnspack.resolver import resolve
+
+# Max raw bytes per chunk before base64 encoding.
+# TXT records can hold ~255 bytes per string. After base64 + base32 encoding
+# with header overhead, 150 bytes of raw data per chunk is safe.
+CHUNK_SIZE = 150
+
+
+def encode_file(data: bytes) -> list[str]:
+    """Encode file bytes into a list of base32 TXT record values.
+
+    Args:
+        data: Raw file bytes to encode.
+
+    Returns:
+        List of base32-encoded chunk strings, ordered by index.
+    """
+    if len(data) == 0:
+        inner = f"0:1:{base64.b64encode(b'').decode()}"
+        return [base64.b32encode(inner.encode()).decode()]
+
+    total = math.ceil(len(data) / CHUNK_SIZE)
+    chunks = []
+    for i in range(total):
+        start = i * CHUNK_SIZE
+        end = start + CHUNK_SIZE
+        chunk_data = data[start:end]
+        b64 = base64.b64encode(chunk_data).decode()
+        inner = f"{i}:{total}:{b64}"
+        chunks.append(base64.b32encode(inner.encode()).decode())
+    return chunks
+
+
+def parse_txt_record(record: str) -> tuple[int, int, bytes]:
+    """Parse a single base32-encoded TXT record value.
+
+    Args:
+        record: Base32-encoded string from a TXT record.
+
+    Returns:
+        Tuple of (chunk_index, total_chunks, raw_payload_bytes).
+
+    Raises:
+        ValueError: If the record cannot be decoded or has invalid format.
+    """
+    try:
+        decoded = base64.b32decode(record).decode("ascii")
+    except Exception as exc:
+        raise ValueError(f"Failed to decode base32 TXT record: {exc}") from exc
+
+    parts = decoded.split(":", 2)
+    if len(parts) != 3:
+        raise ValueError(f"Invalid chunk format: expected 'idx:total:data', got '{decoded}'")
+
+    idx = int(parts[0])
+    total = int(parts[1])
+    payload = base64.b64decode(parts[2])
+    return idx, total, payload
+
+
+def decode_chunks(chunks: list[str]) -> bytes:
+    """Decode a list of base32 TXT record values back to file bytes.
+
+    Chunks can be in any order; they are sorted by index.
+
+    Args:
+        chunks: List of base32-encoded chunk strings.
+
+    Returns:
+        Reconstructed file bytes.
+    """
+    parsed = [parse_txt_record(chunk) for chunk in chunks]
+    parsed.sort(key=lambda x: x[0])
+    return b"".join(payload for _, _, payload in parsed)
+
+
+def generate_zone_records(data: bytes, subdomain: str) -> list[str]:
+    """Generate DNS zone-file TXT records for a file.
+
+    Args:
+        data: Raw file bytes to encode.
+        subdomain: Base subdomain (e.g., "files.example.com").
+
+    Returns:
+        List of zone-file lines, including chunk records and a _meta record.
+    """
+    chunks = encode_file(data)
+    total = len(chunks)
+    sha256 = hashlib.sha256(data).hexdigest()
+
+    records = []
+    for i, chunk in enumerate(chunks):
+        records.append(f'{i}.{subdomain}\tIN\tTXT\t"{chunk}"')
+
+    meta = f"sha256:{sha256}:chunks:{total}"
+    meta_b32 = base64.b32encode(meta.encode()).decode()
+    records.append(f'_meta.{subdomain}\tIN\tTXT\t"{meta_b32}"')
+    return records
+
+
+def fetch_file(subdomain: str) -> bytes:
+    """Fetch and reconstruct a file from DNS TXT records.
+
+    Reads _meta.<subdomain> for chunk count, then fetches each chunk.
+
+    Args:
+        subdomain: The subdomain where chunks are stored.
+
+    Returns:
+        Reconstructed file bytes.
+
+    Raises:
+        RuntimeError: If metadata or chunks cannot be fetched.
+    """
+    meta_records = resolve(f"_meta.{subdomain}", "TXT")
+    if not meta_records:
+        raise RuntimeError(f"No metadata found at _meta.{subdomain}")
+
+    meta_raw = meta_records[0].strip('"')
+    try:
+        meta_decoded = base64.b32decode(meta_raw).decode("ascii")
+    except Exception as exc:
+        raise RuntimeError(f"Failed to decode metadata: {exc}") from exc
+
+    parts = meta_decoded.split(":")
+    # Format: sha256:<hash>:chunks:<count>
+    sha256_expected = parts[1]
+    total_chunks = int(parts[3])
+
+    chunks = []
+    for i in range(total_chunks):
+        txt = resolve(f"{i}.{subdomain}", "TXT")
+        if not txt:
+            raise RuntimeError(f"Missing chunk {i} at {i}.{subdomain}")
+        chunks.append(txt[0].strip('"'))
+
+    data = decode_chunks(chunks)
+
+    sha256_actual = hashlib.sha256(data).hexdigest()
+    if sha256_actual != sha256_expected:
+        raise RuntimeError(f"Hash mismatch: expected {sha256_expected}, got {sha256_actual}")
+    return data
+
+
+def save_txt_file(subdomain: str, file_name: str) -> None:
+    """Fetch a file from DNS TXT records and save it locally.
+
+    Args:
+        subdomain: The subdomain where chunks are stored.
+        file_name: Local path to write the reconstructed file.
+    """
+    data = fetch_file(subdomain)
+    with open(file_name, "wb") as f:
+        f.write(data)

nspack-0.1.0/src/gcnspack/resolver.py

@@ -0,0 +1,73 @@
+"""DNS resolver with sensible defaults."""
+
+import dns.resolver
+
+DEFAULT_NAMESERVERS = ["1.1.1.1", "8.8.8.8", "9.9.9.9"]
+DEFAULT_TIMEOUT = 5.0
+DEFAULT_RECORD_TYPES = ["A", "AAAA", "MX", "TXT", "NS", "CNAME"]
+
+
+def create_resolver(
+    nameservers: list[str] | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> dns.resolver.Resolver:
+    """Create a configured DNS resolver.
+
+    Args:
+        nameservers: List of nameserver IPs. Defaults to public resolvers.
+        timeout: Query lifetime in seconds.
+    """
+    r = dns.resolver.Resolver()
+    r.nameservers = nameservers or DEFAULT_NAMESERVERS
+    r.lifetime = timeout
+    return r
+
+
+_default_resolver = create_resolver()
+
+
+def resolve(
+    domain: str,
+    rdtype: str = "A",
+    resolver: dns.resolver.Resolver | None = None,
+) -> list[str]:
+    """Resolve a DNS query, returning a list of string answers.
+
+    Args:
+        domain: The domain name to query.
+        rdtype: DNS record type (A, AAAA, MX, TXT, etc.).
+        resolver: Optional custom resolver. Uses default if None.
+
+    Returns:
+        List of string representations of DNS answers, or empty list on failure.
+    """
+    r = resolver or _default_resolver
+    try:
+        answer = r.resolve(domain, rdtype)
+        return [str(rdata) for rdata in answer]
+    except (
+        dns.resolver.NXDOMAIN,
+        dns.resolver.NoAnswer,
+        dns.resolver.LifetimeTimeout,
+        dns.resolver.NoNameservers,
+    ):
+        return []
+
+
+def resolve_all(
+    domain: str,
+    rdtypes: list[str] | None = None,
+    resolver: dns.resolver.Resolver | None = None,
+) -> dict[str, list[str]]:
+    """Resolve multiple record types for a domain.
+
+    Args:
+        domain: The domain name to query.
+        rdtypes: List of record types. Defaults to common types.
+        resolver: Optional custom resolver.
+
+    Returns:
+        Dict mapping record type to list of answers.
+    """
+    types = rdtypes or DEFAULT_RECORD_TYPES
+    return {rdtype: resolve(domain, rdtype, resolver) for rdtype in types}