Make chrome_elf use thunks instead of function pointers.

chrome_elf/ntdll_cache.cc

Index: chrome_elf/ntdll_cache.cc
diff --git a/chrome_elf/ntdll_cache.cc b/chrome_elf/ntdll_cache.cc
index e5504421ae420cf6d78b281d4c859df6c0ac2a0b..9aa569b9e242e1e8ca2849c00a3d313db97e4726 100644
--- a/chrome_elf/ntdll_cache.cc
+++ b/chrome_elf/ntdll_cache.cc
@@ -2,15 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome_elf/ntdll_cache.h"
+
 #include <stdint.h>
 #include <windows.h>
 
-#include "chrome_elf/ntdll_cache.h"
+#include "base/basictypes.h"
+#include "chrome_elf/thunk_getter.h"
+#include "sandbox/win/src/interception_internal.h"
+#include "sandbox/win/src/internal_types.h"
+#include "sandbox/win/src/service_resolver.h"
+
+// Allocate storage for thunks in a page of this module to save on doing
+// an extra allocation at run time.
+#pragma section(".crthunk", read, execute)
+__declspec(allocate(".crthunk")) sandbox::ThunkData g_nt_thunk_storage;
 
 FunctionLookupTable g_ntdll_lookup;
 
 void InitCache() {
-  HMODULE ntdll_handle = ::GetModuleHandle(L"ntdll.dll");
+  HMODULE ntdll_handle = ::GetModuleHandle(sandbox::kNtdllName);
 
   // To find the Export Address Table address, we start from the DOS header.
   // The module handle is actually the address of the header.
@@ -48,4 +59,40 @@ void InitCache() {
     FARPROC func_addr = reinterpret_cast<FARPROC>(func + base_addr);
     g_ntdll_lookup[std::string(name)] = func_addr;
   }
+
+  const bool kRelaxed = true;
+
+  // Create a thunk via the appropriate ServiceResolver instance.
+  sandbox::ServiceResolverThunk* thunk = GetThunk(kRelaxed);
+
+  if (!thunk)

[robertshield, 2014/03/04 01:47:07]

This implies that the rest of the function is optional, in which case I prefer
the form 

if (thunk) {
  <code on lines 71-97>
}

in case someone attempts to add some non-optional code to the bottom of the
function in the future.

[Cait (Slow), 2014/03/04 15:43:56]

Done.

+    return;
+
+  BYTE* thunk_storage = reinterpret_cast<BYTE*>(&g_nt_thunk_storage);
+
+  // Mark the thunk storage as readable and writeable, since we
+  // ready to write to it.
+  DWORD old_protect = 0;
+  if (!VirtualProtect(&g_nt_thunk_storage,

[robertshield, 2014/03/04 01:47:07]

In some places in this file we use the scope operator on API calls (see
::GetModuleHandle below) and in others we don't. We should be consistent.

FWIW, I prefer with the scope operator. I feel it calls out Win32 API calls more
clearly.

[Cait (Slow), 2014/03/04 15:43:56]

Done.

+                      sizeof(g_nt_thunk_storage),
+                      PAGE_EXECUTE_READWRITE,
+                      &old_protect)) {
+    return;
+  }
+
+  size_t storage_used = 0;
+  NTSTATUS ret = thunk->CopyThunk(::GetModuleHandle(sandbox::kNtdllName),
+                                  "NtCreateFile",
+                                  thunk_storage,
+                                  sizeof(sandbox::ThunkData),
+                                  &storage_used);
+
+  // Ensure that the pointer to the old function can't be changed.
+  VirtualProtect(&g_nt_thunk_storage,
+                 sizeof(g_nt_thunk_storage),
+                 PAGE_EXECUTE_READ,
+                 &old_protect);
+
+  g_ntdll_lookup[std::string("NtCreateFile")] =

[robertshield, 2014/03/04 01:47:07]

Is the explicit string constructor needed?

[Cait (Slow), 2014/03/04 15:43:56]

Done.

+      reinterpret_cast<FARPROC>(&g_nt_thunk_storage);
 }