Validate hash_sha256 checksum on .crx update.

chrome/browser/extensions/startup_helper.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/extensions/startup_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 103 matching lines @@
   pack_job_->Start();
 
   return pack_job_succeeded_;
 }
 
 namespace {
 
 class ValidateCrxHelper : public SandboxedUnpackerClient {
  public:
   ValidateCrxHelper(const base::FilePath& crx_file,
+                    const std::string& package_hash,
                     const base::FilePath& temp_dir,
                     base::RunLoop* run_loop)
-      : crx_file_(crx_file), temp_dir_(temp_dir), run_loop_(run_loop),
-        finished_(false), success_(false) {}
+      : crx_file_(crx_file),
+        package_hash_(package_hash),
+        temp_dir_(temp_dir),
+        run_loop_(run_loop),
+        finished_(false),
+        success_(false) {}
 
   bool finished() { return finished_; }
   bool success() { return success_; }
   const base::string16& error() { return error_; }
 
   void Start() {
     BrowserThread::PostTask(BrowserThread::FILE,
                             FROM_HERE,
                             base::Bind(&ValidateCrxHelper::StartOnFileThread,
                                        this));
@@ skipping 30 matching lines @@
     if (run_loop_->running())
       run_loop_->Quit();
   }
 
   void StartOnFileThread() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     scoped_refptr<base::MessageLoopProxy> file_thread_proxy =
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
 
     scoped_refptr<SandboxedUnpacker> unpacker(
-        new SandboxedUnpacker(crx_file_,
-                              Manifest::INTERNAL,
+        new SandboxedUnpacker(crx_file_, package_hash_, Manifest::INTERNAL,
                               0, /* no special creation flags */
-                              temp_dir_,
-                              file_thread_proxy.get(),
-                              this));
+                              temp_dir_, file_thread_proxy.get(), this));
     unpacker->Start();
   }
 
   // The file being validated.
   const base::FilePath& crx_file_;
 
+  // SHA256 hash returned from WebStore.
+  const std::string& package_hash_;
+
   // The temporary directory where the sandboxed unpacker will do work.
   const base::FilePath& temp_dir_;
 
   // Unowned pointer to a runloop, so our consumer can wait for us to finish.
   base::RunLoop* run_loop_;
 
   // Whether we're finished unpacking;
   bool finished_;
 
   // Whether the unpacking was successful.
@@ skipping 14 matching lines @@
                                 switches::kValidateCrx);
     return false;
   }
   base::ScopedTempDir temp_dir;
 
   if (!temp_dir.CreateUniqueTempDir()) {
     *error = std::string("Failed to create temp dir");
     return false;
   }
 
+  std::string hash = cmd_line.GetSwitchValueASCII(switches::kValidateCrxHash);
+
   base::RunLoop run_loop;
   scoped_refptr<ValidateCrxHelper> helper(
-      new ValidateCrxHelper(path, temp_dir.path(), &run_loop));
+      new ValidateCrxHelper(path, hash, temp_dir.path(), &run_loop));
   helper->Start();
   if (!helper->finished())
     run_loop.Run();
 
   bool success = helper->success();
   if (!success)
     *error = base::UTF16ToUTF8(helper->error());
   return success;
 }
 
@@ skipping 54 matching lines @@
   } else {
     error_ = "Not a supported ephemeral app installation.";
     done_callback_.Run();
   }
 }
 
 void AppInstallHelper::OnAppInstallComplete(bool success,
                                             const std::string& error,
                                             webstore_install::Result result) {
   success_ = success;
-  error_= error;
+  error_ = error;
   done_callback_.Run();
 }
 
 }  // namespace
 
 bool StartupHelper::InstallEphemeralApp(const base::CommandLine& cmd_line,
                                         Profile* profile) {
   std::string id =
       cmd_line.GetSwitchValueASCII(switches::kInstallEphemeralAppFromWebstore);
   if (!crx_file::id_util::IdIsValid(id)) {
@@ skipping 11 matching lines @@
     LOG(ERROR) << "InstallFromWebstore failed with error: " << helper.error();
   return helper.success();
 }
 
 StartupHelper::~StartupHelper() {
   if (pack_job_.get())
     pack_job_->ClearClient();
 }
 
 }  // namespace extensions