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 {
 
+namespace serialize {
+
+const char kKeyFingerprint[] = "fingerprint";
+const char kKeyPKHash[] = "public_key_hash";
+const char kKeyInProcess[] = "in_process";
+
+const base::FilePath::CharType kCrxFileName[] =
+    FILE_PATH_LITERAL("saved_installer.crx");
+const base::FilePath::CharType kInstallDataFileName[] =
+    FILE_PATH_LITERAL("metadata.json");
+
+}  // namespace serialize
+
 // 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 36 matching lines @@
 
   if (!std::equal(pk_hash_.begin(), pk_hash_.end(), hash)) {
     VLOG(1) << "Hash mismatch: " << path_.value();
     error_ = kInvalidId;
     return false;
   }
   VLOG(1) << "Verification successful: " << path_.value();
   return true;
 }
 
+bool ComponentUnpacker::CreateUnpackDirectory(base::FilePath* new_dir) {
+  if (unpack_base_dir_.empty()) {
+    return base::CreateNewTempDirectory(base::FilePath::StringType(), new_dir);
+  }
+
+  return base::CreateTemporaryDirInDir(
+      unpack_base_dir_, base::FilePath::StringType(), new_dir);
+}
+
 bool ComponentUnpacker::Unzip() {
   base::FilePath& destination = is_delta_ ? unpack_diff_path_ : unpack_path_;
   VLOG(1) << "Unpacking in: " << destination.value();
-  if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
-                                    &destination)) {
+  if (!CreateUnpackDirectory(&destination)) {
     VLOG(1) << "Unable to create temporary directory for unpacking.";
     error_ = kUnzipPathError;
     return false;
   }
   if (!zip::Unzip(path_, destination)) {
     VLOG(1) << "Unzipping failed.";
     error_ = kUnzipFailed;
     return false;
   }
   VLOG(1) << "Unpacked successfully";
   return true;
 }
 
 bool ComponentUnpacker::BeginPatching() {
   if (is_delta_) {  // Package is a diff package.
     // Use a different temp directory for the patch output files.
-    if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
-                                      &unpack_path_)) {
+    if (!CreateUnpackDirectory(&unpack_path_)) {
       error_ = kUnzipPathError;
       return false;
     }
     patcher_ = new ComponentPatcher(unpack_diff_path_,
                                     unpack_path_,
                                     installer_,
                                     in_process_,
                                     task_runner_);
     task_runner_->PostTask(
         FROM_HERE,
@@ skipping 39 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_)) {
+    // Saves the installer files and tries to re-install which is not managed
+    // by the component updater service.
+    if (SaveInstallSource(installer_->GetBackupPath())) {
+      installer_->InstallExternally();
+    }
+
+    // But keep current install error code since we cannot get the external
+    // install result.
     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 (backup_path.empty()) {
+    return false;
+  }
+
+  if (!base::CreateDirectory(backup_path)) {
+    return false;
+  }
+
+  const base::FilePath crx_path = backup_path.Append(serialize::kCrxFileName);
+  if (!base::CopyFile(path_, crx_path)) {
+    return false;
+  }
+
+  const base::FilePath install_data_file_path =
+      backup_path.Append(serialize::kInstallDataFileName);
+  JSONFileValueSerializer serializer(install_data_file_path);
+
+  scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
+  root->SetString(serialize::kKeyFingerprint, fingerprint_);
+  root->SetBoolean(serialize::kKeyInProcess, in_process_);
+  scoped_ptr<base::ListValue> pk_hash_list(new base::ListValue);
+  for (size_t i = 0; i < pk_hash_.size(); ++i) {
+    pk_hash_list->Append(base::Value::CreateIntegerValue(
+        static_cast<int>(pk_hash_[i])));
+  }
+  root->Set(serialize::kKeyPKHash, pk_hash_list.release());
+  if (!serializer.Serialize(*root)) {
+    return false;
+  }
+
+  return true;
+}
+
+void ComponentUnpacker::set_unpack_base_dir(const base::FilePath& path) {
+  unpack_base_dir_ = path;
+}
+
+scoped_refptr<ComponentUnpacker> ComponentUnpacker::CreateFromBackup(
+    const base::FilePath& backup_path,
+    const std::vector<uint8>& pk_hash,
+    ComponentInstaller* installer,
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  const base::FilePath crx_path = backup_path.Append(serialize::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(serialize::kInstallDataFileName);
+  if (!base::PathExists(install_data_file_path)) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  JSONFileValueSerializer serialize(install_data_file_path);
+  scoped_ptr<base::Value> root(serialize.Deserialize(NULL, NULL));
+  if (!root.get() || !root->IsType(base::Value::TYPE_DICTIONARY)) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  scoped_ptr<base::DictionaryValue> metadata(
+      static_cast<base::DictionaryValue*>(root.release()));
+
+  base::ListValue* pk_hash_list = NULL;
+  if (!metadata->GetStringASCII(serialize::kKeyFingerprint, &fingerprint) ||
+      !metadata->GetBoolean(serialize::kKeyInProcess, &in_process) ||
+      !metadata->GetList(serialize::kKeyPKHash, &pk_hash_list) ||
+      pk_hash_list == NULL ||
+      pk_hash_list->GetSize() != pk_hash.size()) {
+    return scoped_refptr<ComponentUnpacker>();
+  }
+
+  for (size_t i = 0; i < pk_hash.size(); ++i) {
+    int value = 0;
+    if (!pk_hash_list->GetInteger(i, &value) ||
+        pk_hash[i] != static_cast<uint8>(value)) {
+      return scoped_refptr<ComponentUnpacker>();
+    }
+  }
+
+  return make_scoped_refptr(new ComponentUnpacker(
+      pk_hash, crx_path, fingerprint, installer, in_process, task_runner));
+}
+
 }  // namespace component_updater