Python for Cybersecurity: Building a Port Scanner

Introduction
Prerequisites
Overview
Setting Up
Creating the Port Scanner
Conclusion

Introduction

In the field of cybersecurity, port scanning plays a vital role in identifying potential vulnerabilities in computer systems. A port scanner is a tool used to scan a range of IP addresses and their respective ports to check for open or closed ports. In this tutorial, we will build a simple port scanner using Python.

By the end of this tutorial, you will have a basic understanding of port scanning techniques and how to implement them in Python. You will be able to create your own port scanner and potentially utilize it for cybersecurity purposes.

Prerequisites

To follow along with this tutorial, you should have a basic knowledge of Python programming. Familiarity with network protocols and cybersecurity concepts will also be helpful, but not mandatory.

Overview

Understand the purpose of a port scanner.
Set up the necessary software and libraries.
Implement a port scanning algorithm in Python.
Test the port scanner with different IP addresses and port ranges.
Troubleshoot and handle common issues.

Setting Up

To begin, we need to set up our development environment with the required Python libraries. We will be using the socket and argparse modules.

Open your favorite text editor or integrated development environment (IDE).
Create a new Python file and save it as port_scanner.py.
Make sure you have Python installed on your system. You can check by running the following command in your terminal:
```
 python --version
```
If Python is not installed, you can download and install it from the official Python website.
Install the required libraries by running the following commands in your terminal:
```
 pip install argparse
```
The argparse library will allow us to accept command-line arguments and customize the behavior of our port scanner.

Creating the Port Scanner

Now that we have our environment set up, let’s start implementing the port scanner.

Import the necessary modules at the beginning of your Python file:
```
 import argparse
 import socket
```

Define a function to conduct the port scanning. Let’s name it port_scan(host, port):

 def port_scan(host, port):
     try:
         # Create a socket object
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         # Set a timeout of 1 second
         s.settimeout(1)
         # Connect to the host and port
         result = s.connect_ex((host, port))
         # Check if the port is open or closed
         if result == 0:
             print(f"Port {port} is open")
         else:
             print(f"Port {port} is closed")
         # Close the socket connection
         s.close()
     except socket.error:
         print("Could not connect to the server")

Let’s break down the steps involved in the port_scan function:

Create a socket object using socket.socket().
Set a timeout for the socket object using s.settimeout(). This ensures that our port scanner does not hang indefinitely while attempting to connect to a host.
Connect to the specified host and port using s.connect_ex().
Check the return code (0 for success) to determine if the port is open or closed.
Print the appropriate message to the console.
Close the socket connection.

Define a new function named parse_arguments() to handle command-line arguments:

 def parse_arguments():
     parser = argparse.ArgumentParser()
     parser.add_argument("host", help="IP address or hostname to scan")
     parser.add_argument("start_port", type=int, help="Starting port number")
     parser.add_argument("end_port", type=int, help="Ending port number")
     return parser.parse_args()

This function uses the argparse library to define three required arguments: host, start_port, and end_port.

Write the main code block to execute the port scanning:

 if __name__ == "__main__":
     args = parse_arguments()
     host = args.host
     start_port = args.start_port
     end_port = args.end_port
	
     print(f"Scanning ports {start_port} to {end_port} on {host}")
	
     for port in range(start_port, end_port + 1):
         port_scan(host, port)

In this code block, we parse the command-line arguments and store them in variables. We then print a message to indicate the start of the port scanning process.

Finally, we loop through the range of ports specified by the user and call the port_scan function for each port.

Save the file and you are ready to use your port scanner!

Conclusion

In this tutorial, we have learned how to build a simple port scanner using Python. We covered the basics of port scanning, set up the necessary software and libraries, and implemented a port scanning algorithm.

Now you can utilize this knowledge to scan IP addresses and identify potential vulnerabilities in computer systems. Remember to use this tool responsibly and always seek proper authorization before conducting any port scanning activities.

Feel free to explore further and enhance your port scanner with additional features such as multi-threading, ping sweeps, or service banner grabbing.

Happy port scanning!

Published: 31 October 2019