DNS NULL Records: The Hidden Data Transfer Method

#!/usr/bin/env python3
"""
Generate BIND9 DNS NULL record entries from any file.

This script can operate in two modes:
1. Single record mode: If no chunk size is specified and file <= 65KB,
   creates a single NULL record containing the entire file.
2. Split mode: If a chunk size is specified, splits the file into multiple
   NULL records with a metadata TXT record for reconstruction.

Usage:
    python3 dns_null_record.py <file> <record_name> [chunk_size]
"""

import sys
import os
import math

def read_file_to_bytes(filename):
    """
    Read a file and return its contents as bytes.

    Args:
        filename: Path to the file to read

    Returns:
        bytes: File contents

    Raises:
        SystemExit: If file doesn't exist or can't be read
    """
    if not os.path.exists(filename):
        print(f"Error: File '{filename}' not found", file=sys.stderr)
        sys.exit(1)

    try:
        with open(filename, 'rb') as f:
            return f.read()
    except Exception as e:
        print(f"Error reading file: {e}", file=sys.stderr)
        sys.exit(1)


def create_single_null_record(data, record_name):
    """
    Create a single BIND9 NULL record from binary data.

    Args:
        data: Binary data to encode
        record_name: DNS record name

    Returns:
        None (prints to stdout)
    """
    file_size = len(data)

    # Check if file is empty
    if file_size == 0:
        print("Error: File is empty", file=sys.stderr)
        sys.exit(1)

    print(f"; Single NULL record with {file_size} bytes", file=sys.stderr)

    # Convert to hex string for BIND zone file
    hex_string = data.hex().upper()

    # Create the NULL record line
    print(f"{record_name}\tIN\tNULL\t\\# {file_size} {hex_string}")


def split_data_into_chunks(data, chunk_size):
    """
    Split binary data into chunks for multiple DNS records.

    Args:
        data: Binary data to split
        chunk_size: Maximum bytes per chunk

    Returns:
        list: List of dictionaries containing chunk information
              Each dict has keys: 'index', 'size', 'hex'
    """
    chunks = []
    for i in range(0, len(data), chunk_size):
        chunk = data[i:i + chunk_size]
        hex_data = chunk.hex().upper()
        chunks.append({
            'index': len(chunks),
            'size': len(chunk),
            'hex': hex_data
        })

    return chunks


def generate_split_zone_entries(chunks, base_name):
    """
    Generate BIND9 zone file entries for split NULL records.

    Args:
        chunks: List of chunk dictionaries from split_data_into_chunks()
        base_name: Base name for chunk records

    Returns:
        None (prints to stdout)
    """
    print(f"; Total chunks: {len(chunks)}")
    print()

    # Metadata record stores the number of chunks for reconstruction
    print(f"meta.{base_name}\tIN\tTXT\t\"{len(chunks)}\"")
    print()

    # Individual chunk records
    for chunk in chunks:
        subdomain = f"{base_name}{chunk['index']}"
        print(f"{subdomain}\tIN\tNULL\t\\# {chunk['size']} {chunk['hex']}")


def main():
    """
    Main function to handle command-line arguments and orchestrate record generation.
    """
    # Maximum size for a single DNS NULL record (64KB - 1 byte)
    MAX_SINGLE_RECORD_SIZE = 65535

    # Parse command-line arguments
    if len(sys.argv) < 2:
        print("Usage: python3 dns_null_record.py <file> <record_name> [chunk_size]")
        print("\nExamples:")
        print("  # Single record mode (file must be <= 65KB)")
        print("  python3 dns_null_record.py data.bin Record-Name")
        print()
        print("  # Split mode (splits file into chunks)")
        print("  python3 dns_null_record.py large_file.bin my-chunk 2048")
        print()
        print("Note: Smaller chunk sizes (1024-2048 bytes) are recommended for DNS compatibility")
        sys.exit(1)

    filename = sys.argv[1]
    record_name = sys.argv[2] if len(sys.argv) > 2 else None
    chunk_size = int(sys.argv[3]) if len(sys.argv) > 3 else None

    # Validate that record_name is provided
    if record_name is None:
        print("Error: record_name is required", file=sys.stderr)
        print("Usage: python3 dns_null_record.py <file> <record_name> [chunk_size]", file=sys.stderr)
        sys.exit(1)

    # Read the file
    data = read_file_to_bytes(filename)
    file_size = len(data)

    # Determine operation mode
    if chunk_size is None or chunk_size == 0:
        # Single record mode
        if file_size > MAX_SINGLE_RECORD_SIZE:
            print(f"Error: File size is {file_size} bytes ({file_size/1024:.2f} KB)", file=sys.stderr)
            print(f"Maximum size for a single NULL record is {MAX_SINGLE_RECORD_SIZE} bytes ({MAX_SINGLE_RECORD_SIZE/1024:.2f} KB)", file=sys.stderr)
            print(f"Please specify a chunk_size argument to split the file into multiple records.", file=sys.stderr)
            print(f"\nExample: python3 dns_null_record.py {filename} my-record 2048", file=sys.stderr)
            sys.exit(1)

        # Use provided record name or default
        create_single_null_record(data, record_name)
    else:
        # Split mode
        print(f"; File size: {file_size} bytes", file=sys.stderr)
        print(f"; Chunk size: {chunk_size} bytes", file=sys.stderr)
        num_chunks = math.ceil(file_size / chunk_size)
        print(f"; Number of chunks: {num_chunks}", file=sys.stderr)
        print(file=sys.stderr)

        # Warn for large files
        if file_size > 10240:  # Warn if > 10KB
            print(f"WARNING: File is {file_size} bytes ({file_size/1024:.1f} KB)", file=sys.stderr)
            print("This will create many DNS records and may be impractical.", file=sys.stderr)
            print("Consider using a smaller file (< 5KB recommended) or larger chunk size\n", file=sys.stderr)

        # Split and generate zone entries
        chunks = split_data_into_chunks(data, chunk_size)
        generate_split_zone_entries(chunks, record_name)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
