Let the Nigori client import and export raw encryption keys.

chrome/browser/sync/util/nigori.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_UTIL_NIGORI_H_
 #define CHROME_BROWSER_SYNC_UTIL_NIGORI_H_
 #pragma once
 
 #include <string>
 
@@ skipping 10 matching lines @@
 // for your secret (basically a map key), and |Encrypt| and |Decrypt| to store
 // and retrieve the secret.
 //
 // TODO: Link to doc.
 class Nigori {
  public:
   enum Type {
     Password = 1,
   };
 
-  // Creates a Nigori client for communicating with |hostname|. Note that
-  // |hostname| is used to derive the keys used to encrypt and decrypt data.
-  explicit Nigori(const std::string& hostname);
+  Nigori();
   virtual ~Nigori();
 
-  // Initialize the client with the supplied |username| and |password|.
-  bool Init(const std::string& username, const std::string& password);
+  // Initialize the client with the given |hostname|, |username| and |password|.
+  bool InitByDerivation(const std::string& hostname,
+                        const std::string& username,
+                        const std::string& password);
+
+  // Initialize the client by importing the given keys instead of deriving new
+  // ones.
+  bool InitByImport(const std::string& user_key,
+                    const std::string& encryption_key,
+                    const std::string& mac_key);
 
   // Derives a secure lookup name from |type| and |name|. If |hostname|,
   // |username| and |password| are kept constant, a given |type| and |name| pair
   // always yields the same |permuted| value. Note that |permuted| will be
   // Base64 encoded.
   bool Permute(Type type, const std::string& name, std::string* permuted) const;
 
   // Encrypts |value|. Note that on success, |encrypted| will be Base64
   // encoded.
   bool Encrypt(const std::string& value, std::string* encrypted) const;
 
   // Decrypts |value| into |decrypted|. It is assumed that |value| is Base64
   // encoded.
   bool Decrypt(const std::string& value, std::string* decrypted) const;
 
+  // Exports the raw derived keys.
+  bool ExportKeys(std::string* user_key,
+                  std::string* encryption_key,
+                  std::string* mac_key) const;
+
   // The next three getters return the parameters used to initialize the keys.
   // Given the hostname, username and password, another Nigori object capable of
   // encrypting and decrypting the same data as this one could be initialized.
   const std::string& hostname() const { return hostname_; }
   const std::string& username() const { return username_; }
   const std::string& password() const { return password_; }
 
   static const char kSaltSalt[];  // The salt used to derive the user salt.
   static const size_t kSaltKeySizeInBits = 128;
   static const size_t kDerivedKeySizeInBits = 128;
@@ skipping 11 matching lines @@
   std::string password_;
 
   scoped_ptr<base::SymmetricKey> user_key_;
   scoped_ptr<base::SymmetricKey> encryption_key_;
   scoped_ptr<base::SymmetricKey> mac_key_;
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_UTIL_NIGORI_H_