Separate cert loading code from CertLibrary and move to src/chromeos

chromeos/cryptohome/cryptohome_library.cc

 // 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 "chromeos/cryptohome/cryptohome_library.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "crypto/encryptor.h"
 #include "crypto/nss_util.h"
 #include "crypto/sha2.h"
 #include "crypto/symmetric_key.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kStubSystemSalt[] = "stub_system_salt";
-const size_t kKeySize = 16;
+const size_t kNonceSize = 16;
 
 // Does nothing.  Used as a Cryptohome::VoidMethodCallback.
 void DoNothing(DBusMethodCallStatus call_status) {}
 
 }  // namespace
 
 // This class handles the interaction with the ChromeOS cryptohome library APIs.
 class CryptohomeLibraryImpl : public CryptohomeLibrary {
  public:
   CryptohomeLibraryImpl() : weak_ptr_factory_(this) {
@@ skipping 125 matching lines @@
   }
 
   // TODO: should this use the system salt for both the password and the salt
   // value, or should this use a separate salt value?
   bool LoadSystemSaltKey() {
     if (!system_salt_key_.get())
       system_salt_key_.reset(PassphraseToKey(GetSystemSalt(), GetSystemSalt()));
     return system_salt_key_.get();
   }
 
-  crypto::SymmetricKey* PassphraseToKey(const std::string& passprhase,
+  crypto::SymmetricKey* PassphraseToKey(const std::string& passphrase,
                                         const std::string& salt) {
     return crypto::SymmetricKey::DeriveKeyFromPassword(
-        crypto::SymmetricKey::AES, passprhase, salt, 1000, 256);
+        crypto::SymmetricKey::AES, passphrase, salt, 1000, 256);
   }
 
 
   // Encrypts (AES) the token given |key| and |salt|.
   std::string EncryptTokenWithKey(crypto::SymmetricKey* key,
                                   const std::string& salt,
                                   const std::string& token) {
     crypto::Encryptor encryptor;
     if (!encryptor.Init(key, crypto::Encryptor::CTR, std::string())) {
       LOG(WARNING) << "Failed to initialize Encryptor.";
       return std::string();
     }
-    std::string nonce = salt.substr(0, kKeySize);
+    std::string nonce = salt.substr(0, kNonceSize);
     std::string encoded_token;
     CHECK(encryptor.SetCounter(nonce));
     if (!encryptor.Encrypt(token, &encoded_token)) {
       LOG(WARNING) << "Failed to encrypt token.";
       return std::string();
     }
 
     return StringToLowerASCII(base::HexEncode(
         reinterpret_cast<const void*>(encoded_token.data()),
         encoded_token.size()));
@@ skipping 11 matching lines @@
 
     std::string encrypted_token(
         reinterpret_cast<char*>(encrypted_token_bytes.data()),
         encrypted_token_bytes.size());
     crypto::Encryptor encryptor;
     if (!encryptor.Init(key, crypto::Encryptor::CTR, std::string())) {
       LOG(WARNING) << "Failed to initialize Encryptor.";
       return std::string();
     }
 
-    std::string nonce = salt.substr(0, kKeySize);
+    std::string nonce = salt.substr(0, kNonceSize);
     std::string token;
     CHECK(encryptor.SetCounter(nonce));
     if (!encryptor.Decrypt(encrypted_token, &token)) {
       LOG(WARNING) << "Failed to decrypt token.";
       return std::string();
     }
     return token;
   }
 
   base::WeakPtrFactory<CryptohomeLibraryImpl> weak_ptr_factory_;
@@ skipping 115 matching lines @@
   CHECK(!g_test_cryptohome_library || !impl);
   g_test_cryptohome_library = impl;
 }
 
 // static
 CryptohomeLibrary* CryptohomeLibrary::GetTestImpl() {
   return new CryptohomeLibraryStubImpl();
 }
 
 } // namespace chromeos