Python 3 ipaddress ping

How to Ping Sweep Your Network with Python — A Beginner’s Guide

As Network Engineers, one of the most basic tasks for us is determining which hosts are currently active on a given network. One way to achieve this is through a ping sweep, which sends ICMP echo requests to every IP address within a given range and checks for responses. While there are other tools available that can perform this task, such as fping or bash scripts, Python offers several advantages that make it a compelling choice for this task.

In this blog post, we will explore how to perform a ping sweep using Python, and the benefits of using Python over other methods. We will also provide a step-by-step guide on how to write a simple Python script to perform a ping sweep of a given subnet, a list of subnets and explain how the script works.

Why Python?

Python is an excellent choice for performing a ping sweep due to several advantages over other tools. Python is cross-platform, meaning that it can run on Windows, Linux, and macOS. Additionally, Python offers greater flexibility and control over the ping sweep process than other tools, making it highly customizable.

Python is also easy to learn and use, making it an ideal choice for beginners. With its vast collection of libraries and modules, Python offers a wide range of options for customizing the ping sweep process, such as the ipaddress module and ping3 library.

Overview

We will start by exploring how to perform a basic ping sweep of a single subnet using Python. We will write a Python script that sends ICMP echo requests to every IP address within a given range and records the responses to a file. We will then explain how the script works and how it can be customized to suit your specific needs.

Next, we will move on to more advanced topics, such as pinging multiple subnets in parallel using the concurrent.futures module. We will show how to modify our original script to work with a list of subnets and demonstrate how to use the ThreadPoolExecutor class to ping multiple subnets concurrently.

By the end of this blog post, you will have a clear understanding of how to perform a ping sweep using Python and how to customize the process to suit your needs. You will also have learned how to take advantage of Python’s concurrency features to speed up the ping sweep process and make it more efficient.

Libraries

To perform the ping sweep in Python, we will be using the ping3 and ipaddress libraries. The ping3 library is a third-party library that can be easily installed using the Python package manager, pip . Once installed, you can import the ping function from the ping3 module and use it to send ping requests.

The ipaddress library is included in the Python standard library and provides a set of classes and functions for working with IP addresses and networks. It provides a simple way to generate a list of IP addresses within a given range using the ip_network() function.

Getting Started

Before diving into the scrip, let’s look at some simple examples on how to use these libraries.

ping3 Module

pip install ping3 # install ping

from ping3 import ping a = ping('8.8.8.8') b = ping ('25.5.6.7') print(a) print(b)

This Python code sends ICMP echo requests to two IP addresses ( 8.8.8.8 and 25.5.6.7 ) using the ping function from the ping3 library. It then prints the round-trip time for the successful ping request to 8.8.8.8 , and None for the unsuccessful ping request to 25.5.6.7 as shown below.

#output 0.010473966598510742 # Returns delay in seconds None # Returns none if the IP doesn't respond

ipaddress Module

import ipaddress network = ipaddress.ip_network('192.168.1.0/29') # Creates subnet object for ip in network: print(ip) # Access each IP in that subnet

This Python code creates an ip_network object that represents a subnet, then iterates over each IP address in the subnet using a for loop and prints the value of each IP address to the console.

# output 192.168.1.0 192.168.1.1 192.168.1.2 192.168.1.3 192.168.1.4 192.168.1.5 192.168.1.6 192.168.1.7

Example 1 — Ping a Single Subnet

In this example, we will be looking at a Python script that can be used to ping each IP address within a given single subnet, while also timestamping each ICMP request and saving the output to a file.

import datetime import ipaddress from ping3 import ping subnet = '192.168.102.0/29' output_file = 'ping_results_single.txt' def ping_sweep(subnet): network = ipaddress.ip_network(subnet, strict=False) with open(output_file, 'a') as f: for ip in network.hosts(): ip_str = str(ip) timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') message = "" try: response_time = ping(ip_str, timeout=1) if response_time is not None: message = f" - is reachable" else: message = f" - is unreachable" except Exception: message = f" - Error pinging " print(message) f.write(message + '\n') ping_sweep(subnet)

Once you run the script, this is the contents of the output file. You also get the same output on the terminal.

2023-04-14 10:00:37 - 192.168.102.1 is reachable 2023-04-14 10:00:37 - 192.168.102.2 is unreachable 2023-04-14 10:00:38 - 192.168.102.3 is unreachable 2023-04-14 10:00:40 - 192.168.102.4 is reachable 2023-04-14 10:00:41 - 192.168.102.5 is reachable 2023-04-14 10:00:42 - 192.168.102.6 is unreachable

Example 2 — Ping Multiple Subnets

In this second example, we will be looking at a Python script that can be used to ping a list of subnets.

import datetime import ipaddress from ping3 import ping import concurrent.futures import threading subnets = ['192.168.102.0/29', '192.168.107.0/29', '192.168.108.0/29'] # Add your subnets here output_file = 'ping_results.txt' output_lock = threading.Lock() def ping_sweep(subnet): network = ipaddress.ip_network(subnet, strict=False) results = [] for ip in network.hosts(): ip_str = str(ip) timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') try: response_time = ping(ip_str, timeout=1) if response_time is not None: message = f" - is reachable" else: message = f" - is unreachable" except Exception: message = f" - Error pinging " results.append(message) with output_lock: print(f"Ping results for subnet :") with open(output_file, 'a') as f: f.write(f"Ping results for subnet :\n") for msg in results: print(msg) f.write(msg + '\n') f.write('\n') print() with concurrent.futures.ThreadPoolExecutor() as executor: executor.map(ping_sweep, subnets)

Here is an explanation of the code line by line, excluding the import statements and the initial variable declarations.

