chrome/browser/k_anonymity_service/k_anonymity_service_client.h - chromium/src - Git at Google

 // Copyright 2022 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_
 #define CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_

 #include <memory>
 #include <string>
 #include <vector>

 #include "base/base64.h"
 #include "base/containers/circular_deque.h"
 #include "base/functional/callback.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/time/time.h"
 #include "chrome/browser/k_anonymity_service/k_anonymity_service_storage.h"
 #include "chrome/browser/k_anonymity_service/k_anonymity_trust_token_getter.h"
 #include "chrome/browser/k_anonymity_service/remote_trust_token_query_answerer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/k_anonymity_service_delegate.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/bindings/unique_receiver_set.h"
 #include "net/base/isolation_info.h"
 #include "services/data_decoder/public/cpp/data_decoder.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/cpp/simple_url_loader.h"
 #include "services/network/public/mojom/oblivious_http_request.mojom-forward.h"
 #include "services/network/public/mojom/trust_tokens.mojom.h"

 // This class implements the KAnonymityServiceDelegate by sending requests
 // to the Chrome k-anonymity Service. This class will eventually send requests
 // over OHTTP in order to anonymize the source of the requests. The requests are
 // internally queued and performed serially.
 //
 // In the case of JoinSet this is necessary because we need
 // to ensure that there is a trust token available to attach to the call, and
 // the network service does not expose a method to get the count.
 //
 // In the case of QuerySets, requests are performed serially in order to
 // simplify implementation. With only one request out at a time 1) it is clear
 // which request the responses are associated with and 2) the limit on the
 // number of outstanding requests can be handled by the caller.
 //
 // IDs passed into the KAnonymityServiceClient will be hashed with SHA256
 // to convert them to a fixed size before being sent to the KAnonymity service.
 class KAnonymityServiceClient : public content::KAnonymityServiceDelegate,
                                 public KeyedService {
  public:
   // The profile must outlive the KAnonymityServiceClient.
   explicit KAnonymityServiceClient(Profile* profile);
   ~KAnonymityServiceClient() override;

   // Implementation of content::KAnonymityServiceDelegate.

   // JoinSet corresponds directly to the JoinSet endpoint provided by the
   // K-anonymity Service endpoint. The endpoint requires us to provide a trust
   // token for rate limiting for each call, so we need to check that before
   // performing the OHTTP request (assuming we have the key).
   //
   // The trust token interface (and network isolation configuration) assume
   // there exists both a "top frame" and a "current frame" for any requests.
   // The KAnonymityServiceClient makes requests in the background so those
   // concepts don't really apply here, but for the purposes of the interface we
   // choose to use the kKAnonymityAuthServer's origin as the origin for both
   // frames. Not only does this ensure that requests that can be cached are
   // cached with the appropriate isolation applied, but also avoids the less
   // common (and less tested) configuration where trust tokens are issued in a
   // third-party frame.
   void JoinSet(std::string id,
                base::OnceCallback<void(bool)> callback) override;
   // QuerySets is implemented as multiple calls to the QuerySet endpoint of
   // the K-anonymity Service.
   void QuerySets(std::vector<std::string> set_ids,
                  base::OnceCallback<void(std::vector<bool>)> callback) override;

   base::TimeDelta GetJoinInterval() override;
   base::TimeDelta GetQueryInterval() override;

  private:
   struct PendingJoinRequest {
     PendingJoinRequest(std::string set_id,
                        base::OnceCallback<void(bool)> callback);
     ~PendingJoinRequest();
     std::string id;
     base::TimeTicks request_start;
     int retries = 0;
     base::OnceCallback<void(bool)> callback;
   };

   struct PendingQueryRequest {
     PendingQueryRequest(std::vector<std::string> set_id,
                         base::OnceCallback<void(std::vector<bool>)> callback);
     ~PendingQueryRequest();
     std::vector<std::string> ids;
     base::TimeTicks request_start;
     base::OnceCallback<void(std::vector<bool>)> callback;
   };

   // Called when storage is ready to for us to make requests.
   void JoinSetOnStorageReady(KAnonymityServiceStorage::InitStatus status);
   // Starts processing items in the queue by calling JoinSetCheckTrustTokens()
   void JoinSetStartNextQueued();
   // Checks that the cached OHTTP Key is still valid and if not calls
   // RequestJoinSetOHTTPKey to refresh it.
   void JoinSetCheckOHTTPKey();
   // Starts the HTTP fetch to obtain the OHTTP key from the JoinSet endpoint.
   void RequestJoinSetOHTTPKey();
   // Asynchronously called by the join_url_loader_ with a response containing
   // the OHTTP key for the JoinSet endpoint. The key is cached and then
   // JoinSetCheckTrustTokens is called to continue processing the current
   // request.
   void OnGotJoinSetOHTTPKey(std::unique_ptr<std::string> response);

   // Calls the token_getter_ to ensure there is a trust token for the request.
   void JoinSetCheckTrustTokens(OHTTPKeyAndExpiration ohttp_key);
   // Asynchronous callback from token_getter_ which is passed the key commitment
   // and non-unique client ID that are needed to complete JoinSet. If the
   // provided optional is not empty this triggers the JoinSet request.
   void OnMaybeHasTrustTokens(
       OHTTPKeyAndExpiration ohttp_key,
       absl::optional<KeyAndNonUniqueUserId> maybe_key_and_id);
   // Starts the OHTTP JoinSet request for the join_queue_.front() request.
   void JoinSetSendRequest(OHTTPKeyAndExpiration ohttp_key,
                           KeyAndNonUniqueUserId key_and_id);
   // Handle the response to the JoinSet request and call CompleteJoinSetRequest
   // if successful.
   void JoinSetOnGotResponse(const absl::optional<std::string>& response,
                             int error_code);
   // Calls DoJoinSetCallback indicating the current request completed
   // successfully. If there are other items in the queue calls
   // JoinSetStartNextQueued to start processing them.
   void CompleteJoinSetRequest();
   // Calls DoJoinSetCallback for each of the requests in the join_queue_
   // indicating the requests were unsuccessful.
   void FailJoinSetRequests();
   // Asynchronously calls the callback for the join_queue_.front() request with
   // the provided status and removes it from the queue.
   void DoJoinSetCallback(bool status);

   // Called when storage is ready to for us to make requests.
   void QuerySetsOnStorageReady(KAnonymityServiceStorage::InitStatus status);
   // Checks that the cached OHTTP Key is still valid and if not calls
   // RequestQuerySetOHTTPKey to refresh it.
   void QuerySetsCheckOHTTPKey();
   // Starts the HTTP fetch to obtain the OHTTP key from the QuerySet endpoint.
   void RequestQuerySetOHTTPKey();
   // Asynchronous response containing the OHTTP key for the QuerySet endpoint.
   // The key is cached and then QuerySetsSendRequests is called to continue
   // processing the current request.
   void OnGotQuerySetOHTTPKey(std::unique_ptr<std::string> response);
   // Handles failures in fetching the OHTTP key. Schedules callbacks indicating
   // failure for all requests on the query_queue_.
   void FailFetchingQueryOHTTPKey();
   // Starts the OHTTP QuerySet request for the current QueryRequest.
   void QuerySetsSendRequest(OHTTPKeyAndExpiration ohttp_key);
   // Called as an asynchronous response to the OHTTP request started by
   // QuerySetsSendRequest. Passes the JSON response received to be decoded and
   // handled in QuerySetsOnParsedResponse.
   void QuerySetsOnGotResponse(const absl::optional<std::string>& response,
                               int error_code);
   // Called asynchronously when the QuerySet response from
   // QuerySetsOnGotResponse has been decoded.
   void QuerySetsOnParsedResponse(
       data_decoder::DataDecoder::ValueOrError result);
   // Calls DoQuerySetsCallback indicating the current request completed
   // successfully. If there are other items in the queue calls
   // QuerySetsCheckOHTTPKey to start processing them.
   void CompleteQuerySetsRequest(std::vector<bool> result);
   // Called when the request started by QuerySetsSendRequest fails
   // either because of network errors are parse failure. Calls
   // DoQuerySetsCallback for each of the requests in the query_queue_ indicating
   // the requests were unsuccessful.
   void FailQuerySetsRequests();
   // Called by QuerySetsOnParsedResponse and FailQuerySetRequest. Schedules
   // a callback containing the result and starts work on the next request in the
   // query_queue_.
   void DoQuerySetsCallback(std::vector<bool> result);

   // queues
   base::circular_deque<std::unique_ptr<PendingJoinRequest>> join_queue_;
   base::circular_deque<std::unique_ptr<PendingQueryRequest>> query_queue_;

   mojo::UniqueReceiverSet<network::mojom::ObliviousHttpClient>
       ohttp_client_receivers_;

   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   std::unique_ptr<network::SimpleURLLoader> join_url_loader_;
   std::unique_ptr<network::SimpleURLLoader> query_url_loader_;
   bool enable_ohttp_requests_;
   net::IsolationInfo isolation_info_;

   std::unique_ptr<KAnonymityServiceStorage> storage_;
   RemoteTrustTokenQueryAnswerer trust_token_answerer_;
   KAnonymityTrustTokenGetter token_getter_;

   url::Origin join_origin_;
   url::Origin query_origin_;

   base::raw_ptr<Profile> profile_;
   base::WeakPtrFactory<KAnonymityServiceClient> weak_ptr_factory_{this};
 };

 #endif  // CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_
	// Copyright 2022 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_
	#define CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_

	#include <memory>
	#include <string>
	#include <vector>

	#include "base/base64.h"
	#include "base/containers/circular_deque.h"
	#include "base/functional/callback.h"
	#include "base/memory/scoped_refptr.h"
	#include "base/time/time.h"
	#include "chrome/browser/k_anonymity_service/k_anonymity_service_storage.h"
	#include "chrome/browser/k_anonymity_service/k_anonymity_trust_token_getter.h"
	#include "chrome/browser/k_anonymity_service/remote_trust_token_query_answerer.h"
	#include "chrome/browser/profiles/profile.h"
	#include "content/public/browser/k_anonymity_service_delegate.h"
	#include "mojo/public/cpp/bindings/remote.h"
	#include "mojo/public/cpp/bindings/unique_receiver_set.h"
	#include "net/base/isolation_info.h"
	#include "services/data_decoder/public/cpp/data_decoder.h"
	#include "services/network/public/cpp/shared_url_loader_factory.h"
	#include "services/network/public/cpp/simple_url_loader.h"
	#include "services/network/public/mojom/oblivious_http_request.mojom-forward.h"
	#include "services/network/public/mojom/trust_tokens.mojom.h"

	// This class implements the KAnonymityServiceDelegate by sending requests
	// to the Chrome k-anonymity Service. This class will eventually send requests
	// over OHTTP in order to anonymize the source of the requests. The requests are
	// internally queued and performed serially.
	//
	// In the case of JoinSet this is necessary because we need
	// to ensure that there is a trust token available to attach to the call, and
	// the network service does not expose a method to get the count.
	//
	// In the case of QuerySets, requests are performed serially in order to
	// simplify implementation. With only one request out at a time 1) it is clear
	// which request the responses are associated with and 2) the limit on the
	// number of outstanding requests can be handled by the caller.
	//
	// IDs passed into the KAnonymityServiceClient will be hashed with SHA256
	// to convert them to a fixed size before being sent to the KAnonymity service.
	class KAnonymityServiceClient : public content::KAnonymityServiceDelegate,
	public KeyedService {
	public:
	// The profile must outlive the KAnonymityServiceClient.
	explicit KAnonymityServiceClient(Profile* profile);
	~KAnonymityServiceClient() override;

	// Implementation of content::KAnonymityServiceDelegate.

	// JoinSet corresponds directly to the JoinSet endpoint provided by the
	// K-anonymity Service endpoint. The endpoint requires us to provide a trust
	// token for rate limiting for each call, so we need to check that before
	// performing the OHTTP request (assuming we have the key).
	//
	// The trust token interface (and network isolation configuration) assume
	// there exists both a "top frame" and a "current frame" for any requests.
	// The KAnonymityServiceClient makes requests in the background so those
	// concepts don't really apply here, but for the purposes of the interface we
	// choose to use the kKAnonymityAuthServer's origin as the origin for both
	// frames. Not only does this ensure that requests that can be cached are
	// cached with the appropriate isolation applied, but also avoids the less
	// common (and less tested) configuration where trust tokens are issued in a
	// third-party frame.
	void JoinSet(std::string id,
	base::OnceCallback<void(bool)> callback) override;
	// QuerySets is implemented as multiple calls to the QuerySet endpoint of
	// the K-anonymity Service.
	void QuerySets(std::vector<std::string> set_ids,
	base::OnceCallback<void(std::vector<bool>)> callback) override;

	base::TimeDelta GetJoinInterval() override;
	base::TimeDelta GetQueryInterval() override;

	private:
	struct PendingJoinRequest {
	PendingJoinRequest(std::string set_id,
	base::OnceCallback<void(bool)> callback);
	~PendingJoinRequest();
	std::string id;
	base::TimeTicks request_start;
	int retries = 0;
	base::OnceCallback<void(bool)> callback;
	};

	struct PendingQueryRequest {
	PendingQueryRequest(std::vector<std::string> set_id,
	base::OnceCallback<void(std::vector<bool>)> callback);
	~PendingQueryRequest();
	std::vector<std::string> ids;
	base::TimeTicks request_start;
	base::OnceCallback<void(std::vector<bool>)> callback;
	};

	// Called when storage is ready to for us to make requests.
	void JoinSetOnStorageReady(KAnonymityServiceStorage::InitStatus status);
	// Starts processing items in the queue by calling JoinSetCheckTrustTokens()
	void JoinSetStartNextQueued();
	// Checks that the cached OHTTP Key is still valid and if not calls
	// RequestJoinSetOHTTPKey to refresh it.
	void JoinSetCheckOHTTPKey();
	// Starts the HTTP fetch to obtain the OHTTP key from the JoinSet endpoint.
	void RequestJoinSetOHTTPKey();
	// Asynchronously called by the join_url_loader_ with a response containing
	// the OHTTP key for the JoinSet endpoint. The key is cached and then
	// JoinSetCheckTrustTokens is called to continue processing the current
	// request.
	void OnGotJoinSetOHTTPKey(std::unique_ptr<std::string> response);

	// Calls the token_getter_ to ensure there is a trust token for the request.
	void JoinSetCheckTrustTokens(OHTTPKeyAndExpiration ohttp_key);
	// Asynchronous callback from token_getter_ which is passed the key commitment
	// and non-unique client ID that are needed to complete JoinSet. If the
	// provided optional is not empty this triggers the JoinSet request.
	void OnMaybeHasTrustTokens(
	OHTTPKeyAndExpiration ohttp_key,
	absl::optional<KeyAndNonUniqueUserId> maybe_key_and_id);
	// Starts the OHTTP JoinSet request for the join_queue_.front() request.
	void JoinSetSendRequest(OHTTPKeyAndExpiration ohttp_key,
	KeyAndNonUniqueUserId key_and_id);
	// Handle the response to the JoinSet request and call CompleteJoinSetRequest
	// if successful.
	void JoinSetOnGotResponse(const absl::optional<std::string>& response,
	int error_code);
	// Calls DoJoinSetCallback indicating the current request completed
	// successfully. If there are other items in the queue calls
	// JoinSetStartNextQueued to start processing them.
	void CompleteJoinSetRequest();
	// Calls DoJoinSetCallback for each of the requests in the join_queue_
	// indicating the requests were unsuccessful.
	void FailJoinSetRequests();
	// Asynchronously calls the callback for the join_queue_.front() request with
	// the provided status and removes it from the queue.
	void DoJoinSetCallback(bool status);

	// Called when storage is ready to for us to make requests.
	void QuerySetsOnStorageReady(KAnonymityServiceStorage::InitStatus status);
	// Checks that the cached OHTTP Key is still valid and if not calls
	// RequestQuerySetOHTTPKey to refresh it.
	void QuerySetsCheckOHTTPKey();
	// Starts the HTTP fetch to obtain the OHTTP key from the QuerySet endpoint.
	void RequestQuerySetOHTTPKey();
	// Asynchronous response containing the OHTTP key for the QuerySet endpoint.
	// The key is cached and then QuerySetsSendRequests is called to continue
	// processing the current request.
	void OnGotQuerySetOHTTPKey(std::unique_ptr<std::string> response);
	// Handles failures in fetching the OHTTP key. Schedules callbacks indicating
	// failure for all requests on the query_queue_.
	void FailFetchingQueryOHTTPKey();
	// Starts the OHTTP QuerySet request for the current QueryRequest.
	void QuerySetsSendRequest(OHTTPKeyAndExpiration ohttp_key);
	// Called as an asynchronous response to the OHTTP request started by
	// QuerySetsSendRequest. Passes the JSON response received to be decoded and
	// handled in QuerySetsOnParsedResponse.
	void QuerySetsOnGotResponse(const absl::optional<std::string>& response,
	int error_code);
	// Called asynchronously when the QuerySet response from
	// QuerySetsOnGotResponse has been decoded.
	void QuerySetsOnParsedResponse(
	data_decoder::DataDecoder::ValueOrError result);
	// Calls DoQuerySetsCallback indicating the current request completed
	// successfully. If there are other items in the queue calls
	// QuerySetsCheckOHTTPKey to start processing them.
	void CompleteQuerySetsRequest(std::vector<bool> result);
	// Called when the request started by QuerySetsSendRequest fails
	// either because of network errors are parse failure. Calls
	// DoQuerySetsCallback for each of the requests in the query_queue_ indicating
	// the requests were unsuccessful.
	void FailQuerySetsRequests();
	// Called by QuerySetsOnParsedResponse and FailQuerySetRequest. Schedules
	// a callback containing the result and starts work on the next request in the
	// query_queue_.
	void DoQuerySetsCallback(std::vector<bool> result);

	// queues
	base::circular_deque<std::unique_ptr<PendingJoinRequest>> join_queue_;
	base::circular_deque<std::unique_ptr<PendingQueryRequest>> query_queue_;

	mojo::UniqueReceiverSet<network::mojom::ObliviousHttpClient>
	ohttp_client_receivers_;

	scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
	std::unique_ptr<network::SimpleURLLoader> join_url_loader_;
	std::unique_ptr<network::SimpleURLLoader> query_url_loader_;
	bool enable_ohttp_requests_;
	net::IsolationInfo isolation_info_;

	std::unique_ptr<KAnonymityServiceStorage> storage_;
	RemoteTrustTokenQueryAnswerer trust_token_answerer_;
	KAnonymityTrustTokenGetter token_getter_;

	url::Origin join_origin_;
	url::Origin query_origin_;

	base::raw_ptr<Profile> profile_;
	base::WeakPtrFactory<KAnonymityServiceClient> weak_ptr_factory_{this};
	};

	#endif // CHROME_BROWSER_K_ANONYMITY_SERVICE_K_ANONYMITY_SERVICE_CLIENT_H_