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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "NSSCertDBTrustDomain.h"

#include <stdint.h>

#include "ExtendedValidation.h"

#include "NSSErrorsService.h"

#include "OCSPRequestor.h"

#include "OCSPVerificationTrustDomain.h"

#include "PublicKeyPinningService.h"

#include "cert.h"

#include "certdb.h"

#include "mozilla/Assertions.h"

#include "mozilla/Casting.h"

#include "mozilla/Move.h"

#include "mozilla/PodOperations.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/Unused.h"

#include "nsNSSCertificate.h"

#include "nsServiceManagerUtils.h"

#include "nss.h"

#include "pk11pub.h"

#include "pkix/Result.h"

#include "pkix/pkix.h"

#include "pkix/pkixnss.h"

#include "prerror.h"

#include "prmem.h"

#include "secerr.h"

#include "CNNICHashWhitelist.inc"

#include "StartComAndWoSignData.inc"

using namespace mozilla;

using namespace mozilla::pkix;

extern LazyLogModule gCertVerifierLog;

static const uint64_t ServerFailureDelaySeconds = 5 * 60;

namespace mozilla { namespace psm {

NSSCertDBTrustDomain::NSSCertDBTrustDomain(SECTrustType certDBTrustType,

                                           OCSPFetching ocspFetching,

                                           OCSPCache& ocspCache,

             /*optional but shouldn't be*/ void* pinArg,

                                           CertVerifier::OcspGetConfig ocspGETConfig,

                                           uint32_t certShortLifetimeInDays,

                                           CertVerifier::PinningMode pinningMode,

                                           unsigned int minRSABits,

                                           ValidityCheckingMode validityCheckingMode,

                                           CertVerifier::SHA1Mode sha1Mode,

                                           NetscapeStepUpPolicy netscapeStepUpPolicy,

                                           const OriginAttributes& originAttributes,

                                           UniqueCERTCertList& builtChain,

                              /*optional*/ PinningTelemetryInfo* pinningTelemetryInfo,

                              /*optional*/ const char* hostname)

  : mCertDBTrustType(certDBTrustType)

  , mOCSPFetching(ocspFetching)

  , mOCSPCache(ocspCache)

  , mPinArg(pinArg)

  , mOCSPGetConfig(ocspGETConfig)

  , mCertShortLifetimeInDays(certShortLifetimeInDays)

  , mPinningMode(pinningMode)

  , mMinRSABits(minRSABits)

  , mValidityCheckingMode(validityCheckingMode)

  , mSHA1Mode(sha1Mode)

  , mNetscapeStepUpPolicy(netscapeStepUpPolicy)

  , mOriginAttributes(originAttributes)

  , mBuiltChain(builtChain)

  , mPinningTelemetryInfo(pinningTelemetryInfo)

  , mHostname(hostname)

  , mCertBlocklist(do_GetService(NS_CERTBLOCKLIST_CONTRACTID))

  , mOCSPStaplingStatus(CertVerifier::OCSP_STAPLING_NEVER_CHECKED)

  , mSCTListFromCertificate()

  , mSCTListFromOCSPStapling()

{

}

// If useRoots is true, we only use root certificates in the candidate list.

// If useRoots is false, we only use non-root certificates in the list.

static Result

FindIssuerInner(const UniqueCERTCertList& candidates, bool useRoots,

                Input encodedIssuerName, TrustDomain::IssuerChecker& checker,

                /*out*/ bool& keepGoing)

{

  keepGoing = true;

  for (CERTCertListNode* n = CERT_LIST_HEAD(candidates);

       !CERT_LIST_END(n, candidates); n = CERT_LIST_NEXT(n)) {

    bool candidateIsRoot = !!n->cert->isRoot;

    if (candidateIsRoot != useRoots) {

      continue;

    }

    Input certDER;

    Result rv = certDER.Init(n->cert->derCert.data, n->cert->derCert.len);

    if (rv != Success) {

      continue; // probably too big

    }

    const SECItem encodedIssuerNameItem = {

      siBuffer,

      const_cast<unsigned char*>(encodedIssuerName.UnsafeGetData()),

      encodedIssuerName.GetLength()

    };

    ScopedAutoSECItem nameConstraints;

    SECStatus srv = CERT_GetImposedNameConstraints(&encodedIssuerNameItem,

                                                   &nameConstraints);

    if (srv != SECSuccess) {

      if (PR_GetError() != SEC_ERROR_EXTENSION_NOT_FOUND) {

        return Result::FATAL_ERROR_LIBRARY_FAILURE;

      }

      // If no imposed name constraints were found, continue without them

      rv = checker.Check(certDER, nullptr, keepGoing);

    } else {

      // Otherwise apply the constraints

      Input nameConstraintsInput;

      if (nameConstraintsInput.Init(nameConstraints.data, nameConstraints.len)

            != Success) {

        return Result::FATAL_ERROR_LIBRARY_FAILURE;

      }

      rv = checker.Check(certDER, &nameConstraintsInput, keepGoing);

    }

    if (rv != Success) {

      return rv;

    }

    if (!keepGoing) {

      break;

    }

  }

  return Success;

}

Result

NSSCertDBTrustDomain::FindIssuer(Input encodedIssuerName,

                                 IssuerChecker& checker, Time)

{

  // TODO: NSS seems to be ambiguous between "no potential issuers found" and

  // "there was an error trying to retrieve the potential issuers."

  SECItem encodedIssuerNameItem = UnsafeMapInputToSECItem(encodedIssuerName);

  UniqueCERTCertList

    candidates(CERT_CreateSubjectCertList(nullptr, CERT_GetDefaultCertDB(),

                                          &encodedIssuerNameItem, 0,

                                          false));

  if (candidates) {

    // First, try all the root certs; then try all the non-root certs.

    bool keepGoing;

    Result rv = FindIssuerInner(candidates, true, encodedIssuerName, checker,

                                keepGoing);

    if (rv != Success) {

      return rv;

    }

    if (keepGoing) {

      rv = FindIssuerInner(candidates, false, encodedIssuerName, checker,

                           keepGoing);

      if (rv != Success) {

        return rv;

      }

    }

  }

  return Success;

}

Result

NSSCertDBTrustDomain::GetCertTrust(EndEntityOrCA endEntityOrCA,

                                   const CertPolicyId& policy,

                                   Input candidateCertDER,

                                   /*out*/ TrustLevel& trustLevel)

{

  // XXX: This would be cleaner and more efficient if we could get the trust

  // information without constructing a CERTCertificate here, but NSS doesn't

  // expose it in any other easy-to-use fashion. The use of

  // CERT_NewTempCertificate to get a CERTCertificate shouldn't be a

  // performance problem because NSS will just find the existing

  // CERTCertificate in its in-memory cache and return it.

  SECItem candidateCertDERSECItem = UnsafeMapInputToSECItem(candidateCertDER);

  UniqueCERTCertificate candidateCert(

    CERT_NewTempCertificate(CERT_GetDefaultCertDB(), &candidateCertDERSECItem,

                            nullptr, false, true));

  if (!candidateCert) {

    return MapPRErrorCodeToResult(PR_GetError());

  }

  // Check the certificate against the OneCRL cert blocklist

  if (!mCertBlocklist) {

    return Result::FATAL_ERROR_LIBRARY_FAILURE;

  }

  // The certificate blocklist currently only applies to TLS server

  // certificates.

  if (mCertDBTrustType == trustSSL) {

    bool isCertRevoked;

    nsresult nsrv = mCertBlocklist->IsCertRevoked(

                      candidateCert->derIssuer.data,

                      candidateCert->derIssuer.len,

                      candidateCert->serialNumber.data,

                      candidateCert->serialNumber.len,

                      candidateCert->derSubject.data,

                      candidateCert->derSubject.len,

                      candidateCert->derPublicKey.data,

                      candidateCert->derPublicKey.len,

                      &isCertRevoked);

    if (NS_FAILED(nsrv)) {

      return Result::FATAL_ERROR_LIBRARY_FAILURE;

    }

    if (isCertRevoked) {

      MOZ_LOG(gCertVerifierLog, LogLevel::Debug,

             ("NSSCertDBTrustDomain: certificate is in blocklist"));

      return Result::ERROR_REVOKED_CERTIFICATE;

    }

  }

  // XXX: CERT_GetCertTrust seems to be abusing SECStatus as a boolean, where

  // SECSuccess means that there is a trust record and SECFailure means there

  // is not a trust record. I looked at NSS's internal uses of

  // CERT_GetCertTrust, and all that code uses the result as a boolean meaning

  // "We have a trust record."

  CERTCertTrust trust;

  if (CERT_GetCertTrust(candidateCert.get(), &trust) == SECSuccess) {

    uint32_t flags = SEC_GET_TRUST_FLAGS(&trust, mCertDBTrustType);

    // For DISTRUST, we use the CERTDB_TRUSTED or CERTDB_TRUSTED_CA bit,

    // because we can have active distrust for either type of cert. Note that

    // CERTDB_TERMINAL_RECORD means "stop trying to inherit trust" so if the

    // relevant trust bit isn't set then that means the cert must be considered

    // distrusted.

    uint32_t relevantTrustBit =

      endEntityOrCA == EndEntityOrCA::MustBeCA ? CERTDB_TRUSTED_CA

                                               : CERTDB_TRUSTED;

    if (((flags & (relevantTrustBit|CERTDB_TERMINAL_RECORD)))

            == CERTDB_TERMINAL_RECORD) {

      trustLevel = TrustLevel::ActivelyDistrusted;

      return Success;

    }

    // For TRUST, we only use the CERTDB_TRUSTED_CA bit, because Gecko hasn't

    // needed to consider end-entity certs to be their own trust anchors since

    // Gecko implemented nsICertOverrideService.

    // Of course, for this to work as expected, we need to make sure we're

    // inquiring about the trust of a CA and not an end-entity. If an end-entity

    // has the CERTDB_TRUSTED_CA bit set, Gecko does not consider it to be a

    // trust anchor; it must inherit its trust.

    if (flags & CERTDB_TRUSTED_CA && endEntityOrCA == EndEntityOrCA::MustBeCA) {

      if (policy.IsAnyPolicy()) {

        trustLevel = TrustLevel::TrustAnchor;

        return Success;

      }

      if (CertIsAuthoritativeForEVPolicy(candidateCert, policy)) {

        trustLevel = TrustLevel::TrustAnchor;

        return Success;

      }

    }

  }

  trustLevel = TrustLevel::InheritsTrust;

  return Success;

}

Result

NSSCertDBTrustDomain::DigestBuf(Input item, DigestAlgorithm digestAlg,

                                /*out*/ uint8_t* digestBuf, size_t digestBufLen)

{

  return DigestBufNSS(item, digestAlg, digestBuf, digestBufLen);

}

static TimeDuration

OCSPFetchingTypeToTimeoutTime(NSSCertDBTrustDomain::OCSPFetching ocspFetching)

{

  switch (ocspFetching) {

    case NSSCertDBTrustDomain::FetchOCSPForDVSoftFail:

      return TimeDuration::FromSeconds(2);

    case NSSCertDBTrustDomain::FetchOCSPForEV:

    case NSSCertDBTrustDomain::FetchOCSPForDVHardFail:

      return TimeDuration::FromSeconds(10);

    // The rest of these are error cases. Assert in debug builds, but return

    // the default value corresponding to 2 seconds in release builds.

    case NSSCertDBTrustDomain::NeverFetchOCSP:

    case NSSCertDBTrustDomain::LocalOnlyOCSPForEV:

      MOZ_ASSERT_UNREACHABLE("we should never see this OCSPFetching type here");

      break;

  }

  MOZ_ASSERT_UNREACHABLE("we're not handling every OCSPFetching type");

  return TimeDuration::FromSeconds(2);

}

// Copied and modified from CERT_GetOCSPAuthorityInfoAccessLocation and

// CERT_GetGeneralNameByType. Returns a non-Result::Success result on error,

// Success with url == nullptr when an OCSP URI was not found, and Success with

// url != nullptr when an OCSP URI was found. The output url will be owned

// by the arena.

static Result

GetOCSPAuthorityInfoAccessLocation(const UniquePLArenaPool& arena,

                                   Input aiaExtension,

                                   /*out*/ char const*& url)

{

  MOZ_ASSERT(arena.get());

  if (!arena.get()) {

    return Result::FATAL_ERROR_INVALID_ARGS;

  }

  url = nullptr;

  SECItem aiaExtensionSECItem = UnsafeMapInputToSECItem(aiaExtension);

  CERTAuthInfoAccess** aia =

    CERT_DecodeAuthInfoAccessExtension(arena.get(), &aiaExtensionSECItem);

  if (!aia) {

    return Result::ERROR_CERT_BAD_ACCESS_LOCATION;

  }