Chrome-side lockbox bindings

chrome/browser/chromeos/login/ownership_service.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.
 
 #include "chrome/browser/chromeos/login/ownership_service.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #include "content/browser/browser_thread.h"
 
 // We want to use NewRunnableMethod for non-static methods of this class but
 // need to disable reference counting since it is singleton.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::OwnershipService);
 
 namespace chromeos {
 
 static base::LazyInstance<OwnershipService> g_ownership_service(
     base::LINKER_INITIALIZED);
@@ skipping 43 matching lines @@
       return status;
     // Under common usage there is very short lapse of time when ownership
     // status is still unknown after constructing OwnershipService.
     LOG(ERROR) << "Blocking on UI thread in OwnershipService::GetStatus";
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     is_owned = IsAlreadyOwned();
   } else {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     is_owned = IsAlreadyOwned();
   }
-  status = is_owned ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
+  status = is_owned ? DetermineOwnerType() : OWNERSHIP_NONE;

[Chris Masone, 2011/04/15 16:59:26]

You will wind up doing this from the file thread in some cases, which is bad and
can lead to crashes.

   SetStatus(status);
   return status;
 }
 
 void OwnershipService::StartLoadOwnerKeyAttempt() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableFunction(&TryLoadOwnerKeyAttempt, this));
 }
 
@@ skipping 26 matching lines @@
                           data,
                           signature,
                           d));
   return;
 }
 
 void OwnershipService::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   if (type.value == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
-    SetStatus(OWNERSHIP_TAKEN);
+    SetStatus(DetermineOwnerType());

[Chris Masone, 2011/04/15 16:59:26]

why do we need to do this all over the code?

     notification_registrar_.RemoveAll();
   } else {
     NOTREACHED();
   }
 }
 
 bool OwnershipService::CurrentUserIsOwner() {
   // If this user has the private key associated with the owner's
   // public key, this user is the owner.
   return IsAlreadyOwned() && manager_->EnsurePrivateKey();
@@ skipping 42 matching lines @@
   service->manager()->Verify(thread_id, data, signature, d);
 }
 
 // static
 void OwnershipService::FailAttempt(OwnerManager::Delegate* d) {
   d->OnKeyOpComplete(OwnerManager::KEY_UNAVAILABLE, std::vector<uint8>());
 }
 
 void OwnershipService::FetchStatus() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  Status status = IsAlreadyOwned() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
+  Status status = IsAlreadyOwned() ? DetermineOwnerType() : OWNERSHIP_NONE;
   SetStatus(status);
 }
 
 void OwnershipService::SetStatus(Status new_status) {
-  DCHECK(new_status == OWNERSHIP_TAKEN || new_status == OWNERSHIP_NONE);
+  DCHECK(new_status != OWNERSHIP_UNKNOWN);
   base::AutoLock lk(ownership_status_lock_);
   ownership_status_ = new_status;
 }
 
+OwnershipService::Status OwnershipService::DetermineOwnerType() {
+  // We assume we are user owned if there is no valid information in the lockbox
+  // this should be backwards compatible and safe enough in case the data has
+  // been tampered with or corrupted.
+  OwnershipService::Status owned = OWNERSHIP_USER;
+  chromeos::CryptohomeLibrary* cryptohome =
+      chromeos::CrosLibrary::Get()->GetCryptohomeLibrary();
+  if (cryptohome && cryptohome->InstallAttributesIsReady() &&
+      !cryptohome->InstallAttributesIsFirstInstall()) {
+    std::string value;
+    if (cryptohome->InstallAttributesGet("enterprise.owned", &value)) {
+       owned =
+           (0 == value.compare("true") ? OWNERSHIP_ENTERPRISE : OWNERSHIP_USER);
+    }
+  }
+  return owned;
+}
+
 }  // namespace chromeos