在网络管理和安全评估中，网络扫描和通信是两个至关重要的环节。Python 的 Scapy 库因其强大的网络数据包处理能力，成为开发和实现这些功能的理想工具。本文将介绍一个基于 Scapy 编写的 Python 脚本，该脚本集成了 ARP 扫描、端口扫描以及 TCP 三次握手和简单聊天功能，为用户提供了一个多功能的网络工具集。

项目概述

Scapy 是一个功能强大的交互式数据包处理程序，允许用户发送、嗅探、解析和伪造网络数据包。通过 Scapy，开发者可以实现复杂的网络操作，如网络扫描、安全审计和网络通信。本文介绍的项目利用 Scapy 库，提供了一个命令行工具，支持 ARP 扫描、端口扫描以及 TCP 三次握手和简单聊天功能。

功能详解

1. ARP 扫描

ARP（地址解析协议）扫描用于检测局域网内活动的主机。通过发送 ARP 请求，ARP 扫描可以确定哪些 IP 地址对应的主机是在线的。

实现方式

• 获取本地 MAC 地址。

• 构造 ARP 请求包，发送给目标 IP 地址。

• 接收并解析 ARP 响应，判断目标主机是否在线。

• 输出在线主机的 IP 和 MAC 地址。

2. 端口扫描

端口扫描用于检测目标主机上开放的端口。通过发送 TCP SYN 包，端口扫描可以确定哪些端口处于开放状态。

实现方式

• 构造 TCP SYN 包，发送给目标主机的指定端口。

• 接收并解析 TCP 响应，判断端口是否开放。

• 如果端口开放，发送 TCP RST 包关闭连接，避免对目标主机造成影响。

• 输出开放的端口号。

3. TCP 三次握手及聊天

TCP 三次握手是建立可靠连接的基础。通过模拟 TCP 三次握手，用户可以与目标主机建立连接，并进行简单的聊天。

实现方式

• 构造 TCP SYN 包，发送给目标主机的指定端口，等待 SYN/ACK 响应。

• 收到 SYN/ACK 响应后，构造 TCP ACK 包，完成三次握手。

• 进入聊天模式，接收用户输入的消息并发送给目标主机。

• 接收并显示目标主机的响应。

• 用户可以输入 exit 退出聊天。

代码结构

• 导入模块: 导入 Scapy 库及其他必要的模块。

• 函数定义: 定义 ARP 扫描、端口扫描和 TCP 三次握手及聊天的功能函数。

• 命令行参数解析: 使用 argparse 模块解析命令行参数，支持选择不同的功能和指定目标 IP 地址、端口范围等。

• 主函数: 根据命令行参数调用相应的功能函数。

使用方法

1. ARP 扫描: 使用 --arp 参数扫描指定 IP 地址或网段，检测在线主机。

   python script.py --arp --ip 192.168.10.1-255
   

2. 端口扫描: 使用 --port 参数扫描指定 IP 地址的端口，检测开放端口。

   python script.py --port --ip 192.168.10.1 --start-port 20 --end-port 100
   

3. TCP 三次握手及聊天: 使用 --tcp 参数与指定 IP 地址的目标主机进行 TCP 三次握手，并进入聊天模式。

   python script.py --tcp --ip 192.168.10.1 --dst-port 55555
   

注意事项

• ARP 扫描和端口扫描仅支持单一 IP 地址，不支持网段。

• 运行脚本可能需要管理员权限，尤其是在发送和接收数据包时。

• 使用这些工具时，请确保遵守相关法律法规，避免未经授权的网络扫描和通信。

结论

本文介绍的基于 Scapy 的网络工具集，提供了一个简洁而强大的解决方案，用于执行 ARP 扫描、端口扫描以及 TCP 三次握手和简单聊天。通过灵活的命令行参数，用户可以根据需要选择不同的功能，进行网络探测和通信。无论是在网络管理、安全审计还是学习和实验中，这个工具集都将是一个有价值的助手。

希望本文的介绍能够帮助读者更好地理解和使用这个基于 Scapy 的网络工具集，为网络操作和管理提供便利。

项目地址：https://github.com/2678509359/Scapy-based-network-scanning-tool

基于scapy的网络扫描工具-源码

import logging
import random
import argparse

from scapy.arch import get_if_hwaddr
from scapy.config import conf
from scapy.layers.inet import TCP, IP
from scapy.layers.l2 import ARP
from scapy.packet import Raw
from scapy.sendrecv import sr1, send

# 配置Scapy日志级别
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)


def scapy_ip(start, end=10, network='192.168.10.'):
    local_mac = get_if_hwaddr(conf.iface)
    for i in range(start, start + end):
        ip = f'{network}{i}'
        try:
            pkg = ARP(op=1, psrc=ip, hwsrc=local_mac, pdst=ip)
            reply = sr1(pkg, timeout=3, verbose=False)
            if reply and ARP in reply and reply[ARP].op == 2:
                print(f'{ip} 在线，MAC 地址: {reply[ARP].hwsrc}')
        except Exception as e:
            continue


def scapy_port(ip, start_port=20, end_port=100, src_ip='192.168.10.101'):
    for port in range(start_port, end_port + 1):
        try:
            pkg = IP(src=src_ip, dst=ip) / TCP(dport=port, flags='S')
            reply = sr1(pkg, timeout=1, verbose=False)
            if reply and reply.haslayer(TCP) and reply[TCP].flags == 0x12:  # SYN/ACK
                print(f'端口 {port} 开放')
                # 发送 RST 包关闭连接
                rst = IP(src=src_ip, dst=ip) / TCP(dport=port, flags='R', seq=reply[TCP].ack)
                send(rst, verbose=False)
        except Exception as e:
            continue


def scapy_tcp_handshake(ip, dst_port=55555, src_port=None):
    if src_port is None:
        src_port = random.randint(1024, 65535)

    # 第一次握手
    pkg_1 = IP(dst=ip) / TCP(sport=src_port, dport=dst_port, flags='S')
    reply = sr1(pkg_1, timeout=2, verbose=False)

    if not reply or not reply.haslayer(TCP) or reply[TCP].flags != 0x12:  # SYN/ACK
        print("未收到 SYN/ACK 响应或响应不完整")
        return

    # 第二次握手
    seq_ack = reply[TCP].ack
    ack_seq = reply[TCP].seq + 1
    pkg_2 = IP(dst=ip) / TCP(sport=src_port, dport=dst_port, flags='A', seq=ack_seq, ack=seq_ack)
    send(pkg_2, verbose=False)

    print("三次握手成功，开始发送聊天信息...")

    while True:
        message = input("输入消息发送 (或 'exit' 退出): ")
        if message.lower() == 'exit':
            break
        pkg_chat = IP(dst=ip) / TCP(sport=src_port, dport=dst_port, flags='PA', seq=ack_seq, ack=seq_ack) / message
        reply = sr1(pkg_chat, timeout=2, verbose=False)

        if reply and reply.haslayer(TCP) and reply[TCP].flags == 0x10:  # ACK
            ack_seq += len(message)
            try:
                received = reply[Raw].load.decode('utf-8')
                print(f"收到响应: {received}")
            except UnicodeDecodeError:
                print("收到的响应无法解码为 UTF-8")
        elif reply is None:
            print("未收到响应")
        else:
            print("握手失败或连接关闭")


def parse_arguments():
    parser = argparse.ArgumentParser(description="Scapy 网络工具集", formatter_class=argparse.RawTextHelpFormatter)
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("--arp", action="store_true", help="执行 ARP 扫描")
    group.add_argument("--port", action="store_true", help="执行端口扫描")
    group.add_argument("--tcp", action="store_true", help="执行 TCP 三次握手及聊天")

    parser.add_argument("--ip", type=str, required=True, help="目标 IP 地址或网段（例如 192.168.10.1 或 192.168.10.0/24）")

    parser.add_argument("--start-port", type=int, default=20, help="端口扫描起始端口（默认: 20）")
    parser.add_argument("--end-port", type=int, default=100, help="端口扫描结束端口（默认: 100）")
    parser.add_argument("--dst-port", type=int, default=55555, help="TCP 目标端口（默认: 55555）")

    return parser.parse_args()


def main():
    args = parse_arguments()

    if args.arp:
        if '/' in args.ip:
            # 处理网段
            network, mask = args.ip.split('/')
            start_ip = int(network.split('.')[-1])
            end_ip = start_ip + (0xFFFFFFFF << (32 - int(mask))) - 1
            scapy_ip(start=start_ip, end=end_ip - start_ip + 1, network=f"{network}.{start_ip // 256}.{start_ip % 256}.")
        else:
            scapy_ip(start=int(args.ip.split('.')[-1]), network=args.ip.rsplit('.', 1)[0] + '.')

    if args.port:
        if '/' in args.ip:
            print("端口扫描不支持网段，请提供一个单一的IP地址。")
        else:
            scapy_port(args.ip, args.start_port, args.end_port)

    if args.tcp:
        if '/' in args.ip:
            print("TCP 握手不支持网段，请提供一个单一的IP地址。")
        else:
            scapy_tcp_handshake(args.ip, args.dst_port)


if __name__ == '__main__':
    main()

基于scapy的网络扫描工具-源码解析

这段代码是一个使用 Scapy 库编写的 Python 脚本，用于执行网络扫描和 TCP 三次握手及聊天功能。以下是对代码的详细分析：

导入模块

• logging: 用于配置 Scapy 的日志级别。

• random: 用于生成随机端口号。

• argparse: 用于解析命令行参数。

• scapy 相关模块: 用于网络数据包的构造、发送和接收。

函数定义

scapy_ip(start, end, network)

• 功能: 执行 ARP 扫描，检测指定网段内的在线主机。

• 参数:

  • start: 起始 IP 地址的最后一个八位字节。

  • end: 结束 IP 地址的最后一个八位字节。

  • network: 网络前缀（例如 192.168.10.）。

• 实现:

  • 获取本地 MAC 地址。

  • 遍历指定范围内的 IP 地址，发送 ARP 请求并等待响应。

  • 如果收到 ARP 响应且操作码为 2（表示 ARP 回复），则打印在线主机的 IP 和 MAC 地址。

scapy_port(ip, start_port, end_port, src_ip)

• 功能: 执行端口扫描，检测指定 IP 地址的开放端口。

• 参数:

  • ip: 目标 IP 地址。

  • start_port: 起始端口号。

  • end_port: 结束端口号。

  • src_ip: 源 IP 地址。

• 实现:

  • 遍历指定范围内的端口号，发送 SYN 包并等待响应。

  • 如果收到 SYN/ACK 响应，则打印开放端口，并发送 RST 包关闭连接。

scapy_tcp_handshake(ip, dst_port, src_port)

• 功能: 执行 TCP 三次握手，并启动一个简单的聊天功能。

• 参数:

  • ip: 目标 IP 地址。

  • dst_port: 目标端口号。

  • src_port: 源端口号（可选，默认随机生成）。

• 实现:

  • 执行 TCP 三次握手。

  • 进入一个循环，接收用户输入的消息并发送给目标 IP 和端口。

  • 接收并打印来自目标的响应。

parse_arguments()

• 功能: 解析命令行参数。

• 实现:

  • 使用 argparse 创建一个参数解析器。

  • 定义互斥的参数组（ARP、端口扫描、TCP 握手）。

  • 定义其他必要的参数（IP 地址、端口范围等）。

main()

• 功能: 主函数，根据命令行参数调用相应的功能。

• 实现:

  • 解析命令行参数。

  • 根据参数调用 scapy_ip、scapy_port 或 scapy_tcp_handshake 函数。

命令行参数

• --arp: 执行 ARP 扫描。

• --port: 执行端口扫描。

• --tcp: 执行 TCP 三次握手及聊天。

• --ip: 目标 IP 地址或网段。

• --start-port: 端口扫描起始端口（默认 20）。

• --end-port: 端口扫描结束端口（默认 100）。

• --dst-port: TCP 目标端口（默认 55555）。

注意事项

• ARP 扫描不支持网段，需要提供单一 IP 地址。

• 端口扫描和 TCP 握手不支持网段，需要提供单一 IP 地址。

• 代码中使用了 Scapy 的 sr1 和 send 函数发送和接收数据包，这些操作可能需要管理员权限。

总结

这段代码提供了一个简单的网络工具集，可以用于 ARP 扫描、端口扫描和 TCP 三次握手及聊天。通过命令行参数可以灵活选择不同的功能。