Elevated install of recovery component (component update part)

chrome/browser/component_updater/component_unpacker.cc

 // Copyright (c) 2012 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/component_updater/component_unpacker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "extensions/common/constants.h"
 #include "extensions/common/crx_file.h"
 #include "third_party/zlib/google/zip.h"
 
 using crypto::SecureHash;
 
 namespace component_updater {
 
 namespace {
 
+const char kKeyNameFingerprint[] = "fingerprint";
+const char kKeyNamePublicKeyHash[] = "public_key_hash";
+const char kKeyNameInProcess[] = "in_process";
+
+const base::FilePath::CharType kCrxFileName[] =
+    FILE_PATH_LITERAL("saved_installer.crx");
+const base::FilePath::CharType kInstallDataFileName[] =
+    FILE_PATH_LITERAL("metadata.json");
+
 // This class makes sure that the CRX digital signature is valid
 // and well formed.
 class CRXValidator {
  public:
   explicit CRXValidator(FILE* crx_file) : valid_(false), is_delta_(false) {
     extensions::CrxFile::Header header;
     size_t len = fread(&header, 1, sizeof(header), crx_file);
     if (len < sizeof(header))
       return;
 
@@ skipping 73 matching lines @@
 // TODO(cpu): add a specific attribute check to a component json that the
 // extension unpacker will reject, so that a component cannot be installed
 // as an extension.
 scoped_ptr<base::DictionaryValue> ReadManifest(
     const base::FilePath& unpack_path) {
   base::FilePath manifest =
       unpack_path.Append(FILE_PATH_LITERAL("manifest.json"));
   if (!base::PathExists(manifest))
     return scoped_ptr<base::DictionaryValue>();
   JSONFileValueSerializer serializer(manifest);
-  std::string error;
-  scoped_ptr<base::Value> root(serializer.Deserialize(NULL, &error));
+  scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
   if (!root.get())
     return scoped_ptr<base::DictionaryValue>();
   if (!root->IsType(base::Value::TYPE_DICTIONARY))
     return scoped_ptr<base::DictionaryValue>();
   return scoped_ptr<base::DictionaryValue>(
              static_cast<base::DictionaryValue*>(root.release())).Pass();
 }
 
 bool ComponentUnpacker::UnpackInternal() {
   return Verify() && Unzip() && BeginPatching();
@@ skipping 118 matching lines @@
     error_ = kFingerprintWriteFailed;
     return;
   }
   scoped_ptr<base::DictionaryValue> manifest(ReadManifest(unpack_path_));
   if (!manifest.get()) {
     error_ = kBadManifest;
     return;
   }
   DCHECK(error_ == kNone);
   if (!installer_->Install(*manifest, unpack_path_)) {
+    installer_->OnInstallError(
+        base::Bind(&ComponentUnpacker::SaveInstallSource, this));
     error_ = kInstallerError;
     return;
   }
 }
 
 void ComponentUnpacker::Finish() {
   if (!unpack_diff_path_.empty())
     base::DeleteFile(unpack_diff_path_, true);
   if (!unpack_path_.empty())
     base::DeleteFile(unpack_path_, true);
   callback_.Run(error_, extended_error_);
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
 }
 
+bool ComponentUnpacker::SaveInstallSource(
+    const base::FilePath& backup_path) const {
+  if (!base::CreateDirectory(backup_path)) {
+    return false;
+  }
+
+  const base::FilePath crx_path = backup_path.Append(kCrxFileName);
+  if (!base::CopyFile(path_, crx_path)) {
+    return false;
+  }
+
+  const base::FilePath install_data_file_path =
+      backup_path.Append(kInstallDataFileName);
+  JSONFileValueSerializer serializer(install_data_file_path);
+
+  scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
+  root->SetString(kKeyNameFingerprint, fingerprint_);
+  root->SetBoolean(kKeyNameInProcess, in_process_);
+  scoped_ptr<base::ListValue> pk_hash_list_value(new base::ListValue);
+  for (size_t i = 0; i < pk_hash_.size(); ++i) {
+    pk_hash_list_value->Append(base::Value::CreateIntegerValue(
+        static_cast<int>(pk_hash_[i])));
+  }
+  root->Set(kKeyNamePublicKeyHash, pk_hash_list_value.release());
+  if (!serializer.Serialize(*root)) {
+    return false;
+  }
+
+  return true;
+}
+
+scoped_refptr<ComponentUnpacker> ComponentUnpacker::CreateFromBackup(
+    const base::FilePath& backup_path,
+    ComponentInstaller* installer,
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  const base::FilePath crx_path = backup_path.Append(kCrxFileName);
+  if (!base::PathExists(crx_path) || base::DirectoryExists(crx_path)) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  std::string fingerprint;
+  bool in_process = false;
+
+  const base::FilePath install_data_file_path =
+      backup_path.Append(kInstallDataFileName);
+  if (!base::PathExists(install_data_file_path)) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  JSONFileValueSerializer serializer(install_data_file_path);
+  scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
+  if (!root.get() || !root->IsType(base::Value::TYPE_DICTIONARY)) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  scoped_ptr<base::DictionaryValue> install_metadata(
+      static_cast<base::DictionaryValue*>(root.release()));
+
+  base::ListValue* pk_hash_list_value = NULL;
+  if (!install_metadata->GetStringASCII(kKeyNameFingerprint, &fingerprint) ||
+      !install_metadata->GetBoolean(kKeyNameInProcess, &in_process) ||
+      !install_metadata->GetList(kKeyNamePublicKeyHash, &pk_hash_list_value) ||
+      pk_hash_list_value == NULL) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  std::vector<uint8> pk_hash;
+  for (size_t i = 0; i < pk_hash_list_value->GetSize(); ++i) {
+    int value = 0;
+    if (pk_hash_list_value->GetInteger(i, &value)) {
+      pk_hash.push_back(static_cast<uint8>(value));
+    }
+  }
+
+  return make_scoped_refptr(new ComponentUnpacker(
+      pk_hash, crx_path, fingerprint, installer, in_process, task_runner));
+}
+
 }  // namespace component_updater