| // 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 "content/browser/browsing_data/clear_site_data_handler.h" |
| |
| #include <optional> |
| |
| #include "base/containers/contains.h" |
| #include "base/functional/bind.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "content/browser/buckets/bucket_utils.h" |
| #include "content/public/browser/browser_context.h" |
| #include "content/public/browser/storage_partition_config.h" |
| #include "content/public/browser/web_contents.h" |
| #include "net/base/load_flags.h" |
| #include "net/url_request/clear_site_data.h" |
| #include "services/network/public/cpp/is_potentially_trustworthy.h" |
| #include "third_party/blink/public/common/features.h" |
| #include "third_party/blink/public/common/features_generated.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| // Pretty-printed log output. |
| const char kConsoleMessageTemplate[] = "Clear-Site-Data header on '%s': %s"; |
| const char kConsoleMessageCleared[] = "Cleared data types: %s."; |
| const char kConsoleMessageDatatypeSeparator[] = ", "; |
| |
| enum LoggableEventMask { |
| CLEAR_SITE_DATA_NO_RECOGNIZABLE_TYPES = 0, |
| CLEAR_SITE_DATA_COOKIES = 1 << 0, |
| CLEAR_SITE_DATA_STORAGE = 1 << 1, |
| CLEAR_SITE_DATA_CACHE = 1 << 2, |
| CLEAR_SITE_DATA_BUCKETS = 1 << 3, |
| CLEAR_SITE_DATA_CLIENT_HINTS = 1 << 4, |
| CLEAR_SITE_DATA_PREFETCH_CACHE = 1 << 5, |
| CLEAR_SITE_DATA_PRERENDER_CACHE = 1 << 6, |
| CLEAR_SITE_DATA_MAX_VALUE = 1 << 7, |
| }; |
| |
| void LogEvent(int event) { |
| UMA_HISTOGRAM_ENUMERATION("Storage.ClearSiteDataHeader.Parameters", event, |
| static_cast<int>(CLEAR_SITE_DATA_MAX_VALUE)); |
| } |
| |
| // Represents the parameters as a single number to be recorded in a histogram. |
| int ParametersMask(const ClearSiteDataTypeSet clear_site_data_types, |
| bool has_buckets) { |
| int mask = CLEAR_SITE_DATA_NO_RECOGNIZABLE_TYPES; |
| if (clear_site_data_types.Has(ClearSiteDataType::kCookies)) { |
| mask = mask | CLEAR_SITE_DATA_COOKIES; |
| } |
| if (clear_site_data_types.Has(ClearSiteDataType::kStorage)) { |
| mask = mask | CLEAR_SITE_DATA_STORAGE; |
| } |
| if (clear_site_data_types.Has(ClearSiteDataType::kCache)) { |
| mask = mask | CLEAR_SITE_DATA_CACHE; |
| } |
| if (has_buckets) { |
| mask = mask | CLEAR_SITE_DATA_BUCKETS; |
| } |
| if (clear_site_data_types.Has(ClearSiteDataType::kClientHints)) { |
| mask = mask | CLEAR_SITE_DATA_CLIENT_HINTS; |
| } |
| if (clear_site_data_types.Has(ClearSiteDataType::kPrefetchCache)) { |
| mask = mask | CLEAR_SITE_DATA_PREFETCH_CACHE; |
| } |
| if (clear_site_data_types.Has(ClearSiteDataType::kPrerenderCache)) { |
| mask = mask | CLEAR_SITE_DATA_PRERENDER_CACHE; |
| } |
| return mask; |
| } |
| |
| // Outputs a single |formatted_message| on the UI thread. |
| void OutputFormattedMessage(WebContents* web_contents, |
| blink::mojom::ConsoleMessageLevel level, |
| const std::string& formatted_text) { |
| if (web_contents) |
| web_contents->GetPrimaryMainFrame()->AddMessageToConsole(level, |
| formatted_text); |
| } |
| |
| } // namespace |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // ConsoleMessagesDelegate |
| |
| ClearSiteDataHandler::ConsoleMessagesDelegate::ConsoleMessagesDelegate() |
| : output_formatted_message_function_( |
| base::BindRepeating(&OutputFormattedMessage)) {} |
| |
| ClearSiteDataHandler::ConsoleMessagesDelegate::~ConsoleMessagesDelegate() {} |
| |
| void ClearSiteDataHandler::ConsoleMessagesDelegate::AddMessage( |
| const GURL& url, |
| const std::string& text, |
| blink::mojom::ConsoleMessageLevel level) { |
| messages_.push_back({url, text, level}); |
| } |
| |
| void ClearSiteDataHandler::ConsoleMessagesDelegate::OutputMessages( |
| base::WeakPtr<WebContents> web_contents) { |
| if (messages_.empty()) |
| return; |
| |
| for (const auto& message : messages_) { |
| // Prefix each message with |kConsoleMessageTemplate|. |
| output_formatted_message_function_.Run( |
| web_contents.get(), message.level, |
| base::StringPrintf(kConsoleMessageTemplate, message.url.spec().c_str(), |
| message.text.c_str())); |
| } |
| |
| messages_.clear(); |
| } |
| |
| void ClearSiteDataHandler::ConsoleMessagesDelegate:: |
| SetOutputFormattedMessageFunctionForTesting( |
| const OutputFormattedMessageFunction& function) { |
| output_formatted_message_function_ = function; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // ClearSiteDataHandler |
| |
| // static |
| void ClearSiteDataHandler::HandleHeader( |
| base::WeakPtr<BrowserContext> browser_context, |
| base::WeakPtr<WebContents> web_contents, |
| const StoragePartitionConfig& storage_partition_config, |
| const GURL& url, |
| const std::string& header_value, |
| int load_flags, |
| const std::optional<net::CookiePartitionKey> cookie_partition_key, |
| const std::optional<blink::StorageKey> storage_key, |
| bool partitioned_state_allowed_only, |
| base::OnceClosure callback) { |
| ClearSiteDataHandler handler( |
| browser_context, web_contents, storage_partition_config, url, |
| header_value, load_flags, cookie_partition_key, storage_key, |
| partitioned_state_allowed_only, std::move(callback), |
| std::make_unique<ConsoleMessagesDelegate>()); |
| handler.HandleHeaderAndOutputConsoleMessages(); |
| } |
| |
| // static |
| bool ClearSiteDataHandler::ParseHeaderForTesting( |
| const std::string& header, |
| ClearSiteDataTypeSet* clear_site_data_types, |
| std::set<std::string>* storage_buckets_to_remove, |
| ConsoleMessagesDelegate* delegate, |
| const GURL& current_url) { |
| return ClearSiteDataHandler::ParseHeader(header, clear_site_data_types, |
| storage_buckets_to_remove, delegate, |
| current_url); |
| } |
| |
| ClearSiteDataHandler::ClearSiteDataHandler( |
| base::WeakPtr<BrowserContext> browser_context, |
| base::WeakPtr<WebContents> web_contents, |
| const StoragePartitionConfig& storage_partition_config, |
| const GURL& url, |
| const std::string& header_value, |
| int load_flags, |
| const std::optional<net::CookiePartitionKey> cookie_partition_key, |
| const std::optional<blink::StorageKey> storage_key, |
| bool partitioned_state_allowed_only, |
| base::OnceClosure callback, |
| std::unique_ptr<ConsoleMessagesDelegate> delegate) |
| : browser_context_(browser_context), |
| web_contents_(web_contents), |
| storage_partition_config_(storage_partition_config), |
| url_(url), |
| header_value_(header_value), |
| load_flags_(load_flags), |
| cookie_partition_key_(cookie_partition_key), |
| storage_key_(storage_key), |
| partitioned_state_allowed_only_(partitioned_state_allowed_only), |
| callback_(std::move(callback)), |
| delegate_(std::move(delegate)) { |
| DCHECK(delegate_); |
| } |
| |
| ClearSiteDataHandler::~ClearSiteDataHandler() = default; |
| |
| bool ClearSiteDataHandler::HandleHeaderAndOutputConsoleMessages() { |
| bool deferred = Run(); |
| |
| // If the redirect is deferred, wait until it is resumed. |
| // TODO(crbug.com/41409604): Delay output until next frame for navigations. |
| if (!deferred) { |
| OutputConsoleMessages(); |
| RunCallbackNotDeferred(); |
| } |
| |
| return deferred; |
| } |
| |
| bool ClearSiteDataHandler::Run() { |
| // Only accept the header on secure non-unique origins. |
| if (!network::IsUrlPotentiallyTrustworthy(url_)) { |
| delegate_->AddMessage(url_, "Not supported for insecure origins.", |
| blink::mojom::ConsoleMessageLevel::kError); |
| return false; |
| } |
| |
| url::Origin origin = url::Origin::Create(url_); |
| if (origin.opaque()) { |
| delegate_->AddMessage(url_, "Not supported for unique origins.", |
| blink::mojom::ConsoleMessageLevel::kError); |
| return false; |
| } |
| |
| // The LOAD_DO_NOT_SAVE_COOKIES flag prohibits the request from doing any |
| // modification to cookies. Clear-Site-Data applies this restriction to other |
| // data types as well. |
| // TODO(msramek): Consider showing a blocked icon via |
| // PageSpecificContentSettings and reporting the action in the "Blocked" |
| // section of the cookies dialog in OIB. |
| if (load_flags_ & net::LOAD_DO_NOT_SAVE_COOKIES) { |
| delegate_->AddMessage( |
| url_, |
| "The request's credentials mode prohibits modifying cookies " |
| "and other local data.", |
| blink::mojom::ConsoleMessageLevel::kError); |
| return false; |
| } |
| |
| ClearSiteDataTypeSet clear_site_data_types; |
| std::set<std::string> storage_buckets_to_remove; |
| |
| if (!ClearSiteDataHandler::ParseHeader(header_value_, &clear_site_data_types, |
| &storage_buckets_to_remove, |
| delegate_.get(), url_)) { |
| return false; |
| } |
| |
| ExecuteClearingTask( |
| origin, clear_site_data_types, storage_buckets_to_remove, |
| base::BindOnce(&ClearSiteDataHandler::TaskFinished, |
| base::TimeTicks::Now(), std::move(delegate_), |
| web_contents_, std::move(callback_))); |
| |
| return true; |
| } |
| |
| // static |
| bool ClearSiteDataHandler::ParseHeader( |
| const std::string& header, |
| ClearSiteDataTypeSet* clear_site_data_types, |
| std::set<std::string>* storage_buckets_to_remove, |
| ConsoleMessagesDelegate* delegate, |
| const GURL& current_url) { |
| DCHECK(clear_site_data_types); |
| DCHECK(storage_buckets_to_remove); |
| DCHECK(delegate); |
| |
| if (!base::IsStringASCII(header)) { |
| delegate->AddMessage(current_url, "Must only contain ASCII characters.", |
| blink::mojom::ConsoleMessageLevel::kWarning); |
| LogEvent(CLEAR_SITE_DATA_NO_RECOGNIZABLE_TYPES); |
| return false; |
| } |
| |
| clear_site_data_types->Clear(); |
| |
| std::vector<std::string> input_types = |
| net::ClearSiteDataHeaderContents(header); |
| std::string output_types; |
| |
| if (base::Contains(input_types, net::kDatatypeWildcard)) { |
| input_types.push_back(net::kDatatypeCookies); |
| input_types.push_back(net::kDatatypeStorage); |
| input_types.push_back(net::kDatatypeCache); |
| input_types.push_back(net::kDatatypeClientHints); |
| } |
| |
| for (auto& input_type : input_types) { |
| // Match here if the beginning is '"storage:' and ends with '"'. |
| if (base::FeatureList::IsEnabled(blink::features::kStorageBuckets) && |
| base::StartsWith(input_type, net::kDatatypeStorageBucketPrefix) && |
| base::EndsWith(input_type, net::kDatatypeStorageBucketSuffix)) { |
| const int prefix_len = strlen(net::kDatatypeStorageBucketPrefix); |
| |
| const std::string bucket_name = input_type.substr( |
| prefix_len, |
| input_type.length() - |
| (prefix_len + strlen(net::kDatatypeStorageBucketSuffix))); |
| |
| if (IsValidBucketName(bucket_name)) |
| storage_buckets_to_remove->insert(bucket_name); |
| |
| // Exit the loop and continue since for buckets, there are no booleans |
| // and the logic later would cause a crash. |
| continue; |
| } |
| |
| ClearSiteDataType data_type = ClearSiteDataType::kUndefined; |
| if (input_type == net::kDatatypeCookies) { |
| data_type = ClearSiteDataType::kCookies; |
| } else if (input_type == net::kDatatypeStorage) { |
| data_type = ClearSiteDataType::kStorage; |
| } else if (input_type == net::kDatatypeCache) { |
| data_type = ClearSiteDataType::kCache; |
| } else if (input_type == net::kDatatypeClientHints) { |
| data_type = ClearSiteDataType::kClientHints; |
| } else if (input_type == net::kDatatypePrefetchCache) { |
| data_type = ClearSiteDataType::kPrefetchCache; |
| } else if (input_type == net::kDatatypePrerenderCache) { |
| data_type = ClearSiteDataType::kPrerenderCache; |
| } else if (input_type == net::kDatatypeWildcard) { |
| continue; |
| } else { |
| delegate->AddMessage( |
| current_url, |
| base::StringPrintf("Unrecognized type: %s.", input_type.c_str()), |
| blink::mojom::ConsoleMessageLevel::kWarning); |
| continue; |
| } |
| |
| if (!base::FeatureList::IsEnabled( |
| blink::features::kClearSiteDataPrefetchPrerenderCache)) { |
| if (data_type == ClearSiteDataType::kPrefetchCache || |
| data_type == ClearSiteDataType::kPrerenderCache) { |
| delegate->AddMessage( |
| current_url, |
| base::StringPrintf( |
| "prefetchCache and prerenderCache not enabled: %s.", |
| input_type.c_str()), |
| blink::mojom::ConsoleMessageLevel::kWarning); |
| continue; |
| } |
| } |
| |
| DCHECK_NE(data_type, ClearSiteDataType::kUndefined); |
| |
| if (clear_site_data_types->Has(data_type)) { |
| continue; |
| } |
| |
| clear_site_data_types->Put(data_type); |
| if (!output_types.empty()) |
| output_types += kConsoleMessageDatatypeSeparator; |
| output_types += input_type; |
| } |
| |
| if (clear_site_data_types->empty() && storage_buckets_to_remove->empty()) { |
| delegate->AddMessage(current_url, "No recognized types specified.", |
| blink::mojom::ConsoleMessageLevel::kWarning); |
| LogEvent(CLEAR_SITE_DATA_NO_RECOGNIZABLE_TYPES); |
| return false; |
| } |
| |
| if (clear_site_data_types->Has(ClearSiteDataType::kStorage) && |
| !storage_buckets_to_remove->empty()) { |
| // `clear_storage` and `clear_storage_buckets` cannot both be true. When |
| // that happens, `clear_storage` stays true and we empty `storage_buckets |
| // _to_remove` |
| delegate->AddMessage(current_url, |
| "All the buckets related to this url will be " |
| "cleared. When passing type 'storage', any " |
| "additional buckets specifiers are ignored.", |
| blink::mojom::ConsoleMessageLevel::kWarning); |
| storage_buckets_to_remove->clear(); |
| } |
| |
| // Pretty-print which types are to be cleared. |
| // TODO(crbug.com/41363015): Remove the disclaimer about cookies. |
| std::string console_output = |
| base::StringPrintf(kConsoleMessageCleared, output_types.c_str()); |
| if (clear_site_data_types->Has(ClearSiteDataType::kCookies)) { |
| console_output += |
| " Clearing channel IDs and HTTP authentication cache is currently not" |
| " supported, as it breaks active network connections."; |
| } |
| delegate->AddMessage(current_url, console_output, |
| blink::mojom::ConsoleMessageLevel::kInfo); |
| |
| // Note that presence of headers is also logged in WebRequest.ResponseHeader |
| LogEvent(ParametersMask(*clear_site_data_types, |
| !storage_buckets_to_remove->empty())); |
| |
| return true; |
| } |
| |
| void ClearSiteDataHandler::ExecuteClearingTask( |
| const url::Origin& origin, |
| const ClearSiteDataTypeSet clear_site_data_types, |
| const std::set<std::string>& storage_buckets_to_remove, |
| base::OnceClosure callback) { |
| ClearSiteData(browser_context_, storage_partition_config_, origin, |
| clear_site_data_types, storage_buckets_to_remove, |
| /*avoid_closing_connections=*/true, cookie_partition_key_, |
| storage_key_, partitioned_state_allowed_only_, |
| std::move(callback)); |
| } |
| |
| // static |
| void ClearSiteDataHandler::TaskFinished( |
| base::TimeTicks clearing_started, |
| std::unique_ptr<ConsoleMessagesDelegate> delegate, |
| base::WeakPtr<WebContents> web_contents, |
| base::OnceClosure callback) { |
| DCHECK(!clearing_started.is_null()); |
| |
| // TODO(crbug.com/41409604): Delay output until next frame for navigations. |
| delegate->OutputMessages(web_contents); |
| |
| std::move(callback).Run(); |
| } |
| |
| void ClearSiteDataHandler::OutputConsoleMessages() { |
| delegate_->OutputMessages(web_contents_); |
| } |
| |
| void ClearSiteDataHandler::RunCallbackNotDeferred() { |
| std::move(callback_).Run(); |
| } |
| |
| } // namespace content |
