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 // Unit tests for the SafeBrowsing storage system. 6 7 #include "chrome/browser/safe_browsing/safe_browsing_database.h" 8 9 #include "base/files/file_util.h" 10 #include "base/files/scoped_temp_dir.h" 11 #include "base/logging.h" 12 #include "base/memory/scoped_vector.h" 13 #include "base/message_loop/message_loop.h" 14 #include "base/sha1.h" 15 #include "base/strings/string_number_conversions.h" 16 #include "base/strings/string_split.h" 17 #include "base/time/time.h" 18 #include "chrome/browser/safe_browsing/chunk.pb.h" 19 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h" 20 #include "content/public/test/test_browser_thread_bundle.h" 21 #include "crypto/sha2.h" 22 #include "net/base/net_util.h" 23 #include "sql/connection.h" 24 #include "sql/statement.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 #include "testing/platform_test.h" 27 #include "url/gurl.h" 28 29 using base::Time; 30 using base::TimeDelta; 31 32 namespace { 33 34 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45); 35 36 SBPrefix SBPrefixForString(const std::string& str) { 37 return SBFullHashForString(str).prefix; 38 } 39 40 // Construct a full hash which has the given prefix, with the given 41 // suffix data coming after the prefix. 42 SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix, 43 const base::StringPiece& suffix) { 44 SBFullHash full_hash; 45 memset(&full_hash, 0, sizeof(SBFullHash)); 46 full_hash.prefix = prefix; 47 CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash)); 48 memcpy(full_hash.full_hash + sizeof(SBPrefix), suffix.data(), suffix.size()); 49 return full_hash; 50 } 51 52 std::string HashedIpPrefix(const std::string& ip_prefix, size_t prefix_size) { 53 net::IPAddressNumber ip_number; 54 EXPECT_TRUE(net::ParseIPLiteralToNumber(ip_prefix, &ip_number)); 55 EXPECT_EQ(net::kIPv6AddressSize, ip_number.size()); 56 const std::string hashed_ip_prefix = base::SHA1HashString( 57 net::IPAddressToPackedString(ip_number)); 58 std::string hash(crypto::kSHA256Length, '\0'); 59 hash.replace(0, hashed_ip_prefix.size(), hashed_ip_prefix); 60 hash[base::kSHA1Length] = static_cast<char>(prefix_size); 61 return hash; 62 } 63 64 // Helper to build a chunk. Caller takes ownership. 65 SBChunkData* BuildChunk(int chunk_number, 66 safe_browsing::ChunkData::ChunkType chunk_type, 67 safe_browsing::ChunkData::PrefixType prefix_type, 68 const void* data, size_t data_size, 69 const std::vector<int>& add_chunk_numbers) { 70 scoped_ptr<safe_browsing::ChunkData> raw_data(new safe_browsing::ChunkData); 71 raw_data->set_chunk_number(chunk_number); 72 raw_data->set_chunk_type(chunk_type); 73 raw_data->set_prefix_type(prefix_type); 74 raw_data->set_hashes(data, data_size); 75 raw_data->clear_add_numbers(); 76 for (size_t i = 0; i < add_chunk_numbers.size(); ++i) { 77 raw_data->add_add_numbers(add_chunk_numbers[i]); 78 } 79 80 return new SBChunkData(raw_data.release()); 81 } 82 83 // Create add chunk with a single prefix. 84 SBChunkData* AddChunkPrefix(int chunk_number, SBPrefix prefix) { 85 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 86 safe_browsing::ChunkData::PREFIX_4B, 87 &prefix, sizeof(prefix), 88 std::vector<int>()); 89 } 90 91 // Create add chunk with a single prefix generated from |value|. 92 SBChunkData* AddChunkPrefixValue(int chunk_number, 93 const std::string& value) { 94 return AddChunkPrefix(chunk_number, SBPrefixForString(value)); 95 } 96 97 // Generate an add chunk with two prefixes. 98 SBChunkData* AddChunkPrefix2Value(int chunk_number, 99 const std::string& value1, 100 const std::string& value2) { 101 const SBPrefix prefixes[2] = { 102 SBPrefixForString(value1), 103 SBPrefixForString(value2), 104 }; 105 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 106 safe_browsing::ChunkData::PREFIX_4B, 107 &prefixes[0], sizeof(prefixes), 108 std::vector<int>()); 109 } 110 111 // Generate an add chunk with four prefixes. 112 SBChunkData* AddChunkPrefix4Value(int chunk_number, 113 const std::string& value1, 114 const std::string& value2, 115 const std::string& value3, 116 const std::string& value4) { 117 const SBPrefix prefixes[4] = { 118 SBPrefixForString(value1), 119 SBPrefixForString(value2), 120 SBPrefixForString(value3), 121 SBPrefixForString(value4), 122 }; 123 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 124 safe_browsing::ChunkData::PREFIX_4B, 125 &prefixes[0], sizeof(prefixes), 126 std::vector<int>()); 127 } 128 129 // Generate an add chunk with a full hash. 130 SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) { 131 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 132 safe_browsing::ChunkData::FULL_32B, 133 &full_hash, sizeof(full_hash), 134 std::vector<int>()); 135 } 136 137 // Generate an add chunk with a full hash generated from |value|. 138 SBChunkData* AddChunkFullHashValue(int chunk_number, 139 const std::string& value) { 140 return AddChunkFullHash(chunk_number, SBFullHashForString(value)); 141 } 142 143 // Generate an add chunk with two full hashes. 144 SBChunkData* AddChunkFullHash2Value(int chunk_number, 145 const std::string& value1, 146 const std::string& value2) { 147 const SBFullHash full_hashes[2] = { 148 SBFullHashForString(value1), 149 SBFullHashForString(value2), 150 }; 151 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 152 safe_browsing::ChunkData::FULL_32B, 153 &full_hashes[0], sizeof(full_hashes), 154 std::vector<int>()); 155 } 156 157 // Generate a sub chunk with a prefix generated from |value|. 158 SBChunkData* SubChunkPrefixValue(int chunk_number, 159 const std::string& value, 160 int add_chunk_number) { 161 const SBPrefix prefix = SBPrefixForString(value); 162 return BuildChunk(chunk_number, safe_browsing::ChunkData::SUB, 163 safe_browsing::ChunkData::PREFIX_4B, 164 &prefix, sizeof(prefix), 165 std::vector<int>(1, add_chunk_number)); 166 } 167 168 // Generate a sub chunk with two prefixes. 169 SBChunkData* SubChunkPrefix2Value(int chunk_number, 170 const std::string& value1, 171 int add_chunk_number1, 172 const std::string& value2, 173 int add_chunk_number2) { 174 const SBPrefix prefixes[2] = { 175 SBPrefixForString(value1), 176 SBPrefixForString(value2), 177 }; 178 std::vector<int> add_chunk_numbers; 179 add_chunk_numbers.push_back(add_chunk_number1); 180 add_chunk_numbers.push_back(add_chunk_number2); 181 return BuildChunk(chunk_number, safe_browsing::ChunkData::SUB, 182 safe_browsing::ChunkData::PREFIX_4B, 183 &prefixes[0], sizeof(prefixes), 184 add_chunk_numbers); 185 } 186 187 // Generate a sub chunk with a full hash. 188 SBChunkData* SubChunkFullHash(int chunk_number, 189 SBFullHash full_hash, 190 int add_chunk_number) { 191 return BuildChunk(chunk_number, safe_browsing::ChunkData::SUB, 192 safe_browsing::ChunkData::FULL_32B, 193 &full_hash, sizeof(full_hash), 194 std::vector<int>(1, add_chunk_number)); 195 } 196 197 // Generate a sub chunk with a full hash generated from |value|. 198 SBChunkData* SubChunkFullHashValue(int chunk_number, 199 const std::string& value, 200 int add_chunk_number) { 201 return SubChunkFullHash(chunk_number, 202 SBFullHashForString(value), 203 add_chunk_number); 204 } 205 206 // Generate an add chunk with a single full hash for the ip blacklist. 207 SBChunkData* AddChunkHashedIpValue(int chunk_number, 208 const std::string& ip_str, 209 size_t prefix_size) { 210 const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size); 211 EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size()); 212 SBFullHash full_hash; 213 std::memcpy(&(full_hash.full_hash), full_hash_str.data(), sizeof(SBFullHash)); 214 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, 215 safe_browsing::ChunkData::FULL_32B, 216 &full_hash, sizeof(full_hash), 217 std::vector<int>()); 218 } 219 220 // Prevent DCHECK from killing tests. 221 // TODO(shess): Pawel disputes the use of this, so the test which uses 222 // it is DISABLED. http://crbug.com/56448 223 class ScopedLogMessageIgnorer { 224 public: 225 ScopedLogMessageIgnorer() { 226 logging::SetLogMessageHandler(&LogMessageIgnorer); 227 } 228 ~ScopedLogMessageIgnorer() { 229 // TODO(shess): Would be better to verify whether anyone else 230 // changed it, and then restore it to the previous value. 231 logging::SetLogMessageHandler(NULL); 232 } 233 234 private: 235 static bool LogMessageIgnorer(int severity, const char* file, int line, 236 size_t message_start, const std::string& str) { 237 // Intercept FATAL, strip the stack backtrace, and log it without 238 // the crash part. 239 if (severity == logging::LOG_FATAL) { 240 size_t newline = str.find('\n'); 241 if (newline != std::string::npos) { 242 const std::string msg = str.substr(0, newline + 1); 243 fprintf(stderr, "%s", msg.c_str()); 244 fflush(stderr); 245 } 246 return true; 247 } 248 249 return false; 250 } 251 }; 252 253 } // namespace 254 255 class SafeBrowsingDatabaseTest : public PlatformTest { 256 public: 257 virtual void SetUp() { 258 PlatformTest::SetUp(); 259 260 // Setup a database in a temporary directory. 261 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 262 database_.reset(new SafeBrowsingDatabaseNew); 263 database_filename_ = 264 temp_dir_.path().AppendASCII("SafeBrowsingTestDatabase"); 265 database_->Init(database_filename_); 266 } 267 268 virtual void TearDown() { 269 database_.reset(); 270 271 PlatformTest::TearDown(); 272 } 273 274 void GetListsInfo(std::vector<SBListChunkRanges>* lists) { 275 lists->clear(); 276 ASSERT_TRUE(database_->UpdateStarted(lists)); 277 database_->UpdateFinished(true); 278 } 279 280 // Helper function to do an AddDel or SubDel command. 281 void DelChunk(const std::string& list, 282 int chunk_id, 283 bool is_sub_del) { 284 std::vector<SBChunkDelete> deletes; 285 SBChunkDelete chunk_delete; 286 chunk_delete.list_name = list; 287 chunk_delete.is_sub_del = is_sub_del; 288 chunk_delete.chunk_del.push_back(ChunkRange(chunk_id)); 289 deletes.push_back(chunk_delete); 290 database_->DeleteChunks(deletes); 291 } 292 293 void AddDelChunk(const std::string& list, int chunk_id) { 294 DelChunk(list, chunk_id, false); 295 } 296 297 void SubDelChunk(const std::string& list, int chunk_id) { 298 DelChunk(list, chunk_id, true); 299 } 300 301 // Utility function for setting up the database for the caching test. 302 void PopulateDatabaseForCacheTest(); 303 304 scoped_ptr<SafeBrowsingDatabaseNew> database_; 305 base::FilePath database_filename_; 306 base::ScopedTempDir temp_dir_; 307 }; 308 309 // Tests retrieving list name information. 310 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowse) { 311 std::vector<SBListChunkRanges> lists; 312 ScopedVector<SBChunkData> chunks; 313 314 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 315 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 316 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html")); 317 318 ASSERT_TRUE(database_->UpdateStarted(&lists)); 319 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 320 database_->UpdateFinished(true); 321 322 GetListsInfo(&lists); 323 ASSERT_LE(1U, lists.size()); 324 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 325 EXPECT_EQ("1-3", lists[0].adds); 326 EXPECT_TRUE(lists[0].subs.empty()); 327 328 // Insert a malware sub chunk. 329 chunks.clear(); 330 chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19)); 331 332 ASSERT_TRUE(database_->UpdateStarted(&lists)); 333 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 334 database_->UpdateFinished(true); 335 336 GetListsInfo(&lists); 337 ASSERT_LE(1U, lists.size()); 338 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 339 EXPECT_EQ("1-3", lists[0].adds); 340 EXPECT_EQ("7", lists[0].subs); 341 if (lists.size() == 2) { 342 // Old style database won't have the second entry since it creates the lists 343 // when it receives an update containing that list. The filter-based 344 // database has these values hard coded. 345 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 346 EXPECT_TRUE(lists[1].adds.empty()); 347 EXPECT_TRUE(lists[1].subs.empty()); 348 } 349 350 // Add phishing chunks. 351 chunks.clear(); 352 chunks.push_back(AddChunkPrefixValue(47, "www.evil.com/phishing.html")); 353 chunks.push_back( 354 SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999)); 355 chunks.push_back( 356 SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999)); 357 358 ASSERT_TRUE(database_->UpdateStarted(&lists)); 359 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 360 database_->UpdateFinished(true); 361 362 GetListsInfo(&lists); 363 ASSERT_EQ(2U, lists.size()); 364 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 365 EXPECT_EQ("1-3", lists[0].adds); 366 EXPECT_EQ("7", lists[0].subs); 367 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 368 EXPECT_EQ("47", lists[1].adds); 369 EXPECT_EQ("200-201", lists[1].subs); 370 } 371 372 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) { 373 database_.reset(); 374 base::MessageLoop loop; 375 SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile(); 376 SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile(); 377 SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile(); 378 SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile(); 379 SafeBrowsingStoreFile* extension_blacklist_store = 380 new SafeBrowsingStoreFile(); 381 SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile(); 382 database_.reset(new SafeBrowsingDatabaseNew(browse_store, 383 download_store, 384 csd_whitelist_store, 385 download_whitelist_store, 386 extension_blacklist_store, 387 NULL, 388 ip_blacklist_store)); 389 database_->Init(database_filename_); 390 391 ScopedVector<SBChunkData> chunks; 392 393 std::vector<SBListChunkRanges> lists; 394 ASSERT_TRUE(database_->UpdateStarted(&lists)); 395 396 // Insert malware, phish, binurl and bindownload add chunks. 397 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 398 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 399 400 chunks.clear(); 401 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 402 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 403 404 chunks.clear(); 405 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html")); 406 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); 407 408 chunks.clear(); 409 chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html")); 410 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get()); 411 412 chunks.clear(); 413 chunks.push_back(AddChunkFullHashValue(6, "www.download.com/")); 414 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks.get()); 415 416 chunks.clear(); 417 chunks.push_back(AddChunkFullHashValue(8, 418 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 419 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 420 database_->InsertChunks(safe_browsing_util::kExtensionBlacklist, 421 chunks.get()); 422 423 chunks.clear(); 424 chunks.push_back(AddChunkHashedIpValue(9, "::ffff:192.168.1.0", 120)); 425 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); 426 427 database_->UpdateFinished(true); 428 429 GetListsInfo(&lists); 430 ASSERT_EQ(7U, lists.size()); 431 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 432 EXPECT_EQ("1", lists[0].adds); 433 EXPECT_TRUE(lists[0].subs.empty()); 434 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 435 EXPECT_EQ("2", lists[1].adds); 436 EXPECT_TRUE(lists[1].subs.empty()); 437 EXPECT_EQ(safe_browsing_util::kBinUrlList, lists[2].name); 438 EXPECT_EQ("3", lists[2].adds); 439 EXPECT_TRUE(lists[2].subs.empty()); 440 EXPECT_EQ(safe_browsing_util::kCsdWhiteList, lists[3].name); 441 EXPECT_EQ("5", lists[3].adds); 442 EXPECT_TRUE(lists[3].subs.empty()); 443 EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name); 444 EXPECT_EQ("6", lists[4].adds); 445 EXPECT_TRUE(lists[4].subs.empty()); 446 EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[5].name); 447 EXPECT_EQ("8", lists[5].adds); 448 EXPECT_TRUE(lists[5].subs.empty()); 449 EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[6].name); 450 EXPECT_EQ("9", lists[6].adds); 451 EXPECT_TRUE(lists[6].subs.empty()); 452 453 database_.reset(); 454 } 455 456 // Checks database reading and writing for browse. 457 TEST_F(SafeBrowsingDatabaseTest, BrowseDatabase) { 458 std::vector<SBListChunkRanges> lists; 459 ScopedVector<SBChunkData> chunks; 460 461 chunks.push_back(AddChunkPrefix2Value(1, 462 "www.evil.com/phishing.html", 463 "www.evil.com/malware.html")); 464 chunks.push_back(AddChunkPrefix4Value(2, 465 "www.evil.com/notevil1.html", 466 "www.evil.com/notevil2.html", 467 "www.good.com/good1.html", 468 "www.good.com/good2.html")); 469 chunks.push_back(AddChunkPrefixValue(3, "192.168.0.1/malware.html")); 470 chunks.push_back(AddChunkFullHashValue(7, "www.evil.com/evil.html")); 471 472 ASSERT_TRUE(database_->UpdateStarted(&lists)); 473 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 474 database_->UpdateFinished(true); 475 476 // Make sure they were added correctly. 477 GetListsInfo(&lists); 478 ASSERT_LE(1U, lists.size()); 479 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 480 EXPECT_EQ("1-3,7", lists[0].adds); 481 EXPECT_TRUE(lists[0].subs.empty()); 482 483 std::vector<SBPrefix> prefix_hits; 484 std::vector<SBFullHashResult> cache_hits; 485 EXPECT_TRUE(database_->ContainsBrowseUrl( 486 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 487 ASSERT_EQ(1U, prefix_hits.size()); 488 EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]); 489 EXPECT_TRUE(cache_hits.empty()); 490 491 EXPECT_TRUE(database_->ContainsBrowseUrl( 492 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 493 494 EXPECT_TRUE(database_->ContainsBrowseUrl( 495 GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits)); 496 497 EXPECT_TRUE(database_->ContainsBrowseUrl( 498 GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits)); 499 500 EXPECT_TRUE(database_->ContainsBrowseUrl( 501 GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits)); 502 503 EXPECT_TRUE(database_->ContainsBrowseUrl( 504 GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits)); 505 506 EXPECT_TRUE(database_->ContainsBrowseUrl( 507 GURL("http://192.168.0.1/malware.html"), &prefix_hits, &cache_hits)); 508 509 EXPECT_FALSE(database_->ContainsBrowseUrl( 510 GURL("http://www.evil.com/"), &prefix_hits, &cache_hits)); 511 EXPECT_TRUE(prefix_hits.empty()); 512 EXPECT_TRUE(cache_hits.empty()); 513 514 EXPECT_FALSE(database_->ContainsBrowseUrl( 515 GURL("http://www.evil.com/robots.txt"), &prefix_hits, &cache_hits)); 516 517 EXPECT_TRUE(database_->ContainsBrowseUrl( 518 GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits)); 519 ASSERT_EQ(1U, prefix_hits.size()); 520 EXPECT_EQ(SBPrefixForString("www.evil.com/evil.html"), prefix_hits[0]); 521 522 // Attempt to re-add the first chunk (should be a no-op). 523 // see bug: http://code.google.com/p/chromium/issues/detail?id=4522 524 chunks.clear(); 525 chunks.push_back(AddChunkPrefix2Value(1, 526 "www.evil.com/phishing.html", 527 "www.evil.com/malware.html")); 528 ASSERT_TRUE(database_->UpdateStarted(&lists)); 529 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 530 database_->UpdateFinished(true); 531 532 GetListsInfo(&lists); 533 ASSERT_LE(1U, lists.size()); 534 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 535 EXPECT_EQ("1-3,7", lists[0].adds); 536 EXPECT_TRUE(lists[0].subs.empty()); 537 538 // Test removing a single prefix from the add chunk. 539 chunks.clear(); 540 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/notevil1.html", 2)); 541 ASSERT_TRUE(database_->UpdateStarted(&lists)); 542 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 543 database_->UpdateFinished(true); 544 545 EXPECT_TRUE(database_->ContainsBrowseUrl( 546 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 547 ASSERT_EQ(1U, prefix_hits.size()); 548 EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]); 549 EXPECT_TRUE(cache_hits.empty()); 550 551 EXPECT_FALSE(database_->ContainsBrowseUrl( 552 GURL("http://www.evil.com/notevil1.html"), &prefix_hits, &cache_hits)); 553 EXPECT_TRUE(prefix_hits.empty()); 554 EXPECT_TRUE(cache_hits.empty()); 555 556 EXPECT_TRUE(database_->ContainsBrowseUrl( 557 GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits)); 558 559 EXPECT_TRUE(database_->ContainsBrowseUrl( 560 GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits)); 561 562 EXPECT_TRUE(database_->ContainsBrowseUrl( 563 GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits)); 564 565 GetListsInfo(&lists); 566 ASSERT_LE(1U, lists.size()); 567 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 568 EXPECT_EQ("1-3,7", lists[0].adds); 569 EXPECT_EQ("4", lists[0].subs); 570 571 // Test the same sub chunk again. This should be a no-op. 572 // see bug: http://code.google.com/p/chromium/issues/detail?id=4522 573 chunks.clear(); 574 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/notevil1.html", 2)); 575 576 ASSERT_TRUE(database_->UpdateStarted(&lists)); 577 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 578 database_->UpdateFinished(true); 579 580 GetListsInfo(&lists); 581 ASSERT_LE(1U, lists.size()); 582 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 583 EXPECT_EQ("1-3,7", lists[0].adds); 584 EXPECT_EQ("4", lists[0].subs); 585 586 // Test removing all the prefixes from an add chunk. 587 ASSERT_TRUE(database_->UpdateStarted(&lists)); 588 AddDelChunk(safe_browsing_util::kMalwareList, 2); 589 database_->UpdateFinished(true); 590 591 EXPECT_FALSE(database_->ContainsBrowseUrl( 592 GURL("http://www.evil.com/notevil2.html"), &prefix_hits, &cache_hits)); 593 594 EXPECT_FALSE(database_->ContainsBrowseUrl( 595 GURL("http://www.good.com/good1.html"), &prefix_hits, &cache_hits)); 596 597 EXPECT_FALSE(database_->ContainsBrowseUrl( 598 GURL("http://www.good.com/good2.html"), &prefix_hits, &cache_hits)); 599 600 GetListsInfo(&lists); 601 ASSERT_LE(1U, lists.size()); 602 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 603 EXPECT_EQ("1,3,7", lists[0].adds); 604 EXPECT_EQ("4", lists[0].subs); 605 606 // The adddel command exposed a bug in the transaction code where any 607 // transaction after it would fail. Add a dummy entry and remove it to 608 // make sure the transcation works fine. 609 chunks.clear(); 610 chunks.push_back(AddChunkPrefixValue(44, "www.redherring.com/index.html")); 611 ASSERT_TRUE(database_->UpdateStarted(&lists)); 612 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 613 614 // Now remove the dummy entry. If there are any problems with the 615 // transactions, asserts will fire. 616 AddDelChunk(safe_browsing_util::kMalwareList, 44); 617 618 // Test the subdel command. 619 SubDelChunk(safe_browsing_util::kMalwareList, 4); 620 database_->UpdateFinished(true); 621 622 GetListsInfo(&lists); 623 ASSERT_LE(1U, lists.size()); 624 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 625 EXPECT_EQ("1,3,7", lists[0].adds); 626 EXPECT_TRUE(lists[0].subs.empty()); 627 628 // Test a sub command coming in before the add. 629 chunks.clear(); 630 chunks.push_back(SubChunkPrefix2Value(5, 631 "www.notevilanymore.com/index.html", 632 10, 633 "www.notevilanymore.com/good.html", 634 10)); 635 ASSERT_TRUE(database_->UpdateStarted(&lists)); 636 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 637 database_->UpdateFinished(true); 638 639 EXPECT_FALSE(database_->ContainsBrowseUrl( 640 GURL("http://www.notevilanymore.com/index.html"), 641 &prefix_hits, 642 &cache_hits)); 643 644 // Now insert the tardy add chunk and we don't expect them to appear 645 // in database because of the previous sub chunk. 646 chunks.clear(); 647 chunks.push_back(AddChunkPrefix2Value(10, 648 "www.notevilanymore.com/index.html", 649 "www.notevilanymore.com/good.html")); 650 ASSERT_TRUE(database_->UpdateStarted(&lists)); 651 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 652 database_->UpdateFinished(true); 653 654 EXPECT_FALSE(database_->ContainsBrowseUrl( 655 GURL("http://www.notevilanymore.com/index.html"), 656 &prefix_hits, 657 &cache_hits)); 658 659 EXPECT_FALSE(database_->ContainsBrowseUrl( 660 GURL("http://www.notevilanymore.com/good.html"), 661 &prefix_hits, 662 &cache_hits)); 663 664 // Reset and reload the database. The database will rely on the prefix set. 665 database_.reset(new SafeBrowsingDatabaseNew); 666 database_->Init(database_filename_); 667 668 // Check that a prefix still hits. 669 EXPECT_TRUE(database_->ContainsBrowseUrl( 670 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 671 ASSERT_EQ(1U, prefix_hits.size()); 672 EXPECT_EQ(SBPrefixForString("www.evil.com/phishing.html"), prefix_hits[0]); 673 674 // Also check that it's not just always returning true in this case. 675 EXPECT_FALSE(database_->ContainsBrowseUrl( 676 GURL("http://www.evil.com/"), &prefix_hits, &cache_hits)); 677 678 // Check that the full hash is still present. 679 EXPECT_TRUE(database_->ContainsBrowseUrl( 680 GURL("http://www.evil.com/evil.html"), &prefix_hits, &cache_hits)); 681 ASSERT_EQ(1U, prefix_hits.size()); 682 EXPECT_EQ(SBPrefixForString("www.evil.com/evil.html"), prefix_hits[0]); 683 } 684 685 // Test adding zero length chunks to the database. 686 TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) { 687 std::vector<SBListChunkRanges> lists; 688 ScopedVector<SBChunkData> chunks; 689 690 // Populate with a couple of normal chunks. 691 chunks.push_back(AddChunkPrefix2Value(1, 692 "www.test.com/test1.html", 693 "www.test.com/test2.html")); 694 chunks.push_back(AddChunkPrefix2Value(10, 695 "www.random.com/random1.html", 696 "www.random.com/random2.html")); 697 698 ASSERT_TRUE(database_->UpdateStarted(&lists)); 699 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 700 database_->UpdateFinished(true); 701 702 // Add an empty ADD and SUB chunk. 703 GetListsInfo(&lists); 704 ASSERT_LE(1U, lists.size()); 705 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 706 EXPECT_EQ("1,10", lists[0].adds); 707 EXPECT_TRUE(lists[0].subs.empty()); 708 709 chunks.clear(); 710 chunks.push_back(BuildChunk(19, safe_browsing::ChunkData::ADD, 711 safe_browsing::ChunkData::PREFIX_4B, 712 NULL, 0, std::vector<int>())); 713 chunks.push_back(BuildChunk(7, safe_browsing::ChunkData::SUB, 714 safe_browsing::ChunkData::PREFIX_4B, 715 NULL, 0, std::vector<int>())); 716 717 ASSERT_TRUE(database_->UpdateStarted(&lists)); 718 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 719 database_->UpdateFinished(true); 720 721 GetListsInfo(&lists); 722 ASSERT_LE(1U, lists.size()); 723 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 724 EXPECT_EQ("1,10,19", lists[0].adds); 725 EXPECT_EQ("7", lists[0].subs); 726 727 // Add an empty chunk along with a couple that contain data. This should 728 // result in the chunk range being reduced in size. 729 chunks.clear(); 730 chunks.push_back(AddChunkPrefixValue(20, "www.notempty.com/full1.html")); 731 chunks.push_back(BuildChunk(21, safe_browsing::ChunkData::ADD, 732 safe_browsing::ChunkData::PREFIX_4B, 733 NULL, 0, std::vector<int>())); 734 chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html")); 735 736 ASSERT_TRUE(database_->UpdateStarted(&lists)); 737 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 738 database_->UpdateFinished(true); 739 740 std::vector<SBPrefix> prefix_hits; 741 std::vector<SBFullHashResult> cache_hits; 742 EXPECT_TRUE(database_->ContainsBrowseUrl( 743 GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits)); 744 EXPECT_TRUE(database_->ContainsBrowseUrl( 745 GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits)); 746 747 GetListsInfo(&lists); 748 ASSERT_LE(1U, lists.size()); 749 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 750 EXPECT_EQ("1,10,19-22", lists[0].adds); 751 EXPECT_EQ("7", lists[0].subs); 752 753 // Handle AddDel and SubDel commands for empty chunks. 754 ASSERT_TRUE(database_->UpdateStarted(&lists)); 755 AddDelChunk(safe_browsing_util::kMalwareList, 21); 756 database_->UpdateFinished(true); 757 758 GetListsInfo(&lists); 759 ASSERT_LE(1U, lists.size()); 760 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 761 EXPECT_EQ("1,10,19-20,22", lists[0].adds); 762 EXPECT_EQ("7", lists[0].subs); 763 764 ASSERT_TRUE(database_->UpdateStarted(&lists)); 765 SubDelChunk(safe_browsing_util::kMalwareList, 7); 766 database_->UpdateFinished(true); 767 768 GetListsInfo(&lists); 769 ASSERT_LE(1U, lists.size()); 770 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 771 EXPECT_EQ("1,10,19-20,22", lists[0].adds); 772 EXPECT_TRUE(lists[0].subs.empty()); 773 } 774 775 // Utility function for setting up the database for the caching test. 776 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() { 777 // Add a couple prefixes. 778 ScopedVector<SBChunkData> chunks; 779 chunks.push_back(AddChunkPrefix2Value(1, 780 "www.evil.com/phishing.html", 781 "www.evil.com/malware.html")); 782 783 std::vector<SBListChunkRanges> lists; 784 ASSERT_TRUE(database_->UpdateStarted(&lists)); 785 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 786 database_->UpdateFinished(true); 787 788 // Cache should be cleared after updating. 789 EXPECT_TRUE(database_->browse_gethash_cache_.empty()); 790 791 SBFullHashResult full_hash; 792 full_hash.list_id = safe_browsing_util::MALWARE; 793 794 std::vector<SBFullHashResult> results; 795 std::vector<SBPrefix> prefixes; 796 797 // Add a fullhash result for each prefix. 798 full_hash.hash = SBFullHashForString("www.evil.com/phishing.html"); 799 results.push_back(full_hash); 800 prefixes.push_back(full_hash.hash.prefix); 801 802 full_hash.hash = SBFullHashForString("www.evil.com/malware.html"); 803 results.push_back(full_hash); 804 prefixes.push_back(full_hash.hash.prefix); 805 806 database_->CacheHashResults(prefixes, results, kCacheLifetime); 807 } 808 809 TEST_F(SafeBrowsingDatabaseTest, HashCaching) { 810 PopulateDatabaseForCacheTest(); 811 812 // We should have both full hashes in the cache. 813 EXPECT_EQ(2U, database_->browse_gethash_cache_.size()); 814 815 // Test the cache lookup for the first prefix. 816 std::vector<SBPrefix> prefix_hits; 817 std::vector<SBFullHashResult> cache_hits; 818 EXPECT_TRUE(database_->ContainsBrowseUrl( 819 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 820 EXPECT_TRUE(prefix_hits.empty()); 821 ASSERT_EQ(1U, cache_hits.size()); 822 EXPECT_TRUE(SBFullHashEqual( 823 cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html"))); 824 825 prefix_hits.clear(); 826 cache_hits.clear(); 827 828 // Test the cache lookup for the second prefix. 829 EXPECT_TRUE(database_->ContainsBrowseUrl( 830 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 831 EXPECT_TRUE(prefix_hits.empty()); 832 ASSERT_EQ(1U, cache_hits.size()); 833 EXPECT_TRUE(SBFullHashEqual( 834 cache_hits[0].hash, SBFullHashForString("www.evil.com/malware.html"))); 835 836 prefix_hits.clear(); 837 cache_hits.clear(); 838 839 // Test removing a prefix via a sub chunk. 840 ScopedVector<SBChunkData> chunks; 841 chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1)); 842 843 std::vector<SBListChunkRanges> lists; 844 ASSERT_TRUE(database_->UpdateStarted(&lists)); 845 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 846 database_->UpdateFinished(true); 847 848 // This prefix should still be there, but cached fullhash should be gone. 849 EXPECT_TRUE(database_->ContainsBrowseUrl( 850 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 851 ASSERT_EQ(1U, prefix_hits.size()); 852 EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefix_hits[0]); 853 EXPECT_TRUE(cache_hits.empty()); 854 prefix_hits.clear(); 855 cache_hits.clear(); 856 857 // This prefix should be gone. 858 EXPECT_FALSE(database_->ContainsBrowseUrl( 859 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 860 prefix_hits.clear(); 861 cache_hits.clear(); 862 863 // Test that an AddDel for the original chunk removes the last cached entry. 864 ASSERT_TRUE(database_->UpdateStarted(&lists)); 865 AddDelChunk(safe_browsing_util::kMalwareList, 1); 866 database_->UpdateFinished(true); 867 EXPECT_FALSE(database_->ContainsBrowseUrl( 868 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 869 EXPECT_TRUE(database_->browse_gethash_cache_.empty()); 870 prefix_hits.clear(); 871 cache_hits.clear(); 872 873 // Test that the cache won't return expired values. First we have to adjust 874 // the cached entries' received time to make them older, since the database 875 // cache insert uses Time::Now(). First, store some entries. 876 PopulateDatabaseForCacheTest(); 877 878 std::map<SBPrefix, SBCachedFullHashResult>* hash_cache = 879 &database_->browse_gethash_cache_; 880 EXPECT_EQ(2U, hash_cache->size()); 881 882 // Now adjust one of the entries times to be in the past. 883 const SBPrefix key = SBPrefixForString("www.evil.com/malware.html"); 884 std::map<SBPrefix, SBCachedFullHashResult>::iterator iter = 885 hash_cache->find(key); 886 ASSERT_TRUE(iter != hash_cache->end()); 887 iter->second.expire_after = Time::Now() - TimeDelta::FromMinutes(1); 888 889 EXPECT_TRUE(database_->ContainsBrowseUrl( 890 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 891 EXPECT_EQ(1U, prefix_hits.size()); 892 EXPECT_TRUE(cache_hits.empty()); 893 // Expired entry should have been removed from cache. 894 EXPECT_EQ(1U, hash_cache->size()); 895 896 // This entry should still exist. 897 EXPECT_TRUE(database_->ContainsBrowseUrl( 898 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 899 EXPECT_TRUE(prefix_hits.empty()); 900 EXPECT_EQ(1U, cache_hits.size()); 901 902 // Testing prefix miss caching. First, we clear out the existing database, 903 // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate 904 // chunks. 905 ASSERT_TRUE(database_->UpdateStarted(&lists)); 906 AddDelChunk(safe_browsing_util::kMalwareList, 1); 907 database_->UpdateFinished(true); 908 909 // Cache should be cleared after updating. 910 EXPECT_TRUE(hash_cache->empty()); 911 912 std::vector<SBPrefix> prefix_misses; 913 std::vector<SBFullHashResult> empty_full_hash; 914 prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html")); 915 prefix_misses.push_back( 916 SBPrefixForString("http://www.bad.com/phishing.html")); 917 database_->CacheHashResults(prefix_misses, empty_full_hash, kCacheLifetime); 918 919 // Prefixes with no full results are misses. 920 EXPECT_EQ(hash_cache->size(), prefix_misses.size()); 921 ASSERT_TRUE( 922 hash_cache->count(SBPrefixForString("http://www.bad.com/malware.html"))); 923 EXPECT_TRUE( 924 hash_cache->find(SBPrefixForString("http://www.bad.com/malware.html")) 925 ->second.full_hashes.empty()); 926 ASSERT_TRUE( 927 hash_cache->count(SBPrefixForString("http://www.bad.com/phishing.html"))); 928 EXPECT_TRUE( 929 hash_cache->find(SBPrefixForString("http://www.bad.com/phishing.html")) 930 ->second.full_hashes.empty()); 931 932 // Update the database. 933 PopulateDatabaseForCacheTest(); 934 935 // Cache a GetHash miss for a particular prefix, and even though the prefix is 936 // in the database, it is flagged as a miss so looking up the associated URL 937 // will not succeed. 938 prefix_hits.clear(); 939 cache_hits.clear(); 940 prefix_misses.clear(); 941 empty_full_hash.clear(); 942 prefix_misses.push_back(SBPrefixForString("www.evil.com/phishing.html")); 943 database_->CacheHashResults(prefix_misses, empty_full_hash, kCacheLifetime); 944 EXPECT_FALSE(database_->ContainsBrowseUrl( 945 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); 946 prefix_hits.clear(); 947 cache_hits.clear(); 948 949 // Test receiving a full add chunk. 950 chunks.clear(); 951 chunks.push_back(AddChunkFullHash2Value(20, 952 "www.fullevil.com/bad1.html", 953 "www.fullevil.com/bad2.html")); 954 ASSERT_TRUE(database_->UpdateStarted(&lists)); 955 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 956 database_->UpdateFinished(true); 957 958 EXPECT_TRUE(database_->ContainsBrowseUrl( 959 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 960 ASSERT_EQ(1U, prefix_hits.size()); 961 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefix_hits[0]); 962 EXPECT_TRUE(cache_hits.empty()); 963 prefix_hits.clear(); 964 cache_hits.clear(); 965 966 EXPECT_TRUE(database_->ContainsBrowseUrl( 967 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 968 ASSERT_EQ(1U, prefix_hits.size()); 969 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); 970 EXPECT_TRUE(cache_hits.empty()); 971 prefix_hits.clear(); 972 cache_hits.clear(); 973 974 // Test receiving a full sub chunk, which will remove one of the full adds. 975 chunks.clear(); 976 chunks.push_back(SubChunkFullHashValue(200, 977 "www.fullevil.com/bad1.html", 978 20)); 979 ASSERT_TRUE(database_->UpdateStarted(&lists)); 980 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 981 database_->UpdateFinished(true); 982 983 EXPECT_FALSE(database_->ContainsBrowseUrl( 984 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 985 986 // There should be one remaining full add. 987 EXPECT_TRUE(database_->ContainsBrowseUrl( 988 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 989 ASSERT_EQ(1U, prefix_hits.size()); 990 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); 991 EXPECT_TRUE(cache_hits.empty()); 992 prefix_hits.clear(); 993 cache_hits.clear(); 994 995 // Now test an AddDel for the remaining full add. 996 ASSERT_TRUE(database_->UpdateStarted(&lists)); 997 AddDelChunk(safe_browsing_util::kMalwareList, 20); 998 database_->UpdateFinished(true); 999 1000 EXPECT_FALSE(database_->ContainsBrowseUrl( 1001 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); 1002 EXPECT_FALSE(database_->ContainsBrowseUrl( 1003 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); 1004 1005 // Add a fullhash which has a prefix collision for a known url. 1006 static const char kExampleFine[] = "www.example.com/fine.html"; 1007 static const char kExampleCollision[] = 1008 "www.example.com/3123364814/malware.htm"; 1009 ASSERT_EQ(SBPrefixForString(kExampleFine), 1010 SBPrefixForString(kExampleCollision)); 1011 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1012 { 1013 ScopedVector<SBChunkData> chunks; 1014 chunks.push_back(AddChunkPrefixValue(21, kExampleCollision)); 1015 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1016 } 1017 database_->UpdateFinished(true); 1018 1019 // Expect a prefix hit due to the collision between |kExampleFine| and 1020 // |kExampleCollision|. 1021 EXPECT_TRUE(database_->ContainsBrowseUrl( 1022 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 1023 ASSERT_EQ(1U, prefix_hits.size()); 1024 EXPECT_EQ(SBPrefixForString(kExampleFine), prefix_hits[0]); 1025 EXPECT_TRUE(cache_hits.empty()); 1026 1027 // Cache gethash response for |kExampleCollision|. 1028 { 1029 SBFullHashResult result; 1030 result.hash = SBFullHashForString(kExampleCollision); 1031 result.list_id = safe_browsing_util::MALWARE; 1032 database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix), 1033 std::vector<SBFullHashResult>(1, result), 1034 kCacheLifetime); 1035 } 1036 1037 // The cached response means the collision no longer causes a hit. 1038 EXPECT_FALSE(database_->ContainsBrowseUrl( 1039 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 1040 } 1041 1042 // Test that corrupt databases are appropriately handled, even if the 1043 // corruption is detected in the midst of the update. 1044 // TODO(shess): Disabled until ScopedLogMessageIgnorer resolved. 1045 // http://crbug.com/56448 1046 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) { 1047 // Re-create the database in a captive message loop so that we can 1048 // influence task-posting. Database specifically needs to the 1049 // file-backed. 1050 database_.reset(); 1051 base::MessageLoop loop; 1052 SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile(); 1053 database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL, NULL, NULL, 1054 NULL, NULL)); 1055 database_->Init(database_filename_); 1056 1057 // This will cause an empty database to be created. 1058 std::vector<SBListChunkRanges> lists; 1059 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1060 database_->UpdateFinished(true); 1061 1062 // Create a sub chunk to insert. 1063 ScopedVector<SBChunkData> chunks; 1064 chunks.push_back(SubChunkPrefixValue(7, 1065 "www.subbed.com/notevil1.html", 1066 19)); 1067 1068 // Corrupt the file by corrupting the checksum, which is not checked 1069 // until the entire table is read in |UpdateFinished()|. 1070 FILE* fp = base::OpenFile(database_filename_, "r+"); 1071 ASSERT_TRUE(fp); 1072 ASSERT_NE(-1, fseek(fp, -8, SEEK_END)); 1073 for (size_t i = 0; i < 8; ++i) { 1074 fputc('!', fp); 1075 } 1076 fclose(fp); 1077 1078 { 1079 // The following code will cause DCHECKs, so suppress the crashes. 1080 ScopedLogMessageIgnorer ignorer; 1081 1082 // Start an update. The insert will fail due to corruption. 1083 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1084 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1085 database_->UpdateFinished(true); 1086 1087 // Database file still exists until the corruption handler has run. 1088 EXPECT_TRUE(base::PathExists(database_filename_)); 1089 1090 // Flush through the corruption-handler task. 1091 VLOG(1) << "Expect failed check on: SafeBrowsing database reset"; 1092 base::MessageLoop::current()->RunUntilIdle(); 1093 } 1094 1095 // Database file should not exist. 1096 EXPECT_FALSE(base::PathExists(database_filename_)); 1097 1098 // Run the update again successfully. 1099 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1100 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1101 database_->UpdateFinished(true); 1102 EXPECT_TRUE(base::PathExists(database_filename_)); 1103 1104 database_.reset(); 1105 } 1106 1107 // Checks database reading and writing. 1108 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrl) { 1109 database_.reset(); 1110 base::MessageLoop loop; 1111 SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile(); 1112 SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile(); 1113 SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile(); 1114 database_.reset(new SafeBrowsingDatabaseNew(browse_store, 1115 download_store, 1116 csd_whitelist_store, 1117 NULL, 1118 NULL, 1119 NULL, 1120 NULL)); 1121 database_->Init(database_filename_); 1122 1123 const char kEvil1Url1[] = "www.evil1.com/download1/"; 1124 const char kEvil1Url2[] = "www.evil1.com/download2.html"; 1125 1126 // Add a simple chunk with one hostkey for download url list. 1127 ScopedVector<SBChunkData> chunks; 1128 chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2)); 1129 1130 std::vector<SBListChunkRanges> lists; 1131 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1132 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); 1133 database_->UpdateFinished(true); 1134 1135 std::vector<SBPrefix> prefix_hits; 1136 std::vector<GURL> urls(1); 1137 1138 urls[0] = GURL(std::string("http://") + kEvil1Url1); 1139 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1140 ASSERT_EQ(1U, prefix_hits.size()); 1141 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1142 1143 urls[0] = GURL(std::string("http://") + kEvil1Url2); 1144 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1145 ASSERT_EQ(1U, prefix_hits.size()); 1146 EXPECT_EQ(SBPrefixForString(kEvil1Url2), prefix_hits[0]); 1147 1148 urls[0] = GURL(std::string("https://") + kEvil1Url2); 1149 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1150 ASSERT_EQ(1U, prefix_hits.size()); 1151 EXPECT_EQ(SBPrefixForString(kEvil1Url2), prefix_hits[0]); 1152 1153 urls[0] = GURL(std::string("ftp://") + kEvil1Url2); 1154 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1155 ASSERT_EQ(1U, prefix_hits.size()); 1156 EXPECT_EQ(SBPrefixForString(kEvil1Url2), prefix_hits[0]); 1157 1158 urls[0] = GURL("http://www.randomevil.com"); 1159 EXPECT_FALSE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1160 1161 // Should match with query args stripped. 1162 urls[0] = GURL(std::string("http://") + kEvil1Url2 + "?blah"); 1163 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1164 ASSERT_EQ(1U, prefix_hits.size()); 1165 EXPECT_EQ(SBPrefixForString(kEvil1Url2), prefix_hits[0]); 1166 1167 // Should match with extra path stuff and query args stripped. 1168 urls[0] = GURL(std::string("http://") + kEvil1Url1 + "foo/bar?blah"); 1169 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1170 ASSERT_EQ(1U, prefix_hits.size()); 1171 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1172 1173 // First hit in redirect chain is malware. 1174 urls.clear(); 1175 urls.push_back(GURL(std::string("http://") + kEvil1Url1)); 1176 urls.push_back(GURL("http://www.randomevil.com")); 1177 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1178 ASSERT_EQ(1U, prefix_hits.size()); 1179 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1180 1181 // Middle hit in redirect chain is malware. 1182 urls.clear(); 1183 urls.push_back(GURL("http://www.randomevil.com")); 1184 urls.push_back(GURL(std::string("http://") + kEvil1Url1)); 1185 urls.push_back(GURL("http://www.randomevil2.com")); 1186 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1187 ASSERT_EQ(1U, prefix_hits.size()); 1188 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1189 1190 // Final hit in redirect chain is malware. 1191 urls.clear(); 1192 urls.push_back(GURL("http://www.randomevil.com")); 1193 urls.push_back(GURL(std::string("http://") + kEvil1Url1)); 1194 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1195 ASSERT_EQ(1U, prefix_hits.size()); 1196 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1197 1198 // Multiple hits in redirect chain are in malware list. 1199 urls.clear(); 1200 urls.push_back(GURL(std::string("http://") + kEvil1Url1)); 1201 urls.push_back(GURL(std::string("https://") + kEvil1Url2)); 1202 EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits)); 1203 ASSERT_EQ(2U, prefix_hits.size()); 1204 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); 1205 EXPECT_EQ(SBPrefixForString(kEvil1Url2), prefix_hits[1]); 1206 database_.reset(); 1207 } 1208 1209 // Checks that the whitelists are handled properly. 1210 TEST_F(SafeBrowsingDatabaseTest, Whitelists) { 1211 database_.reset(); 1212 1213 // We expect all calls to ContainsCsdWhitelistedUrl in particular to be made 1214 // from the IO thread. In general the whitelist lookups are thread-safe. 1215 content::TestBrowserThreadBundle thread_bundle_; 1216 1217 // If the whitelist is disabled everything should match the whitelist. 1218 database_.reset(new SafeBrowsingDatabaseNew(new SafeBrowsingStoreFile(), 1219 NULL, NULL, NULL, NULL, NULL, 1220 NULL)); 1221 database_->Init(database_filename_); 1222 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1223 GURL(std::string("http://www.phishing.com/")))); 1224 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1225 GURL(std::string("http://www.phishing.com/")))); 1226 EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf")); 1227 1228 SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile(); 1229 SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile(); 1230 SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile(); 1231 SafeBrowsingStoreFile* extension_blacklist_store = 1232 new SafeBrowsingStoreFile(); 1233 database_.reset(new SafeBrowsingDatabaseNew(browse_store, NULL, 1234 csd_whitelist_store, 1235 download_whitelist_store, 1236 extension_blacklist_store, 1237 NULL, NULL)); 1238 database_->Init(database_filename_); 1239 1240 const char kGood1Host[] = "www.good1.com/"; 1241 const char kGood1Url1[] = "www.good1.com/a/b.html"; 1242 const char kGood1Url2[] = "www.good1.com/b/"; 1243 1244 const char kGood2Url1[] = "www.good2.com/c"; // Should match '/c/bla'. 1245 1246 // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist. 1247 const char kGood3Url1[] = "good3.com/"; 1248 1249 const char kGoodString[] = "good_string"; 1250 1251 ScopedVector<SBChunkData> csd_chunks; 1252 ScopedVector<SBChunkData> download_chunks; 1253 1254 // Add two simple chunks to the csd whitelist. 1255 csd_chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2)); 1256 csd_chunks.push_back(AddChunkFullHashValue(2, kGood2Url1)); 1257 download_chunks.push_back(AddChunkFullHashValue(2, kGood2Url1)); 1258 download_chunks.push_back(AddChunkFullHashValue(3, kGoodString)); 1259 download_chunks.push_back(AddChunkFullHashValue(4, kGood3Url1)); 1260 1261 std::vector<SBListChunkRanges> lists; 1262 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1263 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get()); 1264 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, 1265 download_chunks.get()); 1266 database_->UpdateFinished(true); 1267 1268 EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl( 1269 GURL(std::string("http://") + kGood1Host))); 1270 1271 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1272 GURL(std::string("http://") + kGood1Url1))); 1273 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1274 GURL(std::string("http://") + kGood1Url1 + "?a=b"))); 1275 1276 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1277 GURL(std::string("http://") + kGood1Url2))); 1278 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1279 GURL(std::string("http://") + kGood1Url2 + "/c.html"))); 1280 1281 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1282 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1283 1284 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1285 GURL(std::string("http://") + kGood2Url1 + "/c"))); 1286 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1287 GURL(std::string("http://") + kGood2Url1 + "/c?bla"))); 1288 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1289 GURL(std::string("http://") + kGood2Url1 + "/c/bla"))); 1290 1291 EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl( 1292 GURL(std::string("http://www.google.com/")))); 1293 1294 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1295 GURL(std::string("http://") + kGood2Url1 + "/c"))); 1296 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1297 GURL(std::string("http://") + kGood2Url1 + "/c?bla"))); 1298 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1299 GURL(std::string("http://") + kGood2Url1 + "/c/bla"))); 1300 1301 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1302 GURL(std::string("http://good3.com/a/b/c/d/e/f/g/")))); 1303 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1304 GURL(std::string("http://a.b.good3.com/")))); 1305 1306 EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf")); 1307 EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString)); 1308 1309 EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl( 1310 GURL(std::string("http://www.google.com/")))); 1311 1312 // The CSD whitelist killswitch is not present. 1313 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1314 1315 // Test only add the malware IP killswitch 1316 csd_chunks.clear(); 1317 csd_chunks.push_back(AddChunkFullHashValue( 1318 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware")); 1319 1320 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1321 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get()); 1322 database_->UpdateFinished(true); 1323 1324 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); 1325 // The CSD whitelist killswitch is not present. 1326 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1327 1328 // Test that the kill-switch works as intended. 1329 csd_chunks.clear(); 1330 download_chunks.clear(); 1331 lists.clear(); 1332 csd_chunks.push_back(AddChunkFullHashValue( 1333 5, "sb-ssl.google.com/safebrowsing/csd/killswitch")); 1334 download_chunks.push_back(AddChunkFullHashValue( 1335 5, "sb-ssl.google.com/safebrowsing/csd/killswitch")); 1336 1337 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1338 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get()); 1339 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, 1340 download_chunks.get()); 1341 database_->UpdateFinished(true); 1342 1343 // The CSD whitelist killswitch is present. 1344 EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn()); 1345 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); 1346 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1347 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1348 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1349 GURL(std::string("http://www.google.com/")))); 1350 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1351 GURL(std::string("http://www.phishing_url.com/")))); 1352 1353 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1354 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1355 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1356 GURL(std::string("http://www.google.com/")))); 1357 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1358 GURL(std::string("http://www.phishing_url.com/")))); 1359 1360 EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf")); 1361 EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString)); 1362 1363 // Remove the kill-switch and verify that we can recover. 1364 csd_chunks.clear(); 1365 download_chunks.clear(); 1366 lists.clear(); 1367 csd_chunks.push_back(SubChunkFullHashValue( 1368 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5)); 1369 csd_chunks.push_back(SubChunkFullHashValue( 1370 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15)); 1371 download_chunks.push_back(SubChunkFullHashValue( 1372 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5)); 1373 1374 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1375 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks.get()); 1376 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, 1377 download_chunks.get()); 1378 database_->UpdateFinished(true); 1379 1380 EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn()); 1381 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); 1382 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1383 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); 1384 EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl( 1385 GURL(std::string("https://") + kGood2Url1 + "/c/bla"))); 1386 EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl( 1387 GURL(std::string("http://www.google.com/")))); 1388 EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl( 1389 GURL(std::string("http://www.phishing_url.com/")))); 1390 1391 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1392 GURL(std::string("https://") + kGood2Url1 + "/c/bla"))); 1393 EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl( 1394 GURL(std::string("https://good3.com/")))); 1395 EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString)); 1396 EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl( 1397 GURL(std::string("http://www.google.com/")))); 1398 EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl( 1399 GURL(std::string("http://www.phishing_url.com/")))); 1400 EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf")); 1401 1402 database_.reset(); 1403 } 1404 1405 // Test to make sure we could insert chunk list that 1406 // contains entries for the same host. 1407 TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) { 1408 ScopedVector<SBChunkData> chunks; 1409 1410 // Add a malware add chunk with two entries of the same host. 1411 chunks.push_back(AddChunkPrefix2Value(1, 1412 "www.evil.com/malware1.html", 1413 "www.evil.com/malware2.html")); 1414 1415 // Insert the testing chunks into database. 1416 std::vector<SBListChunkRanges> lists; 1417 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1418 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1419 database_->UpdateFinished(true); 1420 1421 GetListsInfo(&lists); 1422 ASSERT_LE(1U, lists.size()); 1423 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 1424 EXPECT_EQ("1", lists[0].adds); 1425 EXPECT_TRUE(lists[0].subs.empty()); 1426 1427 // Add a phishing add chunk with two entries of the same host. 1428 chunks.clear(); 1429 chunks.push_back(AddChunkPrefix2Value(47, 1430 "www.evil.com/phishing1.html", 1431 "www.evil.com/phishing2.html")); 1432 1433 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1434 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 1435 database_->UpdateFinished(true); 1436 1437 GetListsInfo(&lists); 1438 ASSERT_EQ(2U, lists.size()); 1439 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); 1440 EXPECT_EQ("1", lists[0].adds); 1441 EXPECT_TRUE(lists[0].subs.empty()); 1442 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); 1443 EXPECT_EQ("47", lists[1].adds); 1444 EXPECT_TRUE(lists[1].subs.empty()); 1445 1446 std::vector<SBPrefix> prefix_hits; 1447 std::vector<SBFullHashResult> cache_hits; 1448 1449 EXPECT_TRUE(database_->ContainsBrowseUrl( 1450 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); 1451 EXPECT_TRUE(database_->ContainsBrowseUrl( 1452 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); 1453 EXPECT_TRUE(database_->ContainsBrowseUrl( 1454 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); 1455 EXPECT_TRUE(database_->ContainsBrowseUrl( 1456 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); 1457 1458 // Test removing a single prefix from the add chunk. 1459 // Remove the prefix that added first. 1460 chunks.clear(); 1461 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1)); 1462 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1463 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1464 database_->UpdateFinished(true); 1465 1466 // Remove the prefix that added last. 1467 chunks.clear(); 1468 chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47)); 1469 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1470 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); 1471 database_->UpdateFinished(true); 1472 1473 // Verify that the database contains urls expected. 1474 EXPECT_FALSE(database_->ContainsBrowseUrl( 1475 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); 1476 EXPECT_TRUE(database_->ContainsBrowseUrl( 1477 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); 1478 EXPECT_TRUE(database_->ContainsBrowseUrl( 1479 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); 1480 EXPECT_FALSE(database_->ContainsBrowseUrl( 1481 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); 1482 } 1483 1484 // Test that an empty update doesn't actually update the database. 1485 // This isn't a functionality requirement, but it is a useful 1486 // optimization. 1487 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) { 1488 ScopedVector<SBChunkData> chunks; 1489 1490 base::FilePath filename = database_->BrowseDBFilename(database_filename_); 1491 1492 // Prime the database. 1493 std::vector<SBListChunkRanges> lists; 1494 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1495 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 1496 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1497 database_->UpdateFinished(true); 1498 1499 // Get an older time to reset the lastmod time for detecting whether 1500 // the file has been updated. 1501 base::File::Info before_info, after_info; 1502 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1503 const Time old_last_modified = 1504 before_info.last_modified - TimeDelta::FromSeconds(10); 1505 1506 // Inserting another chunk updates the database file. The sleep is 1507 // needed because otherwise the entire test can finish w/in the 1508 // resolution of the lastmod time. 1509 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1510 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1511 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1512 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); 1513 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1514 database_->UpdateFinished(true); 1515 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1516 EXPECT_LT(before_info.last_modified, after_info.last_modified); 1517 1518 // Deleting a chunk updates the database file. 1519 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1520 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1521 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1522 AddDelChunk(safe_browsing_util::kMalwareList, 2); 1523 database_->UpdateFinished(true); 1524 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1525 EXPECT_LT(before_info.last_modified, after_info.last_modified); 1526 1527 // Simply calling |UpdateStarted()| then |UpdateFinished()| does not 1528 // update the database file. 1529 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); 1530 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); 1531 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1532 database_->UpdateFinished(true); 1533 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); 1534 EXPECT_EQ(before_info.last_modified, after_info.last_modified); 1535 } 1536 1537 // Test that a filter file is written out during update and read back 1538 // in during setup. 1539 TEST_F(SafeBrowsingDatabaseTest, FilterFile) { 1540 // Create a database with trivial example data and write it out. 1541 { 1542 // Prime the database. 1543 std::vector<SBListChunkRanges> lists; 1544 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1545 1546 ScopedVector<SBChunkData> chunks; 1547 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); 1548 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1549 database_->UpdateFinished(true); 1550 } 1551 1552 // Find the malware url in the database, don't find a good url. 1553 std::vector<SBPrefix> prefix_hits; 1554 std::vector<SBFullHashResult> cache_hits; 1555 EXPECT_TRUE(database_->ContainsBrowseUrl( 1556 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 1557 EXPECT_FALSE(database_->ContainsBrowseUrl( 1558 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); 1559 1560 base::FilePath filter_file = database_->PrefixSetForFilename( 1561 database_->BrowseDBFilename(database_filename_)); 1562 1563 // After re-creating the database, it should have a filter read from 1564 // a file, so it should find the same results. 1565 ASSERT_TRUE(base::PathExists(filter_file)); 1566 database_.reset(new SafeBrowsingDatabaseNew); 1567 database_->Init(database_filename_); 1568 EXPECT_TRUE(database_->ContainsBrowseUrl( 1569 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 1570 EXPECT_FALSE(database_->ContainsBrowseUrl( 1571 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); 1572 1573 // If there is no filter file, the database cannot find malware urls. 1574 base::DeleteFile(filter_file, false); 1575 ASSERT_FALSE(base::PathExists(filter_file)); 1576 database_.reset(new SafeBrowsingDatabaseNew); 1577 database_->Init(database_filename_); 1578 EXPECT_FALSE(database_->ContainsBrowseUrl( 1579 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 1580 EXPECT_FALSE(database_->ContainsBrowseUrl( 1581 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); 1582 } 1583 1584 TEST_F(SafeBrowsingDatabaseTest, CachedFullMiss) { 1585 const SBPrefix kPrefix1 = 1001U; 1586 const SBFullHash kFullHash1_1 = 1587 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); 1588 1589 const SBPrefix kPrefix2 = 1002U; 1590 const SBFullHash kFullHash2_1 = 1591 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01"); 1592 1593 // Insert prefix kPrefix1 and kPrefix2 into database. 1594 ScopedVector<SBChunkData> chunks; 1595 chunks.push_back(AddChunkPrefix(1, kPrefix1)); 1596 chunks.push_back(AddChunkPrefix(2, kPrefix2)); 1597 1598 std::vector<SBListChunkRanges> lists; 1599 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1600 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1601 database_->UpdateFinished(true); 1602 1603 { 1604 // Cache a full miss result for kPrefix1. 1605 std::vector<SBPrefix> prefixes(1, kPrefix1); 1606 std::vector<SBFullHashResult> cache_results; 1607 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1608 } 1609 1610 { 1611 // kFullHash1_1 gets no prefix hit because of the cached item, and also does 1612 // not have a cache hit. 1613 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); 1614 std::vector<SBPrefix> prefix_hits; 1615 std::vector<SBFullHashResult> cache_hits; 1616 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1617 full_hashes, &prefix_hits, &cache_hits)); 1618 1619 // kFullHash2_1 gets a hit from the prefix in the database. 1620 full_hashes.push_back(kFullHash2_1); 1621 prefix_hits.clear(); 1622 cache_hits.clear(); 1623 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1624 full_hashes, &prefix_hits, &cache_hits)); 1625 ASSERT_EQ(1U, prefix_hits.size()); 1626 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1627 EXPECT_TRUE(cache_hits.empty()); 1628 } 1629 } 1630 1631 TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) { 1632 const SBPrefix kPrefix1 = 1001U; 1633 const SBFullHash kFullHash1_1 = 1634 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); 1635 const SBFullHash kFullHash1_2 = 1636 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); 1637 const SBFullHash kFullHash1_3 = 1638 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03"); 1639 1640 const SBPrefix kPrefix2 = 1002U; 1641 const SBFullHash kFullHash2_1 = 1642 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01"); 1643 1644 const SBPrefix kPrefix3 = 1003U; 1645 const SBFullHash kFullHash3_1 = 1646 SBFullHashForPrefixAndSuffix(kPrefix3, "\x01"); 1647 1648 // Insert prefix kPrefix1 and kPrefix2 into database. 1649 ScopedVector<SBChunkData> chunks; 1650 chunks.push_back(AddChunkPrefix(1, kPrefix1)); 1651 chunks.push_back(AddChunkPrefix(2, kPrefix2)); 1652 1653 std::vector<SBListChunkRanges> lists; 1654 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1655 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1656 database_->UpdateFinished(true); 1657 1658 { 1659 // kFullHash1_1 has a prefix hit of kPrefix1. 1660 std::vector<SBFullHash> full_hashes; 1661 full_hashes.push_back(kFullHash1_1); 1662 std::vector<SBPrefix> prefix_hits; 1663 std::vector<SBFullHashResult> cache_hits; 1664 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1665 full_hashes, &prefix_hits, &cache_hits)); 1666 ASSERT_EQ(1U, prefix_hits.size()); 1667 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1668 EXPECT_TRUE(cache_hits.empty()); 1669 1670 // kFullHash2_1 has a prefix hit of kPrefix2. 1671 full_hashes.push_back(kFullHash2_1); 1672 prefix_hits.clear(); 1673 cache_hits.clear(); 1674 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1675 full_hashes, &prefix_hits, &cache_hits)); 1676 ASSERT_EQ(2U, prefix_hits.size()); 1677 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1678 EXPECT_EQ(kPrefix2, prefix_hits[1]); 1679 EXPECT_TRUE(cache_hits.empty()); 1680 1681 // kFullHash3_1 has no hits. 1682 full_hashes.push_back(kFullHash3_1); 1683 prefix_hits.clear(); 1684 cache_hits.clear(); 1685 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1686 full_hashes, &prefix_hits, &cache_hits)); 1687 ASSERT_EQ(2U, prefix_hits.size()); 1688 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1689 EXPECT_EQ(kPrefix2, prefix_hits[1]); 1690 EXPECT_TRUE(cache_hits.empty()); 1691 } 1692 1693 { 1694 // Cache a fullhash result for two kPrefix1 full hashes. 1695 std::vector<SBPrefix> prefixes(1, kPrefix1); 1696 std::vector<SBFullHashResult> cache_results; 1697 1698 SBFullHashResult full_hash_result; 1699 full_hash_result.list_id = safe_browsing_util::MALWARE; 1700 1701 full_hash_result.hash = kFullHash1_1; 1702 cache_results.push_back(full_hash_result); 1703 1704 full_hash_result.hash = kFullHash1_3; 1705 cache_results.push_back(full_hash_result); 1706 1707 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1708 } 1709 1710 { 1711 // kFullHash1_1 should now see a cache hit. 1712 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); 1713 std::vector<SBPrefix> prefix_hits; 1714 std::vector<SBFullHashResult> cache_hits; 1715 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1716 full_hashes, &prefix_hits, &cache_hits)); 1717 EXPECT_TRUE(prefix_hits.empty()); 1718 ASSERT_EQ(1U, cache_hits.size()); 1719 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1720 1721 // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit 1722 // for kPrefix2. 1723 full_hashes.push_back(kFullHash2_1); 1724 prefix_hits.clear(); 1725 cache_hits.clear(); 1726 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1727 full_hashes, &prefix_hits, &cache_hits)); 1728 ASSERT_EQ(1U, prefix_hits.size()); 1729 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1730 ASSERT_EQ(1U, cache_hits.size()); 1731 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1732 1733 // kFullHash1_3 also gets a cache hit. 1734 full_hashes.push_back(kFullHash1_3); 1735 prefix_hits.clear(); 1736 cache_hits.clear(); 1737 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1738 full_hashes, &prefix_hits, &cache_hits)); 1739 ASSERT_EQ(1U, prefix_hits.size()); 1740 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1741 ASSERT_EQ(2U, cache_hits.size()); 1742 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); 1743 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[1].hash)); 1744 } 1745 1746 { 1747 // Check if DB contains only kFullHash1_3. Should return a cache hit. 1748 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); 1749 std::vector<SBPrefix> prefix_hits; 1750 std::vector<SBFullHashResult> cache_hits; 1751 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1752 full_hashes, &prefix_hits, &cache_hits)); 1753 EXPECT_TRUE(prefix_hits.empty()); 1754 ASSERT_EQ(1U, cache_hits.size()); 1755 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[0].hash)); 1756 } 1757 1758 { 1759 // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for 1760 // kPrefix1. 1761 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 1762 std::vector<SBPrefix> prefix_hits; 1763 std::vector<SBFullHashResult> cache_hits; 1764 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1765 full_hashes, &prefix_hits, &cache_hits)); 1766 1767 // Other prefix hits possible when kFullHash1_2 hits nothing. 1768 full_hashes.push_back(kFullHash2_1); 1769 prefix_hits.clear(); 1770 cache_hits.clear(); 1771 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1772 full_hashes, &prefix_hits, &cache_hits)); 1773 ASSERT_EQ(1U, prefix_hits.size()); 1774 EXPECT_EQ(kPrefix2, prefix_hits[0]); 1775 EXPECT_TRUE(cache_hits.empty()); 1776 } 1777 } 1778 1779 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) { 1780 const SBPrefix kPrefix1 = 1001U; 1781 const SBFullHash kFullHash1_1 = 1782 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); 1783 const SBFullHash kFullHash1_2 = 1784 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); 1785 const SBFullHash kFullHash1_3 = 1786 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03"); 1787 1788 // Insert two full hashes with a shared prefix. 1789 ScopedVector<SBChunkData> chunks; 1790 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); 1791 chunks.push_back(AddChunkFullHash(2, kFullHash1_2)); 1792 1793 std::vector<SBListChunkRanges> lists; 1794 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1795 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1796 database_->UpdateFinished(true); 1797 1798 { 1799 // Check a full hash which isn't present. 1800 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); 1801 std::vector<SBPrefix> prefix_hits; 1802 std::vector<SBFullHashResult> cache_hits; 1803 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1804 full_hashes, &prefix_hits, &cache_hits)); 1805 1806 // Also one which is present, should have a prefix hit. 1807 full_hashes.push_back(kFullHash1_1); 1808 prefix_hits.clear(); 1809 cache_hits.clear(); 1810 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1811 full_hashes, &prefix_hits, &cache_hits)); 1812 ASSERT_EQ(1U, prefix_hits.size()); 1813 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1814 EXPECT_TRUE(cache_hits.empty()); 1815 1816 // Two full hash matches with the same prefix should return one prefix hit. 1817 full_hashes.push_back(kFullHash1_2); 1818 prefix_hits.clear(); 1819 cache_hits.clear(); 1820 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1821 full_hashes, &prefix_hits, &cache_hits)); 1822 ASSERT_EQ(1U, prefix_hits.size()); 1823 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1824 EXPECT_TRUE(cache_hits.empty()); 1825 } 1826 1827 { 1828 // Cache a gethash result for kFullHash1_2. 1829 SBFullHashResult full_hash_result; 1830 full_hash_result.list_id = safe_browsing_util::MALWARE; 1831 full_hash_result.hash = kFullHash1_2; 1832 1833 std::vector<SBPrefix> prefixes(1, kPrefix1); 1834 std::vector<SBFullHashResult> cache_results(1, full_hash_result); 1835 1836 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); 1837 } 1838 1839 { 1840 // kFullHash1_3 should still return false, because the cached 1841 // result for kPrefix1 doesn't contain kFullHash1_3. 1842 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); 1843 std::vector<SBPrefix> prefix_hits; 1844 std::vector<SBFullHashResult> cache_hits; 1845 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1846 full_hashes, &prefix_hits, &cache_hits)); 1847 1848 // kFullHash1_1 is also not in the cached result, which takes 1849 // priority over the database. 1850 prefix_hits.clear(); 1851 full_hashes.push_back(kFullHash1_1); 1852 cache_hits.clear(); 1853 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1854 full_hashes, &prefix_hits, &cache_hits)); 1855 1856 // kFullHash1_2 is in the cached result. 1857 full_hashes.push_back(kFullHash1_2); 1858 prefix_hits.clear(); 1859 cache_hits.clear(); 1860 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1861 full_hashes, &prefix_hits, &cache_hits)); 1862 EXPECT_TRUE(prefix_hits.empty()); 1863 ASSERT_EQ(1U, cache_hits.size()); 1864 EXPECT_TRUE(SBFullHashEqual(kFullHash1_2, cache_hits[0].hash)); 1865 } 1866 1867 // Remove kFullHash1_1 from the database. 1868 chunks.clear(); 1869 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); 1870 1871 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1872 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1873 database_->UpdateFinished(true); 1874 1875 // Cache should be cleared after updating. 1876 EXPECT_TRUE(database_->browse_gethash_cache_.empty()); 1877 1878 { 1879 // Now the database doesn't contain kFullHash1_1. 1880 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); 1881 std::vector<SBPrefix> prefix_hits; 1882 std::vector<SBFullHashResult> cache_hits; 1883 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1884 full_hashes, &prefix_hits, &cache_hits)); 1885 1886 // Nor kFullHash1_3. 1887 full_hashes.push_back(kFullHash1_3); 1888 prefix_hits.clear(); 1889 cache_hits.clear(); 1890 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1891 full_hashes, &prefix_hits, &cache_hits)); 1892 1893 // Still has kFullHash1_2. 1894 full_hashes.push_back(kFullHash1_2); 1895 prefix_hits.clear(); 1896 cache_hits.clear(); 1897 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1898 full_hashes, &prefix_hits, &cache_hits)); 1899 ASSERT_EQ(1U, prefix_hits.size()); 1900 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1901 EXPECT_TRUE(cache_hits.empty()); 1902 } 1903 1904 // Remove kFullHash1_2 from the database. 1905 chunks.clear(); 1906 chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2)); 1907 1908 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1909 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1910 database_->UpdateFinished(true); 1911 1912 // Cache should be cleared after updating. 1913 EXPECT_TRUE(database_->browse_gethash_cache_.empty()); 1914 1915 { 1916 // None are present. 1917 std::vector<SBFullHash> full_hashes; 1918 std::vector<SBPrefix> prefix_hits; 1919 std::vector<SBFullHashResult> cache_hits; 1920 full_hashes.push_back(kFullHash1_1); 1921 full_hashes.push_back(kFullHash1_2); 1922 full_hashes.push_back(kFullHash1_3); 1923 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1924 full_hashes, &prefix_hits, &cache_hits)); 1925 } 1926 } 1927 1928 TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) { 1929 const SBPrefix kPrefix1 = 1001U; 1930 const SBFullHash kFullHash1_1 = 1931 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); 1932 const SBFullHash kFullHash1_2 = 1933 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); 1934 1935 ScopedVector<SBChunkData> chunks; 1936 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); 1937 1938 std::vector<SBListChunkRanges> lists; 1939 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1940 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1941 database_->UpdateFinished(true); 1942 1943 { 1944 // kFullHash1_2 does not match kFullHash1_1. 1945 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 1946 std::vector<SBPrefix> prefix_hits; 1947 std::vector<SBFullHashResult> cache_hits; 1948 EXPECT_FALSE(database_->ContainsBrowseUrlHashes( 1949 full_hashes, &prefix_hits, &cache_hits)); 1950 } 1951 1952 // Add a prefix match. 1953 chunks.clear(); 1954 chunks.push_back(AddChunkPrefix(2, kPrefix1)); 1955 1956 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1957 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1958 database_->UpdateFinished(true); 1959 1960 { 1961 // kFullHash1_2 does match kPrefix1. 1962 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 1963 std::vector<SBPrefix> prefix_hits; 1964 std::vector<SBFullHashResult> cache_hits; 1965 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1966 full_hashes, &prefix_hits, &cache_hits)); 1967 ASSERT_EQ(1U, prefix_hits.size()); 1968 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1969 EXPECT_TRUE(cache_hits.empty()); 1970 } 1971 1972 // Remove the full hash. 1973 chunks.clear(); 1974 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); 1975 1976 ASSERT_TRUE(database_->UpdateStarted(&lists)); 1977 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 1978 database_->UpdateFinished(true); 1979 1980 { 1981 // kFullHash1_2 still returns true due to the prefix hit. 1982 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); 1983 std::vector<SBPrefix> prefix_hits; 1984 std::vector<SBFullHashResult> cache_hits; 1985 EXPECT_TRUE(database_->ContainsBrowseUrlHashes( 1986 full_hashes, &prefix_hits, &cache_hits)); 1987 ASSERT_EQ(1U, prefix_hits.size()); 1988 EXPECT_EQ(kPrefix1, prefix_hits[0]); 1989 EXPECT_TRUE(cache_hits.empty()); 1990 } 1991 } 1992 1993 TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) { 1994 database_.reset(); 1995 SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile(); 1996 SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile(); 1997 database_.reset(new SafeBrowsingDatabaseNew(browse_store, 1998 NULL, 1999 NULL, 2000 NULL, 2001 NULL, 2002 NULL, 2003 ip_blacklist_store)); 2004 database_->Init(database_filename_); 2005 std::vector<SBListChunkRanges> lists; 2006 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2007 2008 ScopedVector<SBChunkData> chunks; 2009 2010 // IPv4 prefix match for ::ffff:192.168.1.0/120. 2011 chunks.push_back(AddChunkHashedIpValue(1, "::ffff:192.168.1.0", 120)); 2012 2013 // IPv4 exact match for ::ffff:192.1.1.1. 2014 chunks.push_back(AddChunkHashedIpValue(2, "::ffff:192.1.1.1", 128)); 2015 2016 // IPv6 exact match for: fe80::31a:a0ff:fe10:786e/128. 2017 chunks.push_back(AddChunkHashedIpValue(3, "fe80::31a:a0ff:fe10:786e", 128)); 2018 2019 // IPv6 prefix match for: 2620:0:1000:3103::/64. 2020 chunks.push_back(AddChunkHashedIpValue(4, "2620:0:1000:3103::", 64)); 2021 2022 // IPv4 prefix match for ::ffff:192.1.122.0/119. 2023 chunks.push_back(AddChunkHashedIpValue(5, "::ffff:192.1.122.0", 119)); 2024 2025 // IPv4 prefix match for ::ffff:192.1.128.0/113. 2026 chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113)); 2027 2028 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); 2029 database_->UpdateFinished(true); 2030 2031 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255")); 2032 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.0")); 2033 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.255")); 2034 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.10")); 2035 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.168.1.2")); 2036 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.2.0")); 2037 2038 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.0")); 2039 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.1.1")); 2040 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.2")); 2041 2042 EXPECT_FALSE(database_->ContainsMalwareIP( 2043 "2620:0:1000:3102:ffff:ffff:ffff:ffff")); 2044 EXPECT_TRUE(database_->ContainsMalwareIP("2620:0:1000:3103::")); 2045 EXPECT_TRUE(database_->ContainsMalwareIP( 2046 "2620:0:1000:3103:ffff:ffff:ffff:ffff")); 2047 EXPECT_FALSE(database_->ContainsMalwareIP("2620:0:1000:3104::")); 2048 2049 EXPECT_FALSE(database_->ContainsMalwareIP("fe80::21a:a0ff:fe10:786d")); 2050 EXPECT_TRUE(database_->ContainsMalwareIP("fe80::31a:a0ff:fe10:786e")); 2051 EXPECT_FALSE(database_->ContainsMalwareIP("fe80::21a:a0ff:fe10:786f")); 2052 2053 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.121.255")); 2054 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.122.0")); 2055 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.1.122.1")); 2056 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.122.255")); 2057 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.123.0")); 2058 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.123.255")); 2059 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.124.0")); 2060 2061 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.127.255")); 2062 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.0")); 2063 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.1.128.1")); 2064 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.128.255")); 2065 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.0")); 2066 EXPECT_TRUE(database_->ContainsMalwareIP("192.1.255.255")); 2067 EXPECT_FALSE(database_->ContainsMalwareIP("192.2.0.0")); 2068 } 2069 2070 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) { 2071 std::vector<SBListChunkRanges> lists; 2072 ASSERT_TRUE(database_->UpdateStarted(&lists)); 2073 2074 // Add a host-level hit. 2075 { 2076 ScopedVector<SBChunkData> chunks; 2077 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/")); 2078 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2079 } 2080 2081 // Add a specific fullhash. 2082 static const char kWhateverMalware[] = "www.whatever.com/malware.html"; 2083 { 2084 ScopedVector<SBChunkData> chunks; 2085 chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware)); 2086 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2087 } 2088 2089 // Add a fullhash which has a prefix collision for a known url. 2090 static const char kExampleFine[] = "www.example.com/fine.html"; 2091 static const char kExampleCollision[] = 2092 "www.example.com/3123364814/malware.htm"; 2093 ASSERT_EQ(SBPrefixForString(kExampleFine), 2094 SBPrefixForString(kExampleCollision)); 2095 { 2096 ScopedVector<SBChunkData> chunks; 2097 chunks.push_back(AddChunkFullHashValue(3, kExampleCollision)); 2098 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); 2099 } 2100 2101 database_->UpdateFinished(true); 2102 2103 std::vector<SBPrefix> prefix_hits; 2104 std::vector<SBFullHashResult> cache_hits; 2105 2106 // Anything will hit the host prefix. 2107 EXPECT_TRUE(database_->ContainsBrowseUrl( 2108 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); 2109 ASSERT_EQ(1U, prefix_hits.size()); 2110 EXPECT_EQ(SBPrefixForString("www.evil.com/"), prefix_hits[0]); 2111 EXPECT_TRUE(cache_hits.empty()); 2112 2113 // Hit the specific URL prefix. 2114 EXPECT_TRUE(database_->ContainsBrowseUrl( 2115 GURL(std::string("http://") + kWhateverMalware), 2116 &prefix_hits, &cache_hits)); 2117 ASSERT_EQ(1U, prefix_hits.size()); 2118 EXPECT_EQ(SBPrefixForString(kWhateverMalware), prefix_hits[0]); 2119 EXPECT_TRUE(cache_hits.empty()); 2120 2121 // Other URLs at that host are fine. 2122 EXPECT_FALSE(database_->ContainsBrowseUrl( 2123 GURL("http://www.whatever.com/fine.html"), &prefix_hits, &cache_hits)); 2124 EXPECT_TRUE(prefix_hits.empty()); 2125 EXPECT_TRUE(cache_hits.empty()); 2126 2127 // Hit the specific URL full hash. 2128 EXPECT_TRUE(database_->ContainsBrowseUrl( 2129 GURL(std::string("http://") + kExampleCollision), 2130 &prefix_hits, &cache_hits)); 2131 ASSERT_EQ(1U, prefix_hits.size()); 2132 EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]); 2133 EXPECT_TRUE(cache_hits.empty()); 2134 2135 // This prefix collides, but no full hash match. 2136 EXPECT_FALSE(database_->ContainsBrowseUrl( 2137 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); 2138 } 2139
