OpenSSLCertUtilsTest.cpp File Reference

#include <folly/ssl/OpenSSLCertUtils.h>
#include <folly/Format.h>
#include <folly/Range.h>
#include <folly/String.h>
#include <folly/container/Enumerate.h>
#include <folly/portability/GTest.h>
#include <folly/portability/OpenSSL.h>
#include <folly/ssl/Init.h>
#include <folly/ssl/OpenSSLPtrTypes.h>

Go to the source code of this file.

Classes
class	OpenSSLCertUtilsTest

Functions
	INSTANTIATE_TEST_CASE_P (OpenSSLCertUtilsTest, OpenSSLCertUtilsTest, Bool())
static folly::ssl::X509UniquePtr	readCertFromFile (const std::string &filename)
static folly::ssl::X509UniquePtr	readCertFromData (const folly::StringPiece data)
static void	validateTestCertBundle (const std::vector< folly::ssl::X509UniquePtr > &certs)
static void	validateTestCertWithSAN (X509 *x509)
	TEST_P (OpenSSLCertUtilsTest, TestX509CN)
	TEST_P (OpenSSLCertUtilsTest, TestX509Sans)
	TEST_P (OpenSSLCertUtilsTest, TestX509IssuerAndSubject)
	TEST_P (OpenSSLCertUtilsTest, TestX509Dates)
	TEST_P (OpenSSLCertUtilsTest, TestX509Summary)
	TEST_P (OpenSSLCertUtilsTest, TestDerEncodeDecode)
	TEST_P (OpenSSLCertUtilsTest, TestDerDecodeJunkData)
	TEST_P (OpenSSLCertUtilsTest, TestDerDecodeTooShort)
	TEST_P (OpenSSLCertUtilsTest, TestReadCertsFromBuffer)
	TEST_P (OpenSSLCertUtilsTest, TestReadCertsFromMixedBuffer)
	TEST_P (OpenSSLCertUtilsTest, TestX509Digest)
	TEST_P (OpenSSLCertUtilsTest, TestX509Store)
	TEST_P (OpenSSLCertUtilsTest, TestProcessMalformedCertBuf)
	TEST_P (OpenSSLCertUtilsTest, TestReadStoreDuplicate)

Variables
const char *	kTestCertWithoutSan = "folly/io/async/test/certs/tests-cert.pem"
const char *	kTestCa = "folly/io/async/test/certs/ca-cert.pem"
const std::string	kTestKey
const std::string	kTestCertWithSan
const std::string	kTestCertBundle

Function Documentation

INSTANTIATE_TEST_CASE_P	(	OpenSSLCertUtilsTest	,
		OpenSSLCertUtilsTest	,
		Bool()
	)

static folly::ssl::X509UniquePtr readCertFromData ( const folly::StringPiece  data )

static

Definition at line 157 of file OpenSSLCertUtilsTest.cpp.

References folly::Range< Iter >::data(), and folly::Range< Iter >::size().

Referenced by TEST_P().

                                 {
  folly::ssl::BioUniquePtr bio(BIO_new_mem_buf(data.data(), data.size()));
  if (!bio) {
    throw std::runtime_error("Couldn't create BIO");
  }
  return folly::ssl::X509UniquePtr(
      PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
}

static folly::ssl::X509UniquePtr readCertFromFile ( const std::string &  filename )

static

Definition at line 144 of file OpenSSLCertUtilsTest.cpp.

Referenced by TEST_P().

                                                                         {
  folly::ssl::BioUniquePtr bio(BIO_new(BIO_s_file()));
  if (!bio) {
    throw std::runtime_error("Couldn't create BIO");
  }

  if (BIO_read_filename(bio.get(), filename.c_str()) != 1) {
    throw std::runtime_error("Couldn't read cert file: " + filename);
  }
  return folly::ssl::X509UniquePtr(
      PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509CN
	)

Definition at line 189 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::ssl::OpenSSLCertUtils::getCommonName(), folly::ssl::OpenSSLCertUtils::getSubjectAltNames(), kTestCertWithoutSan, and readCertFromFile().

                                         {
  auto x509 = readCertFromFile(kTestCertWithoutSan);
  EXPECT_NE(x509, nullptr);
  auto identity = folly::ssl::OpenSSLCertUtils::getCommonName(*x509);
  EXPECT_EQ(identity.value(), "Asox Company");
  auto sans = folly::ssl::OpenSSLCertUtils::getSubjectAltNames(*x509);
  EXPECT_EQ(sans.size(), 0);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509Sans
	)

Definition at line 198 of file OpenSSLCertUtilsTest.cpp.

References kTestCertWithSan, readCertFromData(), and validateTestCertWithSAN().

                                           {
  auto x509 = readCertFromData(kTestCertWithSan);
  validateTestCertWithSAN(x509.get());
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509IssuerAndSubject
	)

Definition at line 203 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::ssl::OpenSSLCertUtils::getIssuer(), folly::ssl::OpenSSLCertUtils::getSubject(), kTestCertWithSan, and readCertFromData().

                                                       {
  auto x509 = readCertFromData(kTestCertWithSan);
  EXPECT_NE(x509, nullptr);
  auto issuer = folly::ssl::OpenSSLCertUtils::getIssuer(*x509);
  EXPECT_EQ(
      issuer.value(),
      "C = US, ST = CA, O = Asox, CN = Asox Certification Authority");
  auto subj = folly::ssl::OpenSSLCertUtils::getSubject(*x509);
  EXPECT_EQ(subj.value(), "C = US, O = Asox, CN = 127.0.0.1");
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509Dates
	)

Definition at line 214 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::ssl::OpenSSLCertUtils::getNotAfterTime(), folly::ssl::OpenSSLCertUtils::getNotBeforeTime(), kTestCertWithSan, and readCertFromData().

                                            {
  auto x509 = readCertFromData(kTestCertWithSan);
  EXPECT_NE(x509, nullptr);
  auto notBefore = folly::ssl::OpenSSLCertUtils::getNotBeforeTime(*x509);
  EXPECT_EQ(notBefore, "Feb 13 23:21:03 2017 GMT");
  auto notAfter = folly::ssl::OpenSSLCertUtils::getNotAfterTime(*x509);
  EXPECT_EQ(notAfter, "Jul  1 23:21:03 2044 GMT");
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509Summary
	)

Definition at line 223 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, kTestCertWithSan, readCertFromData(), and folly::ssl::OpenSSLCertUtils::toString().

                                              {
  auto x509 = readCertFromData(kTestCertWithSan);
  EXPECT_NE(x509, nullptr);
  auto summary = folly::ssl::OpenSSLCertUtils::toString(*x509);
  EXPECT_EQ(
      summary.value(),
      "        Version: 3 (0x2)\n        Serial Number: 2 (0x2)\n"
      "        Issuer: C = US, ST = CA, O = Asox, CN = Asox Certification Authority\n"
      "        Validity\n            Not Before: Feb 13 23:21:03 2017 GMT\n"
      "            Not After : Jul  1 23:21:03 2044 GMT\n"
      "        Subject: C = US, O = Asox, CN = 127.0.0.1\n"
      "        X509v3 extensions:\n"
      "            X509v3 Basic Constraints: \n"
      "                CA:FALSE\n"
      "            Netscape Comment: \n"
      "                OpenSSL Generated Certificate\n"
      "            X509v3 Subject Key Identifier: \n"
      "                71:D6:49:9D:64:47:D7:1E:65:8B:1E:94:83:23:42:E1:F2:19:9F:C3\n"
      "            X509v3 Authority Key Identifier: \n"
      "                keyid:17:DF:29:09:29:BF:7B:9F:1A:7F:E9:46:49:C8:3B:ED:B3:B9:E8:7B\n\n"
      "            X509v3 Subject Alternative Name: \n"
      "                DNS:anotherexample.com, DNS:*.thirdexample.com\n"
      "            Authority Information Access: \n"
      "                CA Issuers - URI:https://phabricator.fb.com/diffusion/FBCODE/browse/master/ti/test_certs/ca_cert.pem?view=raw\n\n");
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestDerEncodeDecode
	)

Definition at line 249 of file OpenSSLCertUtilsTest.cpp.

References folly::ssl::OpenSSLCertUtils::derDecode(), folly::ssl::OpenSSLCertUtils::derEncode(), EXPECT_EQ, kTestCertWithSan, readCertFromData(), and folly::ssl::OpenSSLCertUtils::toString().

                                                  {
  auto x509 = readCertFromData(kTestCertWithSan);

  auto der = folly::ssl::OpenSSLCertUtils::derEncode(*x509);
  auto decoded = folly::ssl::OpenSSLCertUtils::derDecode(der->coalesce());

  EXPECT_EQ(
      folly::ssl::OpenSSLCertUtils::toString(*x509),
      folly::ssl::OpenSSLCertUtils::toString(*decoded));
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestDerDecodeJunkData
	)

Definition at line 260 of file OpenSSLCertUtilsTest.cpp.

References folly::ssl::OpenSSLCertUtils::derDecode(), and EXPECT_THROW.

                                                    {
  StringPiece junk{"MyFakeCertificate"};
  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::derDecode(junk), std::runtime_error);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestDerDecodeTooShort
	)

Definition at line 266 of file OpenSSLCertUtilsTest.cpp.

References folly::ssl::OpenSSLCertUtils::derDecode(), folly::ssl::OpenSSLCertUtils::derEncode(), EXPECT_THROW, kTestCertWithSan, and readCertFromData().

                                                    {
  auto x509 = readCertFromData(kTestCertWithSan);

  auto der = folly::ssl::OpenSSLCertUtils::derEncode(*x509);
  der->trimEnd(1);
  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::derDecode(der->coalesce()),
      std::runtime_error);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestReadCertsFromBuffer
	)

Definition at line 276 of file OpenSSLCertUtilsTest.cpp.

References kTestCertBundle, folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), and validateTestCertBundle().

                                                      {
  auto certs = folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(
      StringPiece(kTestCertBundle));
  validateTestCertBundle(certs);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestReadCertsFromMixedBuffer
	)

Definition at line 284 of file OpenSSLCertUtilsTest.cpp.

References ASSERT_EQ, kTestCertWithSan, kTestKey, folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), and validateTestCertWithSAN().

                                                           {
  std::vector<std::string> bufs(
      {folly::to<std::string>(kTestCertWithSan, "\n\n", kTestKey, "\n"),
       folly::to<std::string>(kTestKey, "\n\n", kTestCertWithSan, "\n")});
  for (auto& buf : bufs) {
    auto certs = folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(
        folly::StringPiece(buf));
    ASSERT_EQ(1, certs.size());
    validateTestCertWithSAN(certs.front().get());
  }
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509Digest
	)

Definition at line 296 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::ssl::OpenSSLCertUtils::getDigestSha1(), folly::ssl::OpenSSLCertUtils::getDigestSha256(), folly::hexlify(), kTestCertWithoutSan, folly::range(), and readCertFromFile().

                                             {
  auto x509 = readCertFromFile(kTestCertWithoutSan);
  EXPECT_NE(x509, nullptr);

  auto sha1Digest = folly::ssl::OpenSSLCertUtils::getDigestSha1(*x509);
  EXPECT_EQ(
      folly::hexlify(folly::range(sha1Digest)),
      "b84e951d6c4e6cc70346357fab43d7ed73a07b0f");

  auto sha2Digest = folly::ssl::OpenSSLCertUtils::getDigestSha256(*x509);
  EXPECT_EQ(
      folly::hexlify(folly::range(sha2Digest)),
      "364d3a6a0b10d0635ce59b40c0b7f505ab2cd9fd0a06661cdc61d9cb8c9c9821");
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestX509Store
	)

Definition at line 311 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, kTestCa, kTestCertWithoutSan, readCertFromFile(), and folly::ssl::OpenSSLCertUtils::readStoreFromFile().

                                            {
  auto store = folly::ssl::OpenSSLCertUtils::readStoreFromFile(kTestCa);
  EXPECT_NE(store, nullptr);

  auto x509 = readCertFromFile(kTestCertWithoutSan);
  folly::ssl::X509StoreCtxUniquePtr ctx(X509_STORE_CTX_new());
  auto rc = X509_STORE_CTX_init(ctx.get(), store.get(), x509.get(), nullptr);
  EXPECT_EQ(rc, 1);
  rc = X509_verify_cert(ctx.get());
  EXPECT_EQ(rc, 1);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestProcessMalformedCertBuf
	)

Definition at line 323 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_THROW, kTestCertBundle, folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), folly::ssl::OpenSSLCertUtils::readStoreFromBuffer(), and string.

                                                          {
  std::string badCert =
      "-----BEGIN CERTIFICATE-----\n"
      "yo\n"
      "-----END CERTIFICATE-----\n";

  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(
          folly::StringPiece(badCert)),
      std::runtime_error);

  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::readStoreFromBuffer(
          folly::StringPiece(badCert)),
      std::runtime_error);

  std::string bufWithBadCert =
      folly::to<std::string>(badCert, "\n", kTestCertBundle);

  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(
          folly::StringPiece(bufWithBadCert)),
      std::runtime_error);

  EXPECT_THROW(
      folly::ssl::OpenSSLCertUtils::readStoreFromBuffer(
          folly::StringPiece(bufWithBadCert)),
      std::runtime_error);
}

TEST_P	(	OpenSSLCertUtilsTest	,
		TestReadStoreDuplicate
	)

Definition at line 353 of file OpenSSLCertUtilsTest.cpp.

References EXPECT_EQ, EXPECT_NE, kTestCertBundle, and folly::ssl::OpenSSLCertUtils::readStoreFromBuffer().

                                                     {
  auto dupBundle =
      folly::to<std::string>(kTestCertBundle, "\n\n", kTestCertBundle);

  auto store = folly::ssl::OpenSSLCertUtils::readStoreFromBuffer(
      folly::StringPiece(dupBundle));
  EXPECT_NE(store, nullptr);
  EXPECT_EQ(ERR_get_error(), 0);
}

static void validateTestCertBundle ( const std::vector< folly::ssl::X509UniquePtr > &  certs )

static

Definition at line 168 of file OpenSSLCertUtilsTest.cpp.

References folly::enumerate(), EXPECT_EQ, EXPECT_TRUE, folly::ssl::OpenSSLCertUtils::getCommonName(), i, and folly::sformat().

Referenced by TEST_P().

                                                   {
  EXPECT_EQ(certs.size(), 3);
  for (auto i : folly::enumerate(certs)) {
    auto identity = folly::ssl::OpenSSLCertUtils::getCommonName(**i);
    EXPECT_TRUE(identity);
    EXPECT_EQ(*identity, folly::sformat("test cert {}", i.index + 1));
  }
}

static void validateTestCertWithSAN ( X509 *  x509 )

static

Definition at line 179 of file OpenSSLCertUtilsTest.cpp.

References ASSERT_NE, EXPECT_EQ, folly::ssl::OpenSSLCertUtils::getCommonName(), and folly::ssl::OpenSSLCertUtils::getSubjectAltNames().

Referenced by TEST_P().

                                                {
  ASSERT_NE(nullptr, x509);
  auto identity = folly::ssl::OpenSSLCertUtils::getCommonName(*x509);
  EXPECT_EQ("127.0.0.1", identity.value());
  auto altNames = folly::ssl::OpenSSLCertUtils::getSubjectAltNames(*x509);
  EXPECT_EQ(2, altNames.size());
  EXPECT_EQ("anotherexample.com", altNames[0]);
  EXPECT_EQ("*.thirdexample.com", altNames[1]);
}

Variable Documentation

const char* kTestCa = "folly/io/async/test/certs/ca-cert.pem"

Definition at line 31 of file OpenSSLCertUtilsTest.cpp.

Referenced by TEST_P().

const std::string kTestCertBundle

Definition at line 64 of file OpenSSLCertUtilsTest.cpp.

Referenced by TEST_P().

const char* kTestCertWithoutSan = "folly/io/async/test/certs/tests-cert.pem"

Definition at line 30 of file OpenSSLCertUtilsTest.cpp.

Referenced by TEST_P().

const std::string kTestCertWithSan

Initial value:

= folly::stripLeftMargin(R"(
  -----BEGIN CERTIFICATE-----
  MIIDXDCCAkSgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBQMQswCQYDVQQGEwJVUzEL
  MAkGA1UECAwCQ0ExDTALBgNVBAoMBEFzb3gxJTAjBgNVBAMMHEFzb3ggQ2VydGlm
  aWNhdGlvbiBBdXRob3JpdHkwHhcNMTcwMjEzMjMyMTAzWhcNNDQwNzAxMjMyMTAz
  WjAwMQswCQYDVQQGEwJVUzENMAsGA1UECgwEQXNveDESMBAGA1UEAwwJMTI3LjAu
  MC4xMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE7/f4YYOYunAM/VkmjDYDg3AW
  UgyyTIraWmmQZsnu0bYNV/lLLfNzCtHggxGSwEtEe40nNb9C8wQmHUvb7VBBl6OC
  ASowggEmMAkGA1UdEwQCMAAwLAYJYIZIAYb4QgENBB8WHU9wZW5TU0wgR2VuZXJh
  dGVkIENlcnRpZmljYXRlMB0GA1UdDgQWBBRx1kmdZEfXHmWLHpSDI0Lh8hmfwzAf
  BgNVHSMEGDAWgBQX3ykJKb97nxp/6UZJyDvts7noezAxBgNVHREEKjAoghJhbm90
  aGVyZXhhbXBsZS5jb22CEioudGhpcmRleGFtcGxlLmNvbTB4BggrBgEFBQcBAQRs
  MGowaAYIKwYBBQUHMAKGXGh0dHBzOi8vcGhhYnJpY2F0b3IuZmIuY29tL2RpZmZ1
  c2lvbi9GQkNPREUvYnJvd3NlL21hc3Rlci90aS90ZXN0X2NlcnRzL2NhX2NlcnQu
  cGVtP3ZpZXc9cmF3MA0GCSqGSIb3DQEBCwUAA4IBAQCj3FLjLMLudaFDiYo9pAPQ
  NBYNpG27aajQCvnEsYaMAGnNBxUUhv/E4xpnJEhatiCJWlPgGebdjXkpXYkLxnFj
  38UmpfZbNcvPPKxXmjIlkpYeFwcHTAUpFmMXVHdr8FjkDSN+qWHLllMFNAAqp0U6
  4VWjDlq9xCjzNw+8fdcEpwylpPrbNyQHqSO1k+DhM2qPuQfiWPmHe2PbJv8JB3no
  HWGi9SNe0FjtJM3066L0Gj8g/bFDo/pnyKguQyGkS7PaepK5/u5Y2fMMBO/m4+U0
  b9Yb0TvatsqL688CoZcSn73A0yAjptwbD/4HmcVlG2j/y8eTVpXisugu6Xz+QQGu
  -----END CERTIFICATE-----
)")

Definition at line 41 of file OpenSSLCertUtilsTest.cpp.

Referenced by TEST_P().

const std::string kTestKey

Initial value:

= folly::stripLeftMargin(R"(
  ----BEGIN EC PRIVATE KEY-----
  MHcCAQEEIBskFwVZ9miFN+SKCFZPe9WEuFGmP+fsecLUnsTN6bOcoAoGCCqGSM49
  AwEHoUQDQgAE7/f4YYOYunAM/VkmjDYDg3AWUgyyTIraWmmQZsnu0bYNV/lLLfNz
  CtHggxGSwEtEe40nNb9C8wQmHUvb7VBBlw==
  -----END EC PRIVATE KEY-----
)")

Definition at line 34 of file OpenSSLCertUtilsTest.cpp.

Referenced by folly::getctx(), folly::TEST(), and TEST_P().