passkey_sync_bridge.cc | Explore in Territory

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

#include "components/webauthn/core/browser/passkey_sync_bridge.h"

#include <algorithm>
#include <iterator>
#include <memory>
#include <numeric>
#include <optional>
#include <string>

#include "base/containers/contains.h"
#include "base/containers/flat_set.h"
#include "base/containers/flat_tree.h"
#include "base/containers/span.h"
#include "base/feature_list.h"
#include "base/functional/callback_helpers.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "base/trace_event/trace_event.h"
#include "components/sync/base/data_type.h"
#include "components/sync/base/deletion_origin.h"
#include "components/sync/base/features.h"
#include "components/sync/model/client_tag_based_data_type_processor.h"
#include "components/sync/model/data_type_controller_delegate.h"
#include "components/sync/model/data_type_store.h"
#include "components/sync/model/entity_change.h"
#include "components/sync/model/metadata_change_list.h"
#include "components/sync/model/mutable_data_batch.h"
#include "components/sync/protocol/webauthn_credential_specifics.pb.h"
#include "components/webauthn/core/browser/passkey_model.h"
#include "components/webauthn/core/browser/passkey_model_change.h"
#include "components/webauthn/core/browser/passkey_model_utils.h"

namespace webauthn {
namespace {

// The byte length of the WebauthnCredentialSpecifics `sync_id` field.
constexpr size_t kSyncIdLength = …;

// The byte length of the WebauthnCredentialSpecifics `credential_id` field.
constexpr size_t kCredentialIdLength = …;

// The maximum byte length of the WebauthnCredentialSpecifics `user_id` field.
constexpr size_t kUserIdMaxLength = …;

std::unique_ptr<syncer::EntityData> CreateEntityData(
    const sync_pb::WebauthnCredentialSpecifics& specifics) { … }

bool WebauthnCredentialSpecificsValid(
    const sync_pb::WebauthnCredentialSpecifics& specifics) { … }

std::optional<std::string> FindHeadOfShadowChain(
    const std::map<std::string, sync_pb::WebauthnCredentialSpecifics>& passkeys,
    const std::string& rp_id,
    const std::string& user_id) { … }

PasskeyModelChange::ChangeType ToPasskeyModelChangeType(
    syncer::EntityChange::ChangeType entity_change) { … }

}  // namespace

PasskeySyncBridge::PasskeySyncBridge(
    syncer::OnceDataTypeStoreFactory store_factory)
    : … { … }

PasskeySyncBridge::~PasskeySyncBridge() { … }

void PasskeySyncBridge::AddObserver(Observer* observer) { … }

void PasskeySyncBridge::RemoveObserver(Observer* observer) { … }

std::unique_ptr<syncer::MetadataChangeList>
PasskeySyncBridge::CreateMetadataChangeList() { … }

std::optional<syncer::ModelError> PasskeySyncBridge::MergeFullSyncData(
    std::unique_ptr<syncer::MetadataChangeList> metadata_changes,
    syncer::EntityChangeList entity_changes) { … }

std::optional<syncer::ModelError>
PasskeySyncBridge::ApplyIncrementalSyncChanges(
    std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
    syncer::EntityChangeList entity_changes) { … }

std::unique_ptr<syncer::DataBatch> PasskeySyncBridge::GetDataForCommit(
    StorageKeyList storage_keys) { … }

std::unique_ptr<syncer::DataBatch> PasskeySyncBridge::GetAllDataForDebugging() { … }

bool PasskeySyncBridge::IsEntityDataValid(
    const syncer::EntityData& entity_data) const { … }

std::string PasskeySyncBridge::GetClientTag(
    const syncer::EntityData& entity_data) { … }

std::string PasskeySyncBridge::GetStorageKey(
    const syncer::EntityData& entity_data) { … }

void PasskeySyncBridge::ApplyDisableSyncChanges(
    std::unique_ptr<syncer::MetadataChangeList> delete_metadata_change_list) { … }

base::WeakPtr<syncer::DataTypeControllerDelegate>
PasskeySyncBridge::GetDataTypeControllerDelegate() { … }

bool PasskeySyncBridge::IsReady() const { … }

bool PasskeySyncBridge::IsEmpty() const { … }

base::flat_set<std::string> PasskeySyncBridge::GetAllSyncIds() const { … }

std::vector<sync_pb::WebauthnCredentialSpecifics>
PasskeySyncBridge::GetAllPasskeys() const { … }

std::optional<sync_pb::WebauthnCredentialSpecifics>
PasskeySyncBridge::GetPasskeyByCredentialId(
    const std::string& rp_id,
    const std::string& credential_id) const { … }

std::vector<sync_pb::WebauthnCredentialSpecifics>
PasskeySyncBridge::GetPasskeysForRelyingPartyId(
    const std::string& rp_id) const { … }

bool PasskeySyncBridge::DeletePasskey(const std::string& credential_id,
                                      const base::Location& location) { … }

// The following implementation is more efficient than the simple one which
// would iterate over all passkeys and delete them one by one.
// Deleting all passkeys individually would also send out a notification to
// the observers for each individual deletion. This implementation only sends
// out a single notification for all deletions.
// Shadow chains are not handled separately since all passkeys are deleted
// anyway.
void PasskeySyncBridge::DeleteAllPasskeys() { … }

bool PasskeySyncBridge::UpdatePasskey(const std::string& credential_id,
                                      PasskeyUpdate change) { … }

sync_pb::WebauthnCredentialSpecifics PasskeySyncBridge::CreatePasskey(
    std::string_view rp_id,
    const UserEntity& user_entity,
    base::span<const uint8_t> trusted_vault_key,
    int32_t trusted_vault_key_version,
    std::vector<uint8_t>* public_key_spki_der_out) { … }

void PasskeySyncBridge::CreatePasskey(
    sync_pb::WebauthnCredentialSpecifics& passkey) { … }

std::string PasskeySyncBridge::AddNewPasskeyForTesting(
    sync_pb::WebauthnCredentialSpecifics specifics) { … }

void PasskeySyncBridge::AddPasskeyInternal(
    sync_pb::WebauthnCredentialSpecifics specifics) { … }

void PasskeySyncBridge::OnCreateStore(
    const std::optional<syncer::ModelError>& error,
    std::unique_ptr<syncer::DataTypeStore> store) { … }

void PasskeySyncBridge::OnStoreReadAllDataAndMetadata(
    const std::optional<syncer::ModelError>& error,
    std::unique_ptr<syncer::DataTypeStore::RecordList> entries,
    std::unique_ptr<syncer::MetadataBatch> metadata_batch) { … }

void PasskeySyncBridge::OnStoreCommitWriteBatch(
    const std::optional<syncer::ModelError>& error) { … }

void PasskeySyncBridge::NotifyPasskeysChanged(
    const std::vector<PasskeyModelChange>& changes) { … }

void PasskeySyncBridge::AddShadowedCredentialIdsToNewPasskey(
    sync_pb::WebauthnCredentialSpecifics& passkey) { … }

}  // namespace webauthn
chromium/components/webauthn/core/browser/passkey_sync_bridge.cc
