| // Copyright 2020 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/attribution_reporting/attribution_internals_handler_impl.h" |
| |
| #include <stdint.h> |
| |
| #include <algorithm> |
| #include <iterator> |
| #include <optional> |
| #include <string> |
| #include <utility> |
| #include <variant> |
| #include <vector> |
| |
| #include "base/check.h" |
| #include "base/check_op.h" |
| #include "base/containers/flat_map.h" |
| #include "base/containers/to_vector.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/memory/raw_ref.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/notreached.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/time/time.h" |
| #include "base/values.h" |
| #include "components/attribution_reporting/aggregation_keys.h" |
| #include "components/attribution_reporting/os_registration.h" |
| #include "components/attribution_reporting/parsing_utils.h" |
| #include "components/attribution_reporting/source_registration.h" |
| #include "components/attribution_reporting/suitable_origin.h" |
| #include "components/attribution_reporting/trigger_config.h" |
| #include "components/attribution_reporting/trigger_registration.h" |
| #include "content/browser/attribution_reporting/aggregatable_debug_report.h" |
| #include "content/browser/attribution_reporting/aggregatable_named_budget_pair.h" |
| #include "content/browser/attribution_reporting/attribution_debug_report.h" |
| #include "content/browser/attribution_reporting/attribution_info.h" |
| #include "content/browser/attribution_reporting/attribution_internals.mojom.h" |
| #include "content/browser/attribution_reporting/attribution_manager.h" |
| #include "content/browser/attribution_reporting/attribution_report.h" |
| #include "content/browser/attribution_reporting/attribution_reporting.mojom-forward.h" |
| #include "content/browser/attribution_reporting/attribution_trigger.h" |
| #include "content/browser/attribution_reporting/attribution_utils.h" |
| #include "content/browser/attribution_reporting/common_source_info.h" |
| #include "content/browser/attribution_reporting/create_report_result.h" |
| #include "content/browser/attribution_reporting/os_registration.h" |
| #include "content/browser/attribution_reporting/send_result.h" |
| #include "content/browser/attribution_reporting/storable_source.h" |
| #include "content/browser/attribution_reporting/stored_source.h" |
| #include "content/browser/web_contents/web_contents_impl.h" |
| #include "content/public/browser/browser_context.h" |
| #include "content/public/browser/content_browser_client.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/browser/web_ui.h" |
| #include "content/public/common/content_client.h" |
| #include "net/base/net_errors.h" |
| #include "third_party/abseil-cpp/absl/functional/overload.h" |
| #include "third_party/abseil-cpp/absl/numeric/int128.h" |
| #include "url/gurl.h" |
| #include "url/origin.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| using Attributability = |
| ::attribution_internals::mojom::WebUISource::Attributability; |
| |
| using Empty = ::attribution_internals::mojom::Empty; |
| using ReportStatus = ::attribution_internals::mojom::ReportStatus; |
| using ReportStatusPtr = ::attribution_internals::mojom::ReportStatusPtr; |
| |
| using ::attribution_internals::mojom::WebUIAggregatableDebugReport; |
| using ::attribution_internals::mojom::WebUIDebugReport; |
| |
| std::string SerializeBudgetsMap( |
| const StoredSource::AggregatableNamedBudgets& map) { |
| base::Value::Dict dict; |
| for (const auto& [key, value] : map) { |
| base::Value::Dict inner_dict; |
| inner_dict.Set("original_budget", value.original_budget()); |
| inner_dict.Set("remaining_budget", value.remaining_budget()); |
| dict.Set(key, std::move(inner_dict)); |
| } |
| |
| return SerializeAttributionJson(dict, /*pretty_print=*/true); |
| } |
| |
| attribution_internals::mojom::WebUISourcePtr WebUISource( |
| const StoredSource& source, |
| Attributability attributability) { |
| const CommonSourceInfo& common_info = source.common_info(); |
| return attribution_internals::mojom::WebUISource::New( |
| *source.source_id(), source.source_event_id(), |
| common_info.source_origin(), source.destination_sites(), |
| common_info.reporting_origin(), |
| source.source_time().InMillisecondsFSinceUnixEpoch(), |
| source.expiry_time().InMillisecondsFSinceUnixEpoch(), |
| source.event_report_windows(), |
| base::ToVector(source.trigger_data().trigger_data()), |
| source.max_event_level_reports(), |
| source.aggregatable_report_window_time().InMillisecondsFSinceUnixEpoch(), |
| common_info.source_type(), source.priority(), source.debug_key(), |
| source.dedup_keys(), source.filter_data(), |
| base::MakeFlatMap<std::string, std::string>( |
| source.aggregation_keys().keys(), {}, |
| [](const auto& key) { |
| return std::make_pair( |
| key.first, |
| attribution_reporting::HexEncodeAggregationKey(key.second)); |
| }), |
| source.remaining_aggregatable_attribution_budget(), |
| source.aggregatable_dedup_keys(), source.trigger_data_matching(), |
| source.event_level_epsilon(), |
| source.common_info().cookie_based_debug_allowed(), |
| source.remaining_aggregatable_debug_budget(), |
| attribution_reporting::HexEncodeAggregationKey( |
| source.aggregatable_debug_key_piece()), |
| source.attribution_scopes_data().has_value() |
| ? SerializeAttributionJson(source.attribution_scopes_data()->ToJson(), |
| /*pretty_print=*/true) |
| : "null", |
| SerializeBudgetsMap(source.aggregatable_named_budgets()), |
| attributability); |
| } |
| |
| std::vector<attribution_internals::mojom::WebUISourcePtr> ToWebUISources( |
| const std::vector<StoredSource>& active_sources) { |
| return base::ToVector(active_sources, [](const StoredSource& source) { |
| Attributability attributability; |
| switch (source.attribution_logic()) { |
| case StoredSource::AttributionLogic::kTruthfully: |
| attributability = Attributability::kAttributable; |
| break; |
| case StoredSource::AttributionLogic::kNever: |
| attributability = Attributability::kNoisedNever; |
| break; |
| case StoredSource::AttributionLogic::kFalsely: |
| attributability = Attributability::kNoisedFalsely; |
| break; |
| } |
| |
| if (attributability == Attributability::kAttributable) { |
| switch (source.active_state()) { |
| case StoredSource::ActiveState::kActive: |
| attributability = Attributability::kAttributable; |
| break; |
| case StoredSource::ActiveState::kReachedEventLevelAttributionLimit: |
| attributability = Attributability::kReachedEventLevelAttributionLimit; |
| break; |
| case StoredSource::ActiveState::kInactive: |
| NOTREACHED(); |
| } |
| } |
| |
| return WebUISource(source, attributability); |
| }); |
| } |
| |
| attribution_internals::mojom::WebUIReportPtr WebUIReport( |
| const AttributionReport& report, |
| bool is_debug_report, |
| ReportStatusPtr status) { |
| namespace ai_mojom = attribution_internals::mojom; |
| |
| const AttributionInfo& attribution_info = report.attribution_info(); |
| |
| ai_mojom::WebUIReportDataPtr data = std::visit( |
| absl::Overload{ |
| [](const AttributionReport::EventLevelData& event_level_data) { |
| return ai_mojom::WebUIReportData::NewEventLevelData( |
| ai_mojom::WebUIReportEventLevelData::New( |
| event_level_data.priority, |
| event_level_data.attributed_truthfully)); |
| }, |
| |
| [](const AttributionReport::AggregatableData& aggregatable_data) { |
| std::vector<ai_mojom::AggregatableHistogramContributionPtr> |
| contributions; |
| |
| if (aggregatable_data.is_null()) { |
| contributions.push_back( |
| ai_mojom::AggregatableHistogramContribution::New( |
| attribution_reporting::HexEncodeAggregationKey(0), |
| /*value=*/0, |
| /*filtering_id=*/0)); |
| } else { |
| contributions = base::ToVector( |
| aggregatable_data.contributions(), |
| [](const auto& contribution) { |
| return ai_mojom::AggregatableHistogramContribution::New( |
| attribution_reporting::HexEncodeAggregationKey( |
| contribution.bucket), |
| base::checked_cast<uint32_t>(contribution.value), |
| contribution.filtering_id.value_or(0)); |
| }); |
| } |
| |
| return ai_mojom::WebUIReportData::NewAggregatableAttributionData( |
| ai_mojom::WebUIReportAggregatableAttributionData::New( |
| std::move(contributions), |
| aggregatable_data.aggregation_coordinator_origin() |
| ? aggregatable_data.aggregation_coordinator_origin() |
| ->Serialize() |
| : "", |
| aggregatable_data.is_null())); |
| }, |
| }, |
| report.data()); |
| |
| return attribution_internals::mojom::WebUIReport::New( |
| report.id(), report.ReportURL(is_debug_report), |
| /*trigger_time=*/attribution_info.time.InMillisecondsFSinceUnixEpoch(), |
| /*report_time=*/report.report_time().InMillisecondsFSinceUnixEpoch(), |
| SerializeAttributionJson(report.ReportBody(), /*pretty_print=*/true), |
| std::move(status), std::move(data)); |
| } |
| |
| std::vector<attribution_internals::mojom::WebUIReportPtr> ToWebUIReports( |
| const std::vector<AttributionReport>& pending_reports) { |
| return base::ToVector(pending_reports, [](const AttributionReport& report) { |
| return WebUIReport(report, /*is_debug_report=*/false, |
| ReportStatus::NewPending(Empty::New())); |
| }); |
| } |
| |
| attribution_internals::mojom::NetworkStatusPtr NetworkStatus(int status) { |
| return status >= 0 |
| ? attribution_internals::mojom::NetworkStatus::NewHttpResponseCode( |
| status) |
| : attribution_internals::mojom::NetworkStatus::NewNetworkError( |
| net::ErrorToShortString(status)); |
| } |
| |
| } // namespace |
| |
| AttributionInternalsHandlerImpl::AttributionInternalsHandlerImpl( |
| WebUI* web_ui, |
| mojo::PendingRemote<attribution_internals::mojom::Observer> observer, |
| mojo::PendingReceiver<attribution_internals::mojom::Handler> handler) |
| : web_ui_(raw_ref<WebUI>::from_ptr(web_ui)), |
| observer_(std::move(observer)), |
| handler_(this, std::move(handler)) { |
| if (auto* manager = |
| AttributionManager::FromWebContents(web_ui_->GetWebContents())) { |
| manager_observation_.Observe(manager); |
| observer_.set_disconnect_handler( |
| base::BindOnce(&AttributionInternalsHandlerImpl::OnObserverDisconnected, |
| base::Unretained(this))); |
| OnSourcesChanged(); |
| OnReportsChanged(); |
| } |
| } |
| |
| AttributionInternalsHandlerImpl::~AttributionInternalsHandlerImpl() = default; |
| |
| void AttributionInternalsHandlerImpl::IsAttributionReportingEnabled( |
| attribution_internals::mojom::Handler::IsAttributionReportingEnabledCallback |
| callback) { |
| content::WebContents* contents = web_ui_->GetWebContents(); |
| bool attribution_reporting_enabled = |
| AttributionManager::FromWebContents(contents) && |
| GetContentClient()->browser()->IsAttributionReportingOperationAllowed( |
| contents->GetBrowserContext(), |
| ContentBrowserClient::AttributionReportingOperation::kAny, |
| /*rfh=*/nullptr, /*source_origin=*/nullptr, |
| /*destination_origin=*/nullptr, /*reporting_origin=*/nullptr, |
| /*can_bypass=*/nullptr); |
| |
| std::move(callback).Run( |
| attribution_reporting_enabled, |
| static_cast<WebContentsImpl*>(contents)->GetAttributionSupport()); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnDebugModeChanged(bool debug_mode) { |
| observer_->OnDebugModeChanged(debug_mode); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnSourcesChanged() { |
| if (AttributionManager* manager = |
| AttributionManager::FromWebContents(web_ui_->GetWebContents())) { |
| manager->GetActiveSourcesForWebUI(base::BindOnce( |
| [](base::WeakPtr<AttributionInternalsHandlerImpl> handler, |
| std::vector<StoredSource> sources) { |
| if (handler) { |
| handler->observer_->OnSourcesChanged(ToWebUISources(sources)); |
| } |
| }, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| } |
| |
| void AttributionInternalsHandlerImpl::OnReportsChanged() { |
| if (AttributionManager* manager = |
| AttributionManager::FromWebContents(web_ui_->GetWebContents())) { |
| manager->GetPendingReportsForInternalUse( |
| /*limit=*/1000, |
| base::BindOnce( |
| [](base::WeakPtr<AttributionInternalsHandlerImpl> handler, |
| std::vector<AttributionReport> reports) { |
| if (handler) { |
| handler->observer_->OnReportsChanged(ToWebUIReports(reports)); |
| } |
| }, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| } |
| |
| void AttributionInternalsHandlerImpl::SendReport( |
| AttributionReport::Id id, |
| attribution_internals::mojom::Handler::SendReportCallback callback) { |
| if (AttributionManager* manager = |
| AttributionManager::FromWebContents(web_ui_->GetWebContents())) { |
| manager->SendReportForWebUI(id, std::move(callback)); |
| } else { |
| std::move(callback).Run(); |
| } |
| } |
| |
| void AttributionInternalsHandlerImpl::ClearStorage( |
| attribution_internals::mojom::Handler::ClearStorageCallback callback) { |
| if (AttributionManager* manager = |
| AttributionManager::FromWebContents(web_ui_->GetWebContents())) { |
| manager->ClearData(base::Time::Min(), base::Time::Max(), |
| /*filter=*/base::NullCallback(), |
| /*filter_builder=*/nullptr, |
| /*delete_rate_limit_data=*/true, std::move(callback)); |
| } else { |
| std::move(callback).Run(); |
| } |
| } |
| |
| namespace { |
| |
| using WebUISourceRegistration = |
| ::attribution_internals::mojom::WebUISourceRegistration; |
| |
| attribution_internals::mojom::WebUIRegistrationPtr GetRegistration( |
| base::Time time, |
| const attribution_reporting::SuitableOrigin& context_origin, |
| const attribution_reporting::SuitableOrigin& reporting_origin, |
| std::string registration_json, |
| std::optional<uint64_t> cleared_debug_key) { |
| auto reg = attribution_internals::mojom::WebUIRegistration::New(); |
| reg->time = time.InMillisecondsFSinceUnixEpoch(); |
| reg->context_origin = context_origin; |
| reg->reporting_origin = reporting_origin; |
| reg->registration_json = std::move(registration_json); |
| reg->cleared_debug_key = cleared_debug_key; |
| return reg; |
| } |
| |
| } // namespace |
| |
| void AttributionInternalsHandlerImpl::OnSourceHandled( |
| const StorableSource& source, |
| base::Time source_time, |
| std::optional<uint64_t> cleared_debug_key, |
| attribution_reporting::mojom::StoreSourceResult result) { |
| auto web_ui_source = WebUISourceRegistration::New(); |
| web_ui_source->registration = |
| GetRegistration(source_time, source.common_info().source_origin(), |
| source.common_info().reporting_origin(), |
| SerializeAttributionJson(source.registration().ToJson(), |
| /*pretty_print=*/true), |
| cleared_debug_key); |
| web_ui_source->type = source.common_info().source_type(); |
| web_ui_source->status = std::move(result); |
| |
| observer_->OnSourceHandled(std::move(web_ui_source)); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnReportSent( |
| const AttributionReport& report, |
| bool is_debug_report, |
| const SendResult& info) { |
| ReportStatusPtr status = std::visit( |
| absl::Overload{ |
| [](SendResult::Sent sent) { |
| return ReportStatus::NewNetworkStatus(NetworkStatus(sent.status)); |
| }, |
| [](SendResult::Expired) { |
| return ReportStatus::NewExpired(Empty::New()); |
| }, |
| [](SendResult::Dropped) { |
| return ReportStatus::NewProhibitedByBrowserPolicy(Empty::New()); |
| }, |
| [](SendResult::AssemblyFailure) { |
| return ReportStatus::NewFailedToAssemble(Empty::New()); |
| }, |
| }, |
| info.result); |
| |
| observer_->OnReportHandled( |
| WebUIReport(report, is_debug_report, std::move(status))); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnDebugReportSent( |
| const AttributionDebugReport& report, |
| int status, |
| base::Time time) { |
| auto web_report = WebUIDebugReport::New(); |
| web_report->url = report.ReportUrl(); |
| web_report->time = time.InMillisecondsFSinceUnixEpoch(); |
| web_report->body = |
| SerializeAttributionJson(report.ReportBody(), /*pretty_print=*/true); |
| web_report->status = NetworkStatus(status); |
| |
| observer_->OnDebugReportSent(std::move(web_report)); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnAggregatableDebugReportSent( |
| const AggregatableDebugReport& report, |
| base::ValueView report_body, |
| attribution_reporting::mojom::ProcessAggregatableDebugReportResult |
| process_result, |
| const SendAggregatableDebugReportResult& send_result) { |
| auto web_report = WebUIAggregatableDebugReport::New(); |
| web_report->url = report.ReportUrl(); |
| web_report->time = |
| report.scheduled_report_time().InMillisecondsFSinceUnixEpoch(); |
| web_report->body = |
| SerializeAttributionJson(report_body, /*pretty_print=*/true); |
| web_report->process_result = process_result; |
| |
| web_report->send_result = std::visit( |
| absl::Overload{ |
| [](const SendAggregatableDebugReportResult::Sent& sent) { |
| return attribution_internals::mojom:: |
| SendAggregatableDebugReportResult::NewNetworkStatus( |
| NetworkStatus(sent.status)); |
| }, |
| [](const SendAggregatableDebugReportResult::AssemblyFailed&) { |
| return attribution_internals::mojom:: |
| SendAggregatableDebugReportResult::NewAssemblyFailed( |
| Empty::New()); |
| }, |
| }, |
| send_result.result); |
| |
| observer_->OnAggregatableDebugReportSent(std::move(web_report)); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnOsRegistration( |
| base::Time time, |
| const attribution_reporting::OsRegistrationItem& registration, |
| const url::Origin& top_level_origin, |
| attribution_reporting::mojom::RegistrationType type, |
| bool is_debug_key_allowed, |
| attribution_reporting::mojom::OsRegistrationResult result) { |
| auto web_ui_os_registration = |
| attribution_internals::mojom::WebUIOsRegistration::New(); |
| web_ui_os_registration->time = |
| time.InMillisecondsFSinceUnixEpochIgnoringNull(); |
| web_ui_os_registration->registration_url = registration.url; |
| web_ui_os_registration->top_level_origin = top_level_origin; |
| web_ui_os_registration->is_debug_key_allowed = is_debug_key_allowed; |
| web_ui_os_registration->debug_reporting = registration.debug_reporting; |
| web_ui_os_registration->type = type; |
| web_ui_os_registration->result = result; |
| |
| observer_->OnOsRegistration(std::move(web_ui_os_registration)); |
| } |
| |
| void AttributionInternalsHandlerImpl::OnTriggerHandled( |
| const std::optional<uint64_t> cleared_debug_key, |
| const CreateReportResult& result) { |
| const AttributionTrigger& trigger = result.trigger(); |
| const attribution_reporting::TriggerRegistration& registration = |
| trigger.registration(); |
| |
| auto web_ui_trigger = attribution_internals::mojom::WebUITrigger::New(); |
| web_ui_trigger->registration = |
| GetRegistration(result.trigger_time(), trigger.destination_origin(), |
| trigger.reporting_origin(), |
| SerializeAttributionJson(registration.ToJson(), |
| /*pretty_print=*/true), |
| cleared_debug_key); |
| web_ui_trigger->event_level_result = result.event_level_status(); |
| web_ui_trigger->aggregatable_result = result.aggregatable_status(); |
| |
| observer_->OnTriggerHandled(std::move(web_ui_trigger)); |
| |
| if (const AttributionReport* report = result.replaced_event_level_report()) { |
| CHECK_EQ( |
| result.event_level_status(), |
| AttributionTrigger::EventLevelResult::kSuccessDroppedLowerPriority); |
| CHECK(result.new_event_level_report()); |
| |
| observer_->OnReportHandled( |
| WebUIReport(*report, /*is_debug_report=*/false, |
| ReportStatus::NewReplacedByHigherPriorityReport( |
| result.new_event_level_report() |
| ->external_report_id() |
| .AsLowercaseString()))); |
| } |
| } |
| |
| void AttributionInternalsHandlerImpl::OnObserverDisconnected() { |
| manager_observation_.Reset(); |
| } |
| |
| } // namespace content |
