[Cast Channel] Add real SSL tests to CastSocketTest

extensions/browser/api/cast_channel/cast_socket_unittest.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
+#include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/mock_timer.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "crypto/rsa_private_key.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_test_util.h"
 #include "extensions/browser/api/cast_channel/cast_transport.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
+#include "net/cert/pem_tokenizer.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
+#include "net/socket/ssl_server_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_info.h"
+#include "net/ssl/ssl_server_config.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int64_t kDistantTimeoutMillis = 100000;  // 100 seconds (never hit).
 
 using ::testing::_;
 using ::testing::A;
 using ::testing::DoAll;
@@ skipping 116 matching lines @@
   CompleteHandler() {}
   MOCK_METHOD1(OnCloseComplete, void(int result));
   MOCK_METHOD1(OnConnectComplete, void(ChannelError error_state));
   MOCK_METHOD1(OnWriteComplete, void(int result));
   MOCK_METHOD1(OnReadComplete, void(int result));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
+class FakeTCPClientSocket : public net::TCPClientSocket {
+ public:
+  FakeTCPClientSocket(net::FakeSocket* socket)
+      : net::TCPClientSocket(net::AddressList(),
+                             nullptr,
+                             nullptr,
+                             net::NetLog::Source()),
+        socket_(socket) {
+    DCHECK(socket_);
+  }
+
+  int Read(net::IOBuffer* buf,
+           int buf_len,
+           const net::CompletionCallback& callback) override {
+    return socket_->Read(buf, buf_len, callback);
+  }
+
+  int Write(net::IOBuffer* buf,
+            int buf_len,
+            const net::CompletionCallback& callback) override {
+    return socket_->Write(buf, buf_len, callback);
+  }
+
+  int SetReceiveBufferSize(int32_t size) override {
+    return socket_->SetReceiveBufferSize(size);
+  }
+
+  int SetSendBufferSize(int32_t size) override {
+    return socket_->SetSendBufferSize(size);
+  }
+
+  int Connect(const net::CompletionCallback& callback) override {
+    return socket_->Connect(callback);
+  }
+
+  void Disconnect() override { return socket_->Disconnect(); }
+
+  bool IsConnected() const override { return socket_->IsConnected(); }
+
+  bool IsConnectedAndIdle() const override {
+    return socket_->IsConnectedAndIdle();
+  }
+
+  int GetPeerAddress(net::IPEndPoint* address) const override {
+    return socket_->GetPeerAddress(address);
+  }
+
+  int GetLocalAddress(net::IPEndPoint* address) const override {
+    return socket_->GetLocalAddress(address);
+  }
+
+  const net::BoundNetLog& NetLog() const override { return socket_->NetLog(); }
+
+  void SetSubresourceSpeculation() override {
+    socket_->SetSubresourceSpeculation();
+  }
+
+  void SetOmniboxSpeculation() override { socket_->SetOmniboxSpeculation(); }
+
+  bool WasEverUsed() const override { return socket_->WasEverUsed(); }
+
+  bool WasNpnNegotiated() const override { return socket_->WasNpnNegotiated(); }
+
+  net::NextProto GetNegotiatedProtocol() const override {
+    return socket_->GetNegotiatedProtocol();
+  }
+
+  bool GetSSLInfo(net::SSLInfo* ssl_info) override {
+    return socket_->GetSSLInfo(ssl_info);
+  }
+
+  void GetConnectionAttempts(net::ConnectionAttempts* out) const override {
+    socket_->GetConnectionAttempts(out);
+  }
+
+  void ClearConnectionAttempts() override {
+    socket_->ClearConnectionAttempts();
+  }
+
+  void AddConnectionAttempts(const net::ConnectionAttempts& attempts) override {
+    socket_->AddConnectionAttempts(attempts);
+  }
+
+  int64_t GetTotalReceivedBytes() const override {
+    return socket_->GetTotalReceivedBytes();
+  }
+
+ private:
+  net::FakeSocket* socket_;
+};
+
 class TestCastSocket : public CastSocketImpl {
  public:
   static std::unique_ptr<TestCastSocket> Create(
       Logger* logger,
       uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
     return std::unique_ptr<TestCastSocket>(
         new TestCastSocket(CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL,
                            kDistantTimeoutMillis, logger, device_capabilities));
   }
 
@@ skipping 31 matching lines @@
                        false,
                        logger,
                        device_capabilities),
         capturing_net_log_(capturing_net_log),
         ip_(ip_endpoint),
         extract_cert_result_(true),
         verify_challenge_result_(true),
         verify_challenge_disallow_(false),
         tcp_unresponsive_(false),
         mock_timer_(new base::MockTimer(false, false)),
-        mock_transport_(nullptr) {}
+        mock_transport_(nullptr),
+        fake_socket_(nullptr) {}
 
   ~TestCastSocket() override {}
 
   void SetupMockTransport() {
     mock_transport_ = new MockCastTransport;
     SetTransportForTesting(base::WrapUnique(mock_transport_));
   }
 
+  void SetFakeSocket(net::FakeSocket* fake_socket) {
+    fake_socket_ = fake_socket;
+  }
+
   // Socket connection helpers.
   void SetupTcpConnect(net::IoMode mode, int result) {
     tcp_connect_data_.reset(new net::MockConnect(mode, result));
   }
   void SetupSslConnect(net::IoMode mode, int result) {
     ssl_connect_data_.reset(new net::MockConnect(mode, result));
   }
 
   // Socket I/O helpers.
   void AddWriteResult(const net::MockWrite& write) {
@@ skipping 45 matching lines @@
 
   MockCastTransport* GetMockTransport() {
     CHECK(mock_transport_);
     return mock_transport_;
   }
 
  private:
   std::unique_ptr<net::TCPClientSocket> CreateTcpSocket() override {
     if (tcp_unresponsive_) {
       return std::unique_ptr<net::TCPClientSocket>(new MockTCPSocket(true));
+    } else if (fake_socket_) {
+      return std::unique_ptr<net::TCPClientSocket>(
+          new FakeTCPClientSocket(fake_socket_));
     } else {
       net::MockConnect* connect_data = tcp_connect_data_.get();
       connect_data->peer_addr = ip_;
       return std::unique_ptr<net::TCPClientSocket>(
           new MockTCPSocket(*connect_data));
     }
   }
 
   std::unique_ptr<net::SSLClientSocket> CreateSslSocket(
       std::unique_ptr<net::StreamSocket> socket) override {
+    if (fake_socket_) {
+      return CastSocketImpl::CreateSslSocket(std::move(socket));
+    }
     net::MockConnect* connect_data = ssl_connect_data_.get();
     connect_data->peer_addr = ip_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
     return std::unique_ptr<net::SSLClientSocket>(new net::MockTCPClientSocket(
         net::AddressList(), capturing_net_log_.get(), ssl_data_.get()));
   }
@@ skipping 24 matching lines @@
   // Simulated result of peer cert extraction.
   bool extract_cert_result_;
   // Simulated result of verifying challenge reply.
   bool verify_challenge_result_;
   bool verify_challenge_disallow_;
   // If true, makes TCP connection process stall. For timeout testing.
   bool tcp_unresponsive_;
   std::unique_ptr<base::MockTimer> mock_timer_;
   MockCastTransport* mock_transport_;
 
+  // A fake socket that is used instead of the mocks when testing with the real
+  // SSL implementation.  When this is set, CreateTCPSocket() will use this as
+  // the underlying transport and CreateSSLSocket() will call the base
+  // implementation in CastSocketImpl.
+  net::FakeSocket* fake_socket_;
+
   DISALLOW_COPY_AND_ASSIGN(TestCastSocket);
 };
 
 class CastSocketTest : public testing::Test {
  public:
   CastSocketTest()
       : logger_(
             new Logger(base::WrapUnique<base::Clock>(new base::SimpleTestClock),
                        base::Time())),
         delegate_(new MockDelegate) {}
   ~CastSocketTest() override {}
 
   void SetUp() override { EXPECT_CALL(*delegate_, OnMessage(_)).Times(0); }
 
   void TearDown() override {
     if (socket_.get()) {
       EXPECT_CALL(handler_, OnCloseComplete(net::OK));
       socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                                 base::Unretained(&handler_)));
     }
   }
 
   void CreateCastSocket() { socket_ = TestCastSocket::Create(logger_); }
 
   void CreateCastSocketSecure() {
     socket_ = TestCastSocket::CreateSecure(logger_);
   }
 
