src/chromeos/network/onc/onc_normalizer.cc

   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 "chromeos/network/onc/onc_normalizer.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "base/values.h"
  11 #include "chromeos/network/onc/onc_signature.h"
  12 #include "components/onc/onc_constants.h"
  13
  14 namespace chromeos {
  15 namespace onc {
  16
  17 Normalizer::Normalizer(bool remove_recommended_fields)
  18     : remove_recommended_fields_(remove_recommended_fields) {
  19 }
  20
  21 Normalizer::~Normalizer() {
  22 }
  23
  24 scoped_ptr<base::DictionaryValue> Normalizer::NormalizeObject(
  25     const OncValueSignature* object_signature,
  26     const base::DictionaryValue& onc_object) {
  27   CHECK(object_signature != NULL);
  28   bool error = false;
  29   scoped_ptr<base::DictionaryValue> result =
  30       MapObject(*object_signature, onc_object, &error);
  31   DCHECK(!error);
  32   return result.Pass();
  33 }
  34
  35 scoped_ptr<base::DictionaryValue> Normalizer::MapObject(
  36     const OncValueSignature& signature,
  37     const base::DictionaryValue& onc_object,
  38     bool* error) {
  39   scoped_ptr<base::DictionaryValue> normalized =
  40       Mapper::MapObject(signature, onc_object, error);
  41
  42   if (normalized.get() == NULL)
  43     return scoped_ptr<base::DictionaryValue>();
  44
  45   if (remove_recommended_fields_)
  46     normalized->RemoveWithoutPathExpansion(::onc::kRecommended, NULL);
  47
  48   if (&signature == &kCertificateSignature)
  49     NormalizeCertificate(normalized.get());
  50   else if (&signature == &kEAPSignature)
  51     NormalizeEAP(normalized.get());
  52   else if (&signature == &kEthernetSignature)
  53     NormalizeEthernet(normalized.get());
  54   else if (&signature == &kIPsecSignature)
  55     NormalizeIPsec(normalized.get());
  56   else if (&signature == &kNetworkConfigurationSignature)
  57     NormalizeNetworkConfiguration(normalized.get());
  58   else if (&signature == &kOpenVPNSignature)
  59     NormalizeOpenVPN(normalized.get());
  60   else if (&signature == &kProxySettingsSignature)
  61     NormalizeProxySettings(normalized.get());
  62   else if (&signature == &kVPNSignature)
  63     NormalizeVPN(normalized.get());
  64   else if (&signature == &kWiFiSignature)
  65     NormalizeWiFi(normalized.get());
  66
  67   return normalized.Pass();
  68 }
  69
  70 namespace {
  71
  72 void RemoveEntryUnless(base::DictionaryValue* dict,
  73                        const std::string& path,
  74                        bool condition) {
  75   if (!condition)
  76     dict->RemoveWithoutPathExpansion(path, NULL);
  77 }
  78
  79 }  // namespace
  80
  81 void Normalizer::NormalizeCertificate(base::DictionaryValue* cert) {
  82   using namespace ::onc::certificate;
  83
  84   bool remove = false;
  85   cert->GetBooleanWithoutPathExpansion(::onc::kRemove, &remove);
  86   RemoveEntryUnless(cert, ::onc::certificate::kType, !remove);
  87
  88   std::string type;
  89   cert->GetStringWithoutPathExpansion(::onc::certificate::kType, &type);
  90   RemoveEntryUnless(cert, kPKCS12, type == kClient);
  91   RemoveEntryUnless(cert, kTrustBits, type == kServer || type == kAuthority);
  92   RemoveEntryUnless(cert, kX509, type == kServer || type == kAuthority);
  93 }
  94
  95 void Normalizer::NormalizeEthernet(base::DictionaryValue* ethernet) {
  96   using namespace ::onc::ethernet;
  97
  98   std::string auth;
  99   ethernet->GetStringWithoutPathExpansion(kAuthentication, &auth);
 100   RemoveEntryUnless(ethernet, kEAP, auth == k8021X);
 101 }
 102
 103 void Normalizer::NormalizeEAP(base::DictionaryValue* eap) {
 104   using namespace ::onc::eap;
 105
 106   std::string clientcert_type;
 107   eap->GetStringWithoutPathExpansion(kClientCertType, &clientcert_type);
 108   RemoveEntryUnless(
 109       eap, kClientCertPattern, clientcert_type == ::onc::certificate::kPattern);
 110   RemoveEntryUnless(
 111       eap, kClientCertRef, clientcert_type == ::onc::certificate::kRef);
 112
 113   std::string outer;
 114   eap->GetStringWithoutPathExpansion(kOuter, &outer);
 115   RemoveEntryUnless(eap, kAnonymousIdentity,
 116                     outer == kPEAP || outer == kEAP_TTLS);
 117   RemoveEntryUnless(eap, kInner,
 118                     outer == kPEAP || outer == kEAP_TTLS || outer == kEAP_FAST);
 119 }
 120
 121 void Normalizer::NormalizeIPsec(base::DictionaryValue* ipsec) {
 122   using namespace ::onc::ipsec;
 123
 124   std::string auth_type;
 125   ipsec->GetStringWithoutPathExpansion(kAuthenticationType, &auth_type);
 126   RemoveEntryUnless(ipsec, ::onc::vpn::kClientCertType, auth_type == kCert);
 127   RemoveEntryUnless(ipsec, kServerCARef, auth_type == kCert);
 128   RemoveEntryUnless(ipsec, kPSK, auth_type == kPSK);
 129   RemoveEntryUnless(ipsec, ::onc::vpn::kSaveCredentials, auth_type == kPSK);
 130
 131   std::string clientcert_type;
 132   ipsec->GetStringWithoutPathExpansion(::onc::vpn::kClientCertType,
 133                                        &clientcert_type);
 134   RemoveEntryUnless(ipsec,
 135                     ::onc::vpn::kClientCertPattern,
 136                     clientcert_type == ::onc::certificate::kPattern);
 137   RemoveEntryUnless(ipsec,
 138                     ::onc::vpn::kClientCertRef,
 139                     clientcert_type == ::onc::certificate::kRef);
 140
 141   int ike_version = -1;
 142   ipsec->GetIntegerWithoutPathExpansion(kIKEVersion, &ike_version);
 143   RemoveEntryUnless(ipsec, kEAP, ike_version == 2);
 144   RemoveEntryUnless(ipsec, kGroup, ike_version == 1);
 145   RemoveEntryUnless(ipsec, kXAUTH, ike_version == 1);
 146 }
 147
 148 void Normalizer::NormalizeNetworkConfiguration(base::DictionaryValue* network) {
 149   bool remove = false;
 150   network->GetBooleanWithoutPathExpansion(::onc::kRemove, &remove);
 151   if (remove) {
 152     network->RemoveWithoutPathExpansion(::onc::network_config::kIPConfigs,
 153                                         NULL);
 154     network->RemoveWithoutPathExpansion(::onc::network_config::kName, NULL);
 155     network->RemoveWithoutPathExpansion(::onc::network_config::kNameServers,
 156                                         NULL);
 157     network->RemoveWithoutPathExpansion(::onc::network_config::kProxySettings,
 158                                         NULL);
 159     network->RemoveWithoutPathExpansion(::onc::network_config::kSearchDomains,
 160                                         NULL);
 161     network->RemoveWithoutPathExpansion(::onc::network_config::kType, NULL);
 162     // Fields dependent on kType are removed afterwards, too.
 163   }
 164
 165   std::string type;
 166   network->GetStringWithoutPathExpansion(::onc::network_config::kType, &type);
 167   RemoveEntryUnless(network,
 168                     ::onc::network_config::kEthernet,
 169                     type == ::onc::network_type::kEthernet);
 170   RemoveEntryUnless(
 171       network, ::onc::network_config::kVPN, type == ::onc::network_type::kVPN);
 172   RemoveEntryUnless(network,
 173                     ::onc::network_config::kWiFi,
 174                     type == ::onc::network_type::kWiFi);
 175 }
 176
 177 void Normalizer::NormalizeOpenVPN(base::DictionaryValue* openvpn) {
 178   using namespace ::onc::vpn;
 179
 180   std::string clientcert_type;
 181   openvpn->GetStringWithoutPathExpansion(kClientCertType, &clientcert_type);
 182   RemoveEntryUnless(openvpn,
 183                     kClientCertPattern,
 184                     clientcert_type == ::onc::certificate::kPattern);
 185   RemoveEntryUnless(
 186       openvpn, kClientCertRef, clientcert_type == ::onc::certificate::kRef);
 187 }
 188
 189 void Normalizer::NormalizeProxySettings(base::DictionaryValue* proxy) {
 190   using namespace ::onc::proxy;
 191
 192   std::string type;
 193   proxy->GetStringWithoutPathExpansion(::onc::proxy::kType, &type);
 194   RemoveEntryUnless(proxy, kManual, type == kManual);
 195   RemoveEntryUnless(proxy, kExcludeDomains, type == kManual);
 196   RemoveEntryUnless(proxy, kPAC, type == kPAC);
 197 }
 198
 199 void Normalizer::NormalizeVPN(base::DictionaryValue* vpn) {
 200   using namespace ::onc::vpn;
 201
 202   std::string type;
 203   vpn->GetStringWithoutPathExpansion(::onc::vpn::kType, &type);
 204   RemoveEntryUnless(vpn, kOpenVPN, type == kOpenVPN);
 205   RemoveEntryUnless(vpn, kIPsec, type == kIPsec || type == kTypeL2TP_IPsec);
 206   RemoveEntryUnless(vpn, kL2TP, type == kTypeL2TP_IPsec);
 207 }
 208
 209 void Normalizer::NormalizeWiFi(base::DictionaryValue* wifi) {
 210   using namespace ::onc::wifi;
 211
 212   std::string security;
 213   wifi->GetStringWithoutPathExpansion(::onc::wifi::kSecurity, &security);
 214   RemoveEntryUnless(wifi, kEAP, security == kWEP_8021X || security == kWPA_EAP);
 215   RemoveEntryUnless(wifi, kPassphrase,
 216                     security == kWEP_PSK || security == kWPA_PSK);
 217 }
 218
 219 }  // namespace onc
 220 }  // namespace chromeos