使用Python实现高效的端口扫描器_F11 - 专业站长和开发者的学习网站

1. 端口扫描的基本原理

端口扫描的基本原理是向目标主机的指定端口发送数据包，并监听是否有来自该端口的响应。根据响应的不同，可以判断该端口的状态（如开放、关闭或过滤）。

常见的端口扫描类型包括：

TCP SYN扫描：发送SYN包，如果收到SYN-ACK，则端口开放；如果收到RST，则端口关闭。
TCP Connect扫描：完成三次握手，如果成功则端口开放。
UDP扫描：发送UDP包，如果收到ICMP错误消息，则端口关闭；如果没有响应，则可能开放或过滤。

2. 使用Python实现端口扫描

2.1 安装必要的库

首先，我们需要安装??scapy??库，这是一个强大的网络工具库，支持创建、发送、捕获和解析网络数据包。

1	pip install scapy

2.2 编写端口扫描脚本

下面是一个使用??scapy??实现的简单端口扫描器示例：

from scapy.all import *

import ipaddress

def port_scan(ip, ports):

"""

对指定IP地址的指定端口进行扫描

:param ip: 目标IP地址

:param ports: 需要扫描的端口号列表

:return: 打印开放的端口

"""

open_ports = []

for port in ports:

# 构造SYN包

packet = IP(dst=ip)/TCP(dport=port, flags="S")

response = sr1(packet, timeout=1, verbose=0)

if response is not None and TCP in response:

if response[TCP].flags == 0x12: # 如果收到SYN-ACK

# 发送RST包复位连接

send_rst = sr(IP(dst=ip)/TCP(dport=port, flags="R"), timeout=1, verbose=0)

open_ports.append(port)

elif response[TCP].flags == 0x14: # 如果收到RST

pass # 端口关闭

return open_ports

if __name__ == "__main__":

target_ip = "192.168.1.1" # 替换为目标IP

target_ports = [22, 80, 443, 8080] # 指定需要扫描的端口

open_ports = port_scan(target_ip, target_ports)

if open_ports:

print(f"Open ports on {target_ip}: {open_ports}")

else:

print(f"No open ports found on {target_ip}")

2.3 脚本解释

构造SYN包：使用??scapy??构建一个TCP SYN包，目标是目标IP地址和指定端口。
发送并接收响应：使用??sr1??函数发送数据包并等待响应，超时时间为1秒。
分析响应：如果收到SYN-ACK响应，说明端口开放；如果收到RST响应，说明端口关闭。
复位连接：对于开放的端口，发送一个RST包以复位连接，避免建立完整的TCP连接。

3. 运行与测试

确保你有权限发送网络数据包（通常需要root权限）。运行上述脚本后，它将输出目标主机上开放的端口列表。

本文介绍了如何使用Python和??scapy??库实现一个简单的端口扫描器。虽然这个扫描器功能较为基础，但它提供了一个良好的起点，可以根据实际需求进一步扩展和优化。例如，可以添加多线程支持以提高扫描速度，或者实现更复杂的扫描策略来规避防火墙检测。

这篇文章详细介绍了如何使用Python和??scapy???库实现一个简单的端口扫描器，适合初学者学习和实践。端口扫描是网络安全领域中常用的技术之一，用于检测目标主机上开放的服务和端口。Python 提供了多种库来实现这一功能，其中 ??socket?? 库是最基础也是最灵活的选择之一。为了提高效率，可以使用多线程或异步 I/O 技术。

下面是一个使用 ??socket?? 和 ??concurrent.futures??（多线程）实现的高效端口扫描器示例：

import socket

from concurrent.futures import ThreadPoolExecutor

def scan_port(ip, port):

try:

# 创建一个 socket 对象

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:

sock.settimeout(1) # 设置超时时间

result = sock.connect_ex((ip, port))

if result == 0:

print(f"Port {port} is open")

else:

print(f"Port {port} is closed")

except socket.error as e:

print(f"Socket error: {e}")

def main():

target_ip = input("Enter the target IP address: ")

start_port = int(input("Enter the start port: "))

end_port = int(input("Enter the end port: "))

# 使用 ThreadPoolExecutor 来并行扫描多个端口

with ThreadPoolExecutor(max_workers=100) as executor:

for port in range(start_port, end_port + 1):

executor.submit(scan_port, target_ip, port)

if __name__ == "__main__":

main()

代码说明：

