Use Authenticator interface in Session and SessionManager

remoting/protocol/jingle_session_unittest.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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/time.h"
 #include "base/test/test_timeouts.h"
 #include "crypto/nss_util.h"
+#include "crypto/rsa_private_key.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
+#include "remoting/base/constants.h"
 #include "remoting/protocol/auth_util.h"
+#include "remoting/protocol/authenticator.h"
+#include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/jingle_session.h"
 #include "remoting/protocol/jingle_session_manager.h"
+#include "remoting/protocol/v1_authenticator.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
 
 using testing::_;
 using testing::AtMost;
 using testing::DeleteArg;
 using testing::DoAll;
@@ skipping 70 matching lines @@
   MOCK_METHOD2(OnIncomingSession,
                void(Session*,
                     SessionManager::IncomingSessionResponse*));
 };
 
 class MockSessionCallback {
  public:
   MOCK_METHOD1(OnStateChange, void(Session::State));
 };
 
+class FakeChannelAuthenticator : public ChannelAuthenticator {
+ public:
+  FakeChannelAuthenticator(bool accept)
+      : accept_(accept) {
+  }
+  virtual ~FakeChannelAuthenticator() {}
+
+  virtual void SecureAndAuthenticate(
+      net::StreamSocket* socket, const DoneCallback& done_callback) OVERRIDE {
+    if (accept_) {
+      done_callback.Run(net::OK, socket);
+    } else {
+      delete socket;
+      done_callback.Run(net::ERR_FAILED, NULL);
+    }
+  }
+
+ private:
+  bool accept_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeChannelAuthenticator);
+};
+
+class FakeClientAuthenticator : public Authenticator {
+ public:
+  FakeClientAuthenticator(bool accept, bool accept_channel)
+      : accept_(accept),
+        accept_channel_(accept_channel),
+        state_(MESSAGE_READY) {
+  }
+  virtual ~FakeClientAuthenticator() {}
+
+  virtual State state() const OVERRIDE {
+    return state_;
+  }
+
+  virtual void ProcessMessage(const buzz::XmlElement* message) OVERRIDE {
+    EXPECT_EQ(WAITING_MESSAGE, state_);
+    state_ = accept_ ? ACCEPTED : REJECTED;
+  }
+
+  virtual buzz::XmlElement* GetNextMessage() OVERRIDE {
+    EXPECT_EQ(MESSAGE_READY, state_);
+    state_ = WAITING_MESSAGE;
+    return new buzz::XmlElement(
+        buzz::QName(kChromotingXmlNamespace, "authentication"));
+  }
+
+  virtual ChannelAuthenticator* CreateChannelAuthenticator() const OVERRIDE {
+    return new FakeChannelAuthenticator(accept_channel_);
+  }
+
+ protected:
+  bool accept_;
+  bool accept_channel_;
+  State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeClientAuthenticator);
+};
+
+class FakeHostAuthenticator : public Authenticator {
+ public:
+  FakeHostAuthenticator(bool accept, bool accept_channel)
+      : accept_(accept),
+        accept_channel_(accept_channel),
+        state_(WAITING_MESSAGE) {
+  }
+  virtual ~FakeHostAuthenticator() {}
+
+  virtual State state() const OVERRIDE {
+    return state_;
+  }
+
+  virtual void ProcessMessage(const buzz::XmlElement* message) OVERRIDE {
+    EXPECT_EQ(WAITING_MESSAGE, state_);
+    state_ = MESSAGE_READY;
+  }
+
+  virtual buzz::XmlElement* GetNextMessage() OVERRIDE {
+    EXPECT_EQ(MESSAGE_READY, state_);
+    state_ = accept_ ? ACCEPTED : REJECTED;
+    return new buzz::XmlElement(
+        buzz::QName(kChromotingXmlNamespace, "authentication"));
+  }
+
+  virtual ChannelAuthenticator* CreateChannelAuthenticator() const OVERRIDE {
+    return new FakeChannelAuthenticator(accept_channel_);
+  }
+
+ protected:
+  bool accept_;
+  bool accept_channel_;
+  State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeHostAuthenticator);
+};
+
+class FakeHostAuthenticatorFactory : public AuthenticatorFactory {
+ public:
+  FakeHostAuthenticatorFactory(bool accept, bool accept_channel)
+      : accept_(accept),
+        accept_channel_(accept_channel) {
+  }
+  virtual ~FakeHostAuthenticatorFactory() {}
+
+  virtual Authenticator* CreateAuthenticator(
+      const std::string& remote_jid,
+      const buzz::XmlElement* first_message) OVERRIDE {
+    return new FakeHostAuthenticator(accept_, accept_channel_);
+  }
+
+ private:
+  bool accept_;
+  bool accept_channel_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeHostAuthenticatorFactory);
+};
+
 }  // namespace
 
 class JingleSessionTest : public testing::Test {
  public:
   JingleSessionTest()
       : message_loop_(talk_base::Thread::Current()) {
   }
 
   // Helper method to copy to set value of client_connection_.
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_.reset(session);
     host_session_->SetStateChangeCallback(
         base::Bind(&MockSessionCallback::OnStateChange,
                    base::Unretained(&host_connection_callback_)));
 
     session->set_config(SessionConfig::GetDefault());
-    session->set_shared_secret(kTestSharedSecret);
   }
 
  protected:
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
     CloseSessions();
     CloseSessionManager();
   }
 
   void CloseSessions() {
     if (host_session_.get()) {
       host_session_->Close();
       host_session_.reset();
     }
     if (client_session_.get()) {
       client_session_->Close();
       client_session_.reset();
     }
   }
 
