src/chrome/browser/policy/registry_dict_win.cc

   1 // Copyright 2013 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 "chrome/browser/policy/registry_dict_win.h"
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/sys_byteorder.h"
  13 #include "base/values.h"
  14 #include "base/win/registry.h"
  15 #include "components/json_schema/json_schema_constants.h"
  16
  17 namespace schema = json_schema_constants;
  18
  19 using base::win::RegistryKeyIterator;
  20 using base::win::RegistryValueIterator;
  21
  22 namespace policy {
  23
  24 namespace {
  25
  26 // Returns the entry with key |name| in |dictionary| (can be NULL), or NULL.
  27 const base::DictionaryValue* GetEntry(const base::DictionaryValue* dictionary,
  28                                       const std::string& name) {
  29   if (!dictionary)
  30     return NULL;
  31   const base::DictionaryValue* entry = NULL;
  32   dictionary->GetDictionaryWithoutPathExpansion(name, &entry);
  33   return entry;
  34 }
  35
  36 // Returns the Value type described in |schema|, or |default_type| if not found.
  37 base::Value::Type GetValueTypeForSchema(const base::DictionaryValue* schema,
  38                                         base::Value::Type default_type) {
  39   // JSON-schema types to base::Value::Type mapping.
  40   static const struct {
  41     // JSON schema type.
  42     const char* schema_type;
  43     // Correspondent value type.
  44     base::Value::Type value_type;
  45   } kSchemaToValueTypeMap[] = {
  46     { schema::kArray,        base::Value::TYPE_LIST        },
  47     { schema::kBoolean,      base::Value::TYPE_BOOLEAN     },
  48     { schema::kInteger,      base::Value::TYPE_INTEGER     },
  49     { schema::kNull,         base::Value::TYPE_NULL        },
  50     { schema::kNumber,       base::Value::TYPE_DOUBLE      },
  51     { schema::kObject,       base::Value::TYPE_DICTIONARY  },
  52     { schema::kString,       base::Value::TYPE_STRING      },
  53   };
  54
  55   if (!schema)
  56     return default_type;
  57   std::string type;
  58   if (!schema->GetStringWithoutPathExpansion(schema::kType, &type))
  59     return default_type;
  60   for (size_t i = 0; i < arraysize(kSchemaToValueTypeMap); ++i) {
  61     if (type == kSchemaToValueTypeMap[i].schema_type)
  62       return kSchemaToValueTypeMap[i].value_type;
  63   }
  64   return default_type;
  65 }
  66
  67 // Returns the schema for property |name| given the |schema| of an object.
  68 // Returns the "additionalProperties" schema if no specific schema for
  69 // |name| is present. Returns NULL if no schema is found.
  70 const base::DictionaryValue* GetSchemaFor(const base::DictionaryValue* schema,
  71                                           const std::string& name) {
  72   const base::DictionaryValue* properties =
  73       GetEntry(schema, schema::kProperties);
  74   const base::DictionaryValue* sub_schema = GetEntry(properties, name);
  75   if (sub_schema)
  76     return sub_schema;
  77   // "additionalProperties" can be a boolean, but that case is ignored.
  78   return GetEntry(schema, schema::kAdditionalProperties);
  79 }
  80
  81 // Converts a value (as read from the registry) to meet |schema|, converting
  82 // types as necessary. Unconvertible types will show up as NULL values in the
  83 // result.
  84 scoped_ptr<base::Value> ConvertValue(const base::Value& value,
  85                                      const base::DictionaryValue* schema) {
  86   // Figure out the type to convert to from the schema.
  87   const base::Value::Type result_type(
  88       GetValueTypeForSchema(schema, value.GetType()));
  89
  90   // If the type is good already, go with it.
  91   if (value.IsType(result_type)) {
  92     // Recurse for complex types if there is a schema.
  93     if (schema) {
  94       const base::DictionaryValue* dict = NULL;
  95       const base::ListValue* list = NULL;
  96       if (value.GetAsDictionary(&dict)) {
  97         scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
  98         for (base::DictionaryValue::Iterator entry(*dict); !entry.IsAtEnd();
  99              entry.Advance()) {
 100           scoped_ptr<base::Value> converted_value(
 101               ConvertValue(entry.value(), GetSchemaFor(schema, entry.key())));
 102           result->SetWithoutPathExpansion(entry.key(),
 103                                           converted_value.release());
 104         }
 105         return result.Pass();
 106       } else if (value.GetAsList(&list)) {
 107         scoped_ptr<base::ListValue> result(new base::ListValue());
 108         const base::DictionaryValue* item_schema =
 109             GetEntry(schema, schema::kItems);
 110         for (base::ListValue::const_iterator entry(list->begin());
 111              entry != list->end(); ++entry) {
 112           result->Append(ConvertValue(**entry, item_schema).release());
 113         }
 114         return result.Pass();
 115       }
 116     }
 117     return make_scoped_ptr(value.DeepCopy());
 118   }
 119
 120   // Else, do some conversions to map windows registry data types to JSON types.
 121   std::string string_value;
 122   int int_value = 0;
 123   switch (result_type) {
 124     case base::Value::TYPE_NULL: {
 125       return make_scoped_ptr(base::Value::CreateNullValue());
 126     }
 127     case base::Value::TYPE_BOOLEAN: {
 128       // Accept booleans encoded as either string or integer.
 129       if (value.GetAsInteger(&int_value) ||
 130           (value.GetAsString(&string_value) &&
 131            base::StringToInt(string_value, &int_value))) {
 132         return make_scoped_ptr(Value::CreateBooleanValue(int_value != 0));
 133       }
 134       break;
 135     }
 136     case base::Value::TYPE_INTEGER: {
 137       // Integers may be string-encoded.
 138       if (value.GetAsString(&string_value) &&
 139           base::StringToInt(string_value, &int_value)) {
 140         return make_scoped_ptr(base::Value::CreateIntegerValue(int_value));
 141       }
 142       break;
 143     }
 144     case base::Value::TYPE_DOUBLE: {
 145       // Doubles may be string-encoded or integer-encoded.
 146       double double_value = 0;
 147       if (value.GetAsInteger(&int_value)) {
 148         return make_scoped_ptr(base::Value::CreateDoubleValue(int_value));
 149       } else if (value.GetAsString(&string_value) &&
 150                  base::StringToDouble(string_value, &double_value)) {
 151         return make_scoped_ptr(base::Value::CreateDoubleValue(double_value));
 152       }
 153       break;
 154     }
 155     case base::Value::TYPE_LIST: {
 156       // Lists are encoded as subkeys with numbered value in the registry.
 157       const base::DictionaryValue* dict = NULL;
 158       if (value.GetAsDictionary(&dict)) {
 159         scoped_ptr<base::ListValue> result(new base::ListValue());
 160         const base::DictionaryValue* item_schema =
 161             GetEntry(schema, schema::kItems);
 162         for (int i = 1; ; ++i) {
 163           const base::Value* entry = NULL;
 164           if (!dict->Get(base::IntToString(i), &entry))
 165             break;
 166           result->Append(ConvertValue(*entry, item_schema).release());
 167         }
 168         return result.Pass();
 169       }
 170       // Fall through in order to accept lists encoded as JSON strings.
 171     }
 172     case base::Value::TYPE_DICTIONARY: {
 173       // Dictionaries may be encoded as JSON strings.
 174       if (value.GetAsString(&string_value)) {
 175         scoped_ptr<base::Value> result(base::JSONReader::Read(string_value));
 176         if (result && result->IsType(result_type))
 177           return result.Pass();
 178       }
 179       break;
 180     }
 181     case base::Value::TYPE_STRING:
 182     case base::Value::TYPE_BINARY:
 183       // No conversion possible.
 184       break;
 185   }
 186
 187   LOG(WARNING) << "Failed to convert " << value.GetType()
 188                << " to " << result_type;
 189   return make_scoped_ptr(base::Value::CreateNullValue());
 190 }
 191
 192 }  // namespace
 193
 194 bool CaseInsensitiveStringCompare::operator()(const std::string& a,
 195                                               const std::string& b) const {
 196   return base::strcasecmp(a.c_str(), b.c_str()) < 0;
 197 }
 198
 199 RegistryDict::RegistryDict() {}
 200
 201 RegistryDict::~RegistryDict() {
 202   ClearKeys();
 203   ClearValues();
 204 }
 205
 206 RegistryDict* RegistryDict::GetKey(const std::string& name) {
 207   KeyMap::iterator entry = keys_.find(name);
 208   return entry != keys_.end() ? entry->second : NULL;
 209 }
 210
 211 const RegistryDict* RegistryDict::GetKey(const std::string& name) const {
 212   KeyMap::const_iterator entry = keys_.find(name);
 213   return entry != keys_.end() ? entry->second : NULL;
 214 }
 215
 216 void RegistryDict::SetKey(const std::string& name,
 217                           scoped_ptr<RegistryDict> dict) {
 218   if (!dict) {
 219     RemoveKey(name);
 220     return;
 221   }
 222
 223   RegistryDict*& entry = keys_[name];
 224   delete entry;
 225   entry = dict.release();
 226 }
 227
 228 scoped_ptr<RegistryDict> RegistryDict::RemoveKey(const std::string& name) {
 229   scoped_ptr<RegistryDict> result;
 230   KeyMap::iterator entry = keys_.find(name);
 231   if (entry != keys_.end()) {
 232     result.reset(entry->second);
 233     keys_.erase(entry);
 234   }
 235   return result.Pass();
 236 }
 237
 238 void RegistryDict::ClearKeys() {
 239   STLDeleteValues(&keys_);
 240 }
 241
 242 base::Value* RegistryDict::GetValue(const std::string& name) {
 243   ValueMap::iterator entry = values_.find(name);
 244   return entry != values_.end() ? entry->second : NULL;
 245 }
 246
 247 const base::Value* RegistryDict::GetValue(const std::string& name) const {
 248   ValueMap::const_iterator entry = values_.find(name);
 249   return entry != values_.end() ? entry->second : NULL;
 250 }
 251
 252 void RegistryDict::SetValue(const std::string& name,
 253                             scoped_ptr<base::Value> dict) {
 254   if (!dict) {
 255     RemoveValue(name);
 256     return;
 257   }
 258
 259   Value*& entry = values_[name];
 260   delete entry;
 261   entry = dict.release();
 262 }
 263
 264 scoped_ptr<base::Value> RegistryDict::RemoveValue(const std::string& name) {
 265   scoped_ptr<base::Value> result;
 266   ValueMap::iterator entry = values_.find(name);
 267   if (entry != values_.end()) {
 268     result.reset(entry->second);
 269     values_.erase(entry);
 270   }
 271   return result.Pass();
 272 }
 273
 274 void RegistryDict::ClearValues() {
 275   STLDeleteValues(&values_);
 276 }
 277
 278 void RegistryDict::Merge(const RegistryDict& other) {
 279   for (KeyMap::const_iterator entry(other.keys_.begin());
 280        entry != other.keys_.end(); ++entry) {
 281     RegistryDict*& subdict = keys_[entry->first];
 282     if (!subdict)
 283       subdict = new RegistryDict();
 284     subdict->Merge(*entry->second);
 285   }
 286
 287   for (ValueMap::const_iterator entry(other.values_.begin());
 288        entry != other.values_.end(); ++entry) {
 289     SetValue(entry->first, make_scoped_ptr(entry->second->DeepCopy()));
 290   }
 291 }
 292
 293 void RegistryDict::Swap(RegistryDict* other) {
 294   keys_.swap(other->keys_);
 295   values_.swap(other->values_);
 296 }
 297
 298 void RegistryDict::ReadRegistry(HKEY hive, const string16& root) {
 299   ClearKeys();
 300   ClearValues();
 301
 302   // First, read all the values of the key.
 303   for (RegistryValueIterator it(hive, root.c_str()); it.Valid(); ++it) {
 304     const std::string name = UTF16ToUTF8(it.Name());
 305     switch (it.Type()) {
 306       case REG_SZ:
 307       case REG_EXPAND_SZ:
 308         SetValue(
 309             name,
 310             make_scoped_ptr(new base::StringValue(UTF16ToUTF8(it.Value()))));
 311         continue;
 312       case REG_DWORD_LITTLE_ENDIAN:
 313       case REG_DWORD_BIG_ENDIAN:
 314         if (it.ValueSize() == sizeof(DWORD)) {
 315           DWORD dword_value = *(reinterpret_cast<const DWORD*>(it.Value()));
 316           if (it.Type() == REG_DWORD_BIG_ENDIAN)
 317             dword_value = base::NetToHost32(dword_value);
 318           else
 319             dword_value = base::ByteSwapToLE32(dword_value);
 320           SetValue(
 321               name,
 322               make_scoped_ptr(base::Value::CreateIntegerValue(dword_value)));
 323           continue;
 324         }
 325       case REG_NONE:
 326       case REG_LINK:
 327       case REG_MULTI_SZ:
 328       case REG_RESOURCE_LIST:
 329       case REG_FULL_RESOURCE_DESCRIPTOR:
 330       case REG_RESOURCE_REQUIREMENTS_LIST:
 331       case REG_QWORD_LITTLE_ENDIAN:
 332         // Unsupported type, message gets logged below.
 333         break;
 334     }
 335
 336     LOG(WARNING) << "Failed to read hive " << hive << " at "
 337                  << root << "\\" << name
 338                  << " type " << it.Type();
 339   }
 340
 341   // Recurse for all subkeys.
 342   for (RegistryKeyIterator it(hive, root.c_str()); it.Valid(); ++it) {
 343     std::string name(UTF16ToUTF8(it.Name()));
 344     scoped_ptr<RegistryDict> subdict(new RegistryDict());
 345     subdict->ReadRegistry(hive, root + L"\\" + it.Name());
 346     SetKey(name, subdict.Pass());
 347   }
 348 }
 349
 350 scoped_ptr<base::Value> RegistryDict::ConvertToJSON(
 351     const base::DictionaryValue* schema) const {
 352   base::Value::Type type =
 353       GetValueTypeForSchema(schema, base::Value::TYPE_DICTIONARY);
 354   switch (type) {
 355     case base::Value::TYPE_DICTIONARY: {
 356       scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 357       for (RegistryDict::ValueMap::const_iterator entry(values_.begin());
 358            entry != values_.end(); ++entry) {
 359         result->SetWithoutPathExpansion(
 360             entry->first,
 361             ConvertValue(*entry->second,
 362                          GetSchemaFor(schema, entry->first)).release());
 363       }
 364       for (RegistryDict::KeyMap::const_iterator entry(keys_.begin());
 365            entry != keys_.end(); ++entry) {
 366         result->SetWithoutPathExpansion(
 367             entry->first,
 368             entry->second->ConvertToJSON(
 369                 GetSchemaFor(schema, entry->first)).release());
 370       }
 371       return result.Pass();
 372     }
 373     case base::Value::TYPE_LIST: {
 374       scoped_ptr<base::ListValue> result(new base::ListValue());
 375       const base::DictionaryValue* item_schema =
 376           GetEntry(schema, schema::kItems);
 377       for (int i = 1; ; ++i) {
 378         const std::string name(base::IntToString(i));
 379         const RegistryDict* key = GetKey(name);
 380         if (key) {
 381           result->Append(key->ConvertToJSON(item_schema).release());
 382           continue;
 383         }
 384         const base::Value* value = GetValue(name);
 385         if (value) {
 386           result->Append(ConvertValue(*value, item_schema).release());
 387           continue;
 388         }
 389         break;
 390       }
 391       return result.Pass();
 392     }
 393     default:
 394       LOG(WARNING) << "Can't convert registry key to schema type " << type;
 395   }
 396
 397   return make_scoped_ptr(base::Value::CreateNullValue());
 398 }
 399
 400 }  // namespace policy