1
    if len(packet) < 20:              # ◆ len() 获取二进制数据的字节数
2
                                      #   IP 头最少 20 字节，少于 20 说明数据不完整
3
        return None                   # ◆ return = 返回，None = 空值/啥也没有
4
                                      #   直接返回 None，告诉调用者"这包没法解析"

1
    ip_header = struct.unpack("!BBHHHBBH4s4s", packet[:20])

1
"!BBHHHBBH4s4s" 总共 = 1+1+2+2+2+1+1+2+4+4 = 20 字节，正好是 IP 头
2

3
解析结果是一个元组（tuple），对应：
4
  索引0: B  (版本+首部长度)     ← version_ihl
5
  索引1: B  (服务类型)           ← 暂不用
6
  索引2: H  (总长度)             ← total_len
7
  索引3: H  (标识)               ← 暂不用
8
  索引4: H  (标志+片偏移)        ← 暂不用
9
  索引5: B  (TTL 生存时间)       ← 暂不用
10
  索引6: B  (协议号)             ← protocol
11
  索引7: H  (首部校验和)         ← 暂不用
12
  索引8: 4s (源 IP 地址 4 字节)  ← src_ip
13
  索引9: 4s (目的 IP 地址 4 字节)← dst_ip

1
    version_ihl = ip_header[0]        # ◆ ip_header 是元组，[0] 取第一个元素
2
                                      #   这个字节的前 4 bit 是版本，后 4 bit 是首部长度
3
    version = version_ihl >> 4        # ◆ >> 是右移运算符
4
                                      #   比如 0x45 (二进制 0100_0101) >> 4 = 0x04 = 4
5
                                      #   即 IPv4
6
    ihl = version_ihl & 0xF           # ◆ & 是"按位与"运算符，0xF = 二进制 0000_1111
7
                                      #   0x45 & 0x0F = 0x05 = 5
8
                                      #   即首部长度 = 5 × 4 = 20 字节（不带选项的 IP 头）
9
    header_len = ihl * 4              # ◆ 首部长度单位是"4字节"，所以要 ×4

1
    if version != 4:                  # ◆ 如果版本号不是 4（即不是 IPv4）
2
        return None                   #    则无法解析，返回 None

1
    total_len  = ip_header[2]         # ◆ 取索引2 → 总长度（整个IP数据包有多少字节）
2
    protocol   = ip_header[6]         # ◆ 取索引6 → 协议号（6=TCP, 17=UDP, 1=ICMP）
3
    src_ip     = socket.inet_ntoa(ip_header[8])   # ◆ inet_ntoa：把 4 字节二进制转成"192.168.1.1"
4
    dst_ip     = socket.inet_ntoa(ip_header[9])   # ◆ 同理把 4 字节转成 IP 字符串

1
    return {                           # ◆ return 字典返回解析结果
2
        "src_ip":     src_ip,          #    源 IP（谁发的）
3
        "dst_ip":     dst_ip,          #    目的 IP（发给谁）
4
        "protocol":   protocol,        #    协议号（6/17/1 等）
5
        "total_len":  total_len,       #    整个 IP 包的长度
6
        "header_len": header_len,      #    IP 头长度（用于找到传输层数据在哪）
7
    }

1
    protocol = ip_info["protocol"]     # ◆ 从字典取出协议号，["protocol"] 是字典取值语法
2
    header_len = ip_info["header_len"] # ◆ 从字典取出 IP 头长度
3

4
    transport_data = packet[header_len:]   # ◆ 切片：跳过 IP 头，剩下的就是传输层数据
5
                                           #   [header_len:] 表示"从 header_len 位置到末尾"

1
    elif protocol == PROTO_UDP and len(transport_data) >= 8:
2
        # ↑ 如果协议号=17（UDP）且剩余≥8字节（UDP头固定8字节）
3
        udp = struct.unpack("!HHHH", transport_data[:8])
4
        # ↑ 格式 "!HHHH"：
5
        #   [0] H 源端口    [1] H 目的端口
6
        #   [2] H 长度      [3] H 校验和
7
        return {
8
            "proto":    "UDP",
9
            "src_port": udp[0],
10
            "dst_port": udp[1],
11
            "length":   udp[2],
12
        }

1
    elif protocol == PROTO_ICMP and len(transport_data) >= 4:
2
        # ↑ 如果协议号=1（ICMP）且剩余≥4字节
3
        icmp = struct.unpack("!BBH", transport_data[:4])
4
        # ↑ 格式 "!BBH"：[0] B 类型  [1] B 代码  [2] H 校验和
5
        return {
6
            "proto": "ICMP",
7
            "type":  icmp[0],     # ◆ 如 8=回显请求(ping), 0=回显应答(pong)
8
            "code":  icmp[1],     # ◆ 子类型
9
        }

1
    else:
2
        return {"proto": f"Other({protocol})", "src_port": 0, "dst_port": 0}
3
        # ↑ f"Other({protocol})" 是 f-string 格式化字符串
4
        #   比如协议号=2，显示 "Other(2)"，表示无法详细解析

1
    proto_name = trans.get("proto", "?")
2
    # ◆ .get() 是字典的安全取值方法
3
    #   如果字典有 "proto" 这个键 → 返回其值
4
    #   如果没有 → 返回默认值 "?"
5
    #   等价于 trans["proto"] 但不会因为键不存在而报错

1
    ip_str = f"{ip['src_ip']:<16} -> {ip['dst_ip']:<16}"
2
    #   左右对齐各16字符，输出如： "192.168.1.5      -> 10.0.0.1        "
3

4
    len_str = f"{packet_len:>5}B"
5
    #   右对齐5字符，输出如： " 1500B"
6

7
    print(f"  [{index:>4}] {ip_str} | {transport_str} | {len_str}{flags_str}")
8
    #   [{index:>4}] → 序号右对齐4字符
9
    #   最终输出示例：
10
    #   [   1] 192.168.1.5      -> 10.0.0.1         | TCP    443 -> 54321 |  1500B [flags=0x18]

1
    print("=" * 70)                           # ◆ "=" * 70 = 70个等号连起来
2
    print("  网络嗅探器（scapy + Npcap 驱动版）")
3
    print("  协议栈分层分析：IP → TCP/UDP/ICMP")
4
    print("=" * 70)

1
    hostname = socket.gethostname()           # ◆ 获取本机的计算机名（如 "DESKTOP-ABC"）
2
    try:
3
        local_ip = socket.gethostbyname(hostname)  # ◆ 根据计算机名查本机 IP
4
    except:                                   # ◆ 如果查不出来（如没联网）
5
        local_ip = "0.0.0.0"                  #    就用 "0.0.0.0" 代替
6
    print(f"\n本机 IP: {local_ip}")           # ◆ \n = 换行符
7
    print(f"本机名:  {hostname}")

1
    try:
2
        from scapy.all import sniff           # ◆ sniff = scapy 的抓包函数
3
        from scapy.layers.inet import IP      # ◆ IP = scapy 用来判断数据包是否有 IP 层
4
    except ImportError:                       # ◆ 如果 import 失败（没装 scapy）
5
        print("\n[!] 未安装 scapy，请运行: pip install scapy")
6
        print("[!] 同时请确保已安装 Npcap 驱动: https://npcap.com/#download")
7
        sys.exit(1)                           # ◆ 退出程序，1 表示异常退出

1
    print("\n" + "-" * 40)
2
    print("协议过滤选项：IP / TCP / UDP / ICMP / ALL（默认ALL=全部分析）")
3
    filter_proto = input("输入要分析的协议（直接回车=全部分析）: ").strip()
4
    if not filter_proto:                       # ◆ 空字符串在 Python 中会被当作 False
5
        filter_proto = "ALL"                   #    直接回车 → 默认 ALL
6

7
    bpf_filter = ""                            # ◆ BPF 是底层过滤语法，提升性能
8
    if filter_proto.upper() == "TCP":          #    让 Npcap 驱动只给 scapy "TCP 的包"
9
        bpf_filter = "tcp"
10
    elif filter_proto.upper() == "UDP":
11
        bpf_filter = "udp"
12
    elif filter_proto.upper() == "ICMP":
13
        bpf_filter = "icmp"

1
    try:
2
        count_str = input("捕获数据包数量（直接回车=不限，Ctrl+C 停止）: ").strip()
3
        max_count = int(count_str) if count_str else 0
4
        # ◆ int(count_str) if count_str else 0
5
        #   是 Python 的三元表达式：
6
        #   如果 count_str 非空 → int(count_str)
7
        #   如果 count_str 为空 → 0（0表示不限量）
8
    except ValueError:                         # ◆ 如果输入的不是数字
9
        max_count = 0

1
    print(f"\n[+] 过滤器: {filter_proto.upper()}")
2
    print(f"[+] 网卡: {iface if iface else '自动'}")
3
    print(f"[+] 开始嗅探...（按 Ctrl+C 停止）\n")
4
    print("-" * 70)
5

6
    stats = {"total": 0, "TCP": 0, "UDP": 0, "ICMP": 0, "Other": 0}
7
    # ◆ 创建一个字典来计数：每种协议抓到多少包

1
    def packet_handler(pkt):                   # ◆ 嵌套函数！每抓到一个包，scapy 就调用它

1
    try:
2
        sniff(                                # ◆ scapy 的核心抓包函数
3
            prn=packet_handler,               # ◆ prn = 回调函数，每抓到一个包就调用
4
            store=False,                      # ◆ store=False = 不把包存内存（省内存）
5
            iface=iface,                      # ◆ iface = 网卡名，None=自动选择
6
            filter=bpf_filter if bpf_filter else None,
7
            # ◆ filter = BPF 过滤表达式，空字符串则传 None
8
        )

1
    print("\n" + "=" * 70)
2
    print("  嗅探统计")
3
    print("=" * 70)
4
    print(f"  总数据包:  {stats['total']}")     # ◆ f-string 直接嵌入变量
5
    print(f"  TCP 包:    {stats['TCP']}")
6
    print(f"  UDP 包:    {stats['UDP']}")
7
    print(f"  ICMP 包:   {stats['ICMP']}")
8
    print(f"  其他协议:  {stats['Other']}")
9
    print("=" * 70)