Add ability to query desktop process for its session ID by the network process

remoting/host/win/wts_session_process_delegate.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 the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include <utility>
@@ skipping 11 matching lines @@
 #include "ipc/attachment_broker.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/host/host_main.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/ipc_util.h"
 #include "remoting/host/switches.h"
 #include "remoting/host/win/launch_process_with_token.h"
+#include "remoting/host/win/security_descriptor.h"
 #include "remoting/host/win/worker_process_launcher.h"
 #include "remoting/host/win/wts_terminal_monitor.h"
 #include "remoting/host/worker_process_ipc_delegate.h"
 
 using base::win::ScopedHandle;
 
 // Name of the default session desktop.
 const char kDefaultDesktopName[] = "winsta0\\default";
 
 namespace remoting {
 
 // A private class actually implementing the functionality provided by
 // |WtsSessionProcessDelegate|. This class is ref-counted and implements
 // asynchronous fire-and-forget shutdown.
 class WtsSessionProcessDelegate::Core
     : public base::RefCountedThreadSafe<Core>,
       public base::MessagePumpForIO::IOHandler,
       public IPC::Listener {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
        std::unique_ptr<base::CommandLine> target,
        bool launch_elevated,
-       const std::string& channel_security);
+       const std::string& channel_security,
+       const std::string& new_process_security);
 
   // Initializes the object returning true on success.
   bool Initialize(uint32_t session_id);
 
   // Stops the object asynchronously.
   void Stop();
 
   // Mirrors WorkerProcessLauncher::Delegate.
   void LaunchProcess(WorkerProcessLauncher* event_handler);
   void Send(IPC::Message* message);
@@ skipping 43 matching lines @@
   // The task runner serving job object notifications.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The server end of the IPC channel used to communicate to the worker
   // process.
   std::unique_ptr<IPC::ChannelProxy> channel_;
 
   // Security descriptor (as SDDL) to be applied to |channel_|.
   std::string channel_security_;
 
+  // Security descriptor (as SDDL) to be applied to the newly created process.
+  std::string new_process_security_;
+
   WorkerProcessLauncher* event_handler_;
 
   // Pointer to GetNamedPipeClientProcessId() API if it is available.
   typedef BOOL (WINAPI * GetNamedPipeClientProcessIdFn)(HANDLE, DWORD*);
   GetNamedPipeClientProcessIdFn get_named_pipe_client_pid_;
 
   // The job object used to control the lifetime of child processes.
   base::win::ScopedHandle job_;
 
   // True if the worker process should be launched elevated.
@@ skipping 14 matching lines @@
   // The handle of the worker process, if launched.
   base::win::ScopedHandle worker_process_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 WtsSessionProcessDelegate::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     std::unique_ptr<base::CommandLine> target_command,
     bool launch_elevated,
-    const std::string& channel_security)
+    const std::string& channel_security,
+    const std::string& new_process_security)
     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
       channel_security_(channel_security),
+      new_process_security_(new_process_security),
       event_handler_(nullptr),
       get_named_pipe_client_pid_(nullptr),
       launch_elevated_(launch_elevated),
       launch_pending_(false),
       target_command_(std::move(target_command)) {}
 
 bool WtsSessionProcessDelegate::Core::Initialize(uint32_t session_id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (launch_elevated_) {
@@ skipping 215 matching lines @@
       new IPC::ChannelProxy(this, io_task_runner_));
   IPC::AttachmentBroker::GetGlobal()->RegisterCommunicationChannel(
       channel.get(), io_task_runner_);
   channel->Init(IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER,
                 /*create_pipe_now=*/true);
 
   // Pass the name of the IPC channel to use.
   command_line.AppendSwitchNative(kDaemonPipeSwitchName,
                                   base::UTF8ToWide(channel_name));
 
+  ScopedSd security_descriptor;
+  std::unique_ptr<SECURITY_ATTRIBUTES> security_attributes;
+  if (!new_process_security_.empty()) {
+    security_descriptor = ConvertSddlToSd(new_process_security_);
+    if (!security_descriptor) {
+      PLOG(ERROR) << "ConvertSddlToSd() failed.";
+      ReportFatalError();
+      return;
+    }
+
+    security_attributes.reset(new SECURITY_ATTRIBUTES());
+    security_attributes->nLength = sizeof(SECURITY_ATTRIBUTES);
+    security_attributes->lpSecurityDescriptor = security_descriptor.get();
+    security_attributes->bInheritHandle = FALSE;
+  }
+
   // Try to launch the process.
   ScopedHandle worker_process;
   ScopedHandle worker_thread;
   if (!LaunchProcessWithToken(command_line.GetProgram(),
                               command_line.GetCommandLineString(),
                               session_token_.Get(),
-                              nullptr,
+                              security_attributes.get(),
                               nullptr,
                               false,
                               CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB,
                               base::UTF8ToUTF16(kDefaultDesktopName).c_str(),
                               &worker_process,
                               &worker_thread)) {
     ReportFatalError();
     return;
   }
 
@@ skipping 109 matching lines @@
   }
   ScopedHandle limited_handle(temp_handle);
 
   event_handler_->OnProcessLaunched(std::move(limited_handle));
 }
 
 WtsSessionProcessDelegate::WtsSessionProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     std::unique_ptr<base::CommandLine> target_command,
     bool launch_elevated,
-    const std::string& channel_security) {
+    const std::string& channel_security,
+    const std::string& new_process_security_descriptor) {
   core_ = new Core(io_task_runner, std::move(target_command), launch_elevated,
-                   channel_security);
+                   channel_security, new_process_security_descriptor);
 }
 
 WtsSessionProcessDelegate::~WtsSessionProcessDelegate() {
   core_->Stop();
 }
 
 bool WtsSessionProcessDelegate::Initialize(uint32_t session_id) {
   return core_->Initialize(session_id);
 }
 
 void WtsSessionProcessDelegate::LaunchProcess(
     WorkerProcessLauncher* event_handler) {
   core_->LaunchProcess(event_handler);
 }
 
 void WtsSessionProcessDelegate::Send(IPC::Message* message) {
   core_->Send(message);
 }
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 }  // namespace remoting