??scan_port??? 函数：这个函数负责检查单个端口是否开放。它创建一个 ??socket?? 对象，并尝试连接到指定的 IP 地址和端口。如果连接成功，则端口开放；否则，端口关闭。
??main??? 函数：这是程序的主入口。用户输入目标 IP 地址和要扫描的端口范围。然后使用 ??ThreadPoolExecutor?? 来并行执行多个 ??scan_port?? 任务，以提高扫描速度。
??ThreadPoolExecutor??：这是一个多线程池，可以同时执行多个任务。这里设置的最大工作线程数为 100，可以根据实际情况调整。

注意事项：

性能与资源：多线程可以显著提高扫描速度，但过多的线程可能会消耗大量系统资源，甚至导致目标系统拒绝服务（DoS）。因此，需要根据实际情况调整 ??max_workers?? 的值。
法律与道德：未经授权的端口扫描可能违反法律法规。在进行端口扫描之前，请确保你有合法的权限。

进一步优化：

异步 I/O：可以使用 ??asyncio?? 和 ??aiohttp?? 等库来实现更高效的异步端口扫描。
错误处理：增加更多的错误处理逻辑，以应对网络不稳定等情况。

希望这个示例对你有所帮助！如果你有任何问题或需要进一步的帮助，请告诉我。在Python中实现高效的端口扫描可以通过多种方式完成，其中最常见的是使用多线程或多进程来提高扫描速度。这里将介绍一种使用??socket??和??threading??模块的简单方法，以及更高级的方法，如使用??asyncio??进行异步编程。

1. 使用 ??socket?? 和 ??threading??

这种方法的基本思路是为每个要扫描的端口创建一个线程，每个线程负责检查该端口是否开放。

import socket

import threading

def scan_port(ip, port):

try:

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.settimeout(1) # 设置超时时间

result = sock.connect_ex((ip, port))

if result == 0:

print(f"Port {port} is open")

sock.close()

except Exception as e:

print(f"Error scanning port {port}: {e}")

def main(ip, start_port, end_port):

threads = []

for port in range(start_port, end_port + 1):

thread = threading.Thread(target=scan_port, args=(ip, port))

threads.append(thread)

thread.start()

for thread in threads:

thread.join()

if __name__ == "__main__":

target_ip = "192.168.1.1" # 目标IP地址

start_port = 1 # 开始端口

end_port = 1024 # 结束端口

main(target_ip, start_port, end_port)

2. 使用 ??asyncio?? 进行异步扫描

??asyncio?? 是 Python 的异步 I/O 框架，可以显著提高端口扫描的速度，因为它允许在一个线程中并发执行多个任务。

import asyncio

import socket

async def scan_port(ip, port):

try:

conn = asyncio.open_connection(ip, port)

reader, writer = await asyncio.wait_for(conn, timeout=1)

print(f"Port {port} is open")

writer.close()

await writer.wait_closed()

except (asyncio.TimeoutError, ConnectionRefusedError):

pass

async def main(ip, start_port, end_port):

tasks = []

for port in range(start_port, end_port + 1):

task = asyncio.create_task(scan_port(ip, port))

tasks.append(task)

await asyncio.gather(*tasks)

if __name__ == "__main__":

target_ip = "192.168.1.1" # 目标IP地址

start_port = 1 # 开始端口

end_port = 1024 # 结束端口

asyncio.run(main(target_ip, start_port, end_port))

3. 使用 ??scapy?? 进行更复杂的扫描

??scapy?? 是一个强大的网络工具包，可以用于发送和接收网络数据包，包括进行端口扫描。使用 ??scapy?? 可以实现更复杂的扫描策略，如 SYN 扫描等。

from scapy.all import sr1, IP, TCP

def scan_port(ip, port):

src_port = 1025 # 源端口

syn_packet = IP(dst=ip) / TCP(sport=src_port, dport=port, flags='S')

response = sr1(syn_packet, timeout=1, verbose=0)

if response and response.haslayer(TCP) and response.getlayer(TCP).flags & 0x12: # SYN-ACK

print(f"Port {port} is open")

# 发送 RST 包关闭连接

rst_packet = IP(dst=ip) / TCP(sport=src_port, dport=port, flags='R')

send(rst_packet, verbose=0)

def main(ip, start_port, end_port):

for port in range(start_port, end_port + 1):

scan_port(ip, port)

if __name__ == "__main__":

target_ip = "192.168.1.1" # 目标IP地址

start_port = 1 # 开始端口

end_port = 1024 # 结束端口

main(target_ip, start_port, end_port)

总结

多线程：适用于简单的端口扫描，易于理解和实现。
异步编程：适用于需要高性能和高并发的场景，能够显著提高扫描速度。
Scapy：适用于需要更复杂扫描策略的场景，如 SYN 扫描、UDP 扫描等。

选择哪种方法取决于你的具体需求和目标。希望这些示例对你有所帮助！