This adds support for encrypted ONC import

chrome/browser/chromeos/cros/onc_network_parser_unittest.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/chromeos/cros/onc_network_parser.h"
 
 #include <cert.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 
@@ skipping 451 matching lines @@
       "  \"NetworkConfigurations\": [{"
       "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
       "    \"Type\": \"WiFi\","
       "    \"WiFi\": {"
       "      \"Security\": \"WEP-PSK\","
       "      \"SSID\": \"ssid\","
       "      \"Passphrase\": \"pass\","
       "    }"
       "  }]"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   EXPECT_EQ(0, parser.GetCertificatesSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(network->type(), chromeos::TYPE_WIFI);
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(wifi->encryption(), chromeos::SECURITY_WEP);
   CheckStringProperty(wifi, PROPERTY_INDEX_SECURITY, flimflam::kSecurityWep);
   EXPECT_EQ(wifi->name(), "ssid");
   CheckStringProperty(wifi, PROPERTY_INDEX_SSID, "ssid");
   EXPECT_EQ(wifi->auto_connect(), false);
   EXPECT_EQ(wifi->passphrase(), "pass");
   CheckStringProperty(wifi, PROPERTY_INDEX_PASSPHRASE, "pass");
 }
 
+TEST_F(OncNetworkParserTest, TestLoadEncryptedOnc) {
+  std::string test_blob(
+      "{"
+      "  \"Cipher\": \"AES256\","
+      "  \"Ciphertext\": \"eQ9/r6v29/83M745aa0JllEj4lklt3Nfy4kPPvXgjBt1eTBy"
+      "xXB+FnsdvL6Uca5JBU5aROxfiol2+ZZOkxPmUNNIFZj70pkdqOGVe09ncf0aVBDsAa27"
+      "veGIG8rG/VQTTbAo7d8QaxdNNbZvwQVkdsAXawzPCu7zSh4NF/hDnDbYjbN/JEm1NzvW"
+      "gEjeOfqnnw3PnGUYCArIaRsKq9uD0a1NccU+16ZSzyDhX724JNrJjsuxohotk5YXsCK0"
+      "lP7ZXuXj+nSR0aRIETSQ+eqGhrew2octLXq8cXK05s6ZuVAc0mFKPkntSI/fzBACuPi4"
+      "ZaGd3YEYiKzNOgKJ+qEwgoE39xp0EXMZOZyjMOAtA6e1ZZDQGWG7vKdTLmLKNztHGrXv"
+      "lZkyEf1RDs10YgkwwLgUhm0yBJ+eqbxO/RiBXz7O2/UVOkkkVcmeI6yh3BdL6HIYsMMy"
+      "gnZa5WRkd/2/EudoqEnjcqUyGsL+YUqV6KRTC0PH+z7zSwvFs2KygrSM7SIAZM2yiQHT"
+      "QACkA/YCJDwACkkQOBFnRWTWiX0xmN55WMbgrs/wqJ4zGC9LgdAInOBlc3P+76+i7QLa"
+      "NjMovQ==\","
+      "  \"HMAC\": \"3ylRy5InlhVzFGakJ/9lvGSyVH0=\","
+      "  \"HMACMethod\": \"SHA1\","
+      "  \"IV\": \"hcm6OENfqG6C/TVO6p5a8g==\","
+      "  \"Iterations\": 20000,"
+      "  \"Salt\": \"/3O73QadCzA=\","
+      "  \"Stretch\": \"PBKDF2\","
+      "  \"Type\": \"EncryptedConfiguration\""
+      "}");
+  OncNetworkParser parser(test_blob,
+                          "test0000",
+                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  ASSERT_TRUE(parser.parse_error().empty());
+  EXPECT_EQ(1, parser.GetNetworkConfigsSize());
+  EXPECT_EQ(0, parser.GetCertificatesSize());
+  scoped_ptr<Network> network(parser.ParseNetwork(0));
+  ASSERT_TRUE(network.get());
+
+  EXPECT_EQ(network->type(), chromeos::TYPE_WIFI);
+  WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
+  EXPECT_EQ(wifi->encryption(), chromeos::SECURITY_NONE);
+  EXPECT_EQ(wifi->name(), "WirelessNetwork");
+  EXPECT_EQ(wifi->auto_connect(), false);
+  EXPECT_EQ(wifi->passphrase(), "");
+}
+
+
 TEST_F(OncNetworkParserTest, TestCreateNetworkWifiEAP1) {
   std::string test_blob(
       "{"
       "  \"NetworkConfigurations\": [{"
       "    \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5045}\","
       "    \"Type\": \"WiFi\","
       "    \"WiFi\": {"
       "      \"Security\": \"WPA-EAP\","
       "      \"SSID\": \"ssid\","
       "      \"AutoConnect\": true,"
       "      \"EAP\": {"
       "        \"Outer\": \"PEAP\","
       "        \"UseSystemCAs\": false,"
       "      }"
       "    }"
       "  }]"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   EXPECT_EQ(0, parser.GetCertificatesSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(network->type(), chromeos::TYPE_WIFI);
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(wifi->encryption(), chromeos::SECURITY_8021X);
   CheckStringProperty(wifi, PROPERTY_INDEX_SECURITY, flimflam::kSecurity8021x);
@@ skipping 18 matching lines @@
       "      \"AutoConnect\": false,"
       "      \"EAP\": {"
       "        \"Outer\": \"LEAP\","
       "        \"Identity\": \"user\","
       "        \"Password\": \"pass\","
       "        \"AnonymousIdentity\": \"anon\","
       "      }"
       "    }"
       "  }]"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   EXPECT_EQ(0, parser.GetCertificatesSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(network->type(), chromeos::TYPE_WIFI);
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(wifi->encryption(), chromeos::SECURITY_8021X);
   EXPECT_EQ(wifi->name(), "ssid");
@@ skipping 18 matching lines @@
       "      \"Security\": \"WEP-PSK\","
       "      \"SSID\": \"ssid\","
       "      \"Passphrase\": \"pass\","
       "    },"
       "    \"UnknownField1\": \"Value1\","
       "    \"UnknownField2\": {"
       "      \"UnknownSubField\": \"Value2\""
       "    },"
       "  }]"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get());
 
   EXPECT_EQ(network->type(), chromeos::TYPE_WIFI);
   WifiNetwork* wifi = static_cast<WifiNetwork*>(network.get());
   EXPECT_EQ(wifi->encryption(), chromeos::SECURITY_WEP);
   EXPECT_EQ(wifi->name(), "ssid");
   EXPECT_EQ(wifi->passphrase(), "pass");
 }
 
 TEST_F(OncNetworkParserTest, TestCreateNetworkOpenVPN) {
   std::string test_blob(std::string(
       "{"
       "  \"NetworkConfigurations\": [") +
       std::string(kNetworkConfigurationOpenVPN) + std::string(
       "  ]}"));
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   EXPECT_EQ(0, parser.GetCertificatesSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get() != NULL);
 
   EXPECT_EQ(network->type(), chromeos::TYPE_VPN);
   CheckStringProperty(network.get(), PROPERTY_INDEX_TYPE, flimflam::kTypeVPN);
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ("MyVPN", vpn->name());
@@ skipping 58 matching lines @@
       "          \"PSK\": \"passphrase\""
       "        },"
       "        \"L2TP\": {"
       "          \"SaveCredentials\": false"
       "        }"
       "      }"
       "    }"
       "  ],"
       "  \"Certificates\": []"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   EXPECT_EQ(0, parser.GetCertificatesSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network != NULL);
 
   EXPECT_EQ(network->type(), chromeos::TYPE_VPN);
   CheckStringProperty(network.get(), PROPERTY_INDEX_TYPE, flimflam::kTypeVPN);
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ("MyL2TPVPN", vpn->name());
@@ skipping 10 matching lines @@
 }
 
 TEST_F(OncNetworkParserTest, TestAddClientCertificate) {
   std::string certificate_json(
       "{"
       "    \"Certificates\": ["
       + std::string(kCertificateClient) +
       "    ],"
       "}");
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697ac}");
-  OncNetworkParser parser(certificate_json,
+  OncNetworkParser parser(certificate_json, "",
                           NetworkUIData::ONC_SOURCE_USER_IMPORT);
   ASSERT_EQ(1, parser.GetCertificatesSize());
 
   scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
   EXPECT_TRUE(cert.get() != NULL);
   EXPECT_EQ(net::USER_CERT, GetCertType(cert.get()));
 
   EXPECT_STREQ(test_guid.c_str(),
                cert->GetDefaultNickname(net::USER_CERT).c_str());
   net::CertificateList result_list;
@@ skipping 44 matching lines @@
   std::string certificate_alternate_json(
       "{"
       "    \"Certificates\": ["
       + std::string(kCertificateClientAlternate) +
       "    ],"
       "}");
 
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697ac}");
   {
     // First we import a certificate.
-    OncNetworkParser parser(certificate_json,
+    OncNetworkParser parser(certificate_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
 
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
     EXPECT_EQ(net::USER_CERT, GetCertType(cert.get()));
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::USER_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::USER_CERT, GetCertType(result_list[0].get()));
   }
 
   {
     // Now we import a new certificate with the same GUID as the
     // first.  It should replace the old one.
-    OncNetworkParser parser(certificate_alternate_json,
+    OncNetworkParser parser(certificate_alternate_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::USER_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::USER_CERT, GetCertType(result_list[0].get()));
   }}
 
 TEST_F(OncNetworkParserTest, TestAddServerCertificate) {
   std::string test_blob(
       "{"
       "    \"Certificates\": ["
       + std::string(kCertificateServer) +
       "    ],"
       "}");
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697aa}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
   ASSERT_EQ(1, parser.GetCertificatesSize());
 
   scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
   EXPECT_TRUE(cert.get() != NULL);
   EXPECT_EQ(net::SERVER_CERT, GetCertType(cert.get()));
 
   EXPECT_STREQ(test_guid.c_str(),
                cert->GetDefaultNickname(net::SERVER_CERT).c_str());
   net::CertificateList result_list;
   OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
@@ skipping 20 matching lines @@
 
   std::string certificate_alternate_json(
       "{"
       "    \"Certificates\": ["
       + std::string(kCertificateServerAlternate) +
       "    ],"
       "}");
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697aa}");
   {
     // First we import a certificate.
-    OncNetworkParser parser(certificate_json,
+    OncNetworkParser parser(certificate_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
 
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
     EXPECT_EQ(net::SERVER_CERT, GetCertType(cert.get()));
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::SERVER_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::SERVER_CERT, GetCertType(result_list[0].get()));
   }
 
   {
     // Now we import a new certificate with the same GUID as the
     // first.  It should replace the old one.
-    OncNetworkParser parser(certificate_alternate_json,
+    OncNetworkParser parser(certificate_alternate_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::SERVER_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::SERVER_CERT, GetCertType(result_list[0].get()));
   }
 }
 
 
 TEST_F(OncNetworkParserTest, TestAddAuthorityCertificate) {
   const std::string test_blob("{"
       "    \"Certificates\": [" +
       std::string(kCertificateWebAuthority) +
       "    ],"
       "}");
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697ab}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "", NetworkUIData::ONC_SOURCE_USER_IMPORT);
   ASSERT_EQ(1, parser.GetCertificatesSize());
 
   scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
   EXPECT_TRUE(cert.get() != NULL);
   EXPECT_EQ(net::CA_CERT, GetCertType(cert.get()));
 
   EXPECT_STREQ(test_guid.c_str(),
                cert->GetDefaultNickname(net::CA_CERT).c_str());
   net::CertificateList result_list;
   OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
@@ skipping 19 matching lines @@
   std::string authority_alternate_json(
       "{"
       "  \"Certificates\": [" +
       std::string(kCertificateWebAuthorityAlternate) +
       "  ]"
       "}");
   std::string test_guid("{f998f760-272b-6939-4c2beffe428697ab}");
 
   {
     // First we import an authority certificate.
-    OncNetworkParser parser(authority_json,
+    OncNetworkParser parser(authority_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
 
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
     EXPECT_EQ(net::CA_CERT, GetCertType(cert.get()));
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::CA_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::CA_CERT, GetCertType(result_list[0].get()));
   }
 
   {
     // Now we import a new authority certificate with the same GUID as the
     // first.  It should replace the old one.
-    OncNetworkParser parser(authority_alternate_json,
+    OncNetworkParser parser(authority_alternate_json, "",
                             NetworkUIData::ONC_SOURCE_USER_IMPORT);
     ASSERT_EQ(1, parser.GetCertificatesSize());
     scoped_refptr<net::X509Certificate> cert = parser.ParseCertificate(0).get();
     ASSERT_TRUE(cert.get() != NULL);
 
     EXPECT_STREQ(test_guid.c_str(),
                  cert->GetDefaultNickname(net::CA_CERT).c_str());
     net::CertificateList result_list;
     OncNetworkParser::ListCertsWithNickname(test_guid, &result_list);
     ASSERT_EQ(1ul, result_list.size());
     EXPECT_EQ(net::CA_CERT, GetCertType(result_list[0].get()));
   }
 }
 
 TEST_F(OncNetworkParserTest, TestNetworkAndCertificate) {
   std::string test_blob(
       "{"
       "  \"NetworkConfigurations\": [" +
       std::string(kNetworkConfigurationOpenVPN) +
       "  ],"
       "  \"Certificates\": [" +
       std::string(kCertificateWebAuthority) +
       "  ],"
       "}");
-  OncNetworkParser parser(test_blob, NetworkUIData::ONC_SOURCE_USER_IMPORT);
+  OncNetworkParser parser(test_blob, "",
+                          NetworkUIData::ONC_SOURCE_USER_IMPORT);
 
   EXPECT_EQ(1, parser.GetCertificatesSize());
   EXPECT_TRUE(parser.ParseCertificate(0));
 
   EXPECT_EQ(1, parser.GetNetworkConfigsSize());
   scoped_ptr<Network> network(parser.ParseNetwork(0));
   ASSERT_TRUE(network.get() != NULL);
   EXPECT_EQ(network->type(), chromeos::TYPE_VPN);
   VirtualNetwork* vpn = static_cast<VirtualNetwork*>(network.get());
   EXPECT_EQ(PROVIDER_TYPE_OPEN_VPN, vpn->provider_type());
 }
 
 }  // namespace chromeos