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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/websockets/websocket_frame.h"
#include <algorithm>
#include "base/basictypes.h"
#include "base/logging.h"
#include "base/rand_util.h"
#include "net/base/big_endian.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
namespace {
const uint8 kFinalBit = 0x80;
const uint8 kReserved1Bit = 0x40;
const uint8 kReserved2Bit = 0x20;
const uint8 kReserved3Bit = 0x10;
const uint8 kOpCodeMask = 0xF;
const uint8 kMaskBit = 0x80;
const uint64 kMaxPayloadLengthWithoutExtendedLengthField = 125;
const uint64 kPayloadLengthWithTwoByteExtendedLengthField = 126;
const uint64 kPayloadLengthWithEightByteExtendedLengthField = 127;
inline void MaskWebSocketFramePayloadByBytes(
const net::WebSocketMaskingKey& masking_key,
size_t masking_key_offset,
char* const begin,
char* const end) {
for (char* masked = begin; masked != end; ++masked) {
*masked ^= masking_key.key[masking_key_offset++];
if (masking_key_offset == net::WebSocketFrameHeader::kMaskingKeyLength)
masking_key_offset = 0;
}
}
} // Unnamed namespace.
namespace net {
scoped_ptr<WebSocketFrameHeader> WebSocketFrameHeader::Clone() {
scoped_ptr<WebSocketFrameHeader> ret(new WebSocketFrameHeader(opcode));
ret->final = final;
ret->reserved1 = reserved1;
ret->reserved2 = reserved2;
ret->reserved3 = reserved3;
ret->opcode = opcode;
ret->masked = masked;
ret->payload_length = payload_length;
return ret.Pass();
}
WebSocketFrameChunk::WebSocketFrameChunk() : final_chunk(false) {}
WebSocketFrameChunk::~WebSocketFrameChunk() {}
int GetWebSocketFrameHeaderSize(const WebSocketFrameHeader& header) {
int extended_length_size = 0;
if (header.payload_length > kMaxPayloadLengthWithoutExtendedLengthField &&
header.payload_length <= kuint16max) {
extended_length_size = 2;
} else if (header.payload_length > kuint16max) {
extended_length_size = 8;
}
return (WebSocketFrameHeader::kBaseHeaderSize + extended_length_size +
(header.masked ? WebSocketFrameHeader::kMaskingKeyLength : 0));
}
int WriteWebSocketFrameHeader(const WebSocketFrameHeader& header,
const WebSocketMaskingKey* masking_key,
char* buffer,
int buffer_size) {
DCHECK((header.opcode & kOpCodeMask) == header.opcode)
<< "header.opcode must fit to kOpCodeMask.";
DCHECK(header.payload_length <= static_cast<uint64>(kint64max))
<< "WebSocket specification doesn't allow a frame longer than "
<< "kint64max (0x7FFFFFFFFFFFFFFF) bytes.";
DCHECK_GE(buffer_size, 0);
// WebSocket frame format is as follows:
// - Common header (2 bytes)
// - Optional extended payload length
// (2 or 8 bytes, present if actual payload length is more than 125 bytes)
// - Optional masking key (4 bytes, present if MASK bit is on)
// - Actual payload (XOR masked with masking key if MASK bit is on)
//
// This function constructs frame header (the first three in the list
// above).
int header_size = GetWebSocketFrameHeaderSize(header);
if (header_size > buffer_size)
return ERR_INVALID_ARGUMENT;
int buffer_index = 0;
uint8 first_byte = 0u;
first_byte |= header.final ? kFinalBit : 0u;
first_byte |= header.reserved1 ? kReserved1Bit : 0u;
first_byte |= header.reserved2 ? kReserved2Bit : 0u;
first_byte |= header.reserved3 ? kReserved3Bit : 0u;
first_byte |= header.opcode & kOpCodeMask;
buffer[buffer_index++] = first_byte;
int extended_length_size = 0;
uint8 second_byte = 0u;
second_byte |= header.masked ? kMaskBit : 0u;
if (header.payload_length <= kMaxPayloadLengthWithoutExtendedLengthField) {
second_byte |= header.payload_length;
} else if (header.payload_length <= kuint16max) {
second_byte |= kPayloadLengthWithTwoByteExtendedLengthField;
extended_length_size = 2;
} else {
second_byte |= kPayloadLengthWithEightByteExtendedLengthField;
extended_length_size = 8;
}
buffer[buffer_index++] = second_byte;
// Writes "extended payload length" field.
if (extended_length_size == 2) {
uint16 payload_length_16 = static_cast<uint16>(header.payload_length);
WriteBigEndian(buffer + buffer_index, payload_length_16);
buffer_index += sizeof(payload_length_16);
} else if (extended_length_size == 8) {
WriteBigEndian(buffer + buffer_index, header.payload_length);
buffer_index += sizeof(header.payload_length);
}
// Writes "masking key" field, if needed.
if (header.masked) {
DCHECK(masking_key);
std::copy(masking_key->key,
masking_key->key + WebSocketFrameHeader::kMaskingKeyLength,
buffer + buffer_index);
buffer_index += WebSocketFrameHeader::kMaskingKeyLength;
} else {
DCHECK(!masking_key);
}
DCHECK_EQ(header_size, buffer_index);
return header_size;
}
WebSocketMaskingKey GenerateWebSocketMaskingKey() {
// Masking keys should be generated from a cryptographically secure random
// number generator, which means web application authors should not be able
// to guess the next value of masking key.
WebSocketMaskingKey masking_key;
base::RandBytes(masking_key.key, WebSocketFrameHeader::kMaskingKeyLength);
return masking_key;
}
void MaskWebSocketFramePayload(const WebSocketMaskingKey& masking_key,
uint64 frame_offset,
char* const data,
int data_size) {
static const size_t kMaskingKeyLength =
WebSocketFrameHeader::kMaskingKeyLength;
DCHECK_GE(data_size, 0);
// Most of the masking is done one word at a time, except for the beginning
// and the end of the buffer which may be unaligned. We use size_t to get the
// word size for this architecture. We require it be a multiple of
// kMaskingKeyLength in size.
typedef size_t PackedMaskType;
PackedMaskType packed_mask_key = 0;
static const size_t kPackedMaskKeySize = sizeof(packed_mask_key);
COMPILE_ASSERT((kPackedMaskKeySize >= kMaskingKeyLength &&
kPackedMaskKeySize % kMaskingKeyLength == 0),
word_size_is_not_multiple_of_mask_length);
char* const end = data + data_size;
// If the buffer is too small for the vectorised version to be useful, revert
// to the byte-at-a-time implementation early.
if (data_size <= static_cast<int>(kPackedMaskKeySize * 2)) {
MaskWebSocketFramePayloadByBytes(
masking_key, frame_offset % kMaskingKeyLength, data, end);
return;
}
const size_t data_modulus =
reinterpret_cast<size_t>(data) % kPackedMaskKeySize;
char* const aligned_begin =
data_modulus == 0 ? data : (data + kPackedMaskKeySize - data_modulus);
// Guaranteed by the above check for small data_size.
DCHECK(aligned_begin < end);
MaskWebSocketFramePayloadByBytes(
masking_key, frame_offset % kMaskingKeyLength, data, aligned_begin);
const size_t end_modulus = reinterpret_cast<size_t>(end) % kPackedMaskKeySize;
char* const aligned_end = end - end_modulus;
// Guaranteed by the above check for small data_size.
DCHECK(aligned_end > aligned_begin);
// Create a version of the mask which is rotated by the appropriate offset
// for our alignment. The "trick" here is that 0 XORed with the mask will
// give the value of the mask for the appropriate byte.
char realigned_mask[kMaskingKeyLength] = { 0 };
MaskWebSocketFramePayloadByBytes(
masking_key,
(frame_offset + aligned_begin - data) % kMaskingKeyLength,
realigned_mask,
realigned_mask + kMaskingKeyLength);
for (size_t i = 0; i < kPackedMaskKeySize; i += kMaskingKeyLength) {
// memcpy() is allegedly blessed by the C++ standard for type-punning.
memcpy(reinterpret_cast<char*>(&packed_mask_key) + i,
realigned_mask,
kMaskingKeyLength);
}
// The main loop.
for (char* merged = aligned_begin; merged != aligned_end;
merged += kPackedMaskKeySize) {
// This is not quite standard-compliant C++. However, the standard-compliant
// equivalent (using memcpy()) compiles to slower code using g++. In
// practice, this will work for the compilers and architectures currently
// supported by Chromium, and the tests are extremely unlikely to pass if a
// future compiler/architecture breaks it.
*reinterpret_cast<PackedMaskType*>(merged) ^= packed_mask_key;
}
MaskWebSocketFramePayloadByBytes(
masking_key,
(frame_offset + (aligned_end - data)) % kMaskingKeyLength,
aligned_end,
end);
}
} // namespace net
|
