Common Name Mismatch Handler For WWW Subdomain Mismatch case

chrome/browser/ssl/common_name_mismatch_handler.cc

+// Copyright 2015 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/common_name_mismatch_handler.h"
+
+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/ssl/ssl_error_classification.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
+#include "net/url_request/url_request_status.h"
+
+CommonNameMismatchHandler::CommonNameMismatchHandler(
+    const GURL request_url,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context)
+    : request_url_(request_url), request_context_(request_context) {}
+
+CommonNameMismatchHandler::~CommonNameMismatchHandler() {}
+
+// static
+CommonNameMismatchHandler::TestingState
+    CommonNameMismatchHandler::testing_state_ = NOT_TESTING;
+
+void CommonNameMismatchHandler::CheckSuggestedUrl(
+    const GURL& url,
+    const CheckUrlCallback& callback) {
+  // Should be used only in tests.
+  if (testing_state_ == IGNORE_REQUESTS_FOR_TESTING)
+    return;
+
+  DCHECK(CalledOnValidThread());
+  DCHECK(!CheckingSuggestedUrl());
+  DCHECK(check_url_callback_.is_null());
+
+  check_url_callback_ = callback;
+
+  url_fetcher_ = net::URLFetcher::Create(0 /* testing ID */, url,
+                                         net::URLFetcher::HEAD, this);
+  url_fetcher_->SetAutomaticallyRetryOn5xx(false);
+  url_fetcher_->SetRequestContext(request_context_.get());
+
+  // Can't safely use net::LOAD_DISABLE_CERT_REVOCATION_CHECKING here,
+  // since then the connection may be reused without checking the cert.
+  url_fetcher_->SetLoadFlags(
+      net::LOAD_BYPASS_CACHE | net::LOAD_DO_NOT_SAVE_COOKIES |

[Ryan Sleevi, 2015/08/14 00:40:16]

The LOAD_BYPASS_CACHE is subtle and surprising - document why.

[My own presumption is that you want to make sure that you don't get a
200-series success code, since there's more than 200 to indicate a successful
load, and you also want to make sure the page will actually load if you directed
the user there, even though the latter part seems somewhat weird because the
actual load would be from the cache]

[Bhanu Dev, 2015/08/15 00:18:53]

I used this because I like wanted to completely make sure the page loads. But,
you are right as the load would be from cache only. Removing this. Thanks.

+      net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SEND_AUTH_DATA);
+  url_fetcher_->Start();
+}
+
+void CommonNameMismatchHandler::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(CheckingSuggestedUrl());
+  DCHECK_EQ(url_fetcher_.get(), source);
+  DCHECK(!check_url_callback_.is_null());
+
+  Results results;
+  GetSuggestedUrlCheckResult(url_fetcher_.get(), &results);
+  CheckUrlCallback callback = check_url_callback_;
+  url_fetcher_.reset();
+  check_url_callback_.Reset();
+  callback.Run(results);

[Ryan Sleevi, 2015/08/14 00:40:16]

GetSuggestedUrlCheckResult(...)
url_fetcher_.reset();
base::ResetAndReturn(&check_url_callback_).Run(...);

[Bhanu Dev, 2015/08/15 00:18:52]

Done.

+}
+
+// Takes a net::URLFetcher that has finished trying to retrieve the test
+// URL, and returns a CommonNameMismatchHandler::Result based on its result.
+void CommonNameMismatchHandler::GetSuggestedUrlCheckResult(
+    const net::URLFetcher* url_fetcher,
+    Results* results) const {
+  DCHECK(results);
+  DCHECK(!url_fetcher->GetStatus().is_io_pending());
+
+  results->result = SUGGESTED_URL_NOT_AVAILABLE;
+
+  // |suggested_url| and |landing_url| can be different in case of a redirect.
+  const GURL& suggested_url = url_fetcher->GetOriginalURL();
+  const GURL& landing_url = url_fetcher->GetURL();
+
+  // Make sure the |landing_url| is a valid https page.

[Ryan Sleevi, 2015/08/14 00:40:16]

s/HTTPS/

[Ryan Sleevi, 2015/08/14 00:40:16]

Comment-wise, this seems to hide what 'valid' means - here, you seemingly are
wanting to check if it loads and doesn't result in a redirect loop to the
current page?

[Bhanu Dev, 2015/08/15 00:18:52]

Done.

I was meaning "valid" to be, without any error and having a valid certificate.
Modified it.

[Bhanu Dev, 2015/08/15 00:18:53]

Done.

+  if (url_fetcher->GetResponseCode() == 200 &&
+      landing_url.SchemeIsCryptographic() &&
+      landing_url.host() != request_url_.host()) {
+    results->result = SUGGESTED_URL_AVAILABLE;
+    // Display |suggested_url| to user even if it redirects to |landing_url|.
+    results->suggested_url = suggested_url;
+  }
+}
+
+bool CommonNameMismatchHandler::GetSuggestedUrl(

[Ryan Sleevi, 2015/08/14 00:40:16]

The order of definitions should match the order of declarations - this should be
before OnURLFetchComplete

[Bhanu Dev, 2015/08/15 00:18:53]

Done.

+    const GURL& request_url,
+    const std::vector<std::string>& dns_names,
+    GURL* suggested_url) {
+  std::string host_name = request_url.host();
+  std::string www_mismatch_hostname;
+  if (!SSLErrorClassification::GetWWWSubDomainMatch(host_name, dns_names,
+                                                    &www_mismatch_hostname)) {
+    return false;
+  } else {

[Ryan Sleevi, 2015/08/14 00:40:16]

Don't use else after return -
https://www.chromium.org/developers/coding-style#Code_Formatting

[Bhanu Dev, 2015/08/15 00:18:53]

Done. Thanks.

+    // The full URL should be pinged, not just the new hostname. So, get the
+    // |suggested_url| with the |request_url|'s hostname replaced with
+    // new hostname. Keep resource path, query params the same.
+    GURL::Replacements replacements;
+    replacements.SetHostStr(www_mismatch_hostname);
+    *suggested_url = request_url.ReplaceComponents(replacements);
+    return true;
+  }
+}
+
+bool CommonNameMismatchHandler::CheckingSuggestedUrl() const {
+  return url_fetcher_.get() != NULL;

[Ryan Sleevi, 2015/08/14 00:40:16]

nullptr is recommended for new code ( https://chromium-cpp.appspot.com/ ),
however, an even better strategy is to rely on the implicit bool coercion, which
allows the same pattern across multiple containers

return url_fetcher_;

(scoped_ptr/scoped_refptr<> will convert to bool through conversion helpers, and
raw pointers are always convertable)

[Bhanu Dev, 2015/08/15 00:18:53]

Done.

+}