Use extension for data file updates

Author: emerick

browser/extensions/BUILD.gn

@@ -8,6 +8,8 @@ source_set("extensions") {
     "api/content_settings/brave_content_settings_store.h",
     "brave_component_extension_resource_manager.cc",
     "brave_component_extension_resource_manager.h",
+    "brave_component_installer.cc",
+    "brave_component_installer.h",
     "brave_component_loader.cc",
     "brave_component_loader.h",
   ]

browser/extensions/brave_component_installer.cc

@@ -0,0 +1,150 @@
+// 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 "brave/browser/extensions/brave_component_installer.h"
+
+#include <utility>
+
+#include "base/base64.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/macros.h"
+#include "base/values.h"
+#include "base/version.h"
+#include "components/component_updater/component_updater_service.h"
+#include "components/crx_file/id_util.h"
+#include "components/update_client/update_client.h"
+#include "components/update_client/update_client_errors.h"
+#include "components/update_client/utils.h"
+#include "crypto/sha2.h"
+#include "extensions/common/constants.h"
+#include "extensions/common/manifest_constants.h"
+
+using component_updater::ComponentUpdateService;
+
+namespace {
+
+using Result = update_client::CrxInstaller::Result;
+using InstallError = update_client::InstallError;
+}  // namespace
+
+namespace {
+bool RewriteManifestFile(
+    const base::FilePath& extension_root,
+    const base::DictionaryValue& manifest,
+    const std::string &public_key) {
+
+  // Add the public key
+  DCHECK(!public_key.empty());
+
+  std::unique_ptr<base::DictionaryValue> final_manifest(manifest.DeepCopy());
+  final_manifest->SetString(extensions::manifest_keys::kPublicKey, public_key);
+
+  std::string manifest_json;
+  JSONStringValueSerializer serializer(&manifest_json);
+  serializer.set_pretty_print(true);
+  if (!serializer.Serialize(*final_manifest)) {
+    return false;
+  }
+
+  base::FilePath manifest_path =
+    extension_root.Append(extensions::kManifestFilename);
+  int size = base::checked_cast<int>(manifest_json.size());
+  if (base::WriteFile(manifest_path, manifest_json.data(), size) != size) {
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+namespace brave {
+
+BraveComponentInstallerPolicy::BraveComponentInstallerPolicy(
+  const std::string& name,
+  const std::string& public_key,
+  const ReadyCallback& ready_callback) :
+  name_(name), public_key_(public_key), ready_callback_(ready_callback) {
+}
+
+BraveComponentInstallerPolicy::~BraveComponentInstallerPolicy() {}
+
+bool BraveComponentInstallerPolicy::VerifyInstallation(const base::DictionaryValue& manifest,
+                                                       const base::FilePath& install_dir) const {
+  // The manifest file will generate a random ID if we don't provide one.
+  // We want to write one with the actual extensions public key so we get
+  // the same extensionID which is generated from the public key.
+  std::string base64_public_key;
+  base::Base64Encode(public_key_, &base64_public_key);
+  if (!RewriteManifestFile(install_dir, manifest, base64_public_key)) {
+    return false;
+  }
+  return base::PathExists(
+      install_dir.Append(FILE_PATH_LITERAL("manifest.json")));
+}
+
+bool BraveComponentInstallerPolicy::SupportsGroupPolicyEnabledComponentUpdates() const {
+  return false;
+}
+
+bool BraveComponentInstallerPolicy::RequiresNetworkEncryption() const {
+  return false;
+}
+
+update_client::CrxInstaller::Result BraveComponentInstallerPolicy::OnCustomInstall(
+  const base::DictionaryValue& manifest,
+  const base::FilePath& install_dir) {
+  return Result(InstallError::NONE);
+}
+
+void BraveComponentInstallerPolicy::OnCustomUninstall() {
+}
+
+void BraveComponentInstallerPolicy::ComponentReady(
+  const base::Version& version,
+  const base::FilePath& install_dir,
+  std::unique_ptr<base::DictionaryValue> manifest) {
+  ready_callback_.Run(install_dir);
+}
+
+base::FilePath BraveComponentInstallerPolicy::GetRelativeInstallDir() const {
+  // Get the extension ID from the public key
+  std::string extension_id = crx_file::id_util::GenerateId(public_key_);
+  return base::FilePath(
+      // Convert to wstring or string depending on OS
+      base::FilePath::StringType(extension_id.begin(), extension_id.end()));
+}
+
+void BraveComponentInstallerPolicy::GetHash(std::vector<uint8_t>* hash) const {
+  const std::string public_key_sha256 = crypto::SHA256HashString(public_key_);
+  hash->assign(public_key_sha256.begin(), public_key_sha256.end());
+}
+
+std::string BraveComponentInstallerPolicy::GetName() const {
+  return name_;
+}
+
+std::vector<std::string> BraveComponentInstallerPolicy::GetMimeTypes() const {
+  return std::vector<std::string>();
+}
+
+update_client::InstallerAttributes BraveComponentInstallerPolicy::GetInstallerAttributes() const {
+  return update_client::InstallerAttributes();
+}
+
+void RegisterComponent(
+    ComponentUpdateService* cus,
+    const std::string& name,
+    const std::string& public_key,
+    const base::Closure& registered_callback,
+    const ReadyCallback& ready_callback) {
+  auto installer = base::MakeRefCounted<component_updater::ComponentInstaller>(
+    std::make_unique<BraveComponentInstallerPolicy>(name, public_key, ready_callback));
+  installer->Register(cus, registered_callback);
+}
+
+}  // namespace brave

browser/extensions/brave_component_installer.h

@@ -0,0 +1,71 @@
+// 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.
+
+#ifndef COMPONENTS_COMPONENT_UPDATER_BRAVE_COMPONENT_INSTALLER_H_
+#define COMPONENTS_COMPONENT_UPDATER_BRAVE_COMPONENT_INSTALLER_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/macros.h"
+#include "components/component_updater/component_installer.h"
+#include "components/update_client/update_client.h"
+
+namespace base {
+class FilePath;
+}  // namespace base
+using ReadyCallback = base::Callback<void(const base::FilePath&)>;
+
+namespace brave {
+
+class BraveComponentInstallerPolicy :
+    public component_updater::ComponentInstallerPolicy {
+ public:
+  explicit BraveComponentInstallerPolicy(const std::string& name,
+      const std::string &public_key,
+      const ReadyCallback& ready_callback);
+
+  ~BraveComponentInstallerPolicy() override;
+
+private:
+  // The following methods override ComponentInstallerPolicy
+  bool VerifyInstallation(const base::DictionaryValue& manifest,
+      const base::FilePath& install_dir) const override;
+  bool SupportsGroupPolicyEnabledComponentUpdates() const override;
+  bool RequiresNetworkEncryption() const override;
+  update_client::CrxInstaller::Result OnCustomInstall(
+      const base::DictionaryValue& manifest,
+      const base::FilePath& install_dir) override;
+  void OnCustomUninstall() override;
+  void ComponentReady(
+      const base::Version& version,
+      const base::FilePath& install_dir,
+      std::unique_ptr<base::DictionaryValue> manifest) override;
+  base::FilePath GetRelativeInstallDir() const override;
+  void GetHash(std::vector<uint8_t>* hash) const override;
+  std::string GetName() const override;
+  std::vector<std::string> GetMimeTypes() const override;
+  update_client::InstallerAttributes GetInstallerAttributes() const override;
+
+  std::string name_;
+  std::string public_key_;
+  ReadyCallback ready_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(BraveComponentInstallerPolicy);
+};
+
+void RegisterComponent(component_updater::ComponentUpdateService* cus,
+    const std::string& name,
+    const std::string& public_key,
+    const base::Closure& registered_callback,
+    const ReadyCallback& ready_callback);
+
+}  // namespace brave
+
+#endif  // COMPONENTS_COMPONENT_UPDATER_BRAVE_COMPONENT_INSTALLER_H_

components/brave_shields/browser/BUILD.gn

@@ -14,8 +14,6 @@ source_set("brave_shields") {
     "brave_resource_dispatcher_host_delegate.h",
     "dat_file_util.cc",
     "dat_file_util.h",
-    "dat_file_web_request.cc",
-    "dat_file_web_request.h",
     "https_everywhere_recently_used_cache.h",
     "https_everywhere_service.cc",
     "https_everywhere_service.h",

components/brave_shields/browser/ad_block_service.cc

@@ -13,24 +13,26 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
+#include "brave/browser/extensions/brave_component_installer.h"
 #include "brave/components/brave_shields/browser/dat_file_util.h"
 #include "brave/vendor/ad-block/ad_block_client.h"
+#include "chrome/browser/browser_process.h"
+#include "components/component_updater/component_installer.h"
+#include "components/component_updater/component_updater_service.h"
 
 #define DAT_FILE "ABPFilterParserData.dat"
-// TODO: Repalce this with the real version at runtime
-#define DAT_FILE_URL "https://s3.amazonaws.com/adblock-data/3/ABPFilterParserData.dat"
 
 namespace brave_shields {
 
-GURL AdBlockService::g_ad_block_url(DAT_FILE_URL);
+GURL AdBlockService::g_ad_block_url("");
 
 AdBlockService::AdBlockService() :
-    BaseBraveShieldsService(DAT_FILE, AdBlockService::g_ad_block_url),
     ad_block_client_(new AdBlockClient()) {
 }
 
@@ -69,16 +71,36 @@ bool AdBlockService::ShouldStartRequest(const GURL& url,
 }
 
 bool AdBlockService::Init() {
-   if (!GetDATFileData(DAT_FILE, buffer_)) {
+  base::Closure registered_callback =
+    base::Bind(&AdBlockService::OnComponentRegistered,
+               base::Unretained(this), kAdBlockPlusUpdaterId);
+  ReadyCallback ready_callback =
+    base::Bind(&AdBlockService::OnComponentReady,
+               base::Unretained(this), kAdBlockPlusUpdaterId);
+  brave::RegisterComponent(g_browser_process->component_updater(),
+      kAdBlockPlusUpdaterName, kAdBlockPlusUpdaterPublicKeyStr,
+      registered_callback, ready_callback);
+  return true;
+}
+
+void AdBlockService::OnComponentRegistered(const std::string& extension_id) {
+}
+
+void AdBlockService::OnComponentReady(const std::string& extension_id,
+                                      const base::FilePath& install_dir) {
+  if (!GetDATFileData(install_dir, DAT_FILE, buffer_)) {
     LOG(ERROR) << "Could not obtain ad block data file";
-    return false;
+    return;
+  }
+  if (buffer_.empty()) {
+    LOG(ERROR) << "Could not obtain ad block data";
+    return;
   }
   if (!ad_block_client_->deserialize((char*)&buffer_.front())) {
     ad_block_client_.reset();
-    LOG(ERROR) << "AdBlockService::InitAdBlock deserialize failed";
-    return false;
+    LOG(ERROR) << "Failed to deserialize ad block data";
+    return;
   }
-  return true;
 }
 
 // static

components/brave_shields/browser/ad_block_service.h

@@ -12,12 +12,58 @@
 #include <vector>
 #include <mutex>
 
+#include "base/files/file_path.h"
 #include "brave/components/brave_shields/browser/base_brave_shields_service.h"
 #include "content/public/common/resource_type.h"
 
 class AdBlockClient;
 class AdBlockServiceTest;
 
+const uint8_t kAdBlockPlusUpdaterPublicKey[294] = {
+  0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09,
+  0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
+  0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00,
+  0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
+  0x00, 0xb3, 0x4a, 0xb3, 0x26, 0x61, 0xd2, 0x80,
+  0x88, 0xb0, 0xec, 0x81, 0x85, 0x0b, 0x18, 0xa3,
+  0xd4, 0xd9, 0xc1, 0xe6, 0x12, 0x79, 0x65, 0x0d,
+  0x4b, 0x29, 0x6f, 0x61, 0xb4, 0xbe, 0x04, 0x04,
+  0xe6, 0x8c, 0x26, 0xf9, 0xaa, 0x68, 0x3b, 0x3f,
+  0xc1, 0xfa, 0xb4, 0x9f, 0x0f, 0xe0, 0xa0, 0x11,
+  0xd6, 0xb2, 0xaa, 0xa4, 0x30, 0x1c, 0xa7, 0x45,
+  0x3b, 0xb6, 0x1f, 0x1c, 0x62, 0xae, 0xf7, 0x5b,
+  0x72, 0xe8, 0x27, 0xd4, 0x6a, 0x32, 0xb3, 0x94,
+  0x0a, 0x3e, 0x00, 0x2f, 0x2b, 0x00, 0xc7, 0x26,
+  0x9f, 0x63, 0x96, 0x70, 0x03, 0x5a, 0x6e, 0x71,
+  0x42, 0xf3, 0xd0, 0xe0, 0x61, 0x35, 0x98, 0xad,
+  0x7f, 0x23, 0x79, 0x1a, 0xf5, 0xc1, 0x0e, 0x0b,
+  0x33, 0xd6, 0xe8, 0x62, 0x3e, 0xc0, 0x62, 0xe2,
+  0x54, 0xfc, 0x7d, 0x55, 0x9a, 0xf1, 0x1c, 0x7b,
+  0x12, 0x04, 0x82, 0x51, 0x68, 0x40, 0x79, 0x4f,
+  0x28, 0xb9, 0x6e, 0x3d, 0x02, 0x67, 0xe9, 0x1c,
+  0x7c, 0xc9, 0xd1, 0x4e, 0xc5, 0xc8, 0x07, 0x0d,
+  0xc2, 0xeb, 0x12, 0x60, 0x09, 0x52, 0x88, 0x49,
+  0x05, 0x24, 0x77, 0xc9, 0x9a, 0xc1, 0x5b, 0xc6,
+  0xbe, 0xa3, 0xa1, 0x04, 0xea, 0x20, 0x09, 0xd6,
+  0xfd, 0xab, 0x36, 0xb9, 0x78, 0x9d, 0x42, 0x83,
+  0x1f, 0x11, 0x58, 0xab, 0x9c, 0x15, 0xf6, 0x96,
+  0x5b, 0x12, 0x8b, 0x39, 0xe9, 0x42, 0x88, 0x13,
+  0x13, 0xd4, 0x79, 0xb5, 0xce, 0x70, 0x28, 0x54,
+  0x11, 0xc6, 0xfd, 0xb9, 0x61, 0x24, 0x93, 0x83,
+  0xe4, 0x77, 0x07, 0xfe, 0x17, 0x91, 0xac, 0x1e,
+  0x0c, 0xbe, 0xb1, 0x35, 0x27, 0xbe, 0x96, 0x17,
+  0x77, 0xef, 0x67, 0x4d, 0xda, 0x1d, 0x57, 0x27,
+  0x94, 0xbb, 0x50, 0x7a, 0x23, 0x4d, 0x39, 0x9e,
+  0xd5, 0x6c, 0x10, 0xd7, 0x76, 0x27, 0xbc, 0x36,
+  0x89, 0x9f, 0xfd, 0x0b, 0x30, 0x6c, 0x11, 0x9a,
+  0x57, 0x02, 0x03, 0x01, 0x00, 0x01
+};
+
+const std::string kAdBlockPlusUpdaterPublicKeyStr(
+  (const char *)kAdBlockPlusUpdaterPublicKey, sizeof(kAdBlockPlusUpdaterPublicKey));
+const std::string kAdBlockPlusUpdaterId("cffkpbalmllkdoenhmdmpbkajipdjfam");
+const std::string kAdBlockPlusUpdaterName("AdBlock Plus Updater");
+
 namespace brave_shields {
 
 // The brave shields service in charge of ad-block checking and init.
@@ -35,6 +81,11 @@ class AdBlockService : public BaseBraveShieldsService {
   void Cleanup() override;
 
  private:
+  void OnComponentRegistered(const std::string& extension_id);
+  void OnComponentReady(
+    const std::string& extension_id,
+    const base::FilePath& install_dir);
+
   friend class ::AdBlockServiceTest;
   static GURL g_ad_block_url;
   static void SetAdBlockURLForTest(const GURL& url);