1. output_lock = threading.Lock() : Creates a Lock object from the threading module to be used for ensuring thread-safe access to shared resources, like the output file.
2. def ping_sweep(subnet): : Defines a function named ping_sweep that takes a subnet as its input argument.
3. network = ipaddress.ip_network(subnet, strict=False) : Creates an ip_network object representing the input subnet, allowing for the manipulation of IP addresses within the subnet.
4. results = [] : Initializes an empty list to store the ping results for the hosts within the subnet.
5. for ip in network.hosts(): : Iterates through the host IP addresses in the subnet.
6. ip_str = str(ip) : Converts the ipaddress.IPv4Address object to a string representation.
7. timestamp = datetime.datetime.now().strftime(‘%Y-%m-%d %H:%M:%S’) : Creates a timestamp string for the current time, formatted as ‘YYYY-MM-DD HH:MM:SS’.
8. try-except block: Attempts to ping the current IP address, and constructs a message string based on the result:
9. If the ping is successful (i.e., response_time is not None ), the message will indicate that the IP address is reachable.
10. If the ping is unsuccessful, the message will indicate that the IP address is unreachable.
11. If there’s an exception during the ping process, the message will indicate that there was an error pinging the IP address.
12. results.append(message) : Appends the message to the results list.
13. with output_lock: : Acquires the output_lock to ensure thread-safe access to the shared resource (i.e., the output file).
14. print(f»Ping results for subnet :») : Prints a header line indicating the start of the ping results for the current subnet.
15. with open(output_file, ‘a’) as f: : Opens the output file in append mode, so that new results can be added to the existing content.
16. For loop: Iterates through the messages in the results list and performs the following actions for each message:
17. Prints the message to the console.
18. Writes the message to the output file.
19. f.write(‘\n’) : Adds an empty line to the output file to separate the results of different subnets.
20. print() : Prints an empty line to the console to separate the results of different subnets.
21. with concurrent.futures.ThreadPoolExecutor() as executor: : Creates a ThreadPoolExecutor that manages a pool of worker threads, allowing for the concurrent execution of multiple instances of the ping_sweep function.
22. executor.map(ping_sweep, subnets) : Calls the ping_sweep function with each subnet in the subnets list, distributing the work across the threads in the thread pool. The function runs concurrently for each subnet, and the map function blocks until all the work is complete.

Here are the contents of the output file

Ping results for subnet 192.168.107.0/29: 2023-04-14 09:44:54 - 192.168.107.1 is reachable 2023-04-14 09:44:54 - 192.168.107.2 is unreachable 2023-04-14 09:44:55 - 192.168.107.3 is unreachable 2023-04-14 09:44:56 - 192.168.107.4 is reachable 2023-04-14 09:44:56 - 192.168.107.5 is unreachable 2023-04-14 09:44:57 - 192.168.107.6 is unreachable Ping results for subnet 192.168.108.0/29: 2023-04-14 09:44:54 - 192.168.108.1 is reachable 2023-04-14 09:44:54 - 192.168.108.2 is unreachable 2023-04-14 09:44:55 - 192.168.108.3 is reachable 2023-04-14 09:44:56 - 192.168.108.4 is unreachable 2023-04-14 09:44:57 - 192.168.108.5 is unreachable 2023-04-14 09:44:58 - 192.168.108.6 is unreachable Ping results for subnet 192.168.102.0/29: 2023-04-14 09:44:54 - 192.168.102.1 is reachable 2023-04-14 09:44:54 - 192.168.102.2 is unreachable 2023-04-14 09:44:55 - 192.168.102.3 is unreachable 2023-04-14 09:44:56 - 192.168.102.4 is reachable 2023-04-14 09:44:57 - 192.168.102.5 is reachable 2023-04-14 09:44:58 - 192.168.102.6 is reachable

Conclusion

In conclusion, the first script performs a ping sweep on a single subnet and outputs the results to a file, while the second script extends this functionality by taking a list of subnets and leveraging the concurrent.futures module to run ping sweeps on multiple subnets in parallel, providing a more efficient solution for scanning larger network ranges.

Источник

Python 3 Multi Threaded Ping Sweep Scanner

We know that nmap and other tools are great for scanning a network. What if we want to do it in python?

The following code is a demonstration of multi threading, using python 3 to sweep a network using pings on windows. The single threaded version took almost 2 minutes to check a network, but this version takes about 2 seconds.

Why not NMAP for a Ping Sweep?

Arguably, nmap is better. But you may not have nmap installed, or you might want to learn about multithreading! Regardless, there are many things learned from writing scripts like this.

Python Style

There are things done in this script that might be written more elegantly, but for learning the basics of multi-threading, doing a ping sweep is a great example.

Topics Learned in This Script

Programming is all about the big picture. If you can imagine a concept, the rest is just pieces of a puzzle. It’s useful to break down tasks into smaller and smaller tasks and solve them 1 by 1. However, unless you have a big picture goal in mind, your code gets more like spaghetti as you add features and rewrite your dream into reality.

In this script, if you understand each line, you will also understand all of the following components:

• importing modules in python
• hiding windows using subprocess
• calling a subprocess from OS using python
• coloring the CLI of python output
• reading CIDR network addresses using python
• measuring python program run time
• python functions
• passing data into python functions
• basic python variables
• creating a list in python
• accessing members of a list
• if else logic and skipping branches in python
• while and for loops
• creating a thread queue in python
• python worker pool creation
• locking print threads while workers finish
• converting to string
• Converting a thread to daemon so it dies gracefully
• printing without a newline
• Finding length of a list
• list iteration/looping over a list
• formatting a float to precision desired

Источник