使用 Node.js 解析 WebSocket 数据

Question

客户端上的 Websocket：

socket.send('helloworld');

Node.js 上的 Websocket：

socket.ondata = function(d, start, end){
     // I suppose that the start and end indicates the location of the 
     // actual data 'hello world' after the headers
     var data = d.toString('utf8', start, end);
     
     // Then I'm just printing it
     console.log(data);
});

但我在终端上收到： �����]���1��/�� :O

我试图理解该文档： https://www.rfc-editor.org/rfc/rfc6455#section-5.2 但很难理解，因为我不知道应该使用什么，我的意思是我看不到数据即使使用toString？

我尝试遵循并测试这个问题的答案 如何在服务器端发送和接收 WebSocket 消息？ 但我无法让它工作，有了这个答案，我得到了一个像这样的数组 [false, true, false, false, true ， 真的， false] 等等...我真的不知道该怎么办.. :\

所以我有点困惑，从客户端获取数据以获取真实消息后我到底应该做什么？

我使用的是原始客户端和 Node.js API，没有任何库。

Answer 1

事实上，您可以从 Node 的 HTTP API 开始。这正是我在编写 WebSocket-Node 模块时所做的 https://github.com/Worlize/WebSocket- Node

如果您不想使用现有的 WebSocket 库（尽管您确实应该只使用现有的库），那么您需要能够解析 RFC 定义的二进制数据格式。格式以及如何解释数据非常清楚。从每一帧中，您必须读入所有标志，解释帧大小，可能读取屏蔽键，并在从线路读取内容时取消屏蔽内容。

这是您看不到任何可识别内容的原因之一……在 WebSocket 中，通过使用 XOR 对内容应用随机掩码来混淆所有客户端到服务器的通信，作为安全预防措施，防止可能毒害旧代理服务器的缓存不知道网络套接字。

Answer 2

您使用的是哪个 Node.js 库？从您正在挂钩的 socket.ondata 来看，它看起来像 HTTP 服务器 API。 WebSocket 不是 HTTP。它具有 HTTP 兼容的握手，因此 WebSocket 和 HTTP 服务可以驻留在同一端口上，但相似之处仅此而已。握手后，WebSockets 是一种成帧的全双工、长寿命消息传输，与常规 TCP 套接字比 HTTP 更相似。

如果您想在 node.js 中实现自己的 WebSocket 服务器，您将需要直接使用套接字库（或构建/借用现有的 WebSocket 服务器代码）。

这是一个基于 Node.js 的 WebSocket 服务器，它从 WebSocket 桥接到 TCP 套接字： https://github.com/kanaka/websockify/blob/master/other/websockify.js 请注意，这是针对以前的 Hixie 版本的协议（我还没有机会或动力去更新它） 然而）。该协议的现代 HyBI 版本非常不同，但您也许能够从该实现中收集一些有用的信息。

Answer 3

有两件事 -

1. 您使用的是哪个 Node.js 版本？我从未见过带有 start 和 endpt 的数据事件。发出的事件只是以缓冲区/字符串作为参数的数据。

2. 更重要的是，如果您连接到 HTTP 套接字，则应该注意 HTTP 数据包。它包含听众、正文和预告片。那里可能有垃圾。

Answer 4

这是这篇文章的解决方案：

https:// medium.com/hackernoon/implementing-a-websocket-server-with-node-js-d9b78ec5ffa8

parseMessage(buffer) {
    const firstByte = buffer.readUInt8(0);
    //const isFinalFrame = Boolean((firstByte >>> 7) & 0x1); 
    //const [reserved1, reserved2, reserved3] = [ Boolean((firstByte >>> 6) & 0x1), 
    Boolean((firstByte >>> 5) & 0x1), Boolean((firstByte >>> 4) & 0x1) ]; 
    const opCode = firstByte & 0xF; 
    // We can return null to signify that this is a connection termination frame 
    if (opCode === 0x8) 
        return null; 
    // We only care about text frames from this point onward 
    if (opCode !== 0x1) 
        return; 
    const secondByte = buffer.readUInt8(1); 
    const isMasked = Boolean((secondByte >>> 7) & 0x1); 
    // Keep track of our current position as we advance through the buffer 
    let currentOffset = 2; let payloadLength = secondByte & 0x7F; 
    if (payloadLength > 125) { 
        if (payloadLength === 126) { 
            payloadLength = buffer.readUInt16BE(currentOffset); 
            currentOffset += 2; 
        } else { 
            // 127 
            // If this has a value, the frame size is ridiculously huge! 
            //const leftPart = buffer.readUInt32BE(currentOffset); 
            //const rightPart = buffer.readUInt32BE(currentOffset += 4); 
            // Honestly, if the frame length requires 64 bits, you're probably doing it wrong. 
            // In Node.js you'll require the BigInt type, or a special library to handle this. 
            throw new Error('Large payloads not currently implemented'); 
        } 
    }

    const data = Buffer.alloc(payloadLength);
    // Only unmask the data if the masking bit was set to 1
    if (isMasked) {
        let maskingKey = buffer.readUInt32BE(currentOffset);
        currentOffset += 4;

        // Loop through the source buffer one byte at a time, keeping track of which
        // byte in the masking key to use in the next XOR calculation
        for (let i = 0, j = 0; i < payloadLength; ++i, j = i % 4) {
            // Extract the correct byte mask from the masking key
            const shift = j == 3 ? 0 : (3 - j) << 3; 
            
            const mask = (shift == 0 ? maskingKey : (maskingKey >>> shift)) & 0xFF;
            // Read a byte from the source buffer 
            const source = buffer.readUInt8(currentOffset++); 
            // XOR the source byte and write the result to the data 
            data.writeUInt8(mask ^ source, i); 
        }
    } else {
        // Not masked - we can just read the data as-is
        buffer.copy(data, 0, currentOffset++);
    }

    return data 
}