| // Copyright 2022 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/aggregatable_attribution_utils.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <iterator> |
| #include <optional> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/check.h" |
| #include "base/feature_list.h" |
| #include "base/functional/overloaded.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/notreached.h" |
| #include "base/numerics/checked_math.h" |
| #include "base/numerics/clamped_math.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/ranges/algorithm.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/time/time.h" |
| #include "base/values.h" |
| #include "components/attribution_reporting/aggregatable_trigger_config.h" |
| #include "components/attribution_reporting/aggregatable_trigger_data.h" |
| #include "components/attribution_reporting/aggregatable_utils.h" |
| #include "components/attribution_reporting/aggregatable_values.h" |
| #include "components/attribution_reporting/aggregation_keys.h" |
| #include "components/attribution_reporting/constants.h" |
| #include "components/attribution_reporting/features.h" |
| #include "components/attribution_reporting/filters.h" |
| #include "components/attribution_reporting/source_registration_time_config.mojom.h" |
| #include "components/attribution_reporting/source_type.mojom-forward.h" |
| #include "components/attribution_reporting/suitable_origin.h" |
| #include "content/browser/aggregation_service/aggregatable_report.h" |
| #include "content/browser/aggregation_service/aggregation_service_features.h" |
| #include "content/browser/attribution_reporting/attribution_info.h" |
| #include "content/browser/attribution_reporting/attribution_report.h" |
| #include "net/base/schemeful_site.h" |
| #include "third_party/abseil-cpp/absl/types/variant.h" |
| #include "third_party/blink/public/mojom/aggregation_service/aggregatable_report.mojom.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| // Note: use the same time serialization as in aggregatable_report.cc. |
| // Consider sharing logic if more call-sites need this. |
| std::string SerializeTimeRoundedDownToWholeDayInSeconds(base::Time time) { |
| // TODO(csharrison, linnan): Validate that `time` is valid (e.g. not null / |
| // inf). |
| base::Time rounded = |
| attribution_reporting::RoundDownToWholeDaySinceUnixEpoch(time); |
| return base::NumberToString(rounded.InMillisecondsSinceUnixEpoch() / |
| base::Time::kMillisecondsPerSecond); |
| } |
| |
| bool IsAggregatableFilteringIdsEnabled() { |
| return base::FeatureList::IsEnabled( |
| attribution_reporting::features:: |
| kAttributionReportingAggregatableFilteringIds) && |
| base::FeatureList::IsEnabled( |
| kPrivacySandboxAggregationServiceFilteringIds); |
| } |
| |
| } // namespace |
| |
| std::vector<blink::mojom::AggregatableReportHistogramContribution> |
| CreateAggregatableHistogram( |
| const attribution_reporting::FilterData& source_filter_data, |
| attribution_reporting::mojom::SourceType source_type, |
| const base::Time& source_time, |
| const base::Time& trigger_time, |
| const attribution_reporting::AggregationKeys& keys, |
| const std::vector<attribution_reporting::AggregatableTriggerData>& |
| aggregatable_trigger_data, |
| const std::vector<attribution_reporting::AggregatableValues>& |
| aggregatable_values) { |
| size_t num_trigger_data_filtered = 0; |
| |
| attribution_reporting::AggregationKeys::Keys buckets = keys.keys(); |
| |
| // For each piece of trigger data specified, check if its filters/not_filters |
| // match for the given source, and if applicable modify the bucket based on |
| // the given key piece. |
| for (const auto& data : aggregatable_trigger_data) { |
| if (!source_filter_data.Matches(source_type, source_time, trigger_time, |
| data.filters())) { |
| ++num_trigger_data_filtered; |
| continue; |
| } |
| |
| for (const auto& source_key : data.source_keys()) { |
| auto bucket = buckets.find(source_key); |
| if (bucket == buckets.end()) { |
| continue; |
| } |
| |
| bucket->second |= data.key_piece(); |
| } |
| } |
| |
| std::vector<blink::mojom::AggregatableReportHistogramContribution> |
| contributions; |
| const bool filtering_id_enabled = IsAggregatableFilteringIdsEnabled(); |
| for (const auto& aggregatable_value : aggregatable_values) { |
| if (source_filter_data.Matches(source_type, source_time, trigger_time, |
| aggregatable_value.filters())) { |
| const attribution_reporting::AggregatableValues::Values& values = |
| aggregatable_value.values(); |
| for (const auto& [key_id, key] : buckets) { |
| auto value = values.find(key_id); |
| if (value == values.end()) { |
| continue; |
| } |
| |
| std::optional<uint64_t> filtering_id; |
| if (filtering_id_enabled) { |
| filtering_id = value->second.filtering_id(); |
| } |
| |
| contributions.emplace_back( |
| key, base::checked_cast<int32_t>(value->second.value()), |
| filtering_id); |
| } |
| break; |
| } |
| } |
| |
| if (!aggregatable_trigger_data.empty()) { |
| base::ClampedNumeric<size_t> percentage = num_trigger_data_filtered; |
| percentage *= 100; |
| percentage /= aggregatable_trigger_data.size(); |
| |
| base::UmaHistogramPercentage( |
| "Conversions.AggregatableReport.FilteredTriggerDataPercentage", |
| percentage); |
| } |
| |
| if (!buckets.empty()) { |
| base::ClampedNumeric<size_t> percentage = buckets.size(); |
| percentage -= contributions.size(); |
| percentage *= 100; |
| percentage /= buckets.size(); |
| |
| base::UmaHistogramPercentage( |
| "Conversions.AggregatableReport.DroppedKeysPercentage", percentage); |
| } |
| |
| static_assert(attribution_reporting::kMaxAggregationKeysPerSource == 20, |
| "Bump the version for histogram " |
| "Conversions.AggregatableReport.NumContributionsPerReport2"); |
| |
| base::UmaHistogramExactLinear( |
| "Conversions.AggregatableReport.NumContributionsPerReport2", |
| base::saturated_cast<int>(contributions.size()), |
| attribution_reporting::kMaxAggregationKeysPerSource + 1); |
| |
| // If total values exceeds the max, log the metrics as 100,000 to measure |
| // how often the max is exceeded. |
| static_assert(attribution_reporting::kMaxAggregatableValue == 65536); |
| const int64_t max_value = attribution_reporting::kMaxAggregatableValue + 1; |
| int64_t adjusted_value = std::min( |
| base::MakeStrictNum(max_value), |
| GetTotalAggregatableValues(contributions).ValueOrDefault(max_value)); |
| base::UmaHistogramCounts100000( |
| "Conversions.AggregatableReport.TotalBudgetPerReport", |
| adjusted_value == max_value ? 100000 |
| : base::saturated_cast<int>(adjusted_value)); |
| |
| return contributions; |
| } |
| |
| std::optional<AggregatableReportRequest> CreateAggregatableReportRequest( |
| const AttributionReport& report) { |
| base::Time source_time; |
| const AttributionReport::CommonAggregatableData* common_aggregatable_data = |
| nullptr; |
| std::vector<blink::mojom::AggregatableReportHistogramContribution> |
| contributions; |
| |
| absl::visit( |
| base::Overloaded{ |
| [](const AttributionReport::EventLevelData&) { |
| NOTREACHED_IN_MIGRATION(); |
| }, |
| [&](const AttributionReport::AggregatableAttributionData& data) { |
| source_time = data.source_time; |
| common_aggregatable_data = &data.common_data; |
| contributions = data.contributions; |
| }, |
| [&](const AttributionReport::NullAggregatableData& data) { |
| source_time = data.fake_source_time; |
| common_aggregatable_data = &data.common_data; |
| }, |
| }, |
| report.data()); |
| DCHECK(common_aggregatable_data); |
| |
| const AttributionInfo& attribution_info = report.attribution_info(); |
| |
| AggregatableReportSharedInfo::DebugMode debug_mode = |
| report.CanDebuggingBeEnabled() |
| ? AggregatableReportSharedInfo::DebugMode::kEnabled |
| : AggregatableReportSharedInfo::DebugMode::kDisabled; |
| |
| base::Value::Dict additional_fields; |
| switch (common_aggregatable_data->aggregatable_trigger_config |
| .source_registration_time_config()) { |
| case attribution_reporting::mojom::SourceRegistrationTimeConfig::kInclude: |
| additional_fields.Set( |
| "source_registration_time", |
| SerializeTimeRoundedDownToWholeDayInSeconds(source_time)); |
| break; |
| case attribution_reporting::mojom::SourceRegistrationTimeConfig::kExclude: |
| break; |
| } |
| |
| SetAttributionDestination( |
| additional_fields, net::SchemefulSite(attribution_info.context_origin)); |
| |
| std::optional<size_t> filtering_id_max_bytes; |
| if (IsAggregatableFilteringIdsEnabled()) { |
| filtering_id_max_bytes = |
| common_aggregatable_data->aggregatable_trigger_config |
| .aggregatable_filtering_id_max_bytes() |
| .value(); |
| } else { |
| // We clear the filtering ids to avoid hitting `FilteringIdsFitInMaxBytes()` |
| // invalidly in case that filtering ids were unexpectedly set in the db for |
| // some reason like db corruption. |
| for (auto& contribution : contributions) { |
| contribution.filtering_id.reset(); |
| } |
| } |
| return AggregatableReportRequest::Create( |
| AggregationServicePayloadContents( |
| AggregationServicePayloadContents::Operation::kHistogram, |
| std::move(contributions), |
| blink::mojom::AggregationServiceMode::kDefault, |
| common_aggregatable_data->aggregation_coordinator_origin |
| ? std::make_optional( |
| **common_aggregatable_data->aggregation_coordinator_origin) |
| : std::nullopt, |
| /*max_contributions_allowed=*/ |
| attribution_reporting::kMaxAggregationKeysPerSource, |
| filtering_id_max_bytes), |
| AggregatableReportSharedInfo( |
| report.initial_report_time(), report.external_report_id(), |
| report.reporting_origin(), debug_mode, std::move(additional_fields), |
| filtering_id_max_bytes.has_value() |
| ? AttributionReport::CommonAggregatableData:: |
| kVersionWithFlexibleContributionFiltering |
| : AttributionReport::CommonAggregatableData::kVersion, |
| AttributionReport::CommonAggregatableData::kApiIdentifier), |
| // The returned request cannot be serialized due to the null `delay_type`. |
| /*delay_type=*/std::nullopt); |
| } |
| |
| base::CheckedNumeric<int64_t> GetTotalAggregatableValues( |
| const std::vector<blink::mojom::AggregatableReportHistogramContribution>& |
| contributions) { |
| base::CheckedNumeric<int64_t> total_value = 0; |
| for (const blink::mojom::AggregatableReportHistogramContribution& |
| contribution : contributions) { |
| total_value += contribution.value; |
| } |
| return total_value; |
| } |
| |
| void SetAttributionDestination(base::Value::Dict& dict, |
| const net::SchemefulSite& destination) { |
| dict.Set("attribution_destination", destination.Serialize()); |
| } |
| |
| } // namespace content |
