/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsNSSComponent.h"

#include "EnterpriseRoots.h"

#include "ExtendedValidation.h"

#include "NSSCertDBTrustDomain.h"

#include "PKCS11ModuleDB.h"

#include "ScopedNSSTypes.h"

#include "SharedSSLState.h"

#include "cert.h"

#include "certdb.h"

#include "mozilla/ArrayUtils.h"

#include "mozilla/Assertions.h"

#include "mozilla/Casting.h"

#include "mozilla/Preferences.h"

#include "mozilla/PodOperations.h"

#include "mozilla/PublicSSL.h"

#include "mozilla/Services.h"

#include "mozilla/StaticPtr.h"

#include "mozilla/SyncRunnable.h"

#include "mozilla/Telemetry.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/Unused.h"

#include "mozilla/Vector.h"

#include "nsAppDirectoryServiceDefs.h"

#include "nsCRT.h"

#include "nsClientAuthRemember.h"

#include "nsComponentManagerUtils.h"

#include "nsDirectoryServiceDefs.h"

#include "nsICertOverrideService.h"

#include "nsIFile.h"

#include "nsILocalFileWin.h"

#include "nsIObserverService.h"

#include "nsIPrompt.h"

#include "nsIProperties.h"

#include "nsISiteSecurityService.h"

#include "nsITokenPasswordDialogs.h"

#include "nsIWindowWatcher.h"

#include "nsIXULRuntime.h"

#include "nsLiteralString.h"

#include "nsNSSCertificateDB.h"

#include "nsNSSHelper.h"

#include "nsPK11TokenDB.h"

#include "nsPrintfCString.h"

#include "nsServiceManagerUtils.h"

#include "nsThreadUtils.h"

#include "nsXULAppAPI.h"

#include "nss.h"

#include "p12plcy.h"

#include "pkix/pkixnss.h"

#include "secerr.h"

#include "secmod.h"

#include "ssl.h"

#include "sslerr.h"

#include "sslproto.h"

#include "prmem.h"

#if defined(XP_LINUX) && !defined(ANDROID)

#include <linux/magic.h>

#include <sys/vfs.h>

#endif

#ifdef XP_WIN

#include "mozilla/WindowsVersion.h"

#include "nsILocalFileWin.h"

#include "windows.h" // this needs to be before the following includes

#include "lmcons.h"

#include "sddl.h"

#include "wincrypt.h"

#include "nsIWindowsRegKey.h"

#endif

using namespace mozilla;

using namespace mozilla::psm;

LazyLogModule gPIPNSSLog("pipnss");

int nsNSSComponent::mInstanceCount = 0;

// This function can be called from chrome or content processes

// to ensure that NSS is initialized.

bool EnsureNSSInitializedChromeOrContent()

{

  static Atomic<bool> initialized(false);

  if (initialized) {

    return true;

  }

  // If this is not the main thread (i.e. probably a worker) then forward this

  // call to the main thread.

  if (!NS_IsMainThread()) {

    nsCOMPtr<nsIThread> mainThread;

    nsresult rv = NS_GetMainThread(getter_AddRefs(mainThread));

    if (NS_FAILED(rv)) {

      return false;

    }

    // Forward to the main thread synchronously.

    mozilla::SyncRunnable::DispatchToThread(

      mainThread,

      new SyncRunnable(

        NS_NewRunnableFunction("EnsureNSSInitializedChromeOrContent", []() {

          EnsureNSSInitializedChromeOrContent();

        })));

    return initialized;

  }

  if (XRE_IsParentProcess()) {

    nsCOMPtr<nsISupports> nss = do_GetService(PSM_COMPONENT_CONTRACTID);

    if (!nss) {

      return false;

    }

    initialized = true;

    return true;

  }

  if (NSS_IsInitialized()) {

    initialized = true;

    return true;

  }

  if (NSS_NoDB_Init(nullptr) != SECSuccess) {

    return false;

  }

  if (NS_FAILED(mozilla::psm::InitializeCipherSuite())) {

    return false;

  }

  mozilla::psm::DisableMD5();

  mozilla::pkix::RegisterErrorTable();

  initialized = true;

  return true;

}

static const uint32_t OCSP_TIMEOUT_MILLISECONDS_SOFT_DEFAULT = 2000;

static const uint32_t OCSP_TIMEOUT_MILLISECONDS_SOFT_MAX = 5000;

static const uint32_t OCSP_TIMEOUT_MILLISECONDS_HARD_DEFAULT = 10000;

static const uint32_t OCSP_TIMEOUT_MILLISECONDS_HARD_MAX = 20000;

static void

GetRevocationBehaviorFromPrefs(/*out*/ CertVerifier::OcspDownloadConfig* odc,

                               /*out*/ CertVerifier::OcspStrictConfig* osc,

                               /*out*/ uint32_t* certShortLifetimeInDays,

                               /*out*/ TimeDuration& softTimeout,

                               /*out*/ TimeDuration& hardTimeout,

                               const MutexAutoLock& /*proofOfLock*/)

{

  MOZ_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(odc);

  MOZ_ASSERT(osc);

  MOZ_ASSERT(certShortLifetimeInDays);

  // 0 = disabled

  // 1 = enabled for everything (default)

  // 2 = enabled for EV certificates only

  int32_t ocspLevel = Preferences::GetInt("security.OCSP.enabled", 1);

  switch (ocspLevel) {

    case 0: *odc = CertVerifier::ocspOff; break;

    case 2: *odc = CertVerifier::ocspEVOnly; break;

    default: *odc = CertVerifier::ocspOn; break;

  }

  *osc = Preferences::GetBool("security.OCSP.require", false)

       ? CertVerifier::ocspStrict

       : CertVerifier::ocspRelaxed;

  // If we pass in just 0 as the second argument to Preferences::GetUint, there

  // are two function signatures that match (given that 0 can be intepreted as

  // a null pointer). Thus the compiler will complain without the cast.

  *certShortLifetimeInDays =

    Preferences::GetUint("security.pki.cert_short_lifetime_in_days",

                         static_cast<uint32_t>(0));

  uint32_t softTimeoutMillis =

    Preferences::GetUint("security.OCSP.timeoutMilliseconds.soft",

                         OCSP_TIMEOUT_MILLISECONDS_SOFT_DEFAULT);

  softTimeoutMillis = std::min(softTimeoutMillis,

                               OCSP_TIMEOUT_MILLISECONDS_SOFT_MAX);

  softTimeout = TimeDuration::FromMilliseconds(softTimeoutMillis);

  uint32_t hardTimeoutMillis =

    Preferences::GetUint("security.OCSP.timeoutMilliseconds.hard",

                         OCSP_TIMEOUT_MILLISECONDS_HARD_DEFAULT);

  hardTimeoutMillis = std::min(hardTimeoutMillis,

                               OCSP_TIMEOUT_MILLISECONDS_HARD_MAX);

  hardTimeout = TimeDuration::FromMilliseconds(hardTimeoutMillis);

  SSL_ClearSessionCache();

}

nsNSSComponent::nsNSSComponent()

  : mLoadableRootsLoadedMonitor("nsNSSComponent.mLoadableRootsLoadedMonitor")

  , mLoadableRootsLoaded(false)

  , mLoadableRootsLoadedResult(NS_ERROR_FAILURE)

  , mMutex("nsNSSComponent.mMutex")

  , mMitmDetecionEnabled(false)

  , mLoadLoadableRootsTaskDispatched(false)

{

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("nsNSSComponent::ctor\n"));

  MOZ_RELEASE_ASSERT(NS_IsMainThread());

  MOZ_ASSERT(mInstanceCount == 0,

             "nsNSSComponent is a singleton, but instantiated multiple times!");

  ++mInstanceCount;

}

nsNSSComponent::~nsNSSComponent()

{

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("nsNSSComponent::dtor\n"));

  MOZ_RELEASE_ASSERT(NS_IsMainThread());

  // All cleanup code requiring services needs to happen in xpcom_shutdown

  ShutdownNSS();

  SharedSSLState::GlobalCleanup();

  RememberCertErrorsTable::Cleanup();

  --mInstanceCount;

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("nsNSSComponent::dtor finished\n"));

}

#ifdef XP_WIN

static bool

GetUserSid(nsAString& sidString)

{

  // UNLEN is the maximum user name length (see Lmcons.h). +1 for the null

  // terminator.

  WCHAR lpAccountName[UNLEN + 1];

  DWORD lcAccountName = sizeof(lpAccountName) / sizeof(lpAccountName[0]);

  BOOL success = GetUserName(lpAccountName, &lcAccountName);

  if (!success) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("GetUserName failed"));

    return false;

  }

  char sid_buffer[SECURITY_MAX_SID_SIZE];

  SID* sid = BitwiseCast<SID*, char*>(sid_buffer);

  DWORD cbSid = ArrayLength(sid_buffer);

  SID_NAME_USE eUse;

  // There doesn't appear to be a defined maximum length for the domain name

  // here. To deal with this, we start with a reasonable buffer length and

  // see if that works. If it fails and the error indicates insufficient length,

  // we use the indicated required length and try again.

  DWORD cchReferencedDomainName = 128;

  auto ReferencedDomainName(MakeUnique<WCHAR[]>(cchReferencedDomainName));

  success = LookupAccountName(nullptr, lpAccountName, sid, &cbSid,

                              ReferencedDomainName.get(),

                              &cchReferencedDomainName, &eUse);

  if (!success && GetLastError() != ERROR_INSUFFICIENT_BUFFER) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("LookupAccountName failed"));

    return false;

  }

  if (!success) {

    ReferencedDomainName = MakeUnique<WCHAR[]>(cchReferencedDomainName);

    success = LookupAccountName(nullptr, lpAccountName, sid, &cbSid,

                                ReferencedDomainName.get(),

                                &cchReferencedDomainName, &eUse);

  }

  if (!success) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("LookupAccountName failed"));

    return false;

  }

  LPTSTR StringSid;

  success = ConvertSidToStringSid(sid, &StringSid);

  if (!success) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("ConvertSidToStringSid failed"));

    return false;

  }

  sidString.Assign(StringSid);

  LocalFree(StringSid);

  return true;

}

// This is a specialized helper function to read the value of a registry key

// that might not be present. If it is present, returns (via the output

// parameter) its value. Otherwise, returns the given default value.

// This function handles one level of nesting. That is, if the desired value

// is actually in a direct child of the given registry key (where the child

// and/or the value being sought may not actually be present), this function

// will handle that. In the normal case, though, optionalChildName will be

// null.

static nsresult

ReadRegKeyValueWithDefault(nsCOMPtr<nsIWindowsRegKey> regKey,

                           uint32_t flags,

                           wchar_t* optionalChildName,

                           wchar_t* valueName,

                           uint32_t defaultValue,

                           uint32_t& valueOut)

{

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("ReadRegKeyValueWithDefault"));

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

          ("attempting to read '%S%s%S' with default '%u'",

           optionalChildName ? optionalChildName : L"",

           optionalChildName ? "\\" : "", valueName, defaultValue));

  if (optionalChildName) {

    nsDependentString childNameString(optionalChildName);

    bool hasChild;

    nsresult rv = regKey->HasChild(childNameString, &hasChild);

    if (NS_FAILED(rv)) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

              ("failed to determine if child key is present"));

      return rv;

    }

    if (!hasChild) {

      valueOut = defaultValue;

      return NS_OK;

    }

    nsCOMPtr<nsIWindowsRegKey> childRegKey;

    rv = regKey->OpenChild(childNameString, flags,

                           getter_AddRefs(childRegKey));

    if (NS_FAILED(rv)) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't open child key"));

      return rv;

    }

    return ReadRegKeyValueWithDefault(childRegKey, flags, nullptr, valueName,

                                      defaultValue, valueOut);

  }

  nsDependentString valueNameString(valueName);

  bool hasValue;

  nsresult rv = regKey->HasValue(valueNameString, &hasValue);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("failed to determine if value is present"));

    return rv;

  }

  if (!hasValue) {

    valueOut = defaultValue;

    return NS_OK;

  }

  rv = regKey->ReadIntValue(valueNameString, &valueOut);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("failed to read value"));

    return rv;

  }

  return NS_OK;

}

static nsresult

AccountHasFamilySafetyEnabled(bool& enabled)

{

  enabled = false;

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("AccountHasFamilySafetyEnabled?"));

  nsCOMPtr<nsIWindowsRegKey> parentalControlsKey(

    do_CreateInstance("@mozilla.org/windows-registry-key;1"));

  if (!parentalControlsKey) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't create nsIWindowsRegKey"));

    return NS_ERROR_FAILURE;

  }

  uint32_t flags = nsIWindowsRegKey::ACCESS_READ | nsIWindowsRegKey::WOW64_64;

  NS_NAMED_LITERAL_STRING(familySafetyPath,

    "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Parental Controls");

  nsresult rv = parentalControlsKey->Open(

    nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE, familySafetyPath, flags);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't open parentalControlsKey"));

    return rv;

  }

  NS_NAMED_LITERAL_STRING(usersString, "Users");

  bool hasUsers;

  rv = parentalControlsKey->HasChild(usersString, &hasUsers);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("HasChild(Users) failed"));

    return rv;

  }

  if (!hasUsers) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("Users subkey not present - Parental Controls not enabled"));

    return NS_OK;

  }

  nsCOMPtr<nsIWindowsRegKey> usersKey;

  rv = parentalControlsKey->OpenChild(usersString, flags,

                                      getter_AddRefs(usersKey));

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("failed to open Users subkey"));

    return rv;

  }

  nsAutoString sid;

  if (!GetUserSid(sid)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't get sid"));

    return NS_ERROR_FAILURE;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("our sid is '%S'", sid.get()));

  bool hasSid;

  rv = usersKey->HasChild(sid, &hasSid);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("HasChild(sid) failed"));

    return rv;

  }

  if (!hasSid) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("sid not present in Family Safety Users"));

    return NS_OK;

  }

  nsCOMPtr<nsIWindowsRegKey> sidKey;

  rv = usersKey->OpenChild(sid, flags, getter_AddRefs(sidKey));

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't open sid key"));

    return rv;

  }

  // There are three keys we're interested in: "Parental Controls On",

  // "Logging Required", and "Web\\Filter On". These keys will have value 0

  // or 1, indicating a particular feature is disabled or enabled,

  // respectively. So, if "Parental Controls On" is not 1, Family Safety is

  // disabled and we don't care about anything else. If both "Logging

  // Required" and "Web\\Filter On" are 0, the proxy will not be running,

  // so for our purposes we can consider Family Safety disabled in that

  // case.

  // By default, "Logging Required" is 1 and "Web\\Filter On" is 0,

  // reflecting the initial settings when Family Safety is enabled for an

  // account for the first time, However, these sub-keys are not created

  // unless they are switched away from the default value.

  uint32_t parentalControlsOn;

  rv = sidKey->ReadIntValue(NS_LITERAL_STRING("Parental Controls On"),

                            &parentalControlsOn);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("couldn't read Parental Controls On"));

    return rv;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

          ("Parental Controls On: %u", parentalControlsOn));

  if (parentalControlsOn != 1) {

    return NS_OK;

  }

  uint32_t loggingRequired;

  rv = ReadRegKeyValueWithDefault(sidKey, flags, nullptr, L"Logging Required",

                                  1, loggingRequired);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("failed to read value of Logging Required"));

    return rv;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

          ("Logging Required: %u", loggingRequired));

  uint32_t webFilterOn;

  rv = ReadRegKeyValueWithDefault(sidKey, flags, L"Web", L"Filter On", 0,

                                  webFilterOn);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("failed to read value of Web\\Filter On"));

    return rv;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("Web\\Filter On: %u", webFilterOn));

  enabled = loggingRequired == 1 || webFilterOn == 1;

  return NS_OK;

}

nsresult

nsNSSComponent::MaybeImportFamilySafetyRoot(PCCERT_CONTEXT certificate,

                                            bool& wasFamilySafetyRoot)

{

  MutexAutoLock lock(mMutex);

  MOZ_ASSERT(NS_IsMainThread());

  if (!NS_IsMainThread()) {

    return NS_ERROR_NOT_SAME_THREAD;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("MaybeImportFamilySafetyRoot"));

  wasFamilySafetyRoot = false;

  UniqueCERTCertificate nssCertificate(

    PCCERT_CONTEXTToCERTCertificate(certificate));

  if (!nssCertificate) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("couldn't decode certificate"));

    return NS_ERROR_FAILURE;

  }

  // Looking for a certificate with the common name 'Microsoft Family Safety'

  UniquePORTString subjectName(CERT_GetCommonName(&nssCertificate->subject));

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

          ("subject name is '%s'", subjectName.get()));

  if (kMicrosoftFamilySafetyCN.Equals(subjectName.get())) {

    wasFamilySafetyRoot = true;

    MOZ_ASSERT(!mFamilySafetyRoot);

    mFamilySafetyRoot = std::move(nssCertificate);

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("added Family Safety root"));

  }

  return NS_OK;

}

nsresult

nsNSSComponent::LoadFamilySafetyRoot()

{

  ScopedCertStore certstore(

    CertOpenSystemStore(0, kWindowsDefaultRootStoreName));

  if (!certstore.get()) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("couldn't get certstore '%S'", kWindowsDefaultRootStoreName));

    return NS_ERROR_FAILURE;

  }

  // Any resources held by the certificate are released by the next call to

  // CertFindCertificateInStore.

  PCCERT_CONTEXT certificate = nullptr;

  while ((certificate = CertFindCertificateInStore(certstore.get(),

                                                   X509_ASN_ENCODING, 0,

                                                   CERT_FIND_ANY, nullptr,

                                                   certificate))) {

    bool wasFamilySafetyRoot = false;

    nsresult rv = MaybeImportFamilySafetyRoot(certificate,

                                              wasFamilySafetyRoot);

    if (NS_SUCCEEDED(rv) && wasFamilySafetyRoot) {

      return NS_OK; // We're done (we're only expecting one root).

    }

  }

  return NS_ERROR_FAILURE;

}

#endif // XP_WIN

void

nsNSSComponent::UnloadFamilySafetyRoot()

{

  MOZ_ASSERT(NS_IsMainThread());

  if (!NS_IsMainThread()) {

    return;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("UnloadFamilySafetyRoot"));

  // We can't call ChangeCertTrustWithPossibleAuthentication while holding

  // mMutex (because it could potentially call back in to nsNSSComponent and

  // attempt to acquire mMutex), so we move mFamilySafetyRoot out of

  // nsNSSComponent into a local handle. This has the side-effect of clearing

  // mFamilySafetyRoot, which is what we want anyway.

  UniqueCERTCertificate familySafetyRoot;

  {

    MutexAutoLock lock(mMutex);

    if (!mFamilySafetyRoot) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

              ("Family Safety Root wasn't present"));

      return;

    }

    familySafetyRoot = std::move(mFamilySafetyRoot);

    MOZ_ASSERT(!mFamilySafetyRoot);

  }

  MOZ_ASSERT(familySafetyRoot);

  // It would be intuitive to set the trust to { 0, 0, 0 } here. However, this

  // doesn't work for temporary certificates because CERT_ChangeCertTrust first

  // looks up the current trust settings in the permanent cert database, finds

  // that such trust doesn't exist, considers the current trust to be

  // { 0, 0, 0 }, and decides that it doesn't need to update the trust since

  // they're the same. To work around this, we set a non-zero flag to ensure

  // that the trust will get updated.

  CERTCertTrust trust = { CERTDB_USER, 0, 0 };

  if (ChangeCertTrustWithPossibleAuthentication(familySafetyRoot, trust,

                                                nullptr) != SECSuccess) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("couldn't untrust certificate for TLS server auth"));

  }

}

// The supported values of this pref are:

// 0: disable detecting Family Safety mode and importing the root

// 1: only attempt to detect Family Safety mode (don't import the root)

// 2: detect Family Safety mode and import the root

const char* kFamilySafetyModePref = "security.family_safety.mode";

const uint32_t kFamilySafetyModeDefault = 0;

// The telemetry gathered by this function is as follows:

// 0-2: the value of the Family Safety mode pref

// 3: detecting Family Safety mode failed

// 4: Family Safety was not enabled

// 5: Family Safety was enabled

// 6: failed to import the Family Safety root

// 7: successfully imported the root

void

nsNSSComponent::MaybeEnableFamilySafetyCompatibility(uint32_t familySafetyMode)

{

#ifdef XP_WIN

  if (!(IsWin8Point1OrLater() && !IsWin10OrLater())) {

    return;

  }

  if (familySafetyMode > 2) {

    familySafetyMode = 0;

  }

  if (familySafetyMode == 0) {

    return;

  }

  bool familySafetyEnabled;

  nsresult rv = AccountHasFamilySafetyEnabled(familySafetyEnabled);

  if (NS_FAILED(rv)) {

    return;

  }

  if (!familySafetyEnabled) {

    return;

  }

  if (familySafetyMode == 2) {

    rv = LoadFamilySafetyRoot();

    if (NS_FAILED(rv)) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

              ("failed to load Family Safety root"));

    }

  }

#endif // XP_WIN

}

void

nsNSSComponent::UnloadEnterpriseRoots()

{

  MOZ_ASSERT(NS_IsMainThread());

  if (!NS_IsMainThread()) {

    return;

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("UnloadEnterpriseRoots"));

  // We can't call ChangeCertTrustWithPossibleAuthentication while holding

  // mMutex (because it could potentially call back in to nsNSSComponent and

  // attempt to acquire mMutex), so we move mEnterpriseRoots out of

  // nsNSSComponent into a local handle. This has the side-effect of clearing

  // mEnterpriseRoots, which is what we want anyway.

  UniqueCERTCertList enterpriseRoots;

  {

    MutexAutoLock lock(mMutex);

    if (!mEnterpriseRoots) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

              ("no enterprise roots were present"));

      return;

    }

    enterpriseRoots = std::move(mEnterpriseRoots);

    MOZ_ASSERT(!mEnterpriseRoots);

  }

  MOZ_ASSERT(enterpriseRoots);

  // It would be intuitive to set the trust to { 0, 0, 0 } here. However, this

  // doesn't work for temporary certificates because CERT_ChangeCertTrust first

  // looks up the current trust settings in the permanent cert database, finds

  // that such trust doesn't exist, considers the current trust to be

  // { 0, 0, 0 }, and decides that it doesn't need to update the trust since

  // they're the same. To work around this, we set a non-zero flag to ensure

  // that the trust will get updated.

  CERTCertTrust trust = { CERTDB_USER, 0, 0 };

  for (CERTCertListNode* n = CERT_LIST_HEAD(enterpriseRoots.get());

       !CERT_LIST_END(n, enterpriseRoots.get()); n = CERT_LIST_NEXT(n)) {

    if (!n) {

      break;

    }

    if (!n->cert) {

      continue;

    }

    UniqueCERTCertificate cert(CERT_DupCertificate(n->cert));

    if (ChangeCertTrustWithPossibleAuthentication(cert, trust, nullptr)

          != SECSuccess) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

              ("couldn't untrust certificate for TLS server auth"));

    }

  }

  MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("unloaded enterprise roots"));

}

static const char* kEnterpriseRootModePref = "security.enterprise_roots.enabled";

void

nsNSSComponent::MaybeImportEnterpriseRoots()

{

  MOZ_ASSERT(NS_IsMainThread());

  if (!NS_IsMainThread()) {

    return;

  }

  bool importEnterpriseRoots = Preferences::GetBool(kEnterpriseRootModePref,

                                                    false);

  if (!importEnterpriseRoots) {

    return;

  }

  ImportEnterpriseRoots();

}

void

nsNSSComponent::ImportEnterpriseRoots()

{

  UniqueCERTCertList roots;

  nsresult rv = GatherEnterpriseRoots(roots);

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("failed gathering enterprise roots"));

    return;

  }

  {

    MutexAutoLock lock(mMutex);

    mEnterpriseRoots = std::move(roots);

  }

}

nsresult

nsNSSComponent::TrustLoaded3rdPartyRoots()

{

  // We can't call ChangeCertTrustWithPossibleAuthentication while holding

  // mMutex (because it could potentially call back in to nsNSSComponent and

  // attempt to acquire mMutex), so we copy mEnterpriseRoots.

  UniqueCERTCertList enterpriseRoots;

  {

    MutexAutoLock lock(mMutex);

    if (mEnterpriseRoots) {

      enterpriseRoots = nsNSSCertList::DupCertList(mEnterpriseRoots);

      if (!enterpriseRoots) {

        return NS_ERROR_OUT_OF_MEMORY;

      }

    }

  }

  CERTCertTrust trust = {

    CERTDB_TRUSTED_CA | CERTDB_VALID_CA | CERTDB_USER,

    0,

    0

  };

  if (enterpriseRoots) {

    for (CERTCertListNode* n = CERT_LIST_HEAD(enterpriseRoots.get());

         !CERT_LIST_END(n, enterpriseRoots.get()); n = CERT_LIST_NEXT(n)) {

      if (!n) {

        break;

      }

      if (!n->cert) {

        continue;

      }

      UniqueCERTCertificate cert(CERT_DupCertificate(n->cert));

      if (ChangeCertTrustWithPossibleAuthentication(cert, trust, nullptr)

            != SECSuccess) {

        MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

                ("couldn't trust enterprise certificate for TLS server auth"));

      }

    }

  }

#ifdef XP_WIN

  // Again copy mFamilySafetyRoot so we don't hold mMutex while calling

  // ChangeCertTrustWithPossibleAuthentication.

  UniqueCERTCertificate familySafetyRoot;

  {

    MutexAutoLock lock(mMutex);

    if (mFamilySafetyRoot) {

      familySafetyRoot.reset(CERT_DupCertificate(mFamilySafetyRoot.get()));

      if (!familySafetyRoot) {

        return NS_ERROR_OUT_OF_MEMORY;

      }

    }

  }

  if (familySafetyRoot &&

      ChangeCertTrustWithPossibleAuthentication(familySafetyRoot, trust,

                                                nullptr) != SECSuccess) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Debug,

            ("couldn't trust family safety certificate for TLS server auth"));

  }

#endif

  return NS_OK;

}

NS_IMETHODIMP

nsNSSComponent::GetEnterpriseRoots(nsIX509CertList** enterpriseRoots)

{

  MutexAutoLock nsNSSComponentLock(mMutex);

  MOZ_ASSERT(NS_IsMainThread());

  if (!NS_IsMainThread()) {

    return NS_ERROR_NOT_SAME_THREAD;

  }

  NS_ENSURE_ARG_POINTER(enterpriseRoots);

  if (!mEnterpriseRoots) {

    *enterpriseRoots = nullptr;

    return NS_OK;

  }

  UniqueCERTCertList enterpriseRootsCopy(

    nsNSSCertList::DupCertList(mEnterpriseRoots));

  if (!enterpriseRootsCopy) {

    return NS_ERROR_FAILURE;

  }

  nsCOMPtr<nsIX509CertList> enterpriseRootsCertList(

    new nsNSSCertList(std::move(enterpriseRootsCopy)));

  if (!enterpriseRootsCertList) {

    return NS_ERROR_FAILURE;

  }

  enterpriseRootsCertList.forget(enterpriseRoots);

  return NS_OK;

}

class LoadLoadableRootsTask final : public Runnable

{

public:

  explicit LoadLoadableRootsTask(nsNSSComponent* nssComponent,

                                 bool importEnterpriseRoots,

                                 uint32_t familySafetyMode)

    : Runnable("LoadLoadableRootsTask")

    , mNSSComponent(nssComponent)

    , mImportEnterpriseRoots(importEnterpriseRoots)

    , mFamilySafetyMode(familySafetyMode)

  {

    MOZ_ASSERT(nssComponent);

  }

  ~LoadLoadableRootsTask() = default;

  nsresult Dispatch();

private:

  NS_IMETHOD Run() override;

  nsresult LoadLoadableRoots();

  RefPtr<nsNSSComponent> mNSSComponent;

  bool mImportEnterpriseRoots;

  uint32_t mFamilySafetyMode;

  nsCOMPtr<nsIThread> mThread;

};

nsresult

LoadLoadableRootsTask::Dispatch()

{

  // Can't add 'this' as the event to run, since mThread may not be set yet

  nsresult rv = NS_NewNamedThread("LoadRoots", getter_AddRefs(mThread),

                                  nullptr,

                                  nsIThreadManager::DEFAULT_STACK_SIZE);

  if (NS_FAILED(rv)) {

    return rv;

  }

  // Note: event must not null out mThread!

  return mThread->Dispatch(this, NS_DISPATCH_NORMAL);

}

NS_IMETHODIMP

LoadLoadableRootsTask::Run()

{

  // First we Run() on the "LoadRoots" thread, do our work, and then we Run()

  // again on the main thread so we can shut down the thread (since we don't

  // need it any more). We can't shut down the thread while we're *on* the

  // thread, which is why we do the dispatch to the main thread. CryptoTask.cpp

  // (which informs this code) says that we can't null out mThread. This appears

  // to be because its refcount could be decreased while this dispatch is being

  // processed, so it might get prematurely destroyed. I'm not sure this makes

  // sense but it'll get cleaned up in our destructor anyway, so it's fine to

  // not null it out here (as long as we don't run twice on the main thread,

  // which shouldn't be possible).

  if (NS_IsMainThread()) {

    if (mThread) {

      mThread->Shutdown();

    }

    return NS_OK;

  }

  nsresult loadLoadableRootsResult = LoadLoadableRoots();

  if (NS_WARN_IF(NS_FAILED(loadLoadableRootsResult))) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Error, ("LoadLoadableRoots failed"));

    // We don't return loadLoadableRootsResult here because then

    // BlockUntilLoadableRootsLoaded will just wait forever. Instead we'll save

    // its value (below) so we can inform code that relies on the roots module

    // being present that loading it failed.

  }

  // Loading EV information will only succeed if we've successfully loaded the

  // loadable roots module.

  if (NS_SUCCEEDED(loadLoadableRootsResult)) {

    if (NS_FAILED(LoadExtendedValidationInfo())) {

      // This isn't a show-stopper in the same way that failing to load the

      // roots module is.

      MOZ_LOG(gPIPNSSLog, LogLevel::Error, ("failed to load EV info"));

    }

  }

  if (mImportEnterpriseRoots) {

    mNSSComponent->ImportEnterpriseRoots();

  }

  mNSSComponent->MaybeEnableFamilySafetyCompatibility(mFamilySafetyMode);

  nsresult rv = mNSSComponent->TrustLoaded3rdPartyRoots();

  if (NS_FAILED(rv)) {

    MOZ_LOG(gPIPNSSLog, LogLevel::Error,

            ("failed to trust loaded 3rd party roots"));

  }

  {

    MonitorAutoLock rootsLoadedLock(mNSSComponent->mLoadableRootsLoadedMonitor);

    mNSSComponent->mLoadableRootsLoaded = true;

    // Cache the result of LoadLoadableRoots so BlockUntilLoadableRootsLoaded

    // can return it to all callers later.

    mNSSComponent->mLoadableRootsLoadedResult = loadLoadableRootsResult;

    rv = mNSSComponent->mLoadableRootsLoadedMonitor.NotifyAll();

    if (NS_WARN_IF(NS_FAILED(rv))) {

      MOZ_LOG(gPIPNSSLog, LogLevel::Error,

              ("failed to notify loadable roots loaded monitor"));

    }

  }

  // Go back to the main thread to clean up this worker thread.

  return NS_DispatchToMainThread(this);

}

NS_IMETHODIMP

nsNSSComponent::HasActiveSmartCards(bool* result)

{

  NS_ENSURE_ARG_POINTER(result);

  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");

  if (!NS_IsMainThread()) {

    return NS_ERROR_NOT_SAME_THREAD;

  }

#ifndef MOZ_NO_SMART_CARDS

  MutexAutoLock nsNSSComponentLock(mMutex);

  AutoSECMODListReadLock secmodLock;

  SECMODModuleList* list = SECMOD_GetDefaultModuleList();

  while (list) {

    if (SECMOD_HasRemovableSlots(list->module)) {

      *result = true;

      return NS_OK;

    }

    list = list->next;

  }

#endif

  *result = false;

  return NS_OK;

}

NS_IMETHODIMP

nsNSSComponent::HasUserCertsInstalled(bool* result)

{

  NS_ENSURE_ARG_POINTER(result);

  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");

  if (!NS_IsMainThread()) {

    return NS_ERROR_NOT_SAME_THREAD;

  }

  *result = false;

  UniqueCERTCertList certList(

    CERT_FindUserCertsByUsage(CERT_GetDefaultCertDB(), certUsageSSLClient,

                              false, true, nullptr));

  if (!certList) {

    return NS_OK;

  }

  // check if the list is empty

  if (CERT_LIST_END(CERT_LIST_HEAD(certList), certList)) {

    return NS_OK;

  }

  // The list is not empty, meaning at least one cert is installed

  *result = true;

  return NS_OK;

}

nsresult

nsNSSComponent::BlockUntilLoadableRootsLoaded()

{

  MonitorAutoLock rootsLoadedLock(mLoadableRootsLoadedMonitor);

  while (!mLoadableRootsLoaded) {

    rootsLoadedLock.Wait();

  }

  MOZ_ASSERT(mLoadableRootsLoaded);

  return mLoadableRootsLoadedResult;

}

nsresult

nsNSSComponent::CheckForSmartCardChanges()

{

#ifndef MOZ_NO_SMART_CARDS

  // SECMOD_UpdateSlotList attempts to acquire the list lock as well,

  // so we have to do this in two steps. The lock protects the list itself, so

  // if we get our own owned references to the modules we're interested in,

  // there's no thread safety concern here.

  Vector<UniqueSECMODModule> modulesWithRemovableSlots;

  {

    AutoSECMODListReadLock secmodLock;

    SECMODModuleList* list = SECMOD_GetDefaultModuleList();

    while (list) {

      if (SECMOD_HasRemovableSlots(list->module)) {

        UniqueSECMODModule module(SECMOD_ReferenceModule(list->module));

        if (!modulesWithRemovableSlots.append(std::move(module))) {

          return NS_ERROR_OUT_OF_MEMORY;

        }

      }

      list = list->next;

    }

  }

  for (auto& module : modulesWithRemovableSlots) {

    // Best-effort.