sync/test/fake_sync_encryption_handler.cc

   1 // Copyright (c) 2012 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 "sync/test/fake_sync_encryption_handler.h"
   6
   7 #include "sync/protocol/nigori_specifics.pb.h"
   8 #include "sync/syncable/nigori_util.h"
   9
  10 namespace syncer {
  11
  12 FakeSyncEncryptionHandler::FakeSyncEncryptionHandler()
  13     : encrypted_types_(SensitiveTypes()),
  14       encrypt_everything_(false),
  15       passphrase_type_(IMPLICIT_PASSPHRASE),
  16       cryptographer_(&encryptor_) {
  17 }
  18 FakeSyncEncryptionHandler::~FakeSyncEncryptionHandler() {}
  19
  20 void FakeSyncEncryptionHandler::Init() {
  21   // Set up a basic cryptographer.
  22   KeyParams keystore_params = {"localhost", "dummy", "keystore_key"};
  23   cryptographer_.AddKey(keystore_params);
  24 }
  25
  26 void FakeSyncEncryptionHandler::ApplyNigoriUpdate(
  27     const sync_pb::NigoriSpecifics& nigori,
  28     syncable::BaseTransaction* const trans) {
  29   if (nigori.encrypt_everything())
  30     EnableEncryptEverything();
  31   if (nigori.keybag_is_frozen())
  32     passphrase_type_ = CUSTOM_PASSPHRASE;
  33
  34   // TODO(zea): consider adding fake support for migration.
  35   if (cryptographer_.CanDecrypt(nigori.encryption_keybag()))
  36     cryptographer_.InstallKeys(nigori.encryption_keybag());
  37   else if (nigori.has_encryption_keybag())
  38     cryptographer_.SetPendingKeys(nigori.encryption_keybag());
  39
  40   if (cryptographer_.has_pending_keys()) {
  41     DVLOG(1) << "OnPassPhraseRequired Sent";
  42     sync_pb::EncryptedData pending_keys = cryptographer_.GetPendingKeys();
  43     FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
  44                       OnPassphraseRequired(REASON_DECRYPTION,
  45                                            pending_keys));
  46   } else if (!cryptographer_.is_ready()) {
  47     DVLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
  48              << "ready";
  49     FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
  50                       OnPassphraseRequired(REASON_ENCRYPTION,
  51                                            sync_pb::EncryptedData()));
  52   }
  53 }
  54
  55 void FakeSyncEncryptionHandler::UpdateNigoriFromEncryptedTypes(
  56     sync_pb::NigoriSpecifics* nigori,
  57     syncable::BaseTransaction* const trans) const {
  58   syncable::UpdateNigoriFromEncryptedTypes(encrypted_types_,
  59                                            encrypt_everything_,
  60                                            nigori);
  61 }
  62
  63 bool FakeSyncEncryptionHandler::NeedKeystoreKey(
  64     syncable::BaseTransaction* const trans) const {
  65   return keystore_key_.empty();
  66 }
  67
  68 bool FakeSyncEncryptionHandler::SetKeystoreKeys(
  69     const google::protobuf::RepeatedPtrField<google::protobuf::string>& keys,
  70     syncable::BaseTransaction* const trans) {
  71   if (keys.size() == 0)
  72     return false;
  73   std::string new_key = keys.Get(keys.size()-1);
  74   if (new_key.empty())
  75     return false;
  76   keystore_key_ = new_key;
  77
  78
  79   DVLOG(1) << "Keystore bootstrap token updated.";
  80   FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
  81                     OnBootstrapTokenUpdated(keystore_key_,
  82                                             KEYSTORE_BOOTSTRAP_TOKEN));
  83   return true;
  84 }
  85
  86 ModelTypeSet FakeSyncEncryptionHandler::GetEncryptedTypes(
  87     syncable::BaseTransaction* const trans) const {
  88   return encrypted_types_;
  89 }
  90
  91 void FakeSyncEncryptionHandler::AddObserver(Observer* observer) {
  92   observers_.AddObserver(observer);
  93 }
  94
  95 void FakeSyncEncryptionHandler::RemoveObserver(Observer* observer) {
  96   observers_.RemoveObserver(observer);
  97 }
  98
  99 void FakeSyncEncryptionHandler::SetEncryptionPassphrase(
 100     const std::string& passphrase,
 101     bool is_explicit) {
 102   if (is_explicit)
 103     passphrase_type_ = CUSTOM_PASSPHRASE;
 104 }
 105
 106 void FakeSyncEncryptionHandler::SetDecryptionPassphrase(
 107     const std::string& passphrase) {
 108   // Do nothing.
 109 }
 110
 111 void FakeSyncEncryptionHandler::EnableEncryptEverything() {
 112   if (encrypt_everything_)
 113     return;
 114   encrypt_everything_ = true;
 115   encrypted_types_ = ModelTypeSet::All();
 116   FOR_EACH_OBSERVER(
 117       Observer, observers_,
 118       OnEncryptedTypesChanged(encrypted_types_, encrypt_everything_));
 119 }
 120
 121 bool FakeSyncEncryptionHandler::EncryptEverythingEnabled() const {
 122   return encrypt_everything_;
 123 }
 124
 125 PassphraseType FakeSyncEncryptionHandler::GetPassphraseType() const {
 126   return passphrase_type_;
 127 }
 128
 129 }  // namespace syncer