Update GnubbyAuthHandler to use the current session ID

remoting/host/security_key/gnubby_auth_handler_win.cc

 // Copyright 2016 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/host/security_key/gnubby_auth_handler.h"
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/win/win_util.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/ipc_util.h"
@@ skipping 36 matching lines @@
   typedef std::map<int, std::unique_ptr<RemoteSecurityKeyIpcServer>>
       ActiveChannels;
 
   // GnubbyAuthHandler interface.
   void CreateGnubbyConnection() override;
   bool IsValidConnectionId(int gnubby_connection_id) const override;
   void SendClientResponse(int gnubby_connection_id,
                           const std::string& response) override;
   void SendErrorAndCloseConnection(int gnubby_connection_id) override;
   void SetSendMessageCallback(const SendMessageCallback& callback) override;
+  void SetSessionIdCallback(const SessionIdCallback& callback) override;
   size_t GetActiveConnectionCountForTest() const override;
   void SetRequestTimeoutForTest(base::TimeDelta timeout) override;
 
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
 
   // Creates the IPC server channel and waits for a connection using
   // |ipc_server_channel_name_|.
@@ skipping 11 matching lines @@
 
   // Creates a unique name based on the well-known IPC channel name.
   std::string GenerateUniqueChannelName();
 
   // Represents the last id assigned to a new security key request IPC channel.
   int last_connection_id_ = 0;
 
   // Sends a gnubby extension messages to the remote client when called.
   SendMessageCallback send_message_callback_;
 
+  // Used to retrieve the id of the remoted session.
+  SessionIdCallback session_id_callback_;
+
   // Tracks the IPC channel created for each security key forwarding session.
   ActiveChannels active_channels_;
 
   // The amount of time to wait for a client to process the connection details
   // message and disconnect from the IPC server channel before disconnecting it.
   base::TimeDelta disconnect_timeout_;
 
   // Used to recreate the IPC server channel if a client forgets to disconnect.
   base::OneShotTimer timer_;
 
   // IPC Clients connect to this channel first to receive their own IPC
   // channel to start a security key forwarding session on.
   std::unique_ptr<IPC::Channel> ipc_server_channel_;
 
   // Ensures GnubbyAuthHandlerWin methods are called on the same thread.
   base::ThreadChecker thread_checker_;
 
+  base::WeakPtrFactory<GnubbyAuthHandlerWin> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GnubbyAuthHandlerWin);
 };
 
 std::unique_ptr<GnubbyAuthHandler> GnubbyAuthHandler::Create(
-    const SendMessageCallback& callback) {
+    const SendMessageCallback& send_message_callback,
+    const SessionIdCallback& session_id_callback) {
   std::unique_ptr<GnubbyAuthHandler> auth_handler(new GnubbyAuthHandlerWin());
-  auth_handler->SetSendMessageCallback(callback);
+  auth_handler->SetSendMessageCallback(send_message_callback);
+  auth_handler->SetSessionIdCallback(session_id_callback);
   return auth_handler;
 }
 
 GnubbyAuthHandlerWin::GnubbyAuthHandlerWin()
     : disconnect_timeout_(
-          base::TimeDelta::FromSeconds(kInitialRequestTimeoutSeconds)) {}
+          base::TimeDelta::FromSeconds(kInitialRequestTimeoutSeconds)),
+      weak_factory_(this) {}
 
 GnubbyAuthHandlerWin::~GnubbyAuthHandlerWin() {}
 
 void GnubbyAuthHandlerWin::CreateGnubbyConnection() {
   DCHECK(thread_checker_.CalledOnValidThread());
   StartIpcServerChannel();
 }
 
 bool GnubbyAuthHandlerWin::IsValidConnectionId(int connection_id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 23 matching lines @@
   SendClientResponse(connection_id, kRemoteSecurityKeyConnectionError);
   CloseSecurityKeyRequestIpcChannel(connection_id);
 }
 
 void GnubbyAuthHandlerWin::SetSendMessageCallback(
     const SendMessageCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   send_message_callback_ = callback;
 }
 
+void GnubbyAuthHandlerWin::SetSessionIdCallback(
+    const SessionIdCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  session_id_callback_ = callback;
+}
+
 size_t GnubbyAuthHandlerWin::GetActiveConnectionCountForTest() const {
   return active_channels_.size();
 }
 
 void GnubbyAuthHandlerWin::SetRequestTimeoutForTest(base::TimeDelta timeout) {
   disconnect_timeout_ = timeout;
 }
 
 void GnubbyAuthHandlerWin::StartIpcServerChannel() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 46 matching lines @@
   return false;
 }
 
 void GnubbyAuthHandlerWin::OnChannelConnected(int32_t peer_pid) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   timer_.Start(FROM_HERE, disconnect_timeout_,
                base::Bind(&GnubbyAuthHandlerWin::OnChannelError,
                           base::Unretained(this)));
 
-  // TODO(joedow): Use |peer_pid| to determine the originating session
-  // using ProcessIdToSessionId() and verify it is the one we created.
-  // Tracked via crbug.com/591746
+  // Verify the IPC connection attempt originated from the session we are
+  // currently remoting.  We don't want to service requests from arbitrary
+  // Windows sessions.
+  DWORD peer_session_id;
+  if (!ProcessIdToSessionId(peer_pid, &peer_session_id)) {
+    PLOG(ERROR) << "ProcessIdToSessionId() failed";
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&GnubbyAuthHandlerWin::OnChannelError,
+                              weak_factory_.GetWeakPtr()));
+    return;
+  }
+  if (peer_session_id != session_id_callback_.Run()) {
+    LOG(INFO) << "Ignoring connection attempt from outside remoted session.";
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&GnubbyAuthHandlerWin::OnChannelError,
+                              weak_factory_.GetWeakPtr()));
+    return;
+  }
 
   int new_connection_id = ++last_connection_id_;
   std::unique_ptr<RemoteSecurityKeyIpcServer> ipc_server(
       RemoteSecurityKeyIpcServer::Create(
-          new_connection_id, disconnect_timeout_, send_message_callback_,
+          new_connection_id, peer_session_id, disconnect_timeout_,
+          send_message_callback_,
           base::Bind(&GnubbyAuthHandlerWin::CloseSecurityKeyRequestIpcChannel,
                      base::Unretained(this), new_connection_id)));
 
   std::string unique_channel_name = GenerateUniqueChannelName();
   if (ipc_server->CreateChannel(
           unique_channel_name,
           base::TimeDelta::FromSeconds(kGnubbyRequestTimeoutSeconds))) {
     active_channels_[new_connection_id] = std::move(ipc_server);
     ipc_server_channel_->Send(
         new ChromotingNetworkToRemoteSecurityKeyMsg_ConnectionDetails(
             unique_channel_name));
   }
 }
 
 void GnubbyAuthHandlerWin::OnChannelError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Could be an error, most likely the client disconnected though.  Either way
   // we should restart the server to prepare for the next connection.
   RecreateIpcServerChannel();
 }
 
 }  // namespace remoting