Parse HPKP report-uri and persist in TransportSecurityPersister

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 557 matching lines @@
   sts_state.expiry = expiry;
   sts_state.upgrade_mode = upgrade_mode;
 
   EnableSTSHost(host, sts_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 GURL& report_uri) {
   DCHECK(CalledOnValidThread());
 
   PKPState pkp_state;
   pkp_state.last_observed = last_observed;
   pkp_state.expiry = expiry;
   pkp_state.include_subdomains = include_subdomains;
   pkp_state.spki_hashes = hashes;
+  pkp_state.report_uri = report_uri;
 
   EnablePKPHost(host, pkp_state);
 }
 
 void TransportSecurityState::EnableSTSHost(const std::string& host,
                                            const STSState& state) {
   DCHECK(CalledOnValidThread());
 
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
@@ skipping 139 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;
+  GURL 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, STSState::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 GURL& 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 270 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace