diff options
Diffstat (limited to 'chrome_elf/create_file')
| -rw-r--r-- | chrome_elf/create_file/chrome_create_file.cc | 279 | ||||
| -rw-r--r-- | chrome_elf/create_file/chrome_create_file.h | 38 | ||||
| -rw-r--r-- | chrome_elf/create_file/chrome_create_file_unittest.cc | 391 |
3 files changed, 708 insertions, 0 deletions
diff --git a/chrome_elf/create_file/chrome_create_file.cc b/chrome_elf/create_file/chrome_create_file.cc new file mode 100644 index 0000000..a39cd3e --- /dev/null +++ b/chrome_elf/create_file/chrome_create_file.cc @@ -0,0 +1,279 @@ +// Copyright 2014 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_elf/create_file/chrome_create_file.h" + +#include <string> + +#include "base/strings/string16.h" +#include "chrome_elf/chrome_elf_constants.h" +#include "chrome_elf/ntdll_cache.h" +#include "sandbox/win/src/nt_internals.h" + +namespace { + +// From ShlObj.h in the Windows SDK. +#define CSIDL_LOCAL_APPDATA 0x001c + +typedef BOOL (WINAPI *PathIsUNCFunction)( + IN LPCWSTR path); + +typedef BOOL (WINAPI *PathAppendFunction)( + IN LPWSTR path, + IN LPCWSTR more); + +typedef BOOL (WINAPI *PathIsPrefixFunction)( + IN LPCWSTR prefix, + IN LPCWSTR path); + +typedef LPCWSTR (WINAPI *PathFindFileName)( + IN LPCWSTR path); + +typedef HRESULT (WINAPI *SHGetFolderPathFunction)( + IN HWND hwnd_owner, + IN int folder, + IN HANDLE token, + IN DWORD flags, + OUT LPWSTR path); + +PathIsUNCFunction g_path_is_unc_func; +PathAppendFunction g_path_append_func; +PathIsPrefixFunction g_path_is_prefix_func; +PathFindFileName g_path_find_filename_func; +SHGetFolderPathFunction g_get_folder_func; + +// Populates the g_*_func pointers to functions which will be used in +// ShouldBypass(). Chrome_elf cannot have a load-time dependency on shell32 or +// shlwapi as this would induce a load-time dependency on user32.dll. Instead, +// the addresses of the functions we need are retrieved the first time this +// method is called, and cached to avoid subsequent calls to GetProcAddress(). +// It is assumed that the host process will never unload these functions. +// Returns true if all the functions needed are present. +bool PopulateShellFunctions() { + // Early exit if functions have already been populated. + if (g_path_is_unc_func && g_path_append_func && + g_path_is_prefix_func && g_get_folder_func) { + return true; + } + + // Get the addresses of the functions we need and store them for future use. + // These handles are intentionally leaked to ensure that these modules do not + // get unloaded. + HMODULE shell32 = ::LoadLibrary(L"shell32.dll"); + HMODULE shlwapi = ::LoadLibrary(L"shlwapi.dll"); + + if (!shlwapi || !shell32) + return false; + + g_path_is_unc_func = reinterpret_cast<PathIsUNCFunction>( + ::GetProcAddress(shlwapi, "PathIsUNCW")); + g_path_append_func = reinterpret_cast<PathAppendFunction>( + ::GetProcAddress(shlwapi, "PathAppendW")); + g_path_is_prefix_func = reinterpret_cast<PathIsPrefixFunction>( + ::GetProcAddress(shlwapi, "PathIsPrefixW")); + g_path_find_filename_func = reinterpret_cast<PathFindFileName>( + ::GetProcAddress(shlwapi, "PathFindFileNameW")); + g_get_folder_func = reinterpret_cast<SHGetFolderPathFunction>( + ::GetProcAddress(shell32, "SHGetFolderPathW")); + + return g_path_is_unc_func && g_path_append_func && g_path_is_prefix_func && + g_path_find_filename_func && g_get_folder_func; +} + +} // namespace + +HANDLE WINAPI CreateFileWRedirect( + LPCWSTR file_name, + DWORD desired_access, + DWORD share_mode, + LPSECURITY_ATTRIBUTES security_attributes, + DWORD creation_disposition, + DWORD flags_and_attributes, + HANDLE template_file) { + if (ShouldBypass(file_name)) { + return CreateFileNTDLL(file_name, + desired_access, + share_mode, + security_attributes, + creation_disposition, + flags_and_attributes, + template_file); + } + return CreateFile(file_name, + desired_access, + share_mode, + security_attributes, + creation_disposition, + flags_and_attributes, + template_file); + +} + +HANDLE CreateFileNTDLL( + LPCWSTR file_name, + DWORD desired_access, + DWORD share_mode, + LPSECURITY_ATTRIBUTES security_attributes, + DWORD creation_disposition, + DWORD flags_and_attributes, + HANDLE template_file) { + HANDLE file_handle = INVALID_HANDLE_VALUE; + NTSTATUS result = STATUS_UNSUCCESSFUL; + IO_STATUS_BLOCK io_status_block = {}; + ULONG flags = 0; + + // Convert from Win32 domain to to NT creation disposition values. + switch (creation_disposition) { + case CREATE_NEW: + creation_disposition = FILE_CREATE; + break; + case CREATE_ALWAYS: + creation_disposition = FILE_OVERWRITE_IF; + break; + case OPEN_EXISTING: + creation_disposition = FILE_OPEN; + break; + case OPEN_ALWAYS: + creation_disposition = FILE_OPEN_IF; + break; + case TRUNCATE_EXISTING: + creation_disposition = FILE_OVERWRITE; + break; + default: + SetLastError(ERROR_INVALID_PARAMETER); + return INVALID_HANDLE_VALUE; + } + + // Translate the flags that need no validation: + if (!(flags_and_attributes & FILE_FLAG_OVERLAPPED)) + flags |= FILE_SYNCHRONOUS_IO_NONALERT; + + if (flags_and_attributes & FILE_FLAG_WRITE_THROUGH) + flags |= FILE_WRITE_THROUGH; + + if (flags_and_attributes & FILE_FLAG_RANDOM_ACCESS) + flags |= FILE_RANDOM_ACCESS; + + if (flags_and_attributes & FILE_FLAG_SEQUENTIAL_SCAN) + flags |= FILE_SEQUENTIAL_ONLY; + + if (flags_and_attributes & FILE_FLAG_DELETE_ON_CLOSE) { + flags |= FILE_DELETE_ON_CLOSE; + desired_access |= DELETE; + } + + if (flags_and_attributes & FILE_FLAG_BACKUP_SEMANTICS) + flags |= FILE_OPEN_FOR_BACKUP_INTENT; + else + flags |= FILE_NON_DIRECTORY_FILE; + + + if (flags_and_attributes & FILE_FLAG_OPEN_REPARSE_POINT) + flags |= FILE_OPEN_REPARSE_POINT; + + if (flags_and_attributes & FILE_FLAG_OPEN_NO_RECALL) + flags |= FILE_OPEN_NO_RECALL; + + if (!g_ntdll_lookup["NtCreateFile"] || + !g_ntdll_lookup["RtlInitUnicodeString"]) { + return INVALID_HANDLE_VALUE; + } + + NtCreateFileFunction create_file = + reinterpret_cast<NtCreateFileFunction>(g_ntdll_lookup["NtCreateFile"]); + + RtlInitUnicodeStringFunction init_unicode_string = + reinterpret_cast<RtlInitUnicodeStringFunction>( + g_ntdll_lookup["RtlInitUnicodeString"]); + + UNICODE_STRING path_unicode_string; + + // Format the path into an NT path. Arguably this should be done with + // RtlDosPathNameToNtPathName_U, but afaict this is equivalent for + // local paths. Using this with a UNC path name will almost certainly + // break in interesting ways. + base::string16 filename_string(L"\\??\\"); + filename_string += file_name; + + init_unicode_string(&path_unicode_string, filename_string.c_str()); + + OBJECT_ATTRIBUTES path_attributes = {}; + InitializeObjectAttributes(&path_attributes, + &path_unicode_string, + OBJ_CASE_INSENSITIVE, + NULL, // No Root Directory + NULL); // No Security Descriptor + + // Set desired_access, and flags_and_attributes to match those + // set by kernel32!CreateFile. + desired_access |= 0x100080; + flags_and_attributes &= 0x2FFA7; + + result = create_file(&file_handle, + desired_access, + &path_attributes, + &io_status_block, + 0, // Allocation size + flags_and_attributes, + share_mode, + creation_disposition, + flags, + NULL, + 0); + + if (result != STATUS_SUCCESS) { + if (result == STATUS_OBJECT_NAME_COLLISION && + creation_disposition == FILE_CREATE) { + SetLastError(ERROR_FILE_EXISTS); + } + return INVALID_HANDLE_VALUE; + } + + if (creation_disposition == FILE_OPEN_IF) { + SetLastError(io_status_block.Information == FILE_OPENED ? + ERROR_ALREADY_EXISTS : ERROR_SUCCESS); + } else if (creation_disposition == FILE_OVERWRITE_IF) { + SetLastError(io_status_block.Information == FILE_OVERWRITTEN ? + ERROR_ALREADY_EXISTS : ERROR_SUCCESS); + } else { + SetLastError(ERROR_SUCCESS); + } + + return file_handle; +} + +bool ShouldBypass(LPCWSTR file_path) { + // If the shell functions are not present, forward the call to kernel32. + if (!PopulateShellFunctions()) + return false; + + // Forward all UNC filepaths to kernel32. + if (g_path_is_unc_func(file_path)) + return false; + + wchar_t local_appdata_path[MAX_PATH]; + + // Get the %LOCALAPPDATA% Path and append the location of our UserData + // directory to it. + HRESULT appdata_result = g_get_folder_func( + NULL, CSIDL_LOCAL_APPDATA, NULL, 0, local_appdata_path); + + // If getting the %LOCALAPPDATA% path or appending to it failed, then forward + // the call to kernel32. + if (!SUCCEEDED(appdata_result) || + !g_path_append_func(local_appdata_path, kAppDataDirName) || + !g_path_append_func(local_appdata_path, kUserDataDirName)) { + return false; + } + + LPCWSTR file_name = g_path_find_filename_func(file_path); + + bool in_userdata_dir = !!g_path_is_prefix_func(local_appdata_path, file_path); + bool is_settings_file = wcscmp(file_name, kPreferencesFilename) == 0 || + wcscmp(file_name, kLocalStateFilename) == 0; + + // Check if we are trying to access the Preferences in the UserData dir. If + // so, then redirect the call to bypass kernel32. + return in_userdata_dir && is_settings_file; +} diff --git a/chrome_elf/create_file/chrome_create_file.h b/chrome_elf/create_file/chrome_create_file.h new file mode 100644 index 0000000..dac93af --- /dev/null +++ b/chrome_elf/create_file/chrome_create_file.h @@ -0,0 +1,38 @@ +// Copyright 2014 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. + +#ifndef CHROME_ELF_CREATE_FILE_CHROME_CREATE_FILE_H_ +#define CHROME_ELF_CREATE_FILE_CHROME_CREATE_FILE_H_ + +#include <windows.h> + +#include "chrome_elf/chrome_elf_types.h" + +// A CreateFileW replacement that will call NTCreateFile directly when the +// criteria defined in ShouldBypass() are satisfied for |lp_file_name|. +extern "C" HANDLE WINAPI CreateFileWRedirect( + LPCWSTR file_name, + DWORD desired_access, + DWORD share_mode, + LPSECURITY_ATTRIBUTES security_attributes, + DWORD creation_disposition, + DWORD flags_and_attributes, + HANDLE template_file); + +// Partial reimplementation of kernel32!CreateFile (very partial: only handles +// reading and writing to files in the User Data directory). +HANDLE CreateFileNTDLL( + LPCWSTR file_name, + DWORD desired_access, + DWORD share_mode, + LPSECURITY_ATTRIBUTES security_attributes, + DWORD creation_disposition, + DWORD flags_and_attributes, + HANDLE template_file); + +// Determines whether or not we should use our version of CreateFile, or the +// system version (only uses ours if we're writing to the user data directory). +bool ShouldBypass(LPCWSTR file_name); + +#endif // CHROME_ELF_CREATE_FILE_CHROME_CREATE_FILE_H_ diff --git a/chrome_elf/create_file/chrome_create_file_unittest.cc b/chrome_elf/create_file/chrome_create_file_unittest.cc new file mode 100644 index 0000000..e25b159 --- /dev/null +++ b/chrome_elf/create_file/chrome_create_file_unittest.cc @@ -0,0 +1,391 @@ +// Copyright 2014 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_elf/create_file/chrome_create_file.h" + +#include <windows.h> + +#include <bitset> +#include <string> + +#include "base/base_paths_win.h" +#include "base/file_util.h" +#include "base/files/file_path.h" +#include "base/files/scoped_temp_dir.h" +#include "base/path_service.h" +#include "base/threading/platform_thread.h" +#include "base/win/iat_patch_function.h" +#include "base/win/scoped_handle.h" +#include "base/win/windows_version.h" +#include "chrome_elf/chrome_elf_constants.h" +#include "chrome_elf/ntdll_cache.h" +#include "sandbox/win/src/nt_internals.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "testing/platform_test.h" + + +namespace { + +// Test fixtures ------------------------------------------------------------- + +class ChromeCreateFileTest : public PlatformTest { + protected: + struct NtCreateFileParams { + ACCESS_MASK desired_access; + OBJECT_ATTRIBUTES object_attributes; + PLARGE_INTEGER allocation_size; + ULONG file_attributes; + ULONG share_access; + ULONG create_disposition; + ULONG create_options; + PVOID ea_buffer; + ULONG ea_length; + }; + + enum CallPath { + ELF, + KERNEL + }; + + template<CallPath path> + static NTSTATUS WINAPI FakeNtCreateFile( + PHANDLE file_handle, + ACCESS_MASK desired_access, + POBJECT_ATTRIBUTES object_attributes, + PIO_STATUS_BLOCK io_status_block, + PLARGE_INTEGER allocation_size, + ULONG file_attributes, + ULONG share_access, + ULONG create_disposition, + ULONG create_options, + PVOID ea_buffer, + ULONG ea_length) { + return self_->HandleCreateFileCall(file_handle, + desired_access, + object_attributes, + io_status_block, + allocation_size, + file_attributes, + share_access, + create_disposition, + create_options, + ea_buffer, + ea_length, + path); + } + + virtual void SetUp() OVERRIDE { + original_thread_ = base::PlatformThread::CurrentId(); + InitCache(); + PlatformTest::SetUp(); + + base::FilePath user_data_dir; + PathService::Get(base::DIR_LOCAL_APP_DATA, &user_data_dir); + ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(user_data_dir)); + ASSERT_TRUE(temp_dir2_.CreateUniqueTempDir()); + self_ = this; + } + + void RedirectNtCreateFileCalls() { + old_func_ptr_ = + reinterpret_cast<NtCreateFileFunction>(g_ntdll_lookup["NtCreateFile"]); + + // KernelBase.dll only exists for Win7 and later, prior to that, kernel32 + // imports from ntdll directly. + if (base::win::GetVersion() < base::win::VERSION_WIN7) { + patcher_.Patch(L"kernel32.dll", "ntdll.dll", "NtCreateFile", + reinterpret_cast<void(*)()>(&FakeNtCreateFile<KERNEL>)); + } else { + patcher_.Patch(L"kernelbase.dll", "ntdll.dll", "NtCreateFile", + reinterpret_cast<void(*)()>(&FakeNtCreateFile<KERNEL>)); + } + + g_ntdll_lookup["NtCreateFile"] = reinterpret_cast<void(*)()>( + &ChromeCreateFileTest::FakeNtCreateFile<ELF>); + } + + void ResetNtCreateFileCalls() { + g_ntdll_lookup["NtCreateFile"] = reinterpret_cast<void*>(old_func_ptr_); + patcher_.Unpatch(); + } + + NTSTATUS HandleCreateFileCall(PHANDLE file_handle, + ACCESS_MASK desired_access, + POBJECT_ATTRIBUTES object_attributes, + PIO_STATUS_BLOCK io_status_block, + PLARGE_INTEGER allocation_size, + ULONG file_attributes, + ULONG share_access, + ULONG create_disposition, + ULONG create_options, + PVOID ea_buffer, + ULONG ea_length, + CallPath call_path) { + if (original_thread_ == base::PlatformThread::CurrentId()) { + SetParams(desired_access, + object_attributes, + allocation_size, + file_attributes, + share_access, + create_disposition, + create_options, + ea_buffer, + ea_length, + call_path == ELF ? &elf_params_ : &kernel_params_); + } + + // Forward the call to the real NTCreateFile. + return old_func_ptr_(file_handle, + desired_access, + object_attributes, + io_status_block, + allocation_size, + file_attributes, + share_access, + create_disposition, + create_options, + ea_buffer, + ea_length); + } + + void SetParams(ACCESS_MASK desired_access, + POBJECT_ATTRIBUTES object_attributes, + PLARGE_INTEGER allocation_size, + ULONG file_attributes, + ULONG share_access, + ULONG create_disposition, + ULONG create_options, + PVOID ea_buffer, + ULONG ea_length, + NtCreateFileParams* params) { + params->desired_access = desired_access; + params->object_attributes.Length = object_attributes->Length; + params->object_attributes.ObjectName = object_attributes->ObjectName; + params->object_attributes.RootDirectory = object_attributes->RootDirectory; + params->object_attributes.Attributes = object_attributes->Attributes; + params->object_attributes.SecurityDescriptor = + object_attributes->SecurityDescriptor; + params->object_attributes.SecurityQualityOfService = + object_attributes->SecurityQualityOfService; + params->allocation_size = allocation_size; + params->file_attributes = file_attributes; + params->share_access = share_access; + params->create_disposition = create_disposition; + params->create_options = create_options; + params->ea_buffer = ea_buffer; + params->ea_length = ea_length; + } + + void CheckParams() { + std::bitset<32> elf((int) elf_params_.desired_access); + std::bitset<32> ker((int) kernel_params_.desired_access); + + EXPECT_EQ(kernel_params_.desired_access, elf_params_.desired_access) + << elf << "\n" << ker; + EXPECT_EQ(kernel_params_.object_attributes.Length, + elf_params_.object_attributes.Length); + EXPECT_EQ(kernel_params_.object_attributes.RootDirectory, + elf_params_.object_attributes.RootDirectory); + EXPECT_EQ(kernel_params_.object_attributes.Attributes, + elf_params_.object_attributes.Attributes); + EXPECT_EQ(kernel_params_.object_attributes.SecurityDescriptor, + elf_params_.object_attributes.SecurityDescriptor); + EXPECT_EQ(kernel_params_.allocation_size, elf_params_.allocation_size); + EXPECT_EQ(kernel_params_.file_attributes, elf_params_.file_attributes); + EXPECT_EQ(kernel_params_.share_access, elf_params_.share_access); + EXPECT_EQ(kernel_params_.create_disposition, + elf_params_.create_disposition); + EXPECT_EQ(kernel_params_.create_options, elf_params_.create_options); + EXPECT_EQ(kernel_params_.ea_buffer, elf_params_.ea_buffer); + EXPECT_EQ(kernel_params_.ea_length, elf_params_.ea_length); + } + + void DoWriteCheck(const base::FilePath& path, DWORD flag, bool is_system) { + base::win::ScopedHandle file_handle; + const char kTestData[] = "0123456789"; + int buffer_size = sizeof(kTestData) - 1; + DWORD bytes_written; + + if (is_system) { + file_handle.Set(::CreateFileW(path.value().c_str(), + GENERIC_WRITE, + FILE_SHARE_READ, + NULL, + CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | flag, + NULL)); + } else { + file_handle.Set(CreateFileNTDLL(path.value().c_str(), + GENERIC_WRITE, + FILE_SHARE_READ, + NULL, + CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | flag, + NULL)); + } + + + EXPECT_FALSE(file_handle == INVALID_HANDLE_VALUE); + ::WriteFile(file_handle, kTestData, buffer_size, &bytes_written, NULL); + EXPECT_EQ(buffer_size, bytes_written); + } + + void DoReadCheck(const base::FilePath& path, DWORD flag, bool is_system) { + base::win::ScopedHandle file_handle; + const char kTestData[] = "0123456789"; + int buffer_size = sizeof(kTestData) - 1; + DWORD bytes_read; + char read_buffer[10]; + + if (is_system) { + file_handle.Set(::CreateFileW(path.value().c_str(), + GENERIC_READ, + 0, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | flag, + NULL)); + } else { + file_handle.Set(CreateFileNTDLL(path.value().c_str(), + GENERIC_READ, + 0, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | flag, + NULL)); + } + + EXPECT_FALSE(file_handle == INVALID_HANDLE_VALUE); + ::ReadFile(file_handle, read_buffer, buffer_size, &bytes_read, NULL); + EXPECT_EQ(buffer_size, bytes_read); + EXPECT_EQ(0, memcmp(kTestData, read_buffer, bytes_read)); + } + + void RunChecks(DWORD flag, bool check_reads) { + // Make sure we can write to this file handle when called via the system. + base::FilePath junk_path_1 = temp_dir_.path().Append(L"junk_1.txt"); + base::FilePath junk_path_2 = temp_dir_.path().Append(L"junk_2.txt"); + DoWriteCheck(junk_path_1, flag, true); + DoWriteCheck(junk_path_2, flag, false); + CheckParams(); + + if (check_reads) { + // Make sure we can read from this file handle when called via the system. + DoReadCheck(junk_path_1, flag, true); + DoReadCheck(junk_path_2, flag, false); + CheckParams(); + } + base::DeleteFile(junk_path_1, false); + base::DeleteFile(junk_path_2, false); + + } + + static ChromeCreateFileTest* self_; + + NtCreateFileFunction old_func_ptr_; + base::ScopedTempDir temp_dir_; + base::ScopedTempDir temp_dir2_; + base::win::IATPatchFunction patcher_; + NtCreateFileParams kernel_params_; + NtCreateFileParams elf_params_; + base::PlatformThreadId original_thread_; +}; + +ChromeCreateFileTest* ChromeCreateFileTest::self_ = NULL; + +// Tests --------------------------------------------------------------------- +TEST_F(ChromeCreateFileTest, CheckParams_FILE_ATTRIBUTE_NORMAL) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_ATTRIBUTE_NORMAL, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_WRITE_THROUGH) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_WRITE_THROUGH, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_RANDOM_ACCESS) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_RANDOM_ACCESS, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_SEQUENTIAL_SCAN) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_SEQUENTIAL_SCAN, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_DELETE_ON_CLOSE) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_DELETE_ON_CLOSE, false); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_BACKUP_SEMANTICS) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_BACKUP_SEMANTICS, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_OPEN_REPARSE_POINT) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_OPEN_REPARSE_POINT, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, CheckParams_FILE_FLAG_OPEN_NO_RECALL) { + RedirectNtCreateFileCalls(); + RunChecks(FILE_FLAG_OPEN_NO_RECALL, true); + ResetNtCreateFileCalls(); +} + +TEST_F(ChromeCreateFileTest, BypassTest) { + std::wstring UNC_filepath_file(L"\\\\.\\some_file.txt"); + + base::FilePath local_path; + PathService::Get(base::DIR_LOCAL_APP_DATA, &local_path); + + base::FilePath local_prefs_path = local_path.Append(kAppDataDirName).Append( + kUserDataDirName).Append(L"default\\Preferences"); + base::FilePath local_state_path = local_path.Append(kAppDataDirName).Append( + kUserDataDirName).Append(L"ninja\\Local State"); + base::FilePath local_junk_path = local_path.Append(kAppDataDirName).Append( + kUserDataDirName).Append(L"default\\Junk"); + + base::FilePath desktop_path; + PathService::Get(base::DIR_USER_DESKTOP, &desktop_path); + base::FilePath desktop_junk_path = + desktop_path.Append(L"Downloads\\junk.txt"); + base::FilePath desktop_prefs_path = + desktop_path.Append(L"Downloads\\Preferences"); + + // Don't redirect UNC files. + EXPECT_FALSE(ShouldBypass(UNC_filepath_file.c_str())); + + // Don't redirect if file is not in UserData directory. + EXPECT_FALSE(ShouldBypass(desktop_junk_path.value().c_str())); + EXPECT_FALSE(ShouldBypass(desktop_prefs_path.value().c_str())); + + // Only redirect "Preferences" and "Local State" files. + EXPECT_TRUE(ShouldBypass(local_prefs_path.value().c_str())); + EXPECT_TRUE(ShouldBypass(local_state_path.value().c_str())); + EXPECT_FALSE(ShouldBypass(local_junk_path.value().c_str())); +} + +TEST_F(ChromeCreateFileTest, NtCreateFileAddressCheck) { + HMODULE ntdll_handle = ::GetModuleHandle(L"ntdll.dll"); + EXPECT_EQ(::GetProcAddress(ntdll_handle, "NtCreateFile"), + g_ntdll_lookup["NtCreateFile"]); +} + +TEST_F(ChromeCreateFileTest, ReadWriteFromNtDll) { + base::FilePath file_name = temp_dir_.path().Append(L"some_file.txt"); + DoWriteCheck(file_name, FILE_ATTRIBUTE_NORMAL, false); + DoReadCheck(file_name, FILE_ATTRIBUTE_NORMAL, false); +} + +} // namespace |