Fix install verification for sideloaded extensions without update urls

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 kSignatureFormatVersionKey[] = "signature_format_version";
 const char kTimestampKey[] = "timestamp";
 
+// This allows us to version the format of what we write into the prefs,
+// allowing for forward migration, as well as detecting forwards/backwards
+// incompatabilities, etc.
+const int kSignatureFormatVersion = 2;
+
 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"  \
     "rA5b3MnWTHwA1bgbiDM+L9rrqvcadcKuOlTeN48Q0ijmhHlNFbTzvT9W0zw/GKv8"  \
@@ skipping 39 matching lines @@
     if (i == 4 ||  i == 7) {
       if (input[i] != '-')
         return false;
     } else if (!IsAsciiDigit(input[i])) {
       return false;
     }
   }
   return true;
 }
 
+// Sets the value of |key| in |dictionary| to be a list with the contents of
+// |ids|.
+void SetExtensionIdSet(base::DictionaryValue* dictionary,
+                       const char* key,
+                       const ExtensionIdSet& ids) {
+  base::ListValue* id_list = new base::ListValue();
+  for (ExtensionIdSet::const_iterator i = ids.begin(); i != ids.end(); ++i)
+    id_list->AppendString(*i);
+  dictionary->Set(key, id_list);
+}
+
+// Tries to fetch a list of strings from |dictionay| for |key|, and inserts
+// them into |ids|. The return value indicates success/failure. Note: on
+// failure, |ids| might contain partial results, for instance if some of the
+// members of the list were not strings.
+bool GetExtensionIdSet(const base::DictionaryValue& dictionary,
+                       const char* key,
+                       ExtensionIdSet* ids) {
+  const base::ListValue* id_list = NULL;
+  if (!dictionary.GetList(key, &id_list))
+    return false;
+  for (base::ListValue::const_iterator i = id_list->begin();
+       i != id_list->end();
+       ++i) {
+    std::string id;
+    if (!(*i)->GetAsString(&id)) {
+      return false;
+    }
+    ids->insert(id);
+  }
+  return true;
+}
+
 }  // namespace
 
 namespace extensions {
 
 InstallSignature::InstallSignature() {
 }
 InstallSignature::~InstallSignature() {
 }
 
 void InstallSignature::ToValue(base::DictionaryValue* value) const {
   CHECK(value);
 
-  base::ListValue* id_list = new base::ListValue();
-  for (ExtensionIdSet::const_iterator i = ids.begin(); i != ids.end();
-       ++i)
-    id_list->AppendString(*i);
-
-  value->Set(kIdsKey, id_list);
+  value->SetInteger(kSignatureFormatVersionKey, kSignatureFormatVersion);
+  SetExtensionIdSet(value, kIdsKey, ids);
+  SetExtensionIdSet(value, kInvalidIdsKey, invalid_ids);
   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);
 
+  // For now we don't want to support any backwards compability, but in the
+  // future if we do, we would want to put the migration code here.
+  int format_version = 0;
+  if (!value.GetInteger(kSignatureFormatVersionKey, &format_version) ||
+      format_version != kSignatureFormatVersion) {
+    result.reset();
+    return result.Pass();
+  }
+
   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)) {
+  if (!GetExtensionIdSet(value, kIdsKey, &result->ids) ||
+      !GetExtensionIdSet(value, kInvalidIdsKey, &result->invalid_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();
-      return result.Pass();
-    }
-    result->ids.insert(id);
-  }
-
   return result.Pass();
 }
 
 
 InstallSigner::InstallSigner(net::URLRequestContextGetter* context_getter,
                              const ExtensionIdSet& ids)
     : ids_(ids), context_getter_(context_getter) {
 }
 
 InstallSigner::~InstallSigner() {
@@ skipping 157 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();
+  VLOG(1) << "Sending request: " << json;
   url_fetcher_->Start();
 }
 
 void InstallSigner::ReportErrorViaCallback() {
   InstallSignature* null_signature = NULL;
   if (!callback_.is_null())
     callback_.Run(scoped_ptr<InstallSignature>(null_signature));
 }
 
 void InstallSigner::ParseFetchResponse() {
   bool fetch_success = url_fetcher_->GetStatus().is_success();
   UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.FetchSuccess", fetch_success);
 
   std::string response;
   if (fetch_success) {
     if (!url_fetcher_->GetResponseAsString(&response))
       response.clear();
   }
   UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.GetResponseSuccess",
                         !response.empty());
   if (!fetch_success || response.empty()) {
     ReportErrorViaCallback();
     return;
   }
+  VLOG(1) << "Got response: " << response;
 
   // The response is JSON of the form:
   // {
   //   "protocol_version": "1",
   //   "signature": "<base64-encoded signature>",
   //   "expiry": "<date in YYYY-MM-DD form>",
   //   "invalid_ids": [ "<id3>", "<id4>" ]
   // }
   // where |invalid_ids| is a list of ids from the original request that
   // could not be verified to be in the webstore.
@@ skipping 47 matching lines @@
 void InstallSigner::HandleSignatureResult(const std::string& signature,
                                           const std::string& expire_date,
                                           const ExtensionIdSet& invalid_ids) {
   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->invalid_ids = invalid_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