-  void CreateServerPair() {
+  void CreateServerPair(bool use_fake_auth) {
     FilePath certs_dir;
     PathService::Get(base::DIR_SOURCE_ROOT, &certs_dir);
     certs_dir = certs_dir.AppendASCII("net");
     certs_dir = certs_dir.AppendASCII("data");
     certs_dir = certs_dir.AppendASCII("ssl");
     certs_dir = certs_dir.AppendASCII("certificates");
 
     FilePath cert_path = certs_dir.AppendASCII("unittest.selfsigned.der");
     std::string cert_der;
     ASSERT_TRUE(file_util::ReadFileToString(cert_path, &cert_der));
@@ skipping 11 matching lines @@
     host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
     client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     EXPECT_CALL(host_server_listener_, OnSessionManagerInitialized())
         .Times(1);
     host_server_.reset(new JingleSessionManager(
         base::MessageLoopProxy::current()));
     host_server_->Init(
-        kHostJid, host_signal_strategy_.get(), &host_server_listener_,
-        private_key.release(), cert_der, false);
+        kHostJid, host_signal_strategy_.get(), &host_server_listener_, false);
+
+    if (use_fake_auth) {
+      host_server_->set_authenticator_factory(
+          new FakeHostAuthenticatorFactory(true, false));
+    } else {
+      host_server_->set_authenticator_factory(
+          new V1HostAuthenticatorFactory(
+              cert_der, private_key.release(), kTestSharedSecret));
+    }
 
     EXPECT_CALL(client_server_listener_, OnSessionManagerInitialized())
         .Times(1);
     client_server_.reset(new JingleSessionManager(
         base::MessageLoopProxy::current()));
     client_server_->Init(
-        kClientJid, client_signal_strategy_.get(), &client_server_listener_,
-        NULL, "", false);
+        kClientJid, client_signal_strategy_.get(),
+        &client_server_listener_, false);
   }
 
   void CloseSessionManager() {
     if (host_server_.get()) {
       host_server_->Close();
       host_server_.reset();
     }
     if (client_server_.get()) {
       client_server_->Close();
       client_server_.reset();
     }
     host_signal_strategy_.reset();
     client_signal_strategy_.reset();
   }
 
-  bool InitiateConnection(const char* shared_secret) {
+  bool InitiateConnection(bool use_fake_auth) {
     int not_connected_peers = 2;
 
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(
                 this, &JingleSessionTest::SetHostSession)),
             SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
@@ skipping 17 matching lines @@
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CONNECTED))
           .Times(1)
           .WillOnce(QuitThreadOnCounter(&not_connected_peers));
       // Expect that the connection will be closed eventually.
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CLOSED))
           .Times(AtMost(1));
     }
 
+    Authenticator* authenticator;
+    if (use_fake_auth) {
+      authenticator = new FakeClientAuthenticator(true, true);
+    } else {
+      authenticator = new V1ClientAuthenticator(kClientJid, kTestSharedSecret);
+    }
     client_session_.reset(client_server_->Connect(
-        kHostJid, kTestHostPublicKey,
-        GenerateSupportAuthToken(kClientJid, kTestSharedSecret),
+        kHostJid, authenticator,
         CandidateSessionConfig::CreateDefault(),
         base::Bind(&MockSessionCallback::OnStateChange,
                    base::Unretained(&client_connection_callback_))));
 
-    client_session_->set_shared_secret(shared_secret);
-
     return RunMessageLoopWithTimeout(TestTimeouts::action_max_timeout_ms());
   }
 
   static void DoNothing() { }
 
   JingleThreadMessageLoop message_loop_;
 
   scoped_ptr<FakeSignalStrategy> host_signal_strategy_;
   scoped_ptr<FakeSignalStrategy> client_signal_strategy_;
 
