Token-based authentication for chromoting.

remoting/jingle_glue/jingle_client.cc

 // Copyright (c) 2010 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 "remoting/jingle_glue/jingle_client.h"
 
 #include "base/logging.h"
 #include "base/waitable_event.h"
 #include "base/message_loop.h"
+#include "chrome/common/net/notifier/communicator/gaia_token_pre_xmpp_auth.h"
 #include "chrome/common/net/notifier/communicator/xmpp_socket_adapter.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/relay_port_allocator.h"
 #include "talk/base/asyncsocket.h"
 #include "talk/base/ssladapter.h"
 #include "talk/p2p/base/sessionmanager.h"
 #include "talk/p2p/client/sessionmanagertask.h"
 #ifdef USE_SSL_TUNNEL
 #include "talk/session/tunnel/securetunnelsessionclient.h"
 #endif
 #include "talk/session/tunnel/tunnelsessionclient.h"
+#include "talk/xmpp/prexmppauth.h"
+#include "talk/xmpp/saslcookiemechanism.h"
 
 namespace remoting {
 
 JingleClient::JingleClient()
     : callback_(NULL),
       state_(START) { }
 
 JingleClient::~JingleClient() {
   // JingleClient can be destroyed only after it's closed.
   DCHECK(state_ == CLOSED);
 }
 
-void JingleClient::Init(const std::string& username,
-                        const std::string& password,
-                        Callback* callback) {
+void JingleClient::Init(
+    const std::string& username, const std::string& auth_token,
+    const std::string& auth_token_service, Callback* callback) {
   DCHECK(username != "");
   DCHECK(callback != NULL);
   DCHECK(thread_ == NULL);  // Init() can be called only once.
 
   callback_ = callback;
 
-  username_ = username;
-  password_ = password;
-
   thread_.reset(new JingleThread());
   thread_->Start();
   thread_->message_loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &JingleClient::DoInitialize));
+      FROM_HERE, NewRunnableMethod(this, &JingleClient::DoInitialize,
+                                   username, auth_token, auth_token_service));
 }
 
 class JingleClient::ConnectRequest {
  public:
   ConnectRequest()
       : completed_event_(true, false) { }
 
   JingleChannel* Wait() {
     completed_event_.Wait();
     return channel_;
@@ skipping 42 matching lines @@
   client_->Disconnect();
   // Client is deleted by TaskRunner.
   client_ = NULL;
   tunnel_session_client_.reset();
   port_allocator_.reset();
   session_manager_.reset();
   network_manager_.reset();
   UpdateState(CLOSED);
 }
 
-void JingleClient::DoInitialize() {
-  buzz::Jid login_jid(username_);
-  talk_base::InsecureCryptStringImpl password;
-  password.password() = password_;
+void JingleClient::DoInitialize(const std::string& username,
+                                const std::string& auth_token,
+                                const std::string& auth_token_service) {
+  buzz::Jid login_jid(username);
 
-  buzz::XmppClientSettings xcs;
-  xcs.set_user(login_jid.node());
-  xcs.set_host(login_jid.domain());
-  xcs.set_resource("chromoting");
-  xcs.set_use_tls(true);
-  xcs.set_pass(talk_base::CryptString(password));
-  xcs.set_server(talk_base::SocketAddress("talk.google.com", 5222));
+  buzz::XmppClientSettings settings;
+  settings.set_user(login_jid.node());
+  settings.set_host(login_jid.domain());
+  settings.set_resource("chromoting");
+  settings.set_use_tls(true);
+  settings.set_token_service(auth_token_service);
+  settings.set_auth_cookie(auth_token);
+  settings.set_server(talk_base::SocketAddress("talk.google.com", 5222));
 
   client_ = new buzz::XmppClient(thread_->task_pump());
   client_->SignalStateChange.connect(
       this, &JingleClient::OnConnectionStateChanged);
 
   buzz::AsyncSocket* socket =
-      new notifier::XmppSocketAdapter(xcs, false);
+      new notifier::XmppSocketAdapter(settings, false);
 
-  client_->Connect(xcs, "", socket, NULL);
+  client_->Connect(settings, "", socket, CreatePreXmppAuth(settings));
   client_->Start();
 
   network_manager_.reset(new talk_base::NetworkManager());
 
   RelayPortAllocator* port_allocator =
       new RelayPortAllocator(network_manager_.get(), "transp2");
   port_allocator_.reset(port_allocator);
   port_allocator->SetJingleInfo(client_);
 
   session_manager_.reset(new cricket::SessionManager(port_allocator_.get()));
@@ skipping 75 matching lines @@
 }
 
 void JingleClient::UpdateState(State new_state) {
   if (new_state != state_) {
     state_ = new_state;
     if (callback_)
       callback_->OnStateChange(this, new_state);
   }
 }
 
+buzz::PreXmppAuth* JingleClient::CreatePreXmppAuth(
+    const buzz::XmppClientSettings& settings) {
+  buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
+  return new notifier::GaiaTokenPreXmppAuth(jid.Str(), settings.auth_cookie(),
+                                            settings.token_service());
+}
+
 }  // namespace remoting