Add a lock to the managed user settings page and require authentication for unlocking.

chrome/browser/managed_mode/managed_user_passphrase.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 "chrome/browser/managed_mode/managed_user_passphrase.h"
+
+#include "base/base64.h"
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "crypto/encryptor.h"
+#include "crypto/random.h"
+#include "crypto/symmetric_key.h"
+
+const int kNumberOfIterations = 1;
+const int kDerivedKeySize = 128;
+
+ManagedUserPassphrase::ManagedUserPassphrase(const std::string& salt)
+    : salt_(salt) {
+  if (salt_.empty())
+    GenerateRandomSalt();
+}
+
+ManagedUserPassphrase::~ManagedUserPassphrase() {}
+
+std::string ManagedUserPassphrase::GetSalt() {
+  return salt_;
+}
+
+void ManagedUserPassphrase::GenerateRandomSalt() {
+  std::string bytes(32, '\0');

[Bernhard Bauer, 2013/01/08 17:43:14]

Can you pull the size out into a constant as well? Also, the null bytes probably
aren't necessary, as RandBytes will write over them anyway (and WriteInto will
reserve the space).

[Adrian Kuegel, 2013/01/09 12:10:05]

Done.

+  crypto::RandBytes(WriteInto(&bytes, bytes.size()), bytes.size());

[Bernhard Bauer, 2013/01/08 17:43:14]

I think this will set the length of the string to 31 instead of 32 (it reserves
one additional byte in the backing buffer for the null byte, but that is not
counted as part of the string, so that strlen and .length() return the same
value).

[Adrian Kuegel, 2013/01/09 12:10:05]

Yes, you are right. The question is: which real salt size do we want?

[Bernhard Bauer, 2013/02/04 16:13:35]

32 is fine. You probably should set kSaltSize to 32 though and then pass
kSaltSize+1 as the parameter to WriteInto.

[Adrian Kuegel, 2013/02/05 12:12:35]

Done.

+  bool success = base::Base64Encode(bytes, &salt_);
+  DCHECK(success);
+}
+
+void ManagedUserPassphrase::GenerateHashFromPassphrase(
+    const std::string& passphrase,
+    std::string* encoded_passphrase_hash) {
+  CHECK(encoded_passphrase_hash);
+  std::string passphrase_hash;
+  GetPassphraseHash(passphrase, &passphrase_hash);
+  bool success = base::Base64Encode(passphrase_hash, encoded_passphrase_hash);
+  DCHECK(success);
+}
+
+void ManagedUserPassphrase::GetPassphraseHash(const std::string& passphrase,
+                                              std::string* passphrase_hash) {
+  DCHECK(passphrase_hash);
+  // Create a hash from the user-provided passphrase and our hard-coded salt.
+  scoped_ptr<crypto::SymmetricKey> encryption_key(
+      crypto::SymmetricKey::DeriveKeyFromPassword(
+          crypto::SymmetricKey::AES,
+          passphrase,
+          salt_,
+          kNumberOfIterations,
+          kDerivedKeySize));
+  bool success = encryption_key->GetRawKey(passphrase_hash);
+  DCHECK(success);
+}