OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 // | 4 // |
5 // Unit tests for the SafeBrowsing storage system. | 5 // Unit tests for the SafeBrowsing storage system. |
6 | 6 |
7 #include "chrome/browser/safe_browsing/safe_browsing_database.h" | 7 #include "chrome/browser/safe_browsing/safe_browsing_database.h" |
8 | 8 |
9 #include "base/files/file_util.h" | 9 #include "base/files/file_util.h" |
10 #include "base/files/scoped_temp_dir.h" | 10 #include "base/files/scoped_temp_dir.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 #include "url/gurl.h" | 25 #include "url/gurl.h" |
26 | 26 |
27 using base::Time; | 27 using base::Time; |
28 using base::TimeDelta; | 28 using base::TimeDelta; |
29 | 29 |
30 namespace { | 30 namespace { |
31 | 31 |
32 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45); | 32 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45); |
33 | 33 |
34 SBPrefix SBPrefixForString(const std::string& str) { | 34 SBPrefix SBPrefixForString(const std::string& str) { |
35 return SBFullHashForString(str).prefix; | 35 return safe_browsing::SBFullHashForString(str).prefix; |
36 } | 36 } |
37 | 37 |
38 // Construct a full hash which has the given prefix, with the given | 38 // Construct a full hash which has the given prefix, with the given |
39 // suffix data coming after the prefix. | 39 // suffix data coming after the prefix. |
40 SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix, | 40 SBFullHash SBFullHashForPrefixAndSuffix(SBPrefix prefix, |
41 const base::StringPiece& suffix) { | 41 const base::StringPiece& suffix) { |
42 SBFullHash full_hash; | 42 SBFullHash full_hash; |
43 memset(&full_hash, 0, sizeof(SBFullHash)); | 43 memset(&full_hash, 0, sizeof(SBFullHash)); |
44 full_hash.prefix = prefix; | 44 full_hash.prefix = prefix; |
45 CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash)); | 45 CHECK_LE(suffix.size() + sizeof(SBPrefix), sizeof(SBFullHash)); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) { | 128 SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) { |
129 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, | 129 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, |
130 safe_browsing::ChunkData::FULL_32B, | 130 safe_browsing::ChunkData::FULL_32B, |
131 &full_hash, sizeof(full_hash), | 131 &full_hash, sizeof(full_hash), |
132 std::vector<int>()); | 132 std::vector<int>()); |
133 } | 133 } |
134 | 134 |
135 // Generate an add chunk with a full hash generated from |value|. | 135 // Generate an add chunk with a full hash generated from |value|. |
136 SBChunkData* AddChunkFullHashValue(int chunk_number, | 136 SBChunkData* AddChunkFullHashValue(int chunk_number, |
137 const std::string& value) { | 137 const std::string& value) { |
138 return AddChunkFullHash(chunk_number, SBFullHashForString(value)); | 138 return AddChunkFullHash(chunk_number, |
| 139 safe_browsing::SBFullHashForString(value)); |
139 } | 140 } |
140 | 141 |
141 // Generate an add chunk with two full hashes. | 142 // Generate an add chunk with two full hashes. |
142 SBChunkData* AddChunkFullHash2Value(int chunk_number, | 143 SBChunkData* AddChunkFullHash2Value(int chunk_number, |
143 const std::string& value1, | 144 const std::string& value1, |
144 const std::string& value2) { | 145 const std::string& value2) { |
145 const SBFullHash full_hashes[2] = { | 146 const SBFullHash full_hashes[2] = { |
146 SBFullHashForString(value1), | 147 safe_browsing::SBFullHashForString(value1), |
147 SBFullHashForString(value2), | 148 safe_browsing::SBFullHashForString(value2), |
148 }; | 149 }; |
149 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, | 150 return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD, |
150 safe_browsing::ChunkData::FULL_32B, | 151 safe_browsing::ChunkData::FULL_32B, |
151 &full_hashes[0], sizeof(full_hashes), | 152 &full_hashes[0], sizeof(full_hashes), |
152 std::vector<int>()); | 153 std::vector<int>()); |
153 } | 154 } |
154 | 155 |
155 // Generate a sub chunk with a prefix generated from |value|. | 156 // Generate a sub chunk with a prefix generated from |value|. |
156 SBChunkData* SubChunkPrefixValue(int chunk_number, | 157 SBChunkData* SubChunkPrefixValue(int chunk_number, |
157 const std::string& value, | 158 const std::string& value, |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
190 safe_browsing::ChunkData::FULL_32B, | 191 safe_browsing::ChunkData::FULL_32B, |
191 &full_hash, sizeof(full_hash), | 192 &full_hash, sizeof(full_hash), |
192 std::vector<int>(1, add_chunk_number)); | 193 std::vector<int>(1, add_chunk_number)); |
193 } | 194 } |
194 | 195 |
195 // Generate a sub chunk with a full hash generated from |value|. | 196 // Generate a sub chunk with a full hash generated from |value|. |
196 SBChunkData* SubChunkFullHashValue(int chunk_number, | 197 SBChunkData* SubChunkFullHashValue(int chunk_number, |
197 const std::string& value, | 198 const std::string& value, |
198 int add_chunk_number) { | 199 int add_chunk_number) { |
199 return SubChunkFullHash(chunk_number, | 200 return SubChunkFullHash(chunk_number, |
200 SBFullHashForString(value), | 201 safe_browsing::SBFullHashForString(value), |
201 add_chunk_number); | 202 add_chunk_number); |
202 } | 203 } |
203 | 204 |
204 // Generate an add chunk with a single full hash for the ip blacklist. | 205 // Generate an add chunk with a single full hash for the ip blacklist. |
205 SBChunkData* AddChunkHashedIpValue(int chunk_number, | 206 SBChunkData* AddChunkHashedIpValue(int chunk_number, |
206 const std::string& ip_str, | 207 const std::string& ip_str, |
207 size_t prefix_size) { | 208 size_t prefix_size) { |
208 const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size); | 209 const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size); |
209 EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size()); | 210 EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size()); |
210 SBFullHash full_hash; | 211 SBFullHash full_hash; |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
344 // Tests retrieving list name information. | 345 // Tests retrieving list name information. |
345 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) { | 346 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) { |
346 std::vector<SBListChunkRanges> lists; | 347 std::vector<SBListChunkRanges> lists; |
347 ScopedVector<SBChunkData> chunks; | 348 ScopedVector<SBChunkData> chunks; |
348 | 349 |
349 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); | 350 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); |
350 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); | 351 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); |
351 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html")); | 352 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html")); |
352 | 353 |
353 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 354 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
354 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 355 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
355 database_->UpdateFinished(true); | 356 database_->UpdateFinished(true); |
356 | 357 |
357 GetListsInfo(&lists); | 358 GetListsInfo(&lists); |
358 ASSERT_LE(1U, lists.size()); | 359 ASSERT_LE(1U, lists.size()); |
359 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 360 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
360 EXPECT_EQ("1-3", lists[0].adds); | 361 EXPECT_EQ("1-3", lists[0].adds); |
361 EXPECT_TRUE(lists[0].subs.empty()); | 362 EXPECT_TRUE(lists[0].subs.empty()); |
362 | 363 |
363 // Insert a malware sub chunk. | 364 // Insert a malware sub chunk. |
364 chunks.clear(); | 365 chunks.clear(); |
365 chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19)); | 366 chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19)); |
366 | 367 |
367 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 368 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
368 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 369 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
369 database_->UpdateFinished(true); | 370 database_->UpdateFinished(true); |
370 | 371 |
371 GetListsInfo(&lists); | 372 GetListsInfo(&lists); |
372 ASSERT_LE(1U, lists.size()); | 373 ASSERT_LE(1U, lists.size()); |
373 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 374 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
374 EXPECT_EQ("1-3", lists[0].adds); | 375 EXPECT_EQ("1-3", lists[0].adds); |
375 EXPECT_EQ("7", lists[0].subs); | 376 EXPECT_EQ("7", lists[0].subs); |
376 if (lists.size() == 2) { | 377 if (lists.size() == 2) { |
377 // Old style database won't have the second entry since it creates the lists | 378 // Old style database won't have the second entry since it creates the lists |
378 // when it receives an update containing that list. The filter-based | 379 // when it receives an update containing that list. The filter-based |
379 // database has these values hard coded. | 380 // database has these values hard coded. |
380 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); | 381 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name); |
381 EXPECT_TRUE(lists[1].adds.empty()); | 382 EXPECT_TRUE(lists[1].adds.empty()); |
382 EXPECT_TRUE(lists[1].subs.empty()); | 383 EXPECT_TRUE(lists[1].subs.empty()); |
383 } | 384 } |
384 | 385 |
385 // Add phishing chunks. | 386 // Add phishing chunks. |
386 chunks.clear(); | 387 chunks.clear(); |
387 chunks.push_back(AddChunkPrefixValue(47, "www.evil.com/phishing.html")); | 388 chunks.push_back(AddChunkPrefixValue(47, "www.evil.com/phishing.html")); |
388 chunks.push_back( | 389 chunks.push_back( |
389 SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999)); | 390 SubChunkPrefixValue(200, "www.phishy.com/notevil1.html", 1999)); |
390 chunks.push_back( | 391 chunks.push_back( |
391 SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999)); | 392 SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999)); |
392 | 393 |
393 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 394 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
394 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); | 395 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get()); |
395 database_->UpdateFinished(true); | 396 database_->UpdateFinished(true); |
396 | 397 |
397 GetListsInfo(&lists); | 398 GetListsInfo(&lists); |
398 ASSERT_LE(2U, lists.size()); | 399 ASSERT_LE(2U, lists.size()); |
399 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 400 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
400 EXPECT_EQ("1-3", lists[0].adds); | 401 EXPECT_EQ("1-3", lists[0].adds); |
401 EXPECT_EQ("7", lists[0].subs); | 402 EXPECT_EQ("7", lists[0].subs); |
402 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); | 403 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name); |
403 EXPECT_EQ("47", lists[1].adds); | 404 EXPECT_EQ("47", lists[1].adds); |
404 EXPECT_EQ("200-201", lists[1].subs); | 405 EXPECT_EQ("200-201", lists[1].subs); |
405 } | 406 } |
406 | 407 |
407 TEST_F(SafeBrowsingDatabaseTest, ListNames) { | 408 TEST_F(SafeBrowsingDatabaseTest, ListNames) { |
408 ScopedVector<SBChunkData> chunks; | 409 ScopedVector<SBChunkData> chunks; |
409 | 410 |
410 std::vector<SBListChunkRanges> lists; | 411 std::vector<SBListChunkRanges> lists; |
411 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 412 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
412 | 413 |
413 // Insert malware, phish, binurl and bindownload add chunks. | 414 // Insert malware, phish, binurl and bindownload add chunks. |
414 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); | 415 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); |
415 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 416 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
416 | 417 |
417 chunks.clear(); | 418 chunks.clear(); |
418 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); | 419 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); |
419 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); | 420 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get()); |
420 | 421 |
421 chunks.clear(); | 422 chunks.clear(); |
422 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html")); | 423 chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html")); |
423 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); | 424 database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get()); |
424 | 425 |
425 chunks.clear(); | 426 chunks.clear(); |
426 chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html")); | 427 chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html")); |
427 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get()); | 428 database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get()); |
428 | 429 |
429 chunks.clear(); | 430 chunks.clear(); |
430 chunks.push_back(AddChunkFullHashValue(6, "www.download.com/")); | 431 chunks.push_back(AddChunkFullHashValue(6, "www.download.com/")); |
431 database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks.get()); | 432 database_->InsertChunks(safe_browsing::kDownloadWhiteList, chunks.get()); |
432 | 433 |
433 chunks.clear(); | 434 chunks.clear(); |
434 chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/")); | 435 chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/")); |
435 database_->InsertChunks(safe_browsing_util::kInclusionWhitelist, | 436 database_->InsertChunks(safe_browsing::kInclusionWhitelist, |
436 chunks.get()); | 437 chunks.get()); |
437 | 438 |
438 chunks.clear(); | 439 chunks.clear(); |
439 chunks.push_back(AddChunkFullHashValue(8, | 440 chunks.push_back(AddChunkFullHashValue(8, |
440 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" | 441 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
441 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); | 442 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); |
442 database_->InsertChunks(safe_browsing_util::kExtensionBlacklist, | 443 database_->InsertChunks(safe_browsing::kExtensionBlacklist, |
443 chunks.get()); | 444 chunks.get()); |
444 | 445 |
445 chunks.clear(); | 446 chunks.clear(); |
446 chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120)); | 447 chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120)); |
447 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); | 448 database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get()); |
448 | 449 |
449 chunks.clear(); | 450 chunks.clear(); |
450 chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html")); | 451 chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html")); |
451 database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get()); | 452 database_->InsertChunks(safe_browsing::kUnwantedUrlList, chunks.get()); |
452 | 453 |
453 database_->UpdateFinished(true); | 454 database_->UpdateFinished(true); |
454 | 455 |
455 GetListsInfo(&lists); | 456 GetListsInfo(&lists); |
456 ASSERT_EQ(9U, lists.size()); | 457 ASSERT_EQ(9U, lists.size()); |
457 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 458 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
458 EXPECT_EQ("1", lists[0].adds); | 459 EXPECT_EQ("1", lists[0].adds); |
459 EXPECT_TRUE(lists[0].subs.empty()); | 460 EXPECT_TRUE(lists[0].subs.empty()); |
460 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); | 461 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name); |
461 EXPECT_EQ("2", lists[1].adds); | 462 EXPECT_EQ("2", lists[1].adds); |
462 EXPECT_TRUE(lists[1].subs.empty()); | 463 EXPECT_TRUE(lists[1].subs.empty()); |
463 EXPECT_EQ(safe_browsing_util::kBinUrlList, lists[2].name); | 464 EXPECT_EQ(safe_browsing::kBinUrlList, lists[2].name); |
464 EXPECT_EQ("3", lists[2].adds); | 465 EXPECT_EQ("3", lists[2].adds); |
465 EXPECT_TRUE(lists[2].subs.empty()); | 466 EXPECT_TRUE(lists[2].subs.empty()); |
466 EXPECT_EQ(safe_browsing_util::kCsdWhiteList, lists[3].name); | 467 EXPECT_EQ(safe_browsing::kCsdWhiteList, lists[3].name); |
467 EXPECT_EQ("5", lists[3].adds); | 468 EXPECT_EQ("5", lists[3].adds); |
468 EXPECT_TRUE(lists[3].subs.empty()); | 469 EXPECT_TRUE(lists[3].subs.empty()); |
469 EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name); | 470 EXPECT_EQ(safe_browsing::kDownloadWhiteList, lists[4].name); |
470 EXPECT_EQ("6", lists[4].adds); | 471 EXPECT_EQ("6", lists[4].adds); |
471 EXPECT_TRUE(lists[4].subs.empty()); | 472 EXPECT_TRUE(lists[4].subs.empty()); |
472 EXPECT_EQ(safe_browsing_util::kInclusionWhitelist, lists[5].name); | 473 EXPECT_EQ(safe_browsing::kInclusionWhitelist, lists[5].name); |
473 EXPECT_EQ("7", lists[5].adds); | 474 EXPECT_EQ("7", lists[5].adds); |
474 EXPECT_TRUE(lists[5].subs.empty()); | 475 EXPECT_TRUE(lists[5].subs.empty()); |
475 EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[6].name); | 476 EXPECT_EQ(safe_browsing::kExtensionBlacklist, lists[6].name); |
476 EXPECT_EQ("8", lists[6].adds); | 477 EXPECT_EQ("8", lists[6].adds); |
477 EXPECT_TRUE(lists[6].subs.empty()); | 478 EXPECT_TRUE(lists[6].subs.empty()); |
478 EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name); | 479 EXPECT_EQ(safe_browsing::kIPBlacklist, lists[7].name); |
479 EXPECT_EQ("10", lists[7].adds); | 480 EXPECT_EQ("10", lists[7].adds); |
480 EXPECT_TRUE(lists[7].subs.empty()); | 481 EXPECT_TRUE(lists[7].subs.empty()); |
481 EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name); | 482 EXPECT_EQ(safe_browsing::kUnwantedUrlList, lists[8].name); |
482 EXPECT_EQ("11", lists[8].adds); | 483 EXPECT_EQ("11", lists[8].adds); |
483 EXPECT_TRUE(lists[8].subs.empty()); | 484 EXPECT_TRUE(lists[8].subs.empty()); |
484 | 485 |
485 database_.reset(); | 486 database_.reset(); |
486 } | 487 } |
487 | 488 |
488 // Checks database reading and writing for browse and unwanted PrefixSets. | 489 // Checks database reading and writing for browse and unwanted PrefixSets. |
489 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) { | 490 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) { |
490 struct TestCase { | 491 struct TestCase { |
491 using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)( | 492 using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)( |
492 const GURL& url, | 493 const GURL& url, |
493 std::vector<SBPrefix>* prefix_hits, | 494 std::vector<SBPrefix>* prefix_hits, |
494 std::vector<SBFullHashResult>* cache_hits); | 495 std::vector<SBFullHashResult>* cache_hits); |
495 | 496 |
496 const char* test_list_name; | 497 const char* test_list_name; |
497 size_t expected_list_index; | 498 size_t expected_list_index; |
498 TestListContainsBadUrl test_list_contains_bad_url; | 499 TestListContainsBadUrl test_list_contains_bad_url; |
499 } const kTestCases[] { | 500 } const kTestCases[] { |
500 { safe_browsing_util::kMalwareList, 0U, | 501 { safe_browsing::kMalwareList, 0U, |
501 &SafeBrowsingDatabase::ContainsBrowseUrl }, | 502 &SafeBrowsingDatabase::ContainsBrowseUrl }, |
502 { safe_browsing_util::kPhishingList, 1U, | 503 { safe_browsing::kPhishingList, 1U, |
503 &SafeBrowsingDatabase::ContainsBrowseUrl }, | 504 &SafeBrowsingDatabase::ContainsBrowseUrl }, |
504 { safe_browsing_util::kUnwantedUrlList, 8U, | 505 { safe_browsing::kUnwantedUrlList, 8U, |
505 &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl }, | 506 &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl }, |
506 }; | 507 }; |
507 | 508 |
508 for (const auto& test_case : kTestCases) { | 509 for (const auto& test_case : kTestCases) { |
509 SCOPED_TRACE(std::string("Tested list at fault => ") + | 510 SCOPED_TRACE(std::string("Tested list at fault => ") + |
510 test_case.test_list_name); | 511 test_case.test_list_name); |
511 | 512 |
512 std::vector<SBListChunkRanges> lists; | 513 std::vector<SBListChunkRanges> lists; |
513 ScopedVector<SBChunkData> chunks; | 514 ScopedVector<SBChunkData> chunks; |
514 | 515 |
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
750 | 751 |
751 // Populate with a couple of normal chunks. | 752 // Populate with a couple of normal chunks. |
752 chunks.push_back(AddChunkPrefix2Value(1, | 753 chunks.push_back(AddChunkPrefix2Value(1, |
753 "www.test.com/test1.html", | 754 "www.test.com/test1.html", |
754 "www.test.com/test2.html")); | 755 "www.test.com/test2.html")); |
755 chunks.push_back(AddChunkPrefix2Value(10, | 756 chunks.push_back(AddChunkPrefix2Value(10, |
756 "www.random.com/random1.html", | 757 "www.random.com/random1.html", |
757 "www.random.com/random2.html")); | 758 "www.random.com/random2.html")); |
758 | 759 |
759 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 760 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
760 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 761 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
761 database_->UpdateFinished(true); | 762 database_->UpdateFinished(true); |
762 | 763 |
763 // Add an empty ADD and SUB chunk. | 764 // Add an empty ADD and SUB chunk. |
764 GetListsInfo(&lists); | 765 GetListsInfo(&lists); |
765 ASSERT_LE(1U, lists.size()); | 766 ASSERT_LE(1U, lists.size()); |
766 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 767 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
767 EXPECT_EQ("1,10", lists[0].adds); | 768 EXPECT_EQ("1,10", lists[0].adds); |
768 EXPECT_TRUE(lists[0].subs.empty()); | 769 EXPECT_TRUE(lists[0].subs.empty()); |
769 | 770 |
770 chunks.clear(); | 771 chunks.clear(); |
771 chunks.push_back(BuildChunk(19, safe_browsing::ChunkData::ADD, | 772 chunks.push_back(BuildChunk(19, safe_browsing::ChunkData::ADD, |
772 safe_browsing::ChunkData::PREFIX_4B, | 773 safe_browsing::ChunkData::PREFIX_4B, |
773 NULL, 0, std::vector<int>())); | 774 NULL, 0, std::vector<int>())); |
774 chunks.push_back(BuildChunk(7, safe_browsing::ChunkData::SUB, | 775 chunks.push_back(BuildChunk(7, safe_browsing::ChunkData::SUB, |
775 safe_browsing::ChunkData::PREFIX_4B, | 776 safe_browsing::ChunkData::PREFIX_4B, |
776 NULL, 0, std::vector<int>())); | 777 NULL, 0, std::vector<int>())); |
777 | 778 |
778 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 779 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
779 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 780 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
780 database_->UpdateFinished(true); | 781 database_->UpdateFinished(true); |
781 | 782 |
782 GetListsInfo(&lists); | 783 GetListsInfo(&lists); |
783 ASSERT_LE(1U, lists.size()); | 784 ASSERT_LE(1U, lists.size()); |
784 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 785 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
785 EXPECT_EQ("1,10,19", lists[0].adds); | 786 EXPECT_EQ("1,10,19", lists[0].adds); |
786 EXPECT_EQ("7", lists[0].subs); | 787 EXPECT_EQ("7", lists[0].subs); |
787 | 788 |
788 // Add an empty chunk along with a couple that contain data. This should | 789 // Add an empty chunk along with a couple that contain data. This should |
789 // result in the chunk range being reduced in size. | 790 // result in the chunk range being reduced in size. |
790 chunks.clear(); | 791 chunks.clear(); |
791 chunks.push_back(AddChunkPrefixValue(20, "www.notempty.com/full1.html")); | 792 chunks.push_back(AddChunkPrefixValue(20, "www.notempty.com/full1.html")); |
792 chunks.push_back(BuildChunk(21, safe_browsing::ChunkData::ADD, | 793 chunks.push_back(BuildChunk(21, safe_browsing::ChunkData::ADD, |
793 safe_browsing::ChunkData::PREFIX_4B, | 794 safe_browsing::ChunkData::PREFIX_4B, |
794 NULL, 0, std::vector<int>())); | 795 NULL, 0, std::vector<int>())); |
795 chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html")); | 796 chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html")); |
796 | 797 |
797 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 798 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
798 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 799 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
799 database_->UpdateFinished(true); | 800 database_->UpdateFinished(true); |
800 | 801 |
801 std::vector<SBPrefix> prefix_hits; | 802 std::vector<SBPrefix> prefix_hits; |
802 std::vector<SBFullHashResult> cache_hits; | 803 std::vector<SBFullHashResult> cache_hits; |
803 EXPECT_TRUE(database_->ContainsBrowseUrl( | 804 EXPECT_TRUE(database_->ContainsBrowseUrl( |
804 GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits)); | 805 GURL("http://www.notempty.com/full1.html"), &prefix_hits, &cache_hits)); |
805 EXPECT_TRUE(database_->ContainsBrowseUrl( | 806 EXPECT_TRUE(database_->ContainsBrowseUrl( |
806 GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits)); | 807 GURL("http://www.notempty.com/full2.html"), &prefix_hits, &cache_hits)); |
807 | 808 |
808 GetListsInfo(&lists); | 809 GetListsInfo(&lists); |
809 ASSERT_LE(1U, lists.size()); | 810 ASSERT_LE(1U, lists.size()); |
810 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 811 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
811 EXPECT_EQ("1,10,19-22", lists[0].adds); | 812 EXPECT_EQ("1,10,19-22", lists[0].adds); |
812 EXPECT_EQ("7", lists[0].subs); | 813 EXPECT_EQ("7", lists[0].subs); |
813 | 814 |
814 // Handle AddDel and SubDel commands for empty chunks. | 815 // Handle AddDel and SubDel commands for empty chunks. |
815 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 816 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
816 AddDelChunk(safe_browsing_util::kMalwareList, 21); | 817 AddDelChunk(safe_browsing::kMalwareList, 21); |
817 database_->UpdateFinished(true); | 818 database_->UpdateFinished(true); |
818 | 819 |
819 GetListsInfo(&lists); | 820 GetListsInfo(&lists); |
820 ASSERT_LE(1U, lists.size()); | 821 ASSERT_LE(1U, lists.size()); |
821 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 822 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
822 EXPECT_EQ("1,10,19-20,22", lists[0].adds); | 823 EXPECT_EQ("1,10,19-20,22", lists[0].adds); |
823 EXPECT_EQ("7", lists[0].subs); | 824 EXPECT_EQ("7", lists[0].subs); |
824 | 825 |
825 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 826 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
826 SubDelChunk(safe_browsing_util::kMalwareList, 7); | 827 SubDelChunk(safe_browsing::kMalwareList, 7); |
827 database_->UpdateFinished(true); | 828 database_->UpdateFinished(true); |
828 | 829 |
829 GetListsInfo(&lists); | 830 GetListsInfo(&lists); |
830 ASSERT_LE(1U, lists.size()); | 831 ASSERT_LE(1U, lists.size()); |
831 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 832 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
832 EXPECT_EQ("1,10,19-20,22", lists[0].adds); | 833 EXPECT_EQ("1,10,19-20,22", lists[0].adds); |
833 EXPECT_TRUE(lists[0].subs.empty()); | 834 EXPECT_TRUE(lists[0].subs.empty()); |
834 } | 835 } |
835 | 836 |
836 // Utility function for setting up the database for the caching test. | 837 // Utility function for setting up the database for the caching test. |
837 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() { | 838 void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() { |
838 // Add a couple prefixes. | 839 // Add a couple prefixes. |
839 ScopedVector<SBChunkData> chunks; | 840 ScopedVector<SBChunkData> chunks; |
840 chunks.push_back(AddChunkPrefix2Value(1, | 841 chunks.push_back(AddChunkPrefix2Value(1, |
841 "www.evil.com/phishing.html", | 842 "www.evil.com/phishing.html", |
842 "www.evil.com/malware.html")); | 843 "www.evil.com/malware.html")); |
843 | 844 |
844 std::vector<SBListChunkRanges> lists; | 845 std::vector<SBListChunkRanges> lists; |
845 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 846 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
846 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 847 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
847 database_->UpdateFinished(true); | 848 database_->UpdateFinished(true); |
848 | 849 |
849 // Cache should be cleared after updating. | 850 // Cache should be cleared after updating. |
850 EXPECT_TRUE( | 851 EXPECT_TRUE( |
851 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); | 852 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); |
852 | 853 |
853 SBFullHashResult full_hash; | 854 SBFullHashResult full_hash; |
854 full_hash.list_id = safe_browsing_util::MALWARE; | 855 full_hash.list_id = safe_browsing::MALWARE; |
855 | 856 |
856 std::vector<SBFullHashResult> results; | 857 std::vector<SBFullHashResult> results; |
857 std::vector<SBPrefix> prefixes; | 858 std::vector<SBPrefix> prefixes; |
858 | 859 |
859 // Add a fullhash result for each prefix. | 860 // Add a fullhash result for each prefix. |
860 full_hash.hash = SBFullHashForString("www.evil.com/phishing.html"); | 861 full_hash.hash = |
| 862 safe_browsing::SBFullHashForString("www.evil.com/phishing.html"); |
861 results.push_back(full_hash); | 863 results.push_back(full_hash); |
862 prefixes.push_back(full_hash.hash.prefix); | 864 prefixes.push_back(full_hash.hash.prefix); |
863 | 865 |
864 full_hash.hash = SBFullHashForString("www.evil.com/malware.html"); | 866 full_hash.hash = |
| 867 safe_browsing::SBFullHashForString("www.evil.com/malware.html"); |
865 results.push_back(full_hash); | 868 results.push_back(full_hash); |
866 prefixes.push_back(full_hash.hash.prefix); | 869 prefixes.push_back(full_hash.hash.prefix); |
867 | 870 |
868 database_->CacheHashResults(prefixes, results, kCacheLifetime); | 871 database_->CacheHashResults(prefixes, results, kCacheLifetime); |
869 } | 872 } |
870 | 873 |
871 TEST_F(SafeBrowsingDatabaseTest, HashCaching) { | 874 TEST_F(SafeBrowsingDatabaseTest, HashCaching) { |
872 PopulateDatabaseForCacheTest(); | 875 PopulateDatabaseForCacheTest(); |
873 | 876 |
874 // We should have both full hashes in the cache. | 877 // We should have both full hashes in the cache. |
875 EXPECT_EQ(2U, | 878 EXPECT_EQ(2U, |
876 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->size()); | 879 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->size()); |
877 | 880 |
878 // Test the cache lookup for the first prefix. | 881 // Test the cache lookup for the first prefix. |
879 std::vector<SBPrefix> prefix_hits; | 882 std::vector<SBPrefix> prefix_hits; |
880 std::vector<SBFullHashResult> cache_hits; | 883 std::vector<SBFullHashResult> cache_hits; |
881 EXPECT_TRUE(database_->ContainsBrowseUrl( | 884 EXPECT_TRUE(database_->ContainsBrowseUrl( |
882 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); | 885 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); |
883 EXPECT_TRUE(prefix_hits.empty()); | 886 EXPECT_TRUE(prefix_hits.empty()); |
884 ASSERT_EQ(1U, cache_hits.size()); | 887 ASSERT_EQ(1U, cache_hits.size()); |
885 EXPECT_TRUE(SBFullHashEqual( | 888 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
886 cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html"))); | 889 cache_hits[0].hash, |
| 890 safe_browsing::SBFullHashForString("www.evil.com/phishing.html"))); |
887 | 891 |
888 prefix_hits.clear(); | 892 prefix_hits.clear(); |
889 cache_hits.clear(); | 893 cache_hits.clear(); |
890 | 894 |
891 // Test the cache lookup for the second prefix. | 895 // Test the cache lookup for the second prefix. |
892 EXPECT_TRUE(database_->ContainsBrowseUrl( | 896 EXPECT_TRUE(database_->ContainsBrowseUrl( |
893 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); | 897 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); |
894 EXPECT_TRUE(prefix_hits.empty()); | 898 EXPECT_TRUE(prefix_hits.empty()); |
895 ASSERT_EQ(1U, cache_hits.size()); | 899 ASSERT_EQ(1U, cache_hits.size()); |
896 EXPECT_TRUE(SBFullHashEqual( | 900 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
897 cache_hits[0].hash, SBFullHashForString("www.evil.com/malware.html"))); | 901 cache_hits[0].hash, |
| 902 safe_browsing::SBFullHashForString("www.evil.com/malware.html"))); |
898 | 903 |
899 prefix_hits.clear(); | 904 prefix_hits.clear(); |
900 cache_hits.clear(); | 905 cache_hits.clear(); |
901 | 906 |
902 // Test removing a prefix via a sub chunk. | 907 // Test removing a prefix via a sub chunk. |
903 ScopedVector<SBChunkData> chunks; | 908 ScopedVector<SBChunkData> chunks; |
904 chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1)); | 909 chunks.push_back(SubChunkPrefixValue(2, "www.evil.com/phishing.html", 1)); |
905 | 910 |
906 std::vector<SBListChunkRanges> lists; | 911 std::vector<SBListChunkRanges> lists; |
907 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 912 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
908 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 913 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
909 database_->UpdateFinished(true); | 914 database_->UpdateFinished(true); |
910 | 915 |
911 // This prefix should still be there, but cached fullhash should be gone. | 916 // This prefix should still be there, but cached fullhash should be gone. |
912 EXPECT_TRUE(database_->ContainsBrowseUrl( | 917 EXPECT_TRUE(database_->ContainsBrowseUrl( |
913 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); | 918 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); |
914 ASSERT_EQ(1U, prefix_hits.size()); | 919 ASSERT_EQ(1U, prefix_hits.size()); |
915 EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefix_hits[0]); | 920 EXPECT_EQ(SBPrefixForString("www.evil.com/malware.html"), prefix_hits[0]); |
916 EXPECT_TRUE(cache_hits.empty()); | 921 EXPECT_TRUE(cache_hits.empty()); |
917 prefix_hits.clear(); | 922 prefix_hits.clear(); |
918 cache_hits.clear(); | 923 cache_hits.clear(); |
919 | 924 |
920 // This prefix should be gone. | 925 // This prefix should be gone. |
921 EXPECT_FALSE(database_->ContainsBrowseUrl( | 926 EXPECT_FALSE(database_->ContainsBrowseUrl( |
922 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); | 927 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); |
923 prefix_hits.clear(); | 928 prefix_hits.clear(); |
924 cache_hits.clear(); | 929 cache_hits.clear(); |
925 | 930 |
926 // Test that an AddDel for the original chunk removes the last cached entry. | 931 // Test that an AddDel for the original chunk removes the last cached entry. |
927 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 932 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
928 AddDelChunk(safe_browsing_util::kMalwareList, 1); | 933 AddDelChunk(safe_browsing::kMalwareList, 1); |
929 database_->UpdateFinished(true); | 934 database_->UpdateFinished(true); |
930 EXPECT_FALSE(database_->ContainsBrowseUrl( | 935 EXPECT_FALSE(database_->ContainsBrowseUrl( |
931 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); | 936 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); |
932 EXPECT_TRUE( | 937 EXPECT_TRUE( |
933 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); | 938 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); |
934 prefix_hits.clear(); | 939 prefix_hits.clear(); |
935 cache_hits.clear(); | 940 cache_hits.clear(); |
936 | 941 |
937 // Test that the cache won't return expired values. First we have to adjust | 942 // Test that the cache won't return expired values. First we have to adjust |
938 // the cached entries' received time to make them older, since the database | 943 // the cached entries' received time to make them older, since the database |
(...skipping 21 matching lines...) Expand all Loading... |
960 // This entry should still exist. | 965 // This entry should still exist. |
961 EXPECT_TRUE(database_->ContainsBrowseUrl( | 966 EXPECT_TRUE(database_->ContainsBrowseUrl( |
962 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); | 967 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); |
963 EXPECT_TRUE(prefix_hits.empty()); | 968 EXPECT_TRUE(prefix_hits.empty()); |
964 EXPECT_EQ(1U, cache_hits.size()); | 969 EXPECT_EQ(1U, cache_hits.size()); |
965 | 970 |
966 // Testing prefix miss caching. First, we clear out the existing database, | 971 // Testing prefix miss caching. First, we clear out the existing database, |
967 // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate | 972 // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate |
968 // chunks. | 973 // chunks. |
969 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 974 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
970 AddDelChunk(safe_browsing_util::kMalwareList, 1); | 975 AddDelChunk(safe_browsing::kMalwareList, 1); |
971 database_->UpdateFinished(true); | 976 database_->UpdateFinished(true); |
972 | 977 |
973 // Cache should be cleared after updating. | 978 // Cache should be cleared after updating. |
974 EXPECT_TRUE(hash_cache->empty()); | 979 EXPECT_TRUE(hash_cache->empty()); |
975 | 980 |
976 std::vector<SBPrefix> prefix_misses; | 981 std::vector<SBPrefix> prefix_misses; |
977 std::vector<SBFullHashResult> empty_full_hash; | 982 std::vector<SBFullHashResult> empty_full_hash; |
978 prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html")); | 983 prefix_misses.push_back(SBPrefixForString("http://www.bad.com/malware.html")); |
979 prefix_misses.push_back( | 984 prefix_misses.push_back( |
980 SBPrefixForString("http://www.bad.com/phishing.html")); | 985 SBPrefixForString("http://www.bad.com/phishing.html")); |
(...skipping 28 matching lines...) Expand all Loading... |
1009 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); | 1014 GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits)); |
1010 prefix_hits.clear(); | 1015 prefix_hits.clear(); |
1011 cache_hits.clear(); | 1016 cache_hits.clear(); |
1012 | 1017 |
1013 // Test receiving a full add chunk. | 1018 // Test receiving a full add chunk. |
1014 chunks.clear(); | 1019 chunks.clear(); |
1015 chunks.push_back(AddChunkFullHash2Value(20, | 1020 chunks.push_back(AddChunkFullHash2Value(20, |
1016 "www.fullevil.com/bad1.html", | 1021 "www.fullevil.com/bad1.html", |
1017 "www.fullevil.com/bad2.html")); | 1022 "www.fullevil.com/bad2.html")); |
1018 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1023 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1019 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1024 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1020 database_->UpdateFinished(true); | 1025 database_->UpdateFinished(true); |
1021 | 1026 |
1022 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1027 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1023 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); | 1028 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); |
1024 ASSERT_EQ(1U, prefix_hits.size()); | 1029 ASSERT_EQ(1U, prefix_hits.size()); |
1025 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefix_hits[0]); | 1030 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad1.html"), prefix_hits[0]); |
1026 EXPECT_TRUE(cache_hits.empty()); | 1031 EXPECT_TRUE(cache_hits.empty()); |
1027 prefix_hits.clear(); | 1032 prefix_hits.clear(); |
1028 cache_hits.clear(); | 1033 cache_hits.clear(); |
1029 | 1034 |
1030 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1035 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1031 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); | 1036 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); |
1032 ASSERT_EQ(1U, prefix_hits.size()); | 1037 ASSERT_EQ(1U, prefix_hits.size()); |
1033 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); | 1038 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); |
1034 EXPECT_TRUE(cache_hits.empty()); | 1039 EXPECT_TRUE(cache_hits.empty()); |
1035 prefix_hits.clear(); | 1040 prefix_hits.clear(); |
1036 cache_hits.clear(); | 1041 cache_hits.clear(); |
1037 | 1042 |
1038 // Test receiving a full sub chunk, which will remove one of the full adds. | 1043 // Test receiving a full sub chunk, which will remove one of the full adds. |
1039 chunks.clear(); | 1044 chunks.clear(); |
1040 chunks.push_back(SubChunkFullHashValue(200, | 1045 chunks.push_back(SubChunkFullHashValue(200, |
1041 "www.fullevil.com/bad1.html", | 1046 "www.fullevil.com/bad1.html", |
1042 20)); | 1047 20)); |
1043 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1048 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1044 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1049 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1045 database_->UpdateFinished(true); | 1050 database_->UpdateFinished(true); |
1046 | 1051 |
1047 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1052 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1048 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); | 1053 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); |
1049 | 1054 |
1050 // There should be one remaining full add. | 1055 // There should be one remaining full add. |
1051 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1056 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1052 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); | 1057 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); |
1053 ASSERT_EQ(1U, prefix_hits.size()); | 1058 ASSERT_EQ(1U, prefix_hits.size()); |
1054 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); | 1059 EXPECT_EQ(SBPrefixForString("www.fullevil.com/bad2.html"), prefix_hits[0]); |
1055 EXPECT_TRUE(cache_hits.empty()); | 1060 EXPECT_TRUE(cache_hits.empty()); |
1056 prefix_hits.clear(); | 1061 prefix_hits.clear(); |
1057 cache_hits.clear(); | 1062 cache_hits.clear(); |
1058 | 1063 |
1059 // Now test an AddDel for the remaining full add. | 1064 // Now test an AddDel for the remaining full add. |
1060 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1065 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1061 AddDelChunk(safe_browsing_util::kMalwareList, 20); | 1066 AddDelChunk(safe_browsing::kMalwareList, 20); |
1062 database_->UpdateFinished(true); | 1067 database_->UpdateFinished(true); |
1063 | 1068 |
1064 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1069 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1065 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); | 1070 GURL("http://www.fullevil.com/bad1.html"), &prefix_hits, &cache_hits)); |
1066 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1071 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1067 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); | 1072 GURL("http://www.fullevil.com/bad2.html"), &prefix_hits, &cache_hits)); |
1068 | 1073 |
1069 // Add a fullhash which has a prefix collision for a known url. | 1074 // Add a fullhash which has a prefix collision for a known url. |
1070 static const char kExampleFine[] = "www.example.com/fine.html"; | 1075 static const char kExampleFine[] = "www.example.com/fine.html"; |
1071 static const char kExampleCollision[] = | 1076 static const char kExampleCollision[] = |
1072 "www.example.com/3123364814/malware.htm"; | 1077 "www.example.com/3123364814/malware.htm"; |
1073 ASSERT_EQ(SBPrefixForString(kExampleFine), | 1078 ASSERT_EQ(SBPrefixForString(kExampleFine), |
1074 SBPrefixForString(kExampleCollision)); | 1079 SBPrefixForString(kExampleCollision)); |
1075 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1080 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1076 { | 1081 { |
1077 ScopedVector<SBChunkData> chunks; | 1082 ScopedVector<SBChunkData> chunks; |
1078 chunks.push_back(AddChunkPrefixValue(21, kExampleCollision)); | 1083 chunks.push_back(AddChunkPrefixValue(21, kExampleCollision)); |
1079 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1084 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1080 } | 1085 } |
1081 database_->UpdateFinished(true); | 1086 database_->UpdateFinished(true); |
1082 | 1087 |
1083 // Expect a prefix hit due to the collision between |kExampleFine| and | 1088 // Expect a prefix hit due to the collision between |kExampleFine| and |
1084 // |kExampleCollision|. | 1089 // |kExampleCollision|. |
1085 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1090 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1086 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); | 1091 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); |
1087 ASSERT_EQ(1U, prefix_hits.size()); | 1092 ASSERT_EQ(1U, prefix_hits.size()); |
1088 EXPECT_EQ(SBPrefixForString(kExampleFine), prefix_hits[0]); | 1093 EXPECT_EQ(SBPrefixForString(kExampleFine), prefix_hits[0]); |
1089 EXPECT_TRUE(cache_hits.empty()); | 1094 EXPECT_TRUE(cache_hits.empty()); |
1090 | 1095 |
1091 // Cache gethash response for |kExampleCollision|. | 1096 // Cache gethash response for |kExampleCollision|. |
1092 { | 1097 { |
1093 SBFullHashResult result; | 1098 SBFullHashResult result; |
1094 result.hash = SBFullHashForString(kExampleCollision); | 1099 result.hash = safe_browsing::SBFullHashForString(kExampleCollision); |
1095 result.list_id = safe_browsing_util::MALWARE; | 1100 result.list_id = safe_browsing::MALWARE; |
1096 database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix), | 1101 database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix), |
1097 std::vector<SBFullHashResult>(1, result), | 1102 std::vector<SBFullHashResult>(1, result), |
1098 kCacheLifetime); | 1103 kCacheLifetime); |
1099 } | 1104 } |
1100 | 1105 |
1101 // The cached response means the collision no longer causes a hit. | 1106 // The cached response means the collision no longer causes a hit. |
1102 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1107 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1103 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); | 1108 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); |
1104 } | 1109 } |
1105 | 1110 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1138 fputc('!', fp); | 1143 fputc('!', fp); |
1139 } | 1144 } |
1140 fclose(fp); | 1145 fclose(fp); |
1141 | 1146 |
1142 { | 1147 { |
1143 // The following code will cause DCHECKs, so suppress the crashes. | 1148 // The following code will cause DCHECKs, so suppress the crashes. |
1144 ScopedLogMessageIgnorer ignorer; | 1149 ScopedLogMessageIgnorer ignorer; |
1145 | 1150 |
1146 // Start an update. The insert will fail due to corruption. | 1151 // Start an update. The insert will fail due to corruption. |
1147 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1152 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1148 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1153 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1149 database_->UpdateFinished(true); | 1154 database_->UpdateFinished(true); |
1150 | 1155 |
1151 // Database file still exists until the corruption handler has run. | 1156 // Database file still exists until the corruption handler has run. |
1152 EXPECT_TRUE(base::PathExists(database_filename_)); | 1157 EXPECT_TRUE(base::PathExists(database_filename_)); |
1153 | 1158 |
1154 // Flush through the corruption-handler task. | 1159 // Flush through the corruption-handler task. |
1155 DVLOG(1) << "Expect failed check on: SafeBrowsing database reset"; | 1160 DVLOG(1) << "Expect failed check on: SafeBrowsing database reset"; |
1156 base::MessageLoop::current()->RunUntilIdle(); | 1161 base::MessageLoop::current()->RunUntilIdle(); |
1157 } | 1162 } |
1158 | 1163 |
1159 // Database file should not exist. | 1164 // Database file should not exist. |
1160 EXPECT_FALSE(base::PathExists(database_filename_)); | 1165 EXPECT_FALSE(base::PathExists(database_filename_)); |
1161 | 1166 |
1162 // Run the update again successfully. | 1167 // Run the update again successfully. |
1163 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1168 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1164 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1169 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1165 database_->UpdateFinished(true); | 1170 database_->UpdateFinished(true); |
1166 EXPECT_TRUE(base::PathExists(database_filename_)); | 1171 EXPECT_TRUE(base::PathExists(database_filename_)); |
1167 | 1172 |
1168 database_.reset(); | 1173 database_.reset(); |
1169 } | 1174 } |
1170 | 1175 |
1171 // Checks database reading and writing. | 1176 // Checks database reading and writing. |
1172 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) { | 1177 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) { |
1173 const char kEvil1Url1[] = "www.evil1.com/download1/"; | 1178 const char kEvil1Url1[] = "www.evil1.com/download1/"; |
1174 const char kEvil1Url2[] = "www.evil1.com/download2.html"; | 1179 const char kEvil1Url2[] = "www.evil1.com/download2.html"; |
1175 | 1180 |
1176 // Add a simple chunk with one hostkey for download url list. | 1181 // Add a simple chunk with one hostkey for download url list. |
1177 ScopedVector<SBChunkData> chunks; | 1182 ScopedVector<SBChunkData> chunks; |
1178 chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2)); | 1183 chunks.push_back(AddChunkPrefix2Value(1, kEvil1Url1, kEvil1Url2)); |
1179 | 1184 |
1180 std::vector<SBListChunkRanges> lists; | 1185 std::vector<SBListChunkRanges> lists; |
1181 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1186 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1182 database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get()); | 1187 database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get()); |
1183 database_->UpdateFinished(true); | 1188 database_->UpdateFinished(true); |
1184 | 1189 |
1185 std::vector<SBPrefix> prefix_hits; | 1190 std::vector<SBPrefix> prefix_hits; |
1186 std::vector<GURL> urls(1); | 1191 std::vector<GURL> urls(1); |
1187 | 1192 |
1188 urls[0] = GURL(std::string("http://") + kEvil1Url1); | 1193 urls[0] = GURL(std::string("http://") + kEvil1Url1); |
1189 EXPECT_TRUE(ContainsDownloadUrl(urls, &prefix_hits)); | 1194 EXPECT_TRUE(ContainsDownloadUrl(urls, &prefix_hits)); |
1190 ASSERT_EQ(1U, prefix_hits.size()); | 1195 ASSERT_EQ(1U, prefix_hits.size()); |
1191 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); | 1196 EXPECT_EQ(SBPrefixForString(kEvil1Url1), prefix_hits[0]); |
1192 | 1197 |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1269 bool TestStrings() const { | 1274 bool TestStrings() const { |
1270 return test_list_contains_whitelisted_string != nullptr; | 1275 return test_list_contains_whitelisted_string != nullptr; |
1271 } | 1276 } |
1272 | 1277 |
1273 const char* test_list_name; | 1278 const char* test_list_name; |
1274 TestListContainsWhitelistedUrl test_list_contains_whitelisted_url; | 1279 TestListContainsWhitelistedUrl test_list_contains_whitelisted_url; |
1275 // Optional test case field, if set the tested whitelist will also be tested | 1280 // Optional test case field, if set the tested whitelist will also be tested |
1276 // for strings. | 1281 // for strings. |
1277 TestListContainsWhitelistedString test_list_contains_whitelisted_string; | 1282 TestListContainsWhitelistedString test_list_contains_whitelisted_string; |
1278 } const kTestCases[]{ | 1283 } const kTestCases[]{ |
1279 {safe_browsing_util::kCsdWhiteList, | 1284 {safe_browsing::kCsdWhiteList, |
1280 &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl, | 1285 &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl, |
1281 nullptr}, | 1286 nullptr}, |
1282 {safe_browsing_util::kDownloadWhiteList, | 1287 {safe_browsing::kDownloadWhiteList, |
1283 &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl, | 1288 &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl, |
1284 &SafeBrowsingDatabase::ContainsDownloadWhitelistedString}, | 1289 &SafeBrowsingDatabase::ContainsDownloadWhitelistedString}, |
1285 {safe_browsing_util::kInclusionWhitelist, | 1290 {safe_browsing::kInclusionWhitelist, |
1286 &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl, | 1291 &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl, |
1287 nullptr}, | 1292 nullptr}, |
1288 }; | 1293 }; |
1289 | 1294 |
1290 // If the whitelist is disabled everything should match the whitelist. | 1295 // If the whitelist is disabled everything should match the whitelist. |
1291 database_.reset(new SafeBrowsingDatabaseNew( | 1296 database_.reset(new SafeBrowsingDatabaseNew( |
1292 task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL, | 1297 task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL, |
1293 NULL, NULL, NULL, NULL)); | 1298 NULL, NULL, NULL, NULL)); |
1294 database_->Init(database_filename_); | 1299 database_->Init(database_filename_); |
1295 for (const auto& test_case : kTestCases) { | 1300 for (const auto& test_case : kTestCases) { |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1410 EXPECT_TRUE( | 1415 EXPECT_TRUE( |
1411 (database_.get()->*test_case.test_list_contains_whitelisted_string)( | 1416 (database_.get()->*test_case.test_list_contains_whitelisted_string)( |
1412 kGoodString)); | 1417 kGoodString)); |
1413 } | 1418 } |
1414 | 1419 |
1415 EXPECT_FALSE( | 1420 EXPECT_FALSE( |
1416 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1421 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1417 GURL(std::string("http://www.google.com/")))); | 1422 GURL(std::string("http://www.google.com/")))); |
1418 | 1423 |
1419 // The malware kill switch is for the CSD whitelist only. | 1424 // The malware kill switch is for the CSD whitelist only. |
1420 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { | 1425 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) { |
1421 // The CSD whitelist killswitch is not present. | 1426 // The CSD whitelist killswitch is not present. |
1422 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); | 1427 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); |
1423 | 1428 |
1424 // Test only add the malware IP killswitch | 1429 // Test only add the malware IP killswitch |
1425 chunks.clear(); | 1430 chunks.clear(); |
1426 chunks.push_back(AddChunkFullHashValue( | 1431 chunks.push_back(AddChunkFullHashValue( |
1427 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware")); | 1432 15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware")); |
1428 | 1433 |
1429 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1434 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1430 database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get()); | 1435 database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get()); |
1431 database_->UpdateFinished(true); | 1436 database_->UpdateFinished(true); |
1432 | 1437 |
1433 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); | 1438 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); |
1434 // The CSD whitelist killswitch is not present. | 1439 // The CSD whitelist killswitch is not present. |
1435 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); | 1440 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); |
1436 } | 1441 } |
1437 | 1442 |
1438 // Test that the generic whitelist kill-switch works as intended. | 1443 // Test that the generic whitelist kill-switch works as intended. |
1439 chunks.clear(); | 1444 chunks.clear(); |
1440 lists.clear(); | 1445 lists.clear(); |
1441 chunks.push_back(AddChunkFullHashValue( | 1446 chunks.push_back(AddChunkFullHashValue( |
1442 5, "sb-ssl.google.com/safebrowsing/csd/killswitch")); | 1447 5, "sb-ssl.google.com/safebrowsing/csd/killswitch")); |
1443 | 1448 |
1444 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1449 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1445 database_->InsertChunks(test_case.test_list_name, chunks.get()); | 1450 database_->InsertChunks(test_case.test_list_name, chunks.get()); |
1446 database_->UpdateFinished(true); | 1451 database_->UpdateFinished(true); |
1447 | 1452 |
1448 // Test CSD whitelist specific methods. | 1453 // Test CSD whitelist specific methods. |
1449 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { | 1454 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) { |
1450 // The CSD whitelist killswitch is present. | 1455 // The CSD whitelist killswitch is present. |
1451 EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn()); | 1456 EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn()); |
1452 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); | 1457 EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn()); |
1453 } | 1458 } |
1454 | 1459 |
1455 EXPECT_TRUE( | 1460 EXPECT_TRUE( |
1456 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1461 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1457 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); | 1462 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); |
1458 EXPECT_TRUE( | 1463 EXPECT_TRUE( |
1459 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1464 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1460 GURL(std::string("http://www.google.com/")))); | 1465 GURL(std::string("http://www.google.com/")))); |
1461 EXPECT_TRUE( | 1466 EXPECT_TRUE( |
1462 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1467 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1463 GURL(std::string("http://www.phishing_url.com/")))); | 1468 GURL(std::string("http://www.phishing_url.com/")))); |
1464 | 1469 |
1465 if (test_case.TestStrings()) { | 1470 if (test_case.TestStrings()) { |
1466 EXPECT_TRUE( | 1471 EXPECT_TRUE( |
1467 (database_.get()->*test_case.test_list_contains_whitelisted_string)( | 1472 (database_.get()->*test_case.test_list_contains_whitelisted_string)( |
1468 "asdf")); | 1473 "asdf")); |
1469 EXPECT_TRUE( | 1474 EXPECT_TRUE( |
1470 (database_.get()->*test_case.test_list_contains_whitelisted_string)( | 1475 (database_.get()->*test_case.test_list_contains_whitelisted_string)( |
1471 kGoodString)); | 1476 kGoodString)); |
1472 } | 1477 } |
1473 | 1478 |
1474 // Remove the kill-switch and verify that we can recover. | 1479 // Remove the kill-switch and verify that we can recover. |
1475 chunks.clear(); | 1480 chunks.clear(); |
1476 lists.clear(); | 1481 lists.clear(); |
1477 chunks.push_back(SubChunkFullHashValue( | 1482 chunks.push_back(SubChunkFullHashValue( |
1478 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5)); | 1483 1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5)); |
1479 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { | 1484 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) { |
1480 chunks.push_back(SubChunkFullHashValue( | 1485 chunks.push_back(SubChunkFullHashValue( |
1481 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15)); | 1486 10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15)); |
1482 } | 1487 } |
1483 | 1488 |
1484 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1489 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1485 database_->InsertChunks(test_case.test_list_name, chunks.get()); | 1490 database_->InsertChunks(test_case.test_list_name, chunks.get()); |
1486 database_->UpdateFinished(true); | 1491 database_->UpdateFinished(true); |
1487 | 1492 |
1488 if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) { | 1493 if (test_case.test_list_name == safe_browsing::kCsdWhiteList) { |
1489 EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn()); | 1494 EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn()); |
1490 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); | 1495 EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn()); |
1491 } | 1496 } |
1492 EXPECT_TRUE( | 1497 EXPECT_TRUE( |
1493 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1498 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1494 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); | 1499 GURL(std::string("https://") + kGood1Url2 + "/c.html"))); |
1495 EXPECT_TRUE( | 1500 EXPECT_TRUE( |
1496 (database_.get()->*test_case.test_list_contains_whitelisted_url)( | 1501 (database_.get()->*test_case.test_list_contains_whitelisted_url)( |
1497 GURL(std::string("https://") + kGood2Url1 + "/c/bla"))); | 1502 GURL(std::string("https://") + kGood2Url1 + "/c/bla"))); |
1498 EXPECT_TRUE( | 1503 EXPECT_TRUE( |
(...skipping 22 matching lines...) Expand all Loading... |
1521 ScopedVector<SBChunkData> chunks; | 1526 ScopedVector<SBChunkData> chunks; |
1522 | 1527 |
1523 // Add a malware add chunk with two entries of the same host. | 1528 // Add a malware add chunk with two entries of the same host. |
1524 chunks.push_back(AddChunkPrefix2Value(1, | 1529 chunks.push_back(AddChunkPrefix2Value(1, |
1525 "www.evil.com/malware1.html", | 1530 "www.evil.com/malware1.html", |
1526 "www.evil.com/malware2.html")); | 1531 "www.evil.com/malware2.html")); |
1527 | 1532 |
1528 // Insert the testing chunks into database. | 1533 // Insert the testing chunks into database. |
1529 std::vector<SBListChunkRanges> lists; | 1534 std::vector<SBListChunkRanges> lists; |
1530 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1535 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1531 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1536 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1532 database_->UpdateFinished(true); | 1537 database_->UpdateFinished(true); |
1533 | 1538 |
1534 GetListsInfo(&lists); | 1539 GetListsInfo(&lists); |
1535 ASSERT_LE(1U, lists.size()); | 1540 ASSERT_LE(1U, lists.size()); |
1536 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 1541 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
1537 EXPECT_EQ("1", lists[0].adds); | 1542 EXPECT_EQ("1", lists[0].adds); |
1538 EXPECT_TRUE(lists[0].subs.empty()); | 1543 EXPECT_TRUE(lists[0].subs.empty()); |
1539 | 1544 |
1540 // Add a phishing add chunk with two entries of the same host. | 1545 // Add a phishing add chunk with two entries of the same host. |
1541 chunks.clear(); | 1546 chunks.clear(); |
1542 chunks.push_back(AddChunkPrefix2Value(47, | 1547 chunks.push_back(AddChunkPrefix2Value(47, |
1543 "www.evil.com/phishing1.html", | 1548 "www.evil.com/phishing1.html", |
1544 "www.evil.com/phishing2.html")); | 1549 "www.evil.com/phishing2.html")); |
1545 | 1550 |
1546 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1551 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1547 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); | 1552 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get()); |
1548 database_->UpdateFinished(true); | 1553 database_->UpdateFinished(true); |
1549 | 1554 |
1550 GetListsInfo(&lists); | 1555 GetListsInfo(&lists); |
1551 ASSERT_LE(2U, lists.size()); | 1556 ASSERT_LE(2U, lists.size()); |
1552 EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name); | 1557 EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name); |
1553 EXPECT_EQ("1", lists[0].adds); | 1558 EXPECT_EQ("1", lists[0].adds); |
1554 EXPECT_TRUE(lists[0].subs.empty()); | 1559 EXPECT_TRUE(lists[0].subs.empty()); |
1555 EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name); | 1560 EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name); |
1556 EXPECT_EQ("47", lists[1].adds); | 1561 EXPECT_EQ("47", lists[1].adds); |
1557 EXPECT_TRUE(lists[1].subs.empty()); | 1562 EXPECT_TRUE(lists[1].subs.empty()); |
1558 | 1563 |
1559 std::vector<SBPrefix> prefix_hits; | 1564 std::vector<SBPrefix> prefix_hits; |
1560 std::vector<SBFullHashResult> cache_hits; | 1565 std::vector<SBFullHashResult> cache_hits; |
1561 | 1566 |
1562 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1567 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1563 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); | 1568 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); |
1564 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1569 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1565 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); | 1570 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); |
1566 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1571 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1567 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); | 1572 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); |
1568 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1573 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1569 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); | 1574 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); |
1570 | 1575 |
1571 // Test removing a single prefix from the add chunk. | 1576 // Test removing a single prefix from the add chunk. |
1572 // Remove the prefix that added first. | 1577 // Remove the prefix that added first. |
1573 chunks.clear(); | 1578 chunks.clear(); |
1574 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1)); | 1579 chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1)); |
1575 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1580 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1576 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1581 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1577 database_->UpdateFinished(true); | 1582 database_->UpdateFinished(true); |
1578 | 1583 |
1579 // Remove the prefix that added last. | 1584 // Remove the prefix that added last. |
1580 chunks.clear(); | 1585 chunks.clear(); |
1581 chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47)); | 1586 chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47)); |
1582 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1587 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1583 database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get()); | 1588 database_->InsertChunks(safe_browsing::kPhishingList, chunks.get()); |
1584 database_->UpdateFinished(true); | 1589 database_->UpdateFinished(true); |
1585 | 1590 |
1586 // Verify that the database contains urls expected. | 1591 // Verify that the database contains urls expected. |
1587 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1592 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1588 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); | 1593 GURL("http://www.evil.com/malware1.html"), &prefix_hits, &cache_hits)); |
1589 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1594 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1590 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); | 1595 GURL("http://www.evil.com/malware2.html"), &prefix_hits, &cache_hits)); |
1591 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1596 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1592 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); | 1597 GURL("http://www.evil.com/phishing1.html"), &prefix_hits, &cache_hits)); |
1593 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1598 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1594 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); | 1599 GURL("http://www.evil.com/phishing2.html"), &prefix_hits, &cache_hits)); |
1595 } | 1600 } |
1596 | 1601 |
1597 // Test that an empty update doesn't actually update the database. | 1602 // Test that an empty update doesn't actually update the database. |
1598 // This isn't a functionality requirement, but it is a useful | 1603 // This isn't a functionality requirement, but it is a useful |
1599 // optimization. | 1604 // optimization. |
1600 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) { | 1605 TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) { |
1601 ScopedVector<SBChunkData> chunks; | 1606 ScopedVector<SBChunkData> chunks; |
1602 | 1607 |
1603 base::FilePath filename = database_->BrowseDBFilename(database_filename_); | 1608 base::FilePath filename = database_->BrowseDBFilename(database_filename_); |
1604 | 1609 |
1605 // Prime the database. | 1610 // Prime the database. |
1606 std::vector<SBListChunkRanges> lists; | 1611 std::vector<SBListChunkRanges> lists; |
1607 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1612 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1608 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); | 1613 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); |
1609 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1614 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1610 database_->UpdateFinished(true); | 1615 database_->UpdateFinished(true); |
1611 | 1616 |
1612 // Get an older time to reset the lastmod time for detecting whether | 1617 // Get an older time to reset the lastmod time for detecting whether |
1613 // the file has been updated. | 1618 // the file has been updated. |
1614 base::File::Info before_info, after_info; | 1619 base::File::Info before_info, after_info; |
1615 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); | 1620 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); |
1616 const Time old_last_modified = | 1621 const Time old_last_modified = |
1617 before_info.last_modified - TimeDelta::FromSeconds(10); | 1622 before_info.last_modified - TimeDelta::FromSeconds(10); |
1618 | 1623 |
1619 // Inserting another chunk updates the database file. The sleep is | 1624 // Inserting another chunk updates the database file. The sleep is |
1620 // needed because otherwise the entire test can finish w/in the | 1625 // needed because otherwise the entire test can finish w/in the |
1621 // resolution of the lastmod time. | 1626 // resolution of the lastmod time. |
1622 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); | 1627 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); |
1623 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); | 1628 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); |
1624 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1629 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1625 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); | 1630 chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html")); |
1626 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1631 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1627 database_->UpdateFinished(true); | 1632 database_->UpdateFinished(true); |
1628 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); | 1633 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); |
1629 EXPECT_LT(before_info.last_modified, after_info.last_modified); | 1634 EXPECT_LT(before_info.last_modified, after_info.last_modified); |
1630 | 1635 |
1631 // Deleting a chunk updates the database file. | 1636 // Deleting a chunk updates the database file. |
1632 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); | 1637 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); |
1633 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); | 1638 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); |
1634 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1639 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1635 AddDelChunk(safe_browsing_util::kMalwareList, 2); | 1640 AddDelChunk(safe_browsing::kMalwareList, 2); |
1636 database_->UpdateFinished(true); | 1641 database_->UpdateFinished(true); |
1637 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); | 1642 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); |
1638 EXPECT_LT(before_info.last_modified, after_info.last_modified); | 1643 EXPECT_LT(before_info.last_modified, after_info.last_modified); |
1639 | 1644 |
1640 // Simply calling |UpdateStarted()| then |UpdateFinished()| does not | 1645 // Simply calling |UpdateStarted()| then |UpdateFinished()| does not |
1641 // update the database file. | 1646 // update the database file. |
1642 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); | 1647 ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified)); |
1643 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); | 1648 ASSERT_TRUE(base::GetFileInfo(filename, &before_info)); |
1644 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1649 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1645 database_->UpdateFinished(true); | 1650 database_->UpdateFinished(true); |
1646 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); | 1651 ASSERT_TRUE(base::GetFileInfo(filename, &after_info)); |
1647 EXPECT_EQ(before_info.last_modified, after_info.last_modified); | 1652 EXPECT_EQ(before_info.last_modified, after_info.last_modified); |
1648 } | 1653 } |
1649 | 1654 |
1650 // Test that a filter file is written out during update and read back | 1655 // Test that a filter file is written out during update and read back |
1651 // in during setup. | 1656 // in during setup. |
1652 TEST_F(SafeBrowsingDatabaseTest, FilterFile) { | 1657 TEST_F(SafeBrowsingDatabaseTest, FilterFile) { |
1653 // Create a database with trivial example data and write it out. | 1658 // Create a database with trivial example data and write it out. |
1654 { | 1659 { |
1655 // Prime the database. | 1660 // Prime the database. |
1656 std::vector<SBListChunkRanges> lists; | 1661 std::vector<SBListChunkRanges> lists; |
1657 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1662 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1658 | 1663 |
1659 ScopedVector<SBChunkData> chunks; | 1664 ScopedVector<SBChunkData> chunks; |
1660 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); | 1665 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html")); |
1661 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1666 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1662 database_->UpdateFinished(true); | 1667 database_->UpdateFinished(true); |
1663 } | 1668 } |
1664 | 1669 |
1665 // Find the malware url in the database, don't find a good url. | 1670 // Find the malware url in the database, don't find a good url. |
1666 std::vector<SBPrefix> prefix_hits; | 1671 std::vector<SBPrefix> prefix_hits; |
1667 std::vector<SBFullHashResult> cache_hits; | 1672 std::vector<SBFullHashResult> cache_hits; |
1668 EXPECT_TRUE(database_->ContainsBrowseUrl( | 1673 EXPECT_TRUE(database_->ContainsBrowseUrl( |
1669 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); | 1674 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); |
1670 EXPECT_FALSE(database_->ContainsBrowseUrl( | 1675 EXPECT_FALSE(database_->ContainsBrowseUrl( |
1671 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); | 1676 GURL("http://www.good.com/goodware.html"), &prefix_hits, &cache_hits)); |
(...skipping 29 matching lines...) Expand all Loading... |
1701 const SBFullHash kFullHash2_1 = | 1706 const SBFullHash kFullHash2_1 = |
1702 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01"); | 1707 SBFullHashForPrefixAndSuffix(kPrefix2, "\x01"); |
1703 | 1708 |
1704 // Insert prefix kPrefix1 and kPrefix2 into database. | 1709 // Insert prefix kPrefix1 and kPrefix2 into database. |
1705 ScopedVector<SBChunkData> chunks; | 1710 ScopedVector<SBChunkData> chunks; |
1706 chunks.push_back(AddChunkPrefix(1, kPrefix1)); | 1711 chunks.push_back(AddChunkPrefix(1, kPrefix1)); |
1707 chunks.push_back(AddChunkPrefix(2, kPrefix2)); | 1712 chunks.push_back(AddChunkPrefix(2, kPrefix2)); |
1708 | 1713 |
1709 std::vector<SBListChunkRanges> lists; | 1714 std::vector<SBListChunkRanges> lists; |
1710 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1715 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1711 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1716 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1712 database_->UpdateFinished(true); | 1717 database_->UpdateFinished(true); |
1713 | 1718 |
1714 { | 1719 { |
1715 // Cache a full miss result for kPrefix1. | 1720 // Cache a full miss result for kPrefix1. |
1716 std::vector<SBPrefix> prefixes(1, kPrefix1); | 1721 std::vector<SBPrefix> prefixes(1, kPrefix1); |
1717 std::vector<SBFullHashResult> cache_results; | 1722 std::vector<SBFullHashResult> cache_results; |
1718 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); | 1723 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); |
1719 } | 1724 } |
1720 | 1725 |
1721 { | 1726 { |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1756 const SBFullHash kFullHash3_1 = | 1761 const SBFullHash kFullHash3_1 = |
1757 SBFullHashForPrefixAndSuffix(kPrefix3, "\x01"); | 1762 SBFullHashForPrefixAndSuffix(kPrefix3, "\x01"); |
1758 | 1763 |
1759 // Insert prefix kPrefix1 and kPrefix2 into database. | 1764 // Insert prefix kPrefix1 and kPrefix2 into database. |
1760 ScopedVector<SBChunkData> chunks; | 1765 ScopedVector<SBChunkData> chunks; |
1761 chunks.push_back(AddChunkPrefix(1, kPrefix1)); | 1766 chunks.push_back(AddChunkPrefix(1, kPrefix1)); |
1762 chunks.push_back(AddChunkPrefix(2, kPrefix2)); | 1767 chunks.push_back(AddChunkPrefix(2, kPrefix2)); |
1763 | 1768 |
1764 std::vector<SBListChunkRanges> lists; | 1769 std::vector<SBListChunkRanges> lists; |
1765 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1770 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1766 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1771 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1767 database_->UpdateFinished(true); | 1772 database_->UpdateFinished(true); |
1768 | 1773 |
1769 { | 1774 { |
1770 // kFullHash1_1 has a prefix hit of kPrefix1. | 1775 // kFullHash1_1 has a prefix hit of kPrefix1. |
1771 std::vector<SBFullHash> full_hashes; | 1776 std::vector<SBFullHash> full_hashes; |
1772 full_hashes.push_back(kFullHash1_1); | 1777 full_hashes.push_back(kFullHash1_1); |
1773 std::vector<SBPrefix> prefix_hits; | 1778 std::vector<SBPrefix> prefix_hits; |
1774 std::vector<SBFullHashResult> cache_hits; | 1779 std::vector<SBFullHashResult> cache_hits; |
1775 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1780 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1776 full_hashes, &prefix_hits, &cache_hits)); | 1781 full_hashes, &prefix_hits, &cache_hits)); |
(...skipping 23 matching lines...) Expand all Loading... |
1800 EXPECT_EQ(kPrefix2, prefix_hits[1]); | 1805 EXPECT_EQ(kPrefix2, prefix_hits[1]); |
1801 EXPECT_TRUE(cache_hits.empty()); | 1806 EXPECT_TRUE(cache_hits.empty()); |
1802 } | 1807 } |
1803 | 1808 |
1804 { | 1809 { |
1805 // Cache a fullhash result for two kPrefix1 full hashes. | 1810 // Cache a fullhash result for two kPrefix1 full hashes. |
1806 std::vector<SBPrefix> prefixes(1, kPrefix1); | 1811 std::vector<SBPrefix> prefixes(1, kPrefix1); |
1807 std::vector<SBFullHashResult> cache_results; | 1812 std::vector<SBFullHashResult> cache_results; |
1808 | 1813 |
1809 SBFullHashResult full_hash_result; | 1814 SBFullHashResult full_hash_result; |
1810 full_hash_result.list_id = safe_browsing_util::MALWARE; | 1815 full_hash_result.list_id = safe_browsing::MALWARE; |
1811 | 1816 |
1812 full_hash_result.hash = kFullHash1_1; | 1817 full_hash_result.hash = kFullHash1_1; |
1813 cache_results.push_back(full_hash_result); | 1818 cache_results.push_back(full_hash_result); |
1814 | 1819 |
1815 full_hash_result.hash = kFullHash1_3; | 1820 full_hash_result.hash = kFullHash1_3; |
1816 cache_results.push_back(full_hash_result); | 1821 cache_results.push_back(full_hash_result); |
1817 | 1822 |
1818 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); | 1823 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); |
1819 } | 1824 } |
1820 | 1825 |
1821 { | 1826 { |
1822 // kFullHash1_1 should now see a cache hit. | 1827 // kFullHash1_1 should now see a cache hit. |
1823 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); | 1828 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); |
1824 std::vector<SBPrefix> prefix_hits; | 1829 std::vector<SBPrefix> prefix_hits; |
1825 std::vector<SBFullHashResult> cache_hits; | 1830 std::vector<SBFullHashResult> cache_hits; |
1826 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1831 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1827 full_hashes, &prefix_hits, &cache_hits)); | 1832 full_hashes, &prefix_hits, &cache_hits)); |
1828 EXPECT_TRUE(prefix_hits.empty()); | 1833 EXPECT_TRUE(prefix_hits.empty()); |
1829 ASSERT_EQ(1U, cache_hits.size()); | 1834 ASSERT_EQ(1U, cache_hits.size()); |
1830 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); | 1835 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
| 1836 kFullHash1_1, cache_hits[0].hash)); |
1831 | 1837 |
1832 // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit | 1838 // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit |
1833 // for kPrefix2. | 1839 // for kPrefix2. |
1834 full_hashes.push_back(kFullHash2_1); | 1840 full_hashes.push_back(kFullHash2_1); |
1835 prefix_hits.clear(); | 1841 prefix_hits.clear(); |
1836 cache_hits.clear(); | 1842 cache_hits.clear(); |
1837 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1843 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1838 full_hashes, &prefix_hits, &cache_hits)); | 1844 full_hashes, &prefix_hits, &cache_hits)); |
1839 ASSERT_EQ(1U, prefix_hits.size()); | 1845 ASSERT_EQ(1U, prefix_hits.size()); |
1840 EXPECT_EQ(kPrefix2, prefix_hits[0]); | 1846 EXPECT_EQ(kPrefix2, prefix_hits[0]); |
1841 ASSERT_EQ(1U, cache_hits.size()); | 1847 ASSERT_EQ(1U, cache_hits.size()); |
1842 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); | 1848 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
| 1849 kFullHash1_1, cache_hits[0].hash)); |
1843 | 1850 |
1844 // kFullHash1_3 also gets a cache hit. | 1851 // kFullHash1_3 also gets a cache hit. |
1845 full_hashes.push_back(kFullHash1_3); | 1852 full_hashes.push_back(kFullHash1_3); |
1846 prefix_hits.clear(); | 1853 prefix_hits.clear(); |
1847 cache_hits.clear(); | 1854 cache_hits.clear(); |
1848 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1855 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1849 full_hashes, &prefix_hits, &cache_hits)); | 1856 full_hashes, &prefix_hits, &cache_hits)); |
1850 ASSERT_EQ(1U, prefix_hits.size()); | 1857 ASSERT_EQ(1U, prefix_hits.size()); |
1851 EXPECT_EQ(kPrefix2, prefix_hits[0]); | 1858 EXPECT_EQ(kPrefix2, prefix_hits[0]); |
1852 ASSERT_EQ(2U, cache_hits.size()); | 1859 ASSERT_EQ(2U, cache_hits.size()); |
1853 EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash)); | 1860 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
1854 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[1].hash)); | 1861 kFullHash1_1, cache_hits[0].hash)); |
| 1862 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
| 1863 kFullHash1_3, cache_hits[1].hash)); |
1855 } | 1864 } |
1856 | 1865 |
1857 { | 1866 { |
1858 // Check if DB contains only kFullHash1_3. Should return a cache hit. | 1867 // Check if DB contains only kFullHash1_3. Should return a cache hit. |
1859 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); | 1868 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); |
1860 std::vector<SBPrefix> prefix_hits; | 1869 std::vector<SBPrefix> prefix_hits; |
1861 std::vector<SBFullHashResult> cache_hits; | 1870 std::vector<SBFullHashResult> cache_hits; |
1862 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1871 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1863 full_hashes, &prefix_hits, &cache_hits)); | 1872 full_hashes, &prefix_hits, &cache_hits)); |
1864 EXPECT_TRUE(prefix_hits.empty()); | 1873 EXPECT_TRUE(prefix_hits.empty()); |
1865 ASSERT_EQ(1U, cache_hits.size()); | 1874 ASSERT_EQ(1U, cache_hits.size()); |
1866 EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[0].hash)); | 1875 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
| 1876 kFullHash1_3, cache_hits[0].hash)); |
1867 } | 1877 } |
1868 | 1878 |
1869 { | 1879 { |
1870 // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for | 1880 // kFullHash1_2 has no cache hit, and no prefix hit because of the cache for |
1871 // kPrefix1. | 1881 // kPrefix1. |
1872 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); | 1882 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); |
1873 std::vector<SBPrefix> prefix_hits; | 1883 std::vector<SBPrefix> prefix_hits; |
1874 std::vector<SBFullHashResult> cache_hits; | 1884 std::vector<SBFullHashResult> cache_hits; |
1875 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( | 1885 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( |
1876 full_hashes, &prefix_hits, &cache_hits)); | 1886 full_hashes, &prefix_hits, &cache_hits)); |
(...skipping 19 matching lines...) Expand all Loading... |
1896 const SBFullHash kFullHash1_3 = | 1906 const SBFullHash kFullHash1_3 = |
1897 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03"); | 1907 SBFullHashForPrefixAndSuffix(kPrefix1, "\x03"); |
1898 | 1908 |
1899 // Insert two full hashes with a shared prefix. | 1909 // Insert two full hashes with a shared prefix. |
1900 ScopedVector<SBChunkData> chunks; | 1910 ScopedVector<SBChunkData> chunks; |
1901 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); | 1911 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); |
1902 chunks.push_back(AddChunkFullHash(2, kFullHash1_2)); | 1912 chunks.push_back(AddChunkFullHash(2, kFullHash1_2)); |
1903 | 1913 |
1904 std::vector<SBListChunkRanges> lists; | 1914 std::vector<SBListChunkRanges> lists; |
1905 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1915 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1906 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1916 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1907 database_->UpdateFinished(true); | 1917 database_->UpdateFinished(true); |
1908 | 1918 |
1909 { | 1919 { |
1910 // Check a full hash which isn't present. | 1920 // Check a full hash which isn't present. |
1911 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); | 1921 std::vector<SBFullHash> full_hashes(1, kFullHash1_3); |
1912 std::vector<SBPrefix> prefix_hits; | 1922 std::vector<SBPrefix> prefix_hits; |
1913 std::vector<SBFullHashResult> cache_hits; | 1923 std::vector<SBFullHashResult> cache_hits; |
1914 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( | 1924 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( |
1915 full_hashes, &prefix_hits, &cache_hits)); | 1925 full_hashes, &prefix_hits, &cache_hits)); |
1916 | 1926 |
(...skipping 14 matching lines...) Expand all Loading... |
1931 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1941 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1932 full_hashes, &prefix_hits, &cache_hits)); | 1942 full_hashes, &prefix_hits, &cache_hits)); |
1933 ASSERT_EQ(1U, prefix_hits.size()); | 1943 ASSERT_EQ(1U, prefix_hits.size()); |
1934 EXPECT_EQ(kPrefix1, prefix_hits[0]); | 1944 EXPECT_EQ(kPrefix1, prefix_hits[0]); |
1935 EXPECT_TRUE(cache_hits.empty()); | 1945 EXPECT_TRUE(cache_hits.empty()); |
1936 } | 1946 } |
1937 | 1947 |
1938 { | 1948 { |
1939 // Cache a gethash result for kFullHash1_2. | 1949 // Cache a gethash result for kFullHash1_2. |
1940 SBFullHashResult full_hash_result; | 1950 SBFullHashResult full_hash_result; |
1941 full_hash_result.list_id = safe_browsing_util::MALWARE; | 1951 full_hash_result.list_id = safe_browsing::MALWARE; |
1942 full_hash_result.hash = kFullHash1_2; | 1952 full_hash_result.hash = kFullHash1_2; |
1943 | 1953 |
1944 std::vector<SBPrefix> prefixes(1, kPrefix1); | 1954 std::vector<SBPrefix> prefixes(1, kPrefix1); |
1945 std::vector<SBFullHashResult> cache_results(1, full_hash_result); | 1955 std::vector<SBFullHashResult> cache_results(1, full_hash_result); |
1946 | 1956 |
1947 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); | 1957 database_->CacheHashResults(prefixes, cache_results, kCacheLifetime); |
1948 } | 1958 } |
1949 | 1959 |
1950 { | 1960 { |
1951 // kFullHash1_3 should still return false, because the cached | 1961 // kFullHash1_3 should still return false, because the cached |
(...skipping 13 matching lines...) Expand all Loading... |
1965 full_hashes, &prefix_hits, &cache_hits)); | 1975 full_hashes, &prefix_hits, &cache_hits)); |
1966 | 1976 |
1967 // kFullHash1_2 is in the cached result. | 1977 // kFullHash1_2 is in the cached result. |
1968 full_hashes.push_back(kFullHash1_2); | 1978 full_hashes.push_back(kFullHash1_2); |
1969 prefix_hits.clear(); | 1979 prefix_hits.clear(); |
1970 cache_hits.clear(); | 1980 cache_hits.clear(); |
1971 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 1981 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
1972 full_hashes, &prefix_hits, &cache_hits)); | 1982 full_hashes, &prefix_hits, &cache_hits)); |
1973 EXPECT_TRUE(prefix_hits.empty()); | 1983 EXPECT_TRUE(prefix_hits.empty()); |
1974 ASSERT_EQ(1U, cache_hits.size()); | 1984 ASSERT_EQ(1U, cache_hits.size()); |
1975 EXPECT_TRUE(SBFullHashEqual(kFullHash1_2, cache_hits[0].hash)); | 1985 EXPECT_TRUE(safe_browsing::SBFullHashEqual( |
| 1986 kFullHash1_2, cache_hits[0].hash)); |
1976 } | 1987 } |
1977 | 1988 |
1978 // Remove kFullHash1_1 from the database. | 1989 // Remove kFullHash1_1 from the database. |
1979 chunks.clear(); | 1990 chunks.clear(); |
1980 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); | 1991 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); |
1981 | 1992 |
1982 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 1993 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
1983 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 1994 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
1984 database_->UpdateFinished(true); | 1995 database_->UpdateFinished(true); |
1985 | 1996 |
1986 // Cache should be cleared after updating. | 1997 // Cache should be cleared after updating. |
1987 EXPECT_TRUE( | 1998 EXPECT_TRUE( |
1988 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); | 1999 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); |
1989 | 2000 |
1990 { | 2001 { |
1991 // Now the database doesn't contain kFullHash1_1. | 2002 // Now the database doesn't contain kFullHash1_1. |
1992 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); | 2003 std::vector<SBFullHash> full_hashes(1, kFullHash1_1); |
1993 std::vector<SBPrefix> prefix_hits; | 2004 std::vector<SBPrefix> prefix_hits; |
(...skipping 17 matching lines...) Expand all Loading... |
2011 ASSERT_EQ(1U, prefix_hits.size()); | 2022 ASSERT_EQ(1U, prefix_hits.size()); |
2012 EXPECT_EQ(kPrefix1, prefix_hits[0]); | 2023 EXPECT_EQ(kPrefix1, prefix_hits[0]); |
2013 EXPECT_TRUE(cache_hits.empty()); | 2024 EXPECT_TRUE(cache_hits.empty()); |
2014 } | 2025 } |
2015 | 2026 |
2016 // Remove kFullHash1_2 from the database. | 2027 // Remove kFullHash1_2 from the database. |
2017 chunks.clear(); | 2028 chunks.clear(); |
2018 chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2)); | 2029 chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2)); |
2019 | 2030 |
2020 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 2031 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
2021 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2032 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2022 database_->UpdateFinished(true); | 2033 database_->UpdateFinished(true); |
2023 | 2034 |
2024 // Cache should be cleared after updating. | 2035 // Cache should be cleared after updating. |
2025 EXPECT_TRUE( | 2036 EXPECT_TRUE( |
2026 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); | 2037 database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty()); |
2027 | 2038 |
2028 { | 2039 { |
2029 // None are present. | 2040 // None are present. |
2030 std::vector<SBFullHash> full_hashes; | 2041 std::vector<SBFullHash> full_hashes; |
2031 std::vector<SBPrefix> prefix_hits; | 2042 std::vector<SBPrefix> prefix_hits; |
(...skipping 11 matching lines...) Expand all Loading... |
2043 const SBFullHash kFullHash1_1 = | 2054 const SBFullHash kFullHash1_1 = |
2044 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); | 2055 SBFullHashForPrefixAndSuffix(kPrefix1, "\x01"); |
2045 const SBFullHash kFullHash1_2 = | 2056 const SBFullHash kFullHash1_2 = |
2046 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); | 2057 SBFullHashForPrefixAndSuffix(kPrefix1, "\x02"); |
2047 | 2058 |
2048 ScopedVector<SBChunkData> chunks; | 2059 ScopedVector<SBChunkData> chunks; |
2049 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); | 2060 chunks.push_back(AddChunkFullHash(1, kFullHash1_1)); |
2050 | 2061 |
2051 std::vector<SBListChunkRanges> lists; | 2062 std::vector<SBListChunkRanges> lists; |
2052 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 2063 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
2053 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2064 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2054 database_->UpdateFinished(true); | 2065 database_->UpdateFinished(true); |
2055 | 2066 |
2056 { | 2067 { |
2057 // kFullHash1_2 does not match kFullHash1_1. | 2068 // kFullHash1_2 does not match kFullHash1_1. |
2058 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); | 2069 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); |
2059 std::vector<SBPrefix> prefix_hits; | 2070 std::vector<SBPrefix> prefix_hits; |
2060 std::vector<SBFullHashResult> cache_hits; | 2071 std::vector<SBFullHashResult> cache_hits; |
2061 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( | 2072 EXPECT_FALSE(database_->ContainsBrowseUrlHashesForTesting( |
2062 full_hashes, &prefix_hits, &cache_hits)); | 2073 full_hashes, &prefix_hits, &cache_hits)); |
2063 } | 2074 } |
2064 | 2075 |
2065 // Add a prefix match. | 2076 // Add a prefix match. |
2066 chunks.clear(); | 2077 chunks.clear(); |
2067 chunks.push_back(AddChunkPrefix(2, kPrefix1)); | 2078 chunks.push_back(AddChunkPrefix(2, kPrefix1)); |
2068 | 2079 |
2069 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 2080 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
2070 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2081 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2071 database_->UpdateFinished(true); | 2082 database_->UpdateFinished(true); |
2072 | 2083 |
2073 { | 2084 { |
2074 // kFullHash1_2 does match kPrefix1. | 2085 // kFullHash1_2 does match kPrefix1. |
2075 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); | 2086 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); |
2076 std::vector<SBPrefix> prefix_hits; | 2087 std::vector<SBPrefix> prefix_hits; |
2077 std::vector<SBFullHashResult> cache_hits; | 2088 std::vector<SBFullHashResult> cache_hits; |
2078 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 2089 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
2079 full_hashes, &prefix_hits, &cache_hits)); | 2090 full_hashes, &prefix_hits, &cache_hits)); |
2080 ASSERT_EQ(1U, prefix_hits.size()); | 2091 ASSERT_EQ(1U, prefix_hits.size()); |
2081 EXPECT_EQ(kPrefix1, prefix_hits[0]); | 2092 EXPECT_EQ(kPrefix1, prefix_hits[0]); |
2082 EXPECT_TRUE(cache_hits.empty()); | 2093 EXPECT_TRUE(cache_hits.empty()); |
2083 } | 2094 } |
2084 | 2095 |
2085 // Remove the full hash. | 2096 // Remove the full hash. |
2086 chunks.clear(); | 2097 chunks.clear(); |
2087 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); | 2098 chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1)); |
2088 | 2099 |
2089 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 2100 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
2090 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2101 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2091 database_->UpdateFinished(true); | 2102 database_->UpdateFinished(true); |
2092 | 2103 |
2093 { | 2104 { |
2094 // kFullHash1_2 still returns true due to the prefix hit. | 2105 // kFullHash1_2 still returns true due to the prefix hit. |
2095 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); | 2106 std::vector<SBFullHash> full_hashes(1, kFullHash1_2); |
2096 std::vector<SBPrefix> prefix_hits; | 2107 std::vector<SBPrefix> prefix_hits; |
2097 std::vector<SBFullHashResult> cache_hits; | 2108 std::vector<SBFullHashResult> cache_hits; |
2098 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( | 2109 EXPECT_TRUE(database_->ContainsBrowseUrlHashesForTesting( |
2099 full_hashes, &prefix_hits, &cache_hits)); | 2110 full_hashes, &prefix_hits, &cache_hits)); |
2100 ASSERT_EQ(1U, prefix_hits.size()); | 2111 ASSERT_EQ(1U, prefix_hits.size()); |
(...skipping 19 matching lines...) Expand all Loading... |
2120 | 2131 |
2121 // IPv6 prefix match for: 2620:0:1000:3103::/64. | 2132 // IPv6 prefix match for: 2620:0:1000:3103::/64. |
2122 chunks.push_back(AddChunkHashedIpValue(4, "2620:0:1000:3103::", 64)); | 2133 chunks.push_back(AddChunkHashedIpValue(4, "2620:0:1000:3103::", 64)); |
2123 | 2134 |
2124 // IPv4 prefix match for ::ffff:192.1.122.0/119. | 2135 // IPv4 prefix match for ::ffff:192.1.122.0/119. |
2125 chunks.push_back(AddChunkHashedIpValue(5, "::ffff:192.1.122.0", 119)); | 2136 chunks.push_back(AddChunkHashedIpValue(5, "::ffff:192.1.122.0", 119)); |
2126 | 2137 |
2127 // IPv4 prefix match for ::ffff:192.1.128.0/113. | 2138 // IPv4 prefix match for ::ffff:192.1.128.0/113. |
2128 chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113)); | 2139 chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113)); |
2129 | 2140 |
2130 database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get()); | 2141 database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get()); |
2131 database_->UpdateFinished(true); | 2142 database_->UpdateFinished(true); |
2132 | 2143 |
2133 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255")); | 2144 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255")); |
2134 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.0")); | 2145 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.0")); |
2135 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.255")); | 2146 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.255")); |
2136 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.10")); | 2147 EXPECT_TRUE(database_->ContainsMalwareIP("192.168.1.10")); |
2137 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.168.1.2")); | 2148 EXPECT_TRUE(database_->ContainsMalwareIP("::ffff:192.168.1.2")); |
2138 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.2.0")); | 2149 EXPECT_FALSE(database_->ContainsMalwareIP("192.168.2.0")); |
2139 | 2150 |
2140 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.0")); | 2151 EXPECT_FALSE(database_->ContainsMalwareIP("192.1.1.0")); |
(...skipping 29 matching lines...) Expand all Loading... |
2170 } | 2181 } |
2171 | 2182 |
2172 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) { | 2183 TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) { |
2173 std::vector<SBListChunkRanges> lists; | 2184 std::vector<SBListChunkRanges> lists; |
2174 ASSERT_TRUE(database_->UpdateStarted(&lists)); | 2185 ASSERT_TRUE(database_->UpdateStarted(&lists)); |
2175 | 2186 |
2176 // Add a host-level hit. | 2187 // Add a host-level hit. |
2177 { | 2188 { |
2178 ScopedVector<SBChunkData> chunks; | 2189 ScopedVector<SBChunkData> chunks; |
2179 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/")); | 2190 chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/")); |
2180 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2191 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2181 } | 2192 } |
2182 | 2193 |
2183 // Add a specific fullhash. | 2194 // Add a specific fullhash. |
2184 static const char kWhateverMalware[] = "www.whatever.com/malware.html"; | 2195 static const char kWhateverMalware[] = "www.whatever.com/malware.html"; |
2185 { | 2196 { |
2186 ScopedVector<SBChunkData> chunks; | 2197 ScopedVector<SBChunkData> chunks; |
2187 chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware)); | 2198 chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware)); |
2188 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2199 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2189 } | 2200 } |
2190 | 2201 |
2191 // Add a fullhash which has a prefix collision for a known url. | 2202 // Add a fullhash which has a prefix collision for a known url. |
2192 static const char kExampleFine[] = "www.example.com/fine.html"; | 2203 static const char kExampleFine[] = "www.example.com/fine.html"; |
2193 static const char kExampleCollision[] = | 2204 static const char kExampleCollision[] = |
2194 "www.example.com/3123364814/malware.htm"; | 2205 "www.example.com/3123364814/malware.htm"; |
2195 ASSERT_EQ(SBPrefixForString(kExampleFine), | 2206 ASSERT_EQ(SBPrefixForString(kExampleFine), |
2196 SBPrefixForString(kExampleCollision)); | 2207 SBPrefixForString(kExampleCollision)); |
2197 { | 2208 { |
2198 ScopedVector<SBChunkData> chunks; | 2209 ScopedVector<SBChunkData> chunks; |
2199 chunks.push_back(AddChunkFullHashValue(3, kExampleCollision)); | 2210 chunks.push_back(AddChunkFullHashValue(3, kExampleCollision)); |
2200 database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get()); | 2211 database_->InsertChunks(safe_browsing::kMalwareList, chunks.get()); |
2201 } | 2212 } |
2202 | 2213 |
2203 database_->UpdateFinished(true); | 2214 database_->UpdateFinished(true); |
2204 | 2215 |
2205 std::vector<SBPrefix> prefix_hits; | 2216 std::vector<SBPrefix> prefix_hits; |
2206 std::vector<SBFullHashResult> cache_hits; | 2217 std::vector<SBFullHashResult> cache_hits; |
2207 | 2218 |
2208 // Anything will hit the host prefix. | 2219 // Anything will hit the host prefix. |
2209 EXPECT_TRUE(database_->ContainsBrowseUrl( | 2220 EXPECT_TRUE(database_->ContainsBrowseUrl( |
2210 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); | 2221 GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits)); |
(...skipping 20 matching lines...) Expand all Loading... |
2231 GURL(std::string("http://") + kExampleCollision), | 2242 GURL(std::string("http://") + kExampleCollision), |
2232 &prefix_hits, &cache_hits)); | 2243 &prefix_hits, &cache_hits)); |
2233 ASSERT_EQ(1U, prefix_hits.size()); | 2244 ASSERT_EQ(1U, prefix_hits.size()); |
2234 EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]); | 2245 EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]); |
2235 EXPECT_TRUE(cache_hits.empty()); | 2246 EXPECT_TRUE(cache_hits.empty()); |
2236 | 2247 |
2237 // This prefix collides, but no full hash match. | 2248 // This prefix collides, but no full hash match. |
2238 EXPECT_FALSE(database_->ContainsBrowseUrl( | 2249 EXPECT_FALSE(database_->ContainsBrowseUrl( |
2239 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); | 2250 GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits)); |
2240 } | 2251 } |
OLD | NEW |