Home | History | Annotate | Download | only in browser 
      1 // Copyright (c) 2012 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/certificate_manager_model.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/i18n/time_formatting.h"
      9 #include "base/logging.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "chrome/browser/ui/crypto_module_password_dialog.h"
     12 #include "chrome/common/net/x509_certificate_model.h"
     13 #include "net/base/crypto_module.h"
     14 #include "net/base/net_errors.h"
     15 #include "net/cert/x509_certificate.h"
     16 
     17 #if defined(OS_CHROMEOS)
     18 #include <cert.h>
     19 
     20 #include "crypto/nss_util.h"
     21 #include "grit/generated_resources.h"
     22 #include "ui/base/l10n/l10n_util.h"
     23 #endif
     24 
     25 CertificateManagerModel::CertificateManagerModel(Observer* observer)
     26     : cert_db_(net::NSSCertDatabase::GetInstance()),
     27       observer_(observer) {
     28 }
     29 
     30 CertificateManagerModel::~CertificateManagerModel() {
     31 }
     32 
     33 void CertificateManagerModel::Refresh() {
     34   VLOG(1) << "refresh started";
     35   net::CryptoModuleList modules;
     36   cert_db_->ListModules(&modules, false);
     37   VLOG(1) << "refresh waiting for unlocking...";
     38   chrome::UnlockSlotsIfNecessary(
     39       modules,
     40       chrome::kCryptoModulePasswordListCerts,
     41       std::string(),  // unused.
     42       base::Bind(&CertificateManagerModel::RefreshSlotsUnlocked,
     43                  base::Unretained(this)));
     44 }
     45 
     46 void CertificateManagerModel::RefreshSlotsUnlocked() {
     47   VLOG(1) << "refresh listing certs...";
     48   cert_db_->ListCerts(&cert_list_);
     49   observer_->CertificatesRefreshed();
     50   VLOG(1) << "refresh finished";
     51 }
     52 
     53 void CertificateManagerModel::FilterAndBuildOrgGroupingMap(
     54     net::CertType filter_type,
     55     CertificateManagerModel::OrgGroupingMap* map) const {
     56   for (net::CertificateList::const_iterator i = cert_list_.begin();
     57        i != cert_list_.end(); ++i) {
     58     net::X509Certificate* cert = i->get();
     59     net::CertType type =
     60         x509_certificate_model::GetType(cert->os_cert_handle());
     61     if (type != filter_type)
     62       continue;
     63 
     64     std::string org;
     65     if (!cert->subject().organization_names.empty())
     66       org = cert->subject().organization_names[0];
     67     if (org.empty())
     68       org = cert->subject().GetDisplayName();
     69 
     70     (*map)[org].push_back(cert);
     71   }
     72 }
     73 
     74 string16 CertificateManagerModel::GetColumnText(
     75     const net::X509Certificate& cert,
     76     Column column) const {
     77   string16 rv;
     78   switch (column) {
     79     case COL_SUBJECT_NAME:
     80       rv = UTF8ToUTF16(
     81           x509_certificate_model::GetCertNameOrNickname(cert.os_cert_handle()));
     82 
     83 #if defined(OS_CHROMEOS)
     84       // TODO(xiyuan): Put this into a column when we have js tree-table.
     85       if (IsHardwareBacked(&cert)) {
     86         rv = l10n_util::GetStringFUTF16(
     87             IDS_CERT_MANAGER_HARDWARE_BACKED_KEY_FORMAT,
     88             rv,
     89             l10n_util::GetStringUTF16(IDS_CERT_MANAGER_HARDWARE_BACKED));
     90       }
     91 #endif
     92       break;
     93     case COL_CERTIFICATE_STORE:
     94       rv = UTF8ToUTF16(
     95           x509_certificate_model::GetTokenName(cert.os_cert_handle()));
     96       break;
     97     case COL_SERIAL_NUMBER:
     98       rv = ASCIIToUTF16(x509_certificate_model::GetSerialNumberHexified(
     99           cert.os_cert_handle(), std::string()));
    100       break;
    101     case COL_EXPIRES_ON:
    102       if (!cert.valid_expiry().is_null())
    103         rv = base::TimeFormatShortDateNumeric(cert.valid_expiry());
    104       break;
    105     default:
    106       NOTREACHED();
    107   }
    108   return rv;
    109 }
    110 
    111 int CertificateManagerModel::ImportFromPKCS12(net::CryptoModule* module,
    112                                               const std::string& data,
    113                                               const string16& password,
    114                                               bool is_extractable) {
    115   int result = cert_db_->ImportFromPKCS12(module, data, password,
    116                                           is_extractable, NULL);
    117   if (result == net::OK)
    118     Refresh();
    119   return result;
    120 }
    121 
    122 bool CertificateManagerModel::ImportCACerts(
    123     const net::CertificateList& certificates,
    124     net::NSSCertDatabase::TrustBits trust_bits,
    125     net::NSSCertDatabase::ImportCertFailureList* not_imported) {
    126   bool result = cert_db_->ImportCACerts(certificates, trust_bits, not_imported);
    127   if (result && not_imported->size() != certificates.size())
    128     Refresh();
    129   return result;
    130 }
    131 
    132 bool CertificateManagerModel::ImportServerCert(
    133     const net::CertificateList& certificates,
    134     net::NSSCertDatabase::TrustBits trust_bits,
    135     net::NSSCertDatabase::ImportCertFailureList* not_imported) {
    136   bool result = cert_db_->ImportServerCert(certificates, trust_bits,
    137                                            not_imported);
    138   if (result && not_imported->size() != certificates.size())
    139     Refresh();
    140   return result;
    141 }
    142 
    143 bool CertificateManagerModel::SetCertTrust(
    144     const net::X509Certificate* cert,
    145     net::CertType type,
    146     net::NSSCertDatabase::TrustBits trust_bits) {
    147   return cert_db_->SetCertTrust(cert, type, trust_bits);
    148 }
    149 
    150 bool CertificateManagerModel::Delete(net::X509Certificate* cert) {
    151   bool result = cert_db_->DeleteCertAndKey(cert);
    152   if (result)
    153     Refresh();
    154   return result;
    155 }
    156 
    157 bool CertificateManagerModel::IsHardwareBacked(
    158     const net::X509Certificate* cert) const {
    159 #if defined(OS_CHROMEOS)
    160   return crypto::IsTPMTokenReady() &&
    161          cert->os_cert_handle()->slot ==
    162              cert_db_->GetPrivateModule()->os_module_handle();
    163 #else
    164   return false;
    165 #endif
    166 }
    167