components/user_prefs/tracked/pref_hash_store_transaction.h

   1 // Copyright 2014 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 #ifndef COMPONENTS_USER_PREFS_TRACKED_PREF_HASH_STORE_TRANSACTION_H_
   6 #define COMPONENTS_USER_PREFS_TRACKED_PREF_HASH_STORE_TRANSACTION_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 namespace base {
  12 class DictionaryValue;
  13 class Value;
  14 }  // namespace base
  15
  16 // Used to perform a series of checks/transformations on a PrefHashStore.
  17 class PrefHashStoreTransaction {
  18  public:
  19   enum ValueState {
  20     // The preference value corresponds to its stored hash.
  21     UNCHANGED,
  22     // The preference has been cleared since the last hash.
  23     CLEARED,
  24     // The preference value corresponds to its stored hash, but the hash was
  25     // calculated using a deprecated hash algorithm which is just as safe as
  26     // the current one.
  27     SECURE_LEGACY,
  28     // The preference value has been changed since the last hash.
  29     CHANGED,
  30     // No stored hash exists for the preference value.
  31     UNTRUSTED_UNKNOWN_VALUE,
  32     // No stored hash exists for the preference value, but the current set of
  33     // hashes stored is trusted and thus this value can safely be seeded. This
  34     // happens when all hashes are already properly seeded and a newly
  35     // tracked value needs to be seeded).
  36     TRUSTED_UNKNOWN_VALUE,
  37     // NULL values are inherently trusted.
  38     TRUSTED_NULL_VALUE,
  39   };
  40
  41   // Finalizes any remaining work after the transaction has been performed.
  42   virtual ~PrefHashStoreTransaction() {}
  43
  44   // Checks |initial_value| against the existing stored value hash.
  45   virtual ValueState CheckValue(const std::string& path,
  46                                 const base::Value* initial_value) const = 0;
  47
  48   // Stores a hash of the current |value| of the preference at |path|.
  49   virtual void StoreHash(const std::string& path, const base::Value* value) = 0;
  50
  51   // Checks |initial_value| against the existing stored hashes for the split
  52   // preference at |path|. |initial_split_value| being an empty dictionary or
  53   // NULL is equivalent. |invalid_keys| must initially be empty. |invalid_keys|
  54   // will not be modified unless the return value is CHANGED, in which case it
  55   // will be filled with the keys that are considered invalid (unknown or
  56   // changed).
  57   virtual ValueState CheckSplitValue(
  58       const std::string& path,
  59       const base::DictionaryValue* initial_split_value,
  60       std::vector<std::string>* invalid_keys) const = 0;
  61
  62   // Stores hashes for the |value| of the split preference at |path|.
  63   // |split_value| being an empty dictionary or NULL is equivalent.
  64   virtual void StoreSplitHash(const std::string& path,
  65                               const base::DictionaryValue* split_value) = 0;
  66
  67   // Indicates whether the store contains a hash for the preference at |path|.
  68   virtual bool HasHash(const std::string& path) const = 0;
  69
  70   // Sets the hash for the preference at |path|.
  71   // If |path| is a split preference |hash| must be a DictionaryValue whose
  72   // keys are keys in the split preference and whose values are MACs of the
  73   // corresponding values in the split preference.
  74   // If |path| is an atomic preference |hash| must be a StringValue
  75   // containing a MAC of the preference value.
  76   // |hash| should originate from a PrefHashStore sharing the same MAC
  77   // parameters as this transaction's store.
  78   // The (in)validity of the super MAC will be maintained by this call.
  79   virtual void ImportHash(const std::string& path, const base::Value* hash) = 0;
  80
  81   // Removes the hash stored at |path|. The (in)validity of the super MAC will
  82   // be maintained by this call.
  83   virtual void ClearHash(const std::string& path) = 0;
  84
  85   // Indicates whether the super MAC was successfully verified at the beginning
  86   // of this transaction.
  87   virtual bool IsSuperMACValid() const = 0;
  88
  89   // Forces a valid super MAC to be stored when this transaction terminates.
  90   // Returns true if this results in a change to the store contents.
  91   virtual bool StampSuperMac() = 0;
  92 };
  93
  94 #endif  // COMPONENTS_USER_PREFS_TRACKED_PREF_HASH_STORE_TRANSACTION_H_