DEV Community: CJ

Network Scanning with Python: ARP, Port, and DNS Scanner

CJ — Sat, 18 Oct 2025 14:59:07 +0000

Introduction

Network security and reconnaissance are essential skills for cybersecurity professionals. In this blog post, we will build a Python-based network scanner that performs ARP scanning, port scanning, and DNS resolution using the scapy, socket, dns.resolver, and threading libraries. We will also use rich for better console output.

Overview of the Scanner

Perform an ARP scan to discover active hosts on the network.
Scan common ports on discovered hosts.
Resolve DNS records for a given domain.

Flowchart of the Scanner:

Script Breakdown

Parsing Command-Line Arguments

The script accepts command-line arguments using argparse to select between port scanning and DNS scanning.

ARP Scanning

The Address Resolution Protocol (ARP) scan sends requests to devices in the network and collects responses to determine active hosts.

Port Scanning

For each discovered active host, the script attempts to connect to common ports (e.g., 22, 80, 443) to check if they are open.

DNS Resolution

If DNS mode is enabled, the script retrieves the A records (IPv4 addresses) of a given domain.

Code

import argparse  # Importing argparse for handling command-line arguments
import socket  # Importing socket for network communication
import scapy.all as scapy  # Importing scapy for ARP scanning
import dns.resolver  # Importing dns.resolver for DNS scanning
import threading  # Importing threading for concurrent port scanning
from rich.console import Console  # Importing rich.console for formatted console output
from rich.table import Table  # Importing rich.table for displaying results in table format
from rich.text import Text  # Importing rich.text for text formatting
from rich import print  # Importing print from rich to enhance terminal output

console = Console()  # Initializing a rich console instance

def parser():
    global target, port_enabled, dns_enabled  # Defining global variables to store user inputs

    arg_parser = argparse.ArgumentParser(description="Options for scanning")  # Creating an argument parser
    arg_parser.add_argument('-t', "--target", help="Specify target explicitly")  # Adding argument for target IP/domain

    req_args = arg_parser.add_mutually_exclusive_group(required=True)  # Ensuring only one option (port or DNS) is selected
    req_args.add_argument("--port", action="store_true", help="Enable port scanning")  # Port scanning option
    req_args.add_argument("--dns", action="store_true", help="Enable DNS scanning")  # DNS scanning option

    args = arg_parser.parse_args()  # Parsing command-line arguments
    target = args.target  # Storing target input
    port_enabled = args.port  # Storing port scanning option
    dns_enabled = args.dns  # Storing DNS scanning option

def arp_scan():
    global active_hosts  # Defining a global list to store active hosts
    active_hosts = []  # Initializing an empty list

    # Creating an ARP request to discover active devices in the network
    arp_request = scapy.ARP(pdst=target if target else "192.168.1.1/24")  
    broadcast = scapy.Ether(dst='ff:ff:ff:ff:ff:ff')  # Creating an Ethernet frame for broadcast
    req_broadcast = broadcast / arp_request  # Combining Ethernet frame with ARP request

    clients = scapy.srp(req_broadcast, timeout=1, verbose=False)[0]  # Sending request and capturing responses

    # Creating a table for displaying active hosts
    table = Table(title="Active Hosts", show_header=True, header_style="bold cyan")
    table.add_column("IP Address", style="green")
    table.add_column("MAC Address", style="magenta")
    table.add_column("Device Name", style="yellow")

    for sent, received in clients:  # Iterating through received ARP responses
        ip = received.psrc  # Extracting IP address
        hostname = get_hostname(ip)  # Fetching device name
        active_hosts.append(ip)  # Adding IP to active hosts list
        table.add_row(ip, received.hwsrc, hostname)  # Adding row to table

    console.print(table)  # Displaying the table

def get_hostname(ip):
    try:
        hostname = socket.gethostbyaddr(ip)[0]  # Resolving hostname from IP
        return hostname  # Returning the hostname
    except socket.herror:
        return "Unknown"  # Returning 'Unknown' if resolution fails

def scan_port(host, port):
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:  # Creating a socket object
            s.settimeout(1)  # Setting a timeout for connection attempts
            result = s.connect_ex((host, port))  # Checking if port is open

            if result == 0:
                console.print(f"[bold green]Open port {port} on {host}[/bold green]")  # Printing open ports
    except Exception as e:
        console.print(f"[bold red]Error scanning {host}:{port} - {e}[/bold red]")  # Handling errors

def multi_thread_scan_ports(host, ports):
    threads = []  # Creating a list to store threads
    for port in ports:  # Iterating over ports to scan
        thread = threading.Thread(target=scan_port, args=(host, port))  # Creating a new thread
        thread.start()  # Starting the thread
        threads.append(thread)  # Adding thread to the list

    for thread in threads:
        thread.join()  # Waiting for all threads to complete

def dns_scan():
    try:
        result = dns.resolver.resolve(target, 'A')  # Resolving A records of the target domain

        table = Table(title="DNS MX Records", show_header=True, header_style="bold cyan")  # Creating a table for results
        table.add_column("Mail Exchange (MX) Records", style="yellow")

        for val in result:
            table.add_row(str(val))  # Adding resolved DNS records to the table

        console.print(table)  # Printing the table
    except Exception as e:
        console.print(f"[bold red]DNS scan failed: {e}[/bold red]")  # Handling errors

if __name__ == "__main__":
    ports_to_scan = [21, 22, 23, 25, 53, 80, 443, 8080]  # Defining common ports to scan

    parser()  # Parsing command-line arguments

    if port_enabled:
        console.print("[bold cyan]Starting ARP scan...[/bold cyan]")  # Indicating ARP scan start
        arp_scan()  # Running ARP scan
        for host in active_hosts:
            console.print(f"[bold yellow]Scanning ports on {host}...[/bold yellow]")  # Indicating port scan start
            multi_thread_scan_ports(host, ports_to_scan)  # Scanning ports using multithreading
    else:
        console.print("[bold cyan]Starting DNS scan...[/bold cyan]")  # Indicating DNS scan start
        dns_scan()  # Running DNS scan

Running the Scanner

To run the scanner, use one of the following commands:

Port scanning:

python scanner.py -t 192.168.1.1 --port

DNS scanning:

python scanner.py -t example.com --dns

Hey, I'm CJ, a curious mind who loves breaking down tech stuff into simple, fun stories. If you enjoyed this read, follow me for more posts like this, and check out my other socials to see what I'm building next!
X (Formerly Twitter) | GitHub | Linkedin

From Curiosity to Code: My Path to Programming

CJ — Sat, 11 Oct 2025 15:00:52 +0000

Introduction

It all started when I was enjoying my vacation and watching YouTube videos on my Lenovo tablet. I had already developed an interest in computer-related topics in 7th-8th grade when we were introduced to the subject in school. One day, I came across a YouTube video where the creator was showcasing an app they had built themselves. Later, they started a live Q&A session, and I asked them, "What did you use to make that app?" They mentioned an app called Sketchware – Create Your Own Apps (which has been discontinued for a long time).

Sketchware used a block-based editor where you could drag and drop blocks, fill in some details, run, compile, and your app would be ready. My goal was to create a code editor with syntax highlighting (though I didn’t know that term back then), along with features like autocomplete and auto-closing brackets. This ignited a determination within me to build that app and embark on my coding journey. I joined the Sketchware Slack community and started bombarding people with my endless questions.

Early Days

Like most developers, I relied heavily on copying and pasting code and debugging tons of errors (at one point, I had nearly 100 errors!). I carefully understood each error and solved them one at a time. I then broke down the process into small chunks, first by implementing a custom TextEditor class, then by eventually adding line numbers, syntax highlighting, autocomplete, auto-closing brackets, an inbuilt file manager, and, for .html files, running them in a WebView. I managed to implement all these features simultaneously, and one day the app was ready. Now, you might be thinking: how the heck did I implement all these features using an app that only used blocks? Well, there's a twist in the story: Sketchware included a block called "add source directly" (ASD block). With that block, adding custom code to the app was possible, provided you knew how it worked without breaking the compilation. That block was a blessing for Sketchware users, but it also played a part in Sketchware’s eventual shutdown (that’s a whole different story).

Milestones

I always wanted to explore more and start doing something interesting. So, I created a YouTube channel and started uploading tutorial videos related to Sketchware and using ASD blocks to create various projects. Back in 10th grade, I couldn't contribute much to my learning and curiosity journey due to my studies. However, I still tried my best to find time and explore more of this technology. I downloaded text/code editors like Atom, Notepad++, and Sublime Text to understand how they worked. I was then drawn to desktop app development and started diving into it. I used JavaFX along with Java Swing to understand the process of creating desktop applications. Additionally, I explored different IDEs, transitioning from NetBeans to Eclipse to understand their working mechanisms.

Growth and Evolution

Back in 2018-2019, I met a friend, Amitoj, in the Slack community of Sketchware. He had an idea to create a platform where users who built apps using Sketchware could share their applications, essentially a Play Store for Sketchware. I contributed to that project, specifically the backend, for a few months using PHP and MySQL. The platform, called Sketchub, is still up and running today.

Fast-forward to the lockdown era, I was inspired by the Sketchub project and wanted to create a tool to help the community. That’s when I developed SKTool, a tool that made editing the source code of Sketchware projects easier.