+  // Initializes the SSLServerSocket |server_socket_| and the fake socket
+  // |fake_client_socket_| to be used by the CastSocket |socket_| as transport
+  // to |server_socket_|.
+  void CreateFakeSockets() {
+    channel_1_.reset(new net::FakeDataChannel());
+    channel_2_.reset(new net::FakeDataChannel());
+    server_cert_ =
+        net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
+    ASSERT_TRUE(server_cert_);
+    server_private_key_ = ReadTestKeyFromPEM("ok_cert.pem");
+    ASSERT_TRUE(server_private_key_);
+    server_context_ = CreateSSLServerContext(
+        server_cert_.get(), *server_private_key_, server_ssl_config_);
+
+    fake_client_socket_.reset(
+        new net::FakeSocket(channel_1_.get(), channel_2_.get()));
+    std::unique_ptr<net::StreamSocket> server_socket(

[Wez, 2016/07/01 01:27:56]

nit: fake_server_socket?

[btolsch, 2016/07/01 03:21:08]

This was effectively changed to |accepted_socket|.

+        new net::FakeSocket(channel_2_.get(), channel_1_.get()));
+
+    server_socket_ =
+        server_context_->CreateSSLServerSocket(std::move(server_socket));
+    ASSERT_TRUE(server_socket_);
+  }
+
+  std::unique_ptr<crypto::RSAPrivateKey> ReadTestKeyFromPEM(
+      const base::StringPiece& name) {
+    base::FilePath certs_dir(net::GetTestCertsDirectory());
+    base::FilePath key_path = certs_dir.AppendASCII(name);
+    std::vector<std::string> headers;
+    headers.push_back("PRIVATE KEY");
+    std::string pem_data;
+    if (!base::ReadFileToString(key_path, &pem_data)) {
+      return nullptr;
+    }
+    net::PEMTokenizer pem_tokenizer(pem_data, headers);
+    if (!pem_tokenizer.GetNext()) {
+      return nullptr;
+    }
+    std::vector<uint8_t> key_vector(pem_tokenizer.data().begin(),
+                                    pem_tokenizer.data().end());
+
+    std::unique_ptr<crypto::RSAPrivateKey> key(
+        crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
+    return key;
+  }
+
   void HandleAuthHandshake() {
     socket_->SetupMockTransport();
     CastMessage challenge_proto = CreateAuthChallenge();
     EXPECT_CALL(*socket_->GetMockTransport(),
                 SendMessage(EqualsProto(challenge_proto), _))
         .WillOnce(PostCompletionCallbackTask<1>(net::OK));
     EXPECT_CALL(*socket_->GetMockTransport(), Start());
     EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
     socket_->Connect(std::move(delegate_),
                      base::Bind(&CompleteHandler::OnConnectComplete,
                                 base::Unretained(&handler_)));
     RunPendingTasks();
     socket_->GetMockTransport()->current_delegate()->OnMessage(
         CreateAuthReply());
     RunPendingTasks();
   }
 
+  int ReadExactLength(net::IOBuffer* buffer,
+                      int buffer_length,
+                      net::Socket* socket) {
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
+        new net::DrainableIOBuffer(buffer, buffer_length));
+    while (draining_buffer->BytesRemaining() > 0) {
+      net::TestCompletionCallback read_callback;
+      int read_result = read_callback.GetResult(server_socket_->Read(
+          draining_buffer.get(), buffer_length, read_callback.callback()));
+      EXPECT_GT(read_result, 0);
+      draining_buffer->DidConsume(read_result);
+    }
+    return buffer_length;
+  }
+
+  int WriteExactLength(net::IOBuffer* buffer,
+                       int buffer_length,
+                       net::Socket* socket) {
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
+        new net::DrainableIOBuffer(buffer, buffer_length));
+    while (draining_buffer->BytesRemaining() > 0) {
+      net::TestCompletionCallback write_callback;
+      int write_result = write_callback.GetResult(server_socket_->Write(
+          draining_buffer.get(), buffer_length, write_callback.callback()));
+      EXPECT_GT(write_result, 0);
+      draining_buffer->DidConsume(write_result);
+    }
+    return buffer_length;
+  }
+
  protected:
   // Runs all pending tasks in the message loop.
   void RunPendingTasks() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
