| /* |
| * Copyright (C) 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. |
| */ |
| |
| #import "config.h" |
| |
| #import "HTTPServer.h" |
| #import "PlatformUtilities.h" |
| #import "Test.h" |
| #import "TestNavigationDelegate.h" |
| #import "TestUIDelegate.h" |
| #import "TestURLSchemeHandler.h" |
| #import <WebKit/WKContentRuleList.h> |
| #import <WebKit/WKContentRuleListStorePrivate.h> |
| #import <WebKit/WKFoundation.h> |
| #import <WebKit/WKHTTPCookieStorePrivate.h> |
| #import <WebKit/WKUserContentControllerPrivate.h> |
| #import <WebKit/WKWebpagePreferencesPrivate.h> |
| #import <WebKit/WKWebsiteDataStorePrivate.h> |
| #import <WebKit/_WKContentRuleListAction.h> |
| #import <WebKit/_WKUserContentExtensionStore.h> |
| #import <WebKit/_WKUserContentFilter.h> |
| #import <WebKit/_WKWebsiteDataStoreConfiguration.h> |
| #import <wtf/RetainPtr.h> |
| #import <wtf/Vector.h> |
| #import <wtf/text/WTFString.h> |
| |
| class WKContentRuleListStoreTest : public testing::Test { |
| public: |
| virtual void SetUp() |
| { |
| [[WKContentRuleListStore defaultStore] _removeAllContentRuleLists]; |
| } |
| }; |
| |
| static NSString *basicFilter = @"[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*webkit.org\"}}]"; |
| |
| TEST_F(WKContentRuleListStoreTest, Compile) |
| { |
| __block bool doneCompiling = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| } |
| |
| static NSString *invalidFilter = @"["; |
| |
| static void checkDomain(NSError *error) |
| { |
| EXPECT_STREQ([[error domain] UTF8String], [WKErrorDomain UTF8String]); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, InvalidRuleList) |
| { |
| __block bool doneCompiling = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestRuleList" encodedContentRuleList:invalidFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_NULL(filter); |
| EXPECT_NOT_NULL(error); |
| checkDomain(error); |
| EXPECT_EQ(error.code, WKErrorContentRuleListStoreCompileFailed); |
| EXPECT_STREQ("Rule list compilation failed: Failed to parse the JSON String.", [[error helpAnchor] UTF8String]); |
| |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, Lookup) |
| { |
| __block bool doneCompiling = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| __block bool doneLookingUp = false; |
| [[WKContentRuleListStore defaultStore] lookUpContentRuleListForIdentifier:@"TestRuleList" completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_STREQ(filter.identifier.UTF8String, "TestRuleList"); |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, EncodedIdentifier) |
| { |
| // FIXME: U+00C4 causes problems here. Using the output of encodeForFileName with |
| // the filesystem changes it to U+0041 followed by U+0308 |
| NSString *identifier = @":;%25%+25И😍"; |
| __block bool done = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:identifier encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_STREQ(filter.identifier.UTF8String, identifier.UTF8String); |
| |
| [[WKContentRuleListStore defaultStore] getAvailableContentRuleListIdentifiers:^(NSArray<NSString *> *identifiers) { |
| EXPECT_EQ(identifiers.count, 1u); |
| EXPECT_EQ(identifiers[0].length, identifier.length); |
| EXPECT_STREQ(identifiers[0].UTF8String, identifier.UTF8String); |
| |
| done = true; |
| }]; |
| }]; |
| TestWebKitAPI::Util::run(&done); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, NonExistingIdentifierLookup) |
| { |
| __block bool doneLookingUp = false; |
| [[WKContentRuleListStore defaultStore] lookUpContentRuleListForIdentifier:@"DoesNotExist" completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_NULL(filter); |
| EXPECT_NOT_NULL(error); |
| checkDomain(error); |
| EXPECT_EQ(error.code, WKErrorContentRuleListStoreLookUpFailed); |
| EXPECT_STREQ("Rule list lookup failed: Unspecified error during lookup.", [[error helpAnchor] UTF8String]); |
| |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, VersionMismatch) |
| { |
| __block bool doneCompiling = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) |
| { |
| |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| [[WKContentRuleListStore defaultStore] _invalidateContentRuleListVersionForIdentifier:@"TestRuleList"]; |
| |
| __block bool doneLookingUp = false; |
| [[WKContentRuleListStore defaultStore] lookUpContentRuleListForIdentifier:@"TestRuleList" completionHandler:^(WKContentRuleList *filter, NSError *error) |
| { |
| |
| EXPECT_NULL(filter); |
| EXPECT_NOT_NULL(error); |
| checkDomain(error); |
| EXPECT_EQ(error.code, WKErrorContentRuleListStoreVersionMismatch); |
| EXPECT_STREQ("Rule list lookup failed: Version of file does not match version of interpreter.", [[error helpAnchor] UTF8String]); |
| |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| |
| __block bool doneGettingSource = false; |
| [[WKContentRuleListStore defaultStore] _getContentRuleListSourceForIdentifier:@"TestRuleList" completionHandler:^(NSString* source) { |
| EXPECT_NULL(source); |
| doneGettingSource = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneGettingSource); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, Removal) |
| { |
| __block bool doneCompiling = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| __block bool doneRemoving = false; |
| [[WKContentRuleListStore defaultStore] removeContentRuleListForIdentifier:@"TestRuleList" completionHandler:^(NSError *error) { |
| EXPECT_NULL(error); |
| |
| doneRemoving = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneRemoving); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, CrossOriginCookieBlocking) |
| { |
| using namespace TestWebKitAPI; |
| |
| auto cookiePresentWhenBlocking = [] (bool blockCookies) { |
| |
| std::optional<bool> requestHadCookieResult; |
| |
| HTTPServer server(HTTPServer::UseCoroutines::Yes, [&] (Connection connection) -> Task { |
| while (true) { |
| auto request = co_await connection.awaitableReceiveHTTPRequest(); |
| auto path = HTTPServer::parsePath(request); |
| auto response = [&] { |
| if (path == "/com"_s) { |
| #if CPU(ARM64E) && defined(NDEBUG) |
| // FIXME: This is exactly equivalent code, but the code below crashes on release builds on arm64e. |
| // See rdar://95391568 |
| HashMap<String, String> headerFields; |
| headerFields.reserveInitialCapacity(1); |
| headerFields.add("Set-Cookie"_s, "testCookie=42; Path=/; SameSite=None; Secure"_s); |
| return HTTPResponse(WTFMove(headerFields), "<script>alert('hi')</script>"_s); |
| #else |
| return HTTPResponse({ { "Set-Cookie"_s, "testCookie=42; Path=/; SameSite=None; Secure"_s } }, "<script>alert('hi')</script>"_s); |
| #endif |
| } |
| if (path == "/org"_s) |
| return HTTPResponse("<script>fetch('https://example.com/cookie-check', {credentials: 'include'})</script>"_s); |
| if (path == "/cookie-check"_s) { |
| auto cookieHeader = "Cookie: testCookie=42"; |
| requestHadCookieResult = memmem(request.data(), request.size(), cookieHeader, strlen(cookieHeader)); |
| return HTTPResponse("hi"_s); |
| } |
| RELEASE_ASSERT_NOT_REACHED(); |
| }(); |
| co_await connection.awaitableSend(response.serialize()); |
| } |
| }, HTTPServer::Protocol::HttpsProxy); |
| |
| auto storeConfiguration = adoptNS([[_WKWebsiteDataStoreConfiguration alloc] initNonPersistentConfiguration]); |
| [storeConfiguration setAllowsServerPreconnect:NO]; |
| [storeConfiguration setProxyConfiguration:@{ |
| (NSString *)kCFStreamPropertyHTTPSProxyHost: @"127.0.0.1", |
| (NSString *)kCFStreamPropertyHTTPSProxyPort: @(server.port()) |
| }]; |
| |
| auto dataStore = adoptNS([[WKWebsiteDataStore alloc] _initWithConfiguration:storeConfiguration.get()]); |
| [dataStore _setResourceLoadStatisticsEnabled:NO]; |
| __block bool setPolicy { false }; |
| [dataStore.get().httpCookieStore _setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways completionHandler:^{ |
| setPolicy = true; |
| }]; |
| Util::run(&setPolicy); |
| |
| auto viewConfiguration = adoptNS([WKWebViewConfiguration new]); |
| [viewConfiguration setWebsiteDataStore:dataStore.get()]; |
| |
| if (blockCookies) { |
| __block bool doneCompiling { false }; |
| NSString *json = @"[{\"action\":{\"type\":\"block-cookies\"},\"trigger\":{\"url-filter\":\"cookie-check\"}}]"; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestBlockCookies" encodedContentRuleList:json completionHandler:^(WKContentRuleList *compiledRuleList, NSError *error) { |
| EXPECT_FALSE(error); |
| [[viewConfiguration userContentController] addContentRuleList:compiledRuleList]; |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| } |
| |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectZero configuration:viewConfiguration.get()]); |
| auto delegate = adoptNS([TestNavigationDelegate new]); |
| delegate.get().didReceiveAuthenticationChallenge = ^(WKWebView *, NSURLAuthenticationChallenge *challenge, void (^completionHandler)(NSURLSessionAuthChallengeDisposition, NSURLCredential *)) { |
| completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]); |
| }; |
| webView.get().navigationDelegate = delegate.get(); |
| |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"https://example.com/com"]]]; |
| [delegate waitForDidFinishNavigation]; |
| |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"https://example.org/org"]]]; |
| while (!requestHadCookieResult) |
| Util::spinRunLoop(); |
| return *requestHadCookieResult; |
| }; |
| |
| EXPECT_FALSE(cookiePresentWhenBlocking(true)); |
| EXPECT_TRUE(cookiePresentWhenBlocking(false)); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, NonExistingIdentifierRemove) |
| { |
| __block bool doneRemoving = false; |
| [[WKContentRuleListStore defaultStore] removeContentRuleListForIdentifier:@"DoesNotExist" completionHandler:^(NSError *error) { |
| EXPECT_NOT_NULL(error); |
| checkDomain(error); |
| EXPECT_EQ(error.code, WKErrorContentRuleListStoreRemoveFailed); |
| EXPECT_STREQ("Rule list removal failed: Unspecified error during remove.", [[error helpAnchor] UTF8String]); |
| |
| doneRemoving = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneRemoving); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, NonDefaultStore) |
| { |
| NSURL *tempDir = [NSURL fileURLWithPath:[NSTemporaryDirectory() stringByAppendingPathComponent:@"ContentRuleListTest"] isDirectory:YES]; |
| WKContentRuleListStore *store = [WKContentRuleListStore storeWithURL:tempDir]; |
| NSString *identifier = @"TestRuleList"; |
| NSString *fileName = @"ContentRuleList-TestRuleList"; |
| |
| __block bool doneGettingAvailableIdentifiers = false; |
| [store getAvailableContentRuleListIdentifiers:^(NSArray<NSString *> *identifiers) { |
| EXPECT_NOT_NULL(identifiers); |
| EXPECT_EQ(identifiers.count, 0u); |
| doneGettingAvailableIdentifiers = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneGettingAvailableIdentifiers); |
| |
| __block bool doneCompiling = false; |
| [store compileContentRuleListForIdentifier:identifier encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| doneGettingAvailableIdentifiers = false; |
| [store getAvailableContentRuleListIdentifiers:^(NSArray<NSString *> *identifiers) { |
| EXPECT_NOT_NULL(identifiers); |
| EXPECT_EQ(identifiers.count, 1u); |
| EXPECT_STREQ(identifiers[0].UTF8String, "TestRuleList"); |
| doneGettingAvailableIdentifiers = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneGettingAvailableIdentifiers); |
| |
| NSData *data = [NSData dataWithContentsOfURL:[tempDir URLByAppendingPathComponent:fileName]]; |
| EXPECT_NOT_NULL(data); |
| EXPECT_EQ(data.length, 241u); |
| |
| __block bool doneCheckingSource = false; |
| [store _getContentRuleListSourceForIdentifier:identifier completionHandler:^(NSString *source) { |
| EXPECT_NOT_NULL(source); |
| EXPECT_STREQ(basicFilter.UTF8String, source.UTF8String); |
| doneCheckingSource = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCheckingSource); |
| |
| __block bool doneRemoving = false; |
| [store removeContentRuleListForIdentifier:identifier completionHandler:^(NSError *error) { |
| EXPECT_NULL(error); |
| doneRemoving = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneRemoving); |
| |
| NSData *dataAfterRemoving = [NSData dataWithContentsOfURL:[tempDir URLByAppendingPathComponent:fileName]]; |
| EXPECT_NULL(dataAfterRemoving); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, MultipleRuleLists) |
| { |
| __block bool done = false; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"FirstRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"SecondRuleList" encodedContentRuleList:basicFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| [[WKContentRuleListStore defaultStore] getAvailableContentRuleListIdentifiers:^(NSArray<NSString *> *identifiers) { |
| EXPECT_NOT_NULL(identifiers); |
| EXPECT_EQ(identifiers.count, 2u); |
| EXPECT_STREQ(identifiers[0].UTF8String, "FirstRuleList"); |
| EXPECT_STREQ(identifiers[1].UTF8String, "SecondRuleList"); |
| done = true; |
| }]; |
| }]; |
| }]; |
| TestWebKitAPI::Util::run(&done); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, NonASCIISource) |
| { |
| static NSString *nonASCIIFilter = @"[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\".*webkit.org\"}, \"unused\":\"💩\"}]"; |
| NSURL *tempDir = [NSURL fileURLWithPath:[NSTemporaryDirectory() stringByAppendingPathComponent:@"ContentRuleListTest"] isDirectory:YES]; |
| WKContentRuleListStore *store = [WKContentRuleListStore storeWithURL:tempDir]; |
| NSString *identifier = @"TestRuleList"; |
| NSString *fileName = @"ContentRuleList-TestRuleList"; |
| |
| __block bool done = false; |
| [store compileContentRuleListForIdentifier:identifier encodedContentRuleList:nonASCIIFilter completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| |
| [store _getContentRuleListSourceForIdentifier:identifier completionHandler:^(NSString *source) { |
| EXPECT_NOT_NULL(source); |
| EXPECT_STREQ(nonASCIIFilter.UTF8String, source.UTF8String); |
| |
| [store _removeAllContentRuleLists]; |
| NSData *dataAfterRemoving = [NSData dataWithContentsOfURL:[tempDir URLByAppendingPathComponent:fileName]]; |
| EXPECT_NULL(dataAfterRemoving); |
| |
| done = true; |
| }]; |
| }]; |
| TestWebKitAPI::Util::run(&done); |
| } |
| |
| static size_t alertCount { 0 }; |
| static bool receivedAlert { false }; |
| |
| @interface ContentRuleListDelegate : NSObject <WKUIDelegate> |
| @end |
| |
| @implementation ContentRuleListDelegate |
| |
| - (void)webView:(WKWebView *)webView runJavaScriptAlertPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(void))completionHandler |
| { |
| switch (alertCount++) { |
| case 0: |
| // Default behavior. |
| EXPECT_STREQ("content blockers enabled", message.UTF8String); |
| break; |
| case 1: |
| // After having removed the content RuleList. |
| EXPECT_STREQ("content blockers disabled", message.UTF8String); |
| break; |
| default: |
| EXPECT_TRUE(false); |
| } |
| receivedAlert = true; |
| completionHandler(); |
| } |
| |
| @end |
| |
| TEST_F(WKContentRuleListStoreTest, AddRemove) |
| { |
| [[WKContentRuleListStore defaultStore] _removeAllContentRuleLists]; |
| |
| __block bool doneCompiling = false; |
| NSString* contentBlocker = @"[{\"action\":{\"type\":\"css-display-none\",\"selector\":\".hidden\"},\"trigger\":{\"url-filter\":\".*\"}}]"; |
| __block RetainPtr<WKContentRuleList> ruleList; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"TestAddRemove" encodedContentRuleList:contentBlocker completionHandler:^(WKContentRuleList *compiledRuleList, NSError *error) { |
| EXPECT_TRUE(error == nil); |
| ruleList = compiledRuleList; |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| EXPECT_NOT_NULL(ruleList); |
| |
| auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]); |
| [[configuration userContentController] addContentRuleList:ruleList.get()]; |
| |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]); |
| |
| auto delegate = adoptNS([[ContentRuleListDelegate alloc] init]); |
| [webView setUIDelegate:delegate.get()]; |
| |
| NSURLRequest *request = [NSURLRequest requestWithURL:[[NSBundle mainBundle] URLForResource:@"contentBlockerCheck" withExtension:@"html" subdirectory:@"TestWebKitAPI.resources"]]; |
| alertCount = 0; |
| receivedAlert = false; |
| [webView loadRequest:request]; |
| TestWebKitAPI::Util::run(&receivedAlert); |
| |
| [[configuration userContentController] removeContentRuleList:ruleList.get()]; |
| |
| receivedAlert = false; |
| [webView reload]; |
| TestWebKitAPI::Util::run(&receivedAlert); |
| } |
| |
| #if PLATFORM(IOS_FAMILY) |
| TEST_F(WKContentRuleListStoreTest, UnsafeMMap) |
| { |
| RetainPtr<NSString> tempDir = [NSTemporaryDirectory() stringByAppendingPathComponent:@"UnsafeMMapTest"]; |
| RetainPtr<WKContentRuleListStore> store = [WKContentRuleListStore storeWithURL:[NSURL fileURLWithPath:tempDir.get() isDirectory:YES]]; |
| static NSString *compiledIdentifier = @"CompiledRuleList"; |
| static NSString *copiedIdentifier = @"CopiedRuleList"; |
| static NSString *ruleListSourceString = @"[{\"action\":{\"type\":\"block\"},\"trigger\":{\"url-filter\":\"blockedsubresource\"}}]"; |
| RetainPtr<NSString> compiledFilePath = [tempDir stringByAppendingPathComponent:@"ContentRuleList-CompiledRuleList"]; |
| RetainPtr<NSString> copiedFilePath = [tempDir stringByAppendingPathComponent:@"ContentRuleList-CopiedRuleList"]; |
| |
| __block bool doneCompiling = false; |
| [store compileContentRuleListForIdentifier:compiledIdentifier encodedContentRuleList:ruleListSourceString completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| auto hasCompleteProtection = [] (const RetainPtr<NSString>& path) { |
| NSError *error = nil; |
| NSDictionary<NSFileAttributeKey, id> *attributes = [[NSFileManager defaultManager] attributesOfItemAtPath:path.get() error:&error]; |
| EXPECT_NULL(error); |
| return [[attributes objectForKey:NSFileProtectionKey] isEqualToString:NSFileProtectionComplete]; |
| }; |
| |
| NSError *error = nil; |
| [[NSFileManager defaultManager] copyItemAtPath:compiledFilePath.get() toPath:copiedFilePath.get() error:&error]; |
| EXPECT_NULL(error); |
| EXPECT_FALSE(hasCompleteProtection(copiedFilePath)); |
| [[NSFileManager defaultManager] setAttributes:@{ NSFileProtectionKey: NSFileProtectionComplete } ofItemAtPath:copiedFilePath.get() error:&error]; |
| EXPECT_NULL(error); |
| #if !PLATFORM(IOS_FAMILY_SIMULATOR) |
| EXPECT_TRUE(hasCompleteProtection(copiedFilePath)); |
| #endif |
| |
| __block bool doneLookingUp = false; |
| [store lookUpContentRuleListForIdentifier:copiedIdentifier completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NOT_NULL(filter); |
| EXPECT_NULL(error); |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| EXPECT_FALSE(hasCompleteProtection(copiedFilePath)); |
| |
| __block bool doneRemoving = false; |
| [store removeContentRuleListForIdentifier:compiledIdentifier completionHandler:^(NSError *error) { |
| EXPECT_NULL(error); |
| [store removeContentRuleListForIdentifier:copiedIdentifier completionHandler:^(NSError *error) { |
| EXPECT_NULL(error); |
| doneRemoving = true; |
| }]; |
| }]; |
| TestWebKitAPI::Util::run(&doneRemoving); |
| } |
| #endif // PLATFORM(IOS_FAMILY) |
| |
| TEST_F(WKContentRuleListStoreTest, _WKUserContentExtensionStoreSelectors) |
| { |
| [[WKContentRuleListStore defaultStore] _removeAllContentRuleLists]; |
| NSString *identifier = @"TestOldSPIMixup"; |
| |
| __block bool doneCompiling = false; |
| [(_WKUserContentExtensionStore *)[WKContentRuleListStore defaultStore] compileContentExtensionForIdentifier:identifier encodedContentExtension:basicFilter completionHandler:^(_WKUserContentFilter *filter, NSError *error) { |
| EXPECT_NULL(error); |
| EXPECT_NOT_NULL(filter); |
| doneCompiling = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneCompiling); |
| |
| __block bool doneLookingUp = false; |
| [(_WKUserContentExtensionStore *)[WKContentRuleListStore defaultStore] lookupContentExtensionForIdentifier:identifier completionHandler:^(_WKUserContentFilter *filter, NSError *error) { |
| EXPECT_NULL(error); |
| EXPECT_NOT_NULL(filter); |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| |
| __block bool domeRemoving = false; |
| [(_WKUserContentExtensionStore *)[WKContentRuleListStore defaultStore] removeContentExtensionForIdentifier:identifier completionHandler:^(NSError *error) { |
| EXPECT_NULL(error); |
| domeRemoving = true; |
| }]; |
| TestWebKitAPI::Util::run(&domeRemoving); |
| |
| doneLookingUp = false; |
| [(_WKUserContentExtensionStore *)[WKContentRuleListStore defaultStore] lookupContentExtensionForIdentifier:identifier completionHandler:^(_WKUserContentFilter *filter, NSError *error) { |
| EXPECT_WK_STREQ(error.domain, WKErrorDomain); |
| EXPECT_EQ(error.code, WKErrorContentRuleListStoreLookUpFailed); |
| EXPECT_NULL(filter); |
| doneLookingUp = true; |
| }]; |
| TestWebKitAPI::Util::run(&doneLookingUp); |
| } |
| |
| static RetainPtr<WKContentRuleList> compileContentRuleList(const char* json, NSString *identifier = @"testidentifier") |
| { |
| [[WKContentRuleListStore defaultStore] _removeAllContentRuleLists]; |
| |
| __block RetainPtr<WKContentRuleList> list; |
| [[WKContentRuleListStore defaultStore] compileContentRuleListForIdentifier:@"testidentifier" encodedContentRuleList:[NSString stringWithFormat:@"%s", json] completionHandler:^(WKContentRuleList *filter, NSError *error) { |
| EXPECT_NULL(error); |
| list = filter; |
| }]; |
| while (!list) |
| TestWebKitAPI::Util::spinRunLoop(); |
| |
| return list; |
| } |
| |
| static RetainPtr<TestNavigationDelegate> navigationDelegateAllowingActiveActionsOnTestHost() |
| { |
| static auto delegate = adoptNS([TestNavigationDelegate new]); |
| delegate.get().decidePolicyForNavigationActionWithPreferences = ^(WKNavigationAction *, WKWebpagePreferences *preferences, void (^decisionHandler)(WKNavigationActionPolicy, WKWebpagePreferences *)) { |
| preferences._activeContentRuleListActionPatterns = [NSDictionary dictionaryWithObject:[NSSet setWithObject:@"*://testhost/*"] forKey:@"testidentifier"]; |
| decisionHandler(WKNavigationActionPolicyAllow, preferences); |
| }; |
| return delegate; |
| } |
| |
| static void checkURLs(const Vector<String>& actual, const Vector<String>& expected) |
| { |
| EXPECT_EQ(actual.size(), expected.size()); |
| for (size_t i = 0; i < std::min(actual.size(), expected.size()); i++) |
| EXPECT_WK_STREQ(actual[i], expected[i]); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, ModifyHeaders) |
| { |
| auto list = compileContentRuleList(R"JSON( |
| [ { |
| "action": { "type": "modify-headers", "request-headers": [ { |
| "operation": "set", |
| "header": "testkey", |
| "value": "testvalue" |
| } ] }, |
| "trigger": { "url-filter": "testscheme" } |
| }, { |
| "action": { "type": "modify-headers", "request-headers": [ { |
| "operation": "remove", |
| "header": "Accept" |
| } ] }, |
| "trigger": { "url-filter": "testscheme" } |
| }, { |
| "action": { "type": "modify-headers", "request-headers": [ { |
| "operation": "append", |
| "header": "Content-Type", |
| "value": "Modified-by-test" |
| } ] }, |
| "trigger": { "url-filter": "testscheme" } |
| } ] |
| )JSON"); |
| |
| __block bool receivedAllRequests { false }; |
| auto handler = adoptNS([TestURLSchemeHandler new]); |
| handler.get().startURLSchemeTaskHandler = ^(WKWebView *, id <WKURLSchemeTask> task) { |
| NSString *path = task.request.URL.path; |
| NSDictionary<NSString *, NSString *> *fields = [task.request allHTTPHeaderFields]; |
| if ([path isEqualToString:@"/main.html"]) { |
| EXPECT_WK_STREQ(fields[@"Content-Type"], "Modified-by-test"); |
| EXPECT_WK_STREQ(fields[@"testkey"], "testvalue"); |
| EXPECT_NULL(fields[@"Accept"]); |
| return respond(task, "<iframe src='//otherhost/frame.html'></iframe>"); |
| } |
| if ([path isEqualToString:@"/frame.html"]) { |
| EXPECT_NULL(fields[@"Content-Type"]); |
| EXPECT_NULL(fields[@"testkey"]); |
| EXPECT_NOT_NULL(fields[@"Accept"]); |
| return respond(task, "<script>fetch('//testhost/fetch.txt',{headers: {'Content-Type': 'application/json'}})</script>"); |
| } |
| if ([path isEqualToString:@"/fetch.txt"]) { |
| EXPECT_WK_STREQ(fields[@"Content-Type"], "application/json; Modified-by-test"); |
| EXPECT_WK_STREQ(fields[@"testkey"], "testvalue"); |
| EXPECT_NULL(fields[@"Accept"]); |
| receivedAllRequests = true; |
| return respond(task, ""); |
| } |
| ASSERT_NOT_REACHED(); |
| }; |
| |
| auto configuration = adoptNS([WKWebViewConfiguration new]); |
| [[configuration userContentController] addContentRuleList:list.get()]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"testscheme"]; |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSZeroRect configuration:configuration.get()]); |
| auto delegate = navigationDelegateAllowingActiveActionsOnTestHost().get(); |
| webView.get().navigationDelegate = delegate; |
| __block bool receivedActionNotification { false }; |
| __block Vector<String> urls; |
| delegate.contentRuleListPerformedAction = ^(WKWebView *, NSString *identifier, _WKContentRuleListAction *action, NSURL *url) { |
| urls.append(url.absoluteString); |
| EXPECT_TRUE(action.modifiedHeaders); |
| receivedActionNotification = true; |
| }; |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"testscheme://testhost/main.html"]]]; |
| TestWebKitAPI::Util::run(&receivedAllRequests); |
| TestWebKitAPI::Util::run(&receivedActionNotification); |
| checkURLs(urls, { |
| "testscheme://testhost/main.html"_s, |
| "testscheme://testhost/fetch.txt"_s |
| }); |
| |
| // FIXME: Appending to the User-Agent replaces the user agent because we haven't added the user agent yet when processing the request. |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, Redirect) |
| { |
| auto list = compileContentRuleList(R"JSON( |
| [ { |
| "action": { "type": "redirect", "redirect": { |
| "url": "othertestscheme://not-testhost/1-redirected.txt" |
| } }, |
| "trigger": { "url-filter": "1.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "port": "123", |
| "ignored-comment": "123 is a forbidden port, so this URL is not seen by the WKURLSchemeHandler." |
| } } }, |
| "trigger": { "url-filter": "2.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "host": "newhost", |
| "username": "newusername", |
| "port": "443" |
| } } }, |
| "trigger": { "url-filter": "3.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "port": "", |
| "scheme": "othertestscheme", |
| "query": "?key=value" |
| } } }, |
| "trigger": { "url-filter": "4.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "password": "testpassword", |
| "query": "", |
| "fragment": "#fragment-to-be-added" |
| } } }, |
| "trigger": { "url-filter": "5.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "password": "testpassword", |
| "fragment": "" |
| } } }, |
| "trigger": { "url-filter": "6.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "query": "?", |
| "fragment": "#" |
| } } }, |
| "trigger": { "url-filter": "7.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "transform": { |
| "query-transform": { |
| "remove-parameters": [ "parameter-to-remove" ], |
| "add-or-replace-parameters": [ |
| { "key": "key-to-add", "value": "value-to-add" }, |
| { "key": "key-to-replace-only", "value": "value-to-replace-only", "replace-only": true }, |
| { "key": "key-to-replace-only-but-not-found", "value": "value-to-replace-only-but-not-found", "replace-only": true } |
| ] |
| } |
| } } }, |
| "trigger": { "url-filter": "8.txt" } |
| }, { |
| "action": { "type": "redirect", "redirect": { "regex-substitution": "testscheme://replaced-by-regex/\\1.txt" } }, |
| "trigger": { "url-filter": "(9).txt" } |
| } ] |
| )JSON"); |
| |
| __block bool receivedAllRequests { false }; |
| __block auto urls = adoptNS([NSMutableArray new]); |
| auto handler = adoptNS([TestURLSchemeHandler new]); |
| handler.get().startURLSchemeTaskHandler = ^(WKWebView *, id <WKURLSchemeTask> task) { |
| NSURL *url = task.request.URL; |
| [urls addObject:url]; |
| NSString *path = url.path; |
| if ([path isEqualToString:@"/main.html"]) { |
| return respond(task, R"HTML( |
| <script> |
| async function fetchSubresources() |
| { |
| try { await fetch('1.txt') } catch(e) { }; |
| try { await fetch('//not-testhost-should-not-trigger-action/2.txt', {mode:'no-cors'}) } catch(e) { }; |
| try { await fetch('//testhost/2.txt') } catch(e) { }; |
| try { await fetch('/3.txt?query-should-not-be-removed') } catch(e) { }; |
| try { await fetch('//testhost:80/4.txt#fragment-should-not-be-removed') } catch(e) { }; |
| try { await fetch('5.txt?query-should-be-removed') } catch(e) { }; |
| try { await fetch('6.txt#fragment-should-be-removed') } catch(e) { }; |
| try { await fetch('7.txt') } catch(e) { }; |
| try { await fetch('8.txt?key-to-replace-only=pre-replacement-value') } catch(e) { }; |
| try { await fetch('9.txt') } catch(e) { }; |
| } |
| fetchSubresources(); |
| </script> |
| )HTML"); |
| } |
| if ([path isEqualToString:@"/9.txt"]) |
| receivedAllRequests = true; |
| respond(task, ""); |
| }; |
| |
| auto configuration = adoptNS([WKWebViewConfiguration new]); |
| [[configuration userContentController] addContentRuleList:list.get()]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"testscheme"]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"othertestscheme"]; |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSZeroRect configuration:configuration.get()]); |
| auto delegate = navigationDelegateAllowingActiveActionsOnTestHost().get(); |
| webView.get().navigationDelegate = delegate; |
| __block bool receivedActionNotification { false }; |
| __block Vector<String> urlsFromCallback; |
| delegate.contentRuleListPerformedAction = ^(WKWebView *, NSString *identifier, _WKContentRuleListAction *action, NSURL *url) { |
| urlsFromCallback.append(url.absoluteString); |
| EXPECT_TRUE(action.redirected); |
| receivedActionNotification = true; |
| }; |
| |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"testscheme://testhost/main.html"]]]; |
| TestWebKitAPI::Util::run(&receivedAllRequests); |
| TestWebKitAPI::Util::run(&receivedActionNotification); |
| |
| Vector<String> expectedRequestedURLs { |
| "testscheme://testhost/main.html"_s, |
| "othertestscheme://not-testhost/1-redirected.txt"_s, |
| "testscheme://not-testhost-should-not-trigger-action/2.txt"_s, |
| "testscheme://newusername@newhost:443/3.txt?query-should-not-be-removed"_s, |
| "othertestscheme://testhost/4.txt?key=value#fragment-should-not-be-removed"_s, |
| "testscheme://:testpassword@testhost/5.txt#fragment-to-be-added"_s, |
| "testscheme://:testpassword@testhost/6.txt"_s, |
| "testscheme://testhost/7.txt?#"_s, |
| "testscheme://testhost/8.txt?key-to-replace-only=value-to-replace-only&key-to-add=value-to-add"_s, |
| "testscheme://replaced-by-regex/9.txt"_s, |
| }; |
| EXPECT_EQ(expectedRequestedURLs.size(), [urls count]); |
| for (size_t i = 0; i < expectedRequestedURLs.size(); i++) |
| EXPECT_WK_STREQ(expectedRequestedURLs[i], [[urls objectAtIndex:i] absoluteString]); |
| |
| expectedRequestedURLs.remove(0); |
| expectedRequestedURLs[1] = "testscheme://testhost:123/2.txt"_s; |
| checkURLs(urlsFromCallback, expectedRequestedURLs); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, NullPatternSet) |
| { |
| auto list = compileContentRuleList(R"JSON( |
| [ { |
| "action": { "type": "redirect", "redirect": { |
| "url": "testscheme://testhost/main-redirected.html" |
| } }, |
| "trigger": { "url-filter": "main.html" } |
| } ] |
| )JSON"); |
| |
| __block std::optional<bool> redirectedResult; |
| auto handler = adoptNS([TestURLSchemeHandler new]); |
| handler.get().startURLSchemeTaskHandler = ^(WKWebView *, id <WKURLSchemeTask> task) { |
| NSString *path = task.request.URL.path; |
| if ([path isEqualToString:@"/main.html"]) |
| redirectedResult = false; |
| else { |
| EXPECT_WK_STREQ(path, "/main-redirected.html"); |
| redirectedResult = true; |
| } |
| respond(task, ""); |
| }; |
| |
| __block enum class DelegateAction : uint8_t { |
| AllowAll, |
| AllowNone, |
| AllowTestHost, |
| } delegateAction; |
| auto delegate = adoptNS([TestNavigationDelegate new]); |
| delegate.get().decidePolicyForNavigationActionWithPreferences = ^(WKNavigationAction *, WKWebpagePreferences *preferences, void (^decisionHandler)(WKNavigationActionPolicy, WKWebpagePreferences *)) { |
| EXPECT_NOT_NULL(preferences._activeContentRuleListActionPatterns); |
| EXPECT_EQ(preferences._activeContentRuleListActionPatterns.count, 0u); |
| switch (delegateAction) { |
| case DelegateAction::AllowAll: |
| preferences._activeContentRuleListActionPatterns = [NSDictionary dictionaryWithObject:[NSSet setWithObject:@"*://*/*"] forKey:@"testidentifier"]; |
| break; |
| case DelegateAction::AllowNone: |
| preferences._activeContentRuleListActionPatterns = [NSDictionary dictionary]; |
| break; |
| case DelegateAction::AllowTestHost: |
| preferences._activeContentRuleListActionPatterns = [NSDictionary dictionaryWithObject:[NSSet setWithObject:@"*://testhost/*"] forKey:@"testidentifier"]; |
| break; |
| } |
| decisionHandler(WKNavigationActionPolicyAllow, preferences); |
| }; |
| |
| auto configuration = adoptNS([WKWebViewConfiguration new]); |
| [[configuration userContentController] addContentRuleList:list.get()]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"testscheme"]; |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSZeroRect configuration:configuration.get()]); |
| webView.get().navigationDelegate = delegate.get(); |
| |
| auto getRedirectResult = ^(DelegateAction action) { |
| delegateAction = action; |
| redirectedResult = std::nullopt; |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"testscheme://testhost/main.html"]]]; |
| while (!redirectedResult) |
| TestWebKitAPI::Util::spinRunLoop(); |
| return *redirectedResult; |
| }; |
| EXPECT_TRUE(getRedirectResult(DelegateAction::AllowAll)); |
| EXPECT_FALSE(getRedirectResult(DelegateAction::AllowNone)); |
| EXPECT_TRUE(getRedirectResult(DelegateAction::AllowTestHost)); |
| } |
| |
| TEST_F(WKContentRuleListStoreTest, ExtensionPath) |
| { |
| auto list = compileContentRuleList(R"JSON( |
| [ { |
| "action": { "type": "redirect", "redirect": { |
| "extension-path": "/redirected-to-extension?no-query#no-fragment" |
| } }, |
| "trigger": { "url-filter": "main.html" } |
| } ] |
| )JSON"); |
| |
| __block RetainPtr<NSURL> redirectedURL; |
| auto handler = adoptNS([TestURLSchemeHandler new]); |
| handler.get().startURLSchemeTaskHandler = ^(WKWebView *, id <WKURLSchemeTask> task) { |
| redirectedURL = task.request.URL; |
| respond(task, ""); |
| }; |
| |
| auto delegate = adoptNS([TestNavigationDelegate new]); |
| delegate.get().decidePolicyForNavigationActionWithPreferences = ^(WKNavigationAction *, WKWebpagePreferences *preferences, void (^decisionHandler)(WKNavigationActionPolicy, WKWebpagePreferences *)) { |
| preferences._activeContentRuleListActionPatterns = [NSDictionary dictionaryWithObject:[NSSet setWithObject:@"*://testhost/*"] forKey:@"testidentifier"]; |
| decisionHandler(WKNavigationActionPolicyAllow, preferences); |
| }; |
| |
| auto configuration = adoptNS([WKWebViewConfiguration new]); |
| [[configuration userContentController] _addContentRuleList:list.get() extensionBaseURL:[NSURL URLWithString:@"extension-scheme://extension-host/"]]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"testscheme"]; |
| [configuration setURLSchemeHandler:handler.get() forURLScheme:@"extension-scheme"]; |
| auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSZeroRect configuration:configuration.get()]); |
| webView.get().navigationDelegate = delegate.get(); |
| |
| [webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"testscheme://testhost/main.html"]]]; |
| while (!redirectedURL) |
| TestWebKitAPI::Util::spinRunLoop(); |
| EXPECT_WK_STREQ([redirectedURL absoluteString], "extension-scheme://extension-host/redirected-to-extension%3Fno-query%23no-fragment"); |
| } |