After that, I got bored and became super active on Discord, grinding bots, making friends, and just hanging out. Eventually, I wanted to learn something new, and my friend, Deltawing, suggested learning Python by making Discord bots. I worked on building Discord bots—a lot (or at least I tried). Through that, I learned Python and got introduced to PostgreSQL and SQLite.

I followed the same learning path after getting into college. I participated in a state-level hackathon, my first ever, without any prior experience (we reached the finals). After that, I delved into web development. Back then, I used to think JavaScript was the most complex language, and honestly, I wasn’t wrong, it really is.

Conclusion

Over the past few years, I’ve learned a lot, both in coding and life, and every day, I strive to stay as curious and improve as much as possible. Throughout this journey, I’ve made many friends, both online and in real life.

To anyone who is just starting or in their early days, don’t let your curiosity fade. No one can stop you from learning something new, even if it’s different from what you do daily

Enjoyed this post? Check out my projects and profiles below.

X (Formerly Twitter) GitHub Linkedin

Let's Build a Multi Client TCP Chat with Tkinter

CJ — Sun, 05 Oct 2025 06:23:16 +0000

Table of Content

Introduction
Technical Breakdown
Diagrams & Visuals
Code Walkthrough

1. Introduction

A TCP socket-based chat application allows multiple clients to communicate with a central server in real time. This tutorial walks through building a multi-client chat application using Python’s socket and threading modules for backend communication and Tkinter for a graphical user interface (GUI). This is a great project to learn about networking, concurrency, and GUI development.

2. Technical Breakdown

Understanding Sockets in Python

Sockets enable network communication between processes. Python’s socket module provides the necessary tools to create a server-client architecture where clients send and receive messages through a central server.

Server-Client Architecture for Multi-Client Setup

Server: Listens for incoming connections and handles multiple clients simultaneously.
Clients: Connect to the server, send messages, and receive broadcasts from other clients.

Implementing Threading for Multiple Clients

Since a single-threaded server would block while handling one client, we use Python’s threading module to allow concurrent client connections.

Developing a Tkinter-Based GUI

A simple Tkinter interface will provide a user-friendly way to send and receive messages.

3. Diagrams & Visuals

Network Architecture

Message Flowchart

4. Code Walkthrough

Server.py


import socket  # Importing socket for network communication
import threading  # Importing threading to handle multiple clients concurrently
import tkinter as tk  # Importing Tkinter for GUI
from tkinter import scrolledtext  # Importing scrolledtext for displaying chat messages

class ChatServer:
    def __init__(self, root):
        self.root = root
        self.root.title("Server Chat")  # Setting the window title

        # Creating a server socket (IPv4, TCP)
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # Binding the server to localhost (127.0.0.1) on port 8888
        self.server_socket.bind(("127.0.0.1", 8888))

        # Listening for up to 5 simultaneous connections
        self.server_socket.listen(5)

        # List to keep track of connected clients
        self.clients = []

        # Starting a background thread to accept new clients
        threading.Thread(target=self.accept_clients, daemon=True).start()

        # Creating a scrollable text widget to display chat messages
        self.chat_display = scrolledtext.ScrolledText(root, state='disabled', width=50, height=15)
        self.chat_display.pack(pady=10)

    def accept_clients(self):
        """Accepts incoming client connections and starts a new thread for each."""
        while True:
            client_socket, addr = self.server_socket.accept()  # Accept client connection
            self.clients.append(client_socket)  # Add the client to the list
            threading.Thread(target=self.handle_client, args=(client_socket,)).start()  # Start handling client

    def handle_client(self, client_socket):
        """Handles receiving messages from a client and broadcasting them."""
        while True:
            try:
                # Receive message from the client (max 1024 bytes)
                message = client_socket.recv(1024).decode("utf-8")

                # If the client disconnects, exit the loop
                if not message:
                    break

                # Send the received message to all other clients
                self.broadcast(message, client_socket)

            except:  # If an error occurs (e.g., client disconnects)
                self.clients.remove(client_socket)  # Remove client from the list
                client_socket.close()  # Close the connection
                break  # Exit loop

    def broadcast(self, message, sender_socket):
        """Sends received messages to all clients except the sender."""
        for client in self.clients:
            if client != sender_socket:  # Ensure the sender doesn't receive their own message
                client.send(message.encode("utf-8"))  # Send message to client

        # Display the message in the server GUI
        self.chat_display.config(state='normal')  # Enable text editing
        self.chat_display.insert(tk.END, message + "\n")  # Insert message
        self.chat_display.config(state='disabled')  # Disable text editing
        self.chat_display.yview(tk.END)  # Scroll to the latest message

if __name__ == "__main__":
    root = tk.Tk()  # Create the main Tkinter window
    server = ChatServer(root)  # Initialize and start the chat server
    root.mainloop()  # Run the Tkinter event loop

