network_context_unittest.cc 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. // Copyright 2020 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 <memory>
  5. #include "base/feature_list.h"
  6. #include "base/test/metrics/histogram_tester.h"
  7. #include "base/test/scoped_feature_list.h"
  8. #include "base/test/task_environment.h"
  9. #include "net/base/features.h"
  10. #include "net/test/embedded_test_server/default_handlers.h"
  11. #include "net/test/embedded_test_server/embedded_test_server.h"
  12. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  13. #include "services/cert_verifier/cert_verifier_service_factory.h"
  14. #include "services/cert_verifier/public/mojom/cert_verifier_service_factory.mojom.h"
  15. #include "services/network/network_context.h"
  16. #include "services/network/network_service.h"
  17. #include "services/network/public/cpp/features.h"
  18. #include "services/network/public/mojom/cert_verifier_service.mojom.h"
  19. #include "services/network/public/mojom/network_context.mojom.h"
  20. #include "services/network/test/test_url_loader_client.h"
  21. #include "testing/gtest/include/gtest/gtest.h"
  22. namespace cert_verifier {
  23. namespace {
  24. mojo::PendingRemote<mojom::CertVerifierService> GetNewCertVerifierServiceRemote(
  25. mojom::CertVerifierServiceFactory* cert_verifier_service_factory,
  26. mojom::CertVerifierCreationParamsPtr creation_params) {
  27. mojo::PendingRemote<mojom::CertVerifierService> cert_verifier_remote;
  28. cert_verifier_service_factory->GetNewCertVerifier(
  29. cert_verifier_remote.InitWithNewPipeAndPassReceiver(),
  30. std::move(creation_params));
  31. return cert_verifier_remote;
  32. }
  33. } // namespace
  34. class NetworkContextWithRealCertVerifierTest : public testing::Test {
  35. public:
  36. explicit NetworkContextWithRealCertVerifierTest(
  37. base::test::TaskEnvironment::TimeSource time_source =
  38. base::test::TaskEnvironment::TimeSource::DEFAULT)
  39. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO,
  40. time_source),
  41. network_change_notifier_(
  42. net::NetworkChangeNotifier::CreateMockIfNeeded()),
  43. network_service_(network::NetworkService::CreateForTesting()) {}
  44. ~NetworkContextWithRealCertVerifierTest() override = default;
  45. std::unique_ptr<network::NetworkContext> CreateContextWithParams(
  46. network::mojom::NetworkContextParamsPtr context_params) {
  47. network_context_remote_.reset();
  48. return std::make_unique<network::NetworkContext>(
  49. network_service_.get(),
  50. network_context_remote_.BindNewPipeAndPassReceiver(),
  51. std::move(context_params));
  52. }
  53. network::mojom::CertVerifierServiceRemoteParamsPtr GetCertVerifierParams(
  54. mojom::CertVerifierCreationParamsPtr cert_verifier_creation_params =
  55. mojom::CertVerifierCreationParams::New()) {
  56. if (!cert_verifier_service_factory_) {
  57. cert_verifier_service_factory_ =
  58. std::make_unique<CertVerifierServiceFactoryImpl>(
  59. cert_verifier_service_factory_remote_
  60. .BindNewPipeAndPassReceiver());
  61. }
  62. // Create a cert verifier service.
  63. auto cert_verifier_service_remote = GetNewCertVerifierServiceRemote(
  64. cert_verifier_service_factory_.get(),
  65. std::move(cert_verifier_creation_params));
  66. return network::mojom::CertVerifierServiceRemoteParams::New(
  67. std::move(cert_verifier_service_remote));
  68. }
  69. network::mojom::NetworkService* network_service() const {
  70. return network_service_.get();
  71. }
  72. private:
  73. base::test::TaskEnvironment task_environment_;
  74. std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
  75. std::unique_ptr<network::NetworkService> network_service_;
  76. // Stores the mojo::Remote<NetworkContext> of the most recently created
  77. // NetworkContext. Not strictly needed, but seems best to mimic real-world
  78. // usage.
  79. mojo::Remote<network::mojom::NetworkContext> network_context_remote_;
  80. mojo::Remote<mojom::CertVerifierServiceFactory>
  81. cert_verifier_service_factory_remote_;
  82. std::unique_ptr<mojom::CertVerifierServiceFactory>
  83. cert_verifier_service_factory_;
  84. };
  85. #if BUILDFLAG(BUILTIN_CERT_VERIFIER_FEATURE_SUPPORTED)
  86. namespace {
  87. network::mojom::NetworkContextParamsPtr CreateContextParams() {
  88. network::mojom::NetworkContextParamsPtr params =
  89. network::mojom::NetworkContextParams::New();
  90. // Use a fixed proxy config, to avoid dependencies on local network
  91. // configuration.
  92. params->initial_proxy_config = net::ProxyConfigWithAnnotation::CreateDirect();
  93. return params;
  94. }
  95. std::unique_ptr<network::TestURLLoaderClient> FetchRequest(
  96. const network::ResourceRequest& request,
  97. network::NetworkContext* network_context,
  98. int url_loader_options = network::mojom::kURLLoadOptionNone,
  99. int process_id = network::mojom::kBrowserProcessId,
  100. network::mojom::URLLoaderFactoryParamsPtr params = nullptr) {
  101. mojo::Remote<network::mojom::URLLoaderFactory> loader_factory;
  102. if (!params)
  103. params = network::mojom::URLLoaderFactoryParams::New();
  104. params->process_id = process_id;
  105. params->is_corb_enabled = false;
  106. // If |site_for_cookies| is null, any non-empty NIK is fine. Otherwise, the
  107. // NIK must be consistent with |site_for_cookies|.
  108. if (request.site_for_cookies.IsNull()) {
  109. params->isolation_info = net::IsolationInfo::Create(
  110. net::IsolationInfo::RequestType::kOther,
  111. url::Origin::Create(GURL("https://abc.invalid")),
  112. url::Origin::Create(GURL("https://xyz.invalid")),
  113. request.site_for_cookies);
  114. } else {
  115. params->isolation_info = net::IsolationInfo::CreateForInternalRequest(
  116. url::Origin::Create(request.site_for_cookies.RepresentativeUrl()));
  117. }
  118. network_context->CreateURLLoaderFactory(
  119. loader_factory.BindNewPipeAndPassReceiver(), std::move(params));
  120. auto client = std::make_unique<network::TestURLLoaderClient>();
  121. mojo::PendingRemote<network::mojom::URLLoader> loader;
  122. loader_factory->CreateLoaderAndStart(
  123. loader.InitWithNewPipeAndPassReceiver(), 0 /* request_id */,
  124. url_loader_options, request, client->CreateRemote(),
  125. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
  126. client->RunUntilComplete();
  127. return client;
  128. }
  129. } // namespace
  130. TEST_F(NetworkContextWithRealCertVerifierTest, UseCertVerifierBuiltin) {
  131. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  132. net::test_server::RegisterDefaultHandlers(&test_server);
  133. ASSERT_TRUE(test_server.Start());
  134. // This just happens to be the only histogram that directly records which
  135. // verifier was used.
  136. const char kBuiltinVerifierHistogram[] =
  137. "Net.CertVerifier.NameNormalizationPrivateRoots.Builtin";
  138. for (bool builtin_verifier_enabled : {false, true}) {
  139. SCOPED_TRACE(builtin_verifier_enabled);
  140. network::mojom::NetworkContextParamsPtr params = CreateContextParams();
  141. auto creation_params = mojom::CertVerifierCreationParams::New();
  142. creation_params->use_builtin_cert_verifier =
  143. builtin_verifier_enabled
  144. ? mojom::CertVerifierCreationParams::CertVerifierImpl::kBuiltin
  145. : mojom::CertVerifierCreationParams::CertVerifierImpl::kSystem;
  146. params->cert_verifier_params =
  147. GetCertVerifierParams(std::move(creation_params));
  148. std::unique_ptr<network::NetworkContext> network_context =
  149. CreateContextWithParams(std::move(params));
  150. network::ResourceRequest request;
  151. request.url = test_server.GetURL("/nocontent");
  152. base::HistogramTester histogram_tester;
  153. std::unique_ptr<network::TestURLLoaderClient> client =
  154. FetchRequest(request, network_context.get());
  155. EXPECT_EQ(net::OK, client->completion_status().error_code);
  156. histogram_tester.ExpectTotalCount(kBuiltinVerifierHistogram,
  157. builtin_verifier_enabled ? 1 : 0);
  158. }
  159. }
  160. class NetworkContextCertVerifierBuiltinFeatureFlagTest
  161. : public NetworkContextWithRealCertVerifierTest,
  162. public testing::WithParamInterface<bool> {
  163. public:
  164. NetworkContextCertVerifierBuiltinFeatureFlagTest()
  165. : use_builtin_cert_verifier_feature_(GetParam()) {
  166. scoped_feature_list_.InitWithFeatureState(
  167. net::features::kCertVerifierBuiltinFeature,
  168. use_builtin_cert_verifier_feature_);
  169. }
  170. bool use_builtin_cert_verifier_feature() const {
  171. return use_builtin_cert_verifier_feature_;
  172. }
  173. private:
  174. const bool use_builtin_cert_verifier_feature_;
  175. base::test::ScopedFeatureList scoped_feature_list_;
  176. };
  177. TEST_P(NetworkContextCertVerifierBuiltinFeatureFlagTest,
  178. DefaultNetworkContextParamsUsesCorrectVerifier) {
  179. net::EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
  180. net::test_server::RegisterDefaultHandlers(&test_server);
  181. ASSERT_TRUE(test_server.Start());
  182. // This just happens to be the only histogram that directly records which
  183. // verifier was used.
  184. const char kBuiltinVerifierHistogram[] =
  185. "Net.CertVerifier.NameNormalizationPrivateRoots.Builtin";
  186. // Test creating a NetworkContextParams without specifying a value for
  187. // use_builtin_cert_verifier. Should use whatever the default cert verifier
  188. // implementation is according to the feature flag.
  189. network::mojom::NetworkContextParamsPtr params = CreateContextParams();
  190. params->cert_verifier_params = GetCertVerifierParams();
  191. std::unique_ptr<network::NetworkContext> network_context =
  192. CreateContextWithParams(std::move(params));
  193. network::ResourceRequest request;
  194. request.url = test_server.GetURL("/nocontent");
  195. base::HistogramTester histogram_tester;
  196. std::unique_ptr<network::TestURLLoaderClient> client =
  197. FetchRequest(request, network_context.get());
  198. EXPECT_EQ(net::OK, client->completion_status().error_code);
  199. histogram_tester.ExpectTotalCount(
  200. kBuiltinVerifierHistogram, use_builtin_cert_verifier_feature() ? 1 : 0);
  201. }
  202. INSTANTIATE_TEST_SUITE_P(All,
  203. NetworkContextCertVerifierBuiltinFeatureFlagTest,
  204. ::testing::Bool());
  205. #endif // BUILDFLAG(BUILTIN_CERT_VERIFIER_FEATURE_SUPPORTED)
  206. } // namespace cert_verifier