Home | History | Annotate | Download | only in websockets 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/websockets/websocket_handshake_handler.h"
      6 
      7 #include <limits>
      8 
      9 #include "base/base64.h"
     10 #include "base/sha1.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/string_piece.h"
     13 #include "base/strings/string_tokenizer.h"
     14 #include "base/strings/string_util.h"
     15 #include "base/strings/stringprintf.h"
     16 #include "net/http/http_request_headers.h"
     17 #include "net/http/http_response_headers.h"
     18 #include "net/http/http_util.h"
     19 #include "net/websockets/websocket_handshake_constants.h"
     20 #include "url/gurl.h"
     21 
     22 namespace net {
     23 namespace {
     24 
     25 const int kVersionHeaderValueForRFC6455 = 13;
     26 
     27 // Splits |handshake_message| into Status-Line or Request-Line (including CRLF)
     28 // and headers (excluding 2nd CRLF of double CRLFs at the end of a handshake
     29 // response).
     30 void ParseHandshakeHeader(
     31     const char* handshake_message, int len,
     32     std::string* request_line,
     33     std::string* headers) {
     34   size_t i = base::StringPiece(handshake_message, len).find_first_of("\r\n");
     35   if (i == base::StringPiece::npos) {
     36     *request_line = std::string(handshake_message, len);
     37     *headers = "";
     38     return;
     39   }
     40   // |request_line| includes \r\n.
     41   *request_line = std::string(handshake_message, i + 2);
     42 
     43   int header_len = len - (i + 2) - 2;
     44   if (header_len > 0) {
     45     // |handshake_message| includes trailing \r\n\r\n.
     46     // |headers| doesn't include 2nd \r\n.
     47     *headers = std::string(handshake_message + i + 2, header_len);
     48   } else {
     49     *headers = "";
     50   }
     51 }
     52 
     53 void FetchHeaders(const std::string& headers,
     54                   const char* const headers_to_get[],
     55                   size_t headers_to_get_len,
     56                   std::vector<std::string>* values) {
     57   net::HttpUtil::HeadersIterator iter(headers.begin(), headers.end(), "\r\n");
     58   while (iter.GetNext()) {
     59     for (size_t i = 0; i < headers_to_get_len; i++) {
     60       if (LowerCaseEqualsASCII(iter.name_begin(), iter.name_end(),
     61                                headers_to_get[i])) {
     62         values->push_back(iter.values());
     63       }
     64     }
     65   }
     66 }
     67 
     68 bool GetHeaderName(std::string::const_iterator line_begin,
     69                    std::string::const_iterator line_end,
     70                    std::string::const_iterator* name_begin,
     71                    std::string::const_iterator* name_end) {
     72   std::string::const_iterator colon = std::find(line_begin, line_end, ':');
     73   if (colon == line_end) {
     74     return false;
     75   }
     76   *name_begin = line_begin;
     77   *name_end = colon;
     78   if (*name_begin == *name_end || net::HttpUtil::IsLWS(**name_begin))
     79     return false;
     80   net::HttpUtil::TrimLWS(name_begin, name_end);
     81   return true;
     82 }
     83 
     84 // Similar to HttpUtil::StripHeaders, but it preserves malformed headers, that
     85 // is, lines that are not formatted as "<name>: <value>\r\n".
     86 std::string FilterHeaders(
     87     const std::string& headers,
     88     const char* const headers_to_remove[],
     89     size_t headers_to_remove_len) {
     90   std::string filtered_headers;
     91 
     92   base::StringTokenizer lines(headers.begin(), headers.end(), "\r\n");
     93   while (lines.GetNext()) {
     94     std::string::const_iterator line_begin = lines.token_begin();
     95     std::string::const_iterator line_end = lines.token_end();
     96     std::string::const_iterator name_begin;
     97     std::string::const_iterator name_end;
     98     bool should_remove = false;
     99     if (GetHeaderName(line_begin, line_end, &name_begin, &name_end)) {
    100       for (size_t i = 0; i < headers_to_remove_len; ++i) {
    101         if (LowerCaseEqualsASCII(name_begin, name_end, headers_to_remove[i])) {
    102           should_remove = true;
    103           break;
    104         }
    105       }
    106     }
    107     if (!should_remove) {
    108       filtered_headers.append(line_begin, line_end);
    109       filtered_headers.append("\r\n");
    110     }
    111   }
    112   return filtered_headers;
    113 }
    114 
    115 bool CheckVersionInRequest(const std::string& request_headers) {
    116   std::vector<std::string> values;
    117   const char* const headers_to_get[1] = {
    118     websockets::kSecWebSocketVersionLowercase};
    119   FetchHeaders(request_headers, headers_to_get, 1, &values);
    120   DCHECK_LE(values.size(), 1U);
    121   if (values.empty())
    122     return false;
    123 
    124   int version;
    125   bool conversion_success = base::StringToInt(values[0], &version);
    126   if (!conversion_success)
    127     return false;
    128 
    129   return version == kVersionHeaderValueForRFC6455;
    130 }
    131 
    132 // Append a header to a string. Equivalent to
    133 //   response_message += header + ": " + value + "\r\n"
    134 // but avoids unnecessary allocations and copies.
    135 void AppendHeader(const base::StringPiece& header,
    136                   const base::StringPiece& value,
    137                   std::string* response_message) {
    138   static const char kColonSpace[] = ": ";
    139   const size_t kColonSpaceSize = sizeof(kColonSpace) - 1;
    140   static const char kCrNl[] = "\r\n";
    141   const size_t kCrNlSize = sizeof(kCrNl) - 1;
    142 
    143   size_t extra_size =
    144       header.size() + kColonSpaceSize + value.size() + kCrNlSize;
    145   response_message->reserve(response_message->size() + extra_size);
    146   response_message->append(header.begin(), header.end());
    147   response_message->append(kColonSpace, kColonSpace + kColonSpaceSize);
    148   response_message->append(value.begin(), value.end());
    149   response_message->append(kCrNl, kCrNl + kCrNlSize);
    150 }
    151 
    152 }  // namespace
    153 
    154 WebSocketHandshakeRequestHandler::WebSocketHandshakeRequestHandler()
    155     : original_length_(0),
    156       raw_length_(0) {}
    157 
    158 bool WebSocketHandshakeRequestHandler::ParseRequest(
    159     const char* data, int length) {
    160   DCHECK_GT(length, 0);
    161   std::string input(data, length);
    162   int input_header_length =
    163       HttpUtil::LocateEndOfHeaders(input.data(), input.size(), 0);
    164   if (input_header_length <= 0)
    165     return false;
    166 
    167   ParseHandshakeHeader(input.data(),
    168                        input_header_length,
    169                        &request_line_,
    170                        &headers_);
    171 
    172   if (!CheckVersionInRequest(headers_)) {
    173     NOTREACHED();
    174     return false;
    175   }
    176 
    177   original_length_ = input_header_length;
    178   return true;
    179 }
    180 
    181 size_t WebSocketHandshakeRequestHandler::original_length() const {
    182   return original_length_;
    183 }
    184 
    185 void WebSocketHandshakeRequestHandler::AppendHeaderIfMissing(
    186     const std::string& name, const std::string& value) {
    187   DCHECK(!headers_.empty());
    188   HttpUtil::AppendHeaderIfMissing(name.c_str(), value, &headers_);
    189 }
    190 
    191 void WebSocketHandshakeRequestHandler::RemoveHeaders(
    192     const char* const headers_to_remove[],
    193     size_t headers_to_remove_len) {
    194   DCHECK(!headers_.empty());
    195   headers_ = FilterHeaders(
    196       headers_, headers_to_remove, headers_to_remove_len);
    197 }
    198 
    199 HttpRequestInfo WebSocketHandshakeRequestHandler::GetRequestInfo(
    200     const GURL& url, std::string* challenge) {
    201   HttpRequestInfo request_info;
    202   request_info.url = url;
    203   size_t method_end = base::StringPiece(request_line_).find_first_of(" ");
    204   if (method_end != base::StringPiece::npos)
    205     request_info.method = std::string(request_line_.data(), method_end);
    206 
    207   request_info.extra_headers.Clear();
    208   request_info.extra_headers.AddHeadersFromString(headers_);
    209 
    210   request_info.extra_headers.RemoveHeader(websockets::kUpgrade);
    211   request_info.extra_headers.RemoveHeader(HttpRequestHeaders::kConnection);
    212 
    213   std::string key;
    214   bool header_present = request_info.extra_headers.GetHeader(
    215       websockets::kSecWebSocketKey, &key);
    216   DCHECK(header_present);
    217   request_info.extra_headers.RemoveHeader(websockets::kSecWebSocketKey);
    218   *challenge = key;
    219   return request_info;
    220 }
    221 
    222 bool WebSocketHandshakeRequestHandler::GetRequestHeaderBlock(
    223     const GURL& url,
    224     SpdyHeaderBlock* headers,
    225     std::string* challenge,
    226     int spdy_protocol_version) {
    227   // Construct opening handshake request headers as a SPDY header block.
    228   // For details, see WebSocket Layering over SPDY/3 Draft 8.
    229   if (spdy_protocol_version <= 2) {
    230     (*headers)["path"] = url.path();
    231     (*headers)["version"] = "WebSocket/13";
    232     (*headers)["scheme"] = url.scheme();
    233   } else {
    234     (*headers)[":path"] = url.path();
    235     (*headers)[":version"] = "WebSocket/13";
    236     (*headers)[":scheme"] = url.scheme();
    237   }
    238 
    239   HttpUtil::HeadersIterator iter(headers_.begin(), headers_.end(), "\r\n");
    240   while (iter.GetNext()) {
    241     if (LowerCaseEqualsASCII(iter.name_begin(),
    242                              iter.name_end(),
    243                              websockets::kUpgradeLowercase) ||
    244         LowerCaseEqualsASCII(
    245             iter.name_begin(), iter.name_end(), "connection") ||
    246         LowerCaseEqualsASCII(iter.name_begin(),
    247                              iter.name_end(),
    248                              websockets::kSecWebSocketVersionLowercase)) {
    249       // These headers must be ignored.
    250       continue;
    251     } else if (LowerCaseEqualsASCII(iter.name_begin(),
    252                                     iter.name_end(),
    253                                     websockets::kSecWebSocketKeyLowercase)) {
    254       *challenge = iter.values();
    255       // Sec-WebSocket-Key is not sent to the server.
    256       continue;
    257     } else if (LowerCaseEqualsASCII(
    258                    iter.name_begin(), iter.name_end(), "host") ||
    259                LowerCaseEqualsASCII(
    260                    iter.name_begin(), iter.name_end(), "origin") ||
    261                LowerCaseEqualsASCII(
    262                    iter.name_begin(),
    263                    iter.name_end(),
    264                    websockets::kSecWebSocketProtocolLowercase) ||
    265                LowerCaseEqualsASCII(
    266                    iter.name_begin(),
    267                    iter.name_end(),
    268                    websockets::kSecWebSocketExtensionsLowercase)) {
    269       // TODO(toyoshim): Some WebSocket extensions may not be compatible with
    270       // SPDY. We should omit them from a Sec-WebSocket-Extension header.
    271       std::string name;
    272       if (spdy_protocol_version <= 2)
    273         name = StringToLowerASCII(iter.name());
    274       else
    275         name = ":" + StringToLowerASCII(iter.name());
    276       (*headers)[name] = iter.values();
    277       continue;
    278     }
    279     // Others should be sent out to |headers|.
    280     std::string name = StringToLowerASCII(iter.name());
    281     SpdyHeaderBlock::iterator found = headers->find(name);
    282     if (found == headers->end()) {
    283       (*headers)[name] = iter.values();
    284     } else {
    285       // For now, websocket doesn't use multiple headers, but follows to http.
    286       found->second.append(1, '\0');  // +=() doesn't append 0's
    287       found->second.append(iter.values());
    288     }
    289   }
    290 
    291   return true;
    292 }
    293 
    294 std::string WebSocketHandshakeRequestHandler::GetRawRequest() {
    295   DCHECK(!request_line_.empty());
    296   DCHECK(!headers_.empty());
    297 
    298   std::string raw_request = request_line_ + headers_ + "\r\n";
    299   raw_length_ = raw_request.size();
    300   return raw_request;
    301 }
    302 
    303 size_t WebSocketHandshakeRequestHandler::raw_length() const {
    304   DCHECK_GT(raw_length_, 0);
    305   return raw_length_;
    306 }
    307 
    308 WebSocketHandshakeResponseHandler::WebSocketHandshakeResponseHandler()
    309     : original_header_length_(0) {}
    310 
    311 WebSocketHandshakeResponseHandler::~WebSocketHandshakeResponseHandler() {}
    312 
    313 size_t WebSocketHandshakeResponseHandler::ParseRawResponse(
    314     const char* data, int length) {
    315   DCHECK_GT(length, 0);
    316   if (HasResponse()) {
    317     DCHECK(!status_line_.empty());
    318     // headers_ might be empty for wrong response from server.
    319 
    320     return 0;
    321   }
    322 
    323   size_t old_original_length = original_.size();
    324 
    325   original_.append(data, length);
    326   // TODO(ukai): fail fast when response gives wrong status code.
    327   original_header_length_ = HttpUtil::LocateEndOfHeaders(
    328       original_.data(), original_.size(), 0);
    329   if (!HasResponse())
    330     return length;
    331 
    332   ParseHandshakeHeader(original_.data(),
    333                        original_header_length_,
    334                        &status_line_,
    335                        &headers_);
    336   int header_size = status_line_.size() + headers_.size();
    337   DCHECK_GE(original_header_length_, header_size);
    338   header_separator_ = std::string(original_.data() + header_size,
    339                                   original_header_length_ - header_size);
    340   return original_header_length_ - old_original_length;
    341 }
    342 
    343 bool WebSocketHandshakeResponseHandler::HasResponse() const {
    344   return original_header_length_ > 0 &&
    345       static_cast<size_t>(original_header_length_) <= original_.size();
    346 }
    347 
    348 void ComputeSecWebSocketAccept(const std::string& key,
    349                                std::string* accept) {
    350   DCHECK(accept);
    351 
    352   std::string hash =
    353       base::SHA1HashString(key + websockets::kWebSocketGuid);
    354   base::Base64Encode(hash, accept);
    355 }
    356 
    357 bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
    358     const HttpResponseInfo& response_info,
    359     const std::string& challenge) {
    360   if (!response_info.headers.get())
    361     return false;
    362 
    363   // TODO(ricea): Eliminate all the reallocations and string copies.
    364   std::string response_message;
    365   response_message = response_info.headers->GetStatusLine();
    366   response_message += "\r\n";
    367 
    368   AppendHeader(websockets::kUpgrade,
    369                websockets::kWebSocketLowercase,
    370                &response_message);
    371 
    372   AppendHeader(
    373       HttpRequestHeaders::kConnection, websockets::kUpgrade, &response_message);
    374 
    375   std::string websocket_accept;
    376   ComputeSecWebSocketAccept(challenge, &websocket_accept);
    377   AppendHeader(
    378       websockets::kSecWebSocketAccept, websocket_accept, &response_message);
    379 
    380   void* iter = NULL;
    381   std::string name;
    382   std::string value;
    383   while (response_info.headers->EnumerateHeaderLines(&iter, &name, &value)) {
    384     AppendHeader(name, value, &response_message);
    385   }
    386   response_message += "\r\n";
    387 
    388   return ParseRawResponse(response_message.data(),
    389                           response_message.size()) == response_message.size();
    390 }
    391 
    392 bool WebSocketHandshakeResponseHandler::ParseResponseHeaderBlock(
    393     const SpdyHeaderBlock& headers,
    394     const std::string& challenge,
    395     int spdy_protocol_version) {
    396   SpdyHeaderBlock::const_iterator status;
    397   if (spdy_protocol_version <= 2)
    398     status = headers.find("status");
    399   else
    400     status = headers.find(":status");
    401   if (status == headers.end())
    402     return false;
    403 
    404   std::string hash =
    405       base::SHA1HashString(challenge + websockets::kWebSocketGuid);
    406   std::string websocket_accept;
    407   base::Base64Encode(hash, &websocket_accept);
    408 
    409   std::string response_message = base::StringPrintf(
    410       "%s %s\r\n", websockets::kHttpProtocolVersion, status->second.c_str());
    411 
    412   AppendHeader(
    413       websockets::kUpgrade, websockets::kWebSocketLowercase, &response_message);
    414   AppendHeader(
    415       HttpRequestHeaders::kConnection, websockets::kUpgrade, &response_message);
    416   AppendHeader(
    417       websockets::kSecWebSocketAccept, websocket_accept, &response_message);
    418 
    419   for (SpdyHeaderBlock::const_iterator iter = headers.begin();
    420        iter != headers.end();
    421        ++iter) {
    422     // For each value, if the server sends a NUL-separated list of values,
    423     // we separate that back out into individual headers for each value
    424     // in the list.
    425     if ((spdy_protocol_version <= 2 &&
    426          LowerCaseEqualsASCII(iter->first, "status")) ||
    427         (spdy_protocol_version >= 3 &&
    428          LowerCaseEqualsASCII(iter->first, ":status"))) {
    429       // The status value is already handled as the first line of
    430       // |response_message|. Just skip here.
    431       continue;
    432     }
    433     const std::string& value = iter->second;
    434     size_t start = 0;
    435     size_t end = 0;
    436     do {
    437       end = value.find('\0', start);
    438       std::string tval;
    439       if (end != std::string::npos)
    440         tval = value.substr(start, (end - start));
    441       else
    442         tval = value.substr(start);
    443       if (spdy_protocol_version >= 3 &&
    444           (LowerCaseEqualsASCII(iter->first,
    445                                 websockets::kSecWebSocketProtocolSpdy3) ||
    446            LowerCaseEqualsASCII(iter->first,
    447                                 websockets::kSecWebSocketExtensionsSpdy3)))
    448         AppendHeader(iter->first.substr(1), tval, &response_message);
    449       else
    450         AppendHeader(iter->first, tval, &response_message);
    451       start = end + 1;
    452     } while (end != std::string::npos);
    453   }
    454   response_message += "\r\n";
    455 
    456   return ParseRawResponse(response_message.data(),
    457                           response_message.size()) == response_message.size();
    458 }
    459 
    460 void WebSocketHandshakeResponseHandler::GetHeaders(
    461     const char* const headers_to_get[],
    462     size_t headers_to_get_len,
    463     std::vector<std::string>* values) {
    464   DCHECK(HasResponse());
    465   DCHECK(!status_line_.empty());
    466   // headers_ might be empty for wrong response from server.
    467   if (headers_.empty())
    468     return;
    469 
    470   FetchHeaders(headers_, headers_to_get, headers_to_get_len, values);
    471 }
    472 
    473 void WebSocketHandshakeResponseHandler::RemoveHeaders(
    474     const char* const headers_to_remove[],
    475     size_t headers_to_remove_len) {
    476   DCHECK(HasResponse());
    477   DCHECK(!status_line_.empty());
    478   // headers_ might be empty for wrong response from server.
    479   if (headers_.empty())
    480     return;
    481 
    482   headers_ = FilterHeaders(headers_, headers_to_remove, headers_to_remove_len);
    483 }
    484 
    485 std::string WebSocketHandshakeResponseHandler::GetRawResponse() const {
    486   DCHECK(HasResponse());
    487   return original_.substr(0, original_header_length_);
    488 }
    489 
    490 std::string WebSocketHandshakeResponseHandler::GetResponse() {
    491   DCHECK(HasResponse());
    492   DCHECK(!status_line_.empty());
    493   // headers_ might be empty for wrong response from server.
    494 
    495   return status_line_ + headers_ + header_separator_;
    496 }
    497 
    498 }  // namespace net
    499