1 // Copyright (c) 2012 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 5 #include "base/bind.h" 6 #include "base/bind_helpers.h" 7 #include "base/message_loop/message_loop.h" 8 #include "base/run_loop.h" 9 #include "chrome/browser/managed_mode/managed_mode_url_filter.h" 10 #include "testing/gtest/include/gtest/gtest.h" 11 #include "url/gurl.h" 12 13 class ManagedModeURLFilterTest : public ::testing::Test, 14 public ManagedModeURLFilter::Observer { 15 public: 16 ManagedModeURLFilterTest() : filter_(new ManagedModeURLFilter) { 17 filter_->SetDefaultFilteringBehavior(ManagedModeURLFilter::BLOCK); 18 filter_->AddObserver(this); 19 } 20 21 virtual ~ManagedModeURLFilterTest() { 22 filter_->RemoveObserver(this); 23 } 24 25 // ManagedModeURLFilter::Observer: 26 virtual void OnSiteListUpdated() OVERRIDE { 27 run_loop_.Quit(); 28 } 29 30 protected: 31 bool IsURLWhitelisted(const std::string& url) { 32 return filter_->GetFilteringBehaviorForURL(GURL(url)) == 33 ManagedModeURLFilter::ALLOW; 34 } 35 36 base::MessageLoop message_loop_; 37 base::RunLoop run_loop_; 38 scoped_refptr<ManagedModeURLFilter> filter_; 39 }; 40 41 // Disable all tests if ENABLE_CONFIGURATION_POLICY is not defined 42 // Since IsURLWhitelisted() doesn't work. 43 #if defined(ENABLE_CONFIGURATION_POLICY) 44 45 TEST_F(ManagedModeURLFilterTest, Basic) { 46 std::vector<std::string> list; 47 // Allow domain and all subdomains, for any filtered scheme. 48 list.push_back("google.com"); 49 filter_->SetFromPatterns(list); 50 run_loop_.Run(); 51 52 EXPECT_TRUE(IsURLWhitelisted("http://google.com")); 53 EXPECT_TRUE(IsURLWhitelisted("http://google.com/")); 54 EXPECT_TRUE(IsURLWhitelisted("http://google.com/whatever")); 55 EXPECT_TRUE(IsURLWhitelisted("https://google.com/")); 56 EXPECT_FALSE(IsURLWhitelisted("http://notgoogle.com/")); 57 EXPECT_TRUE(IsURLWhitelisted("http://mail.google.com")); 58 EXPECT_TRUE(IsURLWhitelisted("http://x.mail.google.com")); 59 EXPECT_TRUE(IsURLWhitelisted("https://x.mail.google.com/")); 60 EXPECT_TRUE(IsURLWhitelisted("http://x.y.google.com/a/b")); 61 EXPECT_FALSE(IsURLWhitelisted("http://youtube.com/")); 62 EXPECT_TRUE(IsURLWhitelisted("bogus://youtube.com/")); 63 EXPECT_TRUE(IsURLWhitelisted("chrome://youtube.com/")); 64 } 65 66 TEST_F(ManagedModeURLFilterTest, Inactive) { 67 filter_->SetDefaultFilteringBehavior(ManagedModeURLFilter::ALLOW); 68 69 std::vector<std::string> list; 70 list.push_back("google.com"); 71 filter_->SetFromPatterns(list); 72 run_loop_.Run(); 73 74 // If the filter is inactive, every URL should be whitelisted. 75 EXPECT_TRUE(IsURLWhitelisted("http://google.com")); 76 EXPECT_TRUE(IsURLWhitelisted("https://www.example.com")); 77 } 78 79 TEST_F(ManagedModeURLFilterTest, Scheme) { 80 std::vector<std::string> list; 81 // Filter only http, ftp and ws schemes. 82 list.push_back("http://secure.com"); 83 list.push_back("ftp://secure.com"); 84 list.push_back("ws://secure.com"); 85 filter_->SetFromPatterns(list); 86 run_loop_.Run(); 87 88 EXPECT_TRUE(IsURLWhitelisted("http://secure.com")); 89 EXPECT_TRUE(IsURLWhitelisted("http://secure.com/whatever")); 90 EXPECT_TRUE(IsURLWhitelisted("ftp://secure.com/")); 91 EXPECT_TRUE(IsURLWhitelisted("ws://secure.com")); 92 EXPECT_FALSE(IsURLWhitelisted("https://secure.com/")); 93 EXPECT_FALSE(IsURLWhitelisted("wss://secure.com")); 94 EXPECT_TRUE(IsURLWhitelisted("http://www.secure.com")); 95 EXPECT_FALSE(IsURLWhitelisted("https://www.secure.com")); 96 EXPECT_FALSE(IsURLWhitelisted("wss://www.secure.com")); 97 } 98 99 TEST_F(ManagedModeURLFilterTest, Path) { 100 std::vector<std::string> list; 101 // Filter only a certain path prefix. 102 list.push_back("path.to/ruin"); 103 filter_->SetFromPatterns(list); 104 run_loop_.Run(); 105 106 EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruin")); 107 EXPECT_TRUE(IsURLWhitelisted("https://path.to/ruin")); 108 EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruins")); 109 EXPECT_TRUE(IsURLWhitelisted("http://path.to/ruin/signup")); 110 EXPECT_TRUE(IsURLWhitelisted("http://www.path.to/ruin")); 111 EXPECT_FALSE(IsURLWhitelisted("http://path.to/fortune")); 112 } 113 114 TEST_F(ManagedModeURLFilterTest, PathAndScheme) { 115 std::vector<std::string> list; 116 // Filter only a certain path prefix and scheme. 117 list.push_back("https://s.aaa.com/path"); 118 filter_->SetFromPatterns(list); 119 run_loop_.Run(); 120 121 EXPECT_TRUE(IsURLWhitelisted("https://s.aaa.com/path")); 122 EXPECT_TRUE(IsURLWhitelisted("https://s.aaa.com/path/bbb")); 123 EXPECT_FALSE(IsURLWhitelisted("http://s.aaa.com/path")); 124 EXPECT_FALSE(IsURLWhitelisted("https://aaa.com/path")); 125 EXPECT_FALSE(IsURLWhitelisted("https://x.aaa.com/path")); 126 EXPECT_FALSE(IsURLWhitelisted("https://s.aaa.com/bbb")); 127 EXPECT_FALSE(IsURLWhitelisted("https://s.aaa.com/")); 128 } 129 130 TEST_F(ManagedModeURLFilterTest, Host) { 131 std::vector<std::string> list; 132 // Filter only a certain hostname, without subdomains. 133 list.push_back(".www.example.com"); 134 filter_->SetFromPatterns(list); 135 run_loop_.Run(); 136 137 EXPECT_TRUE(IsURLWhitelisted("http://www.example.com")); 138 EXPECT_FALSE(IsURLWhitelisted("http://example.com")); 139 EXPECT_FALSE(IsURLWhitelisted("http://subdomain.example.com")); 140 } 141 142 TEST_F(ManagedModeURLFilterTest, IPAddress) { 143 std::vector<std::string> list; 144 // Filter an ip address. 145 list.push_back("123.123.123.123"); 146 filter_->SetFromPatterns(list); 147 run_loop_.Run(); 148 149 EXPECT_TRUE(IsURLWhitelisted("http://123.123.123.123/")); 150 EXPECT_FALSE(IsURLWhitelisted("http://123.123.123.124/")); 151 } 152 153 TEST_F(ManagedModeURLFilterTest, Canonicalization) { 154 // We assume that the hosts and URLs are already canonicalized. 155 std::map<std::string, bool> hosts; 156 hosts["www.moose.org"] = true; 157 hosts["www.xn--n3h.net"] = true; 158 std::map<GURL, bool> urls; 159 urls[GURL("http://www.example.com/foo/")] = true; 160 urls[GURL("http://www.example.com/%C3%85t%C3%B8mstr%C3%B6m")] = true; 161 filter_->SetManualHosts(&hosts); 162 filter_->SetManualURLs(&urls); 163 164 // Base cases. 165 EXPECT_TRUE(IsURLWhitelisted("http://www.example.com/foo/")); 166 EXPECT_TRUE(IsURLWhitelisted( 167 "http://www.example.com/%C3%85t%C3%B8mstr%C3%B6m")); 168 169 // Verify that non-URI characters are escaped. 170 EXPECT_TRUE(IsURLWhitelisted( 171 "http://www.example.com/\xc3\x85t\xc3\xb8mstr\xc3\xb6m")); 172 173 // Verify that unnecessary URI escapes are unescaped. 174 EXPECT_TRUE(IsURLWhitelisted("http://www.example.com/%66%6F%6F/")); 175 176 // Verify that the default port are removed. 177 EXPECT_TRUE(IsURLWhitelisted("http://www.example.com:80/foo/")); 178 179 // Verify that scheme and hostname are lowercased. 180 EXPECT_TRUE(IsURLWhitelisted("htTp://wWw.eXamPle.com/foo/")); 181 EXPECT_TRUE(IsURLWhitelisted("HttP://WwW.mOOsE.orG/blurp/")); 182 183 // Verify that UTF-8 in hostnames are converted to punycode. 184 EXPECT_TRUE(IsURLWhitelisted("http://www.\xe2\x98\x83\x0a.net/bla/")); 185 186 // Verify that query and ref are stripped. 187 EXPECT_TRUE(IsURLWhitelisted("http://www.example.com/foo/?bar=baz#ref")); 188 } 189 190 TEST_F(ManagedModeURLFilterTest, HasStandardScheme) { 191 EXPECT_TRUE( 192 ManagedModeURLFilter::HasStandardScheme(GURL("http://example.com"))); 193 EXPECT_TRUE( 194 ManagedModeURLFilter::HasStandardScheme(GURL("https://example.com"))); 195 EXPECT_TRUE( 196 ManagedModeURLFilter::HasStandardScheme(GURL("ftp://example.com"))); 197 EXPECT_TRUE( 198 ManagedModeURLFilter::HasStandardScheme(GURL("gopher://example.com"))); 199 EXPECT_TRUE( 200 ManagedModeURLFilter::HasStandardScheme(GURL("ws://example.com"))); 201 EXPECT_TRUE( 202 ManagedModeURLFilter::HasStandardScheme(GURL("wss://example.com"))); 203 EXPECT_FALSE( 204 ManagedModeURLFilter::HasStandardScheme(GURL("wtf://example.com"))); 205 } 206 207 #endif // ENABLE_CONFIGURATION_POLICY 208
