Enable Android support for Chromoting PINless (paired) authentication

remoting/client/jni/chromoting_jni_instance.cc

 // Copyright 2013 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/client/jni/chromoting_jni_instance.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
+#include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 
 // TODO(solb) Move into location shared with client plugin.
 const char* const kXmppServer = "talk.google.com";
 const int kXmppPort = 5222;
 const bool kXmppUseTls = true;
 
 namespace remoting {
 
 ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
                                              const char* username,
                                              const char* auth_token,
                                              const char* host_jid,
                                              const char* host_id,
-                                             const char* host_pubkey)
+                                             const char* host_pubkey,
+                                             const char* pairing_id,
+                                             const char* pairing_secret)
     : jni_runtime_(jni_runtime),
       username_(username),
       auth_token_(auth_token),
       host_jid_(host_jid),
       host_id_(host_id),
-      host_pubkey_(host_pubkey) {
+      host_pubkey_(host_pubkey),
+      pairing_id_(pairing_id),
+      pairing_secret_(pairing_secret),
+      create_pairing_(false) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   jni_runtime_->display_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniInstance::ConnectToHostOnDisplayThread,
                  this));
 }
 
 ChromotingJniInstance::~ChromotingJniInstance() {}
 
@@ skipping 10 matching lines @@
 
   // The weak pointers must be invalidated on the same thread they were used.
   view_weak_factory_->InvalidateWeakPtrs();
 
   jni_runtime_->network_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniInstance::DisconnectFromHostOnNetworkThread,
                  this));
 }
 
-void ChromotingJniInstance::ProvideSecret(const std::string& pin) {
+void ChromotingJniInstance::ProvideSecret(const std::string& pin,
+                                          bool create_pairing) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
   DCHECK(!pin_callback_.is_null());
 
+  create_pairing_ = create_pairing;
+
   jni_runtime_->network_task_runner()->PostTask(FROM_HERE,
                                                 base::Bind(pin_callback_, pin));
 }
 
 void ChromotingJniInstance::RedrawDesktop() {
   if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->display_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::RedrawDesktop, this));
     return;
@@ skipping 48 matching lines @@
     connection_->input_stub()->InjectKeyEvent(action);
   }
   else {
     LOG(WARNING) << "Ignoring unknown keycode: " << key_code;
   }
 }
 
 void ChromotingJniInstance::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
-  if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
-    jni_runtime_->ui_task_runner()->PostTask(
-            FROM_HERE,
-            base::Bind(&ChromotingJniInstance::OnConnectionState,
-                       this,
-                       state,
-                       error));
-    return;
+  DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
+
+  if (create_pairing_ && state == protocol::ConnectionToHost::CONNECTED) {
+    LOG(INFO) << "Attempting to pair with host";
+    protocol::PairingRequest request;
+    request.set_client_name("Android");
+    connection_->host_stub()->RequestPairing(request);
   }
 
-  jni_runtime_->ReportConnectionStatus(state, error);
+  jni_runtime_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::ReportConnectionStatus,
+                 base::Unretained(jni_runtime_),
+                 state,
+                 error));
 }
 
 void ChromotingJniInstance::OnConnectionReady(bool ready) {
-  // We ignore this message, since OnConnectionState() tells us the same thing.
+  // We ignore this message, since OnConnectoinState tells us the same thing.
 }
 
 void ChromotingJniInstance::SetCapabilities(const std::string& capabilities) {}
 
 void ChromotingJniInstance::SetPairingResponse(
     const protocol::PairingResponse& response) {
-  NOTIMPLEMENTED();
+  LOG(INFO) << "Successfully established pairing with host";
+
+  jni_runtime_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::CommitPairingCredentials,
+                 base::Unretained(jni_runtime_),
+                 host_id_,
+                 response.client_id(),
+                 response.shared_secret()));
 }
 
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingJniInstance::GetCursorShapeStub() {
   return this;
 }
 
@@ skipping 33 matching lines @@
 
   client_config_.reset(new ClientConfig());
   client_config_->host_jid = host_jid_;
   client_config_->host_public_key = host_pubkey_;
 
   client_config_->fetch_secret_callback = base::Bind(
       &ChromotingJniInstance::FetchSecret,
       this);
   client_config_->authentication_tag = host_id_;
 
+  if (!pairing_id_.empty() && !pairing_secret_.empty()) {
+    client_config_->client_pairing_id = pairing_id_;
+    client_config_->client_paired_secret = pairing_secret_;
+    client_config_->authentication_methods.push_back(
+        protocol::AuthenticationMethod::FromString("spake2_pair"));
+  }
+
   client_config_->authentication_methods.push_back(
       protocol::AuthenticationMethod::FromString("spake2_hmac"));
   client_config_->authentication_methods.push_back(
       protocol::AuthenticationMethod::FromString("spake2_plain"));
 
   client_context_.reset(new ClientContext(
       jni_runtime_->network_task_runner().get()));
   client_context_->Start();
 
   connection_.reset(new protocol::ConnectionToHost(true));
@@ skipping 48 matching lines @@
   if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->ui_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::FetchSecret,
                    this,
                    pairable,
                    callback));
     return;
   }
 
+  if (!pairing_id_.empty() || !pairing_secret_.empty()) {
+    // We attempted to connect using an existing pairing that was rejected.
+    // Unless we forget about the stale credentials, we'll continue trying them.
+    LOG(INFO) << "Deleting rejected pairing credentials";
+    jni_runtime_->CommitPairingCredentials(host_id_, "", "");
+  }
+
   pin_callback_ = callback;
   jni_runtime_->DisplayAuthenticationPrompt();
 }
 
 }  // namespace remoting