x509_util.cc 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538
  1. // Copyright (c) 2012 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/cert/x509_util.h"
  5. #include <string.h>
  6. #include <map>
  7. #include <memory>
  8. #include "base/lazy_instance.h"
  9. #include "base/logging.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/notreached.h"
  12. #include "base/strings/string_split.h"
  13. #include "base/strings/string_util.h"
  14. #include "base/time/time.h"
  15. #include "build/build_config.h"
  16. #include "crypto/openssl_util.h"
  17. #include "crypto/rsa_private_key.h"
  18. #include "crypto/sha2.h"
  19. #include "net/base/hash_value.h"
  20. #include "net/cert/asn1_util.h"
  21. #include "net/cert/pki/cert_errors.h"
  22. #include "net/cert/pki/name_constraints.h"
  23. #include "net/cert/pki/parse_certificate.h"
  24. #include "net/cert/pki/parse_name.h"
  25. #include "net/cert/pki/signature_algorithm.h"
  26. #include "net/cert/x509_certificate.h"
  27. #include "net/der/encode_values.h"
  28. #include "net/der/input.h"
  29. #include "net/der/parse_values.h"
  30. #include "third_party/boringssl/src/include/openssl/bytestring.h"
  31. #include "third_party/boringssl/src/include/openssl/digest.h"
  32. #include "third_party/boringssl/src/include/openssl/evp.h"
  33. #include "third_party/boringssl/src/include/openssl/mem.h"
  34. #include "third_party/boringssl/src/include/openssl/pkcs7.h"
  35. #include "third_party/boringssl/src/include/openssl/pool.h"
  36. #include "third_party/boringssl/src/include/openssl/stack.h"
  37. namespace net::x509_util {
  38. namespace {
  39. bool AddRSASignatureAlgorithm(CBB* cbb, DigestAlgorithm algorithm) {
  40. // See RFC 4055.
  41. static const uint8_t kSHA256WithRSAEncryption[] = {
  42. 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b};
  43. // An AlgorithmIdentifier is described in RFC 5280, 4.1.1.2.
  44. CBB sequence, oid, params;
  45. if (!CBB_add_asn1(cbb, &sequence, CBS_ASN1_SEQUENCE) ||
  46. !CBB_add_asn1(&sequence, &oid, CBS_ASN1_OBJECT)) {
  47. return false;
  48. }
  49. switch (algorithm) {
  50. case DIGEST_SHA256:
  51. if (!CBB_add_bytes(&oid, kSHA256WithRSAEncryption,
  52. sizeof(kSHA256WithRSAEncryption)))
  53. return false;
  54. break;
  55. }
  56. // All supported algorithms use null parameters.
  57. if (!CBB_add_asn1(&sequence, &params, CBS_ASN1_NULL) || !CBB_flush(cbb)) {
  58. return false;
  59. }
  60. return true;
  61. }
  62. const EVP_MD* ToEVP(DigestAlgorithm alg) {
  63. switch (alg) {
  64. case DIGEST_SHA256:
  65. return EVP_sha256();
  66. }
  67. return nullptr;
  68. }
  69. class BufferPoolSingleton {
  70. public:
  71. BufferPoolSingleton() : pool_(CRYPTO_BUFFER_POOL_new()) {}
  72. CRYPTO_BUFFER_POOL* pool() { return pool_; }
  73. private:
  74. // The singleton is leaky, so there is no need to use a smart pointer.
  75. raw_ptr<CRYPTO_BUFFER_POOL> pool_;
  76. };
  77. base::LazyInstance<BufferPoolSingleton>::Leaky g_buffer_pool_singleton =
  78. LAZY_INSTANCE_INITIALIZER;
  79. } // namespace
  80. // Adds an X.509 Name with the specified distinguished name to |cbb|.
  81. bool AddName(CBB* cbb, base::StringPiece name) {
  82. // See RFC 4519.
  83. static const uint8_t kCommonName[] = {0x55, 0x04, 0x03};
  84. static const uint8_t kCountryName[] = {0x55, 0x04, 0x06};
  85. static const uint8_t kOrganizationName[] = {0x55, 0x04, 0x0a};
  86. static const uint8_t kOrganizationalUnitName[] = {0x55, 0x04, 0x0b};
  87. std::vector<std::string> attributes = SplitString(
  88. name, /*separators=*/",", base::WhitespaceHandling::TRIM_WHITESPACE,
  89. base::SplitResult::SPLIT_WANT_NONEMPTY);
  90. if (attributes.size() == 0) {
  91. LOG(ERROR) << "Missing DN or wrong format";
  92. return false;
  93. }
  94. // See RFC 5280, section 4.1.2.4.
  95. CBB rdns;
  96. if (!CBB_add_asn1(cbb, &rdns, CBS_ASN1_SEQUENCE)) {
  97. return false;
  98. }
  99. for (const std::string& attribute : attributes) {
  100. std::vector<std::string> parts =
  101. SplitString(attribute, /*separators=*/"=",
  102. base::WhitespaceHandling::KEEP_WHITESPACE,
  103. base::SplitResult::SPLIT_WANT_ALL);
  104. if (parts.size() != 2) {
  105. LOG(ERROR) << "Wrong DN format at " + attribute;
  106. return false;
  107. }
  108. const std::string& type_string = parts[0];
  109. const std::string& value_string = parts[1];
  110. base::span<const uint8_t> type_bytes;
  111. if (type_string == "CN") {
  112. type_bytes = kCommonName;
  113. } else if (type_string == "C") {
  114. type_bytes = kCountryName;
  115. } else if (type_string == "O") {
  116. type_bytes = kOrganizationName;
  117. } else if (type_string == "OU") {
  118. type_bytes = kOrganizationalUnitName;
  119. } else {
  120. LOG(ERROR) << "Unrecognized type " + type_string;
  121. return false;
  122. }
  123. CBB rdn, attr, type, value;
  124. if (!CBB_add_asn1(&rdns, &rdn, CBS_ASN1_SET) ||
  125. !CBB_add_asn1(&rdn, &attr, CBS_ASN1_SEQUENCE) ||
  126. !CBB_add_asn1(&attr, &type, CBS_ASN1_OBJECT) ||
  127. !CBB_add_bytes(&type, type_bytes.data(), type_bytes.size()) ||
  128. !CBB_add_asn1(&attr, &value, type_string == "C" ?
  129. CBS_ASN1_PRINTABLESTRING : CBS_ASN1_UTF8STRING) ||
  130. !CBB_add_bytes(&value,
  131. reinterpret_cast<const uint8_t*>(value_string.data()),
  132. value_string.size()) ||
  133. !CBB_flush(&rdns)) {
  134. return false;
  135. }
  136. }
  137. if (!CBB_flush(cbb)) {
  138. return false;
  139. }
  140. return true;
  141. }
  142. bool CBBAddTime(CBB* cbb, base::Time time) {
  143. der::GeneralizedTime generalized_time;
  144. if (!der::EncodeTimeAsGeneralizedTime(time, &generalized_time))
  145. return false;
  146. // Per RFC 5280, 4.1.2.5, times which fit in UTCTime must be encoded as
  147. // UTCTime rather than GeneralizedTime.
  148. CBB child;
  149. uint8_t* out;
  150. if (generalized_time.InUTCTimeRange()) {
  151. return CBB_add_asn1(cbb, &child, CBS_ASN1_UTCTIME) &&
  152. CBB_add_space(&child, &out, der::kUTCTimeLength) &&
  153. der::EncodeUTCTime(generalized_time, out) && CBB_flush(cbb);
  154. }
  155. return CBB_add_asn1(cbb, &child, CBS_ASN1_GENERALIZEDTIME) &&
  156. CBB_add_space(&child, &out, der::kGeneralizedTimeLength) &&
  157. der::EncodeGeneralizedTime(generalized_time, out) && CBB_flush(cbb);
  158. }
  159. bool GetTLSServerEndPointChannelBinding(const X509Certificate& certificate,
  160. std::string* token) {
  161. static const char kChannelBindingPrefix[] = "tls-server-end-point:";
  162. base::StringPiece der_encoded_certificate =
  163. x509_util::CryptoBufferAsStringPiece(certificate.cert_buffer());
  164. der::Input tbs_certificate_tlv;
  165. der::Input signature_algorithm_tlv;
  166. der::BitString signature_value;
  167. if (!ParseCertificate(der::Input(der_encoded_certificate),
  168. &tbs_certificate_tlv, &signature_algorithm_tlv,
  169. &signature_value, nullptr)) {
  170. return false;
  171. }
  172. absl::optional<SignatureAlgorithm> signature_algorithm =
  173. ParseSignatureAlgorithm(signature_algorithm_tlv, nullptr);
  174. if (!signature_algorithm) {
  175. return false;
  176. }
  177. absl::optional<net::DigestAlgorithm> binding_digest =
  178. GetTlsServerEndpointDigestAlgorithm(*signature_algorithm);
  179. if (!binding_digest) {
  180. return false;
  181. }
  182. const EVP_MD* digest_evp_md = nullptr;
  183. switch (binding_digest.value()) {
  184. case net::DigestAlgorithm::Md2:
  185. case net::DigestAlgorithm::Md4:
  186. case net::DigestAlgorithm::Md5:
  187. case net::DigestAlgorithm::Sha1:
  188. // Legacy digests are not supported, and
  189. // `GetTlsServerEndpointDigestAlgorithm` internally maps MD5 and SHA-1 to
  190. // SHA-256.
  191. NOTREACHED();
  192. break;
  193. case net::DigestAlgorithm::Sha256:
  194. digest_evp_md = EVP_sha256();
  195. break;
  196. case net::DigestAlgorithm::Sha384:
  197. digest_evp_md = EVP_sha384();
  198. break;
  199. case net::DigestAlgorithm::Sha512:
  200. digest_evp_md = EVP_sha512();
  201. break;
  202. }
  203. if (!digest_evp_md)
  204. return false;
  205. uint8_t digest[EVP_MAX_MD_SIZE];
  206. unsigned int out_size;
  207. if (!EVP_Digest(der_encoded_certificate.data(),
  208. der_encoded_certificate.size(), digest, &out_size,
  209. digest_evp_md, nullptr))
  210. return false;
  211. token->assign(kChannelBindingPrefix);
  212. token->append(digest, digest + out_size);
  213. return true;
  214. }
  215. // RSA keys created by CreateKeyAndSelfSignedCert will be of this length.
  216. static const uint16_t kRSAKeyLength = 1024;
  217. // Certificates made by CreateKeyAndSelfSignedCert will be signed using this
  218. // digest algorithm.
  219. static const DigestAlgorithm kSignatureDigestAlgorithm = DIGEST_SHA256;
  220. bool CreateKeyAndSelfSignedCert(const std::string& subject,
  221. uint32_t serial_number,
  222. base::Time not_valid_before,
  223. base::Time not_valid_after,
  224. std::unique_ptr<crypto::RSAPrivateKey>* key,
  225. std::string* der_cert) {
  226. std::unique_ptr<crypto::RSAPrivateKey> new_key(
  227. crypto::RSAPrivateKey::Create(kRSAKeyLength));
  228. if (!new_key)
  229. return false;
  230. bool success = CreateSelfSignedCert(new_key->key(), kSignatureDigestAlgorithm,
  231. subject, serial_number, not_valid_before,
  232. not_valid_after, {}, der_cert);
  233. if (success)
  234. *key = std::move(new_key);
  235. return success;
  236. }
  237. Extension::Extension(base::span<const uint8_t> in_oid,
  238. bool in_critical,
  239. base::span<const uint8_t> in_contents)
  240. : oid(in_oid), critical(in_critical), contents(in_contents) {}
  241. Extension::~Extension() = default;
  242. Extension::Extension(const Extension&) = default;
  243. bool CreateSelfSignedCert(EVP_PKEY* key,
  244. DigestAlgorithm alg,
  245. const std::string& subject,
  246. uint32_t serial_number,
  247. base::Time not_valid_before,
  248. base::Time not_valid_after,
  249. const std::vector<Extension>& extension_specs,
  250. std::string* der_encoded) {
  251. crypto::EnsureOpenSSLInit();
  252. crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
  253. // See RFC 5280, section 4.1. First, construct the TBSCertificate.
  254. bssl::ScopedCBB cbb;
  255. CBB tbs_cert, version, validity;
  256. uint8_t* tbs_cert_bytes;
  257. size_t tbs_cert_len;
  258. if (!CBB_init(cbb.get(), 64) ||
  259. !CBB_add_asn1(cbb.get(), &tbs_cert, CBS_ASN1_SEQUENCE) ||
  260. !CBB_add_asn1(&tbs_cert, &version,
  261. CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0) ||
  262. !CBB_add_asn1_uint64(&version, 2) ||
  263. !CBB_add_asn1_uint64(&tbs_cert, serial_number) ||
  264. !AddRSASignatureAlgorithm(&tbs_cert, alg) || // signature
  265. !AddName(&tbs_cert, subject) || // issuer
  266. !CBB_add_asn1(&tbs_cert, &validity, CBS_ASN1_SEQUENCE) ||
  267. !CBBAddTime(&validity, not_valid_before) ||
  268. !CBBAddTime(&validity, not_valid_after) ||
  269. !AddName(&tbs_cert, subject) || // subject
  270. !EVP_marshal_public_key(&tbs_cert, key)) { // subjectPublicKeyInfo
  271. return false;
  272. }
  273. if (!extension_specs.empty()) {
  274. CBB outer_extensions, extensions;
  275. if (!CBB_add_asn1(&tbs_cert, &outer_extensions,
  276. 3 | CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED) ||
  277. !CBB_add_asn1(&outer_extensions, &extensions, CBS_ASN1_SEQUENCE)) {
  278. return false;
  279. }
  280. for (const auto& extension_spec : extension_specs) {
  281. CBB extension, oid, value;
  282. if (!CBB_add_asn1(&extensions, &extension, CBS_ASN1_SEQUENCE) ||
  283. !CBB_add_asn1(&extension, &oid, CBS_ASN1_OBJECT) ||
  284. !CBB_add_bytes(&oid, extension_spec.oid.data(),
  285. extension_spec.oid.size()) ||
  286. (extension_spec.critical && !CBB_add_asn1_bool(&extension, 1)) ||
  287. !CBB_add_asn1(&extension, &value, CBS_ASN1_OCTETSTRING) ||
  288. !CBB_add_bytes(&value, extension_spec.contents.data(),
  289. extension_spec.contents.size()) ||
  290. !CBB_flush(&extensions)) {
  291. return false;
  292. }
  293. }
  294. if (!CBB_flush(&tbs_cert)) {
  295. return false;
  296. }
  297. }
  298. if (!CBB_finish(cbb.get(), &tbs_cert_bytes, &tbs_cert_len))
  299. return false;
  300. bssl::UniquePtr<uint8_t> delete_tbs_cert_bytes(tbs_cert_bytes);
  301. // Sign the TBSCertificate and write the entire certificate.
  302. CBB cert, signature;
  303. bssl::ScopedEVP_MD_CTX ctx;
  304. uint8_t* sig_out;
  305. size_t sig_len;
  306. uint8_t* cert_bytes;
  307. size_t cert_len;
  308. if (!CBB_init(cbb.get(), tbs_cert_len) ||
  309. !CBB_add_asn1(cbb.get(), &cert, CBS_ASN1_SEQUENCE) ||
  310. !CBB_add_bytes(&cert, tbs_cert_bytes, tbs_cert_len) ||
  311. !AddRSASignatureAlgorithm(&cert, alg) ||
  312. !CBB_add_asn1(&cert, &signature, CBS_ASN1_BITSTRING) ||
  313. !CBB_add_u8(&signature, 0 /* no unused bits */) ||
  314. !EVP_DigestSignInit(ctx.get(), nullptr, ToEVP(alg), nullptr, key) ||
  315. // Compute the maximum signature length.
  316. !EVP_DigestSign(ctx.get(), nullptr, &sig_len, tbs_cert_bytes,
  317. tbs_cert_len) ||
  318. !CBB_reserve(&signature, &sig_out, sig_len) ||
  319. // Actually sign the TBSCertificate.
  320. !EVP_DigestSign(ctx.get(), sig_out, &sig_len, tbs_cert_bytes,
  321. tbs_cert_len) ||
  322. !CBB_did_write(&signature, sig_len) ||
  323. !CBB_finish(cbb.get(), &cert_bytes, &cert_len)) {
  324. return false;
  325. }
  326. bssl::UniquePtr<uint8_t> delete_cert_bytes(cert_bytes);
  327. der_encoded->assign(reinterpret_cast<char*>(cert_bytes), cert_len);
  328. return true;
  329. }
  330. CRYPTO_BUFFER_POOL* GetBufferPool() {
  331. return g_buffer_pool_singleton.Get().pool();
  332. }
  333. bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBuffer(
  334. base::span<const uint8_t> data) {
  335. return bssl::UniquePtr<CRYPTO_BUFFER>(
  336. CRYPTO_BUFFER_new(data.data(), data.size(), GetBufferPool()));
  337. }
  338. bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBuffer(
  339. const base::StringPiece& data) {
  340. return bssl::UniquePtr<CRYPTO_BUFFER>(
  341. CRYPTO_BUFFER_new(reinterpret_cast<const uint8_t*>(data.data()),
  342. data.size(), GetBufferPool()));
  343. }
  344. bssl::UniquePtr<CRYPTO_BUFFER> CreateCryptoBufferFromStaticDataUnsafe(
  345. base::span<const uint8_t> data) {
  346. return bssl::UniquePtr<CRYPTO_BUFFER>(
  347. CRYPTO_BUFFER_new_from_static_data_unsafe(data.data(), data.size(),
  348. GetBufferPool()));
  349. }
  350. bool CryptoBufferEqual(const CRYPTO_BUFFER* a, const CRYPTO_BUFFER* b) {
  351. DCHECK(a && b);
  352. if (a == b)
  353. return true;
  354. return CRYPTO_BUFFER_len(a) == CRYPTO_BUFFER_len(b) &&
  355. memcmp(CRYPTO_BUFFER_data(a), CRYPTO_BUFFER_data(b),
  356. CRYPTO_BUFFER_len(a)) == 0;
  357. }
  358. base::StringPiece CryptoBufferAsStringPiece(const CRYPTO_BUFFER* buffer) {
  359. return base::StringPiece(
  360. reinterpret_cast<const char*>(CRYPTO_BUFFER_data(buffer)),
  361. CRYPTO_BUFFER_len(buffer));
  362. }
  363. base::span<const uint8_t> CryptoBufferAsSpan(const CRYPTO_BUFFER* buffer) {
  364. return base::make_span(CRYPTO_BUFFER_data(buffer), CRYPTO_BUFFER_len(buffer));
  365. }
  366. scoped_refptr<X509Certificate> CreateX509CertificateFromBuffers(
  367. const STACK_OF(CRYPTO_BUFFER) * buffers) {
  368. if (sk_CRYPTO_BUFFER_num(buffers) == 0) {
  369. NOTREACHED();
  370. return nullptr;
  371. }
  372. std::vector<bssl::UniquePtr<CRYPTO_BUFFER>> intermediate_chain;
  373. for (size_t i = 1; i < sk_CRYPTO_BUFFER_num(buffers); ++i) {
  374. intermediate_chain.push_back(
  375. bssl::UpRef(sk_CRYPTO_BUFFER_value(buffers, i)));
  376. }
  377. return X509Certificate::CreateFromBuffer(
  378. bssl::UpRef(sk_CRYPTO_BUFFER_value(buffers, 0)),
  379. std::move(intermediate_chain));
  380. }
  381. bool CreateCertBuffersFromPKCS7Bytes(
  382. base::span<const uint8_t> data,
  383. std::vector<bssl::UniquePtr<CRYPTO_BUFFER>>* handles) {
  384. crypto::EnsureOpenSSLInit();
  385. crypto::OpenSSLErrStackTracer err_cleaner(FROM_HERE);
  386. CBS der_data;
  387. CBS_init(&der_data, data.data(), data.size());
  388. STACK_OF(CRYPTO_BUFFER)* certs = sk_CRYPTO_BUFFER_new_null();
  389. bool success =
  390. PKCS7_get_raw_certificates(certs, &der_data, x509_util::GetBufferPool());
  391. if (success) {
  392. for (size_t i = 0; i < sk_CRYPTO_BUFFER_num(certs); ++i) {
  393. handles->push_back(
  394. bssl::UniquePtr<CRYPTO_BUFFER>(sk_CRYPTO_BUFFER_value(certs, i)));
  395. }
  396. }
  397. // |handles| took ownership of the individual buffers, so only free the list
  398. // itself.
  399. sk_CRYPTO_BUFFER_free(certs);
  400. return success;
  401. }
  402. ParseCertificateOptions DefaultParseCertificateOptions() {
  403. ParseCertificateOptions options;
  404. options.allow_invalid_serial_numbers = true;
  405. return options;
  406. }
  407. bool CalculateSha256SpkiHash(const CRYPTO_BUFFER* buffer, HashValue* hash) {
  408. base::StringPiece spki;
  409. if (!asn1::ExtractSPKIFromDERCert(CryptoBufferAsStringPiece(buffer), &spki)) {
  410. return false;
  411. }
  412. *hash = HashValue(HASH_VALUE_SHA256);
  413. crypto::SHA256HashString(spki, hash->data(), hash->size());
  414. return true;
  415. }
  416. bool SignatureVerifierInitWithCertificate(
  417. crypto::SignatureVerifier* verifier,
  418. crypto::SignatureVerifier::SignatureAlgorithm signature_algorithm,
  419. base::span<const uint8_t> signature,
  420. const CRYPTO_BUFFER* certificate) {
  421. base::StringPiece cert_der =
  422. x509_util::CryptoBufferAsStringPiece(certificate);
  423. der::Input tbs_certificate_tlv;
  424. der::Input signature_algorithm_tlv;
  425. der::BitString signature_value;
  426. ParsedTbsCertificate tbs;
  427. if (!ParseCertificate(der::Input(cert_der), &tbs_certificate_tlv,
  428. &signature_algorithm_tlv, &signature_value, nullptr) ||
  429. !ParseTbsCertificate(tbs_certificate_tlv,
  430. DefaultParseCertificateOptions(), &tbs, nullptr)) {
  431. return false;
  432. }
  433. // The key usage extension, if present, must assert the digitalSignature bit.
  434. if (tbs.extensions_tlv) {
  435. std::map<der::Input, ParsedExtension> extensions;
  436. if (!ParseExtensions(tbs.extensions_tlv.value(), &extensions)) {
  437. return false;
  438. }
  439. ParsedExtension key_usage_ext;
  440. if (ConsumeExtension(der::Input(kKeyUsageOid), &extensions,
  441. &key_usage_ext)) {
  442. der::BitString key_usage;
  443. if (!ParseKeyUsage(key_usage_ext.value, &key_usage) ||
  444. !key_usage.AssertsBit(KEY_USAGE_BIT_DIGITAL_SIGNATURE)) {
  445. return false;
  446. }
  447. }
  448. }
  449. return verifier->VerifyInit(
  450. signature_algorithm, signature,
  451. base::make_span(tbs.spki_tlv.UnsafeData(), tbs.spki_tlv.Length()));
  452. }
  453. bool HasRsaPkcs1Sha1Signature(const CRYPTO_BUFFER* cert_buffer) {
  454. der::Input tbs_certificate_tlv;
  455. der::Input signature_algorithm_tlv;
  456. der::BitString signature_value;
  457. if (!ParseCertificate(der::Input(CRYPTO_BUFFER_data(cert_buffer),
  458. CRYPTO_BUFFER_len(cert_buffer)),
  459. &tbs_certificate_tlv, &signature_algorithm_tlv,
  460. &signature_value, /*out_errors=*/nullptr)) {
  461. return false;
  462. }
  463. absl::optional<SignatureAlgorithm> signature_algorithm =
  464. ParseSignatureAlgorithm(signature_algorithm_tlv,
  465. /*errors=*/nullptr);
  466. return signature_algorithm &&
  467. *signature_algorithm == SignatureAlgorithm::kRsaPkcs1Sha1;
  468. }
  469. } // namespace net::x509_util