Upgrade DevTools WebSocket server implementation from Hybi10 to Hybi17.

net/server/web_socket.cc

 // Copyright (c) 2011 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/server/web_socket.h"
 
 #include "base/base64.h"
 #include "base/rand_util.h"
 #include "base/logging.h"
 #include "base/md5.h"
@@ skipping 151 matching lines @@
 const unsigned char kReserved3Bit = 0x10;
 const unsigned char kOpCodeMask = 0xF;
 const unsigned char kMaskBit = 0x80;
 const unsigned char kPayloadLengthMask = 0x7F;
 
 const size_t kMaxSingleBytePayloadLength = 125;
 const size_t kTwoBytePayloadLengthField = 126;
 const size_t kEightBytePayloadLengthField = 127;
 const size_t kMaskingKeyWidthInBytes = 4;
 
-class WebSocketHybi10 : public WebSocket {
+class WebSocketHybi17 : public WebSocket {
  public:
   static WebSocket* Create(HttpConnection* connection,
                            const HttpServerRequestInfo& request,
                            size_t* pos) {
     std::string version = request.GetHeaderValue("Sec-WebSocket-Version");
     if (version != "8" && version != "13")
       return NULL;
 
     std::string key = request.GetHeaderValue("Sec-WebSocket-Key");
     if (key.empty()) {
       connection->Send500("Invalid request format. "
               "Sec-WebSocket-Key is empty or isn't specified.");
       return NULL;
     }
-    return new WebSocketHybi10(connection, request, pos);
+    return new WebSocketHybi17(connection, request, pos);
   }
 
   virtual void Accept(const HttpServerRequestInfo& request) {
     static const char* const kWebSocketGuid =
         "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     std::string key = request.GetHeaderValue("Sec-WebSocket-Key");
     std::string data = base::StringPrintf("%s%s", key.c_str(), kWebSocketGuid);
     std::string encoded_hash;
     base::Base64Encode(base::SHA1HashString(data), &encoded_hash);
 
@@ skipping 32 matching lines @@
     case kOpCodeText:
       break;
     case kOpCodeBinary: // We don't support binary frames yet.
     case kOpCodeContinuation: // We don't support binary frames yet.
     case kOpCodePing: // We don't support binary frames yet.
     case kOpCodePong: // We don't support binary frames yet.
     default:
       return FRAME_ERROR;
     }
 
+    if (!masked_) // According to Hybi-17 spec client MUST mask his frame.
+      return FRAME_ERROR;
+
     uint64 payload_length64 = second_byte & kPayloadLengthMask;
     if (payload_length64 > kMaxSingleBytePayloadLength) {
       int extended_payload_length_size;
       if (payload_length64 == kTwoBytePayloadLengthField)
         extended_payload_length_size = 2;
       else {
         DCHECK(payload_length64 == kEightBytePayloadLengthField);
         extended_payload_length_size = 8;
       }
       if (buffer_end - p < extended_payload_length_size)
         return FRAME_INCOMPLETE;
       payload_length64 = 0;
       for (int i = 0; i < extended_payload_length_size; ++i) {
         payload_length64 <<= 8;
         payload_length64 |= static_cast<unsigned char>(*p++);
       }
     }
 
     static const uint64 max_payload_length = 0x7FFFFFFFFFFFFFFFull;
-    size_t masking_key_length = masked_ ? kMaskingKeyWidthInBytes : 0;
     static size_t max_length = std::numeric_limits<size_t>::max();
     if (payload_length64 > max_payload_length ||
-        payload_length64 + masking_key_length > max_length) {
+        payload_length64 + kMaskingKeyWidthInBytes > max_length) {
       // WebSocket frame length too large.
       return FRAME_ERROR;
     }
     payload_length_ = static_cast<size_t>(payload_length64);
 
-    size_t total_length = masking_key_length + payload_length_;
+    size_t total_length = kMaskingKeyWidthInBytes + payload_length_;
     if (static_cast<size_t>(buffer_end - p) < total_length)
       return FRAME_INCOMPLETE;
 
     if (masked_) {
       message->resize(payload_length_);
       const char* masking_key = p;
       char* payload = const_cast<char*>(p + kMaskingKeyWidthInBytes);
       for (size_t i = 0; i < payload_length_; ++i)  // Unmask the payload.
         (*message)[i] = payload[i] ^ masking_key[i % kMaskingKeyWidthInBytes];
     } else {
       std::string buffer(p, p + payload_length_);
       message->swap(buffer);
     }
 
-    size_t pos = p + masking_key_length + payload_length_ -
+    size_t pos = p + kMaskingKeyWidthInBytes + payload_length_ -
         connection_->recv_data().c_str();
     connection_->Shift(pos);
 
     return closed_ ? FRAME_CLOSE : FRAME_OK;
   }
 
   virtual void Send(const std::string& message) {
     if (closed_)
       return;
 
     std::vector<char> frame;
     OpCode op_code = kOpCodeText;
     size_t data_length = message.length();
 
     frame.push_back(kFinalBit | op_code);
     if (data_length <= kMaxSingleBytePayloadLength)
-      frame.push_back(kMaskBit | data_length);
+      frame.push_back(data_length);
     else if (data_length <= 0xFFFF) {
-      frame.push_back(kMaskBit | kTwoBytePayloadLengthField);
+      frame.push_back(kTwoBytePayloadLengthField);
       frame.push_back((data_length & 0xFF00) >> 8);
       frame.push_back(data_length & 0xFF);
     } else {
-      frame.push_back(kMaskBit | kEightBytePayloadLengthField);
+      frame.push_back(kEightBytePayloadLengthField);
       char extended_payload_length[8];
       size_t remaining = data_length;
       // Fill the length into extended_payload_length in the network byte order.
       for (int i = 0; i < 8; ++i) {
         extended_payload_length[7 - i] = remaining & 0xFF;
         remaining >>= 8;
       }
       frame.insert(frame.end(),
                    extended_payload_length,
                    extended_payload_length + 8);
       DCHECK(!remaining);
     }
 
-    // Mask the frame.
-    size_t masking_key_start = frame.size();
-    // Add placeholder for masking key. Will be overwritten.
-    frame.resize(frame.size() + kMaskingKeyWidthInBytes);
-    size_t payload_start = frame.size();
     const char* data = message.c_str();
     frame.insert(frame.end(), data, data + data_length);
 
-    base::RandBytes(&frame[0] + masking_key_start,
-                    kMaskingKeyWidthInBytes);
-    for (size_t i = 0; i < data_length; ++i) {
-      frame[payload_start + i] ^=
-          frame[masking_key_start + i % kMaskingKeyWidthInBytes];
-    }
     connection_->Send(&frame[0], frame.size());
   }
 
  private:
-  WebSocketHybi10(HttpConnection* connection,
+  WebSocketHybi17(HttpConnection* connection,
                   const HttpServerRequestInfo& request,
                   size_t* pos)
     : WebSocket(connection),
       op_code_(0),
       final_(false),
       reserved1_(false),
       reserved2_(false),
       reserved3_(false),
       masked_(false),
       payload_(0),
       payload_length_(0),
       frame_end_(0),
       closed_(false) {
   }
 
   OpCode op_code_;
   bool final_;
   bool reserved1_;
   bool reserved2_;
   bool reserved3_;
   bool masked_;
   const char* payload_;
   size_t payload_length_;
   const char* frame_end_;
   bool closed_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebSocketHybi10);
+  DISALLOW_COPY_AND_ASSIGN(WebSocketHybi17);
 };
 
 }  // anonymous namespace
 
 WebSocket* WebSocket::CreateWebSocket(HttpConnection* connection,
                                       const HttpServerRequestInfo& request,
                                       size_t* pos) {
-  WebSocket* socket = WebSocketHybi10::Create(connection, request, pos);
+  WebSocket* socket = WebSocketHybi17::Create(connection, request, pos);
   if (socket)
     return socket;
 
   return WebSocketHixie76::Create(connection, request, pos);
 }
 
 WebSocket::WebSocket(HttpConnection* connection) : connection_(connection) {
 }
 
 }  // namespace net