tor-browser

agent_win.cc (17152B)

---

// Copyright 2022 The Chromium Authors.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <sstream>
#include <utility>
#include <vector>

#include <windows.h>
#include <sddl.h>

#include "common/utils_win.h"

#include "agent_utils_win.h"
#include "agent_win.h"
#include "event_win.h"

namespace content_analysis {
namespace sdk {

// The minimum number of pipe in listening mode.  This is greater than one to
// handle the case of multiple instance of Google Chrome browser starting
// at the same time.
const DWORD kMinNumListeningPipeInstances = 2;

// The minimum number of handles to wait on.  This is the minimum number
// of pipes in listening mode plus the stop event.
const DWORD kMinNumWaitHandles = kMinNumListeningPipeInstances + 1;

// static
std::unique_ptr<Agent> Agent::Create(
   Config config,
   std::unique_ptr<AgentEventHandler> handler,
   ResultCode* rc) {
 auto agent = std::make_unique<AgentWin>(std::move(config), std::move(handler), rc);
 return *rc == ResultCode::OK ? std::move(agent) : nullptr;
}

AgentWin::Connection::Connection(const std::string& pipename,
                                bool user_specific,
                                AgentEventHandler* handler,
                                bool is_first_pipe,
                                ResultCode* rc)
   : handler_(handler)  {
 *rc = ResultCode::OK;
 memset(&overlapped_, 0, sizeof(overlapped_));
 // Create a manual reset event as specified for overlapped IO.
 // Use default security attriutes and no name since this event is not
 // shared with other processes.
 overlapped_.hEvent = CreateEvent(/*securityAttr=*/nullptr,
                                  /*manualReset=*/TRUE,
                                  /*initialState=*/FALSE,
                                  /*name=*/nullptr);
 if (!overlapped_.hEvent) {
   *rc = ResultCode::ERR_CANNOT_CREATE_CHANNEL_IO_EVENT;
   return;
 }

 *rc = ResetInternal(pipename, user_specific, is_first_pipe);
}

AgentWin::Connection::~Connection() {
 Cleanup();

 if (handle_ != INVALID_HANDLE_VALUE) {
   CloseHandle(handle_);
 }

 // Invalid event handles are represented as null.
 if (overlapped_.hEvent) {
   CloseHandle(overlapped_.hEvent);
 }
}

ResultCode AgentWin::Connection::Reset(
   const std::string& pipename,
   bool user_specific) {
 return NotifyIfError("ConnectionReset",
                      ResetInternal(pipename, user_specific, false));
}

ResultCode AgentWin::Connection::HandleEvent(HANDLE handle) {
 auto rc = ResultCode::OK;
 DWORD count;
 BOOL success = GetOverlappedResult(handle, &overlapped_, &count,
                                    /*wait=*/FALSE);
 if (!is_connected_) {
   // This connection is currently listing for a new connection from a Google
   // Chrome browser.  If the result is a success, this means the browser has
   // connected as expected.  Otherwise an error occured so report it to the
   // caller.
   if (success) {
     // A Google Chrome browser connected to the agent.  Reset this
     // connection object to handle communication with the browser and then
     // tell the handler about it.

     is_connected_ = true;
     buffer_.resize(internal::kBufferSize);

     rc = BuildBrowserInfo();
     if (rc == ResultCode::OK) {
       handler_->OnBrowserConnected(browser_info_);
     }
   } else {
     rc = ErrorToResultCode(GetLastError());
     NotifyIfError("GetOverlappedResult", rc);
   }
 } else {
   // Some data has arrived from Google Chrome. This data is (part of) an
   // instance of the proto message `ChromeToAgent`.
   //
   // If the message is small it is received in by one call to ReadFile().
   // If the message is larger it is received in by multiple calls to
   // ReadFile().
   //
   // `success` is true if the data just read is the last bytes for a message.
   // Otherwise it is false.
   rc = OnReadFile(success, count);
 }

 // If all data has been read, queue another read.
 if (rc == ResultCode::OK || rc == ResultCode::ERR_MORE_DATA) {
   rc = QueueReadFile(rc == ResultCode::OK);
 }

 if (rc != ResultCode::OK && rc != ResultCode::ERR_IO_PENDING &&
     rc != ResultCode::ERR_MORE_DATA) {
   Cleanup();
 } else {
   // Don't propagate all the "success" error codes to the called to keep
   // this simpler.
   rc = ResultCode::OK;
 }

 return rc;
}

void AgentWin::Connection::AppendDebugString(std::stringstream& state) const {
 state << "{handle=" << handle_;
 state << " connected=" << is_connected_;
 state << " pid=" << browser_info_.pid;
 state << " rsize=" << read_size_;
 state << " fsize=" << final_size_;
 state << "}";
}

ResultCode AgentWin::Connection::ConnectPipe() {
 // In overlapped mode, connecting to a named pipe always returns false.
 if (ConnectNamedPipe(handle_, &overlapped_)) {
   return ErrorToResultCode(GetLastError());
 }

 DWORD err = GetLastError();
 if (err == ERROR_IO_PENDING) {
   // Waiting for a Google Chrome Browser to connect.
   return ResultCode::OK;
 } else if (err == ERROR_PIPE_CONNECTED) {
   // A Google Chrome browser is already connected.  Make sure event is in
   // signaled state in order to process the connection.
   if (SetEvent(overlapped_.hEvent)) {
     err = ERROR_SUCCESS;
   } else {
     err = GetLastError();
   }
 }

 return ErrorToResultCode(err);
}

ResultCode AgentWin::Connection::ResetInternal(const std::string& pipename,
                                              bool user_specific,
                                              bool is_first_pipe) {
 auto rc = ResultCode::OK;

 // If this is the not the first time, disconnect from any existing Google
 // Chrome browser.  Otherwise creater a new pipe.
 if (handle_ != INVALID_HANDLE_VALUE) {
   if (!DisconnectNamedPipe(handle_)) {
     rc = ErrorToResultCode(GetLastError());
   }
 } else {
   rc = ErrorToResultCode(
       internal::CreatePipe(pipename, user_specific, is_first_pipe, &handle_));
 }

 // Make sure event starts in reset state.
 if (rc == ResultCode::OK && !ResetEvent(overlapped_.hEvent)) {
   rc = ErrorToResultCode(GetLastError());
 }

 if (rc == ResultCode::OK) {
   rc = ConnectPipe();
 }

 if (rc != ResultCode::OK) {
   Cleanup();
   handle_ = INVALID_HANDLE_VALUE;
 }

 return rc;
}

void AgentWin::Connection::Cleanup() {
 if (is_connected_ && handler_) {
   handler_->OnBrowserDisconnected(browser_info_);
 }

 is_connected_ = false;
 browser_info_ = BrowserInfo();
 buffer_.clear();
 cursor_ = nullptr;
 read_size_ = 0;
 final_size_ = 0;

 if (handle_ != INVALID_HANDLE_VALUE) {
   // Cancel all outstanding IO requests on this pipe by using a null for
   // overlapped.
   CancelIoEx(handle_, /*overlapped=*/nullptr);
 }

 // This function does not close `handle_` or the event in `overlapped` so
 // that the server can resuse the pipe with an new Google Chrome browser
 // instance.
}

ResultCode AgentWin::Connection::QueueReadFile(bool reset_cursor) {
 if (reset_cursor) {
   cursor_ = buffer_.data();
   read_size_ = buffer_.size();
   final_size_ = 0;
 }

 // When this function is called there are the following possiblities:
 //
 // 1/ Data is already available and the buffer is filled in.  ReadFile()
 //    return TRUE and the event is set.
 // 2/ Data is not avaiable yet.  ReadFile() returns FALSE and the last error
 //    is ERROR_IO_PENDING(997) and the event is reset.
 // 3/ Some error occurred, like for example Google Chrome stops.  ReadFile()
 //    returns FALSE and the last error is something other than
 //    ERROR_IO_PENDING, for example ERROR_BROKEN_PIPE(109).  The event
 //    state is unchanged.
 auto rc = ResultCode::OK;
 DWORD count;
 if (!ReadFile(handle_, cursor_, read_size_, &count, &overlapped_)) {
   DWORD err = GetLastError();
   rc = ErrorToResultCode(err);

   // IO pending is not an error so don't notify.
   //
   // Ignore broken pipes for notifications since that happens when the Google
   // Chrome browser shuts down.  The agent will be notified of a browser
   // disconnect in that case.
   //
   // More data means that `buffer_` was too small to read the entire message
   // from the browser.  The buffer has already been resized.  Another call to
   // ReadFile() is needed to get the remainder.
   if (rc != ResultCode::ERR_IO_PENDING &&
       rc != ResultCode::ERR_BROKEN_PIPE &&
       rc != ResultCode::ERR_MORE_DATA) {
     NotifyIfError("QueueReadFile", rc, err);
   }
 }

 return rc;
}

ResultCode AgentWin::Connection::OnReadFile(BOOL done_reading, DWORD count) {
 final_size_ += count;

 // If `done_reading` is TRUE, this means the full message has been read.
 // Call the appropriate handler method.
 if (done_reading) {
   return CallHandler();
 }

 // Otherwise there are two possibilities:
 //
 // 1/ The last error is ERROR_MORE_DATA(234).  This means there are more
 //    bytes to read before the request message is complete.  Resize the
 //    buffer and adjust the cursor.  The caller will queue up another read
 //    and wait.  don't notify the handler since this is not an error.
 // 2/ Some error occured.  In this case notify the handler and return the
 //    error.

 DWORD err = GetLastError();
 if (err == ERROR_MORE_DATA) {
   read_size_ = internal::kBufferSize;
   buffer_.resize(buffer_.size() + read_size_);
   cursor_ = buffer_.data() + buffer_.size() - read_size_;
   return ErrorToResultCode(err);
 }

 return NotifyIfError("OnReadFile", ErrorToResultCode(err));
}

ResultCode AgentWin::Connection::CallHandler() {
 ChromeToAgent message;
 if (!message.ParseFromArray(buffer_.data(), final_size_)) {
   // Malformed message.
   return NotifyIfError("ParseChromeToAgent",
                        ResultCode::ERR_INVALID_REQUEST_FROM_BROWSER);
 }

 auto rc = ResultCode::OK;

 if (message.has_request()) {
   // This is a request from Google Chrome to perform a content analysis
   // request.
   //
   // Move the request from `message` to the event to reduce the amount
   // of memory allocation/copying and also because the the handler takes
   // ownership of the event.
   auto event = std::make_unique<ContentAnalysisEventWin>(
       handle_, browser_info_, std::move(*message.mutable_request()));
   rc = event->Init();
   if (rc == ResultCode::OK) {
     handler_->OnAnalysisRequested(std::move(event));
   } else {
     NotifyIfError("RequestValidation", rc);
   }
 } else if (message.has_ack()) {
   // This is an ack from Google Chrome that it has received a content
   // analysis response from the agent.
   handler_->OnResponseAcknowledged(message.ack());
 } else if (message.has_cancel()) {
   // Google Chrome is informing the agent that the content analysis
   // request(s) associated with the given user action id have been
   // canceled by the user.
   handler_->OnCancelRequests(message.cancel());
 } else {
   // Malformed message.
   rc = NotifyIfError("NoRequestOrAck",
                      ResultCode::ERR_INVALID_REQUEST_FROM_BROWSER);
 }

 return rc;
}

ResultCode AgentWin::Connection::BuildBrowserInfo() {
 if (!GetNamedPipeClientProcessId(handle_, &browser_info_.pid)) {
   return NotifyIfError("BuildBrowserInfo",
                        ResultCode::ERR_CANNOT_GET_BROWSER_PID);
 }

 if (!internal::GetProcessPath(browser_info_.pid,
                               &browser_info_.binary_path)) {
   return NotifyIfError("BuildBrowserInfo",
                        ResultCode::ERR_CANNOT_GET_BROWSER_BINARY_PATH);
 }

 return ResultCode::OK;
}

ResultCode AgentWin::Connection::NotifyIfError(
   const char* context,
   ResultCode rc,
   DWORD err) {
 if (handler_ && rc != ResultCode::OK) {
   std::stringstream stm;
   stm << context << " pid=" << browser_info_.pid;
   if (err != ERROR_SUCCESS) {
     stm << context << " err=" << err;
   }

   handler_->OnInternalError(stm.str().c_str(), rc);
 }
 return rc;
}

AgentWin::AgentWin(
   Config config,
   std::unique_ptr<AgentEventHandler> event_handler,
   ResultCode* rc)
 : AgentBase(std::move(config), std::move(event_handler)) {
 *rc = ResultCode::OK;
 if (handler() == nullptr) {
   *rc = ResultCode::ERR_AGENT_EVENT_HANDLER_NOT_SPECIFIED;
   return;
 }

 stop_event_ = CreateEvent(/*securityAttr=*/nullptr,
                           /*manualReset=*/TRUE,
                           /*initialState=*/FALSE,
                           /*name=*/nullptr);
 if (stop_event_ == nullptr) {
   *rc = ResultCode::ERR_CANNOT_CREATE_AGENT_STOP_EVENT;
   return;
 }

 std::string pipename =
     internal::GetPipeNameForAgent(configuration().name,
                                   configuration().user_specific);
 if (pipename.empty()) {
   *rc = ResultCode::ERR_INVALID_CHANNEL_NAME;
   return;
 }

 pipename_ = pipename;

 connections_.reserve(kMinNumListeningPipeInstances);
 for (DWORD i = 0; i < kMinNumListeningPipeInstances; ++i) {
   connections_.emplace_back(
       std::make_unique<Connection>(pipename_, configuration().user_specific,
                                    handler(), i == 0, rc));
   if (*rc != ResultCode::OK || !connections_.back()->IsValid()) {
     Shutdown();
     break;
   }
 }
}

AgentWin::~AgentWin() {
 Shutdown();
}

ResultCode AgentWin::HandleEvents() {
 std::vector<HANDLE> wait_handles;
 auto rc = ResultCode::OK;
 bool stopped = false;
 while (!stopped && rc == ResultCode::OK) {
   rc = HandleOneEvent(wait_handles, &stopped);
 }

 return rc;
}

ResultCode AgentWin::Stop() {
 SetEvent(stop_event_);
 return AgentBase::Stop();
}

std::string AgentWin::DebugString() const {
 std::stringstream state;
 state.setf(std::ios::boolalpha);
 state << "AgentWin{pipe=\"" << pipename_;
 state << "\" stop=" << stop_event_;

 for (size_t i = 0; i < connections_.size(); ++i) {
   state << " conn@" << i;
   connections_[i]->AppendDebugString(state);
 }

 state << "}" << std::ends;
 return state.str();
}

void AgentWin::GetHandles(std::vector<HANDLE>& wait_handles) const {
 // Reserve enough space in the handles vector to include the stop event plus
 // all connections.
 wait_handles.clear();
 wait_handles.reserve(1 + connections_.size());

 for (auto& state : connections_) {
   HANDLE wait_handle = state->GetWaitHandle();
   if (!wait_handle) {
     wait_handles.clear();
     break;
   }
   wait_handles.push_back(wait_handle);
 }

 // Push the stop event last so that connections_ index calculations in
 // HandleOneEvent() don't have to account for this handle.
 wait_handles.push_back(stop_event_);
}

ResultCode AgentWin::HandleOneEventForTesting() {
 std::vector<HANDLE> wait_handles;
 bool stopped;
 return HandleOneEvent(wait_handles, &stopped);
}

bool AgentWin::IsAClientConnectedForTesting() {
 for (const auto& state : connections_) {
   if (state->IsConnected()) {
     return true;
   }
 }
 return false;
}

ResultCode AgentWin::HandleOneEvent(
   std::vector<HANDLE>& wait_handles,
   bool* stopped) {
 *stopped = false;

 // Wait on the specified handles for an event to occur.
 GetHandles(wait_handles);
 if (wait_handles.size() < kMinNumWaitHandles) {
   return NotifyError("GetHandles", ResultCode::ERR_AGENT_NOT_INITIALIZED);
 }

 DWORD index = WaitForMultipleObjects(
     wait_handles.size(), wait_handles.data(),
     /*waitAll=*/FALSE, /*timeoutMs=*/INFINITE);
 if (index == WAIT_FAILED) {
   return NotifyError("WaitForMultipleObjects",
                      ErrorToResultCode(GetLastError()));
 }

 // If the index of signaled handle is the last one in wait_handles, then the
 // stop event was signaled.
 index -= WAIT_OBJECT_0;
 if (index == wait_handles.size() - 1) {
   *stopped = true;
   return ResultCode::OK;
 }

 auto& connection = connections_[index];
 bool was_listening = !connection->IsConnected();
 auto rc = connection->HandleEvent(wait_handles[index]);
 if (rc != ResultCode::OK) {
   // If `connection` was not listening and there are more than
   // kMinNumListeningPipeInstances pipes, delete this connection.  Otherwise
   // reset it so that it becomes a listener.
   if (!was_listening &&
     connections_.size() > kMinNumListeningPipeInstances) {
     connections_.erase(connections_.begin() + index);
   } else {
     rc = connection->Reset(pipename_, configuration().user_specific);
   }
 }

 // If `connection` was listening and is now connected, create a new
 // one so that there are always kMinNumListeningPipeInstances listening.
 if (rc == ResultCode::OK && was_listening && connection->IsConnected()) {
   connections_.emplace_back(
       std::make_unique<Connection>(pipename_, configuration().user_specific,
                                    handler(), false, &rc));
 }

 return ResultCode::OK;
}

void AgentWin::Shutdown() {
 connections_.clear();
 pipename_.clear();
 if (stop_event_ != nullptr) {
   CloseHandle(stop_event_);
   stop_event_ = nullptr;
 }
}

}  // namespace sdk
}  // namespace content_analysis