Let the Nigori client import and export raw encryption keys.

chrome/browser/sync/util/cryptographer.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/util/cryptographer.h"
 
 namespace browser_sync {
 
 const char kNigoriTag[] = "google_chrome_nigori";
 
@@ skipping 65 matching lines @@
   }
 
   // Encrypt the bag with the default Nigori.
   return Encrypt(bag, encrypted);
 }
 
 bool Cryptographer::AddKey(const KeyParams& params) {
   DCHECK(NULL == pending_keys_.get());
 
   // Create the new Nigori and make it the default encryptor.
-  scoped_ptr<Nigori> nigori(new Nigori(params.hostname));
-  if (!nigori->Init(params.username, params.password)) {
+  scoped_ptr<Nigori> nigori(new Nigori);
+  if (!nigori->InitByDerivation(params.hostname,
+                                params.username,
+                                params.password)) {
     NOTREACHED();  // Invalid username or password.
     return false;
   }
   std::string name;
   if (!nigori->Permute(Nigori::Password, kNigoriKeyName, &name)) {
     NOTREACHED();
     return false;
   }
   nigoris_[name] = make_linked_ptr(nigori.release());
   default_nigori_ = &*nigoris_.find(name);
@@ skipping 10 matching lines @@
   InstallKeys(encrypted.key_name(), bag);
   return true;
 }
 
 void Cryptographer::SetPendingKeys(const sync_pb::EncryptedData& encrypted) {
   DCHECK(!CanDecrypt(encrypted));
   pending_keys_.reset(new sync_pb::EncryptedData(encrypted));
 }
 
 bool Cryptographer::DecryptPendingKeys(const KeyParams& params) {
-  Nigori nigori(params.hostname);
-  if (!nigori.Init(params.username, params.password)) {
+  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;
   }
   InstallKeys(pending_keys_->key_name(), bag);
   pending_keys_.reset();
   return true;
 }
 
 void Cryptographer::InstallKeys(const std::string& default_key_name,
                                 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(key.hostname()));
-      if (!new_nigori->Init(key.username(), key.password())) {
+      scoped_ptr<Nigori> new_nigori(new Nigori);
+      if (!new_nigori->InitByDerivation(key.hostname(),
+                                        key.username(),
+                                        key.password())) {
         NOTREACHED();
         continue;
       }
       nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
     }
   }
   DCHECK(nigoris_.end() != nigoris_.find(default_key_name));
   default_nigori_ = &*nigoris_.find(default_key_name);
 }
 
 }  // namespace browser_sync