cert_builder.cc 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/test/cert_builder.h"
  5. #include "base/files/file_path.h"
  6. #include "base/memory/ptr_util.h"
  7. #include "base/strings/string_number_conversions.h"
  8. #include "crypto/ec_private_key.h"
  9. #include "crypto/openssl_util.h"
  10. #include "crypto/rsa_private_key.h"
  11. #include "net/cert/asn1_util.h"
  12. #include "net/cert/pki/verify_signed_data.h"
  13. #include "net/cert/x509_util.h"
  14. #include "net/der/encode_values.h"
  15. #include "net/der/input.h"
  16. #include "net/der/parse_values.h"
  17. #include "net/der/parser.h"
  18. #include "net/test/cert_test_util.h"
  19. #include "net/test/test_data_directory.h"
  20. #include "testing/gtest/include/gtest/gtest.h"
  21. #include "third_party/abseil-cpp/absl/types/optional.h"
  22. #include "third_party/boringssl/src/include/openssl/evp.h"
  23. #include "third_party/boringssl/src/include/openssl/mem.h"
  24. #include "url/gurl.h"
  25. namespace net {
  26. namespace {
  27. std::string MakeRandomHexString(size_t num_bytes) {
  28. std::vector<char> rand_bytes;
  29. rand_bytes.resize(num_bytes);
  30. base::RandBytes(rand_bytes.data(), rand_bytes.size());
  31. return base::HexEncode(rand_bytes.data(), rand_bytes.size());
  32. }
  33. std::string Sha256WithRSAEncryption() {
  34. const uint8_t kSha256WithRSAEncryption[] = {0x30, 0x0D, 0x06, 0x09, 0x2a,
  35. 0x86, 0x48, 0x86, 0xf7, 0x0d,
  36. 0x01, 0x01, 0x0b, 0x05, 0x00};
  37. return std::string(std::begin(kSha256WithRSAEncryption),
  38. std::end(kSha256WithRSAEncryption));
  39. }
  40. std::string Sha1WithRSAEncryption() {
  41. const uint8_t kSha1WithRSAEncryption[] = {0x30, 0x0D, 0x06, 0x09, 0x2a,
  42. 0x86, 0x48, 0x86, 0xf7, 0x0d,
  43. 0x01, 0x01, 0x05, 0x05, 0x00};
  44. return std::string(std::begin(kSha1WithRSAEncryption),
  45. std::end(kSha1WithRSAEncryption));
  46. }
  47. std::string Md5WithRSAEncryption() {
  48. const uint8_t kMd5WithRSAEncryption[] = {0x30, 0x0d, 0x06, 0x09, 0x2a,
  49. 0x86, 0x48, 0x86, 0xf7, 0x0d,
  50. 0x01, 0x01, 0x04, 0x05, 0x00};
  51. return std::string(std::begin(kMd5WithRSAEncryption),
  52. std::end(kMd5WithRSAEncryption));
  53. }
  54. std::string EcdsaWithSha256() {
  55. const uint8_t kDer[] = {0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86,
  56. 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02};
  57. return std::string(std::begin(kDer), std::end(kDer));
  58. }
  59. std::string EcdsaWithSha1() {
  60. const uint8_t kDer[] = {0x30, 0x09, 0x06, 0x07, 0x2a, 0x86,
  61. 0x48, 0xce, 0x3d, 0x04, 0x01};
  62. return std::string(std::begin(kDer), std::end(kDer));
  63. }
  64. // Adds bytes (specified as a StringPiece) to the given CBB.
  65. // The argument ordering follows the boringssl CBB_* api style.
  66. bool CBBAddBytes(CBB* cbb, base::StringPiece bytes) {
  67. return CBB_add_bytes(cbb, reinterpret_cast<const uint8_t*>(bytes.data()),
  68. bytes.size());
  69. }
  70. // Adds bytes (from fixed size array) to the given CBB.
  71. // The argument ordering follows the boringssl CBB_* api style.
  72. template <size_t N>
  73. bool CBBAddBytes(CBB* cbb, const uint8_t (&data)[N]) {
  74. return CBB_add_bytes(cbb, data, N);
  75. }
  76. // Finalizes the CBB to a std::string.
  77. std::string FinishCBB(CBB* cbb) {
  78. size_t cbb_len;
  79. uint8_t* cbb_bytes;
  80. if (!CBB_finish(cbb, &cbb_bytes, &cbb_len)) {
  81. ADD_FAILURE() << "CBB_finish() failed";
  82. return std::string();
  83. }
  84. bssl::UniquePtr<uint8_t> delete_bytes(cbb_bytes);
  85. return std::string(reinterpret_cast<char*>(cbb_bytes), cbb_len);
  86. }
  87. } // namespace
  88. CertBuilder::CertBuilder(CRYPTO_BUFFER* orig_cert, CertBuilder* issuer)
  89. : CertBuilder(orig_cert, issuer, /*unique_subject_key_identifier=*/true) {}
  90. // static
  91. std::unique_ptr<CertBuilder> CertBuilder::FromFile(
  92. const base::FilePath& cert_and_key_file,
  93. CertBuilder* issuer) {
  94. scoped_refptr<X509Certificate> cert = ImportCertFromFile(cert_and_key_file);
  95. if (!cert)
  96. return nullptr;
  97. bssl::UniquePtr<EVP_PKEY> private_key(
  98. LoadPrivateKeyFromFile(cert_and_key_file));
  99. if (!private_key)
  100. return nullptr;
  101. auto builder = base::WrapUnique(new CertBuilder(cert->cert_buffer(), issuer));
  102. builder->key_ = std::move(private_key);
  103. return builder;
  104. }
  105. // static
  106. std::unique_ptr<CertBuilder> CertBuilder::FromStaticCert(CRYPTO_BUFFER* cert,
  107. EVP_PKEY* key) {
  108. std::unique_ptr<CertBuilder> builder = base::WrapUnique(
  109. new CertBuilder(cert, nullptr, /*unique_subject_key_identifier=*/false));
  110. // |cert_|, |key_|, and |subject_tlv_| must be initialized for |builder| to
  111. // function as the |issuer| of another CertBuilder.
  112. builder->cert_ = bssl::UpRef(cert);
  113. builder->key_ = bssl::UpRef(key);
  114. base::StringPiece subject_tlv;
  115. CHECK(asn1::ExtractSubjectFromDERCert(
  116. x509_util::CryptoBufferAsStringPiece(cert), &subject_tlv));
  117. builder->subject_tlv_ = std::string(subject_tlv);
  118. return builder;
  119. }
  120. // static
  121. std::unique_ptr<CertBuilder> CertBuilder::FromStaticCertFile(
  122. const base::FilePath& cert_and_key_file) {
  123. scoped_refptr<X509Certificate> cert = ImportCertFromFile(cert_and_key_file);
  124. if (!cert)
  125. return nullptr;
  126. bssl::UniquePtr<EVP_PKEY> private_key(
  127. LoadPrivateKeyFromFile(cert_and_key_file));
  128. if (!private_key)
  129. return nullptr;
  130. return CertBuilder::FromStaticCert(cert->cert_buffer(), private_key.get());
  131. }
  132. // static
  133. std::unique_ptr<CertBuilder> CertBuilder::FromSubjectPublicKeyInfo(
  134. base::span<const uint8_t> spki_der,
  135. CertBuilder* issuer) {
  136. DCHECK(issuer);
  137. auto builder = std::make_unique<CertBuilder>(/*orig_cert=*/nullptr, issuer);
  138. CBS cbs;
  139. CBS_init(&cbs, spki_der.data(), spki_der.size());
  140. builder->key_ = bssl::UniquePtr<EVP_PKEY>(EVP_parse_public_key(&cbs));
  141. // Check that there was no error in `EVP_parse_public_key` and that it
  142. // consumed the entire public key.
  143. if (!builder->key_ || (CBS_len(&cbs) != 0))
  144. return nullptr;
  145. return builder;
  146. }
  147. CertBuilder::~CertBuilder() = default;
  148. // static
  149. void CertBuilder::CreateSimpleChain(
  150. std::unique_ptr<CertBuilder>* out_leaf,
  151. std::unique_ptr<CertBuilder>* out_intermediate,
  152. std::unique_ptr<CertBuilder>* out_root) {
  153. const char kHostname[] = "www.example.com";
  154. base::FilePath certs_dir =
  155. GetTestNetDataDirectory()
  156. .AppendASCII("verify_certificate_chain_unittest")
  157. .AppendASCII("target-and-intermediate");
  158. CertificateList orig_certs = CreateCertificateListFromFile(
  159. certs_dir, "chain.pem", X509Certificate::FORMAT_AUTO);
  160. ASSERT_EQ(3U, orig_certs.size());
  161. // Build slightly modified variants of |orig_certs|.
  162. *out_root =
  163. std::make_unique<CertBuilder>(orig_certs[2]->cert_buffer(), nullptr);
  164. (*out_root)->SetSignatureAlgorithm(SignatureAlgorithm::kEcdsaSha256);
  165. (*out_root)->GenerateECKey();
  166. *out_intermediate = std::make_unique<CertBuilder>(
  167. orig_certs[1]->cert_buffer(), out_root->get());
  168. (*out_intermediate)->EraseExtension(der::Input(kCrlDistributionPointsOid));
  169. (*out_intermediate)->EraseExtension(der::Input(kAuthorityInfoAccessOid));
  170. (*out_intermediate)->SetSignatureAlgorithm(SignatureAlgorithm::kEcdsaSha256);
  171. (*out_intermediate)->GenerateECKey();
  172. *out_leaf = std::make_unique<CertBuilder>(orig_certs[0]->cert_buffer(),
  173. out_intermediate->get());
  174. (*out_leaf)->SetSubjectAltName(kHostname);
  175. (*out_leaf)->EraseExtension(der::Input(kCrlDistributionPointsOid));
  176. (*out_leaf)->EraseExtension(der::Input(kAuthorityInfoAccessOid));
  177. (*out_leaf)->SetSignatureAlgorithm(SignatureAlgorithm::kEcdsaSha256);
  178. (*out_leaf)->GenerateECKey();
  179. }
  180. // static
  181. void CertBuilder::CreateSimpleChain(std::unique_ptr<CertBuilder>* out_leaf,
  182. std::unique_ptr<CertBuilder>* out_root) {
  183. const char kHostname[] = "www.example.com";
  184. base::FilePath certs_dir = GetTestCertsDirectory();
  185. auto orig_root = ImportCertFromFile(certs_dir, "root_ca_cert.pem");
  186. ASSERT_TRUE(orig_root);
  187. auto orig_leaf = ImportCertFromFile(certs_dir, "ok_cert.pem");
  188. ASSERT_TRUE(orig_leaf);
  189. // Build slightly modified variants of |orig_certs|.
  190. *out_root = std::make_unique<CertBuilder>(orig_root->cert_buffer(), nullptr);
  191. (*out_root)->SetSignatureAlgorithm(SignatureAlgorithm::kEcdsaSha256);
  192. (*out_root)->GenerateECKey();
  193. *out_leaf =
  194. std::make_unique<CertBuilder>(orig_leaf->cert_buffer(), out_root->get());
  195. (*out_leaf)->SetSubjectAltName(kHostname);
  196. (*out_leaf)->SetSignatureAlgorithm(SignatureAlgorithm::kEcdsaSha256);
  197. (*out_leaf)->GenerateECKey();
  198. }
  199. // static
  200. absl::optional<SignatureAlgorithm> CertBuilder::DefaultSignatureAlgorithmForKey(
  201. EVP_PKEY* key) {
  202. if (EVP_PKEY_id(key) == EVP_PKEY_RSA)
  203. return SignatureAlgorithm::kRsaPkcs1Sha256;
  204. if (EVP_PKEY_id(key) == EVP_PKEY_EC)
  205. return SignatureAlgorithm::kEcdsaSha256;
  206. return absl::nullopt;
  207. }
  208. // static
  209. bool CertBuilder::SignData(SignatureAlgorithm signature_algorithm,
  210. base::StringPiece tbs_data,
  211. EVP_PKEY* key,
  212. CBB* out_signature) {
  213. if (!key)
  214. return false;
  215. int expected_pkey_id = 1;
  216. const EVP_MD* digest;
  217. switch (signature_algorithm) {
  218. case SignatureAlgorithm::kRsaPkcs1Md5:
  219. expected_pkey_id = EVP_PKEY_RSA;
  220. digest = EVP_md5();
  221. break;
  222. case SignatureAlgorithm::kRsaPkcs1Sha1:
  223. expected_pkey_id = EVP_PKEY_RSA;
  224. digest = EVP_sha1();
  225. break;
  226. case SignatureAlgorithm::kRsaPkcs1Sha256:
  227. expected_pkey_id = EVP_PKEY_RSA;
  228. digest = EVP_sha256();
  229. break;
  230. case SignatureAlgorithm::kRsaPkcs1Sha384:
  231. expected_pkey_id = EVP_PKEY_RSA;
  232. digest = EVP_sha384();
  233. break;
  234. case SignatureAlgorithm::kRsaPkcs1Sha512:
  235. expected_pkey_id = EVP_PKEY_RSA;
  236. digest = EVP_sha512();
  237. break;
  238. case SignatureAlgorithm::kEcdsaSha1:
  239. expected_pkey_id = EVP_PKEY_EC;
  240. digest = EVP_sha1();
  241. break;
  242. case SignatureAlgorithm::kEcdsaSha256:
  243. expected_pkey_id = EVP_PKEY_EC;
  244. digest = EVP_sha256();
  245. break;
  246. case SignatureAlgorithm::kEcdsaSha384:
  247. expected_pkey_id = EVP_PKEY_EC;
  248. digest = EVP_sha384();
  249. break;
  250. case SignatureAlgorithm::kEcdsaSha512:
  251. expected_pkey_id = EVP_PKEY_EC;
  252. digest = EVP_sha512();
  253. break;
  254. case SignatureAlgorithm::kRsaPssSha256:
  255. case SignatureAlgorithm::kRsaPssSha384:
  256. case SignatureAlgorithm::kRsaPssSha512:
  257. case SignatureAlgorithm::kRsaPkcs1Md2:
  258. case SignatureAlgorithm::kRsaPkcs1Md4:
  259. case SignatureAlgorithm::kDsaSha1:
  260. case SignatureAlgorithm::kDsaSha256:
  261. // Unsupported algorithms.
  262. return false;
  263. }
  264. const uint8_t* tbs_bytes = reinterpret_cast<const uint8_t*>(tbs_data.data());
  265. bssl::ScopedEVP_MD_CTX ctx;
  266. uint8_t* sig_out;
  267. size_t sig_len;
  268. return expected_pkey_id == EVP_PKEY_id(key) &&
  269. EVP_DigestSignInit(ctx.get(), nullptr, digest, nullptr, key) &&
  270. EVP_DigestSign(ctx.get(), nullptr, &sig_len, tbs_bytes,
  271. tbs_data.size()) &&
  272. CBB_reserve(out_signature, &sig_out, sig_len) &&
  273. EVP_DigestSign(ctx.get(), sig_out, &sig_len, tbs_bytes,
  274. tbs_data.size()) &&
  275. CBB_did_write(out_signature, sig_len);
  276. }
  277. // static
  278. std::string CertBuilder::SignatureAlgorithmToDer(
  279. SignatureAlgorithm signature_algorithm) {
  280. switch (signature_algorithm) {
  281. case SignatureAlgorithm::kRsaPkcs1Md5:
  282. return Md5WithRSAEncryption();
  283. case SignatureAlgorithm::kRsaPkcs1Sha1:
  284. return Sha1WithRSAEncryption();
  285. case SignatureAlgorithm::kRsaPkcs1Sha256:
  286. return Sha256WithRSAEncryption();
  287. case SignatureAlgorithm::kEcdsaSha1:
  288. return EcdsaWithSha1();
  289. case SignatureAlgorithm::kEcdsaSha256:
  290. return EcdsaWithSha256();
  291. default:
  292. ADD_FAILURE();
  293. return std::string();
  294. }
  295. }
  296. void CertBuilder::SetExtension(const der::Input& oid,
  297. std::string value,
  298. bool critical) {
  299. auto& extension_value = extensions_[oid.AsString()];
  300. extension_value.critical = critical;
  301. extension_value.value = std::move(value);
  302. Invalidate();
  303. }
  304. void CertBuilder::EraseExtension(const der::Input& oid) {
  305. extensions_.erase(oid.AsString());
  306. Invalidate();
  307. }
  308. void CertBuilder::SetBasicConstraints(bool is_ca, int path_len) {
  309. // From RFC 5280:
  310. //
  311. // BasicConstraints ::= SEQUENCE {
  312. // cA BOOLEAN DEFAULT FALSE,
  313. // pathLenConstraint INTEGER (0..MAX) OPTIONAL }
  314. bssl::ScopedCBB cbb;
  315. CBB basic_constraints;
  316. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  317. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &basic_constraints, CBS_ASN1_SEQUENCE));
  318. if (is_ca)
  319. ASSERT_TRUE(CBB_add_asn1_bool(&basic_constraints, true));
  320. if (path_len >= 0)
  321. ASSERT_TRUE(CBB_add_asn1_uint64(&basic_constraints, path_len));
  322. SetExtension(der::Input(kBasicConstraintsOid), FinishCBB(cbb.get()),
  323. /*critical=*/true);
  324. }
  325. void CertBuilder::SetCaIssuersUrl(const GURL& url) {
  326. SetCaIssuersAndOCSPUrls({url}, {});
  327. }
  328. void CertBuilder::SetCaIssuersAndOCSPUrls(
  329. const std::vector<GURL>& ca_issuers_urls,
  330. const std::vector<GURL>& ocsp_urls) {
  331. std::vector<std::pair<der::Input, GURL>> entries;
  332. for (const auto& url : ca_issuers_urls)
  333. entries.emplace_back(der::Input(kAdCaIssuersOid), url);
  334. for (const auto& url : ocsp_urls)
  335. entries.emplace_back(der::Input(kAdOcspOid), url);
  336. ASSERT_GT(entries.size(), 0U);
  337. // From RFC 5280:
  338. //
  339. // AuthorityInfoAccessSyntax ::=
  340. // SEQUENCE SIZE (1..MAX) OF AccessDescription
  341. //
  342. // AccessDescription ::= SEQUENCE {
  343. // accessMethod OBJECT IDENTIFIER,
  344. // accessLocation GeneralName }
  345. bssl::ScopedCBB cbb;
  346. CBB aia;
  347. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  348. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &aia, CBS_ASN1_SEQUENCE));
  349. for (const auto& entry : entries) {
  350. CBB access_description, access_method, access_location;
  351. ASSERT_TRUE(CBB_add_asn1(&aia, &access_description, CBS_ASN1_SEQUENCE));
  352. ASSERT_TRUE(
  353. CBB_add_asn1(&access_description, &access_method, CBS_ASN1_OBJECT));
  354. ASSERT_TRUE(CBBAddBytes(&access_method, entry.first.AsStringPiece()));
  355. ASSERT_TRUE(CBB_add_asn1(&access_description, &access_location,
  356. CBS_ASN1_CONTEXT_SPECIFIC | 6));
  357. ASSERT_TRUE(CBBAddBytes(&access_location, entry.second.spec()));
  358. ASSERT_TRUE(CBB_flush(&aia));
  359. }
  360. SetExtension(der::Input(kAuthorityInfoAccessOid), FinishCBB(cbb.get()));
  361. }
  362. void CertBuilder::SetCrlDistributionPointUrl(const GURL& url) {
  363. SetCrlDistributionPointUrls({url});
  364. }
  365. void CertBuilder::SetCrlDistributionPointUrls(const std::vector<GURL>& urls) {
  366. bssl::ScopedCBB cbb;
  367. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  368. CBB dps, dp, dp_name, dp_fullname;
  369. // CRLDistributionPoints ::= SEQUENCE SIZE (1..MAX) OF DistributionPoint
  370. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &dps, CBS_ASN1_SEQUENCE));
  371. // DistributionPoint ::= SEQUENCE {
  372. // distributionPoint [0] DistributionPointName OPTIONAL,
  373. // reasons [1] ReasonFlags OPTIONAL,
  374. // cRLIssuer [2] GeneralNames OPTIONAL }
  375. ASSERT_TRUE(CBB_add_asn1(&dps, &dp, CBS_ASN1_SEQUENCE));
  376. ASSERT_TRUE(CBB_add_asn1(
  377. &dp, &dp_name, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
  378. // DistributionPointName ::= CHOICE {
  379. // fullName [0] GeneralNames,
  380. // nameRelativeToCRLIssuer [1] RelativeDistinguishedName }
  381. ASSERT_TRUE(
  382. CBB_add_asn1(&dp_name, &dp_fullname,
  383. CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
  384. // GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
  385. // GeneralName ::= CHOICE {
  386. // uniformResourceIdentifier [6] IA5String,
  387. for (const auto& url : urls) {
  388. CBB dp_url;
  389. ASSERT_TRUE(
  390. CBB_add_asn1(&dp_fullname, &dp_url, CBS_ASN1_CONTEXT_SPECIFIC | 6));
  391. ASSERT_TRUE(CBBAddBytes(&dp_url, url.spec()));
  392. ASSERT_TRUE(CBB_flush(&dp_fullname));
  393. }
  394. SetExtension(der::Input(kCrlDistributionPointsOid), FinishCBB(cbb.get()));
  395. }
  396. void CertBuilder::SetSubjectCommonName(base::StringPiece common_name) {
  397. // See RFC 4519.
  398. static const uint8_t kCommonName[] = {0x55, 0x04, 0x03};
  399. // See RFC 5280, section 4.1.2.4.
  400. bssl::ScopedCBB cbb;
  401. CBB rdns, rdn, attr, type, value;
  402. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  403. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &rdns, CBS_ASN1_SEQUENCE));
  404. ASSERT_TRUE(CBB_add_asn1(&rdns, &rdn, CBS_ASN1_SET));
  405. ASSERT_TRUE(CBB_add_asn1(&rdn, &attr, CBS_ASN1_SEQUENCE));
  406. ASSERT_TRUE(CBB_add_asn1(&attr, &type, CBS_ASN1_OBJECT));
  407. ASSERT_TRUE(CBBAddBytes(&type, kCommonName));
  408. ASSERT_TRUE(CBB_add_asn1(&attr, &value, CBS_ASN1_UTF8STRING));
  409. ASSERT_TRUE(CBBAddBytes(&value, common_name));
  410. subject_tlv_ = FinishCBB(cbb.get());
  411. Invalidate();
  412. }
  413. void CertBuilder::SetSubject(base::span<const uint8_t> subject_tlv) {
  414. subject_tlv_.assign(subject_tlv.begin(), subject_tlv.end());
  415. Invalidate();
  416. }
  417. void CertBuilder::SetSubjectAltName(const std::string& dns_name) {
  418. SetSubjectAltNames({dns_name}, {});
  419. }
  420. void CertBuilder::SetSubjectAltNames(
  421. const std::vector<std::string>& dns_names,
  422. const std::vector<IPAddress>& ip_addresses) {
  423. // From RFC 5280:
  424. //
  425. // SubjectAltName ::= GeneralNames
  426. //
  427. // GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
  428. //
  429. // GeneralName ::= CHOICE {
  430. // ...
  431. // dNSName [2] IA5String,
  432. // ...
  433. // iPAddress [7] OCTET STRING,
  434. // ... }
  435. ASSERT_GT(dns_names.size() + ip_addresses.size(), 0U);
  436. bssl::ScopedCBB cbb;
  437. CBB general_names;
  438. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  439. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &general_names, CBS_ASN1_SEQUENCE));
  440. if (!dns_names.empty()) {
  441. for (const auto& name : dns_names) {
  442. CBB general_name;
  443. ASSERT_TRUE(CBB_add_asn1(&general_names, &general_name,
  444. CBS_ASN1_CONTEXT_SPECIFIC | 2));
  445. ASSERT_TRUE(CBBAddBytes(&general_name, name));
  446. ASSERT_TRUE(CBB_flush(&general_names));
  447. }
  448. }
  449. if (!ip_addresses.empty()) {
  450. for (const auto& addr : ip_addresses) {
  451. CBB general_name;
  452. ASSERT_TRUE(CBB_add_asn1(&general_names, &general_name,
  453. CBS_ASN1_CONTEXT_SPECIFIC | 7));
  454. ASSERT_TRUE(
  455. CBB_add_bytes(&general_name, addr.bytes().data(), addr.size()));
  456. ASSERT_TRUE(CBB_flush(&general_names));
  457. }
  458. }
  459. SetExtension(der::Input(kSubjectAltNameOid), FinishCBB(cbb.get()));
  460. }
  461. void CertBuilder::SetKeyUsages(const std::vector<KeyUsageBit>& usages) {
  462. ASSERT_GT(usages.size(), 0U);
  463. int number_of_unused_bits = 0;
  464. std::vector<uint8_t> bytes;
  465. for (auto usage : usages) {
  466. int bit_index = static_cast<int>(usage);
  467. // Index of the byte that contains the bit.
  468. size_t byte_index = bit_index / 8;
  469. if (byte_index + 1 > bytes.size()) {
  470. bytes.resize(byte_index + 1);
  471. number_of_unused_bits = 8;
  472. }
  473. // Within a byte, bits are ordered from most significant to least
  474. // significant. Convert |bit_index| to an index within the |byte_index|
  475. // byte, measured from its least significant bit.
  476. uint8_t bit_index_in_byte = 7 - (bit_index - byte_index * 8);
  477. if (byte_index + 1 == bytes.size() &&
  478. bit_index_in_byte < number_of_unused_bits) {
  479. number_of_unused_bits = bit_index_in_byte;
  480. }
  481. bytes[byte_index] |= (1 << bit_index_in_byte);
  482. }
  483. // From RFC 5290:
  484. // KeyUsage ::= BIT STRING {...}
  485. bssl::ScopedCBB cbb;
  486. CBB ku_cbb;
  487. ASSERT_TRUE(CBB_init(cbb.get(), bytes.size() + 1));
  488. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &ku_cbb, CBS_ASN1_BITSTRING));
  489. ASSERT_TRUE(CBB_add_u8(&ku_cbb, number_of_unused_bits));
  490. ASSERT_TRUE(CBB_add_bytes(&ku_cbb, bytes.data(), bytes.size()));
  491. SetExtension(der::Input(kKeyUsageOid), FinishCBB(cbb.get()));
  492. }
  493. void CertBuilder::SetExtendedKeyUsages(
  494. const std::vector<der::Input>& purpose_oids) {
  495. // From RFC 5280:
  496. // ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
  497. // KeyPurposeId ::= OBJECT IDENTIFIER
  498. ASSERT_GT(purpose_oids.size(), 0U);
  499. bssl::ScopedCBB cbb;
  500. CBB eku;
  501. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  502. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &eku, CBS_ASN1_SEQUENCE));
  503. for (const auto& oid : purpose_oids) {
  504. CBB purpose_cbb;
  505. ASSERT_TRUE(CBB_add_asn1(&eku, &purpose_cbb, CBS_ASN1_OBJECT));
  506. ASSERT_TRUE(CBBAddBytes(&purpose_cbb, oid.AsStringPiece()));
  507. ASSERT_TRUE(CBB_flush(&eku));
  508. }
  509. SetExtension(der::Input(kExtKeyUsageOid), FinishCBB(cbb.get()));
  510. }
  511. void CertBuilder::SetCertificatePolicies(
  512. const std::vector<std::string>& policy_oids) {
  513. // From RFC 5280:
  514. // certificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation
  515. //
  516. // PolicyInformation ::= SEQUENCE {
  517. // policyIdentifier CertPolicyId,
  518. // policyQualifiers SEQUENCE SIZE (1..MAX) OF
  519. // PolicyQualifierInfo OPTIONAL }
  520. //
  521. // CertPolicyId ::= OBJECT IDENTIFIER
  522. bssl::ScopedCBB cbb;
  523. CBB certificate_policies;
  524. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  525. ASSERT_TRUE(
  526. CBB_add_asn1(cbb.get(), &certificate_policies, CBS_ASN1_SEQUENCE));
  527. for (const auto& oid : policy_oids) {
  528. CBB policy_information, policy_identifier;
  529. ASSERT_TRUE(CBB_add_asn1(&certificate_policies, &policy_information,
  530. CBS_ASN1_SEQUENCE));
  531. ASSERT_TRUE(
  532. CBB_add_asn1(&policy_information, &policy_identifier, CBS_ASN1_OBJECT));
  533. ASSERT_TRUE(
  534. CBB_add_asn1_oid_from_text(&policy_identifier, oid.data(), oid.size()));
  535. ASSERT_TRUE(CBB_flush(&certificate_policies));
  536. }
  537. SetExtension(der::Input(kCertificatePoliciesOid), FinishCBB(cbb.get()));
  538. }
  539. void CertBuilder::SetValidity(base::Time not_before, base::Time not_after) {
  540. // From RFC 5280:
  541. // Validity ::= SEQUENCE {
  542. // notBefore Time,
  543. // notAfter Time }
  544. bssl::ScopedCBB cbb;
  545. CBB validity;
  546. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  547. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &validity, CBS_ASN1_SEQUENCE));
  548. ASSERT_TRUE(x509_util::CBBAddTime(&validity, not_before));
  549. ASSERT_TRUE(x509_util::CBBAddTime(&validity, not_after));
  550. validity_tlv_ = FinishCBB(cbb.get());
  551. Invalidate();
  552. }
  553. void CertBuilder::SetSubjectKeyIdentifier(
  554. const std::string& subject_key_identifier) {
  555. ASSERT_FALSE(subject_key_identifier.empty());
  556. // From RFC 5280:
  557. // KeyIdentifier ::= OCTET STRING
  558. // SubjectKeyIdentifier ::= KeyIdentifier
  559. bssl::ScopedCBB cbb;
  560. ASSERT_TRUE(CBB_init(cbb.get(), 32));
  561. ASSERT_TRUE(CBB_add_asn1_octet_string(
  562. cbb.get(),
  563. reinterpret_cast<const uint8_t*>(subject_key_identifier.data()),
  564. subject_key_identifier.size()));
  565. // Replace the existing SKI. Note it MUST be non-critical, per RFC 5280.
  566. SetExtension(der::Input(kSubjectKeyIdentifierOid), FinishCBB(cbb.get()),
  567. /*critical=*/false);
  568. }
  569. void CertBuilder::SetAuthorityKeyIdentifier(
  570. const std::string& authority_key_identifier) {
  571. // If an empty AKI is presented, simply erase the existing one. Creating
  572. // an empty AKI is technically valid, but there's no use case for this.
  573. // An empty AKI would an empty (ergo, non-unique) SKI on the issuer,
  574. // which would violate RFC 5280, so using the empty value as a placeholder
  575. // unless and until a use case emerges is fine.
  576. if (authority_key_identifier.empty()) {
  577. EraseExtension(der::Input(kAuthorityKeyIdentifierOid));
  578. return;
  579. }
  580. // From RFC 5280:
  581. //
  582. // AuthorityKeyIdentifier ::= SEQUENCE {
  583. // keyIdentifier [0] KeyIdentifier OPTIONAL,
  584. // authorityCertIssuer [1] GeneralNames OPTIONAL,
  585. // authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
  586. //
  587. // KeyIdentifier ::= OCTET STRING
  588. bssl::ScopedCBB cbb;
  589. CBB aki, aki_value;
  590. ASSERT_TRUE(CBB_init(cbb.get(), 32));
  591. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &aki, CBS_ASN1_SEQUENCE));
  592. ASSERT_TRUE(CBB_add_asn1(&aki, &aki_value, CBS_ASN1_CONTEXT_SPECIFIC | 0));
  593. ASSERT_TRUE(CBBAddBytes(&aki_value, authority_key_identifier));
  594. ASSERT_TRUE(CBB_flush(&aki));
  595. SetExtension(der::Input(kAuthorityKeyIdentifierOid), FinishCBB(cbb.get()));
  596. }
  597. void CertBuilder::SetSignatureAlgorithm(
  598. SignatureAlgorithm signature_algorithm) {
  599. signature_algorithm_ = signature_algorithm;
  600. Invalidate();
  601. }
  602. void CertBuilder::SetRandomSerialNumber() {
  603. serial_number_ = base::RandUint64();
  604. Invalidate();
  605. }
  606. CRYPTO_BUFFER* CertBuilder::GetCertBuffer() {
  607. if (!cert_)
  608. GenerateCertificate();
  609. return cert_.get();
  610. }
  611. bssl::UniquePtr<CRYPTO_BUFFER> CertBuilder::DupCertBuffer() {
  612. return bssl::UpRef(GetCertBuffer());
  613. }
  614. const std::string& CertBuilder::GetSubject() {
  615. if (subject_tlv_.empty())
  616. GenerateSubject();
  617. return subject_tlv_;
  618. }
  619. uint64_t CertBuilder::GetSerialNumber() {
  620. if (!serial_number_)
  621. serial_number_ = base::RandUint64();
  622. return serial_number_;
  623. }
  624. std::string CertBuilder::GetSubjectKeyIdentifier() {
  625. std::string ski_oid = der::Input(kSubjectKeyIdentifierOid).AsString();
  626. if (extensions_.find(ski_oid) == extensions_.end()) {
  627. // If no SKI is present, this means that the certificate was either
  628. // created by FromStaticCert() and lacked one, or it was explicitly
  629. // deleted as an extension.
  630. return std::string();
  631. }
  632. auto& extension_value = extensions_[ski_oid];
  633. der::Input ski_value;
  634. if (!ParseSubjectKeyIdentifier(der::Input(&extension_value.value),
  635. &ski_value)) {
  636. return std::string();
  637. }
  638. return ski_value.AsString();
  639. }
  640. bool CertBuilder::GetValidity(base::Time* not_before,
  641. base::Time* not_after) const {
  642. der::GeneralizedTime not_before_generalized_time;
  643. der::GeneralizedTime not_after_generalized_time;
  644. if (!ParseValidity(der::Input(&validity_tlv_), &not_before_generalized_time,
  645. &not_after_generalized_time) ||
  646. !GeneralizedTimeToTime(not_before_generalized_time, not_before) ||
  647. !GeneralizedTimeToTime(not_after_generalized_time, not_after)) {
  648. return false;
  649. }
  650. return true;
  651. }
  652. EVP_PKEY* CertBuilder::GetKey() {
  653. if (!key_) {
  654. switch (default_pkey_id_) {
  655. case EVP_PKEY_RSA:
  656. GenerateRSAKey();
  657. break;
  658. case EVP_PKEY_EC:
  659. GenerateECKey();
  660. break;
  661. }
  662. }
  663. return key_.get();
  664. }
  665. scoped_refptr<X509Certificate> CertBuilder::GetX509Certificate() {
  666. return X509Certificate::CreateFromBuffer(DupCertBuffer(), {});
  667. }
  668. scoped_refptr<X509Certificate> CertBuilder::GetX509CertificateChain() {
  669. std::vector<bssl::UniquePtr<CRYPTO_BUFFER>> intermediates;
  670. // Add intermediates, not including the self-signed root.
  671. for (CertBuilder* cert = issuer_; cert && cert != cert->issuer_;
  672. cert = cert->issuer_) {
  673. intermediates.push_back(cert->DupCertBuffer());
  674. }
  675. return X509Certificate::CreateFromBuffer(DupCertBuffer(),
  676. std::move(intermediates));
  677. }
  678. std::string CertBuilder::GetDER() {
  679. return std::string(x509_util::CryptoBufferAsStringPiece(GetCertBuffer()));
  680. }
  681. CertBuilder::CertBuilder(CRYPTO_BUFFER* orig_cert,
  682. CertBuilder* issuer,
  683. bool unique_subject_key_identifier)
  684. : issuer_(issuer) {
  685. if (!issuer_)
  686. issuer_ = this;
  687. crypto::EnsureOpenSSLInit();
  688. if (orig_cert)
  689. InitFromCert(der::Input(x509_util::CryptoBufferAsStringPiece(orig_cert)));
  690. if (unique_subject_key_identifier) {
  691. GenerateSubjectKeyIdentifier();
  692. SetAuthorityKeyIdentifier(issuer_->GetSubjectKeyIdentifier());
  693. }
  694. }
  695. void CertBuilder::Invalidate() {
  696. cert_.reset();
  697. }
  698. void CertBuilder::GenerateECKey() {
  699. auto private_key = crypto::ECPrivateKey::Create();
  700. key_ = bssl::UpRef(private_key->key());
  701. Invalidate();
  702. }
  703. void CertBuilder::GenerateRSAKey() {
  704. auto private_key = crypto::RSAPrivateKey::Create(2048);
  705. key_ = bssl::UpRef(private_key->key());
  706. Invalidate();
  707. }
  708. void CertBuilder::GenerateSubjectKeyIdentifier() {
  709. // 20 bytes are chosen here for no other reason than it's compatible with
  710. // systems that assume the SKI is SHA-1(SPKI), which RFC 5280 notes as one
  711. // mechanism for generating an SKI, while also noting that random/unique
  712. // SKIs are also fine.
  713. std::string random_ski = base::RandBytesAsString(20);
  714. SetSubjectKeyIdentifier(random_ski);
  715. }
  716. void CertBuilder::GenerateSubject() {
  717. ASSERT_TRUE(subject_tlv_.empty());
  718. // Use a random common name comprised of 12 bytes in hex.
  719. std::string common_name = MakeRandomHexString(12);
  720. SetSubjectCommonName(common_name);
  721. }
  722. void CertBuilder::InitFromCert(const der::Input& cert) {
  723. extensions_.clear();
  724. Invalidate();
  725. // From RFC 5280, section 4.1
  726. // Certificate ::= SEQUENCE {
  727. // tbsCertificate TBSCertificate,
  728. // signatureAlgorithm AlgorithmIdentifier,
  729. // signatureValue BIT STRING }
  730. // TBSCertificate ::= SEQUENCE {
  731. // version [0] EXPLICIT Version DEFAULT v1,
  732. // serialNumber CertificateSerialNumber,
  733. // signature AlgorithmIdentifier,
  734. // issuer Name,
  735. // validity Validity,
  736. // subject Name,
  737. // subjectPublicKeyInfo SubjectPublicKeyInfo,
  738. // issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
  739. // -- If present, version MUST be v2 or v3
  740. // subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
  741. // -- If present, version MUST be v2 or v3
  742. // extensions [3] EXPLICIT Extensions OPTIONAL
  743. // -- If present, version MUST be v3
  744. // }
  745. der::Parser parser(cert);
  746. der::Parser certificate;
  747. der::Parser tbs_certificate;
  748. ASSERT_TRUE(parser.ReadSequence(&certificate));
  749. ASSERT_TRUE(certificate.ReadSequence(&tbs_certificate));
  750. // version
  751. bool unused;
  752. ASSERT_TRUE(tbs_certificate.SkipOptionalTag(
  753. der::kTagConstructed | der::kTagContextSpecific | 0, &unused));
  754. // serialNumber
  755. ASSERT_TRUE(tbs_certificate.SkipTag(der::kInteger));
  756. // signature
  757. der::Input signature_algorithm_tlv;
  758. ASSERT_TRUE(tbs_certificate.ReadRawTLV(&signature_algorithm_tlv));
  759. auto signature_algorithm =
  760. ParseSignatureAlgorithm(signature_algorithm_tlv, nullptr);
  761. ASSERT_TRUE(signature_algorithm);
  762. signature_algorithm_ = *signature_algorithm;
  763. // issuer
  764. ASSERT_TRUE(tbs_certificate.SkipTag(der::kSequence));
  765. // validity
  766. der::Input validity_tlv;
  767. ASSERT_TRUE(tbs_certificate.ReadRawTLV(&validity_tlv));
  768. validity_tlv_ = validity_tlv.AsString();
  769. // subject
  770. ASSERT_TRUE(tbs_certificate.SkipTag(der::kSequence));
  771. // subjectPublicKeyInfo
  772. der::Input spki_tlv;
  773. ASSERT_TRUE(tbs_certificate.ReadRawTLV(&spki_tlv));
  774. bssl::UniquePtr<EVP_PKEY> public_key;
  775. ASSERT_TRUE(ParsePublicKey(spki_tlv, &public_key));
  776. default_pkey_id_ = EVP_PKEY_id(public_key.get());
  777. // issuerUniqueID
  778. ASSERT_TRUE(tbs_certificate.SkipOptionalTag(der::ContextSpecificPrimitive(1),
  779. &unused));
  780. // subjectUniqueID
  781. ASSERT_TRUE(tbs_certificate.SkipOptionalTag(der::ContextSpecificPrimitive(2),
  782. &unused));
  783. // extensions
  784. absl::optional<der::Input> extensions_tlv;
  785. ASSERT_TRUE(tbs_certificate.ReadOptionalTag(
  786. der::ContextSpecificConstructed(3), &extensions_tlv));
  787. if (extensions_tlv) {
  788. std::map<der::Input, ParsedExtension> parsed_extensions;
  789. ASSERT_TRUE(ParseExtensions(extensions_tlv.value(), &parsed_extensions));
  790. for (const auto& parsed_extension : parsed_extensions) {
  791. SetExtension(parsed_extension.second.oid,
  792. parsed_extension.second.value.AsString(),
  793. parsed_extension.second.critical);
  794. }
  795. }
  796. }
  797. void CertBuilder::BuildTBSCertificate(base::StringPiece signature_algorithm_tlv,
  798. std::string* out) {
  799. bssl::ScopedCBB cbb;
  800. CBB tbs_cert, version, extensions_context, extensions;
  801. ASSERT_TRUE(CBB_init(cbb.get(), 64));
  802. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &tbs_cert, CBS_ASN1_SEQUENCE));
  803. ASSERT_TRUE(
  804. CBB_add_asn1(&tbs_cert, &version,
  805. CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
  806. // Always use v3 certificates.
  807. ASSERT_TRUE(CBB_add_asn1_uint64(&version, 2));
  808. ASSERT_TRUE(CBB_add_asn1_uint64(&tbs_cert, GetSerialNumber()));
  809. ASSERT_TRUE(CBBAddBytes(&tbs_cert, signature_algorithm_tlv));
  810. ASSERT_TRUE(CBBAddBytes(&tbs_cert, issuer_->GetSubject()));
  811. ASSERT_TRUE(CBBAddBytes(&tbs_cert, validity_tlv_));
  812. ASSERT_TRUE(CBBAddBytes(&tbs_cert, GetSubject()));
  813. ASSERT_TRUE(GetKey());
  814. ASSERT_TRUE(EVP_marshal_public_key(&tbs_cert, GetKey()));
  815. // Serialize all the extensions.
  816. if (!extensions_.empty()) {
  817. ASSERT_TRUE(
  818. CBB_add_asn1(&tbs_cert, &extensions_context,
  819. CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 3));
  820. ASSERT_TRUE(
  821. CBB_add_asn1(&extensions_context, &extensions, CBS_ASN1_SEQUENCE));
  822. // Extension ::= SEQUENCE {
  823. // extnID OBJECT IDENTIFIER,
  824. // critical BOOLEAN DEFAULT FALSE,
  825. // extnValue OCTET STRING
  826. // -- contains the DER encoding of an ASN.1 value
  827. // -- corresponding to the extension type identified
  828. // -- by extnID
  829. // }
  830. for (const auto& extension_it : extensions_) {
  831. CBB extension_seq, oid, extn_value;
  832. ASSERT_TRUE(CBB_add_asn1(&extensions, &extension_seq, CBS_ASN1_SEQUENCE));
  833. ASSERT_TRUE(CBB_add_asn1(&extension_seq, &oid, CBS_ASN1_OBJECT));
  834. ASSERT_TRUE(CBBAddBytes(&oid, extension_it.first));
  835. if (extension_it.second.critical) {
  836. ASSERT_TRUE(CBB_add_asn1_bool(&extension_seq, true));
  837. }
  838. ASSERT_TRUE(
  839. CBB_add_asn1(&extension_seq, &extn_value, CBS_ASN1_OCTETSTRING));
  840. ASSERT_TRUE(CBBAddBytes(&extn_value, extension_it.second.value));
  841. ASSERT_TRUE(CBB_flush(&extensions));
  842. }
  843. }
  844. *out = FinishCBB(cbb.get());
  845. }
  846. void CertBuilder::GenerateCertificate() {
  847. ASSERT_FALSE(cert_);
  848. absl::optional<SignatureAlgorithm> signature_algorithm = signature_algorithm_;
  849. if (!signature_algorithm)
  850. signature_algorithm = DefaultSignatureAlgorithmForKey(issuer_->GetKey());
  851. ASSERT_TRUE(signature_algorithm.has_value());
  852. std::string signature_algorithm_tlv =
  853. SignatureAlgorithmToDer(*signature_algorithm);
  854. ASSERT_FALSE(signature_algorithm_tlv.empty());
  855. std::string tbs_cert;
  856. BuildTBSCertificate(signature_algorithm_tlv, &tbs_cert);
  857. // Sign the TBSCertificate and write the entire certificate.
  858. bssl::ScopedCBB cbb;
  859. CBB cert, signature;
  860. ASSERT_TRUE(CBB_init(cbb.get(), tbs_cert.size()));
  861. ASSERT_TRUE(CBB_add_asn1(cbb.get(), &cert, CBS_ASN1_SEQUENCE));
  862. ASSERT_TRUE(CBBAddBytes(&cert, tbs_cert));
  863. ASSERT_TRUE(CBBAddBytes(&cert, signature_algorithm_tlv));
  864. ASSERT_TRUE(CBB_add_asn1(&cert, &signature, CBS_ASN1_BITSTRING));
  865. ASSERT_TRUE(CBB_add_u8(&signature, 0 /* no unused bits */));
  866. ASSERT_TRUE(
  867. SignData(*signature_algorithm, tbs_cert, issuer_->GetKey(), &signature));
  868. auto cert_der = FinishCBB(cbb.get());
  869. cert_ =
  870. x509_util::CreateCryptoBuffer(base::as_bytes(base::make_span(cert_der)));
  871. }
  872. } // namespace net