Let the Nigori client import and export raw encryption keys.

chrome/browser/sync/util/nigori.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/nigori.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>  // for htonl
 #endif
 
@@ skipping 43 matching lines @@
     return stream_.str();
   }
 
  private:
   std::ostringstream stream_;
 };
 
 // static
 const char Nigori::kSaltSalt[] = "saltsalt";
 
-Nigori::Nigori(const std::string& hostname)
-    : hostname_(hostname) {
+Nigori::Nigori() {
 }
 
 Nigori::~Nigori() {
 }
 
-bool Nigori::Init(const std::string& username, const std::string& password) {
+bool Nigori::InitByDerivation(const std::string& hostname,
+                              const std::string& username,
+                              const std::string& password) {
+  hostname_ = hostname;
   username_ = username;
   password_ = password;
 
   NigoriStream salt_password;
-  salt_password << username << hostname_;
+  salt_password << username << hostname;
 
   // Suser = PBKDF2(Username || Servername, "saltsalt", Nsalt, 8)
   scoped_ptr<SymmetricKey> user_salt(SymmetricKey::DeriveKeyFromPassword(
       SymmetricKey::HMAC_SHA1, salt_password.str(),
       kSaltSalt,
       kSaltIterations,
       kSaltKeySizeInBits));
   DCHECK(user_salt.get());
 
   std::string raw_user_salt;
@@ skipping 11 matching lines @@
 
   // Kmac = PBKDF2(P, Suser, Nmac, 16)
   mac_key_.reset(SymmetricKey::DeriveKeyFromPassword(
       SymmetricKey::HMAC_SHA1, password, raw_user_salt, kSigningIterations,
       kDerivedKeySizeInBits));
   DCHECK(mac_key_.get());
 
   return true;
 }
 
+bool Nigori::InitByImport(const std::string& user_key,
+                          const std::string& encryption_key,
+                          const std::string& mac_key) {
+  user_key_.reset(SymmetricKey::Import(SymmetricKey::AES, user_key));
+  DCHECK(user_key_.get());
+
+  encryption_key_.reset(SymmetricKey::Import(SymmetricKey::AES,
+                                             encryption_key));
+  DCHECK(encryption_key_.get());
+
+  mac_key_.reset(SymmetricKey::Import(SymmetricKey::HMAC_SHA1, mac_key));
+  DCHECK(mac_key_.get());
+
+  return user_key_.get() && encryption_key_.get() && mac_key_.get();
+}
+
 // Permute[Kenc,Kmac](type || name)
 bool Nigori::Permute(Type type, const std::string& name,
                      std::string* permuted) const {
   DCHECK_LT(0U, name.size());
 
   NigoriStream plaintext;
   plaintext << type << name;
 
   Encryptor encryptor;
   if (!encryptor.Init(encryption_key_.get(), Encryptor::CBC,
@@ skipping 103 matching lines @@
   if (!encryptor.Init(encryption_key_.get(), Encryptor::CBC, iv))
     return false;
 
   std::string plaintext;
   if (!encryptor.Decrypt(ciphertext, value))
     return false;
 
   return true;
 }
 
+bool Nigori::ExportKeys(std::string* user_key,
+                        std::string* encryption_key,
+                        std::string* mac_key) const {
+  DCHECK(user_key);
+  DCHECK(encryption_key);
+  DCHECK(mac_key);
+
+  return user_key_->GetRawKey(user_key) &&
+      encryption_key_->GetRawKey(encryption_key) &&
+      mac_key_->GetRawKey(mac_key);
+}
+
 }  // namespace browser_sync