Enable V2 authentication for Me2Me host.

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me, which is currently
 // used for the Linux-only Virtual Me2Me build.
 
 #include <string>
 
 #include "base/at_exit.h"
@@ skipping 20 matching lines @@
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif
 
+using remoting::protocol::SharedSecretHash;

[Wez, 2012/01/23 23:53:49]

nit: Do you really need this? protocol::SharedSecretHash seems plenty short for
the member declaration below.

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

+
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "remoting_me2me_host";
 
 // These are used for parsing the config-file locations from the command line,
 // and for defining the default locations if the switches are not present.
 const char kAuthConfigSwitchName[] = "auth-config";
 const char kHostConfigSwitchName[] = "host-config";
 
@@ skipping 52 matching lines @@
         &HostProcess::StartHost, base::Unretained(this)));
 
     message_loop_.Run();
 
     return 0;
   }
 
  private:
   // Read Host config from disk, returning true if successful.
   bool LoadConfig(base::MessageLoopProxy* io_message_loop) {
     scoped_refptr<remoting::JsonHostConfig> host_config =

[Wez, 2012/01/23 23:53:49]

nit: Unnecessary remoting::s

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

         new remoting::JsonHostConfig(host_config_path_, io_message_loop);
     scoped_refptr<remoting::JsonHostConfig> auth_config =
         new remoting::JsonHostConfig(auth_config_path_, io_message_loop);
 
     std::string failed_path;
     if (!host_config->Read()) {
       failed_path = host_config_path_.value();
     } else if (!auth_config->Read()) {
       failed_path = auth_config_path_.value();
     }
     if (!failed_path.empty()) {
       LOG(ERROR) << "Failed to read configuration file " << failed_path;
       return false;
     }
 
     if (!host_config->GetString(kHostIdConfigPath, &host_id_)) {
       LOG(ERROR) << "host_id is not defined in the config.";
       return false;
     }
 
     if (!key_pair_.Load(host_config)) {
       return false;
     }
 
+    std::string host_secret_hash_string;
+    if (!host_config->GetString(kHostSecretHashConfigPath,
+                           &host_secret_hash_string)) {

[Wez, 2012/01/23 23:53:49]

nit: Indentation.

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

+      LOG(ERROR) << "host_secret_hash is not defined in the config.";
+      return false;
+    }
+
+    if (!host_secret_hash_.Parse(host_secret_hash_string)) {
+      LOG(ERROR) << "Invalid host_secret_hash.";
+      return false;
+    }
+
     // Use an XMPP connection to the Talk network for session signalling.
     if (!auth_config->GetString(kXmppLoginConfigPath, &xmpp_login_) ||
         !auth_config->GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token_)) {
       LOG(ERROR) << "XMPP credentials are not defined in the config.";
       return false;
     }
 
     if (!auth_config->GetString(remoting::kXmppAuthServiceConfigPath,
                                  &xmpp_auth_service_)) {
       // For the me2me host, we assume we use the ClientLogin token for
       // chromiumsync because we do not have an HTTP stack with which we can
       // easily request an OAuth2 access token even if we had a RefreshToken for
       // the account.
       xmpp_auth_service_ = remoting::kChromotingTokenDefaultServiceName;

[Wez, 2012/01/23 23:53:49]

nit: Here too.

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

     }
 
     return true;
   }
 
   void StartHost() {
     DCHECK(context_.network_message_loop()->BelongsToCurrentThread());
 
     signal_strategy_.reset(
         new XmppSignalStrategy(context_.jingle_thread(), xmpp_login_,
@@ skipping 14 matching lines @@
     heartbeat_sender_.reset(
         new HeartbeatSender(host_id_, signal_strategy_.get(), &key_pair_));
 
     log_to_server_.reset(
         new LogToServer(host_, ServerLogEntry::ME2ME, signal_strategy_.get()));
     host_event_logger_.reset(new HostEventLogger(host_, kApplicationName));
 
     host_->Start();
 
     // Create authenticator factory.
-    //
-    // TODO(sergeyu): Currently empty PIN is used. This is a temporary
-    // hack pending us adding a way to set a PIN. crbug.com/105214 .
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             xmpp_login_, key_pair_.GenerateCertificate(),
-            *key_pair_.private_key(), ""));
+            *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   MessageLoop message_loop_;
   base::Thread file_io_thread_;
   remoting::ChromotingHostContext context_;

[Wez, 2012/01/23 23:53:49]

nit: Doesn't need remoting::

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath auth_config_path_;
   FilePath host_config_path_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
+  SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   scoped_ptr<SignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<remoting::HeartbeatSender> heartbeat_sender_;

[Wez, 2012/01/23 23:53:49]

nit: This doesn't need the remoting:: prefix.

[Sergey Ulanov, 2012/01/24 06:32:22]

Done.

   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
   scoped_refptr<ChromotingHost> host_;
 };
 
 }  // namespace remoting
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
 
   // This object instance is required by Chrome code (for example,
   // LazyInstance, MessageLoop).
   base::AtExitManager exit_manager;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
 #if defined(TOOLKIT_USES_GTK)
   // Required for any calls into GTK functions, such as the Disconnect and
   // Continue windows, though these should not be used for the Me2Me case
   // (crbug.com/104377).
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_USES_GTK
 
   remoting::HostProcess me2me_host;
   me2me_host.InitWithCommandLine(cmd_line);
 
   return me2me_host.Run();
 }