Add sandbox support for Windows process mitigations

sandbox/win/src/target_services.cc

 // Copyright (c) 2012 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 "sandbox/win/src/target_services.h"
 
 #include <process.h>
 
 #include "base/basictypes.h"
 #include "sandbox/win/src/crosscall_client.h"
 #include "sandbox/win/src/handle_closer_agent.h"
 #include "sandbox/win/src/handle_interception.h"
 #include "sandbox/win/src/ipc_tags.h"
+#include "sandbox/win/src/process_mitigations.h"
 #include "sandbox/win/src/restricted_token_utils.h"
 #include "sandbox/win/src/sandbox.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "sandbox/win/src/sharedmem_ipc_client.h"
 #include "sandbox/win/src/sandbox_nt_util.h"
 
 namespace {
 
 // Flushing a cached key is triggered by just opening the key and closing the
 // resulting handle. RegDisablePredefinedCache() is the documented way to flush
@@ skipping 30 matching lines @@
 
   return true;
 }
 
 }  // namespace
 
 namespace sandbox {
 
 SANDBOX_INTERCEPT IntegrityLevel g_shared_delayed_integrity_level =
     INTEGRITY_LEVEL_LAST;
+SANDBOX_INTERCEPT MitigationFlags g_shared_delayed_mitigations = 0;
 
 TargetServicesBase::TargetServicesBase() {
 }
 
 ResultCode TargetServicesBase::Init() {
   process_state_.SetInitCalled();
   return SBOX_ALL_OK;
 }
 
 // Failure here is a breach of security so the process is terminated.
 void TargetServicesBase::LowerToken() {
   if (ERROR_SUCCESS !=
       SetProcessIntegrityLevel(g_shared_delayed_integrity_level))
     ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_INTEGRITY);
   process_state_.SetRevertedToSelf();
   // If the client code as called RegOpenKey, advapi32.dll has cached some
   // handles. The following code gets rid of them.
   if (!::RevertToSelf())
     ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_DROPTOKEN);
   if (!FlushCachedRegHandles())
     ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_FLUSHANDLES);
   if (ERROR_SUCCESS != ::RegDisablePredefinedCache())
     ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_CACHEDISABLE);
   if (!CloseOpenHandles())
     ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_CLOSEHANDLES);
+  // Enabling mitigations must happen last otherwise handle closing breaks
+  if (g_shared_delayed_mitigations &&
+      !ApplyProcessMitigationsToCurrentProcess(g_shared_delayed_mitigations))
+    ::TerminateProcess(::GetCurrentProcess(), SBOX_FATAL_MITIGATION);
 }
 
 ProcessState* TargetServicesBase::GetState() {
   return &process_state_;
 }
 
 TargetServicesBase* TargetServicesBase::GetInstance() {
   static TargetServicesBase instance;
   return &instance;
 }
@@ skipping 80 matching lines @@
 ResultCode TargetServicesBase::DuplicateHandle(HANDLE source_handle,
                                                DWORD target_process_id,
                                                HANDLE* target_handle,
                                                DWORD desired_access,
                                                DWORD options) {
   return sandbox::DuplicateHandleProxy(source_handle, target_process_id,
                                        target_handle, desired_access, options);
 }
 
 }  // namespace sandbox