OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/common/feature_policy/feature_policy.h" | 5 #include "content/common/feature_policy/feature_policy.h" |
6 | 6 |
| 7 #include "base/macros.h" |
| 8 #include "base/memory/ptr_util.h" |
| 9 #include "base/stl_util.h" |
| 10 |
7 namespace content { | 11 namespace content { |
8 | 12 |
| 13 namespace { |
| 14 |
| 15 // Given a string name, return the matching feature struct, or nullptr if it is |
| 16 // not the name of a policy-controlled feature. |
| 17 blink::WebFeaturePolicyFeature FeatureForName( |
| 18 std::string feature_name, |
| 19 const FeaturePolicy::FeatureList& features) { |
| 20 for (const auto& feature_mapping : features) { |
| 21 if (feature_name == feature_mapping.second->feature_name) |
| 22 return feature_mapping.first; |
| 23 } |
| 24 return blink::WebFeaturePolicyFeature::NotFound; |
| 25 } |
| 26 |
| 27 // Definitions of all features controlled by Feature Policy should appear here. |
| 28 const FeaturePolicy::Feature kDocumentCookie{ |
| 29 "cookie", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 30 const FeaturePolicy::Feature kDocumentDomain{ |
| 31 "domain", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 32 const FeaturePolicy::Feature kDocumentWrite{ |
| 33 "docwrite", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 34 const FeaturePolicy::Feature kFullscreenFeature{ |
| 35 "fullscreen", FeaturePolicy::FeatureDefault::EnableForSelf}; |
| 36 const FeaturePolicy::Feature kGeolocationFeature{ |
| 37 "geolocation", FeaturePolicy::FeatureDefault::EnableForSelf}; |
| 38 const FeaturePolicy::Feature kMidiFeature{ |
| 39 "midi", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 40 const FeaturePolicy::Feature kNotificationsFeature{ |
| 41 "notifications", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 42 const FeaturePolicy::Feature kPaymentFeature{ |
| 43 "payment", FeaturePolicy::FeatureDefault::EnableForSelf}; |
| 44 const FeaturePolicy::Feature kPushFeature{ |
| 45 "push", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 46 const FeaturePolicy::Feature kSyncScript{ |
| 47 "sync-script", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 48 const FeaturePolicy::Feature kSyncXHR{ |
| 49 "sync-xhr", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 50 const FeaturePolicy::Feature kUsermedia{ |
| 51 "usermedia", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 52 const FeaturePolicy::Feature kVibrateFeature{ |
| 53 "vibrate", FeaturePolicy::FeatureDefault::EnableForSelf}; |
| 54 const FeaturePolicy::Feature kWebRTC{ |
| 55 "webrtc", FeaturePolicy::FeatureDefault::EnableForAll}; |
| 56 |
| 57 // Extracts a Whitelist from a ParsedFeaturePolicyDeclaration. |
| 58 std::unique_ptr<FeaturePolicy::Whitelist> WhitelistFromDeclaration( |
| 59 const ParsedFeaturePolicyDeclaration& parsed_declaration) { |
| 60 std::unique_ptr<FeaturePolicy::Whitelist> result = |
| 61 base::WrapUnique(new FeaturePolicy::Whitelist()); |
| 62 if (parsed_declaration.matches_all_origins) |
| 63 result->AddAll(); |
| 64 for (const auto& origin : parsed_declaration.origins) |
| 65 result->Add(origin); |
| 66 return result; |
| 67 } |
| 68 |
| 69 } // namespace |
| 70 |
9 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration() | 71 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration() |
10 : matches_all_origins(false) {} | 72 : matches_all_origins(false) {} |
11 | 73 |
12 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration( | 74 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration( |
13 std::string feature_name, | 75 std::string feature_name, |
14 bool matches_all_origins, | 76 bool matches_all_origins, |
15 std::vector<url::Origin> origins) | 77 std::vector<url::Origin> origins) |
16 : feature_name(feature_name), | 78 : feature_name(feature_name), |
17 matches_all_origins(matches_all_origins), | 79 matches_all_origins(matches_all_origins), |
18 origins(origins) {} | 80 origins(origins) {} |
19 | 81 |
20 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration( | 82 ParsedFeaturePolicyDeclaration::ParsedFeaturePolicyDeclaration( |
21 const ParsedFeaturePolicyDeclaration& rhs) = default; | 83 const ParsedFeaturePolicyDeclaration& rhs) = default; |
22 | 84 |
23 ParsedFeaturePolicyDeclaration::~ParsedFeaturePolicyDeclaration() {} | 85 ParsedFeaturePolicyDeclaration::~ParsedFeaturePolicyDeclaration() {} |
24 | 86 |
| 87 FeaturePolicy::Whitelist::Whitelist() : matches_all_origins_(false) {} |
| 88 |
| 89 FeaturePolicy::Whitelist::~Whitelist() = default; |
| 90 |
| 91 void FeaturePolicy::Whitelist::Add(const url::Origin& origin) { |
| 92 origins_.push_back(origin); |
| 93 } |
| 94 |
| 95 void FeaturePolicy::Whitelist::AddAll() { |
| 96 matches_all_origins_ = true; |
| 97 } |
| 98 |
| 99 bool FeaturePolicy::Whitelist::Contains(const url::Origin& origin) const { |
| 100 if (matches_all_origins_) |
| 101 return true; |
| 102 for (const auto& targetOrigin : origins_) { |
| 103 if (targetOrigin.IsSameOriginWith(origin)) |
| 104 return true; |
| 105 } |
| 106 return false; |
| 107 } |
| 108 |
| 109 // static |
| 110 std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromParentPolicy( |
| 111 const FeaturePolicy* parent_policy, |
| 112 const url::Origin& origin) { |
| 113 return CreateFromParentPolicy(parent_policy, origin, getDefaultFeatureList()); |
| 114 } |
| 115 |
| 116 bool FeaturePolicy::IsFeatureEnabledForOrigin( |
| 117 blink::WebFeaturePolicyFeature feature, |
| 118 const url::Origin& origin) const { |
| 119 DCHECK(base::ContainsKey(feature_list_, feature)); |
| 120 const FeaturePolicy::Feature* feature_definition = feature_list_.at(feature); |
| 121 DCHECK(base::ContainsKey(inherited_policies_, feature)); |
| 122 if (!inherited_policies_.at(feature)) { |
| 123 return false; |
| 124 } |
| 125 auto whitelist = whitelists_.find(feature); |
| 126 if (whitelist != whitelists_.end()) { |
| 127 return whitelist->second->Contains(origin); |
| 128 } |
| 129 if (feature_definition->default_policy == |
| 130 FeaturePolicy::FeatureDefault::EnableForAll) { |
| 131 return true; |
| 132 } |
| 133 if (feature_definition->default_policy == |
| 134 FeaturePolicy::FeatureDefault::EnableForSelf) { |
| 135 return origin_.IsSameOriginWith(origin); |
| 136 } |
| 137 return false; |
| 138 } |
| 139 |
| 140 bool FeaturePolicy::IsFeatureEnabled( |
| 141 blink::WebFeaturePolicyFeature feature) const { |
| 142 return IsFeatureEnabledForOrigin(feature, origin_); |
| 143 } |
| 144 |
| 145 void FeaturePolicy::SetHeaderPolicy( |
| 146 const ParsedFeaturePolicyHeader& parsed_header) { |
| 147 DCHECK(whitelists_.empty()); |
| 148 for (const ParsedFeaturePolicyDeclaration& parsed_declaration : |
| 149 parsed_header) { |
| 150 blink::WebFeaturePolicyFeature feature = |
| 151 FeatureForName(parsed_declaration.feature_name, feature_list_); |
| 152 if (feature == blink::WebFeaturePolicyFeature::NotFound) |
| 153 continue; |
| 154 whitelists_[feature] = WhitelistFromDeclaration(parsed_declaration); |
| 155 } |
| 156 } |
| 157 |
| 158 FeaturePolicy::FeaturePolicy(url::Origin origin, |
| 159 const FeatureList& feature_list) |
| 160 : origin_(origin), feature_list_(feature_list) {} |
| 161 |
| 162 FeaturePolicy::FeaturePolicy(url::Origin origin) |
| 163 : origin_(origin), feature_list_(getDefaultFeatureList()) {} |
| 164 |
| 165 FeaturePolicy::~FeaturePolicy() {} |
| 166 |
| 167 // static |
| 168 std::unique_ptr<FeaturePolicy> FeaturePolicy::CreateFromParentPolicy( |
| 169 const FeaturePolicy* parent_policy, |
| 170 const url::Origin& origin, |
| 171 const FeaturePolicy::FeatureList& features) { |
| 172 std::unique_ptr<FeaturePolicy> newPolicy = |
| 173 base::WrapUnique(new FeaturePolicy(origin, features)); |
| 174 for (const auto& feature : features) { |
| 175 if (!parent_policy || |
| 176 parent_policy->IsFeatureEnabledForOrigin(feature.first, origin)) { |
| 177 newPolicy->inherited_policies_[feature.first] = true; |
| 178 } else { |
| 179 newPolicy->inherited_policies_[feature.first] = false; |
| 180 } |
| 181 } |
| 182 return newPolicy; |
| 183 } |
| 184 |
| 185 // static |
| 186 const FeaturePolicy::FeatureList& FeaturePolicy::getDefaultFeatureList() { |
| 187 CR_DEFINE_STATIC_LOCAL( |
| 188 FeatureList, defaultFeatureList, |
| 189 ({{blink::WebFeaturePolicyFeature::DocumentCookie, &kDocumentCookie}, |
| 190 {blink::WebFeaturePolicyFeature::DocumentDomain, &kDocumentDomain}, |
| 191 {blink::WebFeaturePolicyFeature::DocumentWrite, &kDocumentWrite}, |
| 192 {blink::WebFeaturePolicyFeature::Fullscreen, &kFullscreenFeature}, |
| 193 {blink::WebFeaturePolicyFeature::Geolocation, &kGeolocationFeature}, |
| 194 {blink::WebFeaturePolicyFeature::MidiFeature, &kMidiFeature}, |
| 195 {blink::WebFeaturePolicyFeature::Notifications, &kNotificationsFeature}, |
| 196 {blink::WebFeaturePolicyFeature::Payment, &kPaymentFeature}, |
| 197 {blink::WebFeaturePolicyFeature::Push, &kPushFeature}, |
| 198 {blink::WebFeaturePolicyFeature::SyncScript, &kSyncScript}, |
| 199 {blink::WebFeaturePolicyFeature::SyncXHR, &kSyncXHR}, |
| 200 {blink::WebFeaturePolicyFeature::Usermedia, &kUsermedia}, |
| 201 {blink::WebFeaturePolicyFeature::Vibrate, &kVibrateFeature}, |
| 202 {blink::WebFeaturePolicyFeature::WebRTC, &kWebRTC}})); |
| 203 return defaultFeatureList; |
| 204 } |
| 205 |
25 } // namespace content | 206 } // namespace content |
OLD | NEW |