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 265 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 = base::Time::Now();

[Finnur, 2014/02/12 13:54:57]

The timestamp you want is when you sent the request, not when you received a
reply, right? What happens if an extension gets installed in between sending and
receiving a reply?

[asargent_no_longer_on_chrome, 2014/02/12 16:27:56]

This is technically correct about the timestamp, and I've fixed it to avoid any
future problems. 

(It turns out not to matter in the current code since the act of installing an
extension will trigger another signature request to be queued up). 

     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