Implement the NTLM authentication scheme by porting...

net/http/http_auth_unittest.cc

 // Copyright (c) 2006-2008 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/ref_counted.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_response_headers.h"
@@ skipping 26 matching lines @@
       "www-authenticate: nonce=\"aaaaaaaaaa\"\n"
       "www-authenticate: Digest realm=\"DigestRealm\", nonce=\"aaaaaaaaaa\"\n",
 
       // Pick Digset over Basic
       "DigestRealm",
     }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     // Make a HttpResponseHeaders object.
-    std::string headers_with_status_line("HTTP/1.1 401 OK\n");
+    std::string headers_with_status_line("HTTP/1.1 401 Unauthorized\n");
     headers_with_status_line += tests[i].headers;
-    scoped_refptr<net::HttpResponseHeaders> headers( 
+    scoped_refptr<net::HttpResponseHeaders> headers(
        new net::HttpResponseHeaders(
             net::HttpUtil::AssembleRawHeaders(
                 headers_with_status_line.c_str(),
                 headers_with_status_line.length())));
 
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::ChooseBestChallenge(headers.get(),
                                   HttpAuth::AUTH_SERVER,
                                   &handler);
 
     if (handler) {
       EXPECT_STREQ(tests[i].challenge_realm, handler->realm().c_str());
     } else {
       EXPECT_STREQ("", tests[i].challenge_realm);
     }
   }
 }
 
+TEST(HttpAuthTest, ChooseBestChallengeConnectionBased) {
+  static const struct {
+    const char* headers;
+    const char* challenge_realm;
+  } tests[] = {
+    {
+      "WWW-Authenticate: Negotiate\r\n"
+      "WWW-Authenticate: NTLM\r\n",
+
+      // We don't support Negotiate, so pick NTLM.  Either way, realm is
+      // empty.
+      "",
+    },
+    {
+      "WWW-Authenticate: NTLM "
+      "TlRMTVNTUAACAAAADAAMADgAAAAFgokCTroKF1e/DRcAAAAAAAAAALo"
+      "AugBEAAAABQEoCgAAAA9HAE8ATwBHAEwARQACAAwARwBPAE8ARwBMAE"
+      "UAAQAaAEEASwBFAEUAUwBBAFIAQQAtAEMATwBSAFAABAAeAGMAbwByA"
+      "HAALgBnAG8AbwBnAGwAZQAuAGMAbwBtAAMAQABhAGsAZQBlAHMAYQBy"
+      "AGEALQBjAG8AcgBwAC4AYQBkAC4AYwBvAHIAcAAuAGcAbwBvAGcAbAB"
+      "lAC4AYwBvAG0ABQAeAGMAbwByAHAALgBnAG8AbwBnAGwAZQAuAGMAbw"
+      "BtAAAAAAA=\r\n",
+
+      // Realm is empty.
+      "",
+    }
+  };
+
+  scoped_refptr<HttpAuthHandler> handler;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+    // Make a HttpResponseHeaders object.
+    std::string headers_with_status_line("HTTP/1.1 401 Unauthorized\n");
+    headers_with_status_line += tests[i].headers;
+    scoped_refptr<net::HttpResponseHeaders> headers(
+       new net::HttpResponseHeaders(
+            net::HttpUtil::AssembleRawHeaders(
+                headers_with_status_line.c_str(),
+                headers_with_status_line.length())));
+
+    scoped_refptr<HttpAuthHandler> old_handler = handler;
+    HttpAuth::ChooseBestChallenge(headers.get(),
+                                  HttpAuth::AUTH_SERVER,
+                                  &handler);
+
+    EXPECT_TRUE(handler != NULL);
+    // Since NTLM is connection-based, we should continue to use the existing
+    // handler rather than creating a new one.
+    if (i != 0)
+      EXPECT_EQ(old_handler, handler);
+
+    EXPECT_STREQ(tests[i].challenge_realm, handler->realm().c_str());
+  }
+}
+
 TEST(HttpAuthTest, ChallengeTokenizer) {
   std::string challenge_str = "Basic realm=\"foobar\"";
   HttpAuth::ChallengeTokenizer challenge(challenge_str.begin(),
                                          challenge_str.end());
   EXPECT_TRUE(challenge.valid());
   EXPECT_EQ(std::string("Basic"), challenge.scheme());
   EXPECT_TRUE(challenge.GetNext());
   EXPECT_TRUE(challenge.valid());
   EXPECT_EQ(std::string("realm"), challenge.name());
   EXPECT_EQ(std::string("foobar"), challenge.unquoted_value());
@@ skipping 52 matching lines @@
   EXPECT_EQ(std::string("Oblivion"), challenge.unquoted_value());
   EXPECT_TRUE(challenge.value_is_quoted());
   EXPECT_TRUE(challenge.GetNext());
   EXPECT_TRUE(challenge.valid());
   EXPECT_EQ(std::string("qop"), challenge.name());
   EXPECT_EQ(std::string("auth-int"), challenge.value());
   EXPECT_FALSE(challenge.value_is_quoted());
   EXPECT_FALSE(challenge.GetNext());
 }
 
+// Use a challenge which has no property.
+TEST(HttpAuthTest, ChallengeTokenizerNoProperty) {
+  std::string challenge_str = "NTLM";
+  HttpAuth::ChallengeTokenizer challenge(
+      challenge_str.begin(), challenge_str.end());
+  EXPECT_TRUE(challenge.valid());
+  EXPECT_EQ(std::string("NTLM"), challenge.scheme());
+  EXPECT_FALSE(challenge.GetNext());
+}
+
 TEST(HttpAuthTest, GetChallengeHeaderName) {
   std::string name;
 
   name = HttpAuth::GetChallengeHeaderName(HttpAuth::AUTH_SERVER);
   EXPECT_STREQ("WWW-Authenticate", name.c_str());
 
   name = HttpAuth::GetChallengeHeaderName(HttpAuth::AUTH_PROXY);
   EXPECT_STREQ("Proxy-Authenticate", name.c_str());
 }
 
@@ skipping 10 matching lines @@
 TEST(HttpAuthTest, CreateAuthHandler) {
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("Basic realm=\"FooBar\"",
                                 HttpAuth::AUTH_SERVER,
                                 &handler);
     EXPECT_FALSE(handler.get() == NULL);
     EXPECT_STREQ("basic", handler->scheme().c_str());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
+    EXPECT_FALSE(handler->encrypts_identity());
+    EXPECT_FALSE(handler->is_connection_based());
   }
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("UNSUPPORTED realm=\"FooBar\"",
                                 HttpAuth::AUTH_SERVER,
                                 &handler);
     EXPECT_TRUE(handler.get() == NULL);
   }
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("Digest realm=\"FooBar\", nonce=\"xyz\"",
                                 HttpAuth::AUTH_PROXY,
                                 &handler);
     EXPECT_FALSE(handler.get() == NULL);
     EXPECT_STREQ("digest", handler->scheme().c_str());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target());
+    EXPECT_TRUE(handler->encrypts_identity());
+    EXPECT_FALSE(handler->is_connection_based());
+  }
+  {
+    scoped_refptr<HttpAuthHandler> handler;
+    HttpAuth::CreateAuthHandler("NTLM",
+                                HttpAuth::AUTH_SERVER,
+                                &handler);
+    EXPECT_FALSE(handler.get() == NULL);
+    EXPECT_STREQ("ntlm", handler->scheme().c_str());
+    EXPECT_STREQ("", handler->realm().c_str());
+    EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
+    EXPECT_TRUE(handler->encrypts_identity());
+    EXPECT_TRUE(handler->is_connection_based());
   }
 }
 
-} // namespace net
+}  // namespace net