Use a Finch Experiment to control the Browser Blacklist

chrome_elf/blacklist/blacklist.cc

 // Copyright 2013 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/blacklist/blacklist.h"
 
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "chrome_elf/blacklist/blacklist_interceptions.h"
 #include "sandbox/win/src/interception_internal.h"
 #include "sandbox/win/src/internal_types.h"
 #include "sandbox/win/src/sandbox_utils.h"
 #include "sandbox/win/src/service_resolver.h"
+#include "version.h"  // NOLINT
 
 // http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
 extern "C" IMAGE_DOS_HEADER __ImageBase;
 
 namespace blacklist{
 
 const wchar_t* g_troublesome_dlls[kTroublesomeDllsMaxCount] = {};
 int g_troublesome_dlls_cur_index = 0;
 
 const wchar_t kRegistryBeaconPath[] = L"SOFTWARE\\Google\\Chrome\\BLBeacon";
+const wchar_t kBeaconVersion[] = L"version";
+const wchar_t kBeaconState[] = L"state";
 
 }  // namespace blacklist
 
 // 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_thunk_storage;
 
 namespace {
 
@@ skipping 98 matching lines @@
 
 bool IsNonBrowserProcess() {
   wchar_t* command_line = GetCommandLine();
   return (command_line && wcsstr(command_line, L"--type"));
 }
 
 }  // namespace
 
 namespace blacklist {
 
-bool CreateBeacon() {
-  HKEY beacon_key = NULL;
+bool LeaveSetupBeacon() {
+  HKEY key = NULL;
   DWORD disposition = 0;
   LONG result = ::RegCreateKeyEx(HKEY_CURRENT_USER,
                                  kRegistryBeaconPath,
                                  0,
                                  NULL,
-                                 0,
-                                 KEY_WRITE,
+                                 REG_OPTION_NON_VOLATILE,
+                                 KEY_QUERY_VALUE | KEY_SET_VALUE,
                                  NULL,
-                                 &beacon_key,
+                                 &key,
                                  &disposition);
-  bool success = (result == ERROR_SUCCESS &&
-                  disposition != REG_OPENED_EXISTING_KEY);
-  if (result == ERROR_SUCCESS)
-    ::RegCloseKey(beacon_key);
-  return success;
-}
+  if (result != ERROR_SUCCESS)
+    return false;
 
-bool ClearBeacon() {
-  LONG result = ::RegDeleteKey(HKEY_CURRENT_USER, kRegistryBeaconPath);
+  // Retrieve the current blacklist state.
+  DWORD blacklist_state = BLACKLIST_DISABLED;
+  DWORD blacklist_state_size = sizeof(blacklist_state);
+  DWORD type = 0;
+  result = ::RegQueryValueEx(key,
+                             kBeaconState,
+                             0,
+                             &type,
+                             reinterpret_cast<LPBYTE>(&blacklist_state),
+                             &blacklist_state_size);
+
+  if (blacklist_state != BLACKLIST_ENABLED ||
+      result != ERROR_SUCCESS || type != REG_DWORD) {
+    ::RegCloseKey(key);
+    return false;
+  }
+
+  // If the blacklist wasn't set as enabled for this version, don't
+  // use it.
+  wchar_t key_data[255] = {};
+  DWORD key_data_size = sizeof(key_data);
+  result = ::RegQueryValueEx(key,
+                             blacklist::kBeaconVersion,
+                             0,
+                             &type,
+                             reinterpret_cast<LPBYTE>(key_data),
+                             &key_data_size);
+
+  if (wcscmp(key_data, TEXT(CHROME_VERSION_STRING)) != 0 ||
+      result != ERROR_SUCCESS || type != REG_SZ) {
+    ::RegCloseKey(key);
+    return false;
+  }
+
+  // Mark the blacklist setup code as running so if it crashes the blacklist
+  // won't be enabled for the next run.
+  blacklist_state = BLACKLIST_SETUP_RUNNING;
+  result = ::RegSetValueEx(key,
+                           kBeaconState,
+                           0,
+                           REG_DWORD,
+                           reinterpret_cast<LPBYTE>(&blacklist_state),
+                           sizeof(blacklist_state));
+  ::RegCloseKey(key);
+
   return (result == ERROR_SUCCESS);
 }
 
+bool ResetBeacon() {
+  HKEY key = NULL;
+  DWORD disposition = 0;
+  LONG result = ::RegCreateKeyEx(HKEY_CURRENT_USER,
+                                 kRegistryBeaconPath,
+                                 0,
+                                 NULL,
+                                 REG_OPTION_NON_VOLATILE,
+                                 KEY_QUERY_VALUE | KEY_SET_VALUE,
+                                 NULL,
+                                 &key,
+                                 &disposition);
+  if (result != ERROR_SUCCESS)
+    return false;
+
+  DWORD blacklist_state = BLACKLIST_ENABLED;
+  result = ::RegSetValueEx(key,
+                           kBeaconState,
+                           0,
+                           REG_DWORD,
+                           reinterpret_cast<LPBYTE>(&blacklist_state),
+                           sizeof(blacklist_state));
+  ::RegCloseKey(key);
+
+  return (result == ERROR_SUCCESS);
+}
+
 bool AddDllToBlacklist(const wchar_t* dll_name) {
   if (g_troublesome_dlls_cur_index >= kTroublesomeDllsMaxCount)
     return false;
   for (int i = 0; i < g_troublesome_dlls_cur_index; ++i) {
     if (!wcscmp(g_troublesome_dlls[i], dll_name))
       return true;
   }
 
   // Copy string to blacklist.
   wchar_t* str_buffer = new wchar_t[wcslen(dll_name) + 1];
@@ skipping 28 matching lines @@
 
   // Check to see that we found the functions we need in ntdll.
   if (!InitializeInterceptImports())
     return false;
 
   // Check to see if this is a non-browser process, abort if so.
   if (IsNonBrowserProcess())
     return false;
 
   // Check to see if a beacon is present, abort if so.
-  if (!force && !CreateBeacon())
+  if (!force && !LeaveSetupBeacon())
     return false;
 
   // Don't try blacklisting on unsupported OS versions.
   OSInfo os_info;
   if (os_info.version() <= VERSION_PRE_XP_SP2)
     return false;
 
   // Pseudo-handle, no need to close.
   HANDLE current_process = ::GetCurrentProcess();
 
@@ skipping 46 matching lines @@
   // Mark the thunk storage as executable and prevent any future writes to it.
   BOOL page_executable = VirtualProtect(&g_thunk_storage,
                                         sizeof(g_thunk_storage),
                                         PAGE_EXECUTE_READ,
                                         &old_protect);
 
   return NT_SUCCESS(ret) && page_executable;
 }
 
 }  // namespace blacklist