Don't disable extensions immediately if verification is out of date

chrome/browser/extensions/install_verifier.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/extensions/install_verifier.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 158 matching lines @@
     }
   } else {
     LogInitResultHistogram(INIT_NO_PREF);
   }
 }
 
 bool InstallVerifier::NeedsBootstrap() {
   return signature_.get() == NULL && ShouldFetchSignature();
 }
 
+base::Time InstallVerifier::SignatureTimestamp() {
+  if (signature_.get())
+    return signature_->timestamp;
+  else
+    return base::Time();
+}
+
 void InstallVerifier::Add(const std::string& id,
                           const AddResultCallback& callback) {
   ExtensionIdSet ids;
   ids.insert(id);
   AddMany(ids, callback);
 }
 
 void InstallVerifier::AddMany(const ExtensionIdSet& ids,
                               const AddResultCallback& callback) {
   if (!ShouldFetchSignature()) {
@@ skipping 69 matching lines @@
 enum MustRemainDisabledOutcome {
   VERIFIED = 0,
   NOT_EXTENSION,
   UNPACKED,
   ENTERPRISE_POLICY_ALLOWED,
   FORCED_NOT_VERIFIED,
   NOT_FROM_STORE,
   NO_SIGNATURE,
   NOT_VERIFIED_BUT_NOT_ENFORCING,
   NOT_VERIFIED,
+  NOT_VERIFIED_BUT_INSTALL_TIME_NEWER_THAN_SIGNATURE,
 
   // This is used in histograms - do not remove or reorder entries above! Also
   // the "MAX" item below should always be the last element.
-
   MUST_REMAIN_DISABLED_OUTCOME_MAX
 };
 
 void MustRemainDisabledHistogram(MustRemainDisabledOutcome outcome) {
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.MustRemainDisabled",
                             outcome, MUST_REMAIN_DISABLED_OUTCOME_MAX);
 }
 
 }  // namespace
 
@@ skipping 23 matching lines @@
     verified = false;
     outcome = NOT_FROM_STORE;
   } else if (signature_.get() == NULL) {
     // If we don't have a signature yet, we'll temporarily consider every
     // extension from the webstore verified to avoid false positives on existing
     // profiles hitting this code for the first time, and rely on consumers of
     // this class to check NeedsBootstrap() and schedule a first check so we can
     // get a signature.
     outcome = NO_SIGNATURE;
   } else if (!IsVerified(extension->id())) {
-    verified = false;
-    outcome = NOT_VERIFIED;
+    if (WasInstalledAfterSignature(extension->id())) {
+      outcome = NOT_VERIFIED_BUT_INSTALL_TIME_NEWER_THAN_SIGNATURE;
+    } else {
+      verified = false;
+      outcome = NOT_VERIFIED;
+    }
   }
   if (!verified && !ShouldEnforce()) {
     verified = true;
     outcome = NOT_VERIFIED_BUT_NOT_ENFORCING;
   }
   MustRemainDisabledHistogram(outcome);
 
   if (!verified) {
     if (reason)
       *reason = Extension::DISABLE_NOT_VERIFIED;
@@ skipping 47 matching lines @@
       return true;
   }
   return false;
 }
 
 bool InstallVerifier::IsVerified(const std::string& id) const {
   return ((signature_.get() && ContainsKey(signature_->ids, id)) ||
           ContainsKey(provisional_, id));
 }
 
+bool InstallVerifier::WasInstalledAfterSignature(const std::string& id) const {
+  if (!signature_.get() || signature_->timestamp.is_null())
+    return true;
+
+  base::Time install_time = prefs_->GetInstallTime(id);
+  // If the extension install time is in the future, just assume it isn't
+  // newer than the signature. (Either the clock went backwards, or
+  // an attacker changed the install time in the preferences).
+  if (install_time >= base::Time::Now())
+    return false;
+  return install_time > signature_->timestamp;
+}
+
 void InstallVerifier::BeginFetch() {
   DCHECK(ShouldFetchSignature());
 
   // TODO(asargent) - It would be possible to coalesce all operations in the
   // queue into one fetch - we'd probably just need to change the queue to
   // hold (set of ids, list of callbacks) pairs.
   CHECK(!operation_queue_.empty());
   const PendingOperation& operation = *operation_queue_.front();
 
   ExtensionIdSet ids_to_sign;
@@ skipping 92 matching lines @@
     if (!operation->callback.is_null())
       operation->callback.Run(success);
   }
 
   if (!operation_queue_.empty())
     BeginFetch();
 }
 
 
 }  // namespace extensions