-  base::MessageLoop message_loop_;
+  content::TestBrowserThreadBundle thread_bundle_{
+      content::TestBrowserThreadBundle::IO_MAINLOOP};

[Wez, 2016/07/01 01:27:56]

nit: Is there a good reason to use {} init rather than (), given that the other
members (e.g. logger_) are initialized in the constructor?

[btolsch, 2016/07/01 03:21:08]

No, just a habit that slipped through.  Moved to constructor.

   Logger* logger_;
   std::unique_ptr<TestCastSocket> socket_;
   CompleteHandler handler_;
   std::unique_ptr<MockDelegate> delegate_;
 
+  // |channel_1_| and |channel_2_| form a full duplex connection between
+  // |socket_| and |server_socket_|. Passing data through them requires pumping
+  // the message loop.
+  std::unique_ptr<net::FakeDataChannel> channel_1_;
+  std::unique_ptr<net::FakeDataChannel> channel_2_;
+
+  // Used to create the fake TCP socket for |socket_| when communicating with
+  // |server_socket_|.
+  std::unique_ptr<net::FakeSocket> fake_client_socket_;
+
+  // |server_socket_| is used for the *RealSSL tests in order to test the
+  // CastSocket over a real SSL socket. The other members below are used to
+  // initialize |server_socket_|.
+  std::unique_ptr<net::SSLServerSocket> server_socket_;
+  std::unique_ptr<net::SSLServerContext> server_context_;
+  std::unique_ptr<crypto::RSAPrivateKey> server_private_key_;
+  scoped_refptr<net::X509Certificate> server_cert_;
+  net::SSLServerConfig server_ssl_config_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CastSocketTest);
 };
 
 // Tests connecting and closing the socket.
 TEST_F(CastSocketTest, TestConnectAndClose) {
   CreateCastSocket();
   socket_->SetupMockTransport();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
@@ skipping 375 matching lines @@
                               base::Unretained(&handler_)));
   RunPendingTasks();
   socket_->GetMockTransport()->current_delegate()->OnMessage(CreateAuthReply());
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
             socket_->error_state());
 }
 
+// Tests connecting through an actual non-mocked CastTransport object and
+// non-mocked SSLClientSocket, testing the components in integration.
+TEST_F(CastSocketTest, TestConnectEndToEndWithRealSSL) {
+  CreateCastSocketSecure();
+  CreateFakeSockets();
+  socket_->SetFakeSocket(fake_client_socket_.get());
+
+  socket_->Connect(std::move(delegate_),
+                   base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+
+  net::TestCompletionCallback handshake_callback;
+  int server_ret = handshake_callback.GetResult(
+      server_socket_->Handshake(handshake_callback.callback()));
+
+  ASSERT_EQ(net::OK, server_ret);
+
+  // Set low-level auth challenge expectations.
+  CastMessage challenge = CreateAuthChallenge();
+  std::string challenge_str;
+  EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
+
+  int challenge_buffer_length = challenge_str.size();
+  scoped_refptr<net::IOBuffer> challenge_buffer(
+      new net::IOBuffer(challenge_buffer_length));
+  int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
+                             server_socket_.get());
+
+  EXPECT_EQ(challenge_buffer_length, read);
+  EXPECT_EQ(challenge_str,
+            std::string(challenge_buffer->data(), challenge_buffer_length));
+
+  // Set low-level auth reply expectations.
+  CastMessage reply = CreateAuthReply();
+  std::string reply_str;
+  EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
+
+  scoped_refptr<net::StringIOBuffer> reply_buffer(
+      new net::StringIOBuffer(reply_str));
+  int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
+                                 server_socket_.get());
+
+  EXPECT_EQ(reply_buffer->size(), written);
+  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+}
+
+// Sends message data through an actual non-mocked CastTransport object and
+// non-mocked SSLClientSocket, testing the components in integration.
+TEST_F(CastSocketTest, TestMessageEndToEndWithRealSSL) {
+  CreateCastSocketSecure();
+  CreateFakeSockets();
+  socket_->SetFakeSocket(fake_client_socket_.get());

[Wez, 2016/07/01 01:27:56]

Is it necessary for the test to retain ownership of the fake_client_socket_, or
could you pass ownership into the |socket_| instead?

[btolsch, 2016/07/01 03:21:08]

Done (passed ownership to |socket_|).

+
+  socket_->Connect(std::move(delegate_),
+                   base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+
+  net::TestCompletionCallback handshake_callback;
+  int server_ret = handshake_callback.GetResult(
+      server_socket_->Handshake(handshake_callback.callback()));
+
+  ASSERT_EQ(net::OK, server_ret);
+
+  // Set low-level auth challenge expectations.
+  CastMessage challenge = CreateAuthChallenge();
+  std::string challenge_str;
+  EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
+
+  int challenge_buffer_length = challenge_str.size();
+  scoped_refptr<net::IOBuffer> challenge_buffer(
+      new net::IOBuffer(challenge_buffer_length));
+
+  int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
+                             server_socket_.get());
+
+  EXPECT_EQ(challenge_buffer_length, read);
+  EXPECT_EQ(challenge_str,
+            std::string(challenge_buffer->data(), challenge_buffer_length));
+
+  // Set low-level auth reply expectations.
+  CastMessage reply = CreateAuthReply();
+  std::string reply_str;
+  EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
+
+  scoped_refptr<net::StringIOBuffer> reply_buffer(
+      new net::StringIOBuffer(reply_str));
+  int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
+                                 server_socket_.get());
+
+  EXPECT_EQ(reply_buffer->size(), written);
+  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+
+  // Send a test message through the ssl socket.
+  CastMessage test_message = CreateTestMessage();
+  std::string test_message_str;
+  EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
+
+  int test_message_length = test_message_str.size();
+  scoped_refptr<net::IOBuffer> test_message_buffer(
+      new net::IOBuffer(test_message_length));
+
+  EXPECT_CALL(handler_, OnWriteComplete(net::OK));
+  socket_->transport()->SendMessage(
+      test_message, base::Bind(&CompleteHandler::OnWriteComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  read = ReadExactLength(test_message_buffer.get(), test_message_length,
+                         server_socket_.get());
+
+  EXPECT_EQ(test_message_length, read);
+  EXPECT_EQ(test_message_str,
+            std::string(test_message_buffer->data(), test_message_length));
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+}
+
 // Sends message data through an actual non-mocked CastTransport object,
 // testing the two components in integration.
 TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportAsync) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
 
   // Set low-level auth challenge expectations.
   CastMessage challenge = CreateAuthChallenge();
   std::string challenge_str;
@@ skipping 88 matching lines @@
       logger_, cast_channel::CastDeviceCapability::VIDEO_OUT);
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone());
   EXPECT_FALSE(socket_->audio_only());
   EXPECT_FALSE(socket_->TestVerifyChannelPolicyAudioOnly());
   EXPECT_TRUE(socket_->audio_only());
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions