Refactoring key generation and export util code to make mocking possible.

chrome/browser/chromeos/login/owner_key_utils.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/chromeos/login/owner_manager.h"
+#include "chrome/browser/chromeos/login/owner_key_utils.h"
 
 #include <keyhi.h>     // SECKEY_CreateSubjectPublicKeyInfo()
 #include <pk11pub.h>
 #include <prerror.h>   // PR_GetError()
 #include <secder.h>    // DER_Encode()
 #include <secmod.h>
 
 #include <limits>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/nss_util_internal.h"
 #include "base/nss_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 
 // static
-const char OwnerManager::kOwnerKeyFile[] = "/var/lib/whitelist/owner.key";
+OwnerKeyUtils::Factory* OwnerKeyUtils::factory_ = NULL;
+
+class OwnerKeyUtilsImpl : public OwnerKeyUtils {
+ public:
+  OwnerKeyUtilsImpl();
+  virtual ~OwnerKeyUtilsImpl();
+
+  bool GenerateKeyPair(SECKEYPrivateKey** private_key_out,
+                               SECKEYPublicKey** public_key_out);
+
+  bool ExportPublicKey(SECKEYPublicKey* key, const FilePath& key_file);
+
+  SECKEYPublicKey* ImportPublicKey(const FilePath& key_file);
+
+ private:
+  // Fills in fields of |key_der| with DER encoded data from a file at
+  // |key_file|.  The caller must pass in a pointer to an actual SECItem
+  // struct for |key_der|.  |key_der->data| should be initialized to NULL
+  // and |key_der->len| should be set to 0.
+  //
+  // Upon success, data is stored in key_der->data, and the caller takes
+  // ownership.  Returns false on error.
+  //
+  // To free the data, call
+  //    SECITEM_FreeItem(key_der, PR_FALSE);
+  static bool ReadDERFromFile(const FilePath& key_file, SECItem* key_der);
+
+  // The place outside the owner's encrypted home directory where her
+  // key will live.
+  static const char kOwnerKeyFile[];
+
+  // Key generation parameters.
+  static const uint32 kKeyGenMechanism;  // used by PK11_GenerateKeyPair()
+  static const unsigned long kExponent;
+  static const int kKeySizeInBits;
+
+  DISALLOW_COPY_AND_ASSIGN(OwnerKeyUtilsImpl);
+};
+
+OwnerKeyUtils::OwnerKeyUtils() {}
+
+OwnerKeyUtils::~OwnerKeyUtils() {}
+
+OwnerKeyUtils* OwnerKeyUtils::Create() {
+  if (!factory_)
+    return new OwnerKeyUtilsImpl();
+  else
+    return factory_->CreateOwnerKeyUtils();
+}
+
+// static
+const char OwnerKeyUtilsImpl::kOwnerKeyFile[] = "/var/lib/whitelist/owner.key";
 
 // We're generating and using 2048-bit RSA keys.
 // static
-const uint32 OwnerManager::kKeyGenMechanism = CKM_RSA_PKCS_KEY_PAIR_GEN;
+const uint32 OwnerKeyUtilsImpl::kKeyGenMechanism = CKM_RSA_PKCS_KEY_PAIR_GEN;
 // static
-const unsigned long OwnerManager::kExponent = 65537UL;
+const unsigned long OwnerKeyUtilsImpl::kExponent = 65537UL;
 // static
-const int OwnerManager::kKeySizeInBits = 2048;
+const int OwnerKeyUtilsImpl::kKeySizeInBits = 2048;
 
-// static
-bool OwnerManager::GenerateKeyPair(SECKEYPrivateKey** private_key_out,
-                                   SECKEYPublicKey** public_key_out) {
+OwnerKeyUtilsImpl::OwnerKeyUtilsImpl(){}
+
+OwnerKeyUtilsImpl::~OwnerKeyUtilsImpl() {}
+
+bool OwnerKeyUtilsImpl::GenerateKeyPair(SECKEYPrivateKey** private_key_out,
+                                        SECKEYPublicKey** public_key_out) {
   DCHECK(private_key_out);
   DCHECK(public_key_out);
 
   *private_key_out = NULL;
   *public_key_out = NULL;
 
   // Temporary structures used for generating the result
   // in the right format.
   PK11SlotInfo* slot = NULL;
   PK11RSAGenParams rsa_key_gen_params;
@@ skipping 61 matching lines @@
   } else {
     LOG(INFO) << "Owner key generation succeeded!";
   }
   if (slot != NULL) {
     PK11_FreeSlot(slot);
   }
 
   return is_success;
 }
 
-// static
-bool OwnerManager::ExportPublicKey(SECKEYPublicKey* key,
-                                   const FilePath& key_file) {
+bool OwnerKeyUtilsImpl::ExportPublicKey(SECKEYPublicKey* key,
+                                        const FilePath& key_file) {
   DCHECK(key);
   SECItem* der;
   bool ok = false;
   int safe_file_size = 0;
 
   // Instead of exporting/importing the key directly, I'm actually
   // going to use a SubjectPublicKeyInfo.  The reason is because NSS
   // exports functions that encode/decode these kinds of structures, while
   // it does not export the ones that deal directly with public keys.
   der = SECKEY_EncodeDERSubjectPublicKeyInfo(key);
   if (!der) {
     LOG(ERROR) << "Could not encode public key for export!";
     return false;
   }
 
   if (der->len > static_cast<uint>(INT_MAX)) {
     LOG(ERROR) << "key is too big! " << der->len;
   } else {
     safe_file_size = static_cast<int>(der->len);
 
     ok = (safe_file_size ==
           file_util::WriteFile(key_file,
                                reinterpret_cast<char*>(der->data),
                                der->len));
   }
   SECITEM_FreeItem(der, PR_TRUE);
   return ok;
 }
 
-// static
-SECKEYPublicKey* OwnerManager::ImportPublicKey(const FilePath& key_file) {
+SECKEYPublicKey* OwnerKeyUtilsImpl::ImportPublicKey(const FilePath& key_file) {
   SECItem key_der;
 
   if (!ReadDERFromFile(key_file, &key_der)) {
     PLOG(ERROR) << "Could not read in key from " << key_file.value() << ":";
     return NULL;
   }
 
   // See the comment in ExportPublicKey() for why I wrote a
   // SubjectPublicKeyInfo to disk instead of a key.
   CERTSubjectPublicKeyInfo* spki =
      SECKEY_DecodeDERSubjectPublicKeyInfo(&key_der);
   if (!spki) {
     LOG(ERROR) << "Could not decode key info: " << PR_GetError();
+    SECITEM_FreeItem(&key_der, PR_FALSE);
     return NULL;
   }
 
   SECKEYPublicKey *public_key = SECKEY_ExtractPublicKey(spki);
   SECKEY_DestroySubjectPublicKeyInfo(spki);
+  SECITEM_FreeItem(&key_der, PR_FALSE);
   return public_key;
 }
 
 // static
-bool OwnerManager::ReadDERFromFile(const FilePath& key_file,
-                                   SECItem* key_der) {
+bool OwnerKeyUtilsImpl::ReadDERFromFile(const FilePath& key_file,
+                                        SECItem* key_der) {
   // I'd use NSS' SECU_ReadDERFromFile() here, but the SECU_* functions are
   // considered internal to the NSS command line utils.
   // This code is lifted, in spirit, from the implementation of that function.
   DCHECK(key_der) << "Don't pass NULL for |key_der|";
 
   // Get the file size (must fit in a 32 bit int for NSS).
   int64 file_size;
   if (!file_util::GetFileSize(key_file, &file_size)) {
     LOG(ERROR) << "Could not get size of " << key_file.value();
     return false;
@@ skipping 18 matching lines @@
                                       safe_file_size);
 
   if (data_read != safe_file_size) {
     LOG(ERROR) << "Read the wrong amount of data from the DER encoded key! "
                << data_read;
     SECITEM_FreeItem(key_der, PR_FALSE);
     return false;
   }
   return true;
 }