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

chrome/browser/extensions/install_signer.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_signer.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 30 matching lines @@
 using extensions::ExtensionIdSet;
 
 const char kExpireDateKey[] = "expire_date";
 const char kExpiryKey[] = "expiry";
 const char kHashKey[] = "hash";
 const char kIdsKey[] = "ids";
 const char kInvalidIdsKey[] = "invalid_ids";
 const char kProtocolVersionKey[] = "protocol_version";
 const char kSaltKey[] = "salt";
 const char kSignatureKey[] = "signature";
+const char kTimestampKey[] = "timestamp";
 
 const size_t kSaltBytes = 32;
 
 const char kBackendUrl[] =
     "https://www.googleapis.com/chromewebstore/v1.1/items/verify";
 
 const char kPublicKeyPEM[] =                                            \
     "-----BEGIN PUBLIC KEY-----"                                        \
     "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAj/u/XDdjlDyw7gHEtaaa"  \
     "sZ9GdG8WOKAyJzXd8HFrDtz2Jcuy7er7MtWvHgNDA0bwpznbI5YdZeV4UfCEsA4S"  \
@@ skipping 65 matching lines @@
     id_list->AppendString(*i);
 
   value->Set(kIdsKey, id_list);
   value->SetString(kExpireDateKey, expire_date);
   std::string salt_base64;
   std::string signature_base64;
   base::Base64Encode(salt, &salt_base64);
   base::Base64Encode(signature, &signature_base64);
   value->SetString(kSaltKey, salt_base64);
   value->SetString(kSignatureKey, signature_base64);
+  value->SetString(kTimestampKey,
+                   base::Int64ToString(timestamp.ToInternalValue()));
 }
 
 // static
 scoped_ptr<InstallSignature> InstallSignature::FromValue(
     const base::DictionaryValue& value) {
 
   scoped_ptr<InstallSignature> result(new InstallSignature);
 
   std::string salt_base64;
   std::string signature_base64;
   if (!value.GetString(kExpireDateKey, &result->expire_date) ||
       !value.GetString(kSaltKey, &salt_base64) ||
       !value.GetString(kSignatureKey, &signature_base64) ||
       !base::Base64Decode(salt_base64, &result->salt) ||
       !base::Base64Decode(signature_base64, &result->signature)) {
     result.reset();
     return result.Pass();
   }
 
+  // Note: earlier versions of the code did not write out a timestamp value
+  // so older entries will not necessarily have this.
+  if (value.HasKey(kTimestampKey)) {
+    std::string timestamp;
+    int64 timestamp_value = 0;
+    if (!value.GetString(kTimestampKey, &timestamp) ||
+        !base::StringToInt64(timestamp, &timestamp_value)) {
+      result.reset();
+      return result.Pass();
+    }
+    result->timestamp = base::Time::FromInternalValue(timestamp_value);
+  }
+
   const base::ListValue* ids = NULL;
   if (!value.GetList(kIdsKey, &ids)) {
     result.reset();
     return result.Pass();
   }
 
   for (base::ListValue::const_iterator i = ids->begin(); i != ids->end(); ++i) {
     std::string id;
     if (!(*i)->GetAsString(&id)) {
       result.reset();
@@ skipping 171 matching lines @@
   }
   dictionary.Set(kIdsKey, id_list.release());
   std::string json;
   base::JSONWriter::Write(&dictionary, &json);
   if (json.empty()) {
     ReportErrorViaCallback();
     return;
   }
   url_fetcher_->SetUploadData("application/json", json);
   LogRequestStartHistograms();
+  request_start_time_ = base::Time::Now();
   url_fetcher_->Start();
 }
 
 void InstallSigner::ReportErrorViaCallback() {
   InstallSignature* null_signature = NULL;
   if (!callback_.is_null())
     callback_.Run(scoped_ptr<InstallSignature>(null_signature));
 }
 
 void InstallSigner::ParseFetchResponse() {
@@ skipping 74 matching lines @@
   ExtensionIdSet valid_ids =
       base::STLSetDifference<ExtensionIdSet>(ids_, invalid_ids);
 
   scoped_ptr<InstallSignature> result;
   if (!signature.empty()) {
     result.reset(new InstallSignature);
     result->ids = valid_ids;
     result->salt = salt_;
     result->signature = signature;
     result->expire_date = expire_date;
+    result->timestamp = request_start_time_;
     bool verified = VerifySignature(*result);
     UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ResultWasValid", verified);
     UMA_HISTOGRAM_COUNTS_100("ExtensionInstallSigner.InvalidCount",
                              invalid_ids.size());
     if (!verified)
       result.reset();
   }
 
   if (!callback_.is_null())
     callback_.Run(result.Pass());
 }
 
 
 }  // namespace extensions