Add checkbox for reporting invalid TLS/SSL cert chains

chrome/browser/safe_browsing/ping_manager.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/ping_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/net/certificate_error_reporter.h"
 #include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
+#include "net/ssl/ssl_info.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
+#include "url/gurl.h"
 
+using chrome_browser_net::CertificateErrorReporter;
 using content::BrowserThread;
 
+namespace {
+// URL to upload invalid certificate chain reports
+// TODO(estark): Fill this in with the real URL when live.
+const char kExtendedReportingUploadUrl[] = "http://example.test";

[Ryan Sleevi, 2015/03/25 04:49:45]

What will ensure this gets fixed? This seems like a pretty far distance from the
actual code to report. I want to make sure we don't accidentally send reports
here.

An empty/invalid URL + a DCHECK() somewhere seems... safer?

[estark, 2015/03/25 05:34:33]

Done. Changed to an empty URL, and moved the DCHECK for an empty url from the
CertificateErrorReporter constructor to |SendReport|. (If I were to leave it in
the constructor, then it would trigger every time regardless of whether the
extended reporting switch or preference is set.)

+}  // namespace
+
 // SafeBrowsingPingManager implementation ----------------------------------
 
 // static
 SafeBrowsingPingManager* SafeBrowsingPingManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return new SafeBrowsingPingManager(request_context_getter, config);
 }
 
 SafeBrowsingPingManager::SafeBrowsingPingManager(
     net::URLRequestContextGetter* request_context_getter,
     const SafeBrowsingProtocolConfig& config)
     : client_name_(config.client_name),
       request_context_getter_(request_context_getter),
-      url_prefix_(config.url_prefix) {
+      url_prefix_(config.url_prefix),
+      certificate_error_reporter_(new CertificateErrorReporter(
+          request_context_getter->GetURLRequestContext(),
+          GURL(kExtendedReportingUploadUrl),
+          CertificateErrorReporter::SEND_COOKIES)) {

[Ryan Sleevi, 2015/03/25 04:49:45]

o_O

(Edit: ;( )

   DCHECK(!url_prefix_.empty());
 
   version_ = SafeBrowsingProtocolManagerHelper::Version();
 }
 
 SafeBrowsingPingManager::~SafeBrowsingPingManager() {
   // Delete in-progress safebrowsing reports (hits and details).
   STLDeleteContainerPointers(safebrowsing_reports_.begin(),
                              safebrowsing_reports_.end());
 }
@@ skipping 40 matching lines @@
       report_url, net::URLFetcher::POST, this);
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("application/octet-stream", report);
   // Don't try too hard to send reports on failures.
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->Start();
   safebrowsing_reports_.insert(fetcher);
 }
 
+void SafeBrowsingPingManager::ReportInvalidCertificateChain(
+    const std::string& hostname,
+    const net::SSLInfo& ssl_info) {
+  certificate_error_reporter_->SendReport(
+      CertificateErrorReporter::REPORT_TYPE_EXTENDED_REPORTING, hostname,
+      ssl_info);
+}
+
+void SafeBrowsingPingManager::SetCertificateErrorReporterForTesting(
+    scoped_ptr<CertificateErrorReporter> certificate_error_reporter) {
+  certificate_error_reporter_ = certificate_error_reporter.Pass();
+}
+
 GURL SafeBrowsingPingManager::SafeBrowsingHitUrl(
     const GURL& malicious_url, const GURL& page_url,
     const GURL& referrer_url, bool is_subresource,
     SBThreatType threat_type) const {
   DCHECK(threat_type == SB_THREAT_TYPE_URL_MALWARE ||
          threat_type == SB_THREAT_TYPE_URL_PHISHING ||
          threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
          threat_type == SB_THREAT_TYPE_BINARY_MALWARE_URL ||
          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL ||
          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL);
@@ skipping 36 matching lines @@
           url_prefix_.c_str(),
           client_name_.c_str(),
           version_.c_str());
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }