Add support for a module whitelist (goog-whitemodule-digest256) to the safe browsing db

chrome/browser/safe_browsing/safe_browsing_database_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <stddef.h>
 #include <utility>
@@ skipping 262 matching lines @@
     SafeBrowsingStoreFile* download_whitelist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* inclusion_whitelist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* extension_blacklist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* ip_blacklist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* unwanted_software_store =
         new SafeBrowsingStoreFile(task_runner_);
+    SafeBrowsingStoreFile* module_whitelist_store =
+        new SafeBrowsingStoreFile(task_runner_);
     database_.reset(new SafeBrowsingDatabaseNew(
         task_runner_, browse_store, download_store, csd_whitelist_store,
         download_whitelist_store, inclusion_whitelist_store,
-        extension_blacklist_store, ip_blacklist_store,
-        unwanted_software_store));
+        extension_blacklist_store, ip_blacklist_store, unwanted_software_store,
+        module_whitelist_store));
     database_->Init(database_filename_);
   }
 
   bool ContainsDownloadUrl(const std::vector<GURL>& urls,
                            std::vector<SBPrefix>* prefix_hits) {
     std::vector<SBPrefix> prefixes;
     SafeBrowsingDatabase::GetDownloadUrlPrefixes(urls, &prefixes);
     return database_->ContainsDownloadUrlPrefixes(prefixes, prefix_hits);
   }
 
@@ skipping 135 matching lines @@
                           chunks);
 
   chunks.clear();
   chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120));
   database_->InsertChunks(kIPBlacklist, chunks);
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html"));
   database_->InsertChunks(kUnwantedUrlList, chunks);
 
+  chunks.clear();
+  chunks.push_back(AddChunkPrefixValue(12, "chrome.dll"));
+  database_->InsertChunks(kModuleWhitelist, chunks);
+
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  ASSERT_EQ(9U, lists.size());
+  ASSERT_EQ(10U, lists.size());
   EXPECT_EQ(kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
   EXPECT_EQ(kPhishingList, lists[1].name);
   EXPECT_EQ("2", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
   EXPECT_EQ(kBinUrlList, lists[2].name);
   EXPECT_EQ("3", lists[2].adds);
   EXPECT_TRUE(lists[2].subs.empty());
   EXPECT_EQ(kCsdWhiteList, lists[3].name);
   EXPECT_EQ("5", lists[3].adds);
   EXPECT_TRUE(lists[3].subs.empty());
   EXPECT_EQ(kDownloadWhiteList, lists[4].name);
   EXPECT_EQ("6", lists[4].adds);
   EXPECT_TRUE(lists[4].subs.empty());
   EXPECT_EQ(kInclusionWhitelist, lists[5].name);
   EXPECT_EQ("7", lists[5].adds);
   EXPECT_TRUE(lists[5].subs.empty());
   EXPECT_EQ(kExtensionBlacklist, lists[6].name);
   EXPECT_EQ("8", lists[6].adds);
   EXPECT_TRUE(lists[6].subs.empty());
   EXPECT_EQ(kIPBlacklist, lists[7].name);
   EXPECT_EQ("10", lists[7].adds);
   EXPECT_TRUE(lists[7].subs.empty());
   EXPECT_EQ(kUnwantedUrlList, lists[8].name);
   EXPECT_EQ("11", lists[8].adds);
   EXPECT_TRUE(lists[8].subs.empty());
+  EXPECT_EQ(kModuleWhitelist, lists[9].name);
+  EXPECT_EQ("12", lists[9].adds);
+  EXPECT_TRUE(lists[9].subs.empty());
 
   database_.reset();
 }
 
 // Checks database reading and writing for browse and unwanted PrefixSets.
 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
 
   struct TestCase {
     using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)(
         const GURL& url,
@@ skipping 662 matching lines @@
 // 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();
   base::MessageLoop loop;
   SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile(task_runner_);
   database_.reset(new SafeBrowsingDatabaseNew(
-      task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL));
+      task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
   std::vector<scoped_ptr<SBChunkData>> chunks;
   chunks.push_back(SubChunkPrefixValue(7,
@@ skipping 128 matching lines @@
 }
 
 // Checks that the whitelists are handled properly.
 TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
   struct TestCase {
     using TestListContainsWhitelistedUrl =
         bool (SafeBrowsingDatabase::*)(const GURL& url);
     using TestListContainsWhitelistedString =
         bool (SafeBrowsingDatabase::*)(const std::string& str);
 
+    // Returns true if urls should be tested in this test case (i.e.
+    // |test_list_contains_whitelisted_url| is not null).
+    bool TestUrls() const {
+      return test_list_contains_whitelisted_url != nullptr;
+    }
+
     // Returns true if strings should be tested in this test case (i.e.
     // |test_list_contains_whitelisted_string| is not null).
     bool TestStrings() const {
       return test_list_contains_whitelisted_string != nullptr;
     }
 
     const char* test_list_name;
     TestListContainsWhitelistedUrl test_list_contains_whitelisted_url;
     // Optional test case field, if set the tested whitelist will also be tested
     // for strings.
     TestListContainsWhitelistedString test_list_contains_whitelisted_string;
   } const kTestCases[]{
-      {kCsdWhiteList,
-       &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl,
+      {kCsdWhiteList, &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl,
        nullptr},
       {kDownloadWhiteList,
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl,
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedString},
       {kInclusionWhitelist,
-       &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl,
-       nullptr},
+       &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl, nullptr},
+      {kModuleWhitelist, nullptr,
+       &SafeBrowsingDatabase::ContainsModuleWhitelistedString},
   };
 
   // If the whitelist is disabled everything should match the whitelist.
   database_.reset(new SafeBrowsingDatabaseNew(
       task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL,
-      NULL, NULL, NULL, NULL));
+      NULL, NULL, NULL, NULL, NULL));
   database_->Init(database_filename_);
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.phishing.com/"))));
+    if (test_case.TestUrls()) {
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.phishing.com/"))));
+    }
     if (test_case.TestStrings()) {
       EXPECT_TRUE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               "asdf"));
     }
   }
   ResetAndReloadFullDatabase();
 
   // Now test every whitelist one-by-one; intentionally not resetting the
   // database in-between to further stress potential inter-dependencies.
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
     const char kGood1Host[] = "www.good1.com/";
     const char kGood1Url1[] = "www.good1.com/a/b.html";
     const char kGood1Url2[] = "www.good1.com/b/";
 
     const char kGood2Url1[] = "www.good2.com/c";  // Should match '/c/bla'.
 
     // good3.com/a/b/c/d/e/f/g/ should match because it's a whitelist.
     const char kGood3Url1[] = "good3.com/";
 
     const char kGoodString[] = "good_string";
 
     // Nothing should be whitelisted before the database receives the chunks.
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Host)));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url1)));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url2)));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood2Url1)));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood3Url1)));
+    if (test_case.TestUrls()) {
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Host)));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url1)));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url2)));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood2Url1)));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood3Url1)));
+    }
     if (test_case.TestStrings()) {
-      EXPECT_FALSE(
-          (database_.get()->*test_case.test_list_contains_whitelisted_string)(
-              kGoodString));
+      if (test_case.test_list_name == kModuleWhitelist) {
+        // For the module whitelist, everything should be whitelisted before
+        // the database receives the chunks.
+        EXPECT_TRUE(
+            (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+                kGoodString));
+        EXPECT_TRUE(
+            (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+                "asdf"));
+      } else {
+        EXPECT_FALSE(
+            (database_.get()->*test_case.test_list_contains_whitelisted_string)(
+                kGoodString));
+      }
     }
 
     std::vector<scoped_ptr<SBChunkData>> chunks;
 
     // Add a few test chunks to the whitelist under test.
-    chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2));
-    chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
+    if (test_case.TestUrls()) {
+      chunks.push_back(AddChunkFullHash2Value(1, kGood1Url1, kGood1Url2));
+      chunks.push_back(AddChunkFullHashValue(2, kGood2Url1));
+      chunks.push_back(AddChunkFullHashValue(4, kGood3Url1));
+    }
     if (test_case.TestStrings())
       chunks.push_back(AddChunkFullHashValue(3, kGoodString));
-    chunks.push_back(AddChunkFullHashValue(4, kGood3Url1));
 
     std::vector<SBListChunkRanges> lists;
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Host)));
+    if (test_case.TestUrls()) {
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Host)));
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url1)));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url1 + "?a=b")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url1)));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url1 + "?a=b")));
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url2)));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood1Url2 + "/c.html")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url2)));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood1Url2 + "/c.html")));
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("https://") + kGood1Url2 + "/c.html")));
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood2Url1 + "/c")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood2Url1 + "/c")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood2Url1 + "/c?bla")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood2Url1 + "/c/bla")));
 
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.google.com/"))));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.google.com/"))));
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://") + kGood3Url1 + "a/b/c/d/e/f/g/")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://a.b.") + kGood3Url1)));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://") + kGood3Url1 + "a/b/c/d/e/f/g/")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://a.b.") + kGood3Url1)));
+    }
 
     if (test_case.TestStrings()) {
       EXPECT_FALSE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               "asdf"));
       EXPECT_TRUE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               kGoodString));
     }
 
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.google.com/"))));
-
     // The malware kill switch is for the CSD whitelist only.
     if (test_case.test_list_name == kCsdWhiteList) {
       // The CSD whitelist killswitch is not present.
       EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
 
       // Test only add the malware IP killswitch
       chunks.clear();
       chunks.push_back(AddChunkFullHashValue(
           15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware"));
 
@@ skipping 16 matching lines @@
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
     // Test CSD whitelist specific methods.
     if (test_case.test_list_name == kCsdWhiteList) {
       // The CSD whitelist killswitch is present.
       EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn());
       EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
     }
 
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("https://") + kGood1Url2 + "/c.html")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.google.com/"))));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.phishing_url.com/"))));
+    if (test_case.TestUrls()) {
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.google.com/"))));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.phishing_url.com/"))));
+    }
 
     if (test_case.TestStrings()) {
       EXPECT_TRUE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               "asdf"));
       EXPECT_TRUE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               kGoodString));
     }
 
     // Remove the kill-switch and verify that we can recover.
     chunks.clear();
     lists.clear();
     chunks.push_back(SubChunkFullHashValue(
         1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
     if (test_case.test_list_name == kCsdWhiteList) {
       chunks.push_back(SubChunkFullHashValue(
           10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15));
     }
 
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(test_case.test_list_name, chunks);
     database_->UpdateFinished(true);
 
     if (test_case.test_list_name == kCsdWhiteList) {
       EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
       EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
     }
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("https://") + kGood1Url2 + "/c.html")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
-    EXPECT_TRUE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("https://") + kGood3Url1)));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.google.com/"))));
-    EXPECT_FALSE(
-        (database_.get()->*test_case.test_list_contains_whitelisted_url)(
-            GURL(std::string("http://www.phishing_url.com/"))));
+    if (test_case.TestUrls()) {
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("https://") + kGood1Url2 + "/c.html")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("https://") + kGood2Url1 + "/c/bla")));
+      EXPECT_TRUE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("https://") + kGood3Url1)));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.google.com/"))));
+      EXPECT_FALSE(
+          (database_.get()->*test_case.test_list_contains_whitelisted_url)(
+              GURL(std::string("http://www.phishing_url.com/"))));
+    }
     if (test_case.TestStrings()) {
       EXPECT_TRUE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               kGoodString));
       EXPECT_FALSE(
           (database_.get()->*test_case.test_list_contains_whitelisted_string)(
               "asdf"));
     }
   }
 }
@@ skipping 722 matching lines @@
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }
 
 }  // namespace safe_browsing