HSTS: add net-internals UI.

net/base/transport_security_state.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 "net/base/transport_security_state.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 namespace net {
 
 const long int TransportSecurityState::kMaxHSTSAgeSecs = 86400 * 365;  // 1 year
 
 TransportSecurityState::TransportSecurityState()
     : delegate_(NULL) {
 }
 
 void TransportSecurityState::EnableHost(const std::string& host,
                                         const DomainState& state) {
-  const std::string canonicalised_host = CanonicaliseHost(host);
-  if (canonicalised_host.empty())
+  const std::string canonicalized_host = CanonicalizeHost(host);
+  if (canonicalized_host.empty())
     return;
 
   bool temp;
-  if (IsPreloadedSTS(canonicalised_host, &temp))
+  if (IsPreloadedSTS(canonicalized_host, &temp))
     return;
 
   char hashed[base::SHA256_LENGTH];
-  base::SHA256HashString(canonicalised_host, hashed, sizeof(hashed));
+  base::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
 
   // Use the original creation date if we already have this host.
   DomainState state_copy(state);
   DomainState existing_state;
   if (IsEnabledForHost(&existing_state, host))
     state_copy.created = existing_state.created;
 
+  // We don't store these values.
+  state_copy.preloaded = false;
+  state_copy.domain.clear();
+
   enabled_hosts_[std::string(hashed, sizeof(hashed))] = state_copy;
   DirtyNotify();
 }
 
+bool TransportSecurityState::DeleteHost(const std::string& host) {
+  const std::string canonicalized_host = CanonicalizeHost(host);
+  if (canonicalized_host.empty())
+    return false;
+
+  char hashed[base::SHA256_LENGTH];
+  base::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
+
+  std::map<std::string, DomainState>::iterator i = enabled_hosts_.find(
+      std::string(hashed, sizeof(hashed)));
+  if (i != enabled_hosts_.end()) {
+    enabled_hosts_.erase(i);
+    DirtyNotify();
+    return true;
+  }
+  return false;
+}
+
 // IncludeNUL converts a char* to a std::string and includes the terminating
 // NUL in the result.
 static std::string IncludeNUL(const char* in) {
   return std::string(in, strlen(in) + 1);
 }
 
 bool TransportSecurityState::IsEnabledForHost(DomainState* result,
                                               const std::string& host) {
-  const std::string canonicalised_host = CanonicaliseHost(host);
-  if (canonicalised_host.empty())
+  *result = DomainState();
+
+  const std::string canonicalized_host = CanonicalizeHost(host);
+  if (canonicalized_host.empty())
     return false;
 
   bool include_subdomains;
-  if (IsPreloadedSTS(canonicalised_host, &include_subdomains)) {
+  if (IsPreloadedSTS(canonicalized_host, &include_subdomains)) {
     result->created = result->expiry = base::Time::FromTimeT(0);
     result->mode = DomainState::MODE_STRICT;
     result->include_subdomains = include_subdomains;
+    result->preloaded = true;
     return true;
   }
 
+  result->preloaded = false;
   base::Time current_time(base::Time::Now());
 
-  for (size_t i = 0; canonicalised_host[i]; i += canonicalised_host[i] + 1) {
+  for (size_t i = 0; canonicalized_host[i]; i += canonicalized_host[i] + 1) {
     char hashed_domain[base::SHA256_LENGTH];
 
-    base::SHA256HashString(IncludeNUL(&canonicalised_host[i]), &hashed_domain,
+    base::SHA256HashString(IncludeNUL(&canonicalized_host[i]), &hashed_domain,
                            sizeof(hashed_domain));
     std::map<std::string, DomainState>::iterator j =
         enabled_hosts_.find(std::string(hashed_domain, sizeof(hashed_domain)));
     if (j == enabled_hosts_.end())
       continue;
 
     if (current_time > j->second.expiry) {
       enabled_hosts_.erase(j);
       DirtyNotify();
       continue;
     }
 
     *result = j->second;
+    result->domain = DNSDomainToString(
+        canonicalized_host.substr(i, canonicalized_host.size() - i));
 
     // If we matched the domain exactly, it doesn't matter what the value of
     // include_subdomains is.
     if (i == 0)
       return true;
 
     return j->second.include_subdomains;
   }
 
   return false;
@@ skipping 268 matching lines @@
 
 TransportSecurityState::~TransportSecurityState() {
 }
 
 void TransportSecurityState::DirtyNotify() {
   if (delegate_)
     delegate_->StateIsDirty(this);
 }
 
 // static
-std::string TransportSecurityState::CanonicaliseHost(const std::string& host) {
+std::string TransportSecurityState::CanonicalizeHost(const std::string& host) {
   // We cannot perform the operations as detailed in the spec here as |host|
   // has already undergone IDN processing before it reached us. Thus, we check
   // that there are no invalid characters in the host and lowercase the result.
 
   std::string new_host;
   if (!DNSDomainFromDot(host, &new_host)) {
     // DNSDomainFromDot can fail if any label is > 63 bytes or if the whole
     // name is >255 bytes. However, search terms can have those properties.
     return std::string();
   }
@@ skipping 14 matching lines @@
     // step 3(b)
     if (new_host[i + 1] == '-' ||
         new_host[i + label_length] == '-') {
       return std::string();
     }
   }
 
   return new_host;
 }
 
-// IsPreloadedSTS returns true if the canonicalised hostname should always be
+// IsPreloadedSTS returns true if the canonicalized hostname should always be
 // considered to have STS enabled.
 // static
 bool TransportSecurityState::IsPreloadedSTS(
-    const std::string& canonicalised_host, bool *include_subdomains) {
+    const std::string& canonicalized_host, bool *include_subdomains) {
   // In the medium term this list is likely to just be hardcoded here. This,
   // slightly odd, form removes the need for additional relocations records.
   static const struct {
     uint8 length;
     bool include_subdomains;
     char dns_name[30];
   } kPreloadedSTS[] = {
     {16, false, "\003www\006paypal\003com"},
     {16, false, "\003www\006elanex\003biz"},
     {12, true,  "\006jottit\003com"},
     {19, true,  "\015sunshinepress\003org"},
     {21, false, "\003www\013noisebridge\003net"},
     {10, false, "\004neg9\003org"},
     {12, true, "\006riseup\003net"},
     {11, false, "\006factor\002cc"},
     {22, false, "\007members\010mayfirst\003org"},
     {22, false, "\007support\010mayfirst\003org"},
     {17, false, "\002id\010mayfirst\003org"},
     {20, false, "\005lists\010mayfirst\003org"},
     {19, true, "\015splendidbacon\003com"},
     {19, false, "\006health\006google\003com"},
     {21, false, "\010checkout\006google\003com"},
     {19, false, "\006chrome\006google\003com"},
   };
   static const size_t kNumPreloadedSTS = ARRAYSIZE_UNSAFE(kPreloadedSTS);
 
-  for (size_t i = 0; canonicalised_host[i]; i += canonicalised_host[i] + 1) {
+  for (size_t i = 0; canonicalized_host[i]; i += canonicalized_host[i] + 1) {
     for (size_t j = 0; j < kNumPreloadedSTS; j++) {
-      if (kPreloadedSTS[j].length == canonicalised_host.size() - i &&
+      if (kPreloadedSTS[j].length == canonicalized_host.size() - i &&
           (kPreloadedSTS[j].include_subdomains || i == 0) &&
-          memcmp(kPreloadedSTS[j].dns_name, &canonicalised_host[i],
+          memcmp(kPreloadedSTS[j].dns_name, &canonicalized_host[i],
                  kPreloadedSTS[j].length) == 0) {
         *include_subdomains = kPreloadedSTS[j].include_subdomains;
         return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace