Getting information on DNS server with DNS python

The Domain Name System (DNS) is a hierarchical and distributed naming system for computers, services, or other resources connected to the Internet or other Internet Protocol (IP) networks. It associates various information with domain names assigned to each of the associated entities. Most prominently, it translates readily memorized domain names to the numerical IP addresses needed for locating and identifying computer services and devices with the underlying network protocols. The Domain Name System has been an essential component of the functionality of the Internet since 1985.

DNS Protocol Structure

The DNS protocol is based on a client-server model, where a DNS resolver acts as a client to query DNS servers for information about domain names. The DNS protocol uses a message format that consists of a header and four sections:

• Header: Contains general information about the DNS query, such as its type, ID, and flags.
• Question: Specifies the domain name or resource record that the client is asking about.
• Answer: Contains the response to the client’s query, typically providing the IP address associated with the domain name.
• Authority: Indicates which DNS server is authoritative for the domain name in question.
• Additional: Provides additional information that may be helpful for the client, such as MX (mail exchange) records for email routing.

DNS Query Process

When a user enters a domain name into a web browser, the following steps occur to resolve the domain name to an IP address:

1. DNS Resolver Query: The user’s computer sends a DNS query to a local DNS resolver.
2. Root Server Query: The local resolver forwards the query to a root DNS server, which is responsible for directing queries to the appropriate top-level domain (TLD) server.
3. TLD Server Query: The TLD server identifies the authoritative server for the domain name’s second-level domain (e.g., “.com” or “.org”) and forwards the query to that server.
4. Authoritative Server Response: The authoritative server for the domain name responds to the query, providing the IP address associated with the domain name.
5. IP Address Resolution: The local resolver receives the IP address and sends it back to the user’s computer.
6. Web Page Request: The user’s computer uses the IP address to connect to the web server and request the desired web page.

Importance of DNS

DNS plays a crucial role in the functioning of the Internet by providing a user-friendly way to access resources and services. Without DNS, users would need to memorize numerical IP addresses to access websites or communicate with other devices. DNS simplifies this process by translating domain names into IP addresses, making the Internet more accessible and user-friendly.

DNS server

A DNS server is a computer server that translates domain names into IP addresses. When you enter a website address into your web browser, your computer sends a request to a DNS server to find the IP address of the website. The DNS server then sends the IP address back to your computer, which can then connect to the website.

DNS servers are essential for the functioning of the Internet. Without them, it would be impossible to access websites or communicate with other devices on the Internet.

There are two main types of DNS servers:

• Recursive DNS servers: These are the most common type of DNS server. They are responsible for resolving all DNS queries, including those for domains that they are not authoritative for.
• Authoritative DNS servers: These servers are responsible for providing information about a specific domain name. They are typically operated by the domain name registrar or the organization that owns the domain.

When a computer makes a DNS query, it typically sends it to a recursive DNS server. The recursive DNS server will then query the authoritative DNS server for the domain name in question. If the recursive DNS server cannot find the authoritative DNS server, it will query another recursive DNS server until it finds the correct answer.

Once the recursive DNS server has the answer to the query, it will send it back to the computer that made the query. The computer can then use the IP address to connect to the website or other resource.

The DNSpython module

The dnspython module is a Python library that provides a comprehensive set of tools for interacting with DNS servers and performing DNS-related tasks. It allows you to query DNS servers, perform zone transfers, make dynamic updates, and create DNS messages and records.

Key Features of dnspython:

• Comprehensive DNS functionality: Supports a wide range of DNS record types, queries, and operations.
• Low-level access: Provides low-level access to DNS messages, records, and zones for fine-grained control.
• High-level abstraction: Offers high-level classes for simplifying common DNS operations, such as hostname resolution and zone management.
• Extensible architecture: Supports plugins and custom classes for extending its functionality.

Common Use Cases of dnspython:

• DNS Querying: Resolve domain names to IP addresses and retrieve various DNS record information.
• Zone Transfers: Transfer entire DNS zones from authoritative servers for caching or backup purposes.
• Dynamic Updates: Make dynamic updates to DNS zones, such as adding or removing records.
• DNS Message and Record Manipulation: Create, parse, and modify DNS messages and records for custom applications.
• DNSSEC Validation: Validate DNSSEC signatures to ensure data integrity and authenticity.

Installation:

To install dnspython, you can use the pip command:

pip3 install dnspython

Example Usage:

Here’s an example of using dnspython to resolve a domain name to an IP address:

import dns.resolver

# Create a resolver object
resolver = dns.resolver.Resolver()

# Resolve the domain name "example.com" to an IP address
ip_address = resolver.query("example.com")[0].address

print("IP address for example.com:", ip_address)

This code snippet first imports the dns.resolver module to access the resolver class. Then, it creates a resolver object and uses it to query the DNS server for the IP address of the domain name “example.com”. Finally, it prints the retrieved IP address to the console.

DNS Resolution Script

This Python script performs DNS resolution for a list of domain names and prints their corresponding IP addresses.

1. Importing Required Module:

import dns.resolver

The script imports the dns.resolver module for DNS resolution.

2. Defining a List of Domain Names:

hosts = ["oreilly.com", "yahoo.com", "google.com", "microsoft.com", "cnn.com"]

A list of domain names is defined.

3. Performing DNS Resolution:

for host in hosts:
    print(host)
    ip = dns.resolver.query(host, "A")
    for i in ip:
        print(i)

A loop iterates over each domain name in the list. For each domain, it prints the domain name and then queries the DNS resolver for its A (IPv4 address) records. The resulting IP addresses are then printed.

Usage:

• Ensure the dnspython library is installed (pip install dnspython).
• Run the script.

Summary:

