Various supervised user password fixes - 2

chrome/browser/chromeos/login/managed/supervised_user_authentication.cc

 // Copyright 2013 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/managed/supervised_user_authentication.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_file_value_serializer.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/login/managed/locally_managed_user_constants.h"
 #include "chrome/browser/chromeos/login/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 75 matching lines @@
   std::string raw_result(out_bytes, out_bytes + sizeof(out_bytes));
 
   std::string result;
   base::Base64Encode(raw_result, &result);
   return result;
 }
 
 base::DictionaryValue* LoadPasswordData(base::FilePath profile_dir) {
   JSONFileValueSerializer serializer(profile_dir.Append(kPasswordUpdateFile));
   std::string error_message;
-  int error_code;
+  int error_code = JSONFileValueSerializer::JSON_NO_ERROR;
   scoped_ptr<base::Value> value(
       serializer.Deserialize(&error_code, &error_message));
   if (JSONFileValueSerializer::JSON_NO_ERROR != error_code) {
+    LOG(ERROR) << "Could not deserialize password data, error = " << error_code
+               << " / " << error_message;
     return NULL;
   }
   base::DictionaryValue* result;
   if (!value->GetAsDictionary(&result)) {
+    LOG(ERROR) << "Stored password data is not a dictionary";
     return NULL;
   }
-  value.Pass();
+  ignore_result(value.release());
   return result;
 }
 
 void OnPasswordDataLoaded(
     const SupervisedUserAuthentication::PasswordDataCallback& success_callback,
     const base::Closure& failure_callback,
     base::DictionaryValue* value) {
   if (!value) {
     failure_callback.Run();
     return;
@@ skipping 80 matching lines @@
     password_data->SetStringWithoutPathExpansion(kSalt, salt);
     int revision = kMinPasswordRevision;
     password_data->SetIntegerWithoutPathExpansion(kPasswordRevision, revision);
     std::string salted_password =
         BuildPasswordForHashWithSaltSchema(salt, password);
     std::string base64_signature_key = BuildRawHMACKey();
     std::string base64_signature =
         BuildPasswordSignature(salted_password, revision, base64_signature_key);
     password_data->SetStringWithoutPathExpansion(kEncryptedPassword,
                                                  salted_password);
+    password_data->SetStringWithoutPathExpansion(kPasswordSignature,
+                                                 base64_signature);
 
     extra_data->SetStringWithoutPathExpansion(kPasswordEncryptionKey,
                                               BuildRawHMACKey());
     extra_data->SetStringWithoutPathExpansion(kPasswordSignatureKey,
                                               base64_signature_key);
     return true;
   }
   NOTREACHED();
   return false;
 }
@@ skipping 33 matching lines @@
   if (holder.GetIntegerWithoutPathExpansion(kSchemaVersion,
                                             &schema_version_index)) {
     schema_version = static_cast<Schema>(schema_version_index);
   }
   return schema_version;
 }
 
 bool SupervisedUserAuthentication::NeedPasswordChange(
     const std::string& user_id,
     const base::DictionaryValue* password_data) {
-
   base::DictionaryValue local;
   owner_->GetPasswordInformation(user_id, &local);
   int local_schema = SCHEMA_PLAIN;
   int local_revision = kMinPasswordRevision;
   int updated_schema = SCHEMA_PLAIN;
   int updated_revision = kMinPasswordRevision;
   local.GetIntegerWithoutPathExpansion(kSchemaVersion, &local_schema);
   local.GetIntegerWithoutPathExpansion(kPasswordRevision, &local_revision);
   password_data->GetIntegerWithoutPathExpansion(kSchemaVersion,
                                                 &updated_schema);
@@ skipping 46 matching lines @@
 
 bool SupervisedUserAuthentication::HasIncompleteKey(
     const std::string& user_id) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   bool incomplete_key = false;
   holder.GetBoolean(kHasIncompleteKey, &incomplete_key);
   return incomplete_key;
 }
 
-void SupervisedUserAuthentication::MarkKeyIncomplete(
-    const std::string& user_id) {
+void SupervisedUserAuthentication::MarkKeyIncomplete(const std::string& user_id,
+                                                     bool incomplete) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
-  holder.SetBoolean(kHasIncompleteKey, true);
+  holder.SetBoolean(kHasIncompleteKey, incomplete);
   owner_->SetPasswordInformation(user_id, &holder);
 }
 
 void SupervisedUserAuthentication::LoadPasswordUpdateData(
     const std::string& user_id,
     const PasswordDataCallback& success_callback,
     const base::Closure& failure_callback) {
   const User* user = UserManager::Get()->FindUser(user_id);
   base::FilePath profile_path =
       ProfileHelper::GetProfilePathByUserIdHash(user->username_hash());
   PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&LoadPasswordData, profile_path),
       base::Bind(&OnPasswordDataLoaded, success_callback, failure_callback));
 }
 
 }  // namespace chromeos