blocklist_extension_prefs.cc 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "extensions/browser/blocklist_extension_prefs.h"
  5. #include "extensions/browser/blocklist_state.h"
  6. #include "extensions/browser/extension_prefs.h"
  7. namespace extensions {
  8. namespace {
  9. // If extension is blocklisted by Omaha attributes.
  10. constexpr const char kPrefOmahaBlocklistState[] = "omaha_blocklist_state";
  11. // If the user has acknowledged the blocklist state.
  12. constexpr const char kPrefAcknowledgedBlocklistState[] =
  13. "acknowledged_blocklist_state";
  14. // If extension is blocklisted or greylisted.
  15. constexpr const char kPrefBlocklistState[] = "blacklist_state";
  16. // The default value to use for getting blocklist state from the pref.
  17. constexpr BitMapBlocklistState kDefaultBitMapBlocklistState =
  18. BitMapBlocklistState::NOT_BLOCKLISTED;
  19. // Extensions in these states should be put into the extension greylist.
  20. // This list is sorted by the precedence order. When two states are presented
  21. // at the same time, the state with higher precedence takes effect.
  22. const BitMapBlocklistState kGreylistStates[] = {
  23. BitMapBlocklistState::BLOCKLISTED_CWS_POLICY_VIOLATION,
  24. BitMapBlocklistState::BLOCKLISTED_POTENTIALLY_UNWANTED,
  25. BitMapBlocklistState::BLOCKLISTED_SECURITY_VULNERABILITY};
  26. const int kAllGreylistStates =
  27. static_cast<int>(BitMapBlocklistState::BLOCKLISTED_SECURITY_VULNERABILITY) |
  28. static_cast<int>(BitMapBlocklistState::BLOCKLISTED_CWS_POLICY_VIOLATION) |
  29. static_cast<int>(BitMapBlocklistState::BLOCKLISTED_POTENTIALLY_UNWANTED);
  30. // Converts BitMapBlocklistState to BlocklistState.
  31. BlocklistState BitMapBlocklistStateToBlocklistState(
  32. BitMapBlocklistState blocklist_state) {
  33. switch (blocklist_state) {
  34. case BitMapBlocklistState::NOT_BLOCKLISTED:
  35. return NOT_BLOCKLISTED;
  36. case BitMapBlocklistState::BLOCKLISTED_MALWARE:
  37. return BLOCKLISTED_MALWARE;
  38. case BitMapBlocklistState::BLOCKLISTED_SECURITY_VULNERABILITY:
  39. return BLOCKLISTED_SECURITY_VULNERABILITY;
  40. case BitMapBlocklistState::BLOCKLISTED_CWS_POLICY_VIOLATION:
  41. return BLOCKLISTED_CWS_POLICY_VIOLATION;
  42. case BitMapBlocklistState::BLOCKLISTED_POTENTIALLY_UNWANTED:
  43. return BLOCKLISTED_POTENTIALLY_UNWANTED;
  44. }
  45. }
  46. } // namespace
  47. namespace blocklist_prefs {
  48. BitMapBlocklistState BlocklistStateToBitMapBlocklistState(
  49. BlocklistState blocklist_state) {
  50. switch (blocklist_state) {
  51. case NOT_BLOCKLISTED:
  52. return BitMapBlocklistState::NOT_BLOCKLISTED;
  53. case BLOCKLISTED_MALWARE:
  54. return BitMapBlocklistState::BLOCKLISTED_MALWARE;
  55. case BLOCKLISTED_SECURITY_VULNERABILITY:
  56. return BitMapBlocklistState::BLOCKLISTED_SECURITY_VULNERABILITY;
  57. case BLOCKLISTED_CWS_POLICY_VIOLATION:
  58. return BitMapBlocklistState::BLOCKLISTED_CWS_POLICY_VIOLATION;
  59. case BLOCKLISTED_POTENTIALLY_UNWANTED:
  60. return BitMapBlocklistState::BLOCKLISTED_POTENTIALLY_UNWANTED;
  61. case BLOCKLISTED_UNKNOWN:
  62. NOTREACHED() << "The unknown state should not be added into prefs.";
  63. return BitMapBlocklistState::NOT_BLOCKLISTED;
  64. }
  65. }
  66. BitMapBlocklistState GetExtensionBlocklistState(
  67. const std::string& extension_id,
  68. ExtensionPrefs* extension_prefs) {
  69. BitMapBlocklistState sb_state =
  70. GetSafeBrowsingExtensionBlocklistState(extension_id, extension_prefs);
  71. if (sb_state == BitMapBlocklistState::BLOCKLISTED_MALWARE ||
  72. HasOmahaBlocklistState(extension_id,
  73. BitMapBlocklistState::BLOCKLISTED_MALWARE,
  74. extension_prefs)) {
  75. return BitMapBlocklistState::BLOCKLISTED_MALWARE;
  76. }
  77. for (auto greylist_state : kGreylistStates) {
  78. if (sb_state == greylist_state ||
  79. HasOmahaBlocklistState(extension_id, greylist_state, extension_prefs)) {
  80. return greylist_state;
  81. }
  82. }
  83. return BitMapBlocklistState::NOT_BLOCKLISTED;
  84. }
  85. bool IsExtensionBlocklisted(const std::string& extension_id,
  86. ExtensionPrefs* extension_prefs) {
  87. return GetExtensionBlocklistState(extension_id, extension_prefs) ==
  88. BitMapBlocklistState::BLOCKLISTED_MALWARE;
  89. }
  90. void AddOmahaBlocklistState(const std::string& extension_id,
  91. BitMapBlocklistState state,
  92. ExtensionPrefs* extension_prefs) {
  93. extension_prefs->ModifyBitMapPrefBits(
  94. extension_id, static_cast<int>(state), ExtensionPrefs::BIT_MAP_PREF_ADD,
  95. kPrefOmahaBlocklistState, static_cast<int>(kDefaultBitMapBlocklistState));
  96. }
  97. void RemoveOmahaBlocklistState(const std::string& extension_id,
  98. BitMapBlocklistState state,
  99. ExtensionPrefs* extension_prefs) {
  100. extension_prefs->ModifyBitMapPrefBits(
  101. extension_id, static_cast<int>(state),
  102. ExtensionPrefs::BIT_MAP_PREF_REMOVE, kPrefOmahaBlocklistState,
  103. static_cast<int>(kDefaultBitMapBlocklistState));
  104. }
  105. bool HasOmahaBlocklistState(const std::string& extension_id,
  106. BitMapBlocklistState state,
  107. ExtensionPrefs* extension_prefs) {
  108. int current_states = extension_prefs->GetBitMapPrefBits(
  109. extension_id, kPrefOmahaBlocklistState,
  110. static_cast<int>(kDefaultBitMapBlocklistState));
  111. return (current_states & static_cast<int>(state)) != 0;
  112. }
  113. bool HasAnyOmahaGreylistState(const std::string& extension_id,
  114. ExtensionPrefs* extension_prefs) {
  115. int current_states = extension_prefs->GetBitMapPrefBits(
  116. extension_id, kPrefOmahaBlocklistState,
  117. static_cast<int>(kDefaultBitMapBlocklistState));
  118. return (current_states & kAllGreylistStates) != 0;
  119. }
  120. void AddAcknowledgedBlocklistState(const std::string& extension_id,
  121. BitMapBlocklistState state,
  122. ExtensionPrefs* extension_prefs) {
  123. extension_prefs->ModifyBitMapPrefBits(
  124. extension_id, static_cast<int>(state), ExtensionPrefs::BIT_MAP_PREF_ADD,
  125. kPrefAcknowledgedBlocklistState,
  126. static_cast<int>(kDefaultBitMapBlocklistState));
  127. }
  128. void RemoveAcknowledgedBlocklistState(
  129. const std::string& extension_id,
  130. BitMapBlocklistState state,
  131. extensions::ExtensionPrefs* extension_prefs) {
  132. extension_prefs->ModifyBitMapPrefBits(
  133. extension_id, static_cast<int>(state),
  134. ExtensionPrefs::BIT_MAP_PREF_REMOVE, kPrefAcknowledgedBlocklistState,
  135. static_cast<int>(kDefaultBitMapBlocklistState));
  136. }
  137. void ClearAcknowledgedGreylistStates(const std::string& extension_id,
  138. ExtensionPrefs* extension_prefs) {
  139. for (auto state : kGreylistStates) {
  140. RemoveAcknowledgedBlocklistState(extension_id, state, extension_prefs);
  141. }
  142. }
  143. bool HasAcknowledgedBlocklistState(const std::string& extension_id,
  144. BitMapBlocklistState state,
  145. const ExtensionPrefs* extension_prefs) {
  146. int current_states = extension_prefs->GetBitMapPrefBits(
  147. extension_id, kPrefAcknowledgedBlocklistState,
  148. static_cast<int>(kDefaultBitMapBlocklistState));
  149. return (current_states & static_cast<int>(state)) != 0;
  150. }
  151. void UpdateCurrentGreylistStatesAsAcknowledged(
  152. const std::string& extension_id,
  153. ExtensionPrefs* extension_prefs) {
  154. for (auto state : kGreylistStates) {
  155. bool is_on_sb_list = (GetSafeBrowsingExtensionBlocklistState(
  156. extension_id, extension_prefs) == state);
  157. bool is_on_omaha_list =
  158. HasOmahaBlocklistState(extension_id, state, extension_prefs);
  159. if (is_on_sb_list || is_on_omaha_list) {
  160. AddAcknowledgedBlocklistState(extension_id, state, extension_prefs);
  161. } else {
  162. RemoveAcknowledgedBlocklistState(extension_id, state, extension_prefs);
  163. }
  164. }
  165. }
  166. void SetSafeBrowsingExtensionBlocklistState(
  167. const std::string& extension_id,
  168. BitMapBlocklistState bitmap_blocklist_state,
  169. ExtensionPrefs* extension_prefs) {
  170. if (bitmap_blocklist_state == BitMapBlocklistState::NOT_BLOCKLISTED) {
  171. extension_prefs->UpdateExtensionPref(extension_id, kPrefBlocklistState,
  172. nullptr);
  173. extension_prefs->DeleteExtensionPrefsIfPrefEmpty(extension_id);
  174. } else {
  175. extension_prefs->UpdateExtensionPref(
  176. extension_id, kPrefBlocklistState,
  177. std::make_unique<base::Value>(
  178. BitMapBlocklistStateToBlocklistState(bitmap_blocklist_state)));
  179. }
  180. }
  181. BitMapBlocklistState GetSafeBrowsingExtensionBlocklistState(
  182. const std::string& extension_id,
  183. ExtensionPrefs* extension_prefs) {
  184. int int_value = -1;
  185. if (extension_prefs->ReadPrefAsInteger(extension_id, kPrefBlocklistState,
  186. &int_value) &&
  187. int_value >= 0) {
  188. return BlocklistStateToBitMapBlocklistState(
  189. static_cast<BlocklistState>(int_value));
  190. }
  191. return BitMapBlocklistState::NOT_BLOCKLISTED;
  192. }
  193. } // namespace blocklist_prefs
  194. } // namespace extensions