chromeos/cert_loader.cc

   1 // Copyright (c) 2013 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 "chromeos/cert_loader.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/location.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/task_runner_util.h"
  14 #include "base/threading/worker_pool.h"
  15 #include "crypto/nss_util.h"
  16 #include "crypto/scoped_nss_types.h"
  17 #include "net/cert/nss_cert_database.h"
  18 #include "net/cert/nss_cert_database_chromeos.h"
  19 #include "net/cert/x509_certificate.h"
  20
  21 namespace chromeos {
  22
  23 static CertLoader* g_cert_loader = NULL;
  24 static bool g_force_hardware_backed_for_test = false;
  25
  26 // static
  27 void CertLoader::Initialize() {
  28   CHECK(!g_cert_loader);
  29   g_cert_loader = new CertLoader();
  30 }
  31
  32 // static
  33 void CertLoader::Shutdown() {
  34   CHECK(g_cert_loader);
  35   delete g_cert_loader;
  36   g_cert_loader = NULL;
  37 }
  38
  39 // static
  40 CertLoader* CertLoader::Get() {
  41   CHECK(g_cert_loader) << "CertLoader::Get() called before Initialize()";
  42   return g_cert_loader;
  43 }
  44
  45 // static
  46 bool CertLoader::IsInitialized() {
  47   return g_cert_loader;
  48 }
  49
  50 CertLoader::CertLoader()
  51     : certificates_loaded_(false),
  52       certificates_update_required_(false),
  53       certificates_update_running_(false),
  54       database_(NULL),
  55       cert_list_(new net::CertificateList),
  56       weak_factory_(this) {
  57 }
  58
  59 CertLoader::~CertLoader() {
  60   net::CertDatabase::GetInstance()->RemoveObserver(this);
  61 }
  62
  63 void CertLoader::StartWithNSSDB(net::NSSCertDatabase* database) {
  64   CHECK(!database_);
  65   database_ = database;
  66
  67   // Start observing cert database for changes.
  68   // Observing net::CertDatabase is preferred over observing |database_|
  69   // directly, as |database_| observers receive only events generated directly
  70   // by |database_|, so they may miss a few relevant ones.
  71   // TODO(tbarzic): Once singleton NSSCertDatabase is removed, investigate if
  72   // it would be OK to observe |database_| directly; or change NSSCertDatabase
  73   // to send notification on all relevant changes.
  74   net::CertDatabase::GetInstance()->AddObserver(this);
  75
  76   LoadCertificates();
  77 }
  78
  79 void CertLoader::AddObserver(CertLoader::Observer* observer) {
  80   observers_.AddObserver(observer);
  81 }
  82
  83 void CertLoader::RemoveObserver(CertLoader::Observer* observer) {
  84   observers_.RemoveObserver(observer);
  85 }
  86
  87 // static
  88 bool CertLoader::IsCertificateHardwareBacked(const net::X509Certificate* cert) {
  89   if (g_force_hardware_backed_for_test)
  90     return true;
  91   PK11SlotInfo* slot = cert->os_cert_handle()->slot;
  92   return slot && PK11_IsHW(slot);
  93 }
  94
  95 bool CertLoader::CertificatesLoading() const {
  96   return database_ && !certificates_loaded_;
  97 }
  98
  99 // static
 100 void CertLoader::ForceHardwareBackedForTesting() {
 101   g_force_hardware_backed_for_test = true;
 102 }
 103
 104 // static
 105 //
 106 // For background see this discussion on dev-tech-crypto.lists.mozilla.org:
 107 // http://web.archiveorange.com/archive/v/6JJW7E40sypfZGtbkzxX
 108 //
 109 // NOTE: This function relies on the convention that the same PKCS#11 ID
 110 // is shared between a certificate and its associated private and public
 111 // keys.  I tried to implement this with PK11_GetLowLevelKeyIDForCert(),
 112 // but that always returns NULL on Chrome OS for me.
 113 std::string CertLoader::GetPkcs11IdAndSlotForCert(
 114     const net::X509Certificate& cert,
 115     int* slot_id) {
 116   DCHECK(slot_id);
 117
 118   CERTCertificateStr* cert_handle = cert.os_cert_handle();
 119   SECKEYPrivateKey *priv_key =
 120       PK11_FindKeyByAnyCert(cert_handle, NULL /* wincx */);
 121   if (!priv_key)
 122     return std::string();
 123
 124   *slot_id = static_cast<int>(PK11_GetSlotID(priv_key->pkcs11Slot));
 125
 126   // Get the CKA_ID attribute for a key.
 127   SECItem* sec_item = PK11_GetLowLevelKeyIDForPrivateKey(priv_key);
 128   std::string pkcs11_id;
 129   if (sec_item) {
 130     pkcs11_id = base::HexEncode(sec_item->data, sec_item->len);
 131     SECITEM_FreeItem(sec_item, PR_TRUE);
 132   }
 133   SECKEY_DestroyPrivateKey(priv_key);
 134
 135   return pkcs11_id;
 136 }
 137
 138 void CertLoader::LoadCertificates() {
 139   CHECK(thread_checker_.CalledOnValidThread());
 140   VLOG(1) << "LoadCertificates: " << certificates_update_running_;
 141
 142   if (certificates_update_running_) {
 143     certificates_update_required_ = true;
 144     return;
 145   }
 146
 147   certificates_update_running_ = true;
 148   certificates_update_required_ = false;
 149
 150   database_->ListCerts(
 151       base::Bind(&CertLoader::UpdateCertificates, weak_factory_.GetWeakPtr()));
 152 }
 153
 154 void CertLoader::UpdateCertificates(
 155     scoped_ptr<net::CertificateList> cert_list) {
 156   CHECK(thread_checker_.CalledOnValidThread());
 157   DCHECK(certificates_update_running_);
 158   VLOG(1) << "UpdateCertificates: " << cert_list->size();
 159
 160   // Ignore any existing certificates.
 161   cert_list_ = cert_list.Pass();
 162
 163   bool initial_load = !certificates_loaded_;
 164   certificates_loaded_ = true;
 165   NotifyCertificatesLoaded(initial_load);
 166
 167   certificates_update_running_ = false;
 168   if (certificates_update_required_)
 169     LoadCertificates();
 170 }
 171
 172 void CertLoader::NotifyCertificatesLoaded(bool initial_load) {
 173   FOR_EACH_OBSERVER(Observer, observers_,
 174                     OnCertificatesLoaded(*cert_list_, initial_load));
 175 }
 176
 177 void CertLoader::OnCACertChanged(const net::X509Certificate* cert) {
 178   // This is triggered when a CA certificate is modified.
 179   VLOG(1) << "OnCACertChanged";
 180   LoadCertificates();
 181 }
 182
 183 void CertLoader::OnCertAdded(const net::X509Certificate* cert) {
 184   // This is triggered when a client certificate is added.
 185   VLOG(1) << "OnCertAdded";
 186   LoadCertificates();
 187 }
 188
 189 void CertLoader::OnCertRemoved(const net::X509Certificate* cert) {
 190   VLOG(1) << "OnCertRemoved";
 191   LoadCertificates();
 192 }
 193
 194 }  // namespace chromeos