DNS File Fetcher
Reconstructs files by fetching data from DNS NULL records.
"""

import argparse
import subprocess
import sys
import os
import re
from pathlib import Path


class Colors:
    """ANSI color codes for terminal output."""
    RED = '\033[0;31m'
    GREEN = '\033[0;32m'
    YELLOW = '\033[1;33m'
    NC = '\033[0m'  # No Color


def print_colored(message, color=Colors.NC):
    """Print a colored message to the terminal."""
    print(f"{color}{message}{Colors.NC}")


def print_error(message):
    """Print an error message in red."""
    print_colored(f"Error: {message}", Colors.RED)


def print_success(message):
    """Print a success message in green."""
    print_colored(f"✓ {message}", Colors.GREEN)


def print_info(message):
    """Print an info message in yellow."""
    print_colored(message, Colors.YELLOW)


def run_dig_command(query, record_type="TXT"):
    """
    Execute a dig command and return the output.
    
    Args:
        query: The DNS query to perform
        record_type: The DNS record type (TXT or NULL)
    
    Returns:
        The dig command output as a string, or None if failed
    """
    try:
        result = subprocess.run(
            ["dig", "+short", query, record_type],
            capture_output=True,
            text=True,
            timeout=10
        )
        
        if result.returncode != 0:
            return None
            
        return result.stdout.strip()
    
    except subprocess.TimeoutExpired:
        print_error(f"DNS query timed out for {query}")
        return None
    except FileNotFoundError:
        print_error("'dig' command not found. Please install dnsutils/bind-tools package.")
        sys.exit(1)
    except Exception as e:
        print_error(f"Failed to execute dig command: {e}")
        return None


def fetch_metadata(base, zone):
    """
    Fetch metadata from DNS TXT record to determine the number of chunks.
    
    Args:
        base: The base name for DNS records
        zone: The DNS zone to query
    
    Returns:
        Number of chunks as an integer
    """
    print_info("[1/3] Fetching metadata...")
    
    query = f"meta.{base}.{zone}"
    meta = run_dig_command(query, "TXT")
    
    if not meta:
        print_error(f"Failed to fetch metadata from {query}")
        print("Make sure the DNS server is running and the record exists.")
        sys.exit(1)
    
    # Remove quotes from TXT record
    meta = meta.replace('"', '')
    
    print(f"Metadata: {meta}")
    
    # Validate that metadata is a number
    if not re.match(r'^\d+$', meta):
        print_error("Invalid chunk count in metadata")
        print(f"Expected a number, got: {meta}")
        sys.exit(1)
    
    chunks = int(meta)
    print_success(f"Found {chunks} chunks to fetch")
    print()
    
    return chunks


def fetch_chunk(chunk_id, base, zone):
    """
    Fetch a single chunk from DNS NULL record.
    
    Args:
        chunk_id: The chunk number to fetch
        base: The base name for DNS records
        zone: The DNS zone to query
    
    Returns:
        Bytes data of the chunk, or None if failed
    """
    query = f"{base}{chunk_id}.{zone}"
    dig_output = run_dig_command(query, "NULL")
    
    if not dig_output:
        return None
    
    # Extract hex data - remove "\# <number> " prefix and all whitespace
    # The NULL record format is: \# <length> <hex_data>
    hex_data = re.sub(r'\\#\s+\d+\s+', '', dig_output)
    hex_data = re.sub(r'\s+', '', hex_data)
    
    if not hex_data:
        return None
    
    # Validate hex string
    if not re.match(r'^[0-9a-fA-F]+$', hex_data):
        print_error(f"Invalid hex data for chunk {chunk_id}")
        return None
    
    # Convert hex to bytes
    try:
        return bytes.fromhex(hex_data)
    except ValueError as e:
        print_error(f"Failed to convert hex to bytes for chunk {chunk_id}: {e}")
        return None


def fetch_all_chunks(chunks, base, zone):
    """
    Fetch all chunks from DNS.
    
    Args:
        chunks: Total number of chunks to fetch
        base: The base name for DNS records
        zone: The DNS zone to query
    
    Returns:
        List of byte data for each chunk
    """
    print_info(f"[2/3] Fetching {chunks} chunks...")
    
    chunk_data = []
    failed = 0
    
    for i in range(chunks):
        print(f"  Chunk {i + 1}/{chunks}... ", end='', flush=True)
        
        data = fetch_chunk(i, base, zone)
        
        if data is None:
            print_colored("FAILED (no response or invalid data)", Colors.RED)
            failed += 1
            chunk_data.append(b'')  # Placeholder for failed chunk
            continue
        
        chunk_data.append(data)
        print_colored(f"OK ({len(data)} bytes)", Colors.GREEN)
    
    print()
    
    if failed > 0:
        print_error(f"Failed to fetch {failed} chunk(s)")
        sys.exit(1)
    
    return chunk_data


def reconstruct_file(chunk_data, output_file):
    """
    Reconstruct the file from chunks and write to disk.
    
    Args:
        chunk_data: List of byte data for each chunk
        output_file: Path to the output file
    """
    print_info("[3/3] Reconstructing file...")
    
    try:
        # Create output directory if it doesn't exist
        output_path = Path(output_file)
        output_path.parent.mkdir(parents=True, exist_ok=True)
        
        # Write all chunks to file
        with open(output_file, 'wb') as f:
            for chunk in chunk_data:
                f.write(chunk)
        
        # Get file size
        file_size = os.path.getsize(output_file)
        
        print_success("Success!")
        print()
        print("=" * 40)
        print(f"Output file: {output_file}")
        print(f"File size: {file_size} bytes")
        print("=" * 40)
        
        # Try to identify file type using 'file' command
        try:
            result = subprocess.run(
                ["file", output_file],
                capture_output=True,
                text=True,
                timeout=5
            )
            if result.returncode == 0:
                print()
                print(result.stdout.strip())
        except (FileNotFoundError, subprocess.TimeoutExpired):
            # 'file' command not available or timed out, skip file type detection
            pass
    
    except IOError as e:
        print_error(f"Failed to write output file: {e}")
        sys.exit(1)
    except Exception as e:
        print_error(f"Unexpected error during file reconstruction: {e}")
        sys.exit(1)


def main():
    """Main function to orchestrate the DNS file fetching process."""
    parser = argparse.ArgumentParser(
        description="Fetch and reconstruct files from DNS NULL records",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s -o image.jpg -b chunk -z null.dns.example.com
  %(prog)s --output document.pdf --base data --zone files.dns.example.org
        """
    )
    
    parser.add_argument(
        '-o', '--output',
        required=True,
        help='Output file path'
    )
    
    parser.add_argument(
        '-b', '--base',
        required=True,
        help='Base name for DNS records (e.g., "chunk")'
    )
    
    parser.add_argument(
        '-z', '--zone',
        required=True,
        help='DNS zone to query (e.g., "null.dns.example.com")'
    )
    
    args = parser.parse_args()
    
    # Print header
    print_colored("DNS File Fetcher", Colors.GREEN)
    print("=" * 40)
    print(f"Zone: {args.zone}")
    print(f"Base name: {args.base}")
    print(f"Output: {args.output}")
    print()
    
    # Step 1: Fetch metadata
    chunks = fetch_metadata(args.base, args.zone)
    
    # Step 2: Fetch all chunks
    chunk_data = fetch_all_chunks(chunks, args.base, args.zone)
    
    # Step 3: Reconstruct file
    reconstruct_file(chunk_data, args.output)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print()
        print_error("Operation cancelled by user")
        sys.exit(130)
    except Exception as e:
        print_error(f"Unexpected error: {e}")
        sys.exit(1)