Send malware reports when a user opts-in from the safe browsing interstitial ...

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2010 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/protocol_manager.h"
 
 #ifndef NDEBUG
 #include "base/base64.h"
 #endif
 #include "base/environment.h"
@@ skipping 29 matching lines @@
 
 
 // SafeBrowsingProtocolManager implementation ----------------------------------
 
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingService* sb_service,
     const std::string& client_name,
     const std::string& client_key,
     const std::string& wrapped_key,
     URLRequestContextGetter* request_context_getter,
-    const std::string& info_url_prefix,
-    const std::string& mackey_url_prefix,
+    const std::string& http_url_prefix,
+    const std::string& https_url_prefix,
     bool disable_auto_update)
     : sb_service_(sb_service),
       request_type_(NO_REQUEST),
       update_error_count_(0),
       gethash_error_count_(0),
       update_back_off_mult_(1),
       gethash_back_off_mult_(1),
       next_update_sec_(-1),
       update_state_(FIRST_REQUEST),
       initial_request_(true),
       chunk_pending_to_write_(false),
       client_key_(client_key),
       wrapped_key_(wrapped_key),
       update_size_(0),
       client_name_(client_name),
       request_context_getter_(request_context_getter),
-      info_url_prefix_(info_url_prefix),
-      mackey_url_prefix_(mackey_url_prefix),
+      http_url_prefix_(http_url_prefix),
+      https_url_prefix_(https_url_prefix),
       disable_auto_update_(disable_auto_update) {
-  DCHECK(!info_url_prefix_.empty() && !mackey_url_prefix_.empty());
+  DCHECK(!http_url_prefix_.empty() && !https_url_prefix_.empty());
 
   // Set the backoff multiplier fuzz to a random value between 0 and 1.
   back_off_fuzz_ = static_cast<float>(base::RandDouble());
   // The first update must happen between 1-5 minutes of start up.
   next_update_sec_ = base::RandInt(60, kSbTimerStartIntervalSec);
 
   chrome::VersionInfo version_info;
   if (!version_info.is_valid() || version_info.Version().empty())
     version_ = "0.1";
   else
     version_ = version_info.Version();
 }
 
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
   hash_requests_.clear();
 
-  // Delete in-progress safebrowsing reports.
+  // Delete in-progress safebrowsing reports (hits and details).
   STLDeleteContainerPointers(safebrowsing_reports_.begin(),
                              safebrowsing_reports_.end());
   safebrowsing_reports_.clear();
 }
 
 // Public API used by the SafeBrowsingService ----------------------------------
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
@@ skipping 479 matching lines @@
   chunk_pending_to_write_ = false;
 
   if (chunk_request_urls_.empty()) {
     UMA_HISTOGRAM_LONG_TIMES("SB2.Update", Time::Now() - last_update_);
     UpdateFinished(true);
   } else {
     IssueChunkRequest();
   }
 }
 
+// Sends a SafeBrowsing "hit" for UMA users.
 void SafeBrowsingProtocolManager::ReportSafeBrowsingHit(
     const GURL& malicious_url,
     const GURL& page_url,
     const GURL& referrer_url,
     bool is_subresource,
     SafeBrowsingService::UrlCheckResult threat_type) {
-  GURL report_url = SafeBrowsingReportUrl(malicious_url, page_url,
-                                          referrer_url, is_subresource,
-                                          threat_type);
+  GURL report_url = SafeBrowsingHitUrl(malicious_url, page_url,
+                                       referrer_url, is_subresource,
+                                       threat_type);
   URLFetcher* report = new URLFetcher(report_url, URLFetcher::GET, this);
   report->set_load_flags(net::LOAD_DISABLE_CACHE);
   report->set_request_context(request_context_getter_);
   report->Start();
   safebrowsing_reports_.insert(report);
 }
 
+// Sends malware details for users who opt-in.
+void SafeBrowsingProtocolManager::ReportMalwareDetails(
+    const std::string& report) {
+  GURL report_url = MalwareDetailsUrl();
+  URLFetcher* fetcher = new URLFetcher(report_url, URLFetcher::POST, this);
+  fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
+  fetcher->set_request_context(request_context_getter_);
+  fetcher->set_upload_data("application/octet-stream", report);
+  // Don't try too hard to send reports on failures.
+  fetcher->set_automatically_retry_on_5xx(false);
+  fetcher->Start();
+  safebrowsing_reports_.insert(fetcher);
+}
+
+
 // static
 std::string SafeBrowsingProtocolManager::FormatList(
     const SBListChunkRanges& list, bool use_mac) {
   std::string formatted_results;
   formatted_results.append(list.name);
   formatted_results.append(";");
   if (!list.adds.empty()) {
     formatted_results.append("a:" + list.adds);
     if (!list.subs.empty() || use_mac)
       formatted_results.append(":");
@@ skipping 38 matching lines @@
                                  client_name.c_str(), version.c_str());
   if (!additional_query.empty()) {
     DCHECK(url.find("?") != std::string::npos);
     url.append("&");
     url.append(additional_query);
   }
   return url;
 }
 
 GURL SafeBrowsingProtocolManager::UpdateUrl(bool use_mac) const {
-  std::string url = ComposeUrl(info_url_prefix_, "downloads", client_name_,
+  std::string url = ComposeUrl(http_url_prefix_, "downloads", client_name_,
                                version_, additional_query_);
   if (use_mac) {
     url.append("&wrkey=");
     url.append(wrapped_key_);
   }
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::GetHashUrl(bool use_mac) const {
-  std::string url= ComposeUrl(info_url_prefix_, "gethash", client_name_,
+  std::string url= ComposeUrl(http_url_prefix_, "gethash", client_name_,
                               version_, additional_query_);
   if (use_mac) {
     url.append("&wrkey=");
     url.append(wrapped_key_);
   }
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::MacKeyUrl() const {
-  return GURL(ComposeUrl(mackey_url_prefix_, "newkey", client_name_, version_,
+  return GURL(ComposeUrl(https_url_prefix_, "newkey", client_name_, version_,
                          additional_query_));
 }
 
-GURL SafeBrowsingProtocolManager::SafeBrowsingReportUrl(
+GURL SafeBrowsingProtocolManager::SafeBrowsingHitUrl(
     const GURL& malicious_url, const GURL& page_url,
     const GURL& referrer_url, bool is_subresource,
     SafeBrowsingService::UrlCheckResult threat_type) const {
   DCHECK(threat_type == SafeBrowsingService::URL_MALWARE ||
          threat_type == SafeBrowsingService::URL_PHISHING);
-  std::string url = ComposeUrl(info_url_prefix_, "report", client_name_,
+  // The malware and phishing hits go over HTTP.
+  std::string url = ComposeUrl(http_url_prefix_, "report", client_name_,
                                version_, additional_query_);
   return GURL(StringPrintf("%s&evts=%s&evtd=%s&evtr=%s&evhr=%s&evtb=%d",
       url.c_str(),
       (threat_type == SafeBrowsingService::URL_MALWARE) ?
                            "malblhit" : "phishblhit",
       EscapeQueryParamValue(malicious_url.spec(), true).c_str(),
       EscapeQueryParamValue(page_url.spec(), true).c_str(),
       EscapeQueryParamValue(referrer_url.spec(), true).c_str(),
       is_subresource));
 }
 
+GURL SafeBrowsingProtocolManager::MalwareDetailsUrl() const {
+  // The malware details go over HTTPS.
+  std::string url = StringPrintf(
+          "%s/clientreport/malware?client=%s&appver=%s&pver=1.0",
+          https_url_prefix_.c_str(),
+          client_name_.c_str(),
+          version_.c_str());
+  return GURL(url);
+}
+
 GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
   std::string next_url;
   if (!StartsWithASCII(url, "http://", false) &&
       !StartsWithASCII(url, "https://", false)) {
     next_url.append("http://");
     next_url.append(url);
   } else {
     next_url = url;
   }
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }