Google Git
Sign in
chromium / chromium / src.git / e4b349cf47796e947e125b0a2d348ec458122166 / . / net / base / network_isolation_key_unittest.cc
blob: 39b9d55c53c95b55df6d0b570cacdd59fa17b7ef [file] [log] [blame]
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]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
5#include "net/base/network_isolation_key.h"
6
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]7#include "base/stl_util.h"
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]8#include "base/test/scoped_feature_list.h"
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]9#include "base/values.h"
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]10#include "net/base/features.h"
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]11#include "testing/gtest/include/gtest/gtest.h"
12#include "url/gurl.h"
13#include "url/origin.h"
Matt Menked5a68262019-12-18 16:01:54[diff] [blame]14#include "url/url_util.h"
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]15
16namespace net {
17
18TEST(NetworkIsolationKeyTest, EmptyKey) {
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]19 base::test::ScopedFeatureList feature_list;
20 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]21 features::kAppendFrameOriginToNetworkIsolationKey);
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]22
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]23 NetworkIsolationKey key;
24 EXPECT_FALSE(key.IsFullyPopulated());
25 EXPECT_EQ(std::string(), key.ToString());
26 EXPECT_TRUE(key.IsTransient());
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]27 EXPECT_EQ("null", key.ToDebugString());
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]28}
29
30TEST(NetworkIsolationKeyTest, NonEmptyKey) {
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]31 base::test::ScopedFeatureList feature_list;
32 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]33 features::kAppendFrameOriginToNetworkIsolationKey);
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]34
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]35 url::Origin origin = url::Origin::Create(GURL("http://a.test/"));
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]36 NetworkIsolationKey key(origin, origin);
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]37 EXPECT_TRUE(key.IsFullyPopulated());
38 EXPECT_EQ(origin.Serialize(), key.ToString());
39 EXPECT_FALSE(key.IsTransient());
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]40 EXPECT_EQ("http://a.test", key.ToDebugString());
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]41}
42
43TEST(NetworkIsolationKeyTest, OpaqueOriginKey) {
44 url::Origin origin_data =
45 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]46 NetworkIsolationKey key(origin_data, origin_data);
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]47 EXPECT_TRUE(key.IsFullyPopulated());
48 EXPECT_EQ(std::string(), key.ToString());
49 EXPECT_TRUE(key.IsTransient());
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]50
51 // Create another opaque origin, and make sure it has a different debug
52 // string.
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]53 const auto kOriginNew = origin_data.DeriveNewOpaqueOrigin();
54 EXPECT_NE(key.ToDebugString(),
55 NetworkIsolationKey(kOriginNew, kOriginNew).ToDebugString());
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]56}
57
58TEST(NetworkIsolationKeyTest, Operators) {
59 // These are in ascending order.
60 const NetworkIsolationKey kKeys[] = {
61 NetworkIsolationKey(),
62 // Unique origins are still sorted by scheme, so data is before file, and
63 // file before http.
64 NetworkIsolationKey(
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]65 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>")),
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]66 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"))),
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]67 NetworkIsolationKey(url::Origin::Create(GURL("file:///foo")),
68 url::Origin::Create(GURL("file:///foo"))),
69 NetworkIsolationKey(url::Origin::Create(GURL("http://a.test/")),
70 url::Origin::Create(GURL("http://a.test/"))),
71 NetworkIsolationKey(url::Origin::Create(GURL("http://b.test/")),
72 url::Origin::Create(GURL("http://b.test/"))),
73 NetworkIsolationKey(url::Origin::Create(GURL("https://a.test/")),
74 url::Origin::Create(GURL("https://a.test/"))),
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]75 };
76
77 for (size_t first = 0; first < base::size(kKeys); ++first) {
78 NetworkIsolationKey key1 = kKeys[first];
79 SCOPED_TRACE(key1.ToDebugString());
80
81 EXPECT_TRUE(key1 == key1);
82 EXPECT_FALSE(key1 < key1);
83
84 // Make sure that copying a key doesn't change the results of any operation.
85 // This check is a bit more interesting with unique origins.
86 NetworkIsolationKey key1_copy = key1;
87 EXPECT_TRUE(key1 == key1_copy);
88 EXPECT_FALSE(key1 < key1_copy);
89 EXPECT_FALSE(key1_copy < key1);
90
91 for (size_t second = first + 1; second < base::size(kKeys); ++second) {
92 NetworkIsolationKey key2 = kKeys[second];
93 SCOPED_TRACE(key2.ToDebugString());
94
95 EXPECT_TRUE(key1 < key2);
96 EXPECT_FALSE(key2 < key1);
97 EXPECT_FALSE(key1 == key2);
98 EXPECT_FALSE(key2 == key1);
99 }
100 }
101}
102
103TEST(NetworkIsolationKeyTest, UniqueOriginOperators) {
Shivani Sharma8ae506c2019-07-21 21:08:27[diff] [blame]104 const auto kOrigin1 =
105 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
106 const auto kOrigin2 =
107 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
108 NetworkIsolationKey key1(kOrigin1, kOrigin1);
109 NetworkIsolationKey key2(kOrigin2, kOrigin2);
Matt Menke166443c2019-05-24 18:45:59[diff] [blame]110
111 EXPECT_TRUE(key1 == key1);
112 EXPECT_TRUE(key2 == key2);
113
114 // Creating copies shouldn't affect comparison result.
115 EXPECT_TRUE(NetworkIsolationKey(key1) == NetworkIsolationKey(key1));
116 EXPECT_TRUE(NetworkIsolationKey(key2) == NetworkIsolationKey(key2));
117
118 EXPECT_FALSE(key1 == key2);
119 EXPECT_FALSE(key2 == key1);
120
121 // Order of Nonces isn't predictable, but they should have an ordering.
122 EXPECT_TRUE(key1 < key2 || key2 < key1);
123 EXPECT_TRUE(!(key1 < key2) || !(key2 < key1));
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]124}
125
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]126TEST(NetworkIsolationKeyTest, KeyWithOpaqueFrameOrigin) {
127 base::test::ScopedFeatureList feature_list;
128 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]129 features::kAppendFrameOriginToNetworkIsolationKey);
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]130
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]131 url::Origin origin_data =
132 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
133
134 NetworkIsolationKey key1(url::Origin::Create(GURL("http://a.test")),
135 origin_data);
136 EXPECT_TRUE(key1.IsFullyPopulated());
137 EXPECT_FALSE(key1.IsTransient());
138 EXPECT_EQ("http://a.test", key1.ToString());
139 EXPECT_EQ("http://a.test", key1.ToDebugString());
140
141 NetworkIsolationKey key2(origin_data,
142 url::Origin::Create(GURL("http://a.test")));
143 EXPECT_TRUE(key2.IsFullyPopulated());
144 EXPECT_TRUE(key2.IsTransient());
145 EXPECT_EQ("", key2.ToString());
146 EXPECT_EQ(origin_data.GetDebugString(), key2.ToDebugString());
147 EXPECT_NE(origin_data.DeriveNewOpaqueOrigin().GetDebugString(),
148 key2.ToDebugString());
149}
150
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]151TEST(NetworkIsolationKeyTest, ValueRoundTripEmpty) {
152 const url::Origin kJunkOrigin =
153 url::Origin::Create(GURL("data:text/html,junk"));
154
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]155 for (bool use_frame_origins : {true, false}) {
156 SCOPED_TRACE(use_frame_origins);
157 base::test::ScopedFeatureList feature_list;
158 if (use_frame_origins) {
159 feature_list.InitAndEnableFeature(
160 features::kAppendFrameOriginToNetworkIsolationKey);
161 } else {
162 feature_list.InitAndDisableFeature(
163 features::kAppendFrameOriginToNetworkIsolationKey);
164 }
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]165
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]166 // Convert empty key to value and back, expecting the same value.
167 NetworkIsolationKey no_frame_origin_key;
168 base::Value no_frame_origin_value;
169 ASSERT_TRUE(no_frame_origin_key.ToValue(&no_frame_origin_value));
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]170
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]171 // Fill initial value with junk data, to make sure it's overwritten.
172 NetworkIsolationKey out_key(kJunkOrigin, kJunkOrigin);
173 EXPECT_TRUE(
174 NetworkIsolationKey::FromValue(no_frame_origin_value, &out_key));
175 EXPECT_EQ(no_frame_origin_key, out_key);
176 }
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]177}
178
179TEST(NetworkIsolationKeyTest, ValueRoundTripNoFrameOrigin) {
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]180 base::test::ScopedFeatureList feature_list;
181 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]182 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]183 const url::Origin kJunkOrigin =
184 url::Origin::Create(GURL("data:text/html,junk"));
185
186 NetworkIsolationKey key1(url::Origin::Create(GURL("https://foo.test/")),
187 kJunkOrigin);
188 base::Value value;
189 ASSERT_TRUE(key1.ToValue(&value));
190
191 // Fill initial value with junk data, to make sure it's overwritten.
192 NetworkIsolationKey key2(kJunkOrigin, kJunkOrigin);
193 EXPECT_TRUE(NetworkIsolationKey::FromValue(value, &key2));
194 EXPECT_EQ(key1, key2);
195
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]196 feature_list.Reset();
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]197 feature_list.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]198 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]199
200 // Loading should fail when frame origins are enabled.
201 EXPECT_FALSE(NetworkIsolationKey::FromValue(value, &key2));
202}
203
204TEST(NetworkIsolationKeyTest, ValueRoundTripFrameOrigin) {
205 const url::Origin kJunkOrigin =
206 url::Origin::Create(GURL("data:text/html,junk"));
207
208 base::test::ScopedFeatureList feature_list;
209 feature_list.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]210 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]211
212 NetworkIsolationKey key1(url::Origin::Create(GURL("https://foo.test/")),
213 url::Origin::Create(GURL("https://foo.test/")));
214 base::Value value;
215 ASSERT_TRUE(key1.ToValue(&value));
216
217 // Fill initial value with junk data, to make sure it's overwritten.
218 NetworkIsolationKey key2(kJunkOrigin, kJunkOrigin);
219 EXPECT_TRUE(NetworkIsolationKey::FromValue(value, &key2));
220 EXPECT_EQ(key1, key2);
221
222 feature_list.Reset();
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]223 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]224 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]225
226 // Loading should fail when frame origins are disabled.
227 EXPECT_FALSE(NetworkIsolationKey::FromValue(value, &key2));
228}
229
230TEST(NetworkIsolationKeyTest, ToValueTransientOrigin) {
231 const url::Origin kTransientOrigin =
232 url::Origin::Create(GURL("data:text/html,transient"));
233
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]234 for (bool use_frame_origins : {true, false}) {
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]235 SCOPED_TRACE(use_frame_origins);
236 base::test::ScopedFeatureList feature_list;
237 if (use_frame_origins) {
238 feature_list.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]239 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]240 } else {
241 feature_list.InitAndDisableFeature(
242 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]243 }
244
245 NetworkIsolationKey key1(kTransientOrigin, kTransientOrigin);
246 EXPECT_TRUE(key1.IsTransient());
247 base::Value value;
248 EXPECT_FALSE(key1.ToValue(&value));
249 }
250}
251
252TEST(NetworkIsolationKeyTest, FromValueBadData) {
253 // Can't create these inline, since vector initialization lists require a
254 // copy, and base::Value has no copy operator, only move.
255 base::Value::ListStorage not_a_url_list;
256 not_a_url_list.emplace_back(base::Value("not-a-url"));
257
258 base::Value::ListStorage transient_origin_list;
259 transient_origin_list.emplace_back(base::Value("data:text/html,transient"));
260
261 base::Value::ListStorage too_many_origins_list;
262 too_many_origins_list.emplace_back(base::Value("https://too/"));
263 too_many_origins_list.emplace_back(base::Value("https://many/"));
264 too_many_origins_list.emplace_back(base::Value("https://origins/"));
265
266 const base::Value kTestCases[] = {
267 base::Value(base::Value::Type::STRING),
268 base::Value(base::Value::Type::DICTIONARY),
269 base::Value(std::move(not_a_url_list)),
270 base::Value(std::move(transient_origin_list)),
271 base::Value(std::move(too_many_origins_list)),
272 };
273
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]274 for (bool use_frame_origins : {true, false}) {
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]275 SCOPED_TRACE(use_frame_origins);
276 base::test::ScopedFeatureList feature_list;
277 if (use_frame_origins) {
278 feature_list.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]279 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]280 } else {
281 feature_list.InitAndDisableFeature(
282 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menke2fa45992019-08-06 23:07:35[diff] [blame]283 }
284
285 for (const auto& test_case : kTestCases) {
286 NetworkIsolationKey key;
287 // Write the value on failure.
288 EXPECT_FALSE(NetworkIsolationKey::FromValue(test_case, &key))
289 << test_case;
290 }
291 }
292}
293
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]294TEST(NetworkIsolationKeyTest, UseRegistrableDomain) {
295 base::test::ScopedFeatureList feature_list;
Shivani Sharmaaa3020342019-11-20 20:56:57[diff] [blame]296 feature_list.InitWithFeatures(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]297 {features::kUseRegistrableDomainInNetworkIsolationKey},
298 {features::kAppendFrameOriginToNetworkIsolationKey});
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]299
300 // Both origins are non-opaque.
301 url::Origin origin_a = url::Origin::Create(GURL("http://a.foo.test:80"));
302 url::Origin origin_b = url::Origin::Create(GURL("https://b.foo.test:2395"));
303
304 // Resultant NIK should have the same scheme as the initial origin and
305 // default port. Note that frame_origin will be empty as triple keying is not
306 // enabled.
307 url::Origin expected_domain_a = url::Origin::Create(GURL("http://foo.test"));
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]308 NetworkIsolationKey key(origin_a, origin_b);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]309 EXPECT_EQ(origin_a, key.GetTopFrameOrigin().value());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]310 EXPECT_FALSE(key.GetFrameOrigin().has_value());
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]311 EXPECT_EQ(expected_domain_a.Serialize(), key.ToString());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]312
313 // More tests for using registrable domain are in
314 // NetworkIsolationKeyWithFrameOriginTest.UseRegistrableDomain.
315}
316
Robert Ogdendd74d732020-03-12 17:33:19[diff] [blame]317class OpaqueNonTransientNetworkIsolationKeyTest : public testing::Test {
318 public:
319 OpaqueNonTransientNetworkIsolationKeyTest() = default;
320 ~OpaqueNonTransientNetworkIsolationKeyTest() override = default;
321
322 std::string GetOriginNonceToString(const net::NetworkIsolationKey& key) {
323 return key.GetTopFrameOrigin().value().nonce_->token().ToString();
324 }
325};
326
327TEST_F(OpaqueNonTransientNetworkIsolationKeyTest,
328 OpaqueNonTransient_DisableAppendFrameOrigin) {
329 base::test::ScopedFeatureList feature_list;
330 feature_list.InitAndDisableFeature(
331 features::kAppendFrameOriginToNetworkIsolationKey);
332
333 NetworkIsolationKey key = NetworkIsolationKey::CreateOpaqueAndNonTransient();
334 EXPECT_TRUE(key.IsFullyPopulated());
335 EXPECT_FALSE(key.IsTransient());
336 EXPECT_FALSE(key.IsEmpty());
337 EXPECT_EQ("opaque non-transient " + GetOriginNonceToString(key),
338 key.ToString());
339 EXPECT_EQ(key.GetTopFrameOrigin()->GetDebugString() + " non-transient",
340 key.ToDebugString());
341
342 // |opaque_and_non_transient_| is kept when a new frame origin is opaque.
343 url::Origin opaque_origin;
344 NetworkIsolationKey new_frame_origin =
345 key.CreateWithNewFrameOrigin(opaque_origin);
346 EXPECT_TRUE(new_frame_origin.IsFullyPopulated());
347 EXPECT_FALSE(new_frame_origin.IsTransient());
348 EXPECT_FALSE(new_frame_origin.IsEmpty());
349 EXPECT_EQ("opaque non-transient " + GetOriginNonceToString(new_frame_origin),
350 new_frame_origin.ToString());
351 EXPECT_EQ(
352 new_frame_origin.GetTopFrameOrigin()->GetDebugString() + " non-transient",
353 new_frame_origin.ToDebugString());
354
355 // Should not be equal to a similar NetworkIsolationKey derived from it.
356 EXPECT_NE(key, NetworkIsolationKey(*key.GetTopFrameOrigin(),
357 *key.GetTopFrameOrigin()));
358
359 // To and back from a Value should yield the same key.
360 base::Value value;
361 ASSERT_TRUE(key.ToValue(&value));
362 NetworkIsolationKey from_value;
363 ASSERT_TRUE(NetworkIsolationKey::FromValue(value, &from_value));
364 EXPECT_EQ(key, from_value);
365 EXPECT_EQ(key.ToString(), from_value.ToString());
366 EXPECT_EQ(key.ToDebugString(), from_value.ToDebugString());
367}
368
369TEST_F(OpaqueNonTransientNetworkIsolationKeyTest,
370 OpaqueNonTransient_EnableAppendFrameOrigin) {
371 base::test::ScopedFeatureList feature_list;
372 feature_list.InitAndEnableFeature(
373 features::kAppendFrameOriginToNetworkIsolationKey);
374
375 NetworkIsolationKey key = NetworkIsolationKey::CreateOpaqueAndNonTransient();
376 EXPECT_TRUE(key.IsFullyPopulated());
377 EXPECT_FALSE(key.IsTransient());
378 EXPECT_FALSE(key.IsEmpty());
379 EXPECT_EQ("opaque non-transient " + GetOriginNonceToString(key),
380 key.ToString());
381 EXPECT_EQ(key.GetTopFrameOrigin()->GetDebugString() + " " +
382 key.GetFrameOrigin()->GetDebugString() + " non-transient",
383 key.ToDebugString());
384
385 // |opaque_and_non_transient_| is kept when a new frame origin is opaque.
386 url::Origin opaque_origin;
387 NetworkIsolationKey new_frame_origin =
388 key.CreateWithNewFrameOrigin(opaque_origin);
389 EXPECT_TRUE(new_frame_origin.IsFullyPopulated());
390 EXPECT_FALSE(new_frame_origin.IsTransient());
391 EXPECT_FALSE(new_frame_origin.IsEmpty());
392 EXPECT_EQ("opaque non-transient " + GetOriginNonceToString(new_frame_origin),
393 new_frame_origin.ToString());
394 EXPECT_EQ(new_frame_origin.GetTopFrameOrigin()->GetDebugString() + " " +
395 new_frame_origin.GetFrameOrigin()->GetDebugString() +
396 " non-transient",
397 new_frame_origin.ToDebugString());
398
399 // Should not be equal to a similar NetworkIsolationKey derived from it.
400 EXPECT_NE(key, NetworkIsolationKey(*key.GetTopFrameOrigin(),
401 *key.GetFrameOrigin()));
402
403 // To and back from a Value should yield the same key.
404 base::Value value;
405 ASSERT_TRUE(key.ToValue(&value));
406 NetworkIsolationKey from_value;
407 ASSERT_TRUE(NetworkIsolationKey::FromValue(value, &from_value));
408 EXPECT_EQ(key, from_value);
409 EXPECT_EQ(key.ToString(), from_value.ToString());
410 EXPECT_EQ(key.ToDebugString(), from_value.ToDebugString());
411}
412
Yao Xiao6924a36a2019-07-12 16:55:19[diff] [blame]413class NetworkIsolationKeyWithFrameOriginTest : public testing::Test {
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]414 public:
Yao Xiao6924a36a2019-07-12 16:55:19[diff] [blame]415 NetworkIsolationKeyWithFrameOriginTest() {
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]416 feature_list_.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]417 features::kAppendFrameOriginToNetworkIsolationKey);
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]418 }
419
420 private:
421 base::test::ScopedFeatureList feature_list_;
422};
423
Yao Xiao6924a36a2019-07-12 16:55:19[diff] [blame]424TEST_F(NetworkIsolationKeyWithFrameOriginTest, WithFrameOrigin) {
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]425 NetworkIsolationKey key(url::Origin::Create(GURL("http://b.test")),
426 url::Origin::Create(GURL("http://a.test/")));
427 EXPECT_TRUE(key.IsFullyPopulated());
428 EXPECT_FALSE(key.IsTransient());
429 EXPECT_EQ("http://b.test http://a.test", key.ToString());
430 EXPECT_EQ("http://b.test http://a.test", key.ToDebugString());
431
432 EXPECT_TRUE(key == key);
433 EXPECT_FALSE(key != key);
434 EXPECT_FALSE(key < key);
435}
436
Yao Xiao6924a36a2019-07-12 16:55:19[diff] [blame]437TEST_F(NetworkIsolationKeyWithFrameOriginTest, OpaqueOriginKey) {
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]438 url::Origin origin_data =
439 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
440
441 NetworkIsolationKey key1(url::Origin::Create(GURL("http://a.test")),
442 origin_data);
443 EXPECT_TRUE(key1.IsFullyPopulated());
444 EXPECT_TRUE(key1.IsTransient());
445 EXPECT_EQ("", key1.ToString());
446 EXPECT_EQ("http://a.test " + origin_data.GetDebugString(),
447 key1.ToDebugString());
448 EXPECT_NE(
449 "http://a.test " + origin_data.DeriveNewOpaqueOrigin().GetDebugString(),
450 key1.ToDebugString());
451
452 NetworkIsolationKey key2(origin_data,
453 url::Origin::Create(GURL("http://a.test")));
454 EXPECT_TRUE(key2.IsFullyPopulated());
455 EXPECT_TRUE(key2.IsTransient());
456 EXPECT_EQ("", key2.ToString());
457 EXPECT_EQ(origin_data.GetDebugString() + " http://a.test",
458 key2.ToDebugString());
459 EXPECT_NE(
460 origin_data.DeriveNewOpaqueOrigin().GetDebugString() + " http://a.test",
461 key2.ToDebugString());
462}
463
Yao Xiao6924a36a2019-07-12 16:55:19[diff] [blame]464TEST_F(NetworkIsolationKeyWithFrameOriginTest, OpaqueOriginKeyBoth) {
Eric Robinsonfc7de102019-06-21 15:27:10[diff] [blame]465 url::Origin origin_data_1 =
466 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
467 url::Origin origin_data_2 =
468 url::Origin::Create(GURL("data:text/html,<body>Hello Universe</body>"));
469 url::Origin origin_data_3 =
470 url::Origin::Create(GURL("data:text/html,<body>Hello Cosmos</body>"));
471
472 NetworkIsolationKey key1(origin_data_1, origin_data_2);
473 NetworkIsolationKey key2(origin_data_1, origin_data_2);
474 NetworkIsolationKey key3(origin_data_1, origin_data_3);
475
476 // All the keys should be fully populated and transient.
477 EXPECT_TRUE(key1.IsFullyPopulated());
478 EXPECT_TRUE(key2.IsFullyPopulated());
479 EXPECT_TRUE(key3.IsFullyPopulated());
480 EXPECT_TRUE(key1.IsTransient());
481 EXPECT_TRUE(key2.IsTransient());
482 EXPECT_TRUE(key3.IsTransient());
483
484 // Test the equality/comparisons of the various keys
485 EXPECT_TRUE(key1 == key2);
486 EXPECT_FALSE(key1 == key3);
487 EXPECT_FALSE(key1 < key2 || key2 < key1);
488 EXPECT_TRUE(key1 < key3 || key3 < key1);
489
490 // Test the ToString and ToDebugString
491 EXPECT_EQ(key1.ToDebugString(), key2.ToDebugString());
492 EXPECT_NE(key1.ToDebugString(), key3.ToDebugString());
493 EXPECT_EQ("", key1.ToString());
494 EXPECT_EQ("", key2.ToString());
495 EXPECT_EQ("", key3.ToString());
496}
497
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]498TEST_F(NetworkIsolationKeyWithFrameOriginTest, UseRegistrableDomain) {
499 base::test::ScopedFeatureList feature_list;
500 feature_list.InitWithFeatures(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]501 {features::kAppendFrameOriginToNetworkIsolationKey,
502 features::kUseRegistrableDomainInNetworkIsolationKey},
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]503 {});
504
505 // Both origins are non-opaque.
506 url::Origin origin_a = url::Origin::Create(GURL("http://a.foo.test:80"));
507 url::Origin origin_b = url::Origin::Create(GURL("https://b.foo.test:2395"));
508
509 // Resultant NIK should have the same schemes as the initial origins and
510 // default port.
511 url::Origin expected_domain_a = url::Origin::Create(GURL("http://foo.test"));
512 url::Origin expected_domain_b = url::Origin::Create(GURL("https://foo.test"));
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]513 NetworkIsolationKey key(origin_a, origin_b);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]514 EXPECT_EQ(origin_a, key.GetTopFrameOrigin().value());
515 EXPECT_EQ(origin_b, key.GetFrameOrigin().value());
516 EXPECT_EQ(expected_domain_a.Serialize() + " " + expected_domain_b.Serialize(),
517 key.ToString());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]518
519 // Top frame origin is opaque but not the frame origin.
520 url::Origin origin_data =
521 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
522 key = NetworkIsolationKey(origin_data, origin_b);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]523 EXPECT_TRUE(key.top_frame_origin_->opaque());
524 EXPECT_TRUE(key.ToString().empty());
525 EXPECT_EQ(origin_data, key.top_frame_origin_.value());
526 EXPECT_EQ(expected_domain_b, key.frame_origin_.value());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]527
528 // Top frame origin is non-opaque but frame origin is opaque.
529 key = NetworkIsolationKey(origin_a, origin_data);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]530 EXPECT_EQ(expected_domain_a, key.top_frame_origin_.value());
531 EXPECT_TRUE(key.ToString().empty());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]532 EXPECT_EQ(origin_data, key.GetFrameOrigin().value());
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]533 EXPECT_TRUE(key.frame_origin_->opaque());
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]534
535 // Empty NIK stays empty.
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]536 NetworkIsolationKey empty_key;
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]537 EXPECT_TRUE(key.ToString().empty());
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]538
539 // IPv4 and IPv6 origins should not be modified, except for removing their
540 // ports.
541 url::Origin origin_ipv4 = url::Origin::Create(GURL("http://127.0.0.1:1234"));
542 url::Origin origin_ipv6 = url::Origin::Create(GURL("https://[::1]"));
543 key = NetworkIsolationKey(origin_ipv4, origin_ipv6);
544 EXPECT_EQ(url::Origin::Create(GURL("http://127.0.0.1")),
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]545 key.top_frame_origin_.value());
546 EXPECT_EQ(origin_ipv6, key.frame_origin_.value());
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]547
548 // Nor should TLDs, recognized or not.
549 url::Origin origin_tld = url::Origin::Create(GURL("http://com"));
550 url::Origin origin_tld_unknown =
551 url::Origin::Create(GURL("https://bar:1234"));
552 key = NetworkIsolationKey(origin_tld, origin_tld_unknown);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]553 EXPECT_EQ(origin_tld, key.top_frame_origin_.value());
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]554 EXPECT_EQ(url::Origin::Create(GURL("https://bar")),
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]555 key.frame_origin_.value());
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]556
557 // Check for two-part TLDs.
558 url::Origin origin_two_part_tld = url::Origin::Create(GURL("http://co.uk"));
559 url::Origin origin_two_part_tld_with_prefix =
560 url::Origin::Create(GURL("https://a.b.co.uk"));
561 key =
562 NetworkIsolationKey(origin_two_part_tld, origin_two_part_tld_with_prefix);
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]563 EXPECT_EQ(origin_two_part_tld, key.top_frame_origin_.value());
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]564 EXPECT_EQ(url::Origin::Create(GURL("https://b.co.uk")),
Shivani Sharma4ee2c2c2019-12-17 17:53:38[diff] [blame]565 key.frame_origin_.value());
566
567 // Two keys with different origins but same etld+1.
568 // Also test the getter APIs.
569 url::Origin origin_a_foo = url::Origin::Create(GURL("http://a.foo.com"));
570 url::Origin foo = url::Origin::Create(GURL("http://foo.com"));
571 url::Origin origin_b_foo = url::Origin::Create(GURL("http://b.foo.com"));
572 NetworkIsolationKey key1 = NetworkIsolationKey(origin_a_foo, origin_a_foo);
573 NetworkIsolationKey key2 = NetworkIsolationKey(origin_b_foo, origin_b_foo);
574 EXPECT_EQ(key1, key2);
575 EXPECT_EQ(foo.Serialize() + " " + foo.Serialize(), key1.ToString());
576 EXPECT_EQ(foo.Serialize() + " " + foo.Serialize(), key2.ToString());
577 EXPECT_EQ(origin_a_foo, key1.GetTopFrameOrigin());
578 EXPECT_EQ(origin_a_foo, key1.GetFrameOrigin());
579 EXPECT_EQ(origin_b_foo, key2.GetTopFrameOrigin());
580 EXPECT_EQ(origin_b_foo, key2.GetFrameOrigin());
581
582 // Copying one key to another should also copy the original origins.
583 url::Origin origin_bar = url::Origin::Create(GURL("http://a.bar.com"));
584 NetworkIsolationKey key_bar = NetworkIsolationKey(origin_bar, origin_bar);
585 NetworkIsolationKey key_copied = key_bar;
586 EXPECT_EQ(key_copied.GetTopFrameOrigin(), key_bar.GetTopFrameOrigin());
587 EXPECT_EQ(key_copied.GetFrameOrigin(), key_bar.GetFrameOrigin());
588 EXPECT_EQ(key_copied, key_bar);
Shivani Sharma53b39d4c2019-11-14 11:38:41[diff] [blame]589}
590
Matt Menked5a68262019-12-18 16:01:54[diff] [blame]591// Make sure that kUseRegistrableDomainInNetworkIsolationKey does not affect the
592// host when using a non-standard scheme.
593TEST(NetworkIsolationKeyTest, UseRegistrableDomainWithNonStandardScheme) {
594 base::test::ScopedFeatureList feature_list;
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]595 feature_list.InitWithFeatures(
596 // enabled_features
597 {features::kUseRegistrableDomainInNetworkIsolationKey},
598 // disabled_features
599 {features::kAppendFrameOriginToNetworkIsolationKey});
Matt Menked5a68262019-12-18 16:01:54[diff] [blame]600
601 // Have to register the scheme, or url::Origin::Create() will return an opaque
602 // origin.
Michael Thiessen2add7d442020-02-05 13:49:38[diff] [blame]603 url::ScopedSchemeRegistryForTests scoped_registry;
Matt Menked5a68262019-12-18 16:01:54[diff] [blame]604 url::AddStandardScheme("foo", url::SCHEME_WITH_HOST);
605
606 url::Origin origin = url::Origin::Create(GURL("foo://a.foo.com"));
607 ASSERT_FALSE(origin.opaque());
608 ASSERT_EQ(origin.scheme(), "foo");
609 ASSERT_EQ(origin.host(), "a.foo.com");
610
611 net::NetworkIsolationKey key(origin, origin);
612 EXPECT_EQ(origin, key.GetTopFrameOrigin());
613 EXPECT_FALSE(key.GetTopFrameOrigin()->opaque());
614 EXPECT_EQ(key.GetTopFrameOrigin()->scheme(), "foo");
615 EXPECT_EQ(key.GetTopFrameOrigin()->host(), "a.foo.com");
616 EXPECT_EQ(origin.Serialize(), key.ToString());
617}
618
Shivani Sharma38b74f52019-12-05 20:16:23[diff] [blame]619TEST_F(NetworkIsolationKeyWithFrameOriginTest, CreateWithNewFrameOrigin) {
620 url::Origin origin_a = url::Origin::Create(GURL("http://a.com"));
621 url::Origin origin_b = url::Origin::Create(GURL("http://b.com"));
622 url::Origin origin_c = url::Origin::Create(GURL("http://c.com"));
623
624 net::NetworkIsolationKey key(origin_a, origin_b);
625 NetworkIsolationKey key_c = key.CreateWithNewFrameOrigin(origin_c);
626 EXPECT_EQ(origin_c, key_c.GetFrameOrigin());
627 EXPECT_EQ(origin_a, key_c.GetTopFrameOrigin());
628}
629
Matt Menkef146103d2019-11-19 18:21:27[diff] [blame]630TEST(NetworkIsolationKeyTest, CreateTransient) {
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]631 for (bool use_frame_origins : {true, false}) {
632 SCOPED_TRACE(use_frame_origins);
Matt Menkef146103d2019-11-19 18:21:27[diff] [blame]633 base::test::ScopedFeatureList feature_list;
Matt Menkef9c21ff2020-03-04 19:06:46[diff] [blame]634 if (use_frame_origins) {
Matt Menkef146103d2019-11-19 18:21:27[diff] [blame]635 feature_list.InitAndEnableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]636 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menkef146103d2019-11-19 18:21:27[diff] [blame]637 } else {
638 feature_list.InitAndDisableFeature(
Matt Menke4f5cce92019-12-04 19:23:36[diff] [blame]639 features::kAppendFrameOriginToNetworkIsolationKey);
Matt Menkef146103d2019-11-19 18:21:27[diff] [blame]640 }
641
642 NetworkIsolationKey transient_key = NetworkIsolationKey::CreateTransient();
643 EXPECT_TRUE(transient_key.IsFullyPopulated());
644 EXPECT_TRUE(transient_key.IsTransient());
645 EXPECT_FALSE(transient_key.IsEmpty());
646 EXPECT_EQ(transient_key, transient_key);
647
648 // Transient values can't be saved to disk.
649 base::Value value;
650 EXPECT_FALSE(transient_key.ToValue(&value));
651
652 // Make sure that subsequent calls don't return the same NIK.
653 for (int i = 0; i < 1000; ++i) {
654 EXPECT_NE(transient_key, NetworkIsolationKey::CreateTransient());
655 }
656 }
657}
658
Shivani Sharmad81bdd42019-05-23 17:19:56[diff] [blame]659} // namespace net