Client.py

import socket  # Importing socket for network communication
import threading  # Importing threading to handle receiving messages concurrently
import tkinter as tk  # Importing Tkinter for GUI
from tkinter import scrolledtext, messagebox  # Importing scrolledtext for chat display, messagebox for alerts

class ChatClient:
    def __init__(self, root):
        self.root = root
        self.root.title("Client Chat")  # Setting the window title

        self.client_socket = None  # Will hold the socket connection
        self.running = False  # Tracks whether the client is connected

        # GUI Elements
        self.username_label = tk.Label(root, text="Username:")  # Username label
        self.username_label.pack()

        self.username_entry = tk.Entry(root)  # Input field for username
        self.username_entry.pack()

        self.connect_button = tk.Button(root, text="Connect", command=self.connect_to_server)  # Connect button
        self.connect_button.pack(pady=5)

        self.chat_display = scrolledtext.ScrolledText(root, state='disabled', width=50, height=15)  # Chat display area
        self.chat_display.pack(pady=10)

        self.message_entry = tk.Entry(root, width=40)  # Input field for messages
        self.message_entry.pack(pady=5)

        self.send_button = tk.Button(root, text="Send", command=self.send_message)  # Send button
        self.send_button.pack(pady=5)

        self.disconnect_button = tk.Button(root, text="Disconnect", command=self.disconnect)  # Disconnect button
        self.disconnect_button.pack(pady=5)

    def connect_to_server(self):
        """Establishes a connection to the chat server."""
        if self.running:
            messagebox.showwarning("Warning", "Already connected!")
            return

        username = self.username_entry.get().strip()  # Get username from input
        if not username:  
            messagebox.showerror("Error", "Username is required!")  # Show error if username is empty
            return

        try:
            self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # Create a TCP socket
            self.client_socket.connect(("127.0.0.1", 8888))  # Connect to the server
            self.client_socket.send((username + " joined the chat!").encode("utf-8"))  # Send username as the first message
            self.running = True

            # Start a background thread to receive messages
            threading.Thread(target=self.receive_messages, daemon=True).start()

            # Update chat display to show successful connection
            self.chat_display.config(state='normal')
            self.chat_display.insert(tk.END, f"Connected to 127.0.0.1:8888 as {username}\n")
            self.chat_display.config(state='disabled')

        except Exception as e:
            messagebox.showerror("Error", f"Connection failed: {e}")  # Show error message if connection fails

    def receive_messages(self):
        """Continuously receives and displays messages from the server."""
        while self.running:
            try:
                message = self.client_socket.recv(1024).decode("utf-8")  # Receive message (max 1024 bytes)

                if not message:  # If message is empty, exit loop
                    break

                self.chat_display.config(state='normal')

                # Display received message in chat window
                self.chat_display.insert(tk.END, message + "\n")

                self.chat_display.config(state='disabled')
                self.chat_display.yview(tk.END)  # Auto-scroll to the latest message

            except ConnectionResetError:  # If the server disconnects
                self.chat_display.config(state='normal')
                self.chat_display.insert(tk.END, "Server disconnected.\n")
                self.chat_display.config(state='disabled')
                self.running = False
                break  # Exit loop

    def send_message(self):
        """Sends a message to the server."""
        if not self.running:
            messagebox.showerror("Error", "Not connected to any server!")  # Show error if not connected
            return

        message = self.message_entry.get().strip()  # Get the input message
        self.chat_display.config(state='normal')

        # Show the user's message in the chat window
        self.chat_display.insert(tk.END, str(self.username_entry.get()) + "(You): " + message + "\n")

        self.chat_display.config(state='disabled')
        self.chat_display.yview(tk.END)  # Auto-scroll to latest message

        if message:  # If message is not empty
            try:
                # Send the message to the server, prefixed with the username
                self.client_socket.send((str(self.username_entry.get()) + ": " + message).encode("utf-8"))
                self.message_entry.delete(0, tk.END)  # Clear the input field after sending
            except Exception as e:
                messagebox.showerror("Error", f"Message sending failed: {e}")  # Show error if sending fails

    def disconnect(self):
        """Disconnects from the chat server."""
        if not self.running:
            messagebox.showwarning("Warning", "Already disconnected!")  # Show warning if already disconnected
            return

        self.running = False  # Set running to False
        self.client_socket.close()  # Close the socket connection

        # Update chat display to show disconnection message
        self.chat_display.config(state='normal')
        self.chat_display.insert(tk.END, "Disconnected from server.\n")
        self.chat_display.config(state='disabled')

if __name__ == "__main__":
    root = tk.Tk()  # Create the main Tkinter window
    client = ChatClient(root)  # Initialize and start the chat client
    root.mainloop()  # Run the Tkinter event loop