or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

dns-constants.mddns-exceptions.mddns-messages.mddns-names.mddns-queries.mddns-records.mddns-resolution.mddns-updates.mddns-utilities.mddns-zones.mddnssec.mdindex.mdtsig.md
tile.json

tessl/pypi-dnspython

DNS toolkit for Python supporting almost all record types with high-level and low-level DNS operations

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/dnspython@1.16.x

To install, run

npx @tessl/cli install tessl/pypi-dnspython@1.16.0

index.mddocs/

DNSPython

DNSPython is a comprehensive DNS toolkit for Python that supports almost all DNS record types and provides both high-level and low-level access to DNS functionality. It enables queries, zone transfers, dynamic updates, TSIG authenticated messages, and EDNS0 operations with support for DNSSEC validation.

Package Information

  • Package Name: dnspython
  • Language: Python
  • Installation: pip install dnspython

Core Imports

import dns

Common imports for specific functionality:

import dns.resolver
import dns.query
import dns.message
import dns.name
import dns.zone

Import specific record types:

from dns import rdatatype, rdataclass

Basic Usage

import dns.resolver

# High-level DNS resolution
resolver = dns.resolver.Resolver()
result = dns.resolver.query('example.com', 'A')
for rdata in result:
    print(f"IP address: {rdata.address}")

# Query specific record types
mx_records = dns.resolver.query('example.com', 'MX')
for rdata in mx_records:
    print(f"Mail server: {rdata.exchange}, priority: {rdata.preference}")

# Custom resolver configuration
resolver.nameservers = ['8.8.8.8', '8.8.4.4']
resolver.timeout = 30
resolver.lifetime = 60

Architecture

DNSPython provides a layered architecture for DNS operations:

  • High-level: dns.resolver for simple queries with automatic retry and caching
  • Mid-level: dns.query for direct message exchange with nameservers
  • Low-level: dns.message, dns.name, dns.rdata for direct protocol manipulation
  • Zone operations: dns.zone for zone file parsing and manipulation
  • Security: dns.dnssec, dns.tsig for authentication and validation

This design enables everything from simple hostname resolution to complex DNS server implementations and security analysis tools.

Capabilities

High-Level DNS Resolution

Simple DNS queries with automatic retry, caching, and error handling. Provides the easiest interface for common DNS lookups and supports all standard record types.

def query(qname, rdtype='A', rdclass='IN', tcp=False, source=None, 
          raise_on_no_answer=True, source_port=0, lifetime=None): ...
def zone_for_name(name, rdclass='IN', tcp=False, resolver=None): ...

DNS Resolution

Low-Level DNS Queries

Direct DNS message exchange with nameservers using UDP or TCP. Provides fine-grained control over query parameters, timeouts, and response handling.

def udp(q, where, timeout=None, port=53, af=None, source=None, source_port=0): ...
def tcp(q, where, timeout=None, port=53, af=None, source=None, source_port=0): ...
def xfr(where, zone, rdtype='AXFR', rdclass='IN', timeout=None, port=53): ...

DNS Queries

DNS Message Manipulation

Create, parse, and manipulate DNS messages with full protocol support. Handle questions, answers, authority, and additional sections with complete header control.

def make_query(qname, rdtype, rdclass='IN', use_edns=None, want_dnssec=False): ...
def make_response(query, recursion_available=False, our_payload=8192): ...
def from_wire(wire, keyring=None, request_mac=b'', xfr=False): ...

DNS Messages

DNS Name Operations

Parse, manipulate, and format DNS names with full internationalization support. Handle absolute/relative names, wildcards, and IDNA encoding.

def from_text(text, origin=None, idna_codec=None): ...
def from_unicode(text, origin=None, idna_codec=None): ...
def from_wire(message, current): ...

DNS Names

DNS Zone Management

Parse, create, and manipulate DNS zones from files or transfers. Support for zone validation, iteration, and modification operations.

def from_text(text, origin=None, rdclass='IN', relativize=True): ...
def from_file(f, origin=None, rdclass='IN', relativize=True): ...
def from_xfr(xfr, zone_factory=None, relativize=True): ...

DNS Zones

DNS Record Types and Data

Comprehensive support for all DNS record types including modern types like TLSA, CAA, and CDS. Handle record parsing, formatting, and validation.

# Record type constants
A = 1
NS = 2
CNAME = 5
SOA = 6
MX = 15
TXT = 16
AAAA = 28
SRV = 33
TLSA = 52
CAA = 257

DNS Records

DNSSEC Operations

Validate DNSSEC signatures, handle keys, and perform cryptographic operations. Support for all DNSSEC record types and validation algorithms.

def validate(rrset, rrsigset, keys, origin=None, now=None): ...
def validate_rrsig(rrset, rrsig, keys, origin=None, now=None): ...
def make_ds(name, key, algorithm, origin=None): ...

DNSSEC

Dynamic DNS Updates

Create and send dynamic DNS update messages with authentication. Support for adding, deleting, and replacing resource records.

def add(name, *args): ...
def delete(name, *args): ...
def replace(name, *args): ...
def present(name, *args): ...
def absent(name, *args): ...

DNS Updates

TSIG Authentication

Transaction signature support for authenticated DNS messages. Handle key management, signature generation, and verification.

def sign(wire, keyring, keyname, fudge=300, original_id=None, tsig_error=0): ...
def validate(wire, keyring, request_mac, now=None, request_fudge=None): ...

TSIG Authentication

DNS Constants and Enumerations

Essential constants for DNS record types, classes, message flags, opcodes, and response codes. These constants are fundamental for all DNS operations and message handling.

# Record types
A = 1
NS = 2
CNAME = 5
SOA = 6
MX = 15
TXT = 16
AAAA = 28
SRV = 33

# Record classes  
IN = 1      # Internet
CH = 3      # Chaos
ANY = 255   # Any class

# Message flags
QR = 0x8000   # Query Response
AA = 0x0400   # Authoritative Answer
TC = 0x0200   # Truncated
RD = 0x0100   # Recursion Desired

DNS Constants

Exception Handling

Comprehensive exception classes for handling DNS errors, timeouts, validation failures, and operational issues. Essential for robust DNS application development.

class DNSException(Exception): ...
class FormError(DNSException): ...
class Timeout(DNSException): ...
class NXDOMAIN(DNSException): ...
class NoAnswer(DNSException): ...
class ValidationFailure(DNSException): ...

DNS Exceptions

DNS Utilities

Utility functions for IP address processing, reverse DNS operations, E.164 number handling, and address family detection. Supporting tools for common DNS operations.

def from_address(text: str) -> dns.name.Name: ...  # IP to reverse DNS
def to_address(name: dns.name.Name) -> str: ...    # Reverse DNS to IP
def af_for_address(text: str) -> int: ...          # Address family detection
def is_multicast(text: str) -> bool: ...           # Multicast detection

DNS Utilities

Types

class DNSException(Exception):
    """Base class for all DNS exceptions."""

class Timeout(DNSException):
    """DNS operation timed out."""

class NXDOMAIN(DNSException):
    """Query name does not exist."""

class NoAnswer(DNSException):
    """DNS response contains no answer to the question."""

class Name:
    """An immutable DNS name."""
    
class Resolver:
    """High-level DNS resolver with configurable options."""
    
class Message:
    """A DNS message with header and sections."""
    
class Zone:
    """A DNS zone as a mapping from names to nodes."""