Remove unnecessary attempts at memory cleaning

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>
 #elif defined(OS_WIN)
 #include <winsock2.h>
 #endif
 
 #include "base/md5.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
-#include "net/base/zap.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 205 matching lines @@
 //       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;
 
   passbuf = static_cast<uint8_t*>(malloc(len * 2));
   WriteUnicodeLE(passbuf, password.data(), len);
   weak_crypto::MD4Sum(passbuf, len * 2, hash);
 
-  ZapBuf(passbuf, len * 2);
   free(passbuf);
 #else
   weak_crypto::MD4Sum(reinterpret_cast<const uint8_t*>(password.data()),
                       password.length() * 2, hash);
 #endif
 }
 
 //-----------------------------------------------------------------------------
 
 // LM_Response generates the LM response given a 16-byte password hash and the
 // challenge from the Type-2 message.
 //
 // param hash
 //       16-byte password hash
 // param challenge
 //       8-byte challenge from Type-2 message
 // param response
 //       24-byte buffer to contain the LM response upon return
 static void LM_Response(const uint8_t* hash,
                         const uint8_t* challenge,
                         uint8_t* response) {
   uint8_t keybytes[21], k1[8], k2[8], k3[8];
 
   memcpy(keybytes, hash, 16);
-  ZapBuf(keybytes + 16, 5);
+  memset(keybytes + 16, 0, 5);
 
   DESMakeKey(keybytes, k1);
   DESMakeKey(keybytes + 7, k2);
   DESMakeKey(keybytes + 14, k3);
 
   DESEncrypt(k1, challenge, response);
   DESEncrypt(k2, challenge, response + 8);
   DESEncrypt(k3, challenge, response + 16);
 }
 
@@ skipping 303 matching lines @@
 bool HttpAuthHandlerNTLM::AllowsDefaultCredentials() {
   // Default credentials are not supported in the portable implementation of
   // NTLM, but are supported in the SSPI implementation.
   return false;
 }
 
 int HttpAuthHandlerNTLM::InitializeBeforeFirstChallenge() {
   return OK;
 }
 
-HttpAuthHandlerNTLM::~HttpAuthHandlerNTLM() {
-  credentials_.Zap();
-}
+HttpAuthHandlerNTLM::~HttpAuthHandlerNTLM() {}
 
 // static
 HttpAuthHandlerNTLM::GenerateRandomProc
 HttpAuthHandlerNTLM::SetGenerateRandomProc(GenerateRandomProc proc) {
   GenerateRandomProc old_proc = generate_random_proc_;
   generate_random_proc_ = proc;
   return old_proc;
 }
 
 // static
@@ skipping 52 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