Refactor CRX verification in preparation to support CRX₃ files.

components/update_client/component_unpacker.cc

 // Copyright 2014 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 "components/update_client/component_unpacker.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
-#include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
-#include "components/crx_file/crx_file.h"
+#include "components/crx_file/crx_verifier.h"
 #include "components/update_client/component_patcher.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/update_client_errors.h"
-#include "crypto/secure_hash.h"
-#include "crypto/sha2.h"
 #include "third_party/zlib/google/zip.h"
 
-using crypto::SecureHash;
-using crx_file::CrxFile;
-
 namespace update_client {
 
 // 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.
 std::unique_ptr<base::DictionaryValue> ReadManifest(
     const base::FilePath& unpack_path) {
   base::FilePath manifest =
       unpack_path.Append(FILE_PATH_LITERAL("manifest.json"));
   if (!base::PathExists(manifest))
@@ skipping 37 matching lines @@
   if (!UnpackInternal())
     EndUnpacking();
 }
 
 bool ComponentUnpacker::Verify() {
   VLOG(1) << "Verifying component: " << path_.value();
   if (pk_hash_.empty() || path_.empty()) {
     error_ = UnpackerError::kInvalidParams;
     return false;
   }
-  // First, validate the CRX header and signature. As of today
-  // this is SHA1 with RSA 1024.
-  std::string public_key_bytes;
-  std::string public_key_base64;
-  CrxFile::Header header;
-  CrxFile::ValidateError error = CrxFile::ValidateSignature(
-      path_, std::string(), &public_key_base64, nullptr, &header);
-  if (error != CrxFile::ValidateError::NONE ||
-      !base::Base64Decode(public_key_base64, &public_key_bytes)) {
+  const std::vector<std::vector<uint8_t>> required_keys = {pk_hash_};
+  const crx_file::VerifierResult result =
+      crx_file::Verify(path_, crx_file::VerifierFormat::CRX2_OR_CRX3,
+                       required_keys, std::vector<uint8_t>(), nullptr, nullptr);
+  if (result != crx_file::VerifierResult::OK_FULL &&
+      result != crx_file::VerifierResult::OK_DELTA) {
     error_ = UnpackerError::kInvalidFile;
     return false;
   }
-  is_delta_ = CrxFile::HeaderIsDelta(header);
-
-  // File is valid and the digital signature matches. Now make sure
-  // the public key hash matches the expected hash. If they do we fully
-  // trust this CRX.
-  uint8_t hash[crypto::kSHA256Length] = {};
-  std::unique_ptr<SecureHash> sha256(SecureHash::Create(SecureHash::SHA256));
-  sha256->Update(public_key_bytes.data(), public_key_bytes.size());
-  sha256->Finish(hash, arraysize(hash));
-
-  if (!std::equal(pk_hash_.begin(), pk_hash_.end(), hash)) {
-    VLOG(1) << "Hash mismatch: " << path_.value();
-    error_ = UnpackerError::kInvalidId;
-    return false;
-  }
+  is_delta_ = result == crx_file::VerifierResult::OK_DELTA;
   VLOG(1) << "Verification successful: " << path_.value();
   return true;
 }
 
 bool ComponentUnpacker::Unzip() {
   // Mind the reference to non-const type, passed as an argument below.
   base::FilePath& destination = is_delta_ ? unpack_diff_path_ : unpack_path_;
   if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
                                     &destination)) {
     VLOG(1) << "Unable to create temporary directory for unpacking.";
@@ skipping 51 matching lines @@
   Result result;
   result.error = error_;
   result.extended_error = extended_error_;
   if (error_ == UnpackerError::kNone)
     result.unpack_path = unpack_path_;
 
   task_runner_->PostTask(FROM_HERE, base::Bind(callback_, result));
 }
 
 }  // namespace update_client