Home | History | Annotate | Download | only in prefs 
      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 }
    312