Mocks for all libcros elements

chrome/browser/chromeos/login/google_authenticator.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 <errno.h>
 #include <string>
 #include <vector>
 #include <time.h>
 
 #include "base/logging.h"
@@ skipping 29 matching lines @@
 const char GoogleAuthenticator::kFormat[] =
     "Email=%s&"
     "Passwd=%s&"
     "PersistentCookie=%s&"
     "accountType=%s&"
     "source=%s&";
 const char GoogleAuthenticator::kCookiePersistence[] = "true";
 const char GoogleAuthenticator::kAccountType[] = "HOSTED_OR_GOOGLE";
 const char GoogleAuthenticator::kSource[] = "chromeos";
 const int GoogleAuthenticator::kHttpSuccess = 200;
+const int kPassHashLen = 32;
 
 // Chromium OS system salt stored here
 const char GoogleAuthenticator::kSystemSalt[] = "/home/.shadow/salt";
 
 // String that appears at the start of OpenSSL cipher text with embedded salt
 const char GoogleAuthenticator::kOpenSSLMagic[] = "Salted__";
 
 bool GoogleAuthenticator::Authenticate(const std::string& username,
                                        const std::string& password) {
   FilePath user_data_dir;
@@ skipping 35 matching lines @@
     if (client_login_handler_->CanHandle(url)) {
       fetcher_.reset(client_login_handler_->Handle(data, this));
     } else if (issue_handler_->CanHandle(url)) {
       fetcher_.reset(issue_handler_->Handle(data, this));
     } else {
       LOG(INFO) << "Online login successful!";
       ChromeThread::PostTask(
           ChromeThread::UI, FROM_HERE,
           NewRunnableFunction(GoogleAuthenticator::OnLoginSuccess,
                               consumer_,
-                              library_,
                               username_,
                               ascii_hash_,
                               cookies));
     }
   } else if (!status.is_success()) {
     LOG(INFO) << "Network fail";
     // The fetch failed for network reasons, try offline login.
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableFunction(GoogleAuthenticator::CheckOffline,
                             consumer_,
-                            library_,
                             username_,
                             ascii_hash_,
                             status));
   } else {
     std::string error;
     if (status.is_success()) {
       // The fetch succeeded, but ClientLogin said no.
       error.assign(data);
     } else {
       // We couldn't hit the network, and offline login failed.
       error.assign(strerror(status.os_error()));
     }
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableFunction(
             GoogleAuthenticator::OnLoginFailure, consumer_, error));
   }
 }
 
 // static
 void GoogleAuthenticator::OnLoginSuccess(LoginStatusConsumer* consumer,
-                                         CryptohomeLibrary* library,
                                          const std::string& username,
                                          const std::string& passhash,
                                          const ResponseCookies& cookies) {
-  if (library->Mount(username.c_str(), passhash.c_str()))
+  if (CrosLibrary::Get()->GetCryptohomeLibrary()->Mount(username.c_str(),
+                                                        passhash.c_str()))
     consumer->OnLoginSuccess(username, cookies);
   else
     GoogleAuthenticator::OnLoginFailure(consumer, "Could not mount cryptohome");
 }
 
 // static
 void GoogleAuthenticator::CheckOffline(LoginStatusConsumer* consumer,
-                                       CryptohomeLibrary* library,
                                        const std::string& username,
                                        const std::string& passhash,
                                        const URLRequestStatus& status) {
-  if (library->CheckKey(username.c_str(), passhash.c_str())) {
+  if (CrosLibrary::Get()->GetCryptohomeLibrary()->CheckKey(username.c_str(),
+                                                           passhash.c_str())) {
     // The fetch didn't succeed, but offline login did.
     LOG(INFO) << "Offline login successful!";
     ResponseCookies cookies;
     GoogleAuthenticator::OnLoginSuccess(consumer,
-                                        library,
                                         username,
                                         passhash,
                                         cookies);
   } else {
     // We couldn't hit the network, and offline login failed.
     GoogleAuthenticator::OnLoginFailure(consumer, strerror(status.os_error()));
   }
 }
 
 // static
@@ skipping 18 matching lines @@
   int data_read = ReadFile(path, salt, file_size);
 
   CHECK_EQ(data_read % 2, 0);
   system_salt_.assign(salt, salt + data_read);
 }
 
 std::string GoogleAuthenticator::SaltAsAscii() {
   FilePath salt_path(kSystemSalt);
   LoadSystemSalt(salt_path);
   unsigned int salt_len = system_salt_.size();
-  char ascii_salt[2 * salt_len];
+  char ascii_salt[2 * salt_len + 1];
   if (GoogleAuthenticator::BinaryToHex(system_salt_,
                                        salt_len,
                                        ascii_salt,
                                        sizeof(ascii_salt))) {
-    return std::string(ascii_salt, sizeof(ascii_salt));
+    return std::string(ascii_salt, sizeof(ascii_salt) - 1);
   } else {
     return std::string();
   }
 }
 
 void GoogleAuthenticator::StoreHashedPassword(const std::string& password) {
   // Get salt, ascii encode, update sha with that, then update with ascii
   // of password, then end.
   std::string ascii_salt = SaltAsAscii();
-  unsigned char passhash_buf[32];
-  char ascii_buf[32];
+  unsigned char passhash_buf[kPassHashLen];
+  char ascii_buf[kPassHashLen + 1];
 
   // Hash salt and password
   SHA256Context ctx;
   SHA256_Begin(&ctx);
   SHA256_Update(&ctx,
                 reinterpret_cast<const unsigned char*>(ascii_salt.data()),
                 static_cast<unsigned int>(ascii_salt.length()));
   SHA256_Update(&ctx,
                 reinterpret_cast<const unsigned char*>(password.data()),
                 static_cast<unsigned int>(password.length()));
   SHA256_End(&ctx,
              passhash_buf,
              NULL,
              static_cast<unsigned int>(sizeof(passhash_buf)));
 
   std::vector<unsigned char> passhash(passhash_buf,
                                       passhash_buf + sizeof(passhash_buf));
   BinaryToHex(passhash,
               passhash.size() / 2,  // only want top half, at least for now.
               ascii_buf,
               sizeof(ascii_buf));
-  ascii_hash_.assign(ascii_buf, sizeof(ascii_buf));
+  ascii_hash_.assign(ascii_buf, sizeof(ascii_buf) - 1);
 }
 
 // static
 bool GoogleAuthenticator::BinaryToHex(const std::vector<unsigned char>& binary,
                                       const unsigned int binary_len,
                                       char* hex_string,
                                       const unsigned int len) {
   if (len < 2*binary_len)
     return false;
   memset(hex_string, 0, len);
   for (uint i = 0, j = 0; i < binary_len; i++, j+=2)
-    sprintf(hex_string + j, "%02x", binary[i]);
+    snprintf(hex_string + j, len - j, "%02x", binary[i]);
   return true;
 }