Introduce networkingPrivate.getCertificateLists

extensions/browser/api/networking_private/networking_private_chromeos.cc

 // Copyright 2014 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 "extensions/browser/api/networking_private/networking_private_chromeos.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_activation_handler.h"
+#include "chromeos/network/network_certificate_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "chromeos/network/proxy/ui_proxy_config.h"
 #include "chromeos/network/proxy/ui_proxy_config_service.h"
 #include "components/onc/onc_constants.h"
 #include "components/proxy_config/proxy_prefs.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using chromeos::NetworkHandler;
+using chromeos::NetworkCertificateHandler;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using chromeos::UIProxyConfig;
 using extensions::NetworkingPrivateDelegate;
 
 namespace private_api = extensions::api::networking_private;
 
 namespace {
 
@@ skipping 236 matching lines @@
       EnsureDictionaryValue(::onc::proxy::kHost, dict);
   SetProxyEffectiveValue(
       host_dict, state,
       base::MakeUnique<base::Value>(proxy.server.host_port_pair().host()));
   uint16_t port = proxy.server.host_port_pair().port();
   base::DictionaryValue* port_dict =
       EnsureDictionaryValue(::onc::proxy::kPort, dict);
   SetProxyEffectiveValue(port_dict, state, base::MakeUnique<base::Value>(port));
 }
 
+private_api::Certificate GetCertDictionary(
+    const NetworkCertificateHandler::Certificate& cert) {
+  private_api::Certificate api_cert;
+  api_cert.hash = cert.hash;
+  api_cert.issued_by = cert.issued_by;
+  api_cert.issued_to = cert.issued_to;
+  api_cert.hardware_backed = cert.hardware_backed;
+  if (!cert.pem.empty())
+    api_cert.pem = base::MakeUnique<std::string>(cert.pem);
+  if (!cert.pkcs11_id.empty())
+    api_cert.pkcs11_id = base::MakeUnique<std::string>(cert.pkcs11_id);
+  return api_cert;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context), weak_ptr_factory_(this) {}
 
@@ skipping 427 matching lines @@
 NetworkingPrivateChromeOS::GetGlobalPolicy() {
   auto result = base::MakeUnique<base::DictionaryValue>();
   const base::DictionaryValue* global_network_config =
       GetManagedConfigurationHandler()->GetGlobalConfigFromPolicy(
           std::string() /* no username hash, device policy */);
   if (global_network_config)
     result->MergeDictionary(global_network_config);
   return result;
 }
 
+std::unique_ptr<base::DictionaryValue>
+NetworkingPrivateChromeOS::GetCertificateLists() {
+  private_api::CertificateLists result;
+  const std::vector<NetworkCertificateHandler::Certificate>& server_cas =
+      NetworkHandler::Get()
+          ->network_certificate_handler()
+          ->server_ca_certificates();
+  for (const auto& cert : server_cas)
+    result.server_ca_certificates.push_back(GetCertDictionary(cert));
+
+  std::vector<private_api::Certificate> user_cert_list;
+  const std::vector<NetworkCertificateHandler::Certificate>& user_certs =
+      NetworkHandler::Get()->network_certificate_handler()->user_certificates();
+  for (const auto& cert : user_certs)
+    result.user_certificates.push_back(GetCertDictionary(cert));
+
+  return result.ToValue();
+}
+
 bool NetworkingPrivateChromeOS::EnableNetworkType(const std::string& type) {
   NetworkTypePattern pattern =
       chromeos::onc::NetworkTypePatternFromOncType(type);
 
   GetStateHandler()->SetTechnologyEnabled(
       pattern, true, chromeos::network_handler::ErrorCallback());
 
   return true;
 }
 
@@ skipping 121 matching lines @@
     }
     case UIProxyConfig::MODE_DIRECT:
     case UIProxyConfig::MODE_AUTO_DETECT:
       break;
   }
 
   VLOG(2) << " NEW PROXY: " << *proxy_settings;
 }
 
 }  // namespace extensions