Eliminate CHECK from CryptohomeLibrary::LoadSystemSalt

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"
@@ skipping 15 matching lines @@
 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) {
+  CryptohomeLibraryImpl() {
   }
 
   virtual ~CryptohomeLibraryImpl() {
   }
 
   virtual bool TpmIsEnabled() OVERRIDE {
     bool result = false;
     DBusThreadManager::Get()->GetCryptohomeClient()->CallTpmIsEnabledAndBlock(
         &result);
     return result;
@@ skipping 63 matching lines @@
 
   virtual bool InstallAttributesIsFirstInstall() OVERRIDE {
     bool result = false;
     DBusThreadManager::Get()->GetCryptohomeClient()->
         InstallAttributesIsFirstInstall(&result);
     return result;
   }
 
   virtual std::string GetSystemSalt() OVERRIDE {
     LoadSystemSalt();  // no-op if it's already loaded.
-    return StringToLowerASCII(base::HexEncode(
-        reinterpret_cast<const void*>(system_salt_.data()),
-        system_salt_.size()));
+    return system_salt_;
   }
 
   virtual std::string EncryptWithSystemSalt(const std::string& token) OVERRIDE {
     // Don't care about token encryption while debugging.
     if (!base::chromeos::IsRunningOnChromeOS())
       return token;
 
     if (!LoadSystemSaltKey()) {
       LOG(WARNING) << "System salt key is not available for encrypt.";
       return std::string();
     }
     return EncryptTokenWithKey(system_salt_key_.get(),
-                               GetSystemSalt(),
+                               system_salt_,
                                token);
   }
 
   virtual std::string DecryptWithSystemSalt(
       const std::string& encrypted_token_hex) OVERRIDE {
     // Don't care about token encryption while debugging.
     if (!base::chromeos::IsRunningOnChromeOS())
       return encrypted_token_hex;
 
     if (!LoadSystemSaltKey()) {
       LOG(WARNING) << "System salt key is not available for decrypt.";
       return std::string();
     }
     return DecryptTokenWithKey(system_salt_key_.get(),
-                               GetSystemSalt(),
+                               system_salt_,
                                encrypted_token_hex);
   }
 
  private:
   void LoadSystemSalt() {
     if (!system_salt_.empty())
       return;
-    DBusThreadManager::Get()->GetCryptohomeClient()->
-        GetSystemSalt(&system_salt_);
-    CHECK(!system_salt_.empty());
-    CHECK_EQ(system_salt_.size() % 2, 0U);
+    std::vector<uint8> salt;
+    DBusThreadManager::Get()->GetCryptohomeClient()->GetSystemSalt(&salt);
+    if (salt.empty() || salt.size() % 2 != 0U) {
+      LOG(WARNING) << "System salt not available";
+      return;
+    }
+    system_salt_ = StringToLowerASCII(base::HexEncode(
+        reinterpret_cast<const void*>(salt.data()), salt.size()));
   }
 
   // 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_.empty())
+      return false;
     if (!system_salt_key_.get())
-      system_salt_key_.reset(PassphraseToKey(GetSystemSalt(), GetSystemSalt()));
+      system_salt_key_.reset(PassphraseToKey(system_salt_, system_salt_));
     return system_salt_key_.get();
   }
 
   crypto::SymmetricKey* PassphraseToKey(const std::string& passphrase,
                                         const std::string& salt) {
     return crypto::SymmetricKey::DeriveKeyFromPassword(
         crypto::SymmetricKey::AES, passphrase, salt, 1000, 256);
   }
 
 
@@ skipping 41 matching lines @@
     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_;
-  std::vector<uint8> system_salt_;
+  std::string system_salt_;
   // A key based on the system salt.  Useful for encrypting device-level
   // data for which we have no additional credentials.
   scoped_ptr<crypto::SymmetricKey> system_salt_key_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptohomeLibraryImpl);
 };
 
 class CryptohomeLibraryStubImpl : public CryptohomeLibrary {
  public:
   CryptohomeLibraryStubImpl()
@@ skipping 104 matching lines @@
   CHECK(!g_test_cryptohome_library || !impl);
   g_test_cryptohome_library = impl;
 }
 
 // static
 CryptohomeLibrary* CryptohomeLibrary::GetTestImpl() {
   return new CryptohomeLibraryStubImpl();
 }
 
 } // namespace chromeos