ZapcoMan's world
python

自定义网络通讯协议：基于struct的二进制协议设计

2026-07-06 #渗透测试#自定义通讯协议

本文仅供合法授权的安全研究与学习使用，请勿用于非法用途。读者应确保行为符合当地法律法规。

前言

在网络编程中，TCP是流式传输协议——它像一条没有边界的管道，发送方写入的数据会被任意分割和合并。你调用send发送了”ABC”和”DEF”两次，接收方可能一次recv就收到”ABCDEF”。这就是所谓的”粘包”问题。

要解决这个问题，应用层必须自行定义消息边界——也就是设计”应用层协议”。HTTP用\r\n\r\n分隔头部，DNS用固定长度的长度字段。本文将基于Python的struct模块，设计一套名为”VIBE”的二进制网络协议，实现可靠的数据包收发。

技术背景

粘包问题

TCP是面向字节流的协议，不维护应用层消息的边界。发送方连续发送多条消息时，TCP可能将它们合并为一个报文发送（Nagle算法），也可能将一条消息拆分为多个报文。接收方如果不做处理，就无法区分消息的边界。

二进制协议 vs 文本协议

应用层协议分为两大类：

类型 代表协议 优点 缺点
文本协议 HTTP、SMTP 可读性好，易调试 解析复杂，体积大
二进制协议 DNS、TLS 紧凑高效，解析快 不可读，需工具分析

二进制协议通过固定格式的头部字段来描述消息结构，解析时直接按字节偏移读取，效率远高于文本协议的正则匹配。

Python struct模块

struct模块是Python处理二进制数据的利器。它通过格式字符串将Python值打包为字节串，或将字节串解包为Python值。

常用格式字符：

字符 C类型 Python类型 大小
s char[] bytes 1字节
H unsigned short int 2字节
I unsigned int int 4字节
! 网络字节序 - -

!前缀表示使用网络字节序（大端序），这是网络协议的标准字节序。

实现思路

VIBE协议采用经典的”头部+载荷”结构：

1
2
3
4
+--------+--------+--------+--------+--------+--------+--------+--------+--------+---...
| 'V'    | 'I'    | 'B'    | 'E'    | 包类型(2字节) | 数据长度(2字节) | 数据载荷...
+--------+--------+--------+--------+--------+--------+--------+--------+--------+---...
|<------- 协议头(4字节) ------>|<-- 类型 -->|<-- 长度 -->|<------- 载荷 ------->

整体架构包含两个组件：

  1. 服务器端：监听端口，接收数据包并回显响应
  2. 客户端：封装为Client类，提供send_packet和receive_packet方法，支持断线重连

协议格式字符串为 !4sHH：4s表示4字节字符串（协议头”VIBE”），两个H分别表示数据包类型和数据长度。

核心代码解析

1. 协议常量定义

1
2
3
4
5
6
7
import socket
import struct

# 定义协议格式
PROTOCOL_HEADER = b'VIBE'  # 固定的协议开头，用于标识VIBE协议
HEADER_FORMAT = '!4sHH'    # 格式：4字节头 + 2字节包类型 + 2字节长度
HEADER_SIZE = struct.calcsize(HEADER_FORMAT)  # 计算头部固定大小（8字节）

struct.calcsize(HEADER_FORMAT)计算头部结构的固定大小。!4sHH = 4字节 + 2字节 + 2字节 = 8字节。这个值在收发数据时用于精确读取头部。

2. 服务器端：数据包接收与响应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def handle_client(client_socket):
    """
    处理客户端连接。
    循环接收数据包，解析协议头部，读取载荷，并回显响应。
    """
    while True:
        try:
            # 第一步：精确接收头部（8字节）
            header = client_socket.recv(HEADER_SIZE)
            if not header:
                print("Connection closed by client")
                break

            # 第二步：解包头部，提取协议头、包类型、数据长度
            protocol_header, pkt_type, packet_length = struct.unpack(HEADER_FORMAT, header)
            if protocol_header != PROTOCOL_HEADER:
                print("Invalid protocol header")
                break

            # 第三步：根据头部中的长度字段，精确接收载荷
            data = client_socket.recv(packet_length)
            print(f"Received packet type: {pkt_type}, data: {data.decode('utf-8')}")

            # 第四步：构造响应数据包
            response_data = "Hello, Client!"
            response_bytes = response_data.encode('utf-8')
            response_packet_length = len(response_bytes)
            # 打包响应头部
            response_header = struct.pack(HEADER_FORMAT, PROTOCOL_HEADER, pkt_type, response_packet_length)
            # 发送头部+载荷
            client_socket.sendall(response_header + response_bytes)

        except Exception as e:
            print(f"Error handling client: {e}")
            break

    client_socket.close()

服务器端的接收流程严格遵循”先读头部、再读载荷”的模式。这是解决粘包问题的标准方案：头部中的packet_length字段告诉接收方”还有多少字节的载荷需要读取”，从而精确界定一个完整消息。

struct.unpack(HEADER_FORMAT, header)将8字节头部解包为三个值。如果协议头不是b'VIBE'，说明收到的数据不符合协议规范，直接断开连接。

3. 服务器端：启动监听

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def start_server(host, port):
    """
    启动TCP服务器，监听指定地址和端口。
    """
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((host, port))
    server.listen(5)
    print(f"Server listening on {host}:{port}")

    while True:
        # 接受客户端连接
        client_socket, addr = server.accept()
        print(f"Accepted connection from {addr}")
        # 处理客户端连接（单线程模式）
        handle_client(client_socket)

服务器采用单线程处理模式，一次只服务一个客户端。对于学习协议设计而言，这种简洁的结构足以说明问题。在实际生产环境中，可以通过threading扩展为多线程模式。

4. 客户端：连接与断线重连

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Client:
    def __init__(self, server_address, server_port):
        self.server_address = server_address
        self.server_port = server_port
        self.socket = None
        self.connect()

    def connect(self):
        """
        循环尝试连接服务器，直到成功。
        连接被拒绝时每5秒重试一次。
        """
        while True:
            try:
                self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                self.socket.connect((self.server_address, self.server_port))
                print("Connected to server")
                break
            except ConnectionRefusedError:
                print("Connection refused. Retrying...")
                time.sleep(5)

客户端封装为Client类。connect方法实现了断线重连逻辑——当服务器未启动时，connect会抛出ConnectionRefusedError，客户端捕获后等待5秒重试。这种设计使得客户端可以先于服务器启动，不会因为服务器暂时不可用而退出。

5. 客户端：发送数据包

1
2
3
4
5
6
7
8
9
10
11
def send_packet(self, pkt_type, msg_data):
    """
    发送数据包到服务器。
    将消息编码后打包为VIBE协议格式发送。
    """
    data_bytes = msg_data.encode('utf-8')
    packet_length = len(data_bytes)
    # 打包头部：协议头 + 包类型 + 数据长度
    header = struct.pack(HEADER_FORMAT, PROTOCOL_HEADER, pkt_type, packet_length)
    # 发送头部+载荷（原子发送）
    self.socket.sendall(header + data_bytes)

sendall确保所有数据都被发送完毕。与send不同，send可能只发送部分数据（返回实际发送的字节数），而sendall会循环调用send直到所有数据发送完成。对于协议数据包这种需要完整发送的场景，sendall是更安全的选择。

6. 客户端：接收数据包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def receive_packet(self):
    """
    接收服务器发送的数据包。
    先读取头部，验证协议头，再根据长度读取载荷。
    """
    try:
        # 精确读取头部
        header = self.socket.recv(HEADER_SIZE)
        if not header:
            raise ConnectionResetError("Connection closed by server")

        # 解包头部
        protocol_header, pkt_type, packet_length = struct.unpack(HEADER_FORMAT, header)
        if protocol_header != PROTOCOL_HEADER:
            raise ValueError("Invalid protocol header")

        # 根据长度读取载荷
        data = self.socket.recv(packet_length)
        return pkt_type, data.decode('utf-8')
    except ConnectionResetError as e:
        print(f"Connection reset by peer: {e}")
        self.connect()  # 自动重连
        return None, None

客户端的接收逻辑与服务器端对称。当连接被重置时，receive_packet会调用self.connect()自动重连，并返回(None, None)通知上层逻辑。调用方通过检查返回值决定是否继续处理。

7. 主程序调用

1
2
3
4
5
6
7
8
9
10
11
if __name__ == "__main__":
    client = Client('192.168.1.6', 38745)
    try:
        client.send_packet(1, "Hello, Server!")
        while True:
            pkt_type, data = client.receive_packet()
            if pkt_type is None and data is None:
                continue
            print(f"Received packet type: {pkt_type}, data: {data}")
    finally:
        client.close()

客户端发送一条消息后进入循环，持续接收服务器响应。finally块确保无论是否异常，连接都会被正确关闭。

使用方法与运行效果

1
2
3
4
5
6
7
8
9
10
# 终端1：启动服务器
python 服务器端.py
# 输出: Server listening on 192.168.1.6:38745

# 终端2：启动客户端
python 客户端.py
# 客户端输出: Connected to server
#            Received packet type: 1, data: Hello, Client!
# 服务器输出: Accepted connection from 192.168.1.6:xxxxx
#            Received packet type: 1, data: Hello, Server!

协议设计的几点思考

为什么需要协议头魔数？

PROTOCOL_HEADER = b'VIBE'这样的固定标识称为”魔数”（Magic Number）。它的作用是快速识别协议——当接收到的数据不以VIBE开头时，可以立即判定为无效数据。这在处理端口扫描误连、协议版本不匹配等场景时非常有用。

为什么用网络字节序？

!前缀指定网络字节序（大端序）。不同CPU架构的字节序不同（x86是小端序，ARM可配置），如果直接使用主机字节序，在不同架构的机器间通信时数据会错乱。网络字节序是网络协议的事实标准，保证了跨平台兼容性。

长度字段为什么用2字节？

H表示unsigned short，范围是0~65535，即单个数据包最大约64KB。如果需要传输更大的数据，可以改用I（4字节，最大4GB），或者在协议中增加分片字段。

总结

本文设计并实现了一套名为VIBE的自定义二进制网络协议，核心知识点：

  1. 粘包问题的解决：通过”固定头部+长度字段+变长载荷”的结构精确定界消息
  2. struct模块：pack/unpack实现Python值与二进制数据的转换，calcsize计算结构大小
  3. 协议头验证：魔数b'VIBE'快速识别协议有效性
  4. 网络字节序：!前缀确保跨平台兼容
  5. 断线重连：客户端捕获ConnectionRefusedError后自动重试
  6. sendall vs send：sendall保证数据完整发送，避免部分发送问题

自定义协议是网络编程的核心能力。理解了这套设计方法，就能读懂DNS、TLS等真实协议的报文结构，也能为自己的应用设计高效的通信协议。无论是物联网设备通信、游戏服务器协议，还是分布式系统的RPC框架，都建立在同样的原理之上。

评论
分享

相关文章

查看更多
从零打造漏洞扫描器：端口扫描 + Web 检测 + 报告生成 2026-07-06
WAF 指纹识别原理与实现：从 sqlmap 源码学起 2026-07-06
图像预处理 + 二维码识别全攻略：9 种方法让模糊二维码无处遁形 2026-07-06
Vue3 + Flask 全栈实战：从零构建在线二维码解析器 2026-07-06