Add a whitelist for the new binary download protection.

chrome/browser/safe_browsing/safe_browsing_database_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 348 matching lines @@
   EXPECT_EQ(lists[1].adds, "47");
   EXPECT_EQ(lists[1].subs, "200-201");
 }
 
 TEST_F(SafeBrowsingDatabaseTest, ListNameForBrowseAndDownload) {
   database_.reset();
   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
+  SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store,
                                               download_store,
-                                              csd_whitelist_store));
+                                              csd_whitelist_store,
+                                              download_whitelist_store));
   database_->Init(database_filename_);
 
   SBChunkList chunks;
   SBChunk chunk;
 
   // Insert malware, phish, binurl and bindownload add chunks.
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
                               "www.evil.com/malware.html");
   chunks.push_back(chunk);
   std::vector<SBListChunkRanges> lists;
@@ skipping 21 matching lines @@
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kBinHashList, chunks);
 
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 5, "www.forwhitelist.com/",
                                "www.forwhitelist.com/a.html");
   chunks.clear();
   chunks.push_back(chunk);
   database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks);
 
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 6, "www.download.com/",
+                               "www.download.com/");
+
+  chunks.clear();
+  chunks.push_back(chunk);
+  database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks);
+
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  EXPECT_EQ(5U, lists.size());
+  EXPECT_EQ(6U, lists.size());
   EXPECT_TRUE(lists[0].name == safe_browsing_util::kMalwareList);
   EXPECT_EQ(lists[0].adds, "1");
   EXPECT_TRUE(lists[0].subs.empty());
   EXPECT_TRUE(lists[1].name == safe_browsing_util::kPhishingList);
   EXPECT_EQ(lists[1].adds, "2");
   EXPECT_TRUE(lists[1].subs.empty());
   EXPECT_TRUE(lists[2].name == safe_browsing_util::kBinUrlList);
   EXPECT_EQ(lists[2].adds, "3");
   EXPECT_TRUE(lists[2].subs.empty());
   EXPECT_TRUE(lists[3].name == safe_browsing_util::kBinHashList);
   EXPECT_EQ(lists[3].adds, "4");
   EXPECT_TRUE(lists[3].subs.empty());
   EXPECT_TRUE(lists[4].name == safe_browsing_util::kCsdWhiteList);
   EXPECT_EQ(lists[4].adds, "5");
   EXPECT_TRUE(lists[4].subs.empty());
+  EXPECT_TRUE(lists[5].name == safe_browsing_util::kDownloadWhiteList);
+  EXPECT_EQ(lists[5].adds, "6");
+  EXPECT_TRUE(lists[5].subs.empty());
   database_.reset();
 }
 
 // Checks database reading and writing for browse.
 TEST_F(SafeBrowsingDatabaseTest, BrowseDatabase) {
   SBChunkList chunks;
   SBChunk chunk;
 
   // Add a simple chunk with one hostkey.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, "www.evil.com/",
@@ skipping 603 matching lines @@
 // corruption is detected in the midst of the update.
 // TODO(shess): Disabled until ScopedLogMessageIgnorer resolved.
 // http://crbug.com/56448
 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
   // Re-create the database in a captive message loop so that we can
   // influence task-posting.  Database specifically needs to the
   // file-backed.
   database_.reset();
   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
   SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile();
-  database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL));
+  database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL, NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
   SBChunkList chunks;
   SBChunk chunk;
@@ skipping 51 matching lines @@
 
 // Checks database reading and writing.
 TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrl) {
   database_.reset();
   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store,
                                               download_store,
-                                              csd_whitelist_store));
+                                              csd_whitelist_store,
+                                              NULL));
   database_->Init(database_filename_);
 
   const char kEvil1Host[] = "www.evil1.com/";
   const char kEvil1Url1[] = "www.evil1.com/download1/";
   const char kEvil1Url2[] = "www.evil1.com/download2.html";
 
   SBChunkList chunks;
   SBChunk chunk;
   // Add a simple chunk with one hostkey for download url list.
   InsertAddChunkHost2PrefixUrls(&chunk, 1, kEvil1Host,
@@ skipping 71 matching lines @@
   urls.clear();
   urls.push_back(GURL(std::string("http://") + kEvil1Url1));
   urls.push_back(GURL(std::string("https://") + kEvil1Url2));
   EXPECT_TRUE(database_->ContainsDownloadUrl(urls, &prefix_hits));
   ASSERT_EQ(prefix_hits.size(), 2U);
   EXPECT_EQ(prefix_hits[0], Sha256Prefix(kEvil1Url1));
   EXPECT_EQ(prefix_hits[1], Sha256Prefix(kEvil1Url2));
   database_.reset();
 }
 
-// Checks that the csd-whitelist is handled properly.
-TEST_F(SafeBrowsingDatabaseTest, CsdWhitelist) {
+// Checks that the whitelists are handled properly.
+TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
   database_.reset();
   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
-  // We expect all calls to ContainsCsdWhitelistedUrl to be made from the IO
-  // thread.
+  // We expect all calls to ContainsCsdWhitelistedUrl in particular to be made
+  // from the IO thread.  In general the whitelist lookups are thread-safe.
   BrowserThread io_thread(BrowserThread::IO, &loop);
 
   // If the whitelist is disabled everything should match the whitelist.
   database_.reset(new SafeBrowsingDatabaseNew(new SafeBrowsingStoreFile(),
-                                              NULL, NULL));
+                                              NULL, NULL, NULL));
   database_->Init(database_filename_);
-  EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
-      GURL(std::string("http://www.phishig.com/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.phishing.com/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.phishing.com/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf"));
 
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
+  SafeBrowsingStoreFile* download_whitelist_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store, NULL,
-                                              csd_whitelist_store));
+                                              csd_whitelist_store,
+                                              download_whitelist_store));
   database_->Init(database_filename_);
 
   const char kGood1Host[] = "www.good1.com/";
   const char kGood1Url1[] = "www.good1.com/a/b.html";
   const char kGood1Url2[] = "www.good1.com/b/";
 
   const char kGood2Host[] = "www.good2.com/";
   const char kGood2Url1[] = "www.good2.com/c";  // Should match '/c/bla'.
 
-  SBChunkList chunks;
+  // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist.
+  const char kGood3Host[] = "good3.com/";
+  const char kGood3Url1[] = "good3.com/";
+
+  const char kGoodString[] = "good_string";
+
+  SBChunkList download_chunks, csd_chunks;
   SBChunk chunk;
   // Add two simple chunks to the csd whitelist.
   InsertAddChunkHost2FullHashes(&chunk, 1, kGood1Host,
                                 kGood1Url1, kGood1Url2);
-  chunks.push_back(chunk);
+  csd_chunks.push_back(chunk);
 
   chunk.hosts.clear();
   InsertAddChunkHostFullHashes(&chunk, 2, kGood2Host, kGood2Url1);
-  chunks.push_back(chunk);
+  csd_chunks.push_back(chunk);
+
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 2, kGood2Host, kGood2Url1);
+  download_chunks.push_back(chunk);
+
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 3, kGoodString, kGoodString);
+  download_chunks.push_back(chunk);
+
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 4, kGood3Host, kGood3Url1);
+  download_chunks.push_back(chunk);
 
   std::vector<SBListChunkRanges> lists;
   EXPECT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks);
+  database_->InsertChunks(safe_browsing_util::kCsdWhiteList,
+                          csd_chunks);
+  database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
+                          download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Host)));
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Url1)));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Url1 + "?a=b")));
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Url2)));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood1Url2 + "/c.html")));
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood1Url2 + "/c.html")));
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood2Url1 + "/c")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
 
   EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.google.com/"))));
 
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://") + kGood2Url1 + "/c")));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
+
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://good3.com/a/b/c/d/e/f/g/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://a.b.good3.com/"))));
+
+  EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf"));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
+
+  EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.google.com/"))));
+
   // Test that the kill-switch works as intended.
-  chunks.clear();
+  csd_chunks.clear();
+  download_chunks.clear();
   lists.clear();
-  SBChunk chunk2;
-  InsertAddChunkHostFullHashes(&chunk2, 3, "sb-ssl.google.com/",
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 5, "sb-ssl.google.com/",
                                "sb-ssl.google.com/safebrowsing/csd/killswitch");
-  chunks.push_back(chunk2);
+  csd_chunks.push_back(chunk);
+
+  chunk.hosts.clear();
+  InsertAddChunkHostFullHashes(&chunk, 5, "sb-ssl.google.com/",
+                               "sb-ssl.google.com/safebrowsing/csd/killswitch");
+  download_chunks.push_back(chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks);
+  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks);
+  database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
+                          download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood1Url2 + "/c.html")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.google.com/"))));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.phishing_url.com/"))));
 
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.google.com/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.phishing_url.com/"))));
+
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedString("asdf"));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
+
   // Remove the kill-switch and verify that we can recover.
-  chunks.clear();
+  csd_chunks.clear();
+  download_chunks.clear();
   lists.clear();
   SBChunk sub_chunk;
-  InsertSubChunkHostFullHash(&sub_chunk, 1, 3,
+  InsertSubChunkHostFullHash(&sub_chunk, 1, 5,
                              "sb-ssl.google.com/",
                              "sb-ssl.google.com/safebrowsing/csd/killswitch");
-  chunks.push_back(sub_chunk);
+  csd_chunks.push_back(sub_chunk);
+
+  sub_chunk.hosts.clear();
+  InsertSubChunkHostFullHash(&sub_chunk, 1, 5,
+                             "sb-ssl.google.com/",
+                             "sb-ssl.google.com/safebrowsing/csd/killswitch");
+  download_chunks.push_back(sub_chunk);
 
   EXPECT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks);
+  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, csd_chunks);
+  database_->InsertChunks(safe_browsing_util::kDownloadWhiteList,
+                          download_chunks);
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood1Url2 + "/c.html")));
   EXPECT_TRUE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
   EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.google.com/"))));
   EXPECT_FALSE(database_->ContainsCsdWhitelistedUrl(
       GURL(std::string("http://www.phishing_url.com/"))));
 
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("https://good3.com/"))));
+  EXPECT_TRUE(database_->ContainsDownloadWhitelistedString(kGoodString));
+  EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.google.com/"))));
+  EXPECT_FALSE(database_->ContainsDownloadWhitelistedUrl(
+      GURL(std::string("http://www.phishing_url.com/"))));
+  EXPECT_FALSE(database_->ContainsDownloadWhitelistedString("asdf"));
+
   database_.reset();
 }
 
 // Test to make sure we could insert chunk list that
 // contains entries for the same host.
 TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) {
   SBChunk chunk;
 
   // Add a malware add chunk with two entries of the same host.
   InsertAddChunkHostPrefixUrl(&chunk, 1, "www.evil.com/",
@@ skipping 92 matching lines @@
 TEST_F(SafeBrowsingDatabaseTest, BinHashInsertLookup) {
   const SBPrefix kPrefix1 = 0x31313131;
   const SBPrefix kPrefix2 = 0x32323232;
   const SBPrefix kPrefix3 = 0x33333333;
   database_.reset();
   MessageLoop loop(MessageLoop::TYPE_DEFAULT);
   SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
   SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
   database_.reset(new SafeBrowsingDatabaseNew(browse_store,
                                               download_store,
-                                              NULL));
+                                              NULL, NULL));
   database_->Init(database_filename_);
 
   SBChunkList chunks;
   SBChunk chunk;
   // Insert one host.
   InsertAddChunkHostPrefixValue(&chunk, 1, 0, kPrefix1);
   // Insert a second host, which has the same host prefix as the first one.
   InsertAddChunkHostPrefixValue(&chunk, 1, 0, kPrefix2);
   chunks.push_back(chunk);
 
@@ skipping 69 matching lines @@
 
   // Simply calling |UpdateStarted()| then |UpdateFinished()| does not
   // update the database file.
   ASSERT_TRUE(file_util::SetLastModifiedTime(filename, old_last_modified));
   ASSERT_TRUE(file_util::GetFileInfo(filename, &before_info));
   EXPECT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
   ASSERT_TRUE(file_util::GetFileInfo(filename, &after_info));
   EXPECT_EQ(before_info.last_modified, after_info.last_modified);
 }