tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

WindowsProcessMitigations.cpp (4844B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "mozilla/WindowsProcessMitigations.h"
      8 
      9 #include <processthreadsapi.h>
     10 
     11 #include "mozilla/DynamicallyLinkedFunctionPtr.h"
     12 #include "mozilla/WindowsVersion.h"
     13 
     14 static_assert(sizeof(PROCESS_MITIGATION_DYNAMIC_CODE_POLICY) == 4);
     15 
     16 namespace mozilla {
     17 
     18 static decltype(&::GetProcessMitigationPolicy)
     19 FetchGetProcessMitigationPolicyFunc() {
     20  static const StaticDynamicallyLinkedFunctionPtr<
     21      decltype(&::GetProcessMitigationPolicy)>
     22      pGetProcessMitigationPolicy(L"kernel32.dll",
     23                                  "GetProcessMitigationPolicy");
     24  return pGetProcessMitigationPolicy;
     25 }
     26 
     27 static bool sWin32kLockedDownInPolicy = false;
     28 
     29 MFBT_API bool IsWin32kLockedDown() {
     30  static bool sWin32kLockedDown = []() {
     31    auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
     32 
     33    PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY polInfo;
     34    if (!pGetProcessMitigationPolicy ||
     35        !pGetProcessMitigationPolicy(::GetCurrentProcess(),
     36                                     ProcessSystemCallDisablePolicy, &polInfo,
     37                                     sizeof(polInfo))) {
     38      // We failed to get pointer to GetProcessMitigationPolicy or the call
     39      // to it failed, so just return what the sandbox policy says.
     40      return sWin32kLockedDownInPolicy;
     41    }
     42 
     43    return !!polInfo.DisallowWin32kSystemCalls;
     44  }();
     45 
     46  return sWin32kLockedDown;
     47 }
     48 
     49 MFBT_API void SetWin32kLockedDownInPolicy() {
     50  sWin32kLockedDownInPolicy = true;
     51 }
     52 
     53 MFBT_API bool IsDynamicCodeDisabled() {
     54  auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
     55  if (!pGetProcessMitigationPolicy) {
     56    return false;
     57  }
     58 
     59  PROCESS_MITIGATION_DYNAMIC_CODE_POLICY polInfo;
     60  if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
     61                                   ProcessDynamicCodePolicy, &polInfo,
     62                                   sizeof(polInfo))) {
     63    return false;
     64  }
     65 
     66  return polInfo.ProhibitDynamicCode;
     67 }
     68 
     69 MFBT_API bool IsEafPlusEnabled() {
     70  auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
     71  if (!pGetProcessMitigationPolicy) {
     72    return false;
     73  }
     74 
     75  PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY polInfo;
     76  if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
     77                                   ProcessPayloadRestrictionPolicy, &polInfo,
     78                                   sizeof(polInfo))) {
     79    return false;
     80  }
     81 
     82  return polInfo.EnableExportAddressFilterPlus;
     83 }
     84 
     85 MFBT_API bool IsUserShadowStackEnabled() {
     86  auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
     87  if (!pGetProcessMitigationPolicy) {
     88    return false;
     89  }
     90 
     91  PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY polInfo;
     92  if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
     93                                   ProcessUserShadowStackPolicy, &polInfo,
     94                                   sizeof(polInfo))) {
     95    return false;
     96  }
     97 
     98  return polInfo.EnableUserShadowStack;
     99 }
    100 
    101 MFBT_API bool IsPreferLoadFromSystem32Available() {
    102  return mozilla::IsWin10AnniversaryUpdateOrLater();
    103 }
    104 
    105 MFBT_API bool IsPreferLoadFromSystem32Enabled() {
    106  auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
    107  if (!pGetProcessMitigationPolicy) {
    108    return false;
    109  }
    110 
    111  PROCESS_MITIGATION_IMAGE_LOAD_POLICY imgLoadPol{};
    112  if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
    113                                   ProcessImageLoadPolicy, &imgLoadPol,
    114                                   sizeof(imgLoadPol))) {
    115    return false;
    116  }
    117 
    118  return imgLoadPol.PreferSystem32Images;
    119 }
    120 
    121 MFBT_API bool EnablePreferLoadFromSystem32() {
    122  auto pGetProcessMitigationPolicy = FetchGetProcessMitigationPolicyFunc();
    123  if (!pGetProcessMitigationPolicy) {
    124    return false;
    125  }
    126 
    127  static const mozilla::StaticDynamicallyLinkedFunctionPtr<
    128      decltype(&::SetProcessMitigationPolicy)>
    129      pSetProcessMitigationPolicy(L"kernel32.dll",
    130                                  "SetProcessMitigationPolicy");
    131  if (!pSetProcessMitigationPolicy) {
    132    return false;
    133  }
    134 
    135  PROCESS_MITIGATION_IMAGE_LOAD_POLICY imgLoadPol{};
    136  if (!pGetProcessMitigationPolicy(::GetCurrentProcess(),
    137                                   ProcessImageLoadPolicy, &imgLoadPol,
    138                                   sizeof(imgLoadPol))) {
    139    return false;
    140  }
    141 
    142  if (imgLoadPol.PreferSystem32Images) {
    143    return true;
    144  }
    145 
    146  imgLoadPol.PreferSystem32Images = 1;
    147  return pSetProcessMitigationPolicy(ProcessImageLoadPolicy, &imgLoadPol,
    148                                     sizeof(imgLoadPol));
    149 }
    150 
    151 }  // namespace mozilla