Move crypto_helpers from sync to base

chrome/browser/sync/util/user_settings.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 //
 // This class isn't pretty. It's just a step better than globals, which is what
 // these were previously.
 
 #include "chrome/browser/sync/util/user_settings.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
+#include "base/md5.h"
 #include "base/string_util.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"  // For migration.
-#include "chrome/browser/sync/util/crypto_helpers.h"
 #include "chrome/browser/sync/util/data_encryption.h"
 #include "chrome/common/sqlite_utils.h"
+#include "crypto/random.h"
 
 using std::numeric_limits;
 using std::string;
 using std::vector;
 
 using syncable::DirectoryManager;
 
 namespace browser_sync {
 
 void ExecOrDie(sqlite3* dbhandle, const char *query) {
@@ skipping 123 matching lines @@
 }
 
 static void MakeClientIDTable(sqlite3* const dbhandle) {
   // Stores a single client ID value that can be used as the client id, if
   // there's not another such ID provided on the install.
   ExecOrDie(dbhandle, "CREATE TABLE client_id (id) ");
   {
     SQLStatement statement;
     statement.prepare(dbhandle,
                       "INSERT INTO client_id values ( ? )");
-    statement.bind_string(0, Generate128BitRandomHexString());
+    statement.bind_string(0, Generate128BitRandomBase64String());
     if (SQLITE_DONE != statement.step()) {
       LOG(FATAL) << "INSERT INTO client_id\n" << sqlite3_errmsg(dbhandle);
     }
   }
 }
 
 bool UserSettings::Init(const FilePath& settings_path) {
   {  // Scope the handle.
     ScopedDBHandle dbhandle(this);
     if (dbhandle_)
@@ skipping 83 matching lines @@
 UserSettings::~UserSettings() {
   if (dbhandle_)
     sqlite3_close(dbhandle_);
 }
 
 const int32 kInvalidHash = 0xFFFFFFFF;
 
 // We use 10 bits of data from the MD5 digest as the hash.
 const int32 kHashMask = 0x3FF;
 
-int32 GetHashFromDigest(const vector<uint8>& digest) {
+int32 GetHashFromDigest(MD5Digest& digest) {

[Ryan Sleevi, 2011/04/27 13:43:09]

nit: const MD5Digest&

   int32 hash = 0;
   int32 mask = kHashMask;
-  for (vector<uint8>::const_iterator i = digest.begin(); i != digest.end();
-       ++i) {
+  for (size_t i = 0; i < sizeof(digest.a); ++i) {
     hash = hash << 8;
-    hash = hash | (*i & kHashMask);
+    hash = hash | (digest.a[i] & kHashMask);
     mask = mask >> 8;
     if (0 == mask)
       break;
   }
   return hash;
 }
 
 void UserSettings::StoreEmailForSignin(const string& signin,
                                        const string& primary_email) {
   ScopedDBHandle dbhandle(this);
@@ skipping 57 matching lines @@
   return false;
 }
 
 void UserSettings::StoreHashedPassword(const string& email,
                                        const string& password) {
   // Save one-way hashed password:
   char binary_salt[kSaltSize];
   GetRandomBytes(binary_salt, sizeof(binary_salt));
 
   const string salt = APEncode(string(binary_salt, sizeof(binary_salt)));
-  MD5Calculator md5;
-  md5.AddData(salt.data(), salt.size());
-  md5.AddData(password.data(), password.size());
+  MD5Context md5_context;
+  MD5Digest md5_digest;
+  MD5Init(&md5_context);
+  MD5Update(&md5_context, salt.data(), salt.size());
+  MD5Update(&md5_context, password.data(), password.size());
+  MD5Final(&md5_digest, &md5_context);
   ScopedDBHandle dbhandle(this);
   SQLTransaction transaction(dbhandle.get());
   transaction.BeginExclusive();
   {
     SQLStatement statement;
     statement.prepare(dbhandle.get(),
                       "INSERT INTO settings(email, key, value)"
                       " values ( ?, ?, ? )");
     statement.bind_string(0, email);
     statement.bind_string(1, PASSWORD_HASH);
-    statement.bind_int(2, GetHashFromDigest(md5.GetDigest()));
+    statement.bind_int(2, GetHashFromDigest(md5_digest));
     if (SQLITE_DONE != statement.step()) {
       LOG(FATAL) << sqlite3_errmsg(dbhandle.get());
     }
   }
   {
     SQLStatement statement;
     statement.prepare(dbhandle.get(),
                       "INSERT INTO settings(email, key, value)"
                       " values ( ?, ?, ? )");
     statement.bind_string(0, email);
@@ skipping 25 matching lines @@
     string key(query.column_string(0));
     if (key == SALT)
       salt = query.column_string(1);
     else
       hash = query.column_int(1);
     query_result = query.step();
   }
   CHECK(SQLITE_DONE == query_result);
   if (salt.empty() || hash == kInvalidHash)
     return false;
-  MD5Calculator md5;
-  md5.AddData(salt.data(), salt.size());
-  md5.AddData(password.data(), password.size());
-  return hash == GetHashFromDigest(md5.GetDigest());
+  MD5Context md5_context;
+  MD5Digest md5_digest;
+  MD5Init(&md5_context);
+  MD5Update(&md5_context, salt.data(), salt.size());
+  MD5Update(&md5_context, password.data(), password.size());
+  MD5Final(&md5_digest, &md5_context);
+  return hash == GetHashFromDigest(md5_digest);
 }
 
 void UserSettings::SwitchUser(const string& username) {
   {
     base::AutoLock lock(mutex_);
     email_ = username;
   }
 }
 
 string UserSettings::GetClientId() {
@@ skipping 18 matching lines @@
   query.prepare(dbhandle.get(), "SELECT email FROM cookies");
   if (SQLITE_ROW == query.step()) {
     *username = query.column_string(0);
     return true;
   } else {
     return false;
   }
 }
 
 }  // namespace browser_sync