[Sync] Implement keystore migration support.

sync/internal_api/sync_encryption_handler_impl.h

 // 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.
 
 #ifndef SYNC_INTERNAL_API_SYNC_ENCRYPTION_HANDLER_IMPL_H_
 #define SYNC_INTERNAL_API_SYNC_ENCRYPTION_HANDLER_IMPL_H_
 
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 42 matching lines @@
 
   // SyncEncryptionHandler implementation.
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual void Init() OVERRIDE;
   virtual void SetEncryptionPassphrase(const std::string& passphrase,
                                        bool is_explicit) OVERRIDE;
   virtual void SetDecryptionPassphrase(const std::string& passphrase) OVERRIDE;
   virtual void EnableEncryptEverything() OVERRIDE;
   virtual bool EncryptEverythingEnabled() const OVERRIDE;
-  virtual PassphraseState GetPassphraseState() const OVERRIDE;
+  virtual PassphraseType GetPassphraseType() const OVERRIDE;
+
+  // TODO(zea): provide a method for getting the time at which the nigori
+  // node was migrated.
 
   // NigoriHandler implementation.
   // Note: all methods are invoked while the caller holds a transaction.
   virtual void ApplyNigoriUpdate(
       const sync_pb::NigoriSpecifics& nigori,
       syncable::BaseTransaction* const trans) OVERRIDE;
   virtual void UpdateNigoriFromEncryptedTypes(
       sync_pb::NigoriSpecifics* nigori,
       syncable::BaseTransaction* const trans) const OVERRIDE;
   virtual bool NeedKeystoreKey(
       syncable::BaseTransaction* const trans) const OVERRIDE;
   virtual bool SetKeystoreKey(
       const std::string& key,
       syncable::BaseTransaction* const trans) OVERRIDE;
   // Can be called from any thread.
   virtual ModelTypeSet GetEncryptedTypes(
       syncable::BaseTransaction* const trans) const OVERRIDE;
 
   // Unsafe getters. Use only if sync is not up and running and there is no risk
   // of other threads calling this.
   Cryptographer* GetCryptographerUnsafe();
   ModelTypeSet GetEncryptedTypesUnsafe();
 
+  bool MigratedToKeystore();
+
  private:
   FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
                            NigoriEncryptionTypes);
   FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
                            EncryptEverythingExplicit);
   FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
                            EncryptEverythingImplicit);
   FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
                            UnknownSensitiveTypes);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           GetKeystoreDecryptor);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           ReceiveMigratedNigoriKeystorePass);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           ReceiveUmigratedNigoriAfterMigration);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           ReceiveOldMigratedNigori);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           SetKeystoreAfterReceivingMigratedNigori);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           SetCustomPassAfterMigration);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           SetCustomPassAfterMigrationNoKeystoreKey);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           SetImplicitPassAfterMigrationNoKeystoreKey);
+  FRIEND_TEST_ALL_PREFIXES(SyncEncryptionHandlerImplTest,
+                           MigrateOnEncryptEverythingKeystorePassphrase);
 
   // Container for members that require thread safety protection.  All members
   // that can be accessed from more than one thread should be held here and
   // accessed via UnlockVault(..) and UnlockVaultMutable(..), which enforce
   // that a transaction is held.
   struct Vault {
     Vault(Encryptor* encryptor, ModelTypeSet encrypted_types);
     ~Vault();
 
     // Sync's cryptographer. Used for encrypting and decrypting sync data.
@@ skipping 27 matching lines @@
   // Updates local encrypted types from |nigori|.
   // Returns true if the local set of encrypted types either matched or was
   // a subset of that in |nigori|. Returns false if the local state already
   // had stricter encryption than |nigori|, and the nigori node needs to be
   // updated with the newer encryption state.
   // Note: must be called from within a transaction.
   bool UpdateEncryptedTypesFromNigori(
       const sync_pb::NigoriSpecifics& nigori,
       syncable::BaseTransaction* const trans);
 
+  // TODO(zea): make these public and have them replace SetEncryptionPassphrase
+  // and SetDecryptionPassphrase.
+  // Helper methods for handling passphrases once keystore migration has taken
+  // place.
+  //
+  // Sets a new custom passphrase. Should only be called if a custom passphrase
+  // is not already set.
+  // Triggers OnPassphraseAccepted on success, OnPassphraseRequired if a custom
+  // passphrase already existed.
+  void SetCustomPassphrase(const std::string& passphrase,
+                           WriteTransaction* trans,
+                           WriteNode* nigori_node);
+  // Decrypt the encryption keybag using a user provided passphrase.
+  // Should only be called if the current passphrase is a frozen implicit
+  // passphrase or a custom passphrase.
+  // Triggers OnPassphraseAccepted on success, OnPassphraseRequired on failure.
+  void DecryptPendingKeysWithExplicitPassphrase(const std::string& passphrase,
+                                                WriteTransaction* trans,
+                                                WriteNode* nigori_node);
+
   // The final step of SetEncryptionPassphrase and SetDecryptionPassphrase that
   // notifies observers of the result of the set passphrase operation, updates
   // the nigori node, and does re-encryption.
   // |success|: true if the operation was successful and false otherwise. If
   //            success == false, we send an OnPassphraseRequired notification.
   // |bootstrap_token|: used to inform observers if the cryptographer's
   //                    bootstrap token was updated.
   // |is_explicit|: used to differentiate between a custom passphrase (true) and
   //                a GAIA passphrase that is implicitly used for encryption
   //                (false).
   // |trans| and |nigori_node|: used to access data in the cryptographer.
   void FinishSetPassphrase(bool success,
                            const std::string& bootstrap_token,
-                           bool is_explicit,
                            WriteTransaction* trans,
                            WriteNode* nigori_node);
 
   // Merges the given set of encrypted types with the existing set and emits a
   // notification if necessary.
   // Note: must be called from within a transaction.
   void MergeEncryptedTypes(ModelTypeSet new_encrypted_types,
                            syncable::BaseTransaction* const trans);
 
   // Helper methods for ensuring transactions are held when accessing
   // |vault_unsafe_|.
   Vault* UnlockVaultMutable(syncable::BaseTransaction* const trans);
   const Vault& UnlockVault(syncable::BaseTransaction* const trans) const;
 
+  // Helper method for determining if migration of a nigori node should be
+  // triggered or not.
+  // Conditions for triggering migration:
+  // 1. Cryptographer has no pending keys
+  // 2. Nigori node isn't already properly migrated.
+  // 3. Keystore key is available (if we are not migrated yet).
+  // Note: if the nigori node is migrated but has an invalid state, will return
+  // true (e.g. node has KEYSTORE_PASSPHRASE, local is CUSTOM_PASSPHRASE).
+  bool ShouldTriggerMigration(const sync_pb::NigoriSpecifics& nigori,
+                              const Cryptographer& cryptographer) const;
+
+  // Performs the actual migration of the |nigori_node| to support keystore
+  // encryption iff ShouldTriggerMigration(..) returns true.
+  bool AttemptToMigrateNigoriToKeystore(WriteTransaction* trans,
+                                        WriteNode* nigori_node);
+
+  // Fill |encrypted_blob| with the keystore decryptor token if
+  // |encrypted_blob|'s contents didn't already contain the key.
+  // The keystore decryptor token is the serialized current default encryption
+  // key, encrypted with the keystore key.
+  bool GetKeystoreDecryptor(
+      const Cryptographer& cryptographer,
+      const std::string& keystore_key,
+      sync_pb::EncryptedData* encrypted_blob);
+
+  // Helper method for installing the keys encrypted in |encryption_keybag|
+  // into |cryptographer|.
+  // Returns true on success, false if we were unable to install the keybag.
+  // Will not update the default key.
+  bool AttemptToInstallKeybag(const sync_pb::EncryptedData& keybag,
+                              bool update_default,
+                              Cryptographer* cryptographer);
+
+  // Helper method for decrypting pending keys with the keystore bootstrap.
+  // If successful, the default will become the key encrypted in the keystore
+  // bootstrap, and will return true. Else will return false.
+  bool DecryptPendingKeysWithKeystoreKey(
+      const std::string& keystore_key,
+      const sync_pb::EncryptedData& keystore_bootstrap,
+      Cryptographer* cryptographer);
+
+  // Helper to enable encrypt everything, notifying observers if necessary.
+  // Will not perform re-encryption.
+  void EnableEncryptEverythingImpl(syncable::BaseTransaction* const trans);
+
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncEncryptionHandlerImpl> weak_ptr_factory_;
 
   ObserverList<SyncEncryptionHandler::Observer> observers_;
 
   // The current user share (for creating transactions).
   UserShare* user_share_;
 
   // Container for all data that can be accessed from multiple threads. Do not
   // access this object directly. Instead access it via UnlockVault(..) and
   // UnlockVaultMutable(..).
   Vault vault_unsafe_;
 
   // Sync encryption state that is only modified and accessed from the sync
   // thread.
   // Whether all current and future types should be encrypted.
   bool encrypt_everything_;
   // The current state of the passphrase required to decrypt the encryption
   // keys stored in the nigori node.
-  PassphraseState passphrase_state_;
+  PassphraseType passphrase_type_;
 
   // The keystore key provided by the server.
   std::string keystore_key_;
 
   // The number of times we've automatically (i.e. not via SetPassphrase or
   // conflict resolver) updated the nigori's encryption keys in this chrome
   // instantiation.
   int nigori_overwrite_count_;
 
+  // The time (in ms) the nigori was migrated to support keystore encryption.
+  int64 migration_time_ms_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncEncryptionHandlerImpl);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_SYNC_ENCRYPTION_HANDLER_IMPL_H_