Add unit tests for NTLM authentication. This requires...

net/http/http_auth_handler_ntlm.cc

 // Copyright (c) 2009 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/http_auth_handler_ntlm.h"
 
 #include <stdlib.h>
 // For gethostname
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 416 matching lines @@
   LogBuf("flags", (const uint8*) &msg->flags, 4);
   LogFlags(msg->flags);
   LogBuf("challenge", msg->challenge, sizeof(msg->challenge));
 
   // We currently do not implement LMv2/NTLMv2 or NTLM2 responses,
   // so we can ignore target information.  We may want to enable
   // support for these alternate mechanisms in the future.
   return OK;
 }
 
+static void GenerateRandom(uint8* output, size_t n) {
+  for (size_t i = 0; i < n; ++i)
+    output[i] = base::RandInt(0, 255);
+}
+
+static void GetHostName(char* name, size_t namelen) {
+  if (gethostname(name, namelen) != 0)
+    name[0] = '\0';
+}
+
+// TODO(wtc): these two function pointers should become static members of
+// HttpAuthHandlerNTLM.  They are file-scope static variables now so that
+// GenerateType3Msg can use them without being a friend function.  We should
+// have HttpAuthHandlerNTLM absorb NTLMAuthModule and pass the host name and
+// random bytes as input arguments to GenerateType3Msg.
+static HttpAuthHandlerNTLM::GenerateRandomProc generate_random_proc_ =
+    GenerateRandom;
+static HttpAuthHandlerNTLM::HostNameProc get_host_name_proc_ = GetHostName;
+
 // Returns OK or a network error code.
 static int GenerateType3Msg(const string16& domain,
                             const string16& username,
                             const string16& password,
                             const void*     in_buf,
                             uint32          in_len,
                             void**          out_buf,
                             uint32*         out_len) {
   // in_buf contains Type-2 msg (the challenge) from server.
 
@@ skipping 57 matching lines @@
   } else {
     oem_user_buf = base::SysWideToNativeMB(UTF16ToWide(username));
     user_ptr = oem_user_buf.data();
     user_len = oem_user_buf.length();
   }
 
   //
   // Get workstation name (use local machine's hostname).
   //
   char host_buf[256];  // Host names are limited to 255 bytes.
-  if (gethostname(host_buf, sizeof(host_buf)) != 0)
+  get_host_name_proc_(host_buf, sizeof(host_buf));
+  host_len = strlen(host_buf);
+  if (host_len == 0)
     return ERR_UNEXPECTED;
-  host_len = strlen(host_buf);
   if (unicode) {
     // hostname is ASCII, so we can do a simple zero-pad expansion:
     ucs_host_buf.assign(host_buf, host_buf + host_len);
     host_ptr = ucs_host_buf.data();
     host_len = ucs_host_buf.length() * 2;
 #ifdef IS_BIG_ENDIAN
     WriteUnicodeLE(const_cast<void*>(host_ptr), (const char16*) host_ptr,
                    ucs_host_buf.length());
 #endif
   } else {
@@ skipping 13 matching lines @@
   // Next, we compute the LM and NTLM responses.
   //
   uint8 lm_resp[LM_RESP_LEN];
   uint8 ntlm_resp[NTLM_RESP_LEN];
   uint8 ntlm_hash[NTLM_HASH_LEN];
   if (msg.flags & NTLM_NegotiateNTLM2Key) {
     // compute NTLM2 session response
     MD5Digest session_hash;
     uint8 temp[16];
 
-    // TODO(wtc): Add a function that generates random bytes so we can say:
-    //   GenerateRandom(lm_resp, 8);
-    for (int i = 0; i < 8; ++i)
-      lm_resp[i] = base::RandInt(0, 255);
+    generate_random_proc_(lm_resp, 8);
     memset(lm_resp + 8, 0, LM_RESP_LEN - 8);
 
     memcpy(temp, msg.challenge, 8);
     memcpy(temp + 8, lm_resp, 8);
     MD5Sum(temp, 16, &session_hash);
 
     NTLM_Hash(password, ntlm_hash);
     LM_Response(ntlm_hash, session_hash.a, ntlm_resp);
   } else {
     NTLM_Hash(password, ntlm_hash);
@@ skipping 186 matching lines @@
   std::string encode_input(static_cast<char*>(out_buf), out_buf_len);
   std::string encode_output;
   bool ok = Base64Encode(encode_input, &encode_output);
   // OK, we are done with |out_buf|
   free(out_buf);
   if (!ok)
     return std::string();
   return std::string("NTLM ") + encode_output;
 }
 
+// static
+void HttpAuthHandlerNTLM::SetGenerateRandomProc(GenerateRandomProc proc) {
+  generate_random_proc_ = proc;
+}
+
+// static
+void HttpAuthHandlerNTLM::SetHostNameProc(HostNameProc proc) {
+  get_host_name_proc_ = proc;
+}
+
 // The NTLM challenge header looks like:
 //   WWW-Authenticate: NTLM auth-data
 bool HttpAuthHandlerNTLM::ParseChallenge(
     std::string::const_iterator challenge_begin,
     std::string::const_iterator challenge_end) {
   scheme_ = "ntlm";
   score_ = 3;
   properties_ = ENCRYPTS_IDENTITY | IS_CONNECTION_BASED;
   auth_data_.clear();
 
   // Verify the challenge's auth-scheme.
   HttpAuth::ChallengeTokenizer challenge_tok(challenge_begin, challenge_end);
   if (!challenge_tok.valid() ||
       !LowerCaseEqualsASCII(challenge_tok.scheme(), "ntlm"))
     return false;
 
   // Extract the auth-data.  We can't use challenge_tok.GetNext() because
   // auth-data is base64-encoded and may contain '=' padding at the end,
   // which would be mistaken for a name=value pair.
   challenge_begin += 4;  // Skip over "NTLM".
   HttpUtil::TrimLWS(&challenge_begin, &challenge_end);
 
   auth_data_.assign(challenge_begin, challenge_end);
 
   return true;
 }
 
 }  // namespace net