@@ skipping 98 matching lines @@
         base::Bind(&TCPChannelTester::OnChannelReady,
                    base::Unretained(this), 0));
     client_session_->CreateStreamChannel(
         kChannelName,
         base::Bind(&TCPChannelTester::OnChannelReady,
                    base::Unretained(this), 1));
   }
 
   void OnChannelReady(int id, net::StreamSocket* socket) {
     if (!socket) {
+      host_session_->CancelChannelCreation(kChannelName);
+      client_session_->CancelChannelCreation(kChannelName);
       Done();
       return;
     }
 
     DCHECK(id >= 0 && id < 2);
     sockets_[id].reset(socket);
 
     if (sockets_[0].get() && sockets_[1].get()) {
       InitBuffers();
       DoRead();
@@ skipping 255 matching lines @@
   net::OldCompletionCallbackImpl<UDPChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
   int packets_sent_;
   int packets_received_;
   int broken_packets_;
 };
 
 // Verify that we can create and destory server objects without a connection.
 TEST_F(JingleSessionTest, CreateAndDestoy) {
-  CreateServerPair();
+  CreateServerPair(false);
 }
 
 // Verify that incoming session can be rejected, and that the status
 // of the connection is set to CLOSED in this case.
 TEST_F(JingleSessionTest, RejectConnection) {
-  CreateServerPair();
+  CreateServerPair(false);
 
   // Reject incoming session.
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(SetArgumentPointee<1>(protocol::SessionManager::DECLINE));
 
   {
     InSequence dummy;
 
     EXPECT_CALL(client_connection_callback_,
                 OnStateChange(Session::CONNECTING))
         .Times(1);
     EXPECT_CALL(client_connection_callback_,
                 OnStateChange(Session::CLOSED))
         .Times(1)
         .WillOnce(InvokeWithoutArgs(&QuitCurrentThread));
   }
 
+  Authenticator* authenticator =
+      new V1ClientAuthenticator(kClientJid, kTestSharedSecretBad);
   client_session_.reset(client_server_->Connect(
-      kHostJid, kTestHostPublicKey,
-      GenerateSupportAuthToken(kClientJid, kTestSharedSecret),
+      kHostJid, authenticator,
       CandidateSessionConfig::CreateDefault(),
       base::Bind(&MockSessionCallback::OnStateChange,
                  base::Unretained(&client_connection_callback_))));
 
   ASSERT_TRUE(RunMessageLoopWithTimeout(TestTimeouts::action_max_timeout_ms()));
 }
 
 // Verify that we can connect two endpoints.
 TEST_F(JingleSessionTest, Connect) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  CreateServerPair(false);
+  ASSERT_TRUE(InitiateConnection(false));
 }
 
 // Verify that we can't connect two endpoints with mismatched secrets.
 TEST_F(JingleSessionTest, ConnectBadChannelAuth) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecretBad));
+  CreateServerPair(true);
+  ASSERT_TRUE(InitiateConnection(true));
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(host_session_.get(), client_session_.get(),
                            kMessageSize, kMessages));
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   EXPECT_TRUE(tester->did_initialization_fail());
 
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the event channel.
 TEST_F(JingleSessionTest, TestTcpChannel) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  CreateServerPair(false);
+  ASSERT_TRUE(InitiateConnection(false));
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(host_session_.get(), client_session_.get(),
                            kMessageSize, kMessages));
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the video RTP channel.
 TEST_F(JingleSessionTest, TestUdpChannel) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  CreateServerPair(false);
+  ASSERT_TRUE(InitiateConnection(false));
   scoped_refptr<UDPChannelTester> tester(
       new UDPChannelTester(host_session_.get(), client_session_.get()));
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Send packets of different size to get the latency for sending data
 // using sockets from JingleSession.
 TEST_F(JingleSessionTest, FLAKY_TestSpeed) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  CreateServerPair(false);
+  ASSERT_TRUE(InitiateConnection(false));
   scoped_refptr<ChannelSpeedTester> tester;
 
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 512);
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 512 bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   CloseSessions();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  ASSERT_TRUE(InitiateConnection(false));
 
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 1024);
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 1024 bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   CloseSessions();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  ASSERT_TRUE(InitiateConnection(false));
 
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 51200);
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 50k bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   CloseSessions();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+  ASSERT_TRUE(InitiateConnection(false));
 
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 512000);
   tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 500k bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 }  // namespace protocol
 }  // namespace remoting