Added a timeout for platform verification key generation.

chrome/browser/chromeos/attestation/platform_verification_flow.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 "platform_verification_flow.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "chrome/browser/chromeos/attestation/attestation_ca_client.h"
 #include "chrome/browser/chromeos/attestation/attestation_signed_data.pb.h"
 #include "chrome/browser/chromeos/attestation/platform_verification_dialog.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/attestation/attestation_flow.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
 namespace {
 
+const int kTimeoutInSeconds = 8;
+
 // A callback method to handle DBus errors.
 void DBusCallback(const base::Callback<void(bool)>& on_success,
                   const base::Closure& on_failure,
                   chromeos::DBusMethodCallStatus call_status,
                   bool result) {
   if (call_status == chromeos::DBUS_METHOD_CALL_SUCCESS) {
     on_success.Run(result);
   } else {
     LOG(ERROR) << "PlatformVerificationFlow: DBus call failed!";
     on_failure.Run();
@@ skipping 30 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DefaultDelegate);
 };
 
 PlatformVerificationFlow::PlatformVerificationFlow()
     : attestation_flow_(NULL),
       async_caller_(cryptohome::AsyncMethodCaller::GetInstance()),
       cryptohome_client_(DBusThreadManager::Get()->GetCryptohomeClient()),
       user_manager_(UserManager::Get()),
       delegate_(NULL),
       testing_prefs_(NULL),
-      weak_factory_(this) {
+      timeout_delay_(base::TimeDelta::FromSeconds(kTimeoutInSeconds)) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   scoped_ptr<ServerProxy> attestation_ca_client(new AttestationCAClient());
   default_attestation_flow_.reset(new AttestationFlow(
       async_caller_,
       cryptohome_client_,
       attestation_ca_client.Pass()));
   attestation_flow_ = default_attestation_flow_.get();
   default_delegate_.reset(new DefaultDelegate());
   delegate_ = default_delegate_.get();
 }
 
 PlatformVerificationFlow::PlatformVerificationFlow(
     AttestationFlow* attestation_flow,
     cryptohome::AsyncMethodCaller* async_caller,
     CryptohomeClient* cryptohome_client,
     UserManager* user_manager,
     Delegate* delegate)
     : attestation_flow_(attestation_flow),
       async_caller_(async_caller),
       cryptohome_client_(cryptohome_client),
       user_manager_(user_manager),
       delegate_(delegate),
       testing_prefs_(NULL),
-      weak_factory_(this) {
+      timeout_delay_(base::TimeDelta::FromSeconds(kTimeoutInSeconds)) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 PlatformVerificationFlow::~PlatformVerificationFlow() {
 }
 
 void PlatformVerificationFlow::ChallengePlatformKey(
     content::WebContents* web_contents,
     const std::string& service_id,
     const std::string& challenge,
     const ChallengeCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!IsAttestationEnabled(web_contents)) {
     LOG(INFO) << "PlatformVerificationFlow: Feature disabled.";
     ReportError(callback, POLICY_REJECTED);
     return;
   }
+  ChallengeContext context = {web_contents, service_id, challenge, callback};
   BoolDBusMethodCallback dbus_callback = base::Bind(
       &DBusCallback,
-      base::Bind(&PlatformVerificationFlow::CheckConsent,
-                 weak_factory_.GetWeakPtr(),
-                 web_contents,
-                 service_id,
-                 challenge,
-                 callback),
+      base::Bind(&PlatformVerificationFlow::CheckConsent, this, context),
       base::Bind(&ReportError, callback, INTERNAL_ERROR));
   cryptohome_client_->TpmAttestationIsEnrolled(dbus_callback);
 }
 
-void PlatformVerificationFlow::CheckConsent(content::WebContents* web_contents,
-                                            const std::string& service_id,
-                                            const std::string& challenge,
-                                            const ChallengeCallback& callback,
+void PlatformVerificationFlow::CheckConsent(const ChallengeContext& context,
                                             bool attestation_enrolled) {
   ConsentType consent_type = CONSENT_TYPE_NONE;
-  if (!attestation_enrolled || IsFirstUse(web_contents)) {
+  if (!attestation_enrolled || IsFirstUse(context.web_contents)) {
     consent_type = CONSENT_TYPE_ATTESTATION;
-  } else if (IsAlwaysAskRequired(web_contents)) {
+  } else if (IsAlwaysAskRequired(context.web_contents)) {
     consent_type = CONSENT_TYPE_ALWAYS;
   }
   Delegate::ConsentCallback consent_callback = base::Bind(
       &PlatformVerificationFlow::OnConsentResponse,
-      weak_factory_.GetWeakPtr(),
-      web_contents,
-      service_id,
-      challenge,
-      callback,
+      this,
+      context,
       consent_type);
   if (consent_type == CONSENT_TYPE_NONE) {
     consent_callback.Run(CONSENT_RESPONSE_NONE);
   } else {
     delegate_->ShowConsentPrompt(consent_type,
-                                 web_contents,
+                                 context.web_contents,
                                  consent_callback);
   }
 }
 
 void PlatformVerificationFlow::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kRAConsentFirstTime,
                              false,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(
       prefs::kRAConsentDomains,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kRAConsentAlways,
                              false,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 void PlatformVerificationFlow::OnConsentResponse(
-    content::WebContents* web_contents,
-    const std::string& service_id,
-    const std::string& challenge,
-    const ChallengeCallback& callback,
+    const ChallengeContext& context,
     ConsentType consent_type,
     ConsentResponse consent_response) {
   if (consent_type != CONSENT_TYPE_NONE) {
     if (consent_response == CONSENT_RESPONSE_NONE) {
       // No user response - do not proceed and do not modify any settings.
       LOG(WARNING) << "PlatformVerificationFlow: No response from user.";
-      ReportError(callback, USER_REJECTED);
+      ReportError(context.callback, USER_REJECTED);
       return;
     }
-    if (!UpdateSettings(web_contents, consent_type, consent_response)) {
-      ReportError(callback, INTERNAL_ERROR);
+    if (!UpdateSettings(context.web_contents, consent_type, consent_response)) {
+      ReportError(context.callback, INTERNAL_ERROR);
       return;
     }
     if (consent_response == CONSENT_RESPONSE_DENY) {
       LOG(INFO) << "PlatformVerificationFlow: User rejected request.";
       content::RecordAction(
           content::UserMetricsAction("PlatformVerificationRejected"));
-      ReportError(callback, USER_REJECTED);
+      ReportError(context.callback, USER_REJECTED);
       return;
     } else if (consent_response == CONSENT_RESPONSE_ALLOW) {
       content::RecordAction(
           content::UserMetricsAction("PlatformVerificationAccepted"));
     }
   }
 
   // At this point all user interaction is complete and we can proceed with the
   // certificate request.
-  chromeos::User* user = GetUser(web_contents);
+  chromeos::User* user = GetUser(context.web_contents);
   if (!user) {
-    ReportError(callback, INTERNAL_ERROR);
+    ReportError(context.callback, INTERNAL_ERROR);
     LOG(ERROR) << "Profile does not map to a valid user.";
     return;
   }
+
+  scoped_ptr<base::Timer> timer(new base::Timer(false,    // Don't retain.

[DaleCurtis, 2013/10/30 22:53:17]

Timer(false, false) is just OneShotTimer().  Why the generic instance?

+                                                false));  // Don't repeat.
+  base::Closure timeout_callback = base::Bind(
+      &PlatformVerificationFlow::OnCertificateTimeout,
+      this,
+      context);
+  timer->Start(FROM_HERE, timeout_delay_, timeout_callback);
+
   AttestationFlow::CertificateCallback certificate_callback = base::Bind(
       &PlatformVerificationFlow::OnCertificateReady,
-      weak_factory_.GetWeakPtr(),
+      this,
+      context,
       user->email(),
-      service_id,
-      challenge,
-      callback);
+      base::Passed(&timer));
   attestation_flow_->GetCertificate(
       PROFILE_CONTENT_PROTECTION_CERTIFICATE,
       user->email(),
-      service_id,
+      context.service_id,
       false,  // Don't force a new key.
       certificate_callback);
 }
 
 void PlatformVerificationFlow::OnCertificateReady(
+    const ChallengeContext& context,
     const std::string& user_id,
-    const std::string& service_id,
-    const std::string& challenge,
-    const ChallengeCallback& callback,
+    scoped_ptr<base::Timer> timer,
     bool operation_success,
     const std::string& certificate) {
+  // Log failure before checking the timer so all failures are logged, even if
+  // they took too long.
   if (!operation_success) {
     LOG(WARNING) << "PlatformVerificationFlow: Failed to certify platform.";
-    ReportError(callback, PLATFORM_NOT_VERIFIED);
+  }
+  if (!timer->IsRunning()) {
+    LOG(WARNING) << "PlatformVerificationFlow: Certificate ready but call has "
+                 << "already timed out.";
+    return;
+  }
+  timer->Stop();
+  if (!operation_success) {
+    ReportError(context.callback, PLATFORM_NOT_VERIFIED);
     return;
   }
   cryptohome::AsyncMethodCaller::DataCallback cryptohome_callback = base::Bind(
       &PlatformVerificationFlow::OnChallengeReady,
-      weak_factory_.GetWeakPtr(),
-      certificate,
-      challenge,
-      callback);
+      this,
+      context,
+      certificate);
   std::string key_name = kContentProtectionKeyPrefix;
-  key_name += service_id;
+  key_name += context.service_id;
   async_caller_->TpmAttestationSignSimpleChallenge(KEY_USER,
                                                    user_id,
                                                    key_name,
-                                                   challenge,
+                                                   context.challenge,
                                                    cryptohome_callback);
 }
 
+void PlatformVerificationFlow::OnCertificateTimeout(
+    const ChallengeContext& context) {
+  LOG(WARNING) << "PlatformVerificationFlow: Timing out.";
+  ReportError(context.callback, TIMEOUT);
+}
+
 void PlatformVerificationFlow::OnChallengeReady(
+    const ChallengeContext& context,
     const std::string& certificate,
-    const std::string& challenge,
-    const ChallengeCallback& callback,
     bool operation_success,
     const std::string& response_data) {
   if (!operation_success) {
     LOG(ERROR) << "PlatformVerificationFlow: Failed to sign challenge.";
-    ReportError(callback, INTERNAL_ERROR);
+    ReportError(context.callback, INTERNAL_ERROR);
     return;
   }
   SignedData signed_data_pb;
   if (response_data.empty() || !signed_data_pb.ParseFromString(response_data)) {
     LOG(ERROR) << "PlatformVerificationFlow: Failed to parse response data.";
-    ReportError(callback, INTERNAL_ERROR);
+    ReportError(context.callback, INTERNAL_ERROR);
     return;
   }
-  callback.Run(SUCCESS,
-               signed_data_pb.data(),
-               signed_data_pb.signature(),
-               certificate);
+  context.callback.Run(SUCCESS,
+                       signed_data_pb.data(),
+                       signed_data_pb.signature(),
+                       certificate);
   LOG(INFO) << "PlatformVerificationFlow: Platform successfully verified.";
 }
 
 PrefService* PlatformVerificationFlow::GetPrefs(
     content::WebContents* web_contents) {
   if (testing_prefs_)
     return testing_prefs_;
   return user_prefs::UserPrefs::Get(web_contents->GetBrowserContext());
 }
 
@@ skipping 117 matching lines @@
     bool allow_domain) {
   PrefService* pref_service = GetPrefs(web_contents);
   CHECK(pref_service);
   DictionaryPrefUpdate updater(pref_service, prefs::kRAConsentDomains);
   const GURL& url = GetURL(web_contents);
   updater->SetBoolean(url.host(), allow_domain);
 }
 
 }  // namespace attestation
 }  // namespace chromeos