Merge pull request #6964 from brave/mpilgrim_farble_devicememory

Implement navigator.deviceMemory farbling

browser/farbling/BUILD.gn

@@ -1,3 +1,8 @@
+# Copyright (c) 2020 The Brave Authors. All rights reserved.
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/. */
+
 source_set("farbling") {
  check_includes = false
  sources = [
@@ -16,3 +21,33 @@ source_set("farbling") {
  "//third_party/blink/public/common",
  ]
 }
+
+source_set("browser_tests") {
+ testonly = true
+ check_includes = false
+ defines = [ "HAS_OUT_OF_PROC_TEST_RUNNER" ]
+
+ sources = [
+ "brave_enumeratedevices_farbling_browsertest.cc",
+ "brave_navigator_devicememory_farbling_browsertest.cc",
+ "brave_navigator_hardwareconcurrency_farbling_browsertest.cc",
+ "brave_navigator_plugins_farbling_browsertest.cc",
+ "brave_navigator_useragent_farbling_browsertest.cc",
+ "brave_offscreencanvas_farbling_browsertest.cc",
+ "brave_webaudio_farbling_browsertest.cc",
+ "brave_webgl_farbling_browsertest.cc",
+ ]
+
+ deps = [
+ "//brave/browser:browser_process",
+ "//brave/common:pref_names",
+ "//brave/components/brave_component_updater/browser:browser",
+ "//brave/components/brave_shields/browser:browser",
+ "//chrome/browser",
+ "//chrome/browser/ui",
+ "//chrome/test:test_support",
+ "//chrome/test:test_support_ui",
+ "//components/permissions:permissions",
+ "//content/test:test_support",
+ ]
+}

browser/farbling/brave_navigator_devicememory_farbling_browsertest.cc

@@ -0,0 +1,152 @@
+/* Copyright (c) 2020 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "base/path_service.h"
+#include "base/strings/stringprintf.h"
+#include "base/task/post_task.h"
+#include "base/test/thread_test_helper.h"
+#include "brave/browser/brave_browser_process_impl.h"
+#include "brave/browser/brave_content_browser_client.h"
+#include "brave/browser/extensions/brave_base_local_data_files_browsertest.h"
+#include "brave/common/brave_paths.h"
+#include "brave/common/pref_names.h"
+#include "brave/components/brave_component_updater/browser/local_data_files_service.h"
+#include "brave/components/brave_shields/browser/brave_shields_util.h"
+#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/extensions/extension_browsertest.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/common/chrome_content_client.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "components/network_session_configurator/common/network_switches.h"
+#include "components/permissions/permission_request.h"
+#include "components/prefs/pref_service.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/test/browser_test.h"
+#include "content/public/test/browser_test_utils.h"
+#include "net/dns/mock_host_resolver.h"
+#include "third_party/blink/public/common/device_memory/approximated_device_memory.h"
+
+using brave_shields::ControlType;
+
+const char kDeviceMemoryScript[] = "navigator.deviceMemory * 1024";
+
+class BraveDeviceMemoryFarblingBrowserTest : public InProcessBrowserTest {
+ public:
+ BraveDeviceMemoryFarblingBrowserTest()
+ : https_server_(net::EmbeddedTestServer::TYPE_HTTPS) {
+ brave::RegisterPathProvider();
+ base::FilePath test_data_dir;
+ base::PathService::Get(brave::DIR_TEST_DATA, &test_data_dir);
+ https_server_.SetSSLConfig(net::EmbeddedTestServer::CERT_OK);
+ https_server_.ServeFilesFromDirectory(test_data_dir);
+ EXPECT_TRUE(https_server_.Start());
+ }
+
+ BraveDeviceMemoryFarblingBrowserTest(
+ const BraveDeviceMemoryFarblingBrowserTest&) = delete;
+ BraveDeviceMemoryFarblingBrowserTest& operator=(
+ const BraveDeviceMemoryFarblingBrowserTest&) = delete;
+
+ ~BraveDeviceMemoryFarblingBrowserTest() override {}
+
+ void SetUpCommandLine(base::CommandLine* command_line) override {
+ // HTTPS server only serves a valid cert for localhost, so this is needed
+ // to load pages from other hosts without an error
+ command_line->AppendSwitch(switches::kIgnoreCertificateErrors);
+ }
+
+ void SetUpOnMainThread() override {
+ InProcessBrowserTest::SetUpOnMainThread();
+
+ content_client_.reset(new ChromeContentClient);
+ content::SetContentClient(content_client_.get());
+ browser_content_client_.reset(new BraveContentBrowserClient());
+ content::SetBrowserClientForTesting(browser_content_client_.get());
+
+ host_resolver()->AddRule("*", "127.0.0.1");
+ }
+
+ void TearDown() override {
+ browser_content_client_.reset();
+ content_client_.reset();
+ }
+
+ protected:
+ base::test::ScopedFeatureList feature_list_;
+ net::EmbeddedTestServer https_server_;
+
+ HostContentSettingsMap* content_settings() {
+ return HostContentSettingsMapFactory::GetForProfile(browser()->profile());
+ }
+
+ void AllowFingerprinting(std::string domain) {
+ brave_shields::SetFingerprintingControlType(
+ content_settings(), ControlType::ALLOW,
+ https_server_.GetURL(domain, "/"));
+ }
+
+ void BlockFingerprinting(std::string domain) {
+ brave_shields::SetFingerprintingControlType(
+ content_settings(), ControlType::BLOCK,
+ https_server_.GetURL(domain, "/"));
+ }
+
+ void SetFingerprintingDefault(std::string domain) {
+ brave_shields::SetFingerprintingControlType(
+ content_settings(), ControlType::DEFAULT,
+ https_server_.GetURL(domain, "/"));
+ }
+
+ content::WebContents* contents() {
+ return browser()->tab_strip_model()->GetActiveWebContents();
+ }
+
+ bool NavigateToURLUntilLoadStop(const GURL& url) {
+ ui_test_utils::NavigateToURL(browser(), url);
+ return WaitForLoadStop(contents());
+ }
+
+ private:
+ std::unique_ptr<ChromeContentClient> content_client_;
+ std::unique_ptr<BraveContentBrowserClient> browser_content_client_;
+};
+
+// Tests results of farbling known values
+IN_PROC_BROWSER_TEST_F(BraveDeviceMemoryFarblingBrowserTest,
+ FarbleDeviceMemory) {
+ std::string domain1 = "b.com";
+ std::string domain2 = "z.com";
+ GURL url1 = https_server_.GetURL(domain1, "/simple.html");
+ GURL url2 = https_server_.GetURL(domain2, "/simple.html");
+ // set memory to 10GB
+ blink::ApproximatedDeviceMemory::SetPhysicalMemoryMBForTesting(1024 * 10);
+ int true_value =
+ blink::ApproximatedDeviceMemory::GetApproximatedDeviceMemory() * 1024;
+ EXPECT_EQ(true_value, 8192);
+ // Farbling level: off
+ AllowFingerprinting(domain1);
+ NavigateToURLUntilLoadStop(url1);
+ EXPECT_EQ(true_value, EvalJs(contents(), kDeviceMemoryScript));
+ AllowFingerprinting(domain2);
+ NavigateToURLUntilLoadStop(url2);
+ EXPECT_EQ(true_value, EvalJs(contents(), kDeviceMemoryScript));
+
+ // Farbling level: default
+ SetFingerprintingDefault(domain1);
+ NavigateToURLUntilLoadStop(url1);
+ EXPECT_EQ(4096, EvalJs(contents(), kDeviceMemoryScript));
+ SetFingerprintingDefault(domain2);
+ NavigateToURLUntilLoadStop(url2);
+ EXPECT_EQ(2048, EvalJs(contents(), kDeviceMemoryScript));
+
+ // Farbling level: maximum
+ BlockFingerprinting(domain1);
+ NavigateToURLUntilLoadStop(url1);
+ EXPECT_EQ(1024, EvalJs(contents(), kDeviceMemoryScript));
+ AllowFingerprinting(domain2);
+ NavigateToURLUntilLoadStop(url2);
+ EXPECT_EQ(8192, EvalJs(contents(), kDeviceMemoryScript));
+}

chromium_src/third_party/blink/renderer/core/frame/navigator_device_memory.cc

@@ -0,0 +1,68 @@
+/* Copyright (c) 2020 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <random>
+
+#include "brave/third_party/blink/renderer/brave_farbling_constants.h"
+#include "third_party/blink/public/common/device_memory/approximated_device_memory.h"
+#include "third_party/blink/public/platform/web_content_settings_client.h"
+#include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/core/frame/navigator_device_memory.h"
+
+namespace brave {
+
+float FarbleDeviceMemory(blink::ExecutionContext* context) {
+ float true_value =
+ blink::ApproximatedDeviceMemory::GetApproximatedDeviceMemory();
+ blink::WebContentSettingsClient* settings =
+ GetContentSettingsClientFor(context);
+ // If Brave Shields are down or anti-fingerprinting is off for this site,
+ // return the true value.
+ if (!settings || settings->GetBraveFarblingLevel() == BraveFarblingLevel::OFF)
+ return true_value;
+
+ std::vector<float> valid_values = {0.25, 0.5, 1.0, 2.0, 4.0, 8.0};
+ int min_farbled_index;
+ int max_farbled_index;
+ if (settings->GetBraveFarblingLevel() == BraveFarblingLevel::MAXIMUM) {
+ // If anti-fingerprinting is at maximum, select a pseudo-random valid value
+ // based on domain + sesson key.
+ min_farbled_index = 0;
+ max_farbled_index = valid_values.size() - 1;
+ } else {
+ // If anti-fingerprinting is at default level, select a pseudo-random valid
+ // value between 0.5 and the true value (unless the true value is 0.25 in
+ // which case just return that).
+ auto true_it =
+ std::find(valid_values.begin(), valid_values.end(), true_value);
+ int true_index;
+ // Get index into |valid_values| of the true value. If it's not found,
+ // assume the last index. (This should not happen, but it allows us to
+ // fail closed instead of failing open.)
+ if (true_it != valid_values.end())
+ true_index = std::distance(valid_values.begin(), true_it);
+ else
+ true_index = valid_values.size() - 1;
+ min_farbled_index = 1;
+ max_farbled_index = true_index;
+ if (max_farbled_index <= min_farbled_index)
+ return valid_values[min_farbled_index];
+ }
+ std::mt19937_64 prng =
+ BraveSessionCache::From(*context).MakePseudoRandomGenerator();
+ return valid_values[min_farbled_index +
+ (prng() % (max_farbled_index + 1 - min_farbled_index))];
+}
+
+} // namespace brave
+
+namespace blink {
+
+float NavigatorDeviceMemory::deviceMemory(ScriptState* script_state) const {
+ ExecutionContext* context = ExecutionContext::From(script_state);
+ return brave::FarbleDeviceMemory(context);
+}
+
+} // namespace blink

chromium_src/third_party/blink/renderer/core/frame/navigator_device_memory.h

@@ -0,0 +1,20 @@
+/* Copyright (c) 2020 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_CHROMIUM_SRC_THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_NAVIGATOR_DEVICE_MEMORY_H_
+#define BRAVE_CHROMIUM_SRC_THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_NAVIGATOR_DEVICE_MEMORY_H_
+
+#include "third_party/blink/renderer/core/core_export.h"
+
+namespace blink {
+
+class CORE_EXPORT NavigatorDeviceMemory {
+ public:
+ float deviceMemory(ScriptState*) const;
+};
+
+} // namespace blink
+
+#endif // BRAVE_CHROMIUM_SRC_THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_NAVIGATOR_DEVICE_MEMORY_H_

patches/third_party-blink-renderer-core-frame-navigator_device_memory.idl.patch

@@ -0,0 +1,12 @@
+diff --git a/third_party/blink/renderer/core/frame/navigator_device_memory.idl b/third_party/blink/renderer/core/frame/navigator_device_memory.idl
+index f016ac69fa7cb93dc078f0d49aa92ff8bfef1c0b..8204a381031d17eb2fdac11591859f7c221fffd2 100644
+--- a/third_party/blink/renderer/core/frame/navigator_device_memory.idl
++++ b/third_party/blink/renderer/core/frame/navigator_device_memory.idl
+@@ -5,6 +5,6 @@
+ // https://github.com/w3c/device-memory#the-web-exposed-api
+
+ interface mixin NavigatorDeviceMemory {
+- [HighEntropy=Direct,MeasureAs=NavigatorDeviceMemory,SecureContext]
++ [CallWith=ScriptState,HighEntropy=Direct,MeasureAs=NavigatorDeviceMemory,SecureContext]
+ readonly attribute float deviceMemory;
+ };

test/BUILD.gn

@@ -600,13 +600,6 @@ if (!is_android) {
  "//brave/browser/extensions/brave_extension_functional_test.h",
  "//brave/browser/extensions/brave_extension_provider_browsertest.cc",
  "//brave/browser/extensions/brave_theme_event_router_browsertest.cc",
- "//brave/browser/farbling/brave_enumeratedevices_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_navigator_hardwareconcurrency_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_navigator_plugins_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_navigator_useragent_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_offscreencanvas_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_webaudio_farbling_browsertest.cc",
- "//brave/browser/farbling/brave_webgl_farbling_browsertest.cc",
  "//brave/browser/net/brave_network_delegate_browsertest.cc",
  "//brave/browser/net/brave_network_delegate_hsts_fingerprinting_browsertest.cc",
  "//brave/browser/net/brave_site_hacks_network_delegate_helper_browsertest.cc",
@@ -686,6 +679,7 @@ if (!is_android) {
  "//brave/browser/tor:browser_tests",
  "//brave/chromium_src/third_party/blink/renderer/modules:browser_tests",
  "//brave/components/ipfs/test:brave_ipfs_browser_tests",
+ "//brave/browser/farbling:browser_tests",
  "//brave/browser/ui/tabs/test:browser_tests",
  "//media:test_support",
  ]