• The script uses the dns.resolver module to perform DNS resolution for a list of domain names.
• It queries the A records to obtain the corresponding IPv4 addresses.
• The script can be helpful for obtaining the IP addresses of various domains.

Note:

• Make sure to install the dnspython library before running the script (pip install dnspython).

import dns.resolver
 
hosts = ["oreilly.com", "yahoo.com", "google.com", "microsoft.com", "cnn.com"]

for host in hosts:
    print(host)
    ip = dns.resolver.query(host, "A")
    for i in ip:
        print(i)

DNS Domain Relationship Checker

This Python script checks the relationship between two domains using the dns module.

1. Importing Required Modules:

import argparse
import dns.name

The script imports the argparse module for command-line argument parsing and the dns.name module for working with DNS domain names.

2. Defining the Main Function:

def main(domain1, domain2):
    domain1 = dns.name.from_text(domain1)
    domain2 = dns.name.from_text(domain2)
    print("domain1 is subdomain of domain2: ", domain1.is_subdomain(domain2)) 
    print("domain1 is superdomain of domain2: ", domain1.is_superdomain(domain2))

The main function takes two domain names as input arguments, converts them to dns.name objects, and then checks the relationship between them using the is_subdomain and is_superdomain methods. The results are printed.

3. Command-Line Argument Parsing:

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Check 2 domains with dns Python')
    parser.add_argument('--domain1', action="store", dest="domain1", default='python.org')
    parser.add_argument('--domain2', action="store", dest="domain2", default='docs.python.org')
    given_args = parser.parse_args() 
    domain1 = given_args.domain1
    domain2 = given_args.domain2
    main(domain1, domain2)

The script checks if it’s being run as the main module and, if so, parses command-line arguments using argparse. It sets default values for the domain names and calls the main function with the provided or default values.

Usage:

• Run the script with optional --domain1 and --domain2 arguments to check the relationship between two domains.

Summary:

• The script uses the dns.name module to check whether one domain is a subdomain or superdomain of another.
• It provides a simple way to determine the relationship between two domains using DNS-related functionality.

#!/usr/bin/env python

import argparse
import dns.name

def main(domain1, domain2):
    domain1 = dns.name.from_text(domain1)
    domain2 = dns.name.from_text(domain2)
    print("domain1 is subdomain of domain2: ", domain1.is_subdomain(domain2)) 
    print("domain1 is superdomain of domain2: ", domain1.is_superdomain(domain2))

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Check 2 domains with dns Python')
    parser.add_argument('--domain1', action="store", dest="domain1",  default='python.org')
    parser.add_argument('--domain2', action="store", dest="domain2",  default='docs.python.org')
    given_args = parser.parse_args() 
    domain1 = given_args.domain1
    domain2 = given_args.domain2
    main (domain1, domain2)

DNS Record Resolver

This Python script resolves various DNS records for a given domain using the dns.resolver module.

1. Importing Required Modules:

import dns.resolver

The script imports the dns.resolver module for querying DNS records.

2. Defining the Main Function:

def main(domain):
    records = ['A', 'AAAA', 'NS', 'SOA', 'MX', 'TXT']
    for record in records:
        try:
            responses = dns.resolver.query(domain, record)
            print("\nRecord response ", record)
            print("-----------------------------------")
            for response in responses:
                print(response)
        except Exception as exception:
            print("Cannot resolve query for record", record)
            print("Error for obtaining record information:", exception)

The main function takes a domain name as input, and for each specified record type ('A', 'AAAA', 'NS', 'SOA', 'MX', 'TXT'), it queries the DNS resolver, prints the record type, and displays the responses.

3. Running the Script:

if __name__ == '__main__':
    try:
        main('awjunaid.com')
    except KeyboardInterrupt:
        exit()

The script checks if it’s being run as the main module, and if so, it calls the main function with a sample domain ('awjunaid.com'). It also handles a KeyboardInterrupt exception to gracefully exit the script.

Usage:

• Run the script to obtain information about various DNS records for the specified domain ('awjunaid.com' in this example).

Summary:

• The script uses the dns.resolver module to query DNS records for a given domain.
• It provides a comprehensive overview of different record types, including ‘A’, ‘AAAA’, ‘NS’, ‘SOA’, ‘MX’, and ‘TXT’.

import dns.resolver

def main(domain):
    records = ['A','AAAA','NS','SOA','MX','TXT']
    for record in records:
        try:
            responses = dns.resolver.query(domain, record)
            print("\nRecord response ",record)
            print("-----------------------------------")
            for response in responses:
                print(response)
        except Exception as exception:
            print("Cannot resolve query for record",record)
            print("Error for obtaining record information:", exception)

if __name__ == '__main__':
	try:
		main('awjunaid.com')
	except KeyboardInterrupt:
		exit()

Reverse DNS Lookup

This Python script demonstrates how to perform a reverse DNS lookup using the dns.reversename module.

1. Importing Required Modules:

import dns.reversename

The script imports the dns.reversename module for reverse DNS lookup.

2. Performing Reverse DNS Lookup:

domain = dns.reversename.from_address("45.55.99.72")
print(domain)
print(dns.reversename.to_address(domain))

The script uses dns.reversename.from_address to create a domain name from an IP address ("45.55.99.72" in this example). It then prints the obtained domain and performs a reverse operation using dns.reversename.to_address to get the original IP address back.

3. Output:

The output will include the reversed domain and the original IP address.

Summary:

• The script demonstrates how to perform a reverse DNS lookup using the dns.reversename module.
• It converts an IP address to a domain name (from_address) and then converts it back to the original IP address (to_address).

import dns.reversename

domain = dns.reversename.from_address("45.55.99.72")
print(domain)
print(dns.reversename.to_address(domain))