ONC: add support for non-utf-8 SSIDs

chromeos/network/onc/onc_validator.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 "chromeos/network/onc/onc_validator.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "components/onc/onc_constants.h"
 
 namespace chromeos {
 namespace onc {
 
 namespace {
 
+// According to the IEEE 802.11 standard the SSID is a series of 0 to 32 octets.
+const int kMaximumSSIDLengthInBytes = 32;
+
 template <typename T, size_t N>
 std::vector<T> toVector(T const (&array)[N]) {
   return std::vector<T>(array, array + N);
 }
 
 // Copied from policy/configuration_policy_handler.cc.
 // TODO(pneubeck): move to a common place like base/.
 std::string ValueTypeToString(base::Value::Type type) {
   const char* const strings[] = {"null",   "boolean", "integer",    "double",
                                  "string", "binary",  "dictionary", "list"};
@@ skipping 356 matching lines @@
   }
 
   error_or_warning_found_ = true;
   path_.push_back(field_name);
   LOG(ERROR) << MessageHeader() << "Found an empty string, but expected a "
              << "non-empty string.";
   path_.pop_back();
   return true;
 }
 
+bool Validator::IsSSIDOrHexSSIDValid(const base::DictionaryValue& object) {
+  // Check SSID validity.
+  std::string ssid_string;
+  if (object.GetStringWithoutPathExpansion(::onc::wifi::kSSID, &ssid_string)) {
+    if (ssid_string.size() <= 0 ||
+        ssid_string.size() > kMaximumSSIDLengthInBytes) {
+      LOG(ERROR) << MessageHeader() << ::onc::wifi::kSSID
+                 << " has an invalid length.";
+      error_or_warning_found_ = true;
+      return false;
+    }
+  }
+
+  // Check HexSSID validity.
+  std::string hex_ssid_string;
+  if (object.GetStringWithoutPathExpansion(::onc::wifi::kHexSSID,
+                                           &hex_ssid_string)) {
+    std::vector<uint8> bytes;
+    if (!base::HexStringToBytes(hex_ssid_string, &bytes)) {
+      LOG(ERROR) << MessageHeader() << "Field " << ::onc::wifi::kHexSSID
+                 << " is not a valid hex representation: \"" << hex_ssid_string
+                 << "\"";
+      error_or_warning_found_ = true;
+      return false;
+    }
+    if (bytes.size() <= 0 || bytes.size() > kMaximumSSIDLengthInBytes) {
+      LOG(ERROR) << MessageHeader() << ::onc::wifi::kHexSSID
+                 << " has an invalid length.";
+      error_or_warning_found_ = true;
+      return false;
+    }
+  }
+  // If both SSID and HexSSID are set, ensure that they are consistent.
+  if (ssid_string.length() > 0 && hex_ssid_string.length() > 0) {
+    std::string hexified =
+        base::HexEncode(ssid_string.c_str(), ssid_string.size());
+    if (hexified != hex_ssid_string) {
+      LOG(ERROR) << MessageHeader() << "Fields " << ::onc::wifi::kSSID
+                 << " and " << ::onc::wifi::kHexSSID
+                 << " contain inconsistent values.";
+      error_or_warning_found_ = true;
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool Validator::RequireField(const base::DictionaryValue& dict,
                              const std::string& field_name) {
   if (dict.HasKey(field_name))
     return true;
   std::string message = MessageHeader() + "The required field '" + field_name +
       "' is missing.";
   if (error_on_missing_field_) {
     error_or_warning_found_ = true;
     LOG(ERROR) << message;
   } else {
@@ skipping 156 matching lines @@
 
 bool Validator::ValidateWiFi(base::DictionaryValue* result) {
   using namespace ::onc::wifi;
 
   const char* const kValidSecurities[] = {kSecurityNone, kWEP_PSK, kWEP_8021X,
                                           kWPA_PSK, kWPA_EAP};
   const std::vector<const char*> valid_securities(toVector(kValidSecurities));
   if (FieldExistsAndHasNoValidValue(*result, kSecurity, valid_securities))
     return false;
 
-  bool all_required_exist =
-      RequireField(*result, kSecurity) && RequireField(*result, kSSID);
+  // Validate SSID and HexSSID fields, if present.
+  if (!IsSSIDOrHexSSIDValid(*result))
+    return false;
+
+  bool all_required_exist = RequireField(*result, kSecurity);
+
+  // One of {kSSID, kHexSSID} must be present.
+  if (!result->HasKey(kSSID))
+    all_required_exist &= RequireField(*result, kHexSSID);
+  if (!result->HasKey(kHexSSID))
+    all_required_exist &= RequireField(*result, kSSID);
 
   std::string security;
   result->GetStringWithoutPathExpansion(kSecurity, &security);
   if (security == kWEP_8021X || security == kWPA_EAP)
     all_required_exist &= RequireField(*result, kEAP);
   else if (security == kWEP_PSK || security == kWPA_PSK)
     all_required_exist &= RequireField(*result, kPassphrase);
 
   return !error_on_missing_field_ || all_required_exist;
 }
@@ skipping 257 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos