chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/singleton.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/chromeos/certificate_provider/certificate_provider_service.h"
  16 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  17 #include "chrome/browser/profiles/incognito_helpers.h"
  18 #include "chrome/browser/profiles/profile.h"
  19 #include "chrome/common/extensions/api/certificate_provider.h"
  20 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  21 #include "extensions/browser/event_listener_map.h"
  22 #include "extensions/browser/event_router.h"
  23 #include "extensions/browser/event_router_factory.h"
  24 #include "extensions/browser/extension_event_histogram_value.h"
  25 #include "extensions/browser/extension_registry.h"
  26 #include "extensions/browser/extension_registry_factory.h"
  27 #include "extensions/browser/extension_registry_observer.h"
  28 #include "extensions/common/extension.h"
  29 #include "net/cert/x509_certificate.h"
  30 #include "net/ssl/ssl_private_key.h"
  31
  32 namespace chromeos {
  33
  34 namespace {
  35
  36 namespace api_cp = extensions::api::certificate_provider;
  37
  38 class DefaultDelegate : public CertificateProviderService::Delegate,
  39                         public extensions::ExtensionRegistryObserver {
  40  public:
  41   DefaultDelegate(CertificateProviderService* service,
  42                   extensions::ExtensionRegistry* registry,
  43                   extensions::EventRouter* event_router);
  44   ~DefaultDelegate() override;
  45
  46   // CertificateProviderService::Delegate:
  47   std::vector<std::string> CertificateProviderExtensions() override;
  48   void BroadcastCertificateRequest(int request_id) override;
  49   bool DispatchSignRequestToExtension(
  50       const std::string& extension_id,
  51       int request_id,
  52       net::SSLPrivateKey::Hash hash,
  53       const scoped_refptr<net::X509Certificate>& certificate,
  54       const std::string& digest) override;
  55
  56   // extensions::ExtensionRegistryObserver:
  57   void OnExtensionUnloaded(
  58       content::BrowserContext* browser_context,
  59       const extensions::Extension* extension,
  60       extensions::UnloadedExtensionInfo::Reason reason) override;
  61
  62  private:
  63   CertificateProviderService* const service_;
  64   extensions::ExtensionRegistry* const registry_;
  65   extensions::EventRouter* const event_router_;
  66
  67   DISALLOW_COPY_AND_ASSIGN(DefaultDelegate);
  68 };
  69
  70 DefaultDelegate::DefaultDelegate(CertificateProviderService* service,
  71                                  extensions::ExtensionRegistry* registry,
  72                                  extensions::EventRouter* event_router)
  73     : service_(service), registry_(registry), event_router_(event_router) {
  74   DCHECK(service_);
  75   DCHECK(event_router_);
  76   registry_->AddObserver(this);
  77 }
  78
  79 DefaultDelegate::~DefaultDelegate() {
  80   registry_->RemoveObserver(this);
  81 }
  82
  83 std::vector<std::string> DefaultDelegate::CertificateProviderExtensions() {
  84   const std::string event_name(api_cp::OnCertificatesRequested::kEventName);
  85   std::vector<std::string> ids;
  86   for (const auto& listener :
  87        event_router_->listeners().GetEventListenersByName(event_name)) {
  88     ids.push_back(listener->extension_id());
  89   }
  90   return ids;
  91 }
  92
  93 void DefaultDelegate::BroadcastCertificateRequest(int request_id) {
  94   const std::string event_name(api_cp::OnCertificatesRequested::kEventName);
  95   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
  96   internal_args->AppendInteger(request_id);
  97   scoped_ptr<extensions::Event> event(new extensions::Event(
  98       extensions::events::CERTIFICATEPROVIDER_ON_CERTIFICATES_REQUESTED,
  99       event_name, internal_args.Pass()));
 100   event_router_->BroadcastEvent(event.Pass());
 101 }
 102
 103 bool DefaultDelegate::DispatchSignRequestToExtension(
 104     const std::string& extension_id,
 105     int request_id,
 106     net::SSLPrivateKey::Hash hash,
 107     const scoped_refptr<net::X509Certificate>& certificate,
 108     const std::string& digest) {
 109   const std::string event_name(api_cp::OnSignDigestRequested::kEventName);
 110   if (!event_router_->ExtensionHasEventListener(extension_id, event_name))
 111     return false;
 112
 113   api_cp::SignRequest request;
 114   switch (hash) {
 115     case net::SSLPrivateKey::Hash::MD5_SHA1:
 116       request.hash = api_cp::HASH_MD5_SHA1;
 117       break;
 118     case net::SSLPrivateKey::Hash::SHA1:
 119       request.hash = api_cp::HASH_SHA1;
 120       break;
 121     case net::SSLPrivateKey::Hash::SHA256:
 122       request.hash = api_cp::HASH_SHA256;
 123       break;
 124     case net::SSLPrivateKey::Hash::SHA384:
 125       request.hash = api_cp::HASH_SHA384;
 126       break;
 127     case net::SSLPrivateKey::Hash::SHA512:
 128       request.hash = api_cp::HASH_SHA512;
 129       break;
 130   }
 131   request.digest.assign(digest.begin(), digest.end());
 132   std::string cert_der;
 133   if (!net::X509Certificate::GetDEREncoded(certificate->os_cert_handle(),
 134                                            &cert_der)) {
 135     LOG(ERROR) << "Could not DER encode the certificate.";
 136     return false;  // Behave as if the extension wasn't registered anymore.
 137   }
 138   request.certificate.assign(cert_der.begin(), cert_der.end());
 139
 140   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
 141   internal_args->AppendInteger(request_id);
 142   internal_args->Append(request.ToValue().Pass());
 143
 144   event_router_->DispatchEventToExtension(
 145       extension_id,
 146       make_scoped_ptr(new extensions::Event(
 147           extensions::events::CERTIFICATEPROVIDER_ON_SIGN_DIGEST_REQUESTED,
 148           event_name, internal_args.Pass())));
 149   return true;
 150 }
 151
 152 void DefaultDelegate::OnExtensionUnloaded(
 153     content::BrowserContext* browser_context,
 154     const extensions::Extension* extension,
 155     extensions::UnloadedExtensionInfo::Reason reason) {
 156   service_->OnExtensionUnloaded(extension->id());
 157 }
 158
 159 }  // namespace
 160
 161 // static
 162 CertificateProviderService*
 163 CertificateProviderServiceFactory::GetForBrowserContext(
 164     content::BrowserContext* context) {
 165   return static_cast<CertificateProviderService*>(
 166       GetInstance()->GetServiceForBrowserContext(context, true));
 167 }
 168
 169 // static
 170 CertificateProviderServiceFactory*
 171 CertificateProviderServiceFactory::GetInstance() {
 172   return base::Singleton<CertificateProviderServiceFactory>::get();
 173 }
 174
 175 CertificateProviderServiceFactory::CertificateProviderServiceFactory()
 176     : BrowserContextKeyedServiceFactory(
 177           "CertificateProviderService",
 178           BrowserContextDependencyManager::GetInstance()) {
 179   DependsOn(extensions::EventRouterFactory::GetInstance());
 180   DependsOn(extensions::ExtensionRegistryFactory::GetInstance());
 181 }
 182
 183 content::BrowserContext*
 184 CertificateProviderServiceFactory::GetBrowserContextToUse(
 185     content::BrowserContext* context) const {
 186   return chrome::GetBrowserContextRedirectedInIncognito(context);
 187 }
 188
 189 bool CertificateProviderServiceFactory::ServiceIsNULLWhileTesting() const {
 190   return true;
 191 }
 192
 193 KeyedService* CertificateProviderServiceFactory::BuildServiceInstanceFor(
 194     content::BrowserContext* context) const {
 195   if (chromeos::ProfileHelper::IsSigninProfile(
 196           Profile::FromBrowserContext(context))) {
 197     return nullptr;
 198   }
 199   CertificateProviderService* const service = new CertificateProviderService();
 200   service->SetDelegate(make_scoped_ptr(new DefaultDelegate(
 201       service,
 202       extensions::ExtensionRegistryFactory::GetForBrowserContext(context),
 203       extensions::EventRouterFactory::GetForBrowserContext(context))));
 204   return service;
 205 }
 206
 207 }  // namespace chromeos