Resolve certificate references in ONC by PEM.

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/network_constants.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
@@ skipping 625 matching lines @@
 };
 
 // Class for networks of TYPE_VPN.
 class VirtualNetwork : public Network {
  public:
   explicit VirtualNetwork(const std::string& service_path);
   virtual ~VirtualNetwork();
 
   const std::string& server_hostname() const { return server_hostname_; }
   ProviderType provider_type() const { return provider_type_; }
-  const std::string& ca_cert_nss() const { return ca_cert_nss_; }
+  const std::string& ca_cert_fingerprint() const {
+    return ca_cert_fingerprint_;
+  }
   const std::string& psk_passphrase() const { return psk_passphrase_; }
   bool psk_passphrase_required() const { return psk_passphrase_required_; }
   const std::string& client_cert_id() const { return client_cert_id_; }
   const std::string& username() const { return username_; }
   const std::string& user_passphrase() const { return user_passphrase_; }
   bool user_passphrase_required() const { return user_passphrase_required_; }
   const std::string& group_name() const { return group_name_; }
 
   // Sets the well-known PKCS#11 slot and PIN for accessing certificates.
   void SetCertificateSlotAndPin(
       const std::string& slot, const std::string& pin);
 
   // Network overrides.
   virtual bool RequiresUserProfile() const OVERRIDE;
   virtual void CopyCredentialsFromRemembered(Network* remembered) OVERRIDE;
   virtual void AttemptConnection(const base::Closure& connect) OVERRIDE;
 
   // Public getters.
   bool NeedMoreInfoToConnect() const;
   std::string GetProviderTypeString() const;
   // Returns true if a PSK passphrase is required to connect.
   bool IsPSKPassphraseRequired() const;
   // Returns true if a user passphrase is required to connect.
   bool IsUserPassphraseRequired() const;
 
   // Public setters.
-  void SetCACertNSS(const std::string& ca_cert_nss);
+  void SetCACertFingerprint(const std::string& ca_cert_fingerprint);
   void SetL2TPIPsecPSKCredentials(const std::string& psk_passphrase,
                                   const std::string& username,
                                   const std::string& user_passphrase,
                                   const std::string& group_name);
   void SetL2TPIPsecCertCredentials(const std::string& client_cert_id,
                                    const std::string& username,
                                    const std::string& user_passphrase,
                                    const std::string& group_name);
   void SetOpenVPNCredentials(const std::string& client_cert_id,
                              const std::string& username,
@@ skipping 16 matching lines @@
   // Use these functions at your peril.  They are used by the various
   // parsers to set state, and really shouldn't be used by anything else
   // because they don't do the error checking and sending to the
   // network layer that the other setters do.
   void set_server_hostname(const std::string& server_hostname) {
     server_hostname_ = server_hostname;
   }
   void set_provider_type(ProviderType provider_type) {
     provider_type_ = provider_type;
   }
-  void set_ca_cert_nss(const std::string& ca_cert_nss) {
-    ca_cert_nss_ = ca_cert_nss;
+  void set_ca_cert_fingerprint(const std::string& ca_cert_fingerprint) {
+    ca_cert_fingerprint_ = ca_cert_fingerprint;
   }
   void set_psk_passphrase(const std::string& psk_passphrase) {
     psk_passphrase_ = psk_passphrase;
   }
   void set_psk_passphrase_required(bool psk_passphrase_required) {
     psk_passphrase_required_ = psk_passphrase_required;
   }
   void set_client_cert_id(const std::string& client_cert_id) {
     client_cert_id_ = client_cert_id;
   }
@@ skipping 19 matching lines @@
 
  // Network overrides.
   virtual void EraseCredentials() OVERRIDE;
   virtual void CalculateUniqueId() OVERRIDE;
 
   // VirtualNetwork private methods.
   bool ParseProviderValue(int index, const base::Value* value);
 
   std::string server_hostname_;
   ProviderType provider_type_;
-  // NSS nickname for server CA certificate.
-  std::string ca_cert_nss_;
+  std::string ca_cert_fingerprint_;
   std::string psk_passphrase_;
   bool psk_passphrase_required_;
   // PKCS#11 ID for client certificate.
   std::string client_cert_id_;
   std::string username_;
   std::string user_passphrase_;
   bool user_passphrase_required_;
   std::string group_name_;
 
   // Weak pointer factory for wrapping pointers to this network in callbacks.
@@ skipping 212 matching lines @@
   ConnectionSecurity encryption() const { return encryption_; }
   const std::string& passphrase() const { return passphrase_; }
   const std::string& identity() const { return identity_; }
   bool passphrase_required() const { return passphrase_required_; }
   bool hidden_ssid() const { return hidden_ssid_; }
   const std::string& bssid() const { return bssid_; }
   int frequency() const { return frequency_; }
 
   EAPMethod eap_method() const { return eap_method_; }
   EAPPhase2Auth eap_phase_2_auth() const { return eap_phase_2_auth_; }
-  const std::string& eap_server_ca_cert_nss_nickname() const {
-    return eap_server_ca_cert_nss_nickname_; }
+  const std::string& eap_server_ca_cert_fingerprint() const {
+    return eap_server_ca_cert_fingerprint_; }
   const std::string& eap_client_cert_pkcs11_id() const {
     return eap_client_cert_pkcs11_id_; }
   const bool eap_use_system_cas() const { return eap_use_system_cas_; }
   const std::string& eap_identity() const { return eap_identity_; }
   const std::string& eap_anonymous_identity() const {
     return eap_anonymous_identity_;
   }
   const std::string& eap_passphrase() const { return eap_passphrase_; }
   const bool eap_save_credentials() const { return eap_save_credentials_; }
 
   const std::string& GetPassphrase() const;
 
   // Set property and call SetNetworkServiceProperty:
 
   void SetPassphrase(const std::string& passphrase);
   void SetIdentity(const std::string& identity);
   void SetHiddenSSID(bool hidden_ssid);
 
   // 802.1x properties
   void SetEAPMethod(EAPMethod method);
   void SetEAPPhase2Auth(EAPPhase2Auth auth);
-  void SetEAPServerCaCertNssNickname(const std::string& nss_nickname);
+  void SetEAPServerCaCertFingerprint(const std::string& ca_cert_fingerprint);
   void SetEAPClientCertPkcs11Id(const std::string& pkcs11_id);
   void SetEAPUseSystemCAs(bool use_system_cas);
   void SetEAPIdentity(const std::string& identity);
   void SetEAPAnonymousIdentity(const std::string& identity);
   void SetEAPPassphrase(const std::string& passphrase);
 
   // Sets the well-known PKCS#11 PIN for accessing certificates.
   void SetCertificatePin(const std::string& pin);
 
   // Network overrides.
@@ skipping 40 matching lines @@
   }
   void set_hidden_ssid(bool hidden_ssid) {
     hidden_ssid_ = hidden_ssid;
   }
   void set_bssid(const std::string& bssid) { bssid_ = bssid; }
   void set_frequency(int frequency) { frequency_ = frequency; }
   void set_eap_method(EAPMethod eap_method) { eap_method_ = eap_method; }
   void set_eap_phase_2_auth(EAPPhase2Auth eap_phase_2_auth) {
     eap_phase_2_auth_ = eap_phase_2_auth;
   }
-  void set_eap_server_ca_cert_nss_nickname(
-      const std::string& eap_server_ca_cert_nss_nickname) {
-    eap_server_ca_cert_nss_nickname_ = eap_server_ca_cert_nss_nickname;
+  void set_eap_server_ca_cert_fingerprint(
+      const std::string& eap_server_ca_cert_fingerprint) {
+    eap_server_ca_cert_fingerprint_ = eap_server_ca_cert_fingerprint;
   }
   void set_eap_client_cert_pkcs11_id(
       const std::string& eap_client_cert_pkcs11_id) {
     eap_client_cert_pkcs11_id_ = eap_client_cert_pkcs11_id;
   }
   void set_eap_use_system_cas(bool eap_use_system_cas) {
     eap_use_system_cas_ = eap_use_system_cas;
   }
   void set_eap_identity(const std::string& eap_identity) {
     eap_identity_ = eap_identity;
@@ skipping 24 matching lines @@
   ConnectionSecurity encryption_;
   std::string passphrase_;
   bool passphrase_required_;
   std::string identity_;
   bool hidden_ssid_;
   std::string bssid_;
   int frequency_;
 
   EAPMethod eap_method_;
   EAPPhase2Auth eap_phase_2_auth_;
-  std::string eap_server_ca_cert_nss_nickname_;
+  std::string eap_server_ca_cert_fingerprint_;
   std::string eap_client_cert_pkcs11_id_;
   bool eap_use_system_cas_;
   std::string eap_identity_;
   std::string eap_anonymous_identity_;
   std::string eap_passphrase_;
   bool eap_save_credentials_;
 
   // Internal state (not stored in shill).
   // Passphrase set by user (stored for UI).
   std::string user_passphrase_;
@@ skipping 417 matching lines @@
   virtual void ConnectToVirtualNetwork(VirtualNetwork* network) = 0;
 
   // Connect to an unconfigured network with given SSID, security, passphrase,
   // and optional EAP configuration. If |security| is SECURITY_8021X,
   // |eap_config| must be provided.
   struct EAPConfigData {
     EAPConfigData();
     ~EAPConfigData();
     EAPMethod method;
     EAPPhase2Auth auth;
-    std::string server_ca_cert_nss_nickname;
+    std::string server_ca_cert_fingerprint;
     bool use_system_cas;
     std::string client_cert_pkcs11_id;
     std::string identity;
     std::string anonymous_identity;
   };
   virtual void ConnectToUnconfiguredWifiNetwork(
       const std::string& ssid,
       ConnectionSecurity security,
       const std::string& passphrase,
       const EAPConfigData* eap_config,
       bool save_credentials,
       bool shared) = 0;
 
   // Connect to the specified virtual network with service name.
   // VPNConfigData must be provided.
   struct VPNConfigData {
     VPNConfigData();
     ~VPNConfigData();
     std::string psk;
-    std::string server_ca_cert_nss_nickname;
+    std::string server_ca_cert_fingerprint;
     std::string client_cert_pkcs11_id;
     std::string username;
     std::string user_passphrase;
     std::string otp;
     std::string group_name;
     bool save_credentials;
   };
   virtual void ConnectToUnconfiguredVirtualNetwork(
       const std::string& service_name,
       const std::string& server_hostname,
@@ skipping 61 matching lines @@
   virtual void RequestNetworkServiceProperties(
       const std::string& service_path,
       const NetworkServicePropertiesCallback& callback) = 0;
 
   // This will connect to a preferred network if the currently connected
   // network is not preferred. This should be called when the active profile
   // changes.
   virtual void SwitchToPreferredNetwork() = 0;
 
   // Load networks from an NetworkConfigurations list of ONC.
-  virtual void LoadOncNetworks(const base::ListValue& network_configs,
-                               onc::ONCSource source) = 0;
+  virtual void LoadOncNetworks(
+      const base::ListValue& network_configs,
+      onc::ONCSource source,
+      const base::Callback<std::string(const std::string&)>&
+          fingerprint_to_pem) = 0;
 
   // This sets the active network for the network type. Note: priority order
   // is unchanged (i.e. if a wifi network is set to active, but an ethernet
   // network is still active, active_network() will still return the ethernet
   // network). Other networks of the same type will become inactive.
   // Used for testing.
   virtual bool SetActiveNetwork(ConnectionType type,
                                 const std::string& service_path) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_