├── README.md
├── audio
    └── offline_audio_context_power.cc
├── base
    ├── BUILD.gn
    ├── custom_command.h
    ├── extended_parameters.cc
    ├── extended_parameters.h
    └── fingerprint.h
├── canvas
    ├── base_rendering_context_2d_power.cc
    └── canvas_path_power.cc
├── screen
    └── screen_power.cc
└── webgl
    └── webgl_rendering_context_base_power.cc


/README.md:
--------------------------------------------------------------------------------
 1 | # Chrome Power
 2 | 
 3 | ## Refer
 4 | [r0chrome](https://github.com/CrackerCat/r0chrome)
 5 | 
 6 | ## Build
 7 | 
 8 | `autoninja -C out\Default chrome`
 9 | 
10 | ## Files Path
11 | 
12 | ### Hardware
13 | 
14 | `src/third_party/blink/renderer/core/frame/navigator_concurrent_hardware.cc`
15 | 
16 | ### UserAgent, System Type
17 | 
18 | `src/chrome/browser/chrome_content_browser_client.cc`
19 | 
20 | ### Canvas
21 | 
22 | `src/third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.cc`
23 | `BaseRenderingContext2D::measureText`
24 | 
25 | `src\third_party\blink\renderer\modules\canvas\canvas2d\canvas_path.cc`
26 | `CanvasPath::arc`
27 | 
28 | ### Audio
29 | 
30 | `src/third_party/blink/renderer/modules/offline_audio_context_power`
31 | `OfflineAudioContext* OfflineAudioContext::Create`
32 | 
33 | `src/third_party/blink/renderer/modules/webaudio/base_audio_context.cc`
34 | 
35 | ### Fonts
36 | 
37 | `src/third_party/blink/renderer/platform/fonts`
38 | 
39 | ### Memory
40 | 
41 | `src/third_party/blink/renderer/core/frame/navigator_device_memory.cc`
42 | 
43 | ### Platform
44 | 
45 | `src/third_party/blink/renderer/core/frame/navigator_id.cc`
46 | 
47 | ### Screen, Color
48 | 
49 | `src/third_party/blink/renderer/core/frame/screen.cc`
50 | 
51 | ### WebGL
52 | 
53 | `src/third_party/blink/renderer/modules/webgl/webgl_rendering_context_base.cc`
54 | 
55 | ## Hide the "Missing API KEY" Info Bar
56 | 
57 | `src\chrome\browser\ui\startup\infobar_utils.cc`
58 | 
59 | ```c++
60 |     // if (!google_apis::HasAPIKeyConfigured())
61 |       // GoogleApiKeysInfoBarDelegate::Create(infobar_manager);
62 | ```
63 | 
64 | ## Handling of customized parameters
65 | 
66 | Goto `\content\browser\renderer_host\render_process_host_impl.cc`, add custom paramters to `kSwitchNames`
67 | 
68 | 
69 | `src\third_party\blink\renderer\chrome_power\base\extended_parameters.cc`
70 | 


--------------------------------------------------------------------------------
/audio/offline_audio_context_power.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <time.h>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | #include <iostream>
 7 | #include <string>
 8 | #include <vector>
 9 | #include "third_party/blink/renderer/chrome_power/base/extended_parameters.h"
10 | #include "third_party/blink/renderer/chrome_power/base/fingerprint.h"
11 | 
12 | int getRandomAudioNum() {
13 |   srand(int(time(0)));
14 | 
15 |   std::variant<std::string, int, float> param =
16 |       ExtendedParameters::GetInstance()->GetParameter(
17 |           fingerprint::audio::audioFlag);
18 | 
19 |   int result = 0;
20 |   int* int_ptr = std::get_if<int>(&param);
21 |   if (int_ptr) {
22 |     result = *int_ptr;
23 |   } else {
24 |     result = rand() % 99;
25 |   }
26 | 
27 |   return result;
28 | }
29 | 


--------------------------------------------------------------------------------
/base/BUILD.gn:
--------------------------------------------------------------------------------
 1 | # 在 chrome_power/base/BUILD.gn
 2 | 
 3 | source_set("extended_parameters") {
 4 |   sources = [
 5 |     "extended_parameters.cc",  # 源文件列表
 6 |   ]
 7 | 
 8 |   public_deps = [
 9 |     "//base",                  # 依赖 Chromium 的 base 模块
10 |   ]
11 | 
12 |   public = [
13 |     "extended_parameters.h",    # 公开的头文件
14 |     "custom_command.h",
15 |   ]
16 | }
17 | 


--------------------------------------------------------------------------------
/base/custom_command.h:
--------------------------------------------------------------------------------
1 | 
2 | namespace chrome_power {
3 |     constexpr char kExtendedParametersFlag[] = "extended-parameters";
4 | }


--------------------------------------------------------------------------------
/base/extended_parameters.cc:
--------------------------------------------------------------------------------
 1 | // extended_parameters.cc
 2 | #include "third_party/blink/renderer/chrome_power/base/extended_parameters.h"
 3 | #include "third_party/blink/renderer/chrome_power/base/custom_command.h"
 4 | 
 5 | std::mutex ExtendedParameters::mutex_;
 6 | ExtendedParameters* ExtendedParameters::instance_ = nullptr;
 7 | 
 8 | ExtendedParameters::ExtendedParameters() {
 9 |   InitializeFromCommandLine();
10 | }
11 | 
12 | ExtendedParameters* ExtendedParameters::GetInstance() {
13 |   std::lock_guard<std::mutex> lock(mutex_);
14 |   if (instance_ == nullptr) {
15 |     instance_ = new ExtendedParameters();
16 |   }
17 |   return instance_;
18 | }
19 | 
20 | void ExtendedParameters::InitializeFromCommandLine() {
21 |   const auto& command_line = *base::CommandLine::ForCurrentProcess();
22 | 
23 |   if (command_line.HasSwitch(chrome_power::kExtendedParametersFlag)) {
24 |     std::string encoded_param =
25 |         command_line.GetSwitchValueASCII(chrome_power::kExtendedParametersFlag);
26 |     std::string json_string;
27 |     if (base::Base64Decode(encoded_param, &json_string)) {
28 |       absl::optional<base::Value> parsed_json =
29 |           base::JSONReader::Read(json_string);
30 |       if (parsed_json) {
31 |         LOG(WARNING) << "Extended parameters: " << parsed_json.value();
32 |         parameters_ = std::move(*parsed_json);
33 |       } else {
34 |         LOG(ERROR) << "Failed to parse JSON parameters.";
35 |       }
36 |     } else {
37 |       LOG(ERROR) << "Failed to decode extended-parameters.";
38 |     }
39 |   } else {
40 |     LOG(WARNING) << "No extended-parameters found.";
41 |   }
42 | }
43 | 
44 | std::variant<std::string, int, float> ExtendedParameters::GetParameter(
45 |     const std::string& key) const {
46 |   LOG(WARNING) << "Extended parameters: " << parameters_.value();
47 |   if (parameters_ && parameters_->is_dict()) {
48 |     const auto& dict = parameters_->GetDict();
49 | 
50 |     const base::Value* value = dict.Find(key);
51 |     if (value) {
52 |       if (value->is_string()) {
53 |         return value->GetString();
54 |       } else if (value->is_int()) {
55 |         return value->GetInt();
56 |       } else if (value->is_double()) {
57 |         double double_value = value->GetDouble();
58 |         return static_cast<float>(double_value);
59 |       }
60 |     }
61 |   }
62 |   return "";  // 或者返回一个默认的数值，视您的需要而定
63 | }
64 | 


--------------------------------------------------------------------------------
/base/extended_parameters.h:
--------------------------------------------------------------------------------
 1 | #ifndef EXTENDED_PARAMETERS_H_
 2 | #define EXTENDED_PARAMETERS_H_
 3 | 
 4 | #include <variant>
 5 | #include <string>
 6 | #include <mutex>
 7 | #include "base/values.h"
 8 | #include "base/command_line.h"
 9 | #include "base/logging.h"
10 | #include "base/base64.h"
11 | #include "third_party/abseil-cpp/absl/types/optional.h"
12 | #include "base/json/json_reader.h"
13 | 
14 | class ExtendedParameters {
15 |  public:
16 |   static ExtendedParameters* GetInstance();
17 | 
18 |   std::variant<std::string, int, float> GetParameter(const std::string& key) const;
19 | 
20 |  private:
21 |   ExtendedParameters();
22 |   ~ExtendedParameters() = default;
23 | 
24 |   void InitializeFromCommandLine();
25 | 
26 |   absl::optional<base::Value> parameters_;
27 |   static std::mutex mutex_;
28 |   static ExtendedParameters* instance_;
29 | };
30 | 
31 | #endif  // EXTENDED_PARAMETERS_H_


--------------------------------------------------------------------------------
/base/fingerprint.h:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace fingerprint {
 3 |     namespace canvas {
 4 |         constexpr char textFlag[] = "pathStr";
 5 |     }
 6 |     namespace webgl {
 7 |         constexpr char floatFlag[] = "webgl";
 8 |         constexpr char gpuFlag[] = "gpu";
 9 |     }
10 |     namespace audio {
11 |         constexpr char audioFlag[] = "audio";
12 |     }
13 | } 
14 | 


--------------------------------------------------------------------------------
/canvas/base_rendering_context_2d_power.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <time.h>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | #include <iostream>
 7 | #include <string>
 8 | #include <vector>
 9 | #include "third_party/blink/renderer/chrome_power/base/extended_parameters.h"
10 | #include "third_party/blink/renderer/chrome_power/base/fingerprint.h"
11 | 
12 | // #include "base/values.h"
13 | // #include "base/json/json_reader.h"
14 | // #include "third_party/blink/renderer/chrome_power/base/extended_parameters.h"
15 | 
16 | int getRandomNum() {
17 |   srand(int(time(0)));
18 |   return rand() % 20;
19 | }
20 | 
21 | String getRandomStr() {
22 |   srand(int(time(0)));
23 |   String str_list[] = {"a", "b", "c", "d", "e", "f", "g", "h", "i",
24 |                        "j", "k", "l", "m", "n", "o", "p", "q", "r",
25 |                        "s", "t", "u", "v", "w", "x", "y", "z", "0",
26 |                        "1", "2", "3", "4", "5", "6", "7", "8", "9"};
27 | 
28 |   std::variant<std::string, int, float> param =
29 |       ExtendedParameters::GetInstance()->GetParameter(
30 |           fingerprint::canvas::textFlag);
31 | 
32 |   String result;
33 | 
34 |   std::string pathStr;
35 |   // 显式声明指针类型
36 |   std::string* str_ptr = std::get_if<std::string>(&param);
37 |   if (str_ptr) {
38 |     pathStr = *str_ptr;
39 |   }
40 |   if (!pathStr.empty()) {
41 |     result = String::FromUTF8(pathStr.c_str(), pathStr.length());
42 |   } else {
43 |     int length = sizeof(str_list) / sizeof(str_list[0]);
44 |     result = str_list[rand() % length];
45 |   }
46 | 
47 |   return result;
48 | }
49 | 


--------------------------------------------------------------------------------
/canvas/canvas_path_power.cc:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<cstring>
 3 | #include<string>
 4 | #include<vector>
 5 | #include<algorithm>
 6 | #include<time.h>
 7 | #include<stdio.h>
 8 | #include<stdlib.h>
 9 | 
10 | int getRandomArc(){
11 |     srand(int(time(0)));
12 |     return rand() % 10;
13 | }


--------------------------------------------------------------------------------
/screen/screen_power.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <time.h>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | #include <iostream>
 7 | #include <string>
 8 | #include <vector>
 9 | 
10 | int getRandomScreenNum() {
11 |   srand(int(time(0)));
12 |   return rand() % 10;
13 | }
14 | 


--------------------------------------------------------------------------------
/webgl/webgl_rendering_context_base_power.cc:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <time.h>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | #include <iostream>
 7 | #include <string>
 8 | #include <vector>
 9 | #include "third_party/blink/renderer/chrome_power/base/extended_parameters.h"
10 | #include "third_party/blink/renderer/chrome_power/base/fingerprint.h"
11 | 
12 | // int randomFunc(int arr_len) {
13 | //   return rand() % arr_len;
14 | // }
15 | 
16 | // String getRandomGPU() {
17 | //   srand(int(time(0)));
18 | //   String gpuList[] = {
19 | //       "ANGLE (NVIDIA, NVIDIA GeForce RTX 3080 Direct3D11 vs_5_0 ps_5_0,
20 | //       D3D11)", "ANGLE (NVIDIA, NVIDIA GeForce RTX 3070 Direct3D11 vs_5_0
21 | //       ps_5_0, D3D11)", "ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11
22 | //       vs_5_0 ps_5_0, D3D11)",
23 | //   };
24 | //   int length = sizeof(gpuList) / sizeof(gpuList[0]);
25 | //   return gpuList[randomFunc(length)];
26 | // }
27 | 
28 | float getRandomFloat() {
29 |   srand((unsigned int)time(NULL));
30 | 
31 |   std::variant<std::string, int, float> param =
32 |       ExtendedParameters::GetInstance()->GetParameter(
33 |           fingerprint::webgl::floatFlag);
34 | 
35 |   std::visit(
36 |       [](auto&& arg) {
37 |         using T = std::decay_t<decltype(arg)>;
38 |         if constexpr (std::is_same_v<T, float>) {
39 |           LOG(WARNING) << "param is a float: " << arg << std::endl;
40 |         } else if constexpr (std::is_same_v<T, int>) {
41 |           LOG(WARNING) << "param is an int: " << arg << std::endl;
42 |         } else if constexpr (std::is_same_v<T, std::string>) {
43 |           LOG(WARNING) << "param is a string: " << arg << std::endl;
44 |         } else {
45 |           LOG(WARNING) << "param is of unknown type " << std::endl;
46 |         }
47 |       },
48 |       param);
49 | 
50 |   float result;
51 | 
52 |   float* float_ptr = std::get_if<float>(&param);
53 |   if (float_ptr) {
54 |     result = *float_ptr;
55 |   } else {
56 |     result = static_cast<float>(rand()) / static_cast<float>(RAND_MAX) / 2;
57 |   }
58 |   return result;
59 | }
60 | 


--------------------------------------------------------------------------------