Measure how often downloaded executables match the download whitelist.

chrome/browser/safe_browsing/download_protection_service.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.
 
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
@@ skipping 49 matching lines @@
       public content::URLFetcherDelegate {
  public:
   CheckClientDownloadRequest(const DownloadInfo& info,
                              const CheckDownloadCallback& callback,
                              DownloadProtectionService* service,
                              SafeBrowsingService* sb_service)
       : info_(info),
         callback_(callback),
         service_(service),
         sb_service_(sb_service),
-        pingback_enabled_(service_->enabled()) {
+        pingback_enabled_(service_->enabled()),
+        is_signed_(false) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   void Start() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     // TODO(noelutz): implement some cache to make sure we don't issue the same
     // request over and over again if a user downloads the same binary multiple
     // times.
     if (info_.download_url_chain.empty()) {
       RecordStats(REASON_INVALID_URL);
@@ skipping 74 matching lines @@
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class DeleteTask<CheckClientDownloadRequest>;
 
   virtual ~CheckClientDownloadRequest() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   void ExtractFileFeatures() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    bool is_signed;
     if (safe_browsing::signature_util::IsSigned(info_.local_file)) {
       VLOG(2) << "Downloaded a signed binary: " << info_.local_file.value();
-      is_signed = true;
+      is_signed_ = true;
     } else {
       VLOG(2) << "Downloaded an unsigned binary: " << info_.local_file.value();
-      is_signed = false;
+      is_signed_ = false;
     }
-    UMA_HISTOGRAM_BOOLEAN("SBClientDownload.SignedBinaryDownload", is_signed);
+    UMA_HISTOGRAM_BOOLEAN("SBClientDownload.SignedBinaryDownload", is_signed_);
 
     // TODO(noelutz): DownloadInfo should also contain the IP address of every
     // URL in the redirect chain.  We also should check whether the download
     // URL is hosted on the internal network.
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&CheckClientDownloadRequest::CheckWhitelists, this));
   }
 
   void CheckWhitelists() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     DownloadCheckResultReason reason = REASON_MAX;
-    if (!pingback_enabled_ || !sb_service_.get()) {
+    if (!sb_service_.get()) {
       reason = REASON_SB_DISABLED;
     } else {
       for (size_t i = 0; i < info_.download_url_chain.size(); ++i) {
         const GURL& url = info_.download_url_chain[i];
         if (url.is_valid() && sb_service_->MatchDownloadWhitelistUrl(url)) {
           reason = REASON_WHITELISTED_URL;
           break;
         }
       }
-      if (info_.referrer_url.is_valid() &&
+      if (info_.referrer_url.is_valid() && reason == REASON_MAX &&
           sb_service_->MatchDownloadWhitelistUrl(info_.referrer_url)) {
         reason = REASON_WHITELISTED_REFERRER;
       }
+      if (reason != REASON_MAX || is_signed_) {
+        UMA_HISTOGRAM_COUNTS("SBClientDownload.SignedOrWhitelistedDownload", 1);
+      }
     }
     if (reason != REASON_MAX) {
       RecordStats(reason);
       PostFinishTask(SAFE);
-      return;
+    } else if (!pingback_enabled_) {
+      RecordStats(REASON_SB_DISABLED);
+      PostFinishTask(SAFE);
+    } else {
+      // TODO(noelutz): check signature and CA against whitelist.
+
+      // The URLFetcher is owned by the UI thread, so post a message to
+      // start the pingback.
+      BrowserThread::PostTask(
+          BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&CheckClientDownloadRequest::SendRequest, this));
     }
-
-    // TODO(noelutz): check signature and CA against whitelist.
-
-    // The URLFetcher is owned by the UI thread, so post a message to
-    // start the pingback.
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::SendRequest, this));
   }
 
   void SendRequest() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     // This is our last chance to check whether the request has been canceled
     // before sending it.
     if (!service_) {
+      RecordStats(REASON_REQUEST_CANCELED);
       FinishRequest(SAFE);
       return;
     }
 
     ClientDownloadRequest request;
     request.set_url(info_.download_url_chain.back().spec());
     request.mutable_digests()->set_sha256(info_.sha256_hash);
     request.set_length(info_.total_bytes);
     for (size_t i = 0; i < info_.download_url_chain.size(); ++i) {
       ClientDownloadRequest::Resource* resource = request.add_resources();
@@ skipping 48 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("SBClientDownload.CheckDownloadStats",
                               reason,
                               REASON_MAX);
   }
 
   DownloadInfo info_;
   CheckDownloadCallback callback_;
   // Will be NULL if the request has been canceled.
   DownloadProtectionService* service_;
   scoped_refptr<SafeBrowsingService> sb_service_;
-  bool pingback_enabled_;
+  const bool pingback_enabled_;
+  bool is_signed_;
   scoped_ptr<content::URLFetcher> fetcher_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClientDownloadRequest);
 };
 
 DownloadProtectionService::DownloadProtectionService(
     SafeBrowsingService* sb_service,
     net::URLRequestContextGetter* request_context_getter)
     : sb_service_(sb_service),
       request_context_getter_(request_context_getter),
@@ skipping 37 matching lines @@
 void DownloadProtectionService::RequestFinished(
     CheckClientDownloadRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::set<scoped_refptr<CheckClientDownloadRequest> >::iterator it =
       download_requests_.find(request);
   DCHECK(it != download_requests_.end());
   download_requests_.erase(*it);
 }
 
 }  // namespace safe_browsing