chromium/components/enterprise/client_certificates/core/certificate_provisioning_service.cc

// Copyright 2024 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/enterprise/client_certificates/core/certificate_provisioning_service.h"

#include <optional>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "components/enterprise/client_certificates/core/certificate_store.h"
#include "components/enterprise/client_certificates/core/constants.h"
#include "components/enterprise/client_certificates/core/context_delegate.h"
#include "components/enterprise/client_certificates/core/key_upload_client.h"
#include "components/enterprise/client_certificates/core/metrics_util.h"
#include "components/enterprise/client_certificates/core/prefs.h"
#include "components/enterprise/client_certificates/core/private_key.h"
#include "components/enterprise/client_certificates/core/store_error.h"
#include "components/policy/core/common/policy_logger.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/prefs/pref_service.h"
#include "net/cert/x509_certificate.h"

namespace client_certificates {

namespace {

constexpr int kDaysBeforeExpiration = …;

// Returns true if `certificate` expires within the next `kDaysBeforeExpiration`
// days.
bool IsCertExpiringSoon(const net::X509Certificate& certificate) { … }

}  // namespace

CertificateProvisioningService::Status::Status(bool is_provisioning)
    : … { … }

CertificateProvisioningService::Status::Status(const Status&) = default;
CertificateProvisioningService::Status&
CertificateProvisioningService::Status::operator=(const Status&) = default;

CertificateProvisioningService::Status::~Status() = default;

CertificateProvisioningService::~CertificateProvisioningService() = default;

class CertificateProvisioningServiceImpl
    : public CertificateProvisioningService { … };

// static
std::unique_ptr<CertificateProvisioningService>
CertificateProvisioningService::Create(
    PrefService* profile_prefs,
    CertificateStore* certificate_store,
    std::unique_ptr<ContextDelegate> context_delegate,
    std::unique_ptr<KeyUploadClient> upload_client) { … }

CertificateProvisioningServiceImpl::CertificateProvisioningServiceImpl(
    PrefService* profile_prefs,
    CertificateStore* certificate_store,
    std::unique_ptr<ContextDelegate> context_delegate,
    std::unique_ptr<KeyUploadClient> upload_client)
    : … { … }

CertificateProvisioningServiceImpl::~CertificateProvisioningServiceImpl() =
    default;

void CertificateProvisioningServiceImpl::GetManagedIdentity(
    GetManagedIdentityCallback callback) { … }

CertificateProvisioningService::Status
CertificateProvisioningServiceImpl::GetCurrentStatus() const { … }

bool CertificateProvisioningServiceImpl::IsPolicyEnabled() const { … }

bool CertificateProvisioningServiceImpl::IsProvisioning() const { … }

void CertificateProvisioningServiceImpl::OnPolicyUpdated() { … }

void CertificateProvisioningServiceImpl::OnPermanentIdentityLoaded(
    StoreErrorOr<std::optional<ClientIdentity>> expected_permanent_identity) { … }

void CertificateProvisioningServiceImpl::OnTemporaryIdentityLoaded(
    StoreErrorOr<std::optional<ClientIdentity>> expected_temporary_identity) { … }

void CertificateProvisioningServiceImpl::OnPrivateKeyCreated(
    StoreErrorOr<scoped_refptr<PrivateKey>> expected_private_key) { … }

void CertificateProvisioningServiceImpl::OnCertificateCreatedResponse(
    bool is_permanent_identity,
    scoped_refptr<PrivateKey> private_key,
    HttpCodeOrClientError upload_code,
    scoped_refptr<net::X509Certificate> certificate) { … }

void CertificateProvisioningServiceImpl::OnKeyUploadResponse(
    HttpCodeOrClientError upload_code) { … }

void CertificateProvisioningServiceImpl::OnCertificateCommitted(
    scoped_refptr<PrivateKey> private_key,
    scoped_refptr<net::X509Certificate> certificate,
    std::optional<StoreError> commit_error) { … }

void CertificateProvisioningServiceImpl::OnProvisioningError(
    ProvisioningError provisioning_error,
    std::optional<StoreError> store_error) { … }

void CertificateProvisioningServiceImpl::OnFinishedProvisioning(bool success) { … }

}  // namespace client_certificates