| OLD | NEW |
|---|
| (Empty) |
| 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/prefs/pref_hash_store_impl.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/metrics/histogram.h" | |
| 9 #include "base/values.h" | |
| 10 #include "chrome/browser/prefs/pref_hash_store_transaction.h" | |
| 11 #include "chrome/browser/prefs/tracked/hash_store_contents.h" | |
| 12 | |
| 13 class PrefHashStoreImpl::PrefHashStoreTransactionImpl | |
| 14 : public PrefHashStoreTransaction { | |
| 15 public: | |
| 16 // Constructs a PrefHashStoreTransactionImpl which can use the private | |
| 17 // members of its |outer| PrefHashStoreImpl. | |
| 18 PrefHashStoreTransactionImpl(PrefHashStoreImpl* outer, | |
| 19 scoped_ptr<HashStoreContents> storage); | |
| 20 virtual ~PrefHashStoreTransactionImpl(); | |
| 21 | |
| 22 // PrefHashStoreTransaction implementation. | |
| 23 virtual ValueState CheckValue(const std::string& path, | |
| 24 const base::Value* value) const OVERRIDE; | |
| 25 virtual void StoreHash(const std::string& path, | |
| 26 const base::Value* value) OVERRIDE; | |
| 27 virtual ValueState CheckSplitValue( | |
| 28 const std::string& path, | |
| 29 const base::DictionaryValue* initial_split_value, | |
| 30 std::vector<std::string>* invalid_keys) const OVERRIDE; | |
| 31 virtual void StoreSplitHash( | |
| 32 const std::string& path, | |
| 33 const base::DictionaryValue* split_value) OVERRIDE; | |
| 34 virtual bool HasHash(const std::string& path) const OVERRIDE; | |
| 35 virtual void ImportHash(const std::string& path, | |
| 36 const base::Value* hash) OVERRIDE; | |
| 37 virtual void ClearHash(const std::string& path) OVERRIDE; | |
| 38 virtual bool IsSuperMACValid() const OVERRIDE; | |
| 39 virtual bool StampSuperMac() OVERRIDE; | |
| 40 | |
| 41 private: | |
| 42 bool GetSplitMacs(const std::string& path, | |
| 43 std::map<std::string, std::string>* split_macs) const; | |
| 44 | |
| 45 HashStoreContents* contents() { | |
| 46 return outer_->legacy_hash_store_contents_ | |
| 47 ? outer_->legacy_hash_store_contents_.get() | |
| 48 : contents_.get(); | |
| 49 } | |
| 50 | |
| 51 const HashStoreContents* contents() const { | |
| 52 return outer_->legacy_hash_store_contents_ | |
| 53 ? outer_->legacy_hash_store_contents_.get() | |
| 54 : contents_.get(); | |
| 55 } | |
| 56 | |
| 57 PrefHashStoreImpl* outer_; | |
| 58 scoped_ptr<HashStoreContents> contents_; | |
| 59 | |
| 60 bool super_mac_valid_; | |
| 61 bool super_mac_dirty_; | |
| 62 | |
| 63 DISALLOW_COPY_AND_ASSIGN(PrefHashStoreTransactionImpl); | |
| 64 }; | |
| 65 | |
| 66 PrefHashStoreImpl::PrefHashStoreImpl(const std::string& seed, | |
| 67 const std::string& device_id, | |
| 68 bool use_super_mac) | |
| 69 : pref_hash_calculator_(seed, device_id), | |
| 70 use_super_mac_(use_super_mac) { | |
| 71 } | |
| 72 | |
| 73 PrefHashStoreImpl::~PrefHashStoreImpl() { | |
| 74 } | |
| 75 | |
| 76 void PrefHashStoreImpl::set_legacy_hash_store_contents( | |
| 77 scoped_ptr<HashStoreContents> legacy_hash_store_contents) { | |
| 78 legacy_hash_store_contents_ = legacy_hash_store_contents.Pass(); | |
| 79 } | |
| 80 | |
| 81 scoped_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction( | |
| 82 scoped_ptr<HashStoreContents> storage) { | |
| 83 return scoped_ptr<PrefHashStoreTransaction>( | |
| 84 new PrefHashStoreTransactionImpl(this, storage.Pass())); | |
| 85 } | |
| 86 | |
| 87 PrefHashStoreImpl::PrefHashStoreTransactionImpl::PrefHashStoreTransactionImpl( | |
| 88 PrefHashStoreImpl* outer, | |
| 89 scoped_ptr<HashStoreContents> storage) | |
| 90 : outer_(outer), | |
| 91 contents_(storage.Pass()), | |
| 92 super_mac_valid_(false), | |
| 93 super_mac_dirty_(false) { | |
| 94 if (!outer_->use_super_mac_) | |
| 95 return; | |
| 96 | |
| 97 // The store must be initialized and have a valid super MAC to be trusted. | |
| 98 | |
| 99 const base::DictionaryValue* store_contents = contents()->GetContents(); | |
| 100 if (!store_contents) | |
| 101 return; | |
| 102 | |
| 103 std::string super_mac = contents()->GetSuperMac(); | |
| 104 if (super_mac.empty()) | |
| 105 return; | |
| 106 | |
| 107 super_mac_valid_ = | |
| 108 outer_->pref_hash_calculator_.Validate( | |
| 109 contents()->hash_store_id(), store_contents, super_mac) == | |
| 110 PrefHashCalculator::VALID; | |
| 111 } | |
| 112 | |
| 113 PrefHashStoreImpl::PrefHashStoreTransactionImpl:: | |
| 114 ~PrefHashStoreTransactionImpl() { | |
| 115 if (super_mac_dirty_ && outer_->use_super_mac_) { | |
| 116 // Get the dictionary of hashes (or NULL if it doesn't exist). | |
| 117 const base::DictionaryValue* hashes_dict = contents()->GetContents(); | |
| 118 contents()->SetSuperMac(outer_->pref_hash_calculator_.Calculate( | |
| 119 contents()->hash_store_id(), hashes_dict)); | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 PrefHashStoreTransaction::ValueState | |
| 124 PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckValue( | |
| 125 const std::string& path, | |
| 126 const base::Value* initial_value) const { | |
| 127 const base::DictionaryValue* hashes_dict = contents()->GetContents(); | |
| 128 | |
| 129 std::string last_hash; | |
| 130 if (hashes_dict) | |
| 131 hashes_dict->GetString(path, &last_hash); | |
| 132 | |
| 133 if (last_hash.empty()) { | |
| 134 // In the absence of a hash for this pref, always trust a NULL value, but | |
| 135 // only trust an existing value if the initial hashes dictionary is trusted. | |
| 136 return (!initial_value || super_mac_valid_) ? TRUSTED_UNKNOWN_VALUE | |
| 137 : UNTRUSTED_UNKNOWN_VALUE; | |
| 138 } | |
| 139 | |
| 140 PrefHashCalculator::ValidationResult validation_result = | |
| 141 outer_->pref_hash_calculator_.Validate(path, initial_value, last_hash); | |
| 142 switch (validation_result) { | |
| 143 case PrefHashCalculator::VALID: | |
| 144 return UNCHANGED; | |
| 145 case PrefHashCalculator::VALID_SECURE_LEGACY: | |
| 146 return SECURE_LEGACY; | |
| 147 case PrefHashCalculator::INVALID: | |
| 148 return initial_value ? CHANGED : CLEARED; | |
| 149 } | |
| 150 NOTREACHED() << "Unexpected PrefHashCalculator::ValidationResult: " | |
| 151 << validation_result; | |
| 152 return UNTRUSTED_UNKNOWN_VALUE; | |
| 153 } | |
| 154 | |
| 155 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreHash( | |
| 156 const std::string& path, | |
| 157 const base::Value* new_value) { | |
| 158 const std::string mac = | |
| 159 outer_->pref_hash_calculator_.Calculate(path, new_value); | |
| 160 (*contents()->GetMutableContents())->SetString(path, mac); | |
| 161 super_mac_dirty_ = true; | |
| 162 } | |
| 163 | |
| 164 PrefHashStoreTransaction::ValueState | |
| 165 PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckSplitValue( | |
| 166 const std::string& path, | |
| 167 const base::DictionaryValue* initial_split_value, | |
| 168 std::vector<std::string>* invalid_keys) const { | |
| 169 DCHECK(invalid_keys && invalid_keys->empty()); | |
| 170 | |
| 171 std::map<std::string, std::string> split_macs; | |
| 172 const bool has_hashes = GetSplitMacs(path, &split_macs); | |
| 173 | |
| 174 // Treat NULL and empty the same; otherwise we would need to store a hash | |
| 175 // for the entire dictionary (or some other special beacon) to | |
| 176 // differentiate these two cases which are really the same for | |
| 177 // dictionaries. | |
| 178 if (!initial_split_value || initial_split_value->empty()) | |
| 179 return has_hashes ? CLEARED : UNCHANGED; | |
| 180 | |
| 181 if (!has_hashes) | |
| 182 return super_mac_valid_ ? TRUSTED_UNKNOWN_VALUE : UNTRUSTED_UNKNOWN_VALUE; | |
| 183 | |
| 184 bool has_secure_legacy_id_hashes = false; | |
| 185 std::string keyed_path(path); | |
| 186 keyed_path.push_back('.'); | |
| 187 const size_t common_part_length = keyed_path.length(); | |
| 188 for (base::DictionaryValue::Iterator it(*initial_split_value); !it.IsAtEnd(); | |
| 189 it.Advance()) { | |
| 190 std::map<std::string, std::string>::iterator entry = | |
| 191 split_macs.find(it.key()); | |
| 192 if (entry == split_macs.end()) { | |
| 193 invalid_keys->push_back(it.key()); | |
| 194 } else { | |
| 195 // Keep the common part from the old |keyed_path| and replace the key to | |
| 196 // get the new |keyed_path|. | |
| 197 keyed_path.replace(common_part_length, std::string::npos, it.key()); | |
| 198 switch (outer_->pref_hash_calculator_.Validate( | |
| 199 keyed_path, &it.value(), entry->second)) { | |
| 200 case PrefHashCalculator::VALID: | |
| 201 break; | |
| 202 case SECURE_LEGACY: | |
| 203 // Secure legacy device IDs based hashes are still accepted, but we | |
| 204 // should make sure to notify the caller for him to update the legacy | |
| 205 // hashes. | |
| 206 has_secure_legacy_id_hashes = true; | |
| 207 break; | |
| 208 case PrefHashCalculator::INVALID: | |
| 209 invalid_keys->push_back(it.key()); | |
| 210 break; | |
| 211 } | |
| 212 // Remove processed MACs, remaining MACs at the end will also be | |
| 213 // considered invalid. | |
| 214 split_macs.erase(entry); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 // Anything left in the map is missing from the data. | |
| 219 for (std::map<std::string, std::string>::const_iterator it = | |
| 220 split_macs.begin(); | |
| 221 it != split_macs.end(); | |
| 222 ++it) { | |
| 223 invalid_keys->push_back(it->first); | |
| 224 } | |
| 225 | |
| 226 return invalid_keys->empty() | |
| 227 ? (has_secure_legacy_id_hashes ? SECURE_LEGACY : UNCHANGED) | |
| 228 : CHANGED; | |
| 229 } | |
| 230 | |
| 231 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreSplitHash( | |
| 232 const std::string& path, | |
| 233 const base::DictionaryValue* split_value) { | |
| 234 scoped_ptr<HashStoreContents::MutableDictionary> mutable_dictionary = | |
| 235 contents()->GetMutableContents(); | |
| 236 (*mutable_dictionary)->Remove(path, NULL); | |
| 237 | |
| 238 if (split_value) { | |
| 239 std::string keyed_path(path); | |
| 240 keyed_path.push_back('.'); | |
| 241 const size_t common_part_length = keyed_path.length(); | |
| 242 for (base::DictionaryValue::Iterator it(*split_value); !it.IsAtEnd(); | |
| 243 it.Advance()) { | |
| 244 // Keep the common part from the old |keyed_path| and replace the key to | |
| 245 // get the new |keyed_path|. | |
| 246 keyed_path.replace(common_part_length, std::string::npos, it.key()); | |
| 247 (*mutable_dictionary)->SetString( | |
| 248 keyed_path, | |
| 249 outer_->pref_hash_calculator_.Calculate(keyed_path, &it.value())); | |
| 250 } | |
| 251 } | |
| 252 super_mac_dirty_ = true; | |
| 253 } | |
| 254 | |
| 255 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::GetSplitMacs( | |
| 256 const std::string& key, | |
| 257 std::map<std::string, std::string>* split_macs) const { | |
| 258 DCHECK(split_macs); | |
| 259 DCHECK(split_macs->empty()); | |
| 260 | |
| 261 const base::DictionaryValue* hashes_dict = contents()->GetContents(); | |
| 262 const base::DictionaryValue* split_mac_dictionary = NULL; | |
| 263 if (!hashes_dict || !hashes_dict->GetDictionary(key, &split_mac_dictionary)) | |
| 264 return false; | |
| 265 for (base::DictionaryValue::Iterator it(*split_mac_dictionary); !it.IsAtEnd(); | |
| 266 it.Advance()) { | |
| 267 std::string mac_string; | |
| 268 if (!it.value().GetAsString(&mac_string)) { | |
| 269 NOTREACHED(); | |
| 270 continue; | |
| 271 } | |
| 272 split_macs->insert(make_pair(it.key(), mac_string)); | |
| 273 } | |
| 274 return true; | |
| 275 } | |
| 276 | |
| 277 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::HasHash( | |
| 278 const std::string& path) const { | |
| 279 const base::DictionaryValue* hashes_dict = contents()->GetContents(); | |
| 280 return hashes_dict && hashes_dict->Get(path, NULL); | |
| 281 } | |
| 282 | |
| 283 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::ImportHash( | |
| 284 const std::string& path, | |
| 285 const base::Value* hash) { | |
| 286 DCHECK(hash); | |
| 287 | |
| 288 (*contents()->GetMutableContents())->Set(path, hash->DeepCopy()); | |
| 289 | |
| 290 if (super_mac_valid_) | |
| 291 super_mac_dirty_ = true; | |
| 292 } | |
| 293 | |
| 294 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::ClearHash( | |
| 295 const std::string& path) { | |
| 296 if ((*contents()->GetMutableContents())->RemovePath(path, NULL) && | |
| 297 super_mac_valid_) { | |
| 298 super_mac_dirty_ = true; | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::IsSuperMACValid() const { | |
| 303 return super_mac_valid_; | |
| 304 } | |
| 305 | |
| 306 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::StampSuperMac() { | |
| 307 if (!outer_->use_super_mac_ || super_mac_valid_) | |
| 308 return false; | |
| 309 super_mac_dirty_ = true; | |
| 310 return true; | |
| 311 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 620933002:
Move all files related to tracked preferences from c/b/prefs to c/b/prefs/tracked. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master