Add TLS-SRP (RFC 5054) support

chrome/browser/ssl/ssl_policy.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 "chrome/browser/ssl/ssl_policy.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/singleton.h"
 #include "base/string_piece.h"
@@ skipping 98 matching lines @@
   //      resource), the resource load just fails.
   //   2) If the user has previously approved the same certificate error for
   //      this host in a full-page interstitial, then we'll proceed with the
   //      load.
   //   3) If we proceed with the load, we should treat the resources as if they
   //      were loaded over HTTP, w.r.t. the display vs. run distinction above.
   //
   // However, right now we don't have the proper context to understand where
   // these resources will be used.  Consequently, we're conservative and treat
   // them all like DidRunInsecureContent().
-
-  if (net::IsCertStatusError(info->ssl_cert_status())) {
+  if (net::IsCertStatusError(info->ssl_cert_status()) ||
+      (!info->ssl_cert_id() && info->tls_username().empty())) {
     backend_->HostRanInsecureContent(info->url().host(), info->child_id());
 
     // TODO(abarth): We should eventually remove the main_frame_origin and
     // frame_origin properties.  First, not every resource load is associated
     // with a frame, so they don't always make sense.  Second, the
     // main_frame_origin is computed from the first_party_for_cookies, which has
     // been hacked to death to support third-party cookie blocking.
 
     if (info->resource_type() != ResourceType::MAIN_FRAME &&
         info->resource_type() != ResourceType::SUB_FRAME) {
@@ skipping 10 matching lines @@
 }
 
 void SSLPolicy::UpdateEntry(NavigationEntry* entry, TabContents* tab_contents) {
   DCHECK(entry);
 
   InitializeEntryIfNeeded(entry);
 
   if (!entry->url().SchemeIsSecure())
     return;
 
-  // An HTTPS response may not have a certificate for some reason.  When that
-  // happens, use the unauthenticated (HTTP) rather than the authentication
-  // broken security style so that we can detect this error condition.
-  if (!entry->ssl().cert_id()) {
+  // An HTTPS response may not have a certificate or TLS auth username for some
+  // reason.  When that happens, use the unauthenticated (HTTP) rather than the
+  // authentication broken security style so that we can detect this error
+  // condition.
+  if (!entry->ssl().cert_id() && entry->ssl().tls_username().empty()) {
     entry->ssl().set_security_style(SECURITY_STYLE_UNAUTHENTICATED);
     return;
   }
 
   if (!(entry->ssl().cert_status() & net::CERT_STATUS_COMMON_NAME_INVALID)) {
     // CAs issue certificates for intranet hosts to everyone.  Therefore, we
     // mark intranet hosts as being non-unique.
     if (IsIntranetHost(entry->url().host())) {
       entry->ssl().set_cert_status(entry->ssl().cert_status() |
                                    net::CERT_STATUS_NON_UNIQUE_NAME);
     }
   }
 
   // If CERT_STATUS_UNABLE_TO_CHECK_REVOCATION is the only certificate error,
   // don't lower the security style to SECURITY_STYLE_AUTHENTICATION_BROKEN.
   int cert_errors = entry->ssl().cert_status() & net::CERT_STATUS_ALL_ERRORS;
-  if (cert_errors) {
+  if (cert_errors && entry->ssl().tls_username().empty()) {
     if (cert_errors != net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION)
       entry->ssl().set_security_style(SECURITY_STYLE_AUTHENTICATION_BROKEN);
     return;
   }
 
   SiteInstance* site_instance = entry->site_instance();
   // Note that |site_instance| can be NULL here because NavigationEntries don't
   // necessarily have site instances.  Without a process, the entry can't
   // possibly have insecure content.  See bug http://crbug.com/12423.
   if (site_instance &&
@@ skipping 68 matching lines @@
 
   entry->ssl().set_security_style(entry->url().SchemeIsSecure() ?
       SECURITY_STYLE_AUTHENTICATED : SECURITY_STYLE_UNAUTHENTICATED);
 }
 
 void SSLPolicy::OriginRanInsecureContent(const std::string& origin, int pid) {
   GURL parsed_origin(origin);
   if (parsed_origin.SchemeIsSecure())
     backend_->HostRanInsecureContent(parsed_origin.host(), pid);
 }