Remove insecure code paths in portable NTLM.

net/http/http_auth_handler_ntlm_portable.cc

 // Copyright (c) 2012 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 132 matching lines @@
 
   LM_HASH_LEN = 16,
   LM_RESP_LEN = 24,
 
   NTLM_HASH_LEN = 16,
   NTLM_RESP_LEN = 24
 };
 
 //-----------------------------------------------------------------------------
 
-// The return value of this function controls whether or not the LM hash will
-// be included in response to a NTLM challenge.
-//
-// In Mozilla, this function returns the value of the boolean preference
-// "network.ntlm.send-lm-response".  By default, the preference is disabled
-// since servers should almost never need the LM hash, and the LM hash is what
-// makes NTLM authentication less secure.  See
-// https://bugzilla.mozilla.org/show_bug.cgi?id=250691 for further details.
-//
-// We just return a hardcoded false.
-static bool SendLM() {
-  return false;
-}
-
-//-----------------------------------------------------------------------------
-
 #define LogFlags(x) ((void)0)
 #define LogBuf(a, b, c) ((void)0)
 #define LogToken(a, b, c) ((void)0)
 
 //-----------------------------------------------------------------------------
 
 // Byte order swapping.
 #define SWAP16(x) ((((x)&0xff) << 8) | (((x) >> 8) & 0xff))
 #define SWAP32(x) ((SWAP16((x)&0xffff) << 16) | (SWAP16((x) >> 16)))
 
@@ skipping 60 matching lines @@
   uint32_t x = (static_cast<uint32_t>(buf[0])) |
                (static_cast<uint32_t>(buf[1]) << 8) |
                (static_cast<uint32_t>(buf[2]) << 16) |
                (static_cast<uint32_t>(buf[3]) << 24);
   buf += sizeof(x);
   return x;
 }
 
 //-----------------------------------------------------------------------------
 
-// LM_Hash computes the LM hash of the given password.
-//
-// param password
-//       unicode password.
-// param hash
-//       16-byte result buffer
-//
-// Note: This function is not being used because our SendLM() function always
-// returns false.
-static void LM_Hash(const base::string16& password, uint8_t* hash) {
-  static const uint8_t LM_MAGIC[] = "KGS!@#$%";
-
-  // Convert password to OEM character set.  We'll just use the native
-  // filesystem charset.
-  std::string passbuf = base::SysWideToNativeMB(base::UTF16ToWide(password));
-  passbuf = base::ToUpperASCII(passbuf);
-  passbuf.resize(14, '\0');
-
-  uint8_t k1[8], k2[8];
-  DESMakeKey(reinterpret_cast<const uint8_t*>(passbuf.data()), k1);
-  DESMakeKey(reinterpret_cast<const uint8_t*>(passbuf.data()) + 7, k2);
-  ZapString(&passbuf);
-
-  // Use password keys to hash LM magic string twice.
-  DESEncrypt(k1, LM_MAGIC, hash);
-  DESEncrypt(k2, LM_MAGIC, hash + 8);
-}
-
 // NTLM_Hash computes the NTLM hash of the given password.
 //
 // param password
 //       null-terminated unicode password.
 // param hash
 //       16-byte result buffer
 static void NTLM_Hash(const base::string16& password, uint8_t* hash) {
 #ifdef IS_BIG_ENDIAN
   uint32_t len = password.length();
   uint8_t* passbuf;
@@ skipping 253 matching lines @@
   *out_buf = malloc(*out_len);
   if (!*out_buf)
     return ERR_OUT_OF_MEMORY;
 
   //
   // Next, we compute the LM and NTLM responses.
   //
   uint8_t lm_resp[LM_RESP_LEN];
   uint8_t ntlm_resp[NTLM_RESP_LEN];
   uint8_t ntlm_hash[NTLM_HASH_LEN];
-  if (msg.flags & NTLM_NegotiateNTLM2Key) {
-    // compute NTLM2 session response
-    base::MD5Digest session_hash;
-    uint8_t temp[16];
 
-    memcpy(lm_resp, rand_8_bytes, 8);
-    memset(lm_resp + 8, 0, LM_RESP_LEN - 8);
+  // compute NTLM2 session response
+  base::MD5Digest session_hash;
+  uint8_t temp[16];
 
-    memcpy(temp, msg.challenge, 8);
-    memcpy(temp + 8, lm_resp, 8);
-    base::MD5Sum(temp, 16, &session_hash);
+  memcpy(lm_resp, rand_8_bytes, 8);
+  memset(lm_resp + 8, 0, LM_RESP_LEN - 8);
 
-    NTLM_Hash(password, ntlm_hash);
-    LM_Response(ntlm_hash, session_hash.a, ntlm_resp);
-  } else {
-    NTLM_Hash(password, ntlm_hash);
-    LM_Response(ntlm_hash, msg.challenge, ntlm_resp);
+  memcpy(temp, msg.challenge, 8);
+  memcpy(temp + 8, lm_resp, 8);
+  base::MD5Sum(temp, 16, &session_hash);
 
-    if (SendLM()) {
-      uint8_t lm_hash[LM_HASH_LEN];
-      LM_Hash(password, lm_hash);
-      LM_Response(lm_hash, msg.challenge, lm_resp);
-    } else {
-      // According to http://davenport.sourceforge.net/ntlm.html#ntlmVersion2,
-      // the correct way to not send the LM hash is to send the NTLM hash twice
-      // in both the LM and NTLM response fields.
-      LM_Response(ntlm_hash, msg.challenge, lm_resp);
-    }
-  }
+  NTLM_Hash(password, ntlm_hash);
+  LM_Response(ntlm_hash, session_hash.a, ntlm_resp);
 
   //
   // Finally, we assemble the Type-3 msg :-)
   //
   void* cursor = *out_buf;
   uint32_t offset;
 
   // 0 : signature
   cursor = WriteBytes(cursor, NTLM_SIGNATURE, sizeof(NTLM_SIGNATURE));
 
@@ skipping 132 matching lines @@
   // of NTLM.
   std::unique_ptr<HttpAuthHandler> tmp_handler(new HttpAuthHandlerNTLM);
   if (!tmp_handler->InitFromChallenge(challenge, target, ssl_info, origin,
                                       net_log))
     return ERR_INVALID_RESPONSE;
   handler->swap(tmp_handler);
   return OK;
 }
 
 }  // namespace net