blob: a66261532827df9392b2d336151807f0c95a711b [file] [log] [blame]
/*
* Copyright (C) 2014-2017 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "ContentExtensionsBackend.h"
#if ENABLE(CONTENT_EXTENSIONS)
#include "Chrome.h"
#include "ChromeClient.h"
#include "CompiledContentExtension.h"
#include "ContentExtension.h"
#include "ContentExtensionsDebugging.h"
#include "DFABytecodeInterpreter.h"
#include "Document.h"
#include "DocumentLoader.h"
#include "ExtensionStyleSheets.h"
#include "Frame.h"
#include "FrameLoaderClient.h"
#include "Page.h"
#include "ResourceLoadInfo.h"
#include "URL.h"
#include "UserContentController.h"
#include <wtf/NeverDestroyed.h>
#include <wtf/text/CString.h>
namespace WebCore {
namespace ContentExtensions {
void ContentExtensionsBackend::addContentExtension(const String& identifier, Ref<CompiledContentExtension> compiledContentExtension, ContentExtension::ShouldCompileCSS shouldCompileCSS)
{
ASSERT(!identifier.isEmpty());
if (identifier.isEmpty())
return;
auto contentExtension = ContentExtension::create(identifier, WTFMove(compiledContentExtension), shouldCompileCSS);
m_contentExtensions.set(identifier, WTFMove(contentExtension));
}
void ContentExtensionsBackend::removeContentExtension(const String& identifier)
{
m_contentExtensions.remove(identifier);
}
void ContentExtensionsBackend::removeAllContentExtensions()
{
m_contentExtensions.clear();
}
std::pair<Vector<Action>, Vector<String>> ContentExtensionsBackend::actionsForResourceLoad(const ResourceLoadInfo& resourceLoadInfo) const
{
#if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
MonotonicTime addedTimeStart = MonotonicTime::now();
#endif
if (m_contentExtensions.isEmpty()
|| !resourceLoadInfo.resourceURL.isValid()
|| resourceLoadInfo.resourceURL.protocolIsData())
return { };
const String& urlString = resourceLoadInfo.resourceURL.string();
ASSERT_WITH_MESSAGE(urlString.isAllASCII(), "A decoded URL should only contain ASCII characters. The matching algorithm assumes the input is ASCII.");
const auto urlCString = urlString.utf8();
Vector<Action> finalActions;
Vector<String> stylesheetIdentifiers;
ResourceFlags flags = resourceLoadInfo.getResourceFlags();
for (auto& contentExtension : m_contentExtensions.values()) {
const CompiledContentExtension& compiledExtension = contentExtension->compiledExtension();
DFABytecodeInterpreter withoutConditionsInterpreter(compiledExtension.filtersWithoutConditionsBytecode(), compiledExtension.filtersWithoutConditionsBytecodeLength());
DFABytecodeInterpreter::Actions withoutConditionsActions = withoutConditionsInterpreter.interpret(urlCString, flags);
URL topURL = resourceLoadInfo.mainDocumentURL;
DFABytecodeInterpreter withConditionsInterpreter(compiledExtension.filtersWithConditionsBytecode(), compiledExtension.filtersWithConditionsBytecodeLength());
DFABytecodeInterpreter::Actions withConditionsActions = withConditionsInterpreter.interpretWithConditions(urlCString, flags, contentExtension->topURLActions(topURL));
const SerializedActionByte* actions = compiledExtension.actions();
const unsigned actionsLength = compiledExtension.actionsLength();
bool sawIgnorePreviousRules = false;
const Vector<uint32_t>& universalWithConditions = contentExtension->universalActionsWithConditions(topURL);
const Vector<uint32_t>& universalWithoutConditions = contentExtension->universalActionsWithoutConditions();
if (!withoutConditionsActions.isEmpty() || !withConditionsActions.isEmpty() || !universalWithConditions.isEmpty() || !universalWithoutConditions.isEmpty()) {
Vector<uint32_t> actionLocations;
actionLocations.reserveInitialCapacity(withoutConditionsActions.size() + withConditionsActions.size() + universalWithoutConditions.size() + universalWithConditions.size());
for (uint64_t actionLocation : withoutConditionsActions)
actionLocations.uncheckedAppend(static_cast<uint32_t>(actionLocation));
for (uint64_t actionLocation : withConditionsActions)
actionLocations.uncheckedAppend(static_cast<uint32_t>(actionLocation));
for (uint32_t actionLocation : universalWithoutConditions)
actionLocations.uncheckedAppend(actionLocation);
for (uint32_t actionLocation : universalWithConditions)
actionLocations.uncheckedAppend(actionLocation);
std::sort(actionLocations.begin(), actionLocations.end());
// Add actions in reverse order to properly deal with IgnorePreviousRules.
for (unsigned i = actionLocations.size(); i; i--) {
Action action = Action::deserialize(actions, actionsLength, actionLocations[i - 1]);
action.setExtensionIdentifier(contentExtension->identifier());
if (action.type() == ActionType::IgnorePreviousRules) {
sawIgnorePreviousRules = true;
break;
}
finalActions.append(action);
}
}
if (!sawIgnorePreviousRules)
stylesheetIdentifiers.append(contentExtension->identifier());
}
#if CONTENT_EXTENSIONS_PERFORMANCE_REPORTING
MonotonicTime addedTimeEnd = MonotonicTime::now();
dataLogF("Time added: %f microseconds %s \n", (addedTimeEnd - addedTimeStart).microseconds(), resourceLoadInfo.resourceURL.string().utf8().data());
#endif
return { WTFMove(finalActions), WTFMove(stylesheetIdentifiers) };
}
void ContentExtensionsBackend::forEach(const WTF::Function<void(const String&, ContentExtension&)>& apply)
{
for (auto& pair : m_contentExtensions)
apply(pair.key, pair.value);
}
StyleSheetContents* ContentExtensionsBackend::globalDisplayNoneStyleSheet(const String& identifier) const
{
const auto& contentExtension = m_contentExtensions.get(identifier);
return contentExtension ? contentExtension->globalDisplayNoneStyleSheet() : nullptr;
}
BlockedStatus ContentExtensionsBackend::processContentExtensionRulesForLoad(const URL& url, ResourceType resourceType, DocumentLoader& initiatingDocumentLoader)
{
if (m_contentExtensions.isEmpty())
return { };
Document* currentDocument = nullptr;
URL mainDocumentURL;
if (Frame* frame = initiatingDocumentLoader.frame()) {
currentDocument = frame->document();
if (initiatingDocumentLoader.isLoadingMainResource()
&& frame->isMainFrame()
&& resourceType == ResourceType::Document)
mainDocumentURL = url;
else if (Document* mainDocument = frame->mainFrame().document())
mainDocumentURL = mainDocument->url();
}
ResourceLoadInfo resourceLoadInfo = { url, mainDocumentURL, resourceType };
auto actions = actionsForResourceLoad(resourceLoadInfo);
bool willBlockLoad = false;
bool willBlockCookies = false;
bool willMakeHTTPS = false;
HashSet<std::pair<String, String>> notifications;
for (const auto& action : actions.first) {
switch (action.type()) {
case ContentExtensions::ActionType::BlockLoad:
willBlockLoad = true;
break;
case ContentExtensions::ActionType::BlockCookies:
willBlockCookies = true;
break;
case ContentExtensions::ActionType::CSSDisplayNoneSelector:
if (resourceType == ResourceType::Document)
initiatingDocumentLoader.addPendingContentExtensionDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID());
else if (currentDocument)
currentDocument->extensionStyleSheets().addDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID());
break;
case ContentExtensions::ActionType::Notify:
notifications.add(std::make_pair(action.extensionIdentifier(), action.stringArgument()));
break;
case ContentExtensions::ActionType::MakeHTTPS: {
if ((url.protocolIs("http") || url.protocolIs("ws"))
&& (!url.port() || isDefaultPortForProtocol(url.port().value(), url.protocol())))
willMakeHTTPS = true;
break;
}
case ContentExtensions::ActionType::IgnorePreviousRules:
RELEASE_ASSERT_NOT_REACHED();
}
}
for (const auto& identifier : actions.second) {
if (auto* styleSheetContents = globalDisplayNoneStyleSheet(identifier)) {
if (resourceType == ResourceType::Document)
initiatingDocumentLoader.addPendingContentExtensionSheet(identifier, *styleSheetContents);
else if (currentDocument)
currentDocument->extensionStyleSheets().maybeAddContentExtensionSheet(identifier, *styleSheetContents);
}
}
if (currentDocument) {
if (willMakeHTTPS) {
ASSERT(url.protocolIs("http") || url.protocolIs("ws"));
String newProtocol = url.protocolIs("http") ? ASCIILiteral("https") : ASCIILiteral("wss");
currentDocument->addConsoleMessage(MessageSource::ContentBlocker, MessageLevel::Info, makeString("Content blocker promoted URL from ", url.string(), " to ", newProtocol));
}
if (willBlockLoad)
currentDocument->addConsoleMessage(MessageSource::ContentBlocker, MessageLevel::Info, makeString("Content blocker prevented frame displaying ", mainDocumentURL.string(), " from loading a resource from ", url.string()));
}
return { willBlockLoad, willBlockCookies, willMakeHTTPS, WTFMove(notifications) };
}
BlockedStatus ContentExtensionsBackend::processContentExtensionRulesForPingLoad(const URL& url, const URL& mainDocumentURL)
{
if (m_contentExtensions.isEmpty())
return { };
ResourceLoadInfo resourceLoadInfo = { url, mainDocumentURL, ResourceType::Raw };
auto actions = actionsForResourceLoad(resourceLoadInfo);
bool willBlockLoad = false;
bool willBlockCookies = false;
bool willMakeHTTPS = false;
for (const auto& action : actions.first) {
switch (action.type()) {
case ContentExtensions::ActionType::BlockLoad:
willBlockLoad = true;
break;
case ContentExtensions::ActionType::BlockCookies:
willBlockCookies = true;
break;
case ContentExtensions::ActionType::MakeHTTPS:
if ((url.protocolIs("http") || url.protocolIs("ws")) && (!url.port() || isDefaultPortForProtocol(url.port().value(), url.protocol())))
willMakeHTTPS = true;
break;
case ContentExtensions::ActionType::CSSDisplayNoneSelector:
case ContentExtensions::ActionType::Notify:
break;
case ContentExtensions::ActionType::IgnorePreviousRules:
RELEASE_ASSERT_NOT_REACHED();
}
}
return { willBlockLoad, willBlockCookies, willMakeHTTPS, { } };
}
const String& ContentExtensionsBackend::displayNoneCSSRule()
{
static NeverDestroyed<const String> rule(MAKE_STATIC_STRING_IMPL("display:none !important;"));
return rule;
}
void applyBlockedStatusToRequest(const BlockedStatus& status, Page* page, ResourceRequest& request)
{
if (page && !status.notifications.isEmpty())
page->chrome().client().contentRuleListNotification(request.url(), status.notifications);
if (status.blockedCookies)
request.setAllowCookies(false);
if (status.madeHTTPS) {
const URL& originalURL = request.url();
ASSERT(originalURL.protocolIs("http"));
ASSERT(!originalURL.port() || isDefaultPortForProtocol(originalURL.port().value(), originalURL.protocol()));
URL newURL = originalURL;
newURL.setProtocol("https");
if (originalURL.port())
newURL.setPort(defaultPortForProtocol("https").value());
request.setURL(newURL);
}
}
} // namespace ContentExtensions
} // namespace WebCore
#endif // ENABLE(CONTENT_EXTENSIONS)