SSLTCP (pseudo-SSL with fake handshake and unencrypted data) support for p2p socket.

content/browser/renderer_host/p2p/socket_host_tcp.cc

 // 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 "content/browser/renderer_host/p2p/socket_host_tcp.h"
 
 #include "base/sys_byteorder.h"
+#include "content/browser/renderer_host/p2p/ssltcp_helper.h"
 #include "content/common/p2p_messages.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace {
 
 typedef uint16 PacketLength;
 const int kPacketHeaderSize = sizeof(PacketLength);
 const int kReadBufferSize = 4096;
 const int kPacketLengthOffset = 2;
 const int kTurnChannelDataHeaderSize = 4;
-
 }  // namespace
 
 namespace content {
 
 P2PSocketHostTcpBase::P2PSocketHostTcpBase(IPC::Sender* message_sender,
-                                           int id)
+                                           int id, bool ssl)

[Sergey Ulanov, 2013/06/18 20:01:26]

nit: one argument per line please.

     : P2PSocketHost(message_sender, id),
       write_pending_(false),
       connected_(false) {
+  if (ssl) {
+    ssltcp_helper_.reset(new SsltcpHelper());
+  }
 }
 
 P2PSocketHostTcpBase::~P2PSocketHostTcpBase() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 bool P2PSocketHostTcpBase::InitAccepted(const net::IPEndPoint& remote_address,
                                         net::StreamSocket* socket) {
   DCHECK(socket);
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
+  if (ssltcp_helper_.get()) {

[Sergey Ulanov, 2013/06/18 20:01:26]

nit: don't need .get() here and in Init().

+    // Init ssltcp helper to server mode.

[Sergey Ulanov, 2013/06/18 20:01:26]

You wouldn't need this comment if you used an enum instead of bool:
  ssltcp_helper_->Init(SssltcpHelper::SERVER);

+    ssltcp_helper_->Init(false);
+  }
   remote_address_ = remote_address;
   socket_.reset(socket);
   state_ = STATE_OPEN;
   DoRead();
   return state_ != STATE_ERROR;
 }
 
 bool P2PSocketHostTcpBase::Init(const net::IPEndPoint& local_address,
-                            const net::IPEndPoint& remote_address) {
+                                const net::IPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
+  if (ssltcp_helper_.get()) {
+    // Init ssltcp helper to client mode.
+    ssltcp_helper_->Init(true);
+  }
   remote_address_ = remote_address;
   state_ = STATE_CONNECTING;
   scoped_ptr<net::TCPClientSocket> tcp_socket(new net::TCPClientSocket(
       net::AddressList(remote_address),
       NULL, net::NetLog::Source()));
   if (tcp_socket->Bind(local_address) != net::OK) {
     OnError();
     return false;
   }
   socket_.reset(tcp_socket.release());
@@ skipping 11 matching lines @@
   socket_.reset();
 
   if (state_ == STATE_UNINITIALIZED || state_ == STATE_CONNECTING ||
       state_ == STATE_OPEN) {
     message_sender_->Send(new P2PMsg_OnError(id_));
   }
 
   state_ = STATE_ERROR;
 }
 
+int P2PSocketHostTcpBase::MaybeHandleSslHello(char** cur, int* cur_len,
+                                              int* consumed) {
+  if (static_cast<size_t>(*cur_len) <
+      ssltcp_helper_->remote_hello_message_size()) {
+    return 0;
+  }
+  if (!ssltcp_helper_->IsHelloMessage(*cur)) {
+    LOG(ERROR) << "Expect a SSL HELLO message.";
+    OnError();
+    return 0;
+  }
+  *cur_len -= ssltcp_helper_->remote_hello_message_size();
+  *consumed += ssltcp_helper_->remote_hello_message_size();
+  *cur += ssltcp_helper_->remote_hello_message_size();
+  ssltcp_helper_->set_hello_received(true);
+
+  if (!ssltcp_helper_->IsClient()) {
+    // Response with a server hello message.
+    DoSend(remote_address_, ssltcp_helper_->server_hello_message());
+    ssltcp_helper_->set_hello_sent(true);
+  }
+
+  return *consumed;
+}
+
 void P2PSocketHostTcpBase::OnConnected(int result) {
   DCHECK_EQ(state_, STATE_CONNECTING);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   if (result != net::OK) {
     OnError();
     return;
   }
 
   net::IPEndPoint address;
@@ skipping 67 matching lines @@
     return;
   }
 
   if (!(to == remote_address_)) {
     // Renderer should use this socket only to send data to |remote_address_|.
     NOTREACHED();
     OnError();
     return;
   }
 
+  if (ssltcp_helper_.get() && ssltcp_helper_->IsClient() &&
+      !ssltcp_helper_->hello_sent()) {
+    DoSend(remote_address_, ssltcp_helper_->client_hello_message());
+    ssltcp_helper_->set_hello_sent(true);
+  }
+
   if (!connected_) {
     P2PSocketHost::StunMessageType type;
     bool stun = GetStunPacketType(&*data.begin(), data.size(), &type);
     if (!stun || type == STUN_DATA_INDICATION) {
       LOG(ERROR) << "Page tried to send a data packet to " << to.ToString()
                  << " before STUN binding is finished.";
       OnError();
       return;
     }
   }
@@ skipping 80 matching lines @@
     pos += consumed;
   }
   // We've consumed all complete packets from the buffer; now move any remaining
   // bytes to the head of the buffer and set offset to reflect this.
   if (pos && pos <= read_buffer_->offset()) {
     memmove(head, head + pos, read_buffer_->offset() - pos);
     read_buffer_->set_offset(read_buffer_->offset() - pos);
   }
 }
 
-P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender, int id)
-    : P2PSocketHostTcpBase(message_sender, id) {
+P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender, int id,
+                                   bool ssl)
+    : P2PSocketHostTcpBase(message_sender, id, ssl) {
 }
 
 P2PSocketHostTcp::~P2PSocketHostTcp() {
 }
 
 int P2PSocketHostTcp::ProcessInput(char* input, int input_len) {
   if (input_len < kPacketHeaderSize)
     return 0;
   int packet_size = base::NetToHost16(*reinterpret_cast<uint16*>(input));
   if (input_len < packet_size + kPacketHeaderSize)
     return 0;
 
   int consumed = kPacketHeaderSize;
   char* cur = input + consumed;
+
+  // Handle ssltcp hello message.
+  if (ssltcp_helper_.get() && !ssltcp_helper_->hello_received()) {
+    return MaybeHandleSslHello(&cur, &packet_size, &consumed);

[Sergey Ulanov, 2013/06/18 20:01:26]

I think this should be handled in DidCompleteRead(). ProcessInput() should only
be called after hello has been received.

+  }
+
   std::vector<char> data(cur, cur + packet_size);
   OnPacket(data);
   consumed += packet_size;
   return consumed;
 }
 
 void P2PSocketHostTcp::DoSend(const net::IPEndPoint& to,
                               const std::vector<char>& data) {
   int size = kPacketHeaderSize + data.size();
   scoped_refptr<net::DrainableIOBuffer> buffer =
       new net::DrainableIOBuffer(new net::IOBuffer(size), size);
   *reinterpret_cast<uint16*>(buffer->data()) = base::HostToNet16(data.size());
   memcpy(buffer->data() + kPacketHeaderSize, &data[0], data.size());
 
   WriteOrQueue(buffer);
 }
 
 // P2PSocketHostStunTcp
 P2PSocketHostStunTcp::P2PSocketHostStunTcp(IPC::Sender* message_sender,
-                                           int id)
-    : P2PSocketHostTcpBase(message_sender, id) {
+                                           int id, bool ssl)
+    : P2PSocketHostTcpBase(message_sender, id, ssl) {
 }
 
 P2PSocketHostStunTcp::~P2PSocketHostStunTcp() {
 }
 
 int P2PSocketHostStunTcp::ProcessInput(char* input, int input_len) {
-  if (input_len < kPacketHeaderSize + kPacketLengthOffset)
-    return 0;
+  int consumed = 0;
+  char* cur = input;
+  int cur_len = input_len;
+  int pad_bytes;
 
-  int pad_bytes;
-  int packet_size = GetExpectedPacketSize(
-      input, input_len, &pad_bytes);
+  // Handle ssltcp hello message if not received yet.
+  if (ssltcp_helper_.get() && !ssltcp_helper_->hello_received()) {
+    return MaybeHandleSslHello(&cur, &cur_len, &consumed);
+  }
 
-  if (input_len < packet_size + pad_bytes)
-    return 0;
+  if (cur_len < kPacketHeaderSize + kPacketLengthOffset)
+    return consumed;
+
+  int packet_size = GetExpectedPacketSize(cur, cur_len, &pad_bytes);
+
+  if (cur_len < packet_size + pad_bytes)
+    return consumed;
 
   // We have a complete packet. Read through it.
-  int consumed = 0;
-  char* cur = input;
   std::vector<char> data(cur, cur + packet_size);
   OnPacket(data);
   consumed += packet_size;
   consumed += pad_bytes;
   return consumed;
 }
 
 void P2PSocketHostStunTcp::DoSend(const net::IPEndPoint& to,
                                   const std::vector<char>& data) {
   // Each packet is expected to have header (STUN/TURN ChannelData), where
   // header contains message type and and length of message.
   if (data.size() < kPacketHeaderSize + kPacketLengthOffset) {
     NOTREACHED();
     OnError();
     return;
   }
 
   int pad_bytes;
   size_t expected_len = GetExpectedPacketSize(
       &data[0], data.size(), &pad_bytes);
 
+  if (ssltcp_helper_.get() && !ssltcp_helper_->hello_sent()) {
+    expected_len = ssltcp_helper_->hello_message_size();

[Sergey Ulanov, 2013/06/18 20:01:26]

Why do we need this here? P2PSocketHostTcpBase::Send() should take care of hello
messages.

+    pad_bytes = 0;
+  }
+
   // Accepts only complete STUN/TURN packets.
   if (data.size() != expected_len) {
     NOTREACHED();
     OnError();
     return;
   }
 
   // Add any pad bytes to the total size.
   int size = data.size() + pad_bytes;
 
@@ skipping 26 matching lines @@
   } else {
     packet_size += kTurnChannelDataHeaderSize;
     // Calculate any padding if present.
     if (packet_size % 4)
       *pad_bytes = 4 - packet_size % 4;
   }
   return packet_size;
 }
 
 }  // namespace content