blob: 13ca3210c41c9fe9366daefc8d9bdf41fc760cf8 [file] [log] [blame]
// Copyright 2018 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/os/file_remover.h"
#include <stdint.h>
#include <memory>
#include <utility>
#include "base/base_paths.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/memory/scoped_refptr.h"
#include "base/message_loop/message_loop.h"
#include "base/path_service.h"
#include "base/strings/strcat.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/multiprocess_test.h"
#include "base/test/scoped_path_override.h"
#include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
#include "chrome/chrome_cleaner/logging/proto/removal_status.pb.h"
#include "chrome/chrome_cleaner/os/disk_util.h"
#include "chrome/chrome_cleaner/os/file_removal_status_updater.h"
#include "chrome/chrome_cleaner/os/layered_service_provider_wrapper.h"
#include "chrome/chrome_cleaner/os/pre_fetched_paths.h"
#include "chrome/chrome_cleaner/os/system_util.h"
#include "chrome/chrome_cleaner/os/whitelisted_directory.h"
#include "chrome/chrome_cleaner/test/file_remover_test_util.h"
#include "chrome/chrome_cleaner/test/reboot_deletion_helper.h"
#include "chrome/chrome_cleaner/test/resources/grit/test_resources.h"
#include "chrome/chrome_cleaner/test/test_file_util.h"
#include "chrome/chrome_cleaner/test/test_layered_service_provider.h"
#include "chrome/chrome_cleaner/test/test_strings.h"
#include "chrome/chrome_cleaner/test/test_util.h"
#include "chrome/chrome_cleaner/zip_archiver/broker/sandbox_setup.h"
#include "chrome/chrome_cleaner/zip_archiver/sandboxed_zip_archiver.h"
#include "chrome/chrome_cleaner/zip_archiver/target/sandbox_setup.h"
#include "components/chrome_cleaner/test/test_name_helper.h"
#include "sandbox/win/src/sandbox.h"
#include "sandbox/win/src/sandbox_factory.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"
namespace chrome_cleaner {
namespace {
using testing::_;
using testing::Eq;
using testing::Return;
using ValidationStatus = FileRemoverAPI::DeletionValidationStatus;
const wchar_t kRemoveFile1[] = L"remove_one.exe";
const wchar_t kRemoveFile2[] = L"remove_two.exe";
const wchar_t kRemoveFolder[] = L"remove";
class FileRemoverTest : public ::testing::Test {
protected:
FileRemoverTest()
: default_file_remover_(
/*digest_verifier=*/nullptr,
/*archiver=*/nullptr,
LayeredServiceProviderWrapper(),
/*deletion_allowed_paths=*/{},
base::BindRepeating(&FileRemoverTest::RebootRequired,
base::Unretained(this))) {
FileRemovalStatusUpdater::GetInstance()->Clear();
}
void RebootRequired() { reboot_required_ = true; }
void TestBlacklistedRemoval(FileRemover* remover,
const base::FilePath& path) {
DCHECK(remover);
EXPECT_EQ(ValidationStatus::FORBIDDEN, remover->CanRemove(path));
FileRemovalStatusUpdater* removal_status_updater =
FileRemovalStatusUpdater::GetInstance();
VerifyRemoveNowFailure(path, remover);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
removal_status_updater->Clear();
VerifyRegisterPostRebootRemovalFailure(path, remover);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
EXPECT_TRUE(base::PathExists(path));
EXPECT_FALSE(IsFileRegisteredForPostRebootRemoval(path));
}
FileRemover default_file_remover_;
base::MessageLoop message_loop_;
bool reboot_required_ = false;
};
} // namespace
TEST_F(FileRemoverTest, RemoveNowValidFile) {
// Create a temporary empty file.
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
const base::FilePath file_path = temp.GetPath().Append(kRemoveFile1);
EXPECT_TRUE(CreateEmptyFile(file_path));
// Removing it must succeed.
VerifyRemoveNowSuccess(file_path, &default_file_remover_);
EXPECT_FALSE(base::PathExists(file_path));
EXPECT_EQ(
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(file_path),
REMOVAL_STATUS_REMOVED);
}
TEST_F(FileRemoverTest, RemoveNowAbsentFile) {
// Create a non-existing file name.
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
FileRemovalStatusUpdater* removal_status_updater =
FileRemovalStatusUpdater::GetInstance();
const base::FilePath file_path = temp.GetPath().Append(kRemoveFile1);
EXPECT_FALSE(base::PathExists(file_path));
// Removing it must not generate an error.
VerifyRemoveNowSuccess(file_path, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path),
REMOVAL_STATUS_NOT_FOUND);
// Ensure the non-existant files with non-existant parents don't generate an
// error.
base::FilePath file_path_deeper = file_path.Append(kRemoveFile2);
VerifyRemoveNowSuccess(file_path_deeper, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path_deeper),
REMOVAL_STATUS_NOT_FOUND);
}
TEST_F(FileRemoverTest, NoKnownFileRemoval) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FileRemover remover(
DigestVerifier::CreateFromResource(IDS_TEST_SAMPLE_DLL_DIGEST),
/*archiver=*/nullptr, LayeredServiceProviderWrapper(),
/*deletion_allowed_paths=*/{}, base::DoNothing::Repeatedly());
// Copy the sample DLL to the temp folder.
base::FilePath dll_path = GetSampleDLLPath();
ASSERT_TRUE(base::PathExists(dll_path)) << dll_path.value();
base::FilePath target_dll_path(
temp_dir.GetPath().Append(dll_path.BaseName()));
ASSERT_TRUE(base::CopyFile(dll_path, target_dll_path));
TestBlacklistedRemoval(&remover, target_dll_path);
}
TEST_F(FileRemoverTest, NoSelfRemoval) {
base::FilePath exe_path = PreFetchedPaths::GetInstance()->GetExecutablePath();
TestBlacklistedRemoval(&default_file_remover_, exe_path);
}
TEST_F(FileRemoverTest, NoWhitelistedFileRemoval) {
base::FilePath program_files_dir =
PreFetchedPaths::GetInstance()->GetProgramFilesFolder();
TestBlacklistedRemoval(&default_file_remover_, program_files_dir);
}
TEST_F(FileRemoverTest, NoWhitelistFileTempRemoval) {
base::FilePath temp_dir;
ASSERT_TRUE(base::PathService::Get(base::DIR_TEMP, &temp_dir));
TestBlacklistedRemoval(&default_file_remover_, temp_dir);
}
TEST_F(FileRemoverTest, NoLSPRemoval) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath provider_path = temp.GetPath().Append(kRemoveFile1);
ASSERT_TRUE(CreateEmptyFile(provider_path));
TestLayeredServiceProvider lsp;
lsp.AddProvider(kGUID1, provider_path);
FileRemover remover(/*digest_verifier=*/nullptr, /*archiver=*/nullptr, lsp,
/*deletion_allowed_paths=*/{},
base::DoNothing::Repeatedly());
TestBlacklistedRemoval(&remover, provider_path);
}
TEST_F(FileRemoverTest, CanRemoveAbsolutePath) {
EXPECT_EQ(ValidationStatus::ALLOWED,
default_file_remover_.CanRemove(base::FilePath(L"C:\\foo\\bar")));
}
TEST_F(FileRemoverTest, NoRelativePathRemoval) {
EXPECT_EQ(ValidationStatus::FORBIDDEN,
default_file_remover_.CanRemove(base::FilePath(L"bar.txt")));
}
TEST_F(FileRemoverTest, NoDriveRemoval) {
EXPECT_EQ(ValidationStatus::FORBIDDEN,
default_file_remover_.CanRemove(base::FilePath(L"C:")));
EXPECT_EQ(ValidationStatus::FORBIDDEN,
default_file_remover_.CanRemove(base::FilePath(L"C:\\")));
}
TEST_F(FileRemoverTest, NoPathTraversal) {
EXPECT_EQ(
ValidationStatus::FORBIDDEN,
default_file_remover_.CanRemove(base::FilePath(L"C:\\foo\\..\\bar")));
EXPECT_EQ(
ValidationStatus::FORBIDDEN,
default_file_remover_.CanRemove(base::FilePath(L"..\\foo\\bar.dll")));
}
TEST_F(FileRemoverTest, CorrectPathTraversalDetection) {
EXPECT_EQ(
ValidationStatus::ALLOWED,
default_file_remover_.CanRemove(base::FilePath(L"C:\\foo\\..bar.dll")));
EXPECT_EQ(
ValidationStatus::ALLOWED,
default_file_remover_.CanRemove(base::FilePath(L"C:\\foo\\bar..dll")));
EXPECT_EQ(
ValidationStatus::ALLOWED,
default_file_remover_.CanRemove(base::FilePath(L"C:\\foo..\\bar.dll")));
}
TEST_F(FileRemoverTest, RemoveNowDoesNotDeleteFolders) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
// Create the folder and the files.
base::FilePath subfolder_path = temp.GetPath().Append(kRemoveFolder);
base::CreateDirectory(subfolder_path);
base::FilePath file_path1 = subfolder_path.Append(kRemoveFile1);
ASSERT_TRUE(CreateEmptyFile(file_path1));
// The folder should not be removed.
VerifyRemoveNowFailure(subfolder_path, &default_file_remover_);
EXPECT_EQ(
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(subfolder_path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
EXPECT_TRUE(base::PathExists(subfolder_path));
EXPECT_TRUE(base::PathExists(file_path1));
}
TEST_F(FileRemoverTest, RemoveNowDeletesEmptyFolders) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
// Create the folder and the files.
base::FilePath subfolder_path = temp.GetPath().Append(kRemoveFolder);
base::CreateDirectory(subfolder_path);
base::FilePath file_path1 = subfolder_path.Append(kRemoveFile1);
ASSERT_TRUE(CreateEmptyFile(file_path1));
base::FilePath subsubfolder_path = subfolder_path.Append(kRemoveFolder);
base::CreateDirectory(subsubfolder_path);
base::FilePath file_path2 = subsubfolder_path.Append(kRemoveFile2);
ASSERT_TRUE(CreateEmptyFile(file_path2));
FileRemovalStatusUpdater* removal_status_updater =
FileRemovalStatusUpdater::GetInstance();
// Delete a file in a folder with other stuff, so the folder isn't deleted.
VerifyRemoveNowSuccess(file_path1, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path1),
REMOVAL_STATUS_REMOVED);
EXPECT_TRUE(base::PathExists(subfolder_path));
EXPECT_FALSE(base::PathExists(file_path1));
EXPECT_TRUE(base::PathExists(subsubfolder_path));
EXPECT_TRUE(base::PathExists(file_path2));
// Delete the file and ensure the two parent folders are deleted since they
// are now empty.
VerifyRemoveNowSuccess(file_path2, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path2),
REMOVAL_STATUS_REMOVED);
EXPECT_FALSE(base::PathExists(subfolder_path));
EXPECT_FALSE(base::PathExists(subsubfolder_path));
EXPECT_FALSE(base::PathExists(file_path2));
}
TEST_F(FileRemoverTest, RemoveNowDeletesEmptyFoldersNotTemp) {
base::ScopedPathOverride temp_override(base::DIR_TEMP);
base::FilePath scoped_temp_dir;
ASSERT_TRUE(base::PathService::Get(base::DIR_TEMP, &scoped_temp_dir));
// Create a file in temp.
base::FilePath file_path = scoped_temp_dir.Append(kRemoveFile1);
ASSERT_TRUE(CreateEmptyFile(file_path));
// Delete the file and ensure Temp isn't deleted since it is whitelisted.
VerifyRemoveNowSuccess(file_path, &default_file_remover_);
EXPECT_EQ(
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(file_path),
REMOVAL_STATUS_REMOVED);
EXPECT_FALSE(base::PathExists(file_path));
base::FilePath temp_dir;
ASSERT_TRUE(base::GetTempDir(&temp_dir));
EXPECT_TRUE(base::PathExists(temp_dir));
}
TEST_F(FileRemoverTest, RegisterPostRebootRemoval) {
FileRemovalStatusUpdater* removal_status_updater =
FileRemovalStatusUpdater::GetInstance();
// When trying to delete a whitelisted file, we should fail to register the
// file for removal, and no reboot should be required.
base::FilePath exe_path = PreFetchedPaths::GetInstance()->GetExecutablePath();
VerifyRegisterPostRebootRemovalFailure(exe_path, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(exe_path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
EXPECT_FALSE(reboot_required_);
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath file_path = temp.GetPath().Append(kRemoveFile2);
// When trying to delete an non-existant file, we should return success, but
// not require a reboot.
VerifyRegisterPostRebootRemovalSuccess(file_path, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path),
REMOVAL_STATUS_NOT_FOUND);
EXPECT_FALSE(reboot_required_);
// When trying to delete a real file, we should return success and require a
// reboot.
ASSERT_TRUE(CreateEmptyFile(file_path));
VerifyRegisterPostRebootRemovalSuccess(file_path, &default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(file_path),
REMOVAL_STATUS_SCHEDULED_FOR_REMOVAL);
EXPECT_TRUE(reboot_required_);
EXPECT_TRUE(IsFileRegisteredForPostRebootRemoval(file_path));
}
TEST_F(FileRemoverTest, RegisterPostRebootRemoval_Directories) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
// Create an empty directory.
base::FilePath subfolder_path = temp.GetPath().Append(kRemoveFolder);
ASSERT_TRUE(base::CreateDirectory(subfolder_path));
FileRemovalStatusUpdater* removal_status_updater =
FileRemovalStatusUpdater::GetInstance();
// Directories shouldn't be registered for deletion.
VerifyRegisterPostRebootRemovalFailure(subfolder_path,
&default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(subfolder_path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
// Put a file into the directory and ensure the non-empty directory still
// isn't registered for removal.
removal_status_updater->Clear();
base::FilePath file_path1 = subfolder_path.Append(kRemoveFile1);
ASSERT_TRUE(CreateEmptyFile(file_path1));
VerifyRegisterPostRebootRemovalFailure(subfolder_path,
&default_file_remover_);
EXPECT_EQ(removal_status_updater->GetRemovalStatus(subfolder_path),
REMOVAL_STATUS_BLACKLISTED_FOR_REMOVAL);
}
TEST_F(FileRemoverTest, NotActiveFileType) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath path = temp.GetPath().Append(L"temp_file.txt");
ASSERT_TRUE(
CreateFileInFolder(path.DirName(), path.BaseName().value().c_str()));
EXPECT_EQ(ValidationStatus::INACTIVE,
FileRemover::IsFileRemovalAllowed(path, {}, {}));
VerifyRemoveNowSuccess(path, &default_file_remover_);
EXPECT_EQ(REMOVAL_STATUS_NOT_REMOVED_INACTIVE_EXTENSION,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_TRUE(base::PathExists(path));
}
TEST_F(FileRemoverTest, NotActiveFileAllowed) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath path = temp.GetPath().Append(L"temp_file.txt");
ASSERT_TRUE(
CreateFileInFolder(path.DirName(), path.BaseName().value().c_str()));
FileRemover remover(/*digest_verifier=*/nullptr, /*archiver=*/nullptr,
LayeredServiceProviderWrapper(), {path.value().c_str()},
base::DoNothing::Repeatedly());
EXPECT_EQ(ValidationStatus::ALLOWED, FileRemover::IsFileRemovalAllowed(
path, {path.value().c_str()}, {}));
VerifyRemoveNowSuccess(path, &remover);
EXPECT_EQ(REMOVAL_STATUS_REMOVED,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_FALSE(base::PathExists(path));
}
TEST_F(FileRemoverTest, DosMzExecutable) {
base::ScopedTempDir temp;
ASSERT_TRUE(temp.CreateUniqueTempDir());
base::FilePath path = temp.GetPath().Append(L"temp_file.txt");
constexpr char kMzExecutable[] = "MZ executable";
CreateFileWithContent(path, kMzExecutable, sizeof(kMzExecutable));
ASSERT_TRUE(base::PathExists(path));
FileRemover remover(/*digest_verifier=*/nullptr, /*archiver=*/nullptr,
LayeredServiceProviderWrapper(), {path.value().c_str()},
base::DoNothing::Repeatedly());
EXPECT_EQ(ValidationStatus::ALLOWED,
FileRemover::IsFileRemovalAllowed(path, {}, {}));
VerifyRemoveNowSuccess(path, &remover);
EXPECT_EQ(REMOVAL_STATUS_REMOVED,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_FALSE(base::PathExists(path));
}
namespace {
constexpr char kTestPassword[] = "1234";
constexpr char kTestContent[] = "Hello World";
constexpr wchar_t kTestFileName[] = L"temp_file.exe";
constexpr wchar_t kTestExpectArchiveName[] =
L"temp_file.exe_"
L"A591A6D40BF420404A011733CFB7B190D62C65BF0BCDA32B57B277D9AD9F146E.zip";
class FileRemoverQuarantineTest : public base::MultiProcessTest,
public ::testing::WithParamInterface<bool> {
public:
void SetUp() override {
use_reboot_removal_ = GetParam();
scoped_refptr<MojoTaskRunner> mojo_task_runner = MojoTaskRunner::Create();
ZipArchiverSandboxSetupHooks setup_hooks(
mojo_task_runner.get(), base::BindOnce([] {
FAIL() << "ZipArchiver sandbox connection error";
}));
ASSERT_EQ(RESULT_CODE_SUCCESS,
StartSandboxTarget(MakeCmdLine("FileRemoverQuarantineTargetMain"),
&setup_hooks, SandboxType::kTest));
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
auto zip_archiver = std::make_unique<SandboxedZipArchiver>(
mojo_task_runner, setup_hooks.TakeZipArchiverPtr(), temp_dir_.GetPath(),
kTestPassword);
file_remover_ = std::make_unique<FileRemover>(
/*digest_verifier=*/nullptr, std::move(zip_archiver),
LayeredServiceProviderWrapper(), FilePathSet(),
base::DoNothing::Repeatedly());
}
protected:
// Do removal corresponding to |use_reboot_removal_|. Also do corresponding
// check for file existence and removal status.
void DoAndExpectCorrespondingRemoval(const base::FilePath& path) {
if (use_reboot_removal_) {
VerifyRegisterPostRebootRemovalSuccess(path, file_remover_.get());
EXPECT_EQ(
REMOVAL_STATUS_SCHEDULED_FOR_REMOVAL,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_TRUE(base::PathExists(path));
} else {
VerifyRemoveNowSuccess(path, file_remover_.get());
EXPECT_EQ(
REMOVAL_STATUS_REMOVED,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_FALSE(base::PathExists(path));
}
return;
}
bool use_reboot_removal_ = false;
base::MessageLoop message_loop_;
base::ScopedTempDir temp_dir_;
std::unique_ptr<FileRemover> file_remover_;
};
} // namespace
MULTIPROCESS_TEST_MAIN(FileRemoverQuarantineTargetMain) {
sandbox::TargetServices* sandbox_target_services =
sandbox::SandboxFactory::GetTargetServices();
DCHECK(sandbox_target_services);
// |RunZipArchiverSandboxTarget| won't return. The mojo error handler will
// abort this process when the connection is broken.
RunZipArchiverSandboxTarget(*base::CommandLine::ForCurrentProcess(),
sandbox_target_services);
return 0;
}
TEST_P(FileRemoverQuarantineTest, QuarantineFile) {
const base::FilePath path = temp_dir_.GetPath().Append(kTestFileName);
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
DoAndExpectCorrespondingRemoval(path);
EXPECT_EQ(QUARANTINE_STATUS_QUARANTINED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(path));
const base::FilePath expected_archive_path =
temp_dir_.GetPath().Append(kTestExpectArchiveName);
EXPECT_TRUE(base::PathExists(expected_archive_path));
}
TEST_P(FileRemoverQuarantineTest, FailToQuarantine) {
const base::FilePath path = temp_dir_.GetPath().Append(kTestFileName);
// Acquire exclusive read access to the file, so the archiver can't open the
// file.
base::File file(path, base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_EXCLUSIVE_READ);
ASSERT_TRUE(file.IsValid());
(use_reboot_removal_)
? VerifyRegisterPostRebootRemovalFailure(path, file_remover_.get())
: VerifyRemoveNowFailure(path, file_remover_.get());
EXPECT_EQ(REMOVAL_STATUS_ERROR_IN_ARCHIVER,
FileRemovalStatusUpdater::GetInstance()->GetRemovalStatus(path));
EXPECT_EQ(QUARANTINE_STATUS_ERROR,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(path));
EXPECT_TRUE(base::PathExists(path));
}
TEST_P(FileRemoverQuarantineTest, DuplicatedFile) {
const base::FilePath path = temp_dir_.GetPath().Append(kTestFileName);
const base::FilePath expected_archive_path =
temp_dir_.GetPath().Append(kTestExpectArchiveName);
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
DoAndExpectCorrespondingRemoval(path);
EXPECT_EQ(QUARANTINE_STATUS_QUARANTINED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(path));
EXPECT_TRUE(base::PathExists(expected_archive_path));
// The file should not be archived twice if there is already one with the same
// name and content in the quarantine. So the modified time of the archive
// should not be updated.
base::File::Info old_info;
ASSERT_TRUE(base::GetFileInfo(expected_archive_path, &old_info));
// Recreate the source file and remove it again.
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
DoAndExpectCorrespondingRemoval(path);
// Although the file won't be archived again, it still has a backup in the
// quarantine. So the status should be |QUARANTINE_STATUS_QUARANTINED|.
EXPECT_EQ(QUARANTINE_STATUS_QUARANTINED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(path));
EXPECT_TRUE(base::PathExists(expected_archive_path));
base::File::Info new_info;
ASSERT_TRUE(base::GetFileInfo(expected_archive_path, &new_info));
EXPECT_EQ(old_info.last_modified, new_info.last_modified);
}
TEST_P(FileRemoverQuarantineTest, DoNotQuarantineSymbolicLink) {
const base::FilePath path = temp_dir_.GetPath().Append(L"source_temp_file");
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
const base::FilePath sym_path = temp_dir_.GetPath().Append(kTestFileName);
ASSERT_NE(0, ::CreateSymbolicLink(sym_path.AsUTF16Unsafe().c_str(),
path.AsUTF16Unsafe().c_str(), 0));
DoAndExpectCorrespondingRemoval(sym_path);
EXPECT_EQ(
QUARANTINE_STATUS_SKIPPED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(sym_path));
const base::FilePath expected_archive_path =
temp_dir_.GetPath().Append(kTestExpectArchiveName);
EXPECT_FALSE(base::PathExists(expected_archive_path));
// The original file should exist.
EXPECT_TRUE(base::PathExists(path));
}
TEST_P(FileRemoverQuarantineTest, QuarantineDefaultFileStream) {
const base::FilePath path = temp_dir_.GetPath().Append(kTestFileName);
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
base::FilePath stream_path(base::StrCat({path.AsUTF16Unsafe(), L"::$data"}));
CreateFileWithContent(stream_path, kTestContent, strlen(kTestContent));
DoAndExpectCorrespondingRemoval(stream_path);
EXPECT_EQ(QUARANTINE_STATUS_QUARANTINED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(
stream_path));
const base::FilePath expected_archive_path =
temp_dir_.GetPath().Append(kTestExpectArchiveName);
EXPECT_TRUE(base::PathExists(expected_archive_path));
}
TEST_P(FileRemoverQuarantineTest, DoNotQuarantineNonDefaultFileStream) {
const base::FilePath path = temp_dir_.GetPath().Append(kTestFileName);
CreateFileWithContent(path, kTestContent, strlen(kTestContent));
base::FilePath stream_path(
base::StrCat({path.AsUTF16Unsafe(), L":stream:$data"}));
CreateFileWithContent(stream_path, kTestContent, strlen(kTestContent));
DoAndExpectCorrespondingRemoval(stream_path);
EXPECT_EQ(QUARANTINE_STATUS_SKIPPED,
FileRemovalStatusUpdater::GetInstance()->GetQuarantineStatus(
stream_path));
}
INSTANTIATE_TEST_SUITE_P(All,
FileRemoverQuarantineTest,
testing::Bool(),
GetParamNameForTest());
} // namespace chrome_cleaner