chrome/browser/safe_browsing/ping_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/safe_browsing/ping_manager.h"
   6
   7 #include "base/logging.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "chrome/browser/net/certificate_error_reporter.h"
  12 #include "chrome/common/env_vars.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "google_apis/google_api_keys.h"
  15 #include "net/base/escape.h"
  16 #include "net/base/load_flags.h"
  17 #include "net/ssl/ssl_info.h"
  18 #include "net/url_request/certificate_report_sender.h"
  19 #include "net/url_request/url_fetcher.h"
  20 #include "net/url_request/url_request_context_getter.h"
  21 #include "net/url_request/url_request_status.h"
  22 #include "url/gurl.h"
  23
  24 using chrome_browser_net::CertificateErrorReporter;
  25 using content::BrowserThread;
  26
  27 namespace {
  28 // URLs to upload invalid certificate chain reports. The HTTP URL is
  29 // preferred since a client seeing an invalid cert might not be able to
  30 // make an HTTPS connection to report it.
  31 const char kExtendedReportingUploadUrlInsecure[] =
  32     "http://safebrowsing.googleusercontent.com/safebrowsing/clientreport/"
  33     "chrome-certs";
  34 const char kExtendedReportingUploadUrlSecure[] =
  35     "https://sb-ssl.google.com/safebrowsing/clientreport/chrome-certs";
  36 }  // namespace
  37
  38 // SafeBrowsingPingManager implementation ----------------------------------
  39
  40 // static
  41 SafeBrowsingPingManager* SafeBrowsingPingManager::Create(
  42     net::URLRequestContextGetter* request_context_getter,
  43     const SafeBrowsingProtocolConfig& config) {
  44   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  45   return new SafeBrowsingPingManager(request_context_getter, config);
  46 }
  47
  48 SafeBrowsingPingManager::SafeBrowsingPingManager(
  49     net::URLRequestContextGetter* request_context_getter,
  50     const SafeBrowsingProtocolConfig& config)
  51     : client_name_(config.client_name),
  52       request_context_getter_(request_context_getter),
  53       url_prefix_(config.url_prefix) {
  54   DCHECK(!url_prefix_.empty());
  55
  56   if (request_context_getter) {
  57     // Set the upload URL and whether or not to send cookies with
  58     // certificate reports sent to Safe Browsing servers.
  59     bool use_insecure_certificate_upload_url =
  60         CertificateErrorReporter::IsHttpUploadUrlSupported();
  61
  62     net::CertificateReportSender::CookiesPreference cookies_preference;
  63     GURL certificate_upload_url;
  64     if (use_insecure_certificate_upload_url) {
  65       cookies_preference = net::CertificateReportSender::DO_NOT_SEND_COOKIES;
  66       certificate_upload_url = GURL(kExtendedReportingUploadUrlInsecure);
  67     } else {
  68       cookies_preference = net::CertificateReportSender::SEND_COOKIES;
  69       certificate_upload_url = GURL(kExtendedReportingUploadUrlSecure);
  70     }
  71
  72     certificate_error_reporter_.reset(new CertificateErrorReporter(
  73         request_context_getter->GetURLRequestContext(), certificate_upload_url,
  74         cookies_preference));
  75   }
  76
  77   version_ = SafeBrowsingProtocolManagerHelper::Version();
  78 }
  79
  80 SafeBrowsingPingManager::~SafeBrowsingPingManager() {
  81   // Delete in-progress safebrowsing reports (hits and details).
  82   STLDeleteContainerPointers(safebrowsing_reports_.begin(),
  83                              safebrowsing_reports_.end());
  84 }
  85
  86 // net::URLFetcherDelegate implementation ----------------------------------
  87
  88 // All SafeBrowsing request responses are handled here.
  89 void SafeBrowsingPingManager::OnURLFetchComplete(
  90     const net::URLFetcher* source) {
  91   Reports::iterator sit = safebrowsing_reports_.find(source);
  92   DCHECK(sit != safebrowsing_reports_.end());
  93   delete *sit;
  94   safebrowsing_reports_.erase(sit);
  95 }
  96
  97 // Sends a SafeBrowsing "hit" for UMA users.
  98 void SafeBrowsingPingManager::ReportSafeBrowsingHit(
  99     const GURL& malicious_url,
 100     const GURL& page_url,
 101     const GURL& referrer_url,
 102     bool is_subresource,
 103     SBThreatType threat_type,
 104     const std::string& post_data,
 105     bool is_extended_reporting) {
 106   GURL report_url =
 107       SafeBrowsingHitUrl(malicious_url, page_url, referrer_url, is_subresource,
 108                          threat_type, is_extended_reporting);
 109   net::URLFetcher* report =
 110       net::URLFetcher::Create(
 111           report_url,
 112           post_data.empty() ? net::URLFetcher::GET : net::URLFetcher::POST,
 113           this).release();
 114   report->SetLoadFlags(net::LOAD_DISABLE_CACHE);
 115   report->SetRequestContext(request_context_getter_.get());
 116   if (!post_data.empty())
 117     report->SetUploadData("text/plain", post_data);
 118   safebrowsing_reports_.insert(report);
 119   report->Start();
 120 }
 121
 122 // Sends malware details for users who opt-in.
 123 void SafeBrowsingPingManager::ReportMalwareDetails(
 124     const std::string& report) {
 125   GURL report_url = MalwareDetailsUrl();
 126   net::URLFetcher* fetcher =
 127       net::URLFetcher::Create(report_url, net::URLFetcher::POST, this)
 128           .release();
 129   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
 130   fetcher->SetRequestContext(request_context_getter_.get());
 131   fetcher->SetUploadData("application/octet-stream", report);
 132   // Don't try too hard to send reports on failures.
 133   fetcher->SetAutomaticallyRetryOn5xx(false);
 134   fetcher->Start();
 135   safebrowsing_reports_.insert(fetcher);
 136 }
 137
 138 void SafeBrowsingPingManager::ReportInvalidCertificateChain(
 139     const std::string& serialized_report) {
 140   DCHECK(certificate_error_reporter_);
 141   certificate_error_reporter_->SendReport(
 142       CertificateErrorReporter::REPORT_TYPE_EXTENDED_REPORTING,
 143       serialized_report);
 144 }
 145
 146 void SafeBrowsingPingManager::SetCertificateErrorReporterForTesting(
 147     scoped_ptr<CertificateErrorReporter> certificate_error_reporter) {
 148   certificate_error_reporter_ = certificate_error_reporter.Pass();
 149 }
 150
 151 GURL SafeBrowsingPingManager::SafeBrowsingHitUrl(
 152     const GURL& malicious_url,
 153     const GURL& page_url,
 154     const GURL& referrer_url,
 155     bool is_subresource,
 156     SBThreatType threat_type,
 157     bool is_extended_reporting) const {
 158   DCHECK(threat_type == SB_THREAT_TYPE_URL_MALWARE ||
 159          threat_type == SB_THREAT_TYPE_URL_PHISHING ||
 160          threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
 161          threat_type == SB_THREAT_TYPE_BINARY_MALWARE_URL ||
 162          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL ||
 163          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL);
 164   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
 165       url_prefix_, "report", client_name_, version_, std::string(),
 166       is_extended_reporting);
 167   std::string threat_list = "none";
 168   switch (threat_type) {
 169     case SB_THREAT_TYPE_URL_MALWARE:
 170       threat_list = "malblhit";
 171       break;
 172     case SB_THREAT_TYPE_URL_PHISHING:
 173       threat_list = "phishblhit";
 174       break;
 175     case SB_THREAT_TYPE_URL_UNWANTED:
 176       threat_list = "uwsblhit";
 177       break;
 178     case SB_THREAT_TYPE_BINARY_MALWARE_URL:
 179       threat_list = "binurlhit";
 180       break;
 181     case SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL:
 182       threat_list = "phishcsdhit";
 183       break;
 184     case SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL:
 185       threat_list = "malcsdhit";
 186       break;
 187     default:
 188       NOTREACHED();
 189   }
 190   return GURL(base::StringPrintf("%s&evts=%s&evtd=%s&evtr=%s&evhr=%s&evtb=%d",
 191       url.c_str(), threat_list.c_str(),
 192       net::EscapeQueryParamValue(malicious_url.spec(), true).c_str(),
 193       net::EscapeQueryParamValue(page_url.spec(), true).c_str(),
 194       net::EscapeQueryParamValue(referrer_url.spec(), true).c_str(),
 195       is_subresource));
 196 }
 197
 198 GURL SafeBrowsingPingManager::MalwareDetailsUrl() const {
 199   std::string url = base::StringPrintf(
 200           "%s/clientreport/malware?client=%s&appver=%s&pver=1.0",
 201           url_prefix_.c_str(),
 202           client_name_.c_str(),
 203           version_.c_str());
 204   std::string api_key = google_apis::GetAPIKey();
 205   if (!api_key.empty()) {
 206     base::StringAppendF(&url, "&key=%s",
 207                         net::EscapeQueryParamValue(api_key, true).c_str());
 208   }
 209   return GURL(url);
 210 }