| // Copyright 2019 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 "chrome/chrome_cleaner/engines/broker/engine_requests_impl.h" |
| |
| // Windows include must be first for the code to compile. |
| // clang-format off |
| #include <windows.h> |
| #include <sddl.h> |
| // clang-format on |
| |
| #include <set> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/task/thread_pool.h" |
| #include "base/task/post_task.h" |
| #include "base/task/task_traits.h" |
| #include "chrome/chrome_cleaner/engines/broker/scanner_sandbox_interface.h" |
| #include "chrome/chrome_cleaner/os/registry.h" |
| #include "mojo/public/cpp/system/platform_handle.h" |
| |
| namespace chrome_cleaner { |
| |
| namespace { |
| |
| void CloseRegistryHandle(HANDLE handle) { |
| if (IsPredefinedRegistryHandle(handle)) |
| return; |
| // Call ::CloseHandle instead of ::RegCloseKey as it's not always possible to |
| // distinguish whether the passed handle was returned by RegOpenKey or by |
| // NtOpenKey. |
| // TODO(veranika): track registry handle types and close them correctly. |
| bool success = ::CloseHandle(handle); |
| PLOG_IF(ERROR, !success) << "Failed to close handle"; |
| } |
| |
| void ForwardOpenRegistryResult( |
| mojom::EngineRequests::SandboxOpenReadOnlyRegistryCallback result_callback, |
| uint32_t return_code, |
| HKEY handle) { |
| std::move(result_callback).Run(return_code, handle); |
| |
| if (return_code == 0) { |
| // Close |handle| only on successful operation, as otherwise it's not set. |
| LSTATUS status = ::RegCloseKey(handle); |
| LOG_IF(ERROR, status != ERROR_SUCCESS) |
| << "Failed to close a registry key: " |
| << logging::SystemErrorCodeToString(status); |
| } |
| } |
| |
| void ForwardNtOpenRegistryResult( |
| mojom::EngineRequests::SandboxNtOpenReadOnlyRegistryCallback callback, |
| uint32_t return_code, |
| HANDLE handle) { |
| std::move(callback).Run(return_code, handle); |
| CloseRegistryHandle(handle); |
| } |
| |
| } // namespace |
| |
| EngineRequestsImpl::EngineRequestsImpl( |
| scoped_refptr<MojoTaskRunner> mojo_task_runner, |
| InterfaceMetadataObserver* metadata_observer) |
| : mojo_task_runner_(mojo_task_runner), |
| metadata_observer_(metadata_observer) {} |
| |
| EngineRequestsImpl::~EngineRequestsImpl() = default; |
| |
| void EngineRequestsImpl::Bind( |
| mojo::PendingAssociatedRemote<mojom::EngineRequests>* remote) { |
| if (receiver_.is_bound()) |
| receiver_.reset(); |
| |
| receiver_.Bind(remote->InitWithNewEndpointAndPassReceiver()); |
| // There's no need to call set_disconnect_handler on this since it's an |
| // associated interface. Any errors will be handled on the main EngineCommands |
| // interface. |
| } |
| |
| void EngineRequestsImpl::SandboxGetFileAttributes( |
| const base::FilePath& file_name, |
| SandboxGetFileAttributesCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetFileAttributes, |
| base::Unretained(this), file_name, |
| std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetFileAttributes( |
| const base::FilePath& file_name, |
| SandboxGetFileAttributesCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| uint32_t attributes = INVALID_FILE_ATTRIBUTES; |
| uint32_t result = |
| chrome_cleaner_sandbox::SandboxGetFileAttributes(file_name, &attributes); |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, attributes)); |
| } |
| |
| void EngineRequestsImpl::SandboxGetKnownFolderPath( |
| mojom::KnownFolder folder_id, |
| SandboxGetKnownFolderPathCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetKnownFolderPath, |
| base::Unretained(this), folder_id, |
| std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetKnownFolderPath( |
| mojom::KnownFolder folder_id, |
| SandboxGetKnownFolderPathCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| base::FilePath folder_path; |
| bool result = chrome_cleaner_sandbox::SandboxGetKnownFolderPath(folder_id, |
| &folder_path); |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, folder_path)); |
| } |
| |
| void EngineRequestsImpl::SandboxGetProcesses( |
| SandboxGetProcessesCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetProcesses, base::Unretained(this), |
| std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetProcesses( |
| SandboxGetProcessesCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| std::vector<base::ProcessId> processes; |
| bool result = chrome_cleaner_sandbox::SandboxGetProcesses(&processes); |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, std::move(processes))); |
| } |
| |
| void EngineRequestsImpl::SandboxGetTasks( |
| SandboxGetTasksCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetTasks, base::Unretained(this), |
| std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetTasks(SandboxGetTasksCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| |
| std::vector<TaskScheduler::TaskInfo> tasks; |
| bool result = chrome_cleaner_sandbox::SandboxGetTasks(&tasks); |
| |
| std::vector<mojom::ScheduledTaskPtr> mojo_tasks; |
| for (TaskScheduler::TaskInfo& task : tasks) { |
| std::vector<mojom::ScheduledTaskActionPtr> mojo_actions; |
| for (TaskScheduler::TaskExecAction& action : task.exec_actions) { |
| auto mojo_action = mojom::ScheduledTaskAction::New( |
| std::move(action.application_path), std::move(action.working_dir), |
| std::move(action.arguments)); |
| mojo_actions.push_back(std::move(mojo_action)); |
| } |
| auto mojo_task = mojom::ScheduledTask::New(std::move(task.name), |
| std::move(task.description), |
| std::move(mojo_actions)); |
| mojo_tasks.push_back(std::move(mojo_task)); |
| } |
| |
| mojo_task_runner_->PostTask(FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, |
| std::move(mojo_tasks))); |
| } |
| |
| void EngineRequestsImpl::SandboxGetProcessImagePath( |
| base::ProcessId pid, |
| SandboxGetProcessImagePathCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetProcessImagePath, |
| base::Unretained(this), pid, std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetProcessImagePath( |
| base::ProcessId pid, |
| SandboxGetProcessImagePathCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| base::FilePath image_path; |
| bool result = |
| chrome_cleaner_sandbox::SandboxGetProcessImagePath(pid, &image_path); |
| |
| mojo_task_runner_->PostTask(FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, |
| std::move(image_path))); |
| } |
| |
| void EngineRequestsImpl::SandboxGetLoadedModules( |
| base::ProcessId pid, |
| SandboxGetLoadedModulesCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetLoadedModules, |
| base::Unretained(this), pid, std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetLoadedModules( |
| base::ProcessId pid, |
| SandboxGetLoadedModulesCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| std::set<std::wstring> modules; |
| bool result = chrome_cleaner_sandbox::SandboxGetLoadedModules(pid, &modules); |
| |
| std::vector<std::wstring> modules_list(modules.begin(), modules.end()); |
| mojo_task_runner_->PostTask(FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, |
| std::move(modules_list))); |
| } |
| |
| void EngineRequestsImpl::SandboxGetProcessCommandLine( |
| base::ProcessId pid, |
| SandboxGetProcessCommandLineCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetProcessCommandLine, |
| base::Unretained(this), pid, std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetProcessCommandLine( |
| base::ProcessId pid, |
| SandboxGetProcessCommandLineCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| |
| std::wstring command_line; |
| bool result = |
| chrome_cleaner_sandbox::SandboxGetProcessCommandLine(pid, &command_line); |
| |
| mojo_task_runner_->PostTask(FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, |
| std::move(command_line))); |
| } |
| |
| void EngineRequestsImpl::SandboxGetUserInfoFromSID( |
| mojom::StringSidPtr string_sid, |
| SandboxGetUserInfoFromSIDCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::GetUserInfoFromSID, |
| base::Unretained(this), std::move(string_sid), |
| std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::GetUserInfoFromSID( |
| mojom::StringSidPtr string_sid, |
| SandboxGetUserInfoFromSIDCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| |
| PSID sid = nullptr; |
| if (!::ConvertStringSidToSid(string_sid->value.c_str(), &sid)) { |
| PLOG(ERROR) << "Failed to convert string sid to sid"; |
| } |
| mojom::UserInformationPtr user_info = mojom::UserInformation::New(); |
| bool result = chrome_cleaner_sandbox::SandboxGetUserInfoFromSID( |
| static_cast<SID*>(sid), user_info.get()); |
| ::LocalFree(sid); |
| |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(result_callback), result, std::move(user_info))); |
| } |
| |
| void EngineRequestsImpl::SandboxOpenReadOnlyRegistry( |
| HANDLE root_key_handle, |
| const std::wstring& sub_key, |
| uint32_t dw_access, |
| SandboxOpenReadOnlyRegistryCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::OpenReadOnlyRegistry, |
| base::Unretained(this), root_key_handle, sub_key, |
| dw_access, std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::OpenReadOnlyRegistry( |
| HANDLE root_key_handle, |
| const std::wstring& sub_key, |
| uint32_t dw_access, |
| SandboxOpenReadOnlyRegistryCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| HKEY handle; |
| uint32_t return_code = chrome_cleaner_sandbox::SandboxOpenReadOnlyRegistry( |
| root_key_handle, sub_key, dw_access, &handle); |
| |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(ForwardOpenRegistryResult, std::move(result_callback), |
| return_code, handle)); |
| |
| // Close handles as Mojo doesn't own them. ForwardOpenRegistryResult will |
| // close result handle. |
| // TODO(veranika): clearly define ownership and find a better fix. |
| CloseRegistryHandle(root_key_handle); |
| } |
| |
| void EngineRequestsImpl::SandboxNtOpenReadOnlyRegistry( |
| HANDLE root_key_handle, |
| const WStringEmbeddedNulls& sub_key, |
| uint32_t dw_access, |
| SandboxNtOpenReadOnlyRegistryCallback result_callback) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock()}, |
| base::BindOnce(&EngineRequestsImpl::NtOpenReadOnlyRegistry, |
| base::Unretained(this), root_key_handle, sub_key, |
| dw_access, std::move(result_callback))); |
| } |
| |
| void EngineRequestsImpl::NtOpenReadOnlyRegistry( |
| HANDLE root_key_handle, |
| const WStringEmbeddedNulls& sub_key, |
| uint32_t dw_access, |
| SandboxNtOpenReadOnlyRegistryCallback result_callback) { |
| if (metadata_observer_) |
| metadata_observer_->ObserveCall(CURRENT_FILE_AND_METHOD); |
| |
| HANDLE handle; |
| uint32_t return_code = chrome_cleaner_sandbox::SandboxNtOpenReadOnlyRegistry( |
| root_key_handle, sub_key, dw_access, &handle); |
| |
| mojo_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(ForwardNtOpenRegistryResult, std::move(result_callback), |
| return_code, handle)); |
| |
| // Close handles as Mojo doesn't own them. ForwardOpenRegistryResult will |
| // close result handle. |
| // TODO(veranika): clearly define ownership and find a better fix. |
| CloseRegistryHandle(root_key_handle); |
| } |
| |
| } // namespace chrome_cleaner |
