Removing x-x509-user-cert mime handler.

chrome/browser/ui/webui/options/certificate_manager_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/options/certificate_manager_handler.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/certificate_dialogs.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/crypto_module_password_dialog_nss.h"
 #include "chrome/browser/ui/webui/certificate_viewer_webui.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
+#include "net/cert/cert_database.h"
 #include "net/cert/x509_certificate.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater.h"
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater_factory.h"
 #endif
 
 using base::UTF8ToUTF16;
 using content::BrowserThread;
@@ skipping 660 matching lines @@
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   if (!args->GetBoolean(0, &use_hardware_backed_)) {
     // Unable to retrieve the hardware backed attribute from the args,
     // so bail.
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("p12"));
+  file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("crt"));
   file_type_info.extension_description_overrides.push_back(
-      l10n_util::GetStringUTF16(IDS_CERT_MANAGER_PKCS12_FILES));
+      l10n_util::GetStringUTF16(IDS_CERT_USAGE_SSL_CLIENT));
   file_type_info.include_all_files = true;
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_OPEN_FILE, base::string16(),
       base::FilePath(), &file_type_info, 1, FILE_PATH_LITERAL("p12"),

[Ryan Sleevi, 2015/10/30 23:33:47]

BUG? the FILE_PATH_LITERAL("p12")

[svaldez, 2015/11/02 16:27:38]

We're defaulting to the existing case of unknown files being parsed as p12. This
is also ignored in most systems for SelectFile dialogs.

       GetParentWindow(),
       reinterpret_cast<void*>(IMPORT_PERSONAL_FILE_SELECTED));
 }
 
 void CertificateManagerHandler::ImportPersonalFileSelected(
     const base::FilePath& path) {
   file_path_ = path;
-  web_ui()->CallJavascriptFunction(
-      "CertificateManager.importPersonalAskPassword");
+  if (file_path_.MatchesExtension(FILE_PATH_LITERAL(".p12"))) {
+    web_ui()->CallJavascriptFunction(
+        "CertificateManager.importPersonalAskPassword");

[Ryan Sleevi, 2015/10/30 23:33:46]

Blergh; this is bugged even for .p12; there's no guarantee that a .p12 will be
password protected.

[svaldez, 2015/11/02 16:27:38]

It looked like it worked correctly if you just entered a blank password
previously.

+  } else {
+    password_.clear();
+    file_access_provider_->StartRead(
+        file_path_,
+        base::Bind(&CertificateManagerHandler::ImportPersonalFileRead,
+                   base::Unretained(this)),
+        &tracker_);
+  }
 }
 
 void CertificateManagerHandler::ImportPersonalPasswordSelected(
     const base::ListValue* args) {
   if (!args->GetString(0, &password_)) {
     web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
   file_access_provider_->StartRead(
@@ skipping 11 matching lines @@
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_IMPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(IDS_CERT_MANAGER_READ_ERROR_FORMAT,
                                   UTF8ToUTF16(
                                       base::safe_strerror(*read_errno))));
     return;
   }
 
   file_data_ = *data;
 
-  if (use_hardware_backed_) {
-    module_ = certificate_manager_model_->cert_db()->GetPrivateModule();
+  if (file_path_.MatchesExtension(FILE_PATH_LITERAL(".p12"))) {

[Ryan Sleevi, 2015/10/30 23:33:47]

Again, no guarantee that .p12 == private

[svaldez, 2015/11/02 16:27:38]

Can't we assume as much since this is coming in from the user cert import
codepath, and if we fail to import the cert, then we just error out?

+    if (use_hardware_backed_) {
+      module_ = certificate_manager_model_->cert_db()->GetPrivateModule();
+    } else {
+      module_ = certificate_manager_model_->cert_db()->GetPublicModule();
+    }
+
+    net::CryptoModuleList modules;
+    modules.push_back(module_);
+    chrome::UnlockSlotsIfNecessary(
+        modules,
+        chrome::kCryptoModulePasswordCertImport,
+        net::HostPortPair(),  // unused.
+        GetParentWindow(),
+        base::Bind(&CertificateManagerHandler::ImportPersonalSlotUnlocked,
+                   base::Unretained(this)));
   } else {
-    module_ = certificate_manager_model_->cert_db()->GetPublicModule();
+    scoped_refptr<net::X509Certificate> cert =
+        net::X509Certificate::CreateFromBytes(data->c_str(), data->size());

[Ryan Sleevi, 2015/10/30 23:33:47]

BUG: Part of the goal of this change was to support multiple certificate types,
much like .p12 can. There's no guarantee that |cert| will be a singular
certificate (it could be a chain in a variety of formats)

[svaldez, 2015/11/02 16:27:37]

Done.

+
+    int cert_error =
+        net::CertDatabase::GetInstance()->CheckUserCert(cert.get());

[Ryan Sleevi, 2015/10/30 23:33:47]

net::CertDatabase is pretty awful; ideally, we'll be able to move away from it
as much as possible.

We already have a net::NSSCertDatabase (cert_db_), via the
certificate_manager_model_, ideally we should be importing certificates against
that. Even if we don't, we want the model to be responsible for this sort of
logic, I think...

There's also no (strict) need to require an associated private key.

[svaldez, 2015/11/02 16:27:38]

We'd need to modify the mozilla_security_manager to support this case, since
there currently doesn't exist an API to import a bare certificate, without also
providing the private key. Also, by spec, it looks like we are required to throw
an error on a missing private key.

+    if (cert_error == net::OK)
+      cert_error = net::CertDatabase::GetInstance()->AddUserCert(cert.get());
+
+    ImportExportCleanup();
+    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    if (cert_error != net::OK) {

[Ryan Sleevi, 2015/10/30 23:33:47]

BUG: You shouldn't assume that *any* error indicates a missing private key.
net::ERR_NO_PRIVATE_KEY_FOR_CERT is that error, but you can have other errors.

[svaldez, 2015/11/02 16:27:37]

Done.

+      ShowError(
+          l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_IMPORT_ERROR_TITLE),
+          l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_MISSING_KEY));
+    }
   }
-
-  net::CryptoModuleList modules;
-  modules.push_back(module_);
-  chrome::UnlockSlotsIfNecessary(
-      modules,
-      chrome::kCryptoModulePasswordCertImport,
-      net::HostPortPair(),  // unused.
-      GetParentWindow(),
-      base::Bind(&CertificateManagerHandler::ImportPersonalSlotUnlocked,
-                 base::Unretained(this)));
 }
 
 void CertificateManagerHandler::ImportPersonalSlotUnlocked() {
   // Determine if the private key should be unextractable after the import.
   // We do this by checking the value of |use_hardware_backed_| which is set
   // to true if importing into a hardware module. Currently, this only happens
   // for Chrome OS when the "Import and Bind" option is chosen.
   bool is_extractable = !use_hardware_backed_;
   int result = certificate_manager_model_->ImportFromPKCS12(
       module_.get(), file_data_, password_, is_extractable);
@@ skipping 368 matching lines @@
                                    title_value,
                                    error_value,
                                    cert_error_list);
 }
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options