summaryrefslogtreecommitdiffstats
path: root/chrome_elf/create_file
diff options
context:
space:
mode:
authorcaitkp@chromium.org <caitkp@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2014-02-02 05:52:41 +0000
committercaitkp@chromium.org <caitkp@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2014-02-02 05:52:41 +0000
commit2106f5f60602468d0c54d55c43757e3cd191b470 (patch)
tree881c8b3a3d7417ea4586dced346551293a21365e /chrome_elf/create_file
parent46b4e44f1e8177bf0fcb7f18e660abebd3da0afc (diff)
downloadchromium_src-2106f5f60602468d0c54d55c43757e3cd191b470.zip
chromium_src-2106f5f60602468d0c54d55c43757e3cd191b470.tar.gz
chromium_src-2106f5f60602468d0c54d55c43757e3cd191b470.tar.bz2
Use an alternate mechanism for CreateFile calls in Chrome
BUG=334379 Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=245464 Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=246313 Review URL: https://codereview.chromium.org/138593004 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@248380 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'chrome_elf/create_file')
-rw-r--r--chrome_elf/create_file/chrome_create_file.cc279
-rw-r--r--chrome_elf/create_file/chrome_create_file.h38
-rw-r--r--chrome_elf/create_file/chrome_create_file_unittest.cc391
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