/* 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 "CertVerifier.h"
#include "OCSPCache.h"
#include "gtest/gtest.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/Casting.h"
#include "mozilla/Preferences.h"
#include "mozilla/Sprintf.h"
#include "nss.h"
#include "mozpkix/pkixtypes.h"
#include "mozpkix/test/pkixtestutil.h"
#include "prerr.h"
#include "secerr.h"

using namespace mozilla::pkix;
using namespace mozilla::pkix::test;

using mozilla::OriginAttributes;

template <size_t N>
inline Input LiteralInput(const char (&valueString)[N]) {
  // Ideally we would use mozilla::BitwiseCast() here rather than
  // reinterpret_cast for better type checking, but the |N - 1| part trips
  // static asserts.
  return Input(reinterpret_cast<const uint8_t (&)[N - 1]>(valueString));
}

const int MaxCacheEntries = 1024;

class psm_OCSPCacheTest : public ::testing::Test {
 protected:
  psm_OCSPCacheTest() : now(Now()) {}

  static void SetUpTestCase() { NSS_NoDB_Init(nullptr); }

  const Time now;
  mozilla::psm::OCSPCache cache;
};

static void PutAndGet(
    mozilla::psm::OCSPCache& cache, const CertID& certID, Result result,
    Time time, const OriginAttributes& originAttributes = OriginAttributes()) {
  // The first time is thisUpdate. The second is validUntil.
  // The caller is expecting the validUntil returned with Get
  // to be equal to the passed-in time. Since these values will
  // be different in practice, make thisUpdate less than validUntil.
  Time thisUpdate(time);
  ASSERT_EQ(Success, thisUpdate.SubtractSeconds(10));
  Result rv = cache.Put(certID, originAttributes, result, thisUpdate, time);
  ASSERT_TRUE(rv == Success);
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_TRUE(cache.Get(certID, originAttributes, resultOut, timeOut));
  ASSERT_EQ(result, resultOut);
  ASSERT_EQ(time, timeOut);
}

MOZ_RUNINIT Input fakeIssuer1(LiteralInput("CN=issuer1"));
MOZ_RUNINIT Input fakeKey000(LiteralInput("key000"));
MOZ_RUNINIT Input fakeKey001(LiteralInput("key001"));
MOZ_RUNINIT Input fakeSerial0000(LiteralInput("0000"));

TEST_F(psm_OCSPCacheTest, TestPutAndGet) {
  Input fakeSerial000(LiteralInput("000"));
  Input fakeSerial001(LiteralInput("001"));

  SCOPED_TRACE("");
  PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial001), Success,
            now);
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial000),
                         OriginAttributes(), resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, TestVariousGets) {
  SCOPED_TRACE("");
  for (int i = 0; i < MaxCacheEntries; i++) {
    uint8_t serialBuf[8];
    snprintf(mozilla::BitwiseCast<char*, uint8_t*>(serialBuf),
             sizeof(serialBuf), "%04d", i);
    Input fakeSerial;
    ASSERT_EQ(Success, fakeSerial.Init(serialBuf, 4));
    Time timeIn(now);
    ASSERT_EQ(Success, timeIn.AddSeconds(i));
    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), Success,
              timeIn);
  }

  Time timeIn(now);
  Result resultOut;
  Time timeOut(Time::uninitialized);

  // This will be at the end of the list in the cache
  CertID cert0000(fakeIssuer1, fakeKey000, fakeSerial0000);
  ASSERT_TRUE(cache.Get(cert0000, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(timeIn, timeOut);
  // Once we access it, it goes to the front
  ASSERT_TRUE(cache.Get(cert0000, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(timeIn, timeOut);

  // This will be in the middle
  Time timeInPlus512(now);
  ASSERT_EQ(Success, timeInPlus512.AddSeconds(512));

  static const Input fakeSerial0512(LiteralInput("0512"));
  CertID cert0512(fakeIssuer1, fakeKey000, fakeSerial0512);
  ASSERT_TRUE(cache.Get(cert0512, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(timeInPlus512, timeOut);
  ASSERT_TRUE(cache.Get(cert0512, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(timeInPlus512, timeOut);

  // We've never seen this certificate
  static const Input fakeSerial1111(LiteralInput("1111"));
  ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey000, fakeSerial1111),
                         OriginAttributes(), resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, TestEviction) {
  SCOPED_TRACE("");
  // By putting more distinct entries in the cache than it can hold,
  // we cause the least recently used entry to be evicted.
  for (int i = 0; i < MaxCacheEntries + 1; i++) {
    uint8_t serialBuf[8];
    snprintf(mozilla::BitwiseCast<char*, uint8_t*>(serialBuf),
             sizeof(serialBuf), "%04d", i);
    Input fakeSerial;
    ASSERT_EQ(Success, fakeSerial.Init(serialBuf, 4));
    Time timeIn(now);
    ASSERT_EQ(Success, timeIn.AddSeconds(i));
    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), Success,
              timeIn);
  }

  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial0000),
                         OriginAttributes(), resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, TestNoEvictionForRevokedResponses) {
  SCOPED_TRACE("");
  CertID notEvicted(fakeIssuer1, fakeKey000, fakeSerial0000);
  Time timeIn(now);
  PutAndGet(cache, notEvicted, Result::ERROR_REVOKED_CERTIFICATE, timeIn);
  // By putting more distinct entries in the cache than it can hold,
  // we cause the least recently used entry that isn't revoked to be evicted.
  for (int i = 1; i < MaxCacheEntries + 1; i++) {
    uint8_t serialBuf[8];
    snprintf(mozilla::BitwiseCast<char*, uint8_t*>(serialBuf),
             sizeof(serialBuf), "%04d", i);
    Input fakeSerial;
    ASSERT_EQ(Success, fakeSerial.Init(serialBuf, 4));
    Time timeIn(now);
    ASSERT_EQ(Success, timeIn.AddSeconds(i));
    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), Success,
              timeIn);
  }
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_TRUE(cache.Get(notEvicted, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, resultOut);
  ASSERT_EQ(timeIn, timeOut);

  Input fakeSerial0001(LiteralInput("0001"));
  CertID evicted(fakeIssuer1, fakeKey000, fakeSerial0001);
  ASSERT_FALSE(cache.Get(evicted, OriginAttributes(), resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, TestEverythingIsRevoked) {
  SCOPED_TRACE("");
  Time timeIn(now);
  // Fill up the cache with revoked responses.
  for (int i = 0; i < MaxCacheEntries; i++) {
    uint8_t serialBuf[8];
    snprintf(mozilla::BitwiseCast<char*, uint8_t*>(serialBuf),
             sizeof(serialBuf), "%04d", i);
    Input fakeSerial;
    ASSERT_EQ(Success, fakeSerial.Init(serialBuf, 4));
    Time timeIn(now);
    ASSERT_EQ(Success, timeIn.AddSeconds(i));
    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial),
              Result::ERROR_REVOKED_CERTIFICATE, timeIn);
  }
  static const Input fakeSerial1025(LiteralInput("1025"));
  CertID good(fakeIssuer1, fakeKey000, fakeSerial1025);
  // This will "succeed", allowing verification to continue. However,
  // nothing was actually put in the cache.
  Time timeInPlus1025(timeIn);
  ASSERT_EQ(Success, timeInPlus1025.AddSeconds(1025));
  Time timeInPlus1025Minus50(timeInPlus1025);
  ASSERT_EQ(Success, timeInPlus1025Minus50.SubtractSeconds(50));
  Result result = cache.Put(good, OriginAttributes(), Success,
                            timeInPlus1025Minus50, timeInPlus1025);
  ASSERT_EQ(Success, result);
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_FALSE(cache.Get(good, OriginAttributes(), resultOut, timeOut));

  static const Input fakeSerial1026(LiteralInput("1026"));
  CertID revoked(fakeIssuer1, fakeKey000, fakeSerial1026);
  // This will fail, causing verification to fail.
  Time timeInPlus1026(timeIn);
  ASSERT_EQ(Success, timeInPlus1026.AddSeconds(1026));
  Time timeInPlus1026Minus50(timeInPlus1026);
  ASSERT_EQ(Success, timeInPlus1026Minus50.SubtractSeconds(50));
  result =
      cache.Put(revoked, OriginAttributes(), Result::ERROR_REVOKED_CERTIFICATE,
                timeInPlus1026Minus50, timeInPlus1026);
  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, result);
}

TEST_F(psm_OCSPCacheTest, VariousIssuers) {
  SCOPED_TRACE("");
  Time timeIn(now);
  static const Input fakeIssuer2(LiteralInput("CN=issuer2"));
  static const Input fakeSerial001(LiteralInput("001"));
  CertID subject(fakeIssuer1, fakeKey000, fakeSerial001);
  PutAndGet(cache, subject, Success, now);
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_TRUE(cache.Get(subject, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(timeIn, timeOut);
  // Test that we don't match a different issuer DN
  ASSERT_FALSE(cache.Get(CertID(fakeIssuer2, fakeKey000, fakeSerial001),
                         OriginAttributes(), resultOut, timeOut));
  // Test that we don't match a different issuer key
  ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial001),
                         OriginAttributes(), resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, Times) {
  SCOPED_TRACE("");
  CertID certID(fakeIssuer1, fakeKey000, fakeSerial0000);
  PutAndGet(cache, certID, Result::ERROR_OCSP_UNKNOWN_CERT,
            TimeFromElapsedSecondsAD(100));
  PutAndGet(cache, certID, Success, TimeFromElapsedSecondsAD(200));
  // This should not override the more recent entry.
  ASSERT_EQ(
      Success,
      cache.Put(certID, OriginAttributes(), Result::ERROR_OCSP_UNKNOWN_CERT,
                TimeFromElapsedSecondsAD(100), TimeFromElapsedSecondsAD(100)));
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_TRUE(cache.Get(certID, OriginAttributes(), resultOut, timeOut));
  // Here we see the more recent time.
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(TimeFromElapsedSecondsAD(200), timeOut);

  // Result::ERROR_REVOKED_CERTIFICATE overrides everything
  PutAndGet(cache, certID, Result::ERROR_REVOKED_CERTIFICATE,
            TimeFromElapsedSecondsAD(50));
}

TEST_F(psm_OCSPCacheTest, NetworkFailure) {
  SCOPED_TRACE("");
  CertID certID(fakeIssuer1, fakeKey000, fakeSerial0000);
  PutAndGet(cache, certID, Result::ERROR_CONNECT_REFUSED,
            TimeFromElapsedSecondsAD(100));
  PutAndGet(cache, certID, Success, TimeFromElapsedSecondsAD(200));
  // This should not override the already present entry.
  ASSERT_EQ(
      Success,
      cache.Put(certID, OriginAttributes(), Result::ERROR_CONNECT_REFUSED,
                TimeFromElapsedSecondsAD(300), TimeFromElapsedSecondsAD(350)));
  Result resultOut;
  Time timeOut(Time::uninitialized);
  ASSERT_TRUE(cache.Get(certID, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Success, resultOut);
  ASSERT_EQ(TimeFromElapsedSecondsAD(200), timeOut);

  PutAndGet(cache, certID, Result::ERROR_OCSP_UNKNOWN_CERT,
            TimeFromElapsedSecondsAD(400));
  // This should not override the already present entry.
  ASSERT_EQ(
      Success,
      cache.Put(certID, OriginAttributes(), Result::ERROR_CONNECT_REFUSED,
                TimeFromElapsedSecondsAD(500), TimeFromElapsedSecondsAD(550)));
  ASSERT_TRUE(cache.Get(certID, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Result::ERROR_OCSP_UNKNOWN_CERT, resultOut);
  ASSERT_EQ(TimeFromElapsedSecondsAD(400), timeOut);

  PutAndGet(cache, certID, Result::ERROR_REVOKED_CERTIFICATE,
            TimeFromElapsedSecondsAD(600));
  // This should not override the already present entry.
  ASSERT_EQ(
      Success,
      cache.Put(certID, OriginAttributes(), Result::ERROR_CONNECT_REFUSED,
                TimeFromElapsedSecondsAD(700), TimeFromElapsedSecondsAD(750)));
  ASSERT_TRUE(cache.Get(certID, OriginAttributes(), resultOut, timeOut));
  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, resultOut);
  ASSERT_EQ(TimeFromElapsedSecondsAD(600), timeOut);
}

TEST_F(psm_OCSPCacheTest, TestOriginAttributes) {
  CertID certID(fakeIssuer1, fakeKey000, fakeSerial0000);

  // We test firstPartyDomain, partitionKey, userContextId, and
  // privateBrowsingId as independent isolation dimensions.

  SCOPED_TRACE("");
  OriginAttributes attrs;
  attrs.mFirstPartyDomain.AssignLiteral("foo.com");
  PutAndGet(cache, certID, Success, now, attrs);

  Result resultOut;
  Time timeOut(Time::uninitialized);

  // OCSP cache entry should not exist for the other firstPartyDomain.
  attrs.mFirstPartyDomain.AssignLiteral("bar.com");
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache should be isolated by containers for firstPartyDomain.
  attrs.mUserContextId = 1;
  attrs.mFirstPartyDomain.AssignLiteral("foo.com");
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache entry should exist for the original firstPartyDomain and
  // container.
  attrs.mUserContextId = 0;
  attrs.mFirstPartyDomain.AssignLiteral("foo.com");
  ASSERT_TRUE(cache.Get(certID, attrs, resultOut, timeOut));

  // Clear originAttributes.
  attrs.mUserContextId = 0;
  attrs.mFirstPartyDomain.Truncate();

  // Add OCSP cache for the partitionKey.
  attrs.mPartitionKey.AssignLiteral("(https,foo.com)");
  PutAndGet(cache, certID, Success, now, attrs);

  // Check cache entry for the partitionKey.
  attrs.mPartitionKey.AssignLiteral("(https,foo.com)");
  ASSERT_TRUE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache entry should not exist for the other partitionKey.
  attrs.mPartitionKey.AssignLiteral("(https,bar.com)");
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache should be isolated by containers for partitionKey.
  attrs.mUserContextId = 1;
  attrs.mPartitionKey.AssignLiteral("(https,foo.com)");
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache should not exist for the OAs which has both attributes set.
  attrs.mUserContextId = 0;
  attrs.mFirstPartyDomain.AssignLiteral("foo.com");
  attrs.mPartitionKey.AssignLiteral("(https,foo.com)");
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));

  // OCSP cache should be isolated by private browsing mode.
  attrs.mUserContextId = 0;
  attrs.mFirstPartyDomain.Truncate();
  attrs.mPartitionKey.Truncate();
  PutAndGet(cache, certID, Success, now, attrs);
  attrs.mPrivateBrowsingId = 1;
  ASSERT_FALSE(cache.Get(certID, attrs, resultOut, timeOut));
}

TEST_F(psm_OCSPCacheTest, TestClearPrivateBrowsing) {
  // Insert entries in the order p, n, p, p, n, p to exercise removal at the
  // beginning, end, and middle of the vector, including consecutive privates.
  CertID certID0(fakeIssuer1, fakeKey000, LiteralInput("s0"));
  CertID certID1(fakeIssuer1, fakeKey000, LiteralInput("s1"));
  CertID certID2(fakeIssuer1, fakeKey000, LiteralInput("s2"));
  CertID certID3(fakeIssuer1, fakeKey000, LiteralInput("s3"));

  OriginAttributes normalAttrs;
  OriginAttributes pbAttrs;
  pbAttrs.mPrivateBrowsingId = 1;

  SCOPED_TRACE("");
  PutAndGet(cache, certID0, Success, now, pbAttrs);
  PutAndGet(cache, certID0, Success, now, normalAttrs);
  PutAndGet(cache, certID1, Success, now, pbAttrs);
  PutAndGet(cache, certID2, Success, now, pbAttrs);
  PutAndGet(cache, certID1, Success, now, normalAttrs);
  PutAndGet(cache, certID3, Success, now, pbAttrs);

  cache.ClearPrivateBrowsing();

  Result resultOut;
  Time timeOut(Time::uninitialized);

  // Normal entries should still be present.
  ASSERT_TRUE(cache.Get(certID0, normalAttrs, resultOut, timeOut));
  ASSERT_TRUE(cache.Get(certID1, normalAttrs, resultOut, timeOut));

  // All private browsing entries should have been removed.
  ASSERT_FALSE(cache.Get(certID0, pbAttrs, resultOut, timeOut));
  ASSERT_FALSE(cache.Get(certID1, pbAttrs, resultOut, timeOut));
  ASSERT_FALSE(cache.Get(certID2, pbAttrs, resultOut, timeOut));
  ASSERT_FALSE(cache.Get(certID3, pbAttrs, resultOut, timeOut));
}