发布于 由admin

WebSocket Subprotocols 逆向：如何识别并分析自定义 WebSocket 子协议的通信内容？

WebSocket 子协议逆向：解密自定义通信的奥秘

各位观众，各位朋友，大家好！我是今天的讲师，一位在代码世界里摸爬滚打多年的老兵。今天咱们聊点刺激的——WebSocket 子协议逆向！

WebSocket 这玩意儿，大家应该都用过，即使没直接上手，也肯定听说过。它就像一根双向管道，让客户端和服务器可以实时通信，不用像传统的 HTTP 请求那样，客户端巴巴地等着服务器回复。

但是，WebSocket 本身只负责建立连接和传输原始数据，就像一条空荡荡的管道，里面能跑啥，得靠“子协议”说了算。子协议定义了消息的格式、语义和交互规则，让客户端和服务器知道彼此在说什么。

如果 WebSocket 是高速公路，那子协议就是跑在上面的车队，各有各的运输标准。

今天我们要做的，就是当这条高速公路上出现了一支我们不认识的车队时，如何去识别它们，搞清楚它们运的到底是啥。

一、什么是 WebSocket 子协议？

WebSocket 协议本身非常简单，它只定义了建立连接和传输数据的基本机制。要进行更复杂的交互，就需要使用子协议。子协议本质上是一种应用层协议，它建立在 WebSocket 连接之上，定义了消息的格式、编码方式、以及客户端和服务器之间的交互流程。

在 WebSocket 握手阶段，客户端可以通过 Sec-WebSocket-Protocol 首部声明自己支持的子协议列表，服务器则在响应中选择一个它支持的子协议，并通过 Sec-WebSocket-Protocol 首部返回给客户端。

举个例子，客户端可能发送：

GET /chat HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin: http://example.com
Sec-WebSocket-Protocol: chat, superchat

服务器可能会响应：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: superchat

这意味着客户端和服务器最终协商使用的子协议是 superchat。

常见的 WebSocket 子协议有：

子协议 描述
wamp WebSocket Application Messaging Protocol，用于构建分布式应用程序，提供远程过程调用（RPC）和发布/订阅功能。
mqtt Message Queuing Telemetry Transport，一种轻量级的消息传递协议，常用于物联网设备。
graphqlws 基于 WebSocket 的 GraphQL 协议，用于实时数据传输。
jsonrpc JSON Remote Procedure Call，一种使用 JSON 作为数据格式的 RPC 协议。
(自定义) 除了这些标准协议，很多应用程序会使用自定义的子协议，用于满足特定的业务需求。这些自定义协议往往是逆向分析的重点。

二、逆向分析的准备工作

想要逆向分析一个未知的 WebSocket 子协议，我们需要做好充分的准备。这就像侦探破案，得先收集线索。

  1. 抓包工具： 这是我们的眼睛，能看到客户端和服务器之间传输的所有数据。常用的工具包括：

    • Wireshark: 功能强大，但上手难度较高。
    • Burp Suite: 渗透测试利器，可以拦截、修改和重放 WebSocket 消息。
    • Chrome/Edge 开发者工具: 内置的网络面板，可以查看 WebSocket 连接和消息。

  2. WebSocket 客户端工具： 方便我们手动发送和接收消息，模拟客户端行为。常用的工具有：

    • wscat: 一个命令行 WebSocket 客户端，简单易用。
    • Postman: 虽然主要用于 HTTP 请求，但也支持 WebSocket。
    • 自定义脚本 (Python, Node.js): 可以编写脚本来自动化测试和分析。

  3. 文本编辑器/代码编辑器： 用于查看和编辑抓包数据、编写测试脚本。

  4. 耐心和好奇心： 这是最重要的！逆向分析需要不断尝试、猜测和验证，需要保持耐心和对未知事物的好奇心。

三、开始逆向分析：线索搜集与初步判断

有了工具，我们就可以开始搜集线索了。

  1. 观察握手过程：

    首先，我们需要观察 WebSocket 握手过程，看看客户端和服务器协商使用了哪个子协议。Sec-WebSocket-Protocol 首部是关键。

    如果握手成功，但 Sec-WebSocket-Protocol 首部为空，意味着没有使用任何子协议，直接传输原始数据。这种情况比较简单，可以直接分析数据内容。

    如果使用了自定义的子协议，例如 my-custom-protocol，我们就需要进一步分析。

  2. 分析消息格式：

    接下来，我们需要观察客户端和服务器之间传输的消息内容。不同的子协议会使用不同的消息格式。

    • 文本消息： 消息内容是文本字符串。常见的文本格式包括：

      • JSON: 易于解析和生成，常用于数据交换。
      • XML: 结构化数据格式，但相对复杂。
      • CSV: 逗号分隔值，用于表格数据。
      • 自定义文本格式： 一些协议会使用自定义的文本格式，例如使用特定的分隔符或编码方式。

    • 二进制消息： 消息内容是二进制数据。常见的二进制格式包括：

      • Protocol Buffers: Google 开发的一种高效的序列化协议。
      • MessagePack: 一种紧凑的二进制序列化格式。
      • 自定义二进制格式： 一些协议会使用自定义的二进制格式，例如定义特定的数据结构和字段。

    通过观察消息内容，我们可以初步判断消息的格式，为后续的分析奠定基础。

    举例：

    假设我们抓到如下的WebSocket消息：

    {"type": "chat", "user": "Alice", "message": "Hello, world!"}

    很明显，这是一个 JSON 格式的消息。我们可以猜测 type 字段表示消息类型，user 字段表示发送者，message 字段表示消息内容。

    再看一个例子：

    0x01 0x00 0x05 0x48 0x65 0x6c 0x6c 0x6f

    这是一个二进制消息。我们需要进一步分析才能确定它的含义。例如，我们可能需要猜测第一个字节 0x01 表示消息类型，第二个字节 0x00 表示标志位，第三个字节 0x05 表示字符串长度，后面的五个字节 0x48 0x65 0x6c 0x6c 0x6f 表示字符串 "Hello"。

  3. 寻找规律：

    在观察消息内容时，我们需要寻找规律。例如：

    • 消息类型： 是否存在表示消息类型的字段？不同的消息类型对应不同的数据结构？
    • 数据字段： 消息中包含哪些数据字段？这些字段的含义是什么？
    • 消息顺序： 客户端和服务器之间的消息交互是否存在特定的顺序？
    • 错误处理： 如何处理错误和异常情况？

    通过寻找规律，我们可以逐渐理解协议的运作方式。

四、深入分析：解构消息格式与交互流程

在初步判断消息格式的基础上，我们需要深入分析，解构消息格式，并理解客户端和服务器之间的交互流程。

  1. JSON 格式分析：

    如果消息是 JSON 格式，我们可以使用 JSON 解析器来提取数据字段。

    Python 示例：

    import json

message = '{"type": "chat", "user": "Alice", "message": "Hello, world!"}'
data = json.loads(message)

message_type = data['type']
user = data['user']
message_content = data['message']

print(f"消息类型: {message_type}")
print(f"用户: {user}")
print(f"内容: {message_content}")

    通过解析 JSON 数据，我们可以轻松地提取出消息中的各个字段。

  2. 二进制格式分析：

    如果消息是二进制格式，我们需要根据协议的定义来解析数据。这通常需要一些逆向工程的技巧。

    Python 示例：

    import struct

message = b'x01x00x05x48x65x6cx6cx6f'

message_type = message[0]
flags = message[1]
length = message[2]
content = message[3:3+length].decode('utf-8')

print(f"消息类型: {message_type}")
print(f"标志位: {flags}")
print(f"长度: {length}")
print(f"内容: {content}")

    在这个例子中，我们使用了 struct 模块来解析二进制数据。struct 模块允许我们将二进制数据解包成不同的数据类型，例如整数、浮点数和字符串。

    更复杂的二进制数据解析：

    如果二进制数据结构比较复杂，可以使用专门的库来处理，例如：

    • Construct: 一个强大的 Python 库，用于定义和解析二进制数据结构。
    • kaitai struct: 一个跨平台的库，支持多种编程语言，可以根据描述文件生成代码来解析二进制数据。

  3. 交互流程分析：

    分析客户端和服务器之间的消息交互流程，可以帮助我们理解协议的运作方式。

    • 状态机： 可以使用状态机来描述客户端和服务器的状态转换。不同的消息可能会触发不同的状态转换。
    • 时序图： 可以使用时序图来描述消息的发送和接收顺序。

    通过分析交互流程，我们可以更好地理解协议的设计意图。

五、验证与推断：构造消息并观察响应

理论分析之后，我们需要进行实践验证。构造不同的消息，发送给服务器，并观察服务器的响应。

  1. 构造有效消息：

    根据我们对协议的理解，构造一些有效的消息，发送给服务器。观察服务器是否能够正确处理这些消息，并返回预期的响应。

  2. 构造无效消息：

    构造一些无效的消息，例如格式错误的消息、数据类型错误的消息、超出范围的消息等。观察服务器如何处理这些错误，是否会返回错误信息。

  3. 边界测试：

    进行边界测试，例如发送超长消息、发送包含特殊字符的消息等。观察服务器的健壮性。

  4. 观察响应：

    仔细观察服务器的响应，包括响应的状态码、响应头和响应内容。分析响应中的错误信息，可以帮助我们更好地理解协议的细节。

Python 示例：

import websocket
import json

def send_message(ws, message_type, data):
    message = json.dumps({"type": message_type, "data": data})
    ws.send(message)
    result = ws.recv()
    print(f"Received: {result}")

ws = websocket.create_connection("ws://example.com/ws", subprotocols=["my-custom-protocol"])

# 发送有效消息
send_message(ws, "login", {"username": "test", "password": "password"})

# 发送无效消息
send_message(ws, "invalid_message", {"foo": "bar"})

ws.close()

通过构造不同的消息并观察响应，我们可以验证我们对协议的理解，并发现协议中隐藏的细节。

六、案例分析：逆向一个简单的自定义协议

假设我们抓到如下的WebSocket握手信息:

GET /game HTTP/1.1
Host: game.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: ...
Sec-WebSocket-Protocol: game-protocol-v1

并且观察到如下的消息交互：

客户端 -> 服务器:

{"action": "join", "room": "lobby"}

服务器 -> 客户端:

{"event": "user_joined", "user": "Alice"}

客户端 -> 服务器:

{"action": "send_message", "message": "Hello!"}

服务器 -> 客户端:

{"event": "new_message", "user": "You", "message": "Hello!"}

分析：

  1. 子协议： 使用了名为 game-protocol-v1 的自定义子协议。
  2. 消息格式： 使用 JSON 格式。

  3. 交互流程：

    • 客户端发送 join 消息加入房间。
    • 服务器发送 user_joined 消息通知用户加入。
    • 客户端发送 send_message 消息发送消息。
    • 服务器发送 new_message 消息广播新消息。

实现：

我们可以使用 Python 和 websocket-client 库来模拟客户端行为。

import websocket
import json

def on_message(ws, message):
    print(f"Received: {message}")

def on_error(ws, error):
    print(f"Error: {error}")

def on_close(ws, close_status_code, close_msg):
    print("Connection closed")

def on_open(ws):
    print("Connection opened")
    ws.send(json.dumps({"action": "join", "room": "lobby"}))
    ws.send(json.dumps({"action": "send_message", "message": "Hello!"}))

if __name__ == "__main__":
    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("ws://game.example.com/game",
                                subprotocols=["game-protocol-v1"],
                                on_open=on_open,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)

    ws.run_forever()

这个例子展示了如何连接到 WebSocket 服务器，使用自定义子协议，并发送和接收消息。

七、工具辅助：自动化分析与模糊测试

手动分析 WebSocket 子协议需要耗费大量时间和精力。我们可以使用一些工具来辅助分析，提高效率。

  1. WebSocket 模糊测试器：

    模糊测试是一种自动化测试技术，通过向程序输入大量的随机数据，来发现程序中的漏洞和错误。可以使用模糊测试器来测试 WebSocket 服务器的健壮性。

    • wfuzz: 一个强大的 Web 应用模糊测试器，可以用于模糊测试 WebSocket 协议。

  2. 协议分析器：

    一些协议分析器可以自动分析 WebSocket 消息，并提取出关键信息。

    • Wireshark: 可以使用 Wireshark 的过滤器和协议解析器来分析 WebSocket 消息。

  3. 自定义脚本：

    可以编写自定义脚本来自动化分析 WebSocket 消息，例如提取消息类型、数据字段等。

八、总结与建议

WebSocket 子协议逆向是一项充满挑战但也很有趣的任务。通过抓包分析、消息解构、交互流程分析、验证与推断，我们可以逐步理解未知的 WebSocket 子协议。

一些建议：

  • 从小处着手： 先从简单的消息格式入手，逐步分析复杂的协议。
  • 多做实验： 不断尝试、猜测和验证，才能真正理解协议的运作方式。
  • 善用工具： 使用合适的工具可以提高分析效率。
  • 保持耐心： 逆向分析需要耗费时间和精力，保持耐心才能成功。

希望今天的讲解能够帮助大家更好地理解 WebSocket 子协议逆向。记住，代码的世界充满了奥秘，只要我们保持好奇心和探索精神，就能解开一个又一个谜题。

好了，今天的讲座就到这里，谢谢大家！下次有机会再见！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注