649 lines
28 KiB
C++
649 lines
28 KiB
C++
// Copyright 2018 The Chromium Authors
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "net/cookies/cookie_deletion_info.h"
|
|
|
|
#include "base/test/scoped_feature_list.h"
|
|
#include "net/base/features.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "url/gurl.h"
|
|
|
|
namespace net {
|
|
|
|
using TimeRange = CookieDeletionInfo::TimeRange;
|
|
|
|
TEST(CookieDeletionInfoTest, TimeRangeValues) {
|
|
TimeRange range;
|
|
EXPECT_EQ(base::Time(), range.start());
|
|
EXPECT_EQ(base::Time(), range.end());
|
|
|
|
const base::Time kTestStart = base::Time::FromDoubleT(1000);
|
|
const base::Time kTestEnd = base::Time::FromDoubleT(10000);
|
|
|
|
EXPECT_EQ(kTestStart, TimeRange(kTestStart, base::Time()).start());
|
|
EXPECT_EQ(base::Time(), TimeRange(kTestStart, base::Time()).end());
|
|
|
|
EXPECT_EQ(kTestStart, TimeRange(kTestStart, kTestEnd).start());
|
|
EXPECT_EQ(kTestEnd, TimeRange(kTestStart, kTestEnd).end());
|
|
|
|
TimeRange range2;
|
|
range2.SetStart(kTestStart);
|
|
EXPECT_EQ(kTestStart, range2.start());
|
|
EXPECT_EQ(base::Time(), range2.end());
|
|
range2.SetEnd(kTestEnd);
|
|
EXPECT_EQ(kTestStart, range2.start());
|
|
EXPECT_EQ(kTestEnd, range2.end());
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, TimeRangeContains) {
|
|
// Default TimeRange matches all time values.
|
|
TimeRange range;
|
|
EXPECT_TRUE(range.Contains(base::Time::Now()));
|
|
EXPECT_TRUE(range.Contains(base::Time::Max()));
|
|
|
|
// With a start, but no end.
|
|
const double kTestMinEpoch = 1000;
|
|
range.SetStart(base::Time::FromDoubleT(kTestMinEpoch));
|
|
EXPECT_FALSE(range.Contains(base::Time::Min()));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch - 1)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch + 1)));
|
|
EXPECT_TRUE(range.Contains(base::Time::Max()));
|
|
|
|
// With an end, but no start.
|
|
const double kTestMaxEpoch = 10000000;
|
|
range = TimeRange();
|
|
range.SetEnd(base::Time::FromDoubleT(kTestMaxEpoch));
|
|
EXPECT_TRUE(range.Contains(base::Time::Min()));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch - 1)));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch)));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch + 1)));
|
|
EXPECT_FALSE(range.Contains(base::Time::Max()));
|
|
|
|
// With both a start and an end.
|
|
range.SetStart(base::Time::FromDoubleT(kTestMinEpoch));
|
|
EXPECT_FALSE(range.Contains(base::Time::Min()));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch - 1)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch + 1)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch - 1)));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch)));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMaxEpoch + 1)));
|
|
EXPECT_FALSE(range.Contains(base::Time::Max()));
|
|
|
|
// And where start==end.
|
|
range = TimeRange(base::Time::FromDoubleT(kTestMinEpoch),
|
|
base::Time::FromDoubleT(kTestMinEpoch));
|
|
EXPECT_FALSE(range.Contains(base::Time::Min()));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch - 1)));
|
|
EXPECT_TRUE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch)));
|
|
EXPECT_FALSE(range.Contains(base::Time::FromDoubleT(kTestMinEpoch + 1)));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchSessionControl) {
|
|
auto persistent_cookie = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"persistent-cookie", "persistent-value", "persistent-domain",
|
|
"persistent-path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
auto session_cookie = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"session-cookie", "session-value", "session-domain", "session-path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
CookieDeletionInfo delete_info;
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*persistent_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*session_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.session_control =
|
|
CookieDeletionInfo::SessionControl::PERSISTENT_COOKIES;
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*persistent_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*session_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.session_control =
|
|
CookieDeletionInfo::SessionControl::SESSION_COOKIES;
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*persistent_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*session_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchHost) {
|
|
auto domain_cookie = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"domain-cookie", "domain-cookie-value",
|
|
/*domain=*/".example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
auto host_cookie = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"host-cookie", "host-cookie-value",
|
|
/*domain=*/"thehost.hosting.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
EXPECT_TRUE(domain_cookie->IsDomainCookie());
|
|
EXPECT_TRUE(host_cookie->IsHostCookie());
|
|
|
|
CookieDeletionInfo delete_info;
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*domain_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*host_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.host = "thehost.hosting.com";
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*domain_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*host_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.host = "otherhost.hosting.com";
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*domain_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*host_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.host = "thehost.otherhosting.com";
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*domain_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*host_cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchName) {
|
|
auto cookie1 = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"cookie1-name", "cookie1-value",
|
|
/*domain=*/".example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
auto cookie2 = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"cookie2-name", "cookie2-value",
|
|
/*domain=*/".example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.name = "cookie1-name";
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie1,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*cookie2,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchValue) {
|
|
auto cookie1 = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"cookie1-name", "cookie1-value",
|
|
/*domain=*/".example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
auto cookie2 = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"cookie2-name", "cookie2-value",
|
|
/*domain=*/".example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.value_for_testing = "cookie2-value";
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*cookie1,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie2,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchUrl) {
|
|
auto cookie = CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
"cookie-name", "cookie-value",
|
|
/*domain=*/"www.example.com", "/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false, CookieSameSite::NO_RESTRICTION,
|
|
CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.url = GURL("https://www.example.com/path");
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.url = GURL("https://www.example.com/another/path");
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
delete_info.url = GURL("http://www.example.com/path");
|
|
// Secure cookie on http:// URL -> no match.
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
// Secure cookie on http:// URL, but delegate says treat is as trustworhy ->
|
|
// match.
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/true,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoDomainMatchesDomain) {
|
|
CookieDeletionInfo delete_info;
|
|
|
|
const double kTestMinEpoch = 1000;
|
|
const double kTestMaxEpoch = 10000000;
|
|
delete_info.creation_range.SetStart(base::Time::FromDoubleT(kTestMinEpoch));
|
|
delete_info.creation_range.SetEnd(base::Time::FromDoubleT(kTestMaxEpoch));
|
|
|
|
auto create_cookie = [kTestMinEpoch](std::string cookie_domain) {
|
|
return *CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
/*name=*/"test-cookie",
|
|
/*value=*/"cookie-value", cookie_domain,
|
|
/*path=*/"cookie/path",
|
|
/*creation=*/base::Time::FromDoubleT(kTestMinEpoch + 1),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::FromDoubleT(kTestMinEpoch + 1),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/true,
|
|
/*httponly=*/false,
|
|
/*same_site=*/CookieSameSite::NO_RESTRICTION,
|
|
/*priority=*/CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
};
|
|
|
|
// by default empty domain list and default match action will match.
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("example.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
const char kExtensionHostname[] = "mgndgikekgjfcpckkfioiadnlibdjbkf";
|
|
|
|
// Only using the inclusion list because this is only testing
|
|
// DomainMatchesDomainSet and not CookieDeletionInfo::Matches.
|
|
delete_info.domains_and_ips_to_delete =
|
|
std::set<std::string>({"example.com", "another.com", "192.168.0.1"});
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie(".example.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("example.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie(".another.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("192.168.0.1"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie(".nomatch.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("192.168.0.2"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie(kExtensionHostname),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, CookieDeletionInfoMatchesDomainList) {
|
|
CookieDeletionInfo delete_info;
|
|
|
|
auto create_cookie = [](std::string cookie_domain) {
|
|
return *CanonicalCookie::CreateUnsafeCookieForTesting(
|
|
/*name=*/"test-cookie",
|
|
/*value=*/"cookie-value", cookie_domain,
|
|
/*path=*/"cookie/path",
|
|
/*creation=*/base::Time::Now(),
|
|
/*expiration=*/base::Time::Max(),
|
|
/*last_access=*/base::Time::Now(),
|
|
/*last_update=*/base::Time::Now(),
|
|
/*secure=*/false,
|
|
/*httponly=*/false,
|
|
/*same_site=*/CookieSameSite::NO_RESTRICTION,
|
|
/*priority=*/CookiePriority::COOKIE_PRIORITY_DEFAULT,
|
|
/*same_party=*/false);
|
|
};
|
|
|
|
// With two empty lists (default) should match any domain.
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("anything.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
// With only an "to_delete" list.
|
|
delete_info.domains_and_ips_to_delete =
|
|
std::set<std::string>({"includea.com", "includeb.com"});
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("includea.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("includeb.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("anything.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
// With only an "to_ignore" list.
|
|
delete_info.domains_and_ips_to_delete.clear();
|
|
delete_info.domains_and_ips_to_ignore.insert("exclude.com");
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("anything.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("exclude.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
|
|
// Now with both lists populated.
|
|
//
|
|
// +----------------------+
|
|
// | to_delete | outside.com
|
|
// | |
|
|
// | left.com +---------------------+
|
|
// | | mid.com | to_ignore |
|
|
// | | | |
|
|
// +------------|---------+ |
|
|
// | right.com |
|
|
// | |
|
|
// +---------------------+
|
|
delete_info.domains_and_ips_to_delete =
|
|
std::set<std::string>({"left.com", "mid.com"});
|
|
delete_info.domains_and_ips_to_ignore =
|
|
std::set<std::string>({"mid.com", "right.com"});
|
|
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
create_cookie("left.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("mid.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("right.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_FALSE(delete_info.Matches(
|
|
create_cookie("outside.com"),
|
|
CookieAccessParams{net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
// Test that Matches() works regardless of the cookie access semantics (because
|
|
// the IncludeForRequestURL call uses CookieOptions::MakeAllInclusive).
|
|
TEST(CookieDeletionInfoTest, MatchesWithCookieAccessSemantics) {
|
|
// Cookie with unspecified SameSite.
|
|
auto cookie = CanonicalCookie::Create(GURL("https://www.example.com"),
|
|
"cookie=1", base::Time::Now(),
|
|
/*server_time=*/absl::nullopt,
|
|
/*cookie_partition_key=*/absl::nullopt);
|
|
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.url = GURL("https://www.example.com/path");
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{CookieAccessSemantics::LEGACY,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
EXPECT_TRUE(delete_info.Matches(
|
|
*cookie,
|
|
CookieAccessParams{CookieAccessSemantics::NONLEGACY,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, MatchesCookiePartitionKeyCollection) {
|
|
const CookiePartitionKey kPartitionKey =
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://www.foo.com"));
|
|
const CookiePartitionKey kOtherPartitionKey =
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://www.bar.com"));
|
|
const CookiePartitionKeyCollection kEmptyKeychain;
|
|
const CookiePartitionKeyCollection kSingletonKeychain(kPartitionKey);
|
|
const CookiePartitionKeyCollection kMultipleKeysKeychain(
|
|
{kPartitionKey, kOtherPartitionKey});
|
|
const CookiePartitionKeyCollection kAllKeysKeychain =
|
|
CookiePartitionKeyCollection::ContainsAll();
|
|
const absl::optional<CookiePartitionKey> kPartitionKeyOpt =
|
|
absl::make_optional(kPartitionKey);
|
|
const CookiePartitionKeyCollection kOtherKeySingletonKeychain(
|
|
kOtherPartitionKey);
|
|
|
|
struct TestCase {
|
|
const std::string desc;
|
|
const CookiePartitionKeyCollection filter_cookie_partition_key_collection;
|
|
const absl::optional<CookiePartitionKey> cookie_partition_key;
|
|
bool expects_match;
|
|
} test_cases[] = {
|
|
// Unpartitioned cookie always matches
|
|
{"Unpartitioned empty keychain", kEmptyKeychain, absl::nullopt, true},
|
|
{"Unpartitioned singleton keychain", kSingletonKeychain, absl::nullopt,
|
|
true},
|
|
{"Unpartitioned multiple keys", kMultipleKeysKeychain, absl::nullopt,
|
|
true},
|
|
{"Unpartitioned all keys", kAllKeysKeychain, absl::nullopt, true},
|
|
// Partitioned cookie only matches keychains which contain its partition
|
|
// key.
|
|
{"Partitioned empty keychain", kEmptyKeychain, kPartitionKeyOpt, false},
|
|
{"Partitioned singleton keychain", kSingletonKeychain, kPartitionKeyOpt,
|
|
true},
|
|
{"Partitioned multiple keys", kMultipleKeysKeychain, kPartitionKeyOpt,
|
|
true},
|
|
{"Partitioned all keys", kAllKeysKeychain, kPartitionKeyOpt, true},
|
|
{"Partitioned mismatched keys", kOtherKeySingletonKeychain,
|
|
kPartitionKeyOpt, false},
|
|
};
|
|
|
|
for (const auto& test_case : test_cases) {
|
|
SCOPED_TRACE(test_case.desc);
|
|
auto cookie = CanonicalCookie::Create(
|
|
GURL("https://www.example.com"),
|
|
"__Host-foo=bar; Secure; Path=/; Partitioned", base::Time::Now(),
|
|
/*server_time=*/absl::nullopt, test_case.cookie_partition_key);
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.cookie_partition_key_collection =
|
|
test_case.filter_cookie_partition_key_collection;
|
|
EXPECT_EQ(
|
|
test_case.expects_match,
|
|
delete_info.Matches(
|
|
*cookie, CookieAccessParams{
|
|
net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
}
|
|
|
|
TEST(CookieDeletionInfoTest, MatchesExcludeUnpartitionedCookies) {
|
|
struct TestCase {
|
|
const std::string desc;
|
|
const absl::optional<CookiePartitionKey> cookie_partition_key;
|
|
bool partitioned_state_only;
|
|
bool expects_match;
|
|
} test_cases[] = {
|
|
{"Unpartitioned cookie not excluded", absl::nullopt, false, true},
|
|
{"Unpartitioned cookie excluded", absl::nullopt, true, false},
|
|
{"Partitioned cookie when unpartitioned not excluded",
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://foo.com")), false,
|
|
true},
|
|
{"Partitioned cookie when unpartitioned excluded",
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://foo.com")), true,
|
|
true},
|
|
{"Nonced partitioned cookie when unpartitioned not excluded",
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://foo.com"),
|
|
base::UnguessableToken::Create()),
|
|
false, true},
|
|
{"Nonced partitioned cookie when unpartitioned excluded",
|
|
CookiePartitionKey::FromURLForTesting(GURL("https://foo.com"),
|
|
base::UnguessableToken::Create()),
|
|
true, true},
|
|
};
|
|
|
|
for (const auto& test_case : test_cases) {
|
|
SCOPED_TRACE(test_case.desc);
|
|
auto cookie = CanonicalCookie::Create(
|
|
GURL("https://www.example.com"),
|
|
"__Host-foo=bar; Secure; Path=/; Partitioned", base::Time::Now(),
|
|
/*server_time=*/absl::nullopt, test_case.cookie_partition_key);
|
|
CookieDeletionInfo delete_info;
|
|
delete_info.partitioned_state_only = test_case.partitioned_state_only;
|
|
EXPECT_EQ(
|
|
test_case.expects_match,
|
|
delete_info.Matches(
|
|
*cookie, CookieAccessParams{
|
|
net::CookieAccessSemantics::UNKNOWN,
|
|
/*delegate_treats_url_as_trustworthy=*/false,
|
|
CookieSamePartyStatus::kNoSamePartyEnforcement}));
|
|
}
|
|
}
|
|
|
|
} // namespace net
|