Merge NTLMAuthModule into HttpAuthHandlerNTLM. The...

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>
 #elif defined(OS_WIN)
 #include <winsock2.h>
 #endif
 
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "net/base/base64.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "net/http/des.h"
 #include "net/http/md4.h"
 
 namespace net {
 
 // Based on mozilla/security/manager/ssl/src/nsNTLMAuthModule.cpp,
 // CVS rev. 1.14.
 //
 // TODO(wtc):
 // - The IS_BIG_ENDIAN code is not tested.
@@ skipping 401 matching lines @@
   // 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) {
+                            const std::string& hostname,
+                            const void* rand_8_bytes,
+                            const void* in_buf,
+                            uint32 in_len,
+                            void** out_buf,
+                            uint32* out_len) {
   // in_buf contains Type-2 msg (the challenge) from server.
 
   int rv;
   Type2Msg msg;
 
   rv = ParseType2Msg(in_buf, in_len, &msg);
   if (rv != OK)
     return rv;
 
   bool unicode = (msg.flags & NTLM_NegotiateUnicode) != 0;
 
   // Temporary buffers for unicode strings
 #ifdef IS_BIG_ENDIAN
   string16 ucs_domain_buf, ucs_user_buf;
 #endif
   string16 ucs_host_buf;
   // Temporary buffers for oem strings
-  std::string oem_domain_buf, oem_user_buf, oem_host_buf;
+  std::string oem_domain_buf, oem_user_buf;
   // Pointers and lengths for the string buffers; encoding is unicode if
   // the "negotiate unicode" flag was set in the Type-2 message.
   const void* domain_ptr;
   const void* user_ptr;
   const void* host_ptr;
   uint32 domain_len, user_len, host_len;
 
   //
   // Get domain name.
   //
@@ skipping 30 matching lines @@
 #endif
   } 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.
-  get_host_name_proc_(host_buf, sizeof(host_buf));
-  host_len = strlen(host_buf);
-  if (host_len == 0)
-    return ERR_UNEXPECTED;
   if (unicode) {
     // hostname is ASCII, so we can do a simple zero-pad expansion:
-    ucs_host_buf.assign(host_buf, host_buf + host_len);
+    ucs_host_buf.assign(hostname.begin(), hostname.end());
     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 {
-    host_ptr = host_buf;
+    host_ptr = hostname.data();
+    host_len = hostname.length();
   }
 
   //
   // Now that we have generated all of the strings, we can allocate out_buf.
   //
   *out_len = NTLM_TYPE3_HEADER_LEN + host_len + domain_len + user_len +
              LM_RESP_LEN + NTLM_RESP_LEN;
   *out_buf = malloc(*out_len);
   if (!*out_buf)
     return ERR_OUT_OF_MEMORY;
 
   //
   // 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];
 
-    generate_random_proc_(lm_resp, 8);
+    memcpy(lm_resp, rand_8_bytes, 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 50 matching lines @@
 
   // 52 : session key sec buf (not used)
   cursor = WriteSecBuf(cursor, 0, 0);
 
   // 60 : negotiated flags
   cursor = WriteDWORD(cursor, msg.flags & NTLM_TYPE1_FLAGS);
 
   return OK;
 }
 
-//-----------------------------------------------------------------------------
-
-class NTLMAuthModule {
- public:
-  NTLMAuthModule() {}
-
-  ~NTLMAuthModule();
-
-  int Init(const string16& domain,
-           const string16& username,
-           const string16& password);
-
-  int GetNextToken(const void* in_token,
-                   uint32 in_token_len,
-                   void** out_token,
-                   uint32* out_token_len);
-
- private:
-  string16 domain_;
-  string16 username_;
-  string16 password_;
-};
-
-NTLMAuthModule::~NTLMAuthModule() {
-  ZapString(&password_);
-}
-
-int NTLMAuthModule::Init(const string16& domain,
-                         const string16& username,
-                         const string16& password) {
-  domain_ = domain;
-  username_ = username;
-  password_ = password;
-  return OK;
-}
-
-int NTLMAuthModule::GetNextToken(const void* in_token,
-                                 uint32 in_token_len,
-                                 void** out_token,
-                                 uint32* out_token_len) {
-  int rv;
-
-  // If in_token is non-null, then assume it contains a type 2 message...
-  if (in_token) {
-    LogToken("in-token", in_token, in_token_len);
-    rv = GenerateType3Msg(domain_, username_, password_, in_token,
-                          in_token_len, out_token, out_token_len);
-  } else {
-    rv = GenerateType1Msg(out_token, out_token_len);
-  }
-
-  if (rv == OK)
-    LogToken("out-token", *out_token, *out_token_len);
-
-  return rv;
-}
-
 // NTLM authentication is specified in "NTLM Over HTTP Protocol Specification"
 // [MS-NTHT].
 
-HttpAuthHandlerNTLM::HttpAuthHandlerNTLM()
-    : ntlm_module_(new NTLMAuthModule) {
+// static
+HttpAuthHandlerNTLM::GenerateRandomProc
+HttpAuthHandlerNTLM::generate_random_proc_ = GenerateRandom;
+
+// static
+HttpAuthHandlerNTLM::HostNameProc
+HttpAuthHandlerNTLM::get_host_name_proc_ = GetMyHostName;
+
+HttpAuthHandlerNTLM::HttpAuthHandlerNTLM() {
 }
 
 HttpAuthHandlerNTLM::~HttpAuthHandlerNTLM() {
+  // Wipe our copy of the password from memory, to reduce the chance of being
+  // written to the paging file on disk.
+  ZapString(&password_);
 }
 
 bool HttpAuthHandlerNTLM::NeedsIdentity() {
   return !auth_data_.empty();
 }
 
 std::string HttpAuthHandlerNTLM::GenerateCredentials(
     const std::wstring& username,
     const std::wstring& password,
     const HttpRequestInfo* request,
     const ProxyInfo* proxy) {
-  int rv;
   // TODO(wtc): See if we can use char* instead of void* for in_buf and
   // out_buf.  This change will need to propagate to GetNextToken,
   // GenerateType1Msg, and GenerateType3Msg, and perhaps further.
   const void* in_buf;
   void* out_buf;
   uint32 in_buf_len, out_buf_len;
   std::string decoded_auth_data;
 
   // |username| may be in the form "DOMAIN\user".  Parse it into the two
   // components.
   std::wstring domain;
   std::wstring user;
   size_t backslash_idx = username.find(L'\\');
   if (backslash_idx == std::wstring::npos) {
     user = username;
   } else {
     domain = username.substr(0, backslash_idx);
     user = username.substr(backslash_idx + 1);
   }
-  rv = ntlm_module_->Init(WideToUTF16(domain), WideToUTF16(user),
-                          WideToUTF16(password));
+  domain_ = WideToUTF16(domain);
+  username_ = WideToUTF16(user);
+  password_ = WideToUTF16(password);
 
   // Initial challenge.
   if (auth_data_.empty()) {
     in_buf_len = 0;
     in_buf = NULL;
   } else {
     // Decode |auth_data_| into the input buffer.
     int len = auth_data_.length();
 
     // Strip off any padding.
     // (See https://bugzilla.mozilla.org/show_bug.cgi?id=230351.)
     //
     // Our base64 decoder requires that the length be a multiple of 4.
     while (len > 0 && len % 4 != 0 && auth_data_[len - 1] == '=')
       len--;
     auth_data_.erase(len);
 
     if (!Base64Decode(auth_data_, &decoded_auth_data))
       return std::string();  // Improper base64 encoding
     in_buf_len = decoded_auth_data.length();
     in_buf = decoded_auth_data.data();
   }
 
-  rv = ntlm_module_->GetNextToken(in_buf, in_buf_len, &out_buf, &out_buf_len);
+  int rv = GetNextToken(in_buf, in_buf_len, &out_buf, &out_buf_len);
   if (rv != OK)
     return std::string();
 
   // Base64 encode data in output buffer and prepend "NTLM ".
   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) {
+HttpAuthHandlerNTLM::GenerateRandomProc
+HttpAuthHandlerNTLM::SetGenerateRandomProc(
+    GenerateRandomProc proc) {
+  GenerateRandomProc old_proc = generate_random_proc_;
   generate_random_proc_ = proc;
+  return old_proc;
 }
 
 // static
-void HttpAuthHandlerNTLM::SetHostNameProc(HostNameProc proc) {
+HttpAuthHandlerNTLM::HostNameProc HttpAuthHandlerNTLM::SetHostNameProc(
+    HostNameProc proc) {
+  HostNameProc old_proc = get_host_name_proc_;
   get_host_name_proc_ = proc;
+  return old_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;
 }
 
+int HttpAuthHandlerNTLM::GetNextToken(const void* in_token,
+                                      uint32 in_token_len,
+                                      void** out_token,
+                                      uint32* out_token_len) {
+  int rv;
+
+  // If in_token is non-null, then assume it contains a type 2 message...
+  if (in_token) {
+    LogToken("in-token", in_token, in_token_len);
+    std::string hostname = get_host_name_proc_();
+    if (hostname.empty())
+      return ERR_UNEXPECTED;
+    uint8 rand_buf[8];
+    generate_random_proc_(rand_buf, 8);
+    rv = GenerateType3Msg(domain_, username_, password_, hostname, rand_buf,
+                          in_token, in_token_len, out_token, out_token_len);
+  } else {
+    rv = GenerateType1Msg(out_token, out_token_len);
+  }
+
+  if (rv == OK)
+    LogToken("out-token", *out_token, *out_token_len);
+
+  return rv;
+}
+
 }  // namespace net