Add sampling of unknown filetypes in download protection.

chrome/browser/safe_browsing/download_protection_service_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.
 
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 20 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/safe_browsing/download_feedback_service.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/binary_feature_extractor.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
+#include "chrome/common/safe_browsing/file_type_policies_test_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
@@ skipping 219 matching lines @@
         .AppendASCII("download_protection");
 
     // Setup a profile
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     profile_.reset(new TestingProfile(profile_dir_.path()));
     ASSERT_TRUE(profile_->CreateHistoryService(true /* delete_file */,
                                                false /* no_db */));
 
     // Setup a directory to place test files in.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+
+    // Turn off binary sampling by default.
+    SetBinarySamplingProbability(0.0);
   }
 
   void TearDown() override {
     client_download_request_subscription_.reset();
     sb_service_->ShutDown();
     // Flush all of the thread message loops to ensure that there are no
     // tasks currently running.
     FlushThreadMessageLoops();
     sb_service_ = NULL;
   }
 
   void SetWhitelistedDownloadSampleRate(double target_rate) {
     download_service_->whitelist_sample_rate_ = target_rate;
   }
 
+  void SetBinarySamplingProbability(double target_rate) {
+    std::unique_ptr<DownloadFileTypeConfig> config =
+        policies_.DuplicateConfig();
+    config->set_sampled_ping_probability(target_rate);
+    policies_.SwapConfig(config);
+  }
+
   bool RequestContainsResource(const ClientDownloadRequest& request,
                                ClientDownloadRequest::ResourceType type,
                                const std::string& url,
                                const std::string& referrer) {
     for (int i = 0; i < request.resources_size(); ++i) {
       if (request.resources(i).url() == url &&
           request.resources(i).type() == type &&
           (referrer.empty() || request.resources(i).referrer() == referrer)) {
         return true;
       }
@@ skipping 196 matching lines @@
         is_extended_reporting);
   }
 
   // Check scenarios where we should/shouldn't send a report for
   // a corrupted zip.
   void CheckClientDownloadReportCorruptZip(bool is_extended_reporting,
                                            bool is_incognito);
 
 
  protected:
+  // This will effectivly mask the global Singleton while this is in scope.
+  FileTypePoliciesTestOverlay policies_;
+
   scoped_refptr<FakeSafeBrowsingService> sb_service_;
   scoped_refptr<MockBinaryFeatureExtractor> binary_feature_extractor_;
   DownloadProtectionService* download_service_;
   DownloadProtectionService::DownloadCheckResult result_;
   bool has_result_;
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
   base::FilePath testdata_path_;
   DownloadProtectionService::ClientDownloadRequestSubscription
       client_download_request_subscription_;
@@ skipping 283 matching lines @@
           .WillRepeatedly(Return(profile_.get()));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   EXPECT_FALSE(HasClientDownloadRequest());
 }
 
+TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSampledFile) {
+  // Server response will be discarded.
+  net::FakeURLFetcherFactory factory(NULL);
+  PrepareResponse(
+      &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+      net::URLRequestStatus::SUCCESS);
+
+  content::MockDownloadItem item;
+  PrepareBasicDownloadItem(
+    &item,
+    std::vector<std::string>(),   // empty url_chain
+    "http://www.google.com/",     // referrer
+    FILE_PATH_LITERAL("a.tmp"),   // tmp_path
+    FILE_PATH_LITERAL("a.foobar_unknown_ype"));  // final_path
+  EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
+      .Times(1);
+  EXPECT_CALL(*binary_feature_extractor_.get(),
+              ExtractImageFeatures(
+                  tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
+      .Times(1);
+  url_chain_.push_back(GURL("http://www.whitelist.com/a.foobar_unknown_type"));
+
+  // Set ping sample rate to 1.00 so download_service_ will always send a
+  // "light" ping for unknown types if allowed.
+  SetBinarySamplingProbability(1.0);
+
+  // Case (1): is_extended_reporting && is_incognito.
+  //           ClientDownloadRequest should NOT be sent.
+  SetExtendedReportingPreference(true);
+  EXPECT_CALL(item, GetBrowserContext())
+          .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
+  download_service_->CheckClientDownload(
+      &item,
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+  EXPECT_FALSE(HasClientDownloadRequest());
+
+  // Case (2): is_extended_reporting && !is_incognito.
+  //           A "light" ClientDownloadRequest should be sent.
+  EXPECT_CALL(item, GetBrowserContext())
+          .WillRepeatedly(Return(profile_.get()));
+  download_service_->CheckClientDownload(
+      &item,
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+  EXPECT_TRUE(HasClientDownloadRequest());
+  // Verify it's a "light" ping, check that URLs don't have paths, and
+  // and verify filename is just an extension.
+  auto* req = GetClientDownloadRequest();
+  EXPECT_EQ(ClientDownloadRequest::SAMPLED_UNSUPPORTED_FILE,
+            req->download_type());
+  EXPECT_EQ(GURL(req->url()).GetOrigin().spec(), req->url());
+  for (auto resource : req->resources()) {
+    EXPECT_EQ(GURL(resource.url()).GetOrigin().spec(), resource.url());
+    EXPECT_EQ(GURL(resource.referrer()).GetOrigin().spec(),
+              resource.referrer());
+  }
+  EXPECT_EQ('.', req->file_basename()[0]);
+
+  ClearClientDownloadRequest();
+
+  // Case (3): !is_extended_reporting && is_incognito.
+  //           ClientDownloadRequest should NOT be sent.
+  SetExtendedReportingPreference(false);
+  EXPECT_CALL(item, GetBrowserContext())
+          .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
+  download_service_->CheckClientDownload(
+      &item,
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+  EXPECT_FALSE(HasClientDownloadRequest());
+
+  // Case (4): !is_extended_reporting && !is_incognito.
+  //           ClientDownloadRequest should NOT be sent.
+  EXPECT_CALL(item, GetBrowserContext())
+          .WillRepeatedly(Return(profile_.get()));
+  download_service_->CheckClientDownload(
+      &item,
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+  EXPECT_FALSE(HasClientDownloadRequest());
+}
+
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadFetchFailed) {
   // HTTP request will fail.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_INTERNAL_SERVER_ERROR,
       net::URLRequestStatus::FAILED);
 
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
@@ skipping 1326 matching lines @@
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing