Initial (partial) implementation of HPKP violation reporting

net/http/transport_security_state.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 "net/http/transport_security_state.h"
 
 #if defined(USE_OPENSSL)
 #include <openssl/ecdsa.h>
 #include <openssl/ssl.h>
 #else  // !defined(USE_OPENSSL)
@@ skipping 501 matching lines @@
     return true;
   }
 
   return false;
 }
 
 bool TransportSecurityState::CheckPublicKeyPins(
     const std::string& host,
     bool is_issued_by_known_root,
     const HashValueVector& public_key_hashes,
+    uint16_t port,
+    const scoped_refptr<X509Certificate>& served_certificate_chain,
+    const scoped_refptr<X509Certificate>& validated_certificate_chain,
+    const PublicKeyPinReportStatus report_status,
     std::string* pinning_failure_log) {
   // Perform pin validation if, and only if, all these conditions obtain:
   //
   // * the server's certificate chain chains up to a known root (i.e. not a
   //   user-installed trust anchor); and
   // * the server actually has public key pins.
   if (!is_issued_by_known_root || !HasPublicKeyPins(host)) {
     return true;
   }
 
-  bool pins_are_valid =
-      CheckPublicKeyPinsImpl(host, public_key_hashes, pinning_failure_log);
+  bool pins_are_valid = CheckPublicKeyPinsImpl(
+      host, public_key_hashes, port, served_certificate_chain,
+      validated_certificate_chain, report_status, pinning_failure_log);
   if (!pins_are_valid) {
     LOG(ERROR) << *pinning_failure_log;
     ReportUMAOnPinFailure(host);
   }
 
   UMA_HISTOGRAM_BOOLEAN("Net.PublicKeyPinSuccess", pins_are_valid);
   return pins_are_valid;
 }
 
 bool TransportSecurityState::HasPublicKeyPins(const std::string& host) {
   DomainState dynamic_state;
   if (GetDynamicDomainState(host, &dynamic_state))
     return dynamic_state.HasPublicKeyPins();
 
   DomainState static_state;
   if (GetStaticDomainState(host, &static_state)) {
     if (static_state.HasPublicKeyPins())
       return true;
   }
 
   return false;
 }
 
 void TransportSecurityState::SetDelegate(
     TransportSecurityState::Delegate* delegate) {
   DCHECK(CalledOnValidThread());
   delegate_ = delegate;
 }
 
+void TransportSecurityState::SetReporter(
+    TransportSecurityState::Reporter* reporter) {
+  DCHECK(CalledOnValidThread());
+  reporter_ = reporter;
+}
+
 void TransportSecurityState::AddHSTSInternal(
     const std::string& host,
     TransportSecurityState::DomainState::UpgradeMode upgrade_mode,
     const base::Time& expiry,
     bool include_subdomains) {
   DCHECK(CalledOnValidThread());
 
   // Copy-and-modify the existing DomainState for this host (if any).
   DomainState domain_state;
   const std::string canonicalized_host = CanonicalizeHost(host);
   const std::string hashed_host = HashHost(canonicalized_host);
   DomainStateMap::const_iterator i = enabled_hosts_.find(hashed_host);
   if (i != enabled_hosts_.end())
     domain_state = i->second;
 
   domain_state.sts.last_observed = base::Time::Now();
   domain_state.sts.include_subdomains = include_subdomains;
   domain_state.sts.expiry = expiry;
   domain_state.sts.upgrade_mode = upgrade_mode;
   EnableHost(host, domain_state);
 }
 
 void TransportSecurityState::AddHPKPInternal(const std::string& host,
                                              const base::Time& last_observed,
                                              const base::Time& expiry,
                                              bool include_subdomains,
-                                             const HashValueVector& hashes) {
+                                             const HashValueVector& hashes,
+                                             const std::string& report_uri) {
   DCHECK(CalledOnValidThread());
 
   // Copy-and-modify the existing DomainState for this host (if any).
   DomainState domain_state;
   const std::string canonicalized_host = CanonicalizeHost(host);
   const std::string hashed_host = HashHost(canonicalized_host);
   DomainStateMap::const_iterator i = enabled_hosts_.find(hashed_host);
   if (i != enabled_hosts_.end())
     domain_state = i->second;
 
   domain_state.pkp.last_observed = last_observed;
   domain_state.pkp.expiry = expiry;
   domain_state.pkp.include_subdomains = include_subdomains;
   domain_state.pkp.spki_hashes = hashes;
+  domain_state.pkp.report_uri = report_uri;
   EnableHost(host, domain_state);
 }
 
 void TransportSecurityState::EnableHost(const std::string& host,
                                         const DomainState& state) {
   DCHECK(CalledOnValidThread());
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
@@ skipping 97 matching lines @@
 
 bool TransportSecurityState::AddHPKPHeader(const std::string& host,
                                            const std::string& value,
                                            const SSLInfo& ssl_info) {
   DCHECK(CalledOnValidThread());
 
   base::Time now = base::Time::Now();
   base::TimeDelta max_age;
   bool include_subdomains;
   HashValueVector spki_hashes;
+  std::string report_uri;
+
   if (!ParseHPKPHeader(value, ssl_info.public_key_hashes, &max_age,
-                       &include_subdomains, &spki_hashes)) {
+                       &include_subdomains, &spki_hashes, &report_uri)) {
     return false;
   }
   // Handle max-age == 0.
   if (max_age.InSeconds() == 0)
     spki_hashes.clear();
-  AddHPKPInternal(host, now, now + max_age, include_subdomains, spki_hashes);
+  AddHPKPInternal(host, now, now + max_age, include_subdomains, spki_hashes,
+                  report_uri);
   return true;
 }
 
 void TransportSecurityState::AddHSTS(const std::string& host,
                                      const base::Time& expiry,
                                      bool include_subdomains) {
   DCHECK(CalledOnValidThread());
   AddHSTSInternal(host, DomainState::MODE_FORCE_HTTPS, expiry,
                   include_subdomains);
 }
 
 void TransportSecurityState::AddHPKP(const std::string& host,
                                      const base::Time& expiry,
                                      bool include_subdomains,
-                                     const HashValueVector& hashes) {
+                                     const HashValueVector& hashes,
+                                     const std::string& report_uri) {
   DCHECK(CalledOnValidThread());
-  AddHPKPInternal(host, base::Time::Now(), expiry, include_subdomains, hashes);
+  AddHPKPInternal(host, base::Time::Now(), expiry, include_subdomains, hashes,
+                  report_uri);
 }
 
 // static
 bool TransportSecurityState::IsGooglePinnedProperty(const std::string& host) {
   PreloadResult result;
   return DecodeHSTSPreload(host, &result) && result.has_pins &&
          kPinsets[result.pinset_id].accepted_pins == kGoogleAcceptableCerts;
 }
 
 // static
@@ skipping 22 matching lines @@
 #else
   const base::Time build_time = base::GetBuildTime();
   // We consider built-in information to be timely for 10 weeks.
   return (base::Time::Now() - build_time).InDays() < 70 /* 10 weeks */;
 #endif
 }
 
 bool TransportSecurityState::CheckPublicKeyPinsImpl(
     const std::string& host,
     const HashValueVector& hashes,
+    uint16_t port,
+    const scoped_refptr<X509Certificate>& served_certificate_chain,
+    const scoped_refptr<X509Certificate>& validated_certificate_chain,
+    const PublicKeyPinReportStatus report_status,
     std::string* failure_log) {
   DomainState dynamic_state;
-  if (GetDynamicDomainState(host, &dynamic_state))
-    return dynamic_state.CheckPublicKeyPins(hashes, failure_log);
+  if (GetDynamicDomainState(host, &dynamic_state)) {
+    bool result = dynamic_state.CheckPublicKeyPins(hashes, failure_log);
+
+    if (result || !reporter_ ||
+        report_status == DO_NOT_SEND_PUBLIC_KEY_PIN_REPORT)
+      return result;
+
+    GURL report_uri;
+    std::string serialized_report;
+
+    if (!reporter_->GetHPKPReportUri(dynamic_state.pkp, &report_uri))
+      return result;
+
+    if (!reporter_->BuildHPKPReport(
+            host, port, dynamic_state.pkp.expiry,
+            dynamic_state.pkp.include_subdomains, dynamic_state.pkp.domain,
+            served_certificate_chain, validated_certificate_chain,
+            dynamic_state.pkp.spki_hashes, &serialized_report)) {
+      LOG(ERROR) << "Failed to build HPKP report";
+      return result;
+    }
+
+    reporter_->SendHPKPReport(report_uri, serialized_report);
+  }
 
   DomainState static_state;
   if (GetStaticDomainState(host, &static_state))
     return static_state.CheckPublicKeyPins(hashes, failure_log);
 
   // HasPublicKeyPins should have returned true in order for this method
   // to have been called, so if we fall through to here, it's an error.
   return false;
 }
 
@@ skipping 191 matching lines @@
 TransportSecurityState::DomainState::STSState::~STSState() {
 }
 
 TransportSecurityState::DomainState::PKPState::PKPState() {
 }
 
 TransportSecurityState::DomainState::PKPState::~PKPState() {
 }
 
 }  // namespace