blob: 0fe0b25a3c8922329eede2daa12bf0b1368a795c [file] [log] [blame]
// 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.
#include "sync/util/cryptographer.h"
#include <algorithm>
#include "base/base64.h"
#include "base/basictypes.h"
#include "base/logging.h"
#include "sync/protocol/nigori_specifics.pb.h"
#include "sync/util/encryptor.h"
namespace syncer {
const char kNigoriTag[] = "google_chrome_nigori";
// We name a particular Nigori instance (ie. a triplet consisting of a hostname,
// a username, and a password) by calling Permute on this string. Since the
// output of Permute is always the same for a given triplet, clients will always
// assign the same name to a particular triplet.
const char kNigoriKeyName[] = "nigori-key";
Cryptographer::Cryptographer(Encryptor* encryptor)
: encryptor_(encryptor) {
DCHECK(encryptor);
}
Cryptographer::Cryptographer(const Cryptographer& other)
: encryptor_(other.encryptor_),
default_nigori_name_(other.default_nigori_name_) {
for (NigoriMap::const_iterator it = other.nigoris_.begin();
it != other.nigoris_.end();
++it) {
std::string user_key, encryption_key, mac_key;
it->second->ExportKeys(&user_key, &encryption_key, &mac_key);
linked_ptr<Nigori> nigori_copy(new Nigori());
nigori_copy->InitByImport(user_key, encryption_key, mac_key);
nigoris_.insert(std::make_pair(it->first, nigori_copy));
}
if (other.pending_keys_) {
pending_keys_.reset(new sync_pb::EncryptedData(*(other.pending_keys_)));
}
}
Cryptographer::~Cryptographer() {}
void Cryptographer::Bootstrap(const std::string& restored_bootstrap_token) {
if (is_initialized()) {
NOTREACHED();
return;
}
std::string serialized_nigori_key =
UnpackBootstrapToken(restored_bootstrap_token);
if (serialized_nigori_key.empty())
return;
ImportNigoriKey(serialized_nigori_key);
}
bool Cryptographer::CanDecrypt(const sync_pb::EncryptedData& data) const {
return nigoris_.end() != nigoris_.find(data.key_name());
}
bool Cryptographer::CanDecryptUsingDefaultKey(
const sync_pb::EncryptedData& data) const {
return !default_nigori_name_.empty() &&
data.key_name() == default_nigori_name_;
}
bool Cryptographer::Encrypt(
const ::google::protobuf::MessageLite& message,
sync_pb::EncryptedData* encrypted) const {
DCHECK(encrypted);
if (default_nigori_name_.empty()) {
LOG(ERROR) << "Cryptographer not ready, failed to encrypt.";
return false;
}
std::string serialized;
if (!message.SerializeToString(&serialized)) {
LOG(ERROR) << "Message is invalid/missing a required field.";
return false;
}
return EncryptString(serialized, encrypted);
}
bool Cryptographer::EncryptString(
const std::string& serialized,
sync_pb::EncryptedData* encrypted) const {
if (CanDecryptUsingDefaultKey(*encrypted)) {
const std::string& original_serialized = DecryptToString(*encrypted);
if (original_serialized == serialized) {
DVLOG(2) << "Re-encryption unnecessary, encrypted data already matches.";
return true;
}
}
NigoriMap::const_iterator default_nigori =
nigoris_.find(default_nigori_name_);
if (default_nigori == nigoris_.end()) {
LOG(ERROR) << "Corrupt default key.";
return false;
}
encrypted->set_key_name(default_nigori_name_);
if (!default_nigori->second->Encrypt(serialized,
encrypted->mutable_blob())) {
LOG(ERROR) << "Failed to encrypt data.";
return false;
}
return true;
}
bool Cryptographer::Decrypt(const sync_pb::EncryptedData& encrypted,
::google::protobuf::MessageLite* message) const {
DCHECK(message);
std::string plaintext = DecryptToString(encrypted);
return message->ParseFromString(plaintext);
}
std::string Cryptographer::DecryptToString(
const sync_pb::EncryptedData& encrypted) const {
NigoriMap::const_iterator it = nigoris_.find(encrypted.key_name());
if (nigoris_.end() == it) {
// The key used to encrypt the blob is not part of the set of installed
// nigoris.
LOG(ERROR) << "Cannot decrypt message";
return std::string();
}
std::string plaintext;
if (!it->second->Decrypt(encrypted.blob(), &plaintext)) {
return std::string();
}
return plaintext;
}
bool Cryptographer::GetKeys(sync_pb::EncryptedData* encrypted) const {
DCHECK(encrypted);
DCHECK(!nigoris_.empty());
// Create a bag of all the Nigori parameters we know about.
sync_pb::NigoriKeyBag bag;
for (NigoriMap::const_iterator it = nigoris_.begin(); it != nigoris_.end();
++it) {
const Nigori& nigori = *it->second;
sync_pb::NigoriKey* key = bag.add_key();
key->set_name(it->first);
nigori.ExportKeys(key->mutable_user_key(),
key->mutable_encryption_key(),
key->mutable_mac_key());
}
// Encrypt the bag with the default Nigori.
return Encrypt(bag, encrypted);
}
bool Cryptographer::AddKey(const KeyParams& params) {
// Create the new Nigori and make it the default encryptor.
scoped_ptr<Nigori> nigori(new Nigori);
if (!nigori->InitByDerivation(params.hostname,
params.username,
params.password)) {
NOTREACHED(); // Invalid username or password.
return false;
}
return AddKeyImpl(nigori.Pass(), true);
}
bool Cryptographer::AddNonDefaultKey(const KeyParams& params) {
DCHECK(is_initialized());
// Create the new Nigori and add it to the keybag.
scoped_ptr<Nigori> nigori(new Nigori);
if (!nigori->InitByDerivation(params.hostname,
params.username,
params.password)) {
NOTREACHED(); // Invalid username or password.
return false;
}
return AddKeyImpl(nigori.Pass(), false);
}
bool Cryptographer::AddKeyFromBootstrapToken(
const std::string& restored_bootstrap_token) {
// Create the new Nigori and make it the default encryptor.
std::string serialized_nigori_key = UnpackBootstrapToken(
restored_bootstrap_token);
return ImportNigoriKey(serialized_nigori_key);
}
bool Cryptographer::AddKeyImpl(scoped_ptr<Nigori> initialized_nigori,
bool set_as_default) {
std::string name;
if (!initialized_nigori->Permute(Nigori::Password, kNigoriKeyName, &name)) {
NOTREACHED();
return false;
}
nigoris_[name] = make_linked_ptr(initialized_nigori.release());
// Check if the key we just added can decrypt the pending keys and add them
// too if so.
if (pending_keys_.get() && CanDecrypt(*pending_keys_)) {
sync_pb::NigoriKeyBag pending_bag;
Decrypt(*pending_keys_, &pending_bag);
InstallKeyBag(pending_bag);
SetDefaultKey(pending_keys_->key_name());
pending_keys_.reset();
}
// The just-added key takes priority over the pending keys as default.
if (set_as_default) SetDefaultKey(name);
return true;
}
void Cryptographer::InstallKeys(const sync_pb::EncryptedData& encrypted) {
DCHECK(CanDecrypt(encrypted));
sync_pb::NigoriKeyBag bag;
if (!Decrypt(encrypted, &bag))
return;
InstallKeyBag(bag);
}
void Cryptographer::SetDefaultKey(const std::string& key_name) {
DCHECK(nigoris_.end() != nigoris_.find(key_name));
default_nigori_name_ = key_name;
}
void Cryptographer::SetPendingKeys(const sync_pb::EncryptedData& encrypted) {
DCHECK(!CanDecrypt(encrypted));
DCHECK(!encrypted.blob().empty());
pending_keys_.reset(new sync_pb::EncryptedData(encrypted));
}
const sync_pb::EncryptedData& Cryptographer::GetPendingKeys() const {
DCHECK(has_pending_keys());
return *(pending_keys_.get());
}
bool Cryptographer::DecryptPendingKeys(const KeyParams& params) {
Nigori nigori;
if (!nigori.InitByDerivation(params.hostname,
params.username,
params.password)) {
NOTREACHED();
return false;
}
std::string plaintext;
if (!nigori.Decrypt(pending_keys_->blob(), &plaintext))
return false;
sync_pb::NigoriKeyBag bag;
if (!bag.ParseFromString(plaintext)) {
NOTREACHED();
return false;
}
InstallKeyBag(bag);
const std::string& new_default_key_name = pending_keys_->key_name();
SetDefaultKey(new_default_key_name);
pending_keys_.reset();
return true;
}
bool Cryptographer::GetBootstrapToken(std::string* token) const {
DCHECK(token);
std::string unencrypted_token = GetDefaultNigoriKeyData();
if (unencrypted_token.empty())
return false;
std::string encrypted_token;
if (!encryptor_->EncryptString(unencrypted_token, &encrypted_token)) {
return false;
}
base::Base64Encode(encrypted_token, token);
return true;
}
std::string Cryptographer::UnpackBootstrapToken(
const std::string& token) const {
if (token.empty())
return std::string();
std::string encrypted_data;
if (!base::Base64Decode(token, &encrypted_data)) {
DLOG(WARNING) << "Could not decode token.";
return std::string();
}
std::string unencrypted_token;
if (!encryptor_->DecryptString(encrypted_data, &unencrypted_token)) {
DLOG(WARNING) << "Decryption of bootstrap token failed.";
return std::string();
}
return unencrypted_token;
}
void Cryptographer::InstallKeyBag(const sync_pb::NigoriKeyBag& bag) {
int key_size = bag.key_size();
for (int i = 0; i < key_size; ++i) {
const sync_pb::NigoriKey key = bag.key(i);
// Only use this key if we don't already know about it.
if (nigoris_.end() == nigoris_.find(key.name())) {
scoped_ptr<Nigori> new_nigori(new Nigori);
if (!new_nigori->InitByImport(key.user_key(),
key.encryption_key(),
key.mac_key())) {
NOTREACHED();
continue;
}
nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
}
}
}
bool Cryptographer::KeybagIsStale(
const sync_pb::EncryptedData& encrypted_bag) const {
if (!is_ready())
return false;
if (encrypted_bag.blob().empty())
return true;
if (!CanDecrypt(encrypted_bag))
return false;
if (!CanDecryptUsingDefaultKey(encrypted_bag))
return true;
sync_pb::NigoriKeyBag bag;
if (!Decrypt(encrypted_bag, &bag)) {
LOG(ERROR) << "Failed to decrypt keybag for stale check. "
<< "Assuming keybag is corrupted.";
return true;
}
if (static_cast<size_t>(bag.key_size()) < nigoris_.size())
return true;
return false;
}
std::string Cryptographer::GetDefaultNigoriKeyName() const {
return default_nigori_name_;
}
std::string Cryptographer::GetDefaultNigoriKeyData() const {
if (!is_initialized())
return std::string();
NigoriMap::const_iterator iter = nigoris_.find(default_nigori_name_);
if (iter == nigoris_.end())
return std::string();
sync_pb::NigoriKey key;
if (!iter->second->ExportKeys(key.mutable_user_key(),
key.mutable_encryption_key(),
key.mutable_mac_key()))
return std::string();
return key.SerializeAsString();
}
bool Cryptographer::ImportNigoriKey(const std::string& serialized_nigori_key) {
if (serialized_nigori_key.empty())
return false;
sync_pb::NigoriKey key;
if (!key.ParseFromString(serialized_nigori_key))
return false;
scoped_ptr<Nigori> nigori(new Nigori);
if (!nigori->InitByImport(key.user_key(), key.encryption_key(),
key.mac_key())) {
NOTREACHED();
return false;
}
if (!AddKeyImpl(nigori.Pass(), true))
return false;
return true;
}
} // namespace syncer