Switch to standard integer types in net/.

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 159 matching lines @@
 #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)))
 
-static void* WriteBytes(void* buf, const void* data, uint32 data_len) {
+static void* WriteBytes(void* buf, const void* data, uint32_t data_len) {
   memcpy(buf, data, data_len);
   return static_cast<char*>(buf) + data_len;
 }
 
-static void* WriteDWORD(void* buf, uint32 dword) {
+static void* WriteDWORD(void* buf, uint32_t dword) {
 #ifdef IS_BIG_ENDIAN
   // NTLM uses little endian on the wire.
   dword = SWAP32(dword);
 #endif
   return WriteBytes(buf, &dword, sizeof(dword));
 }
 
-static void* WriteSecBuf(void* buf, uint16 length, uint32 offset) {
+static void* WriteSecBuf(void* buf, uint16_t length, uint32_t offset) {
 #ifdef IS_BIG_ENDIAN
   length = SWAP16(length);
   offset = SWAP32(offset);
 #endif
   // Len: 2 bytes.
   buf = WriteBytes(buf, &length, sizeof(length));
   // MaxLen: 2 bytes. The sender should set it to the value of Len. The
   // recipient must ignore it.
   buf = WriteBytes(buf, &length, sizeof(length));
   // BufferOffset: 4 bytes.
   buf = WriteBytes(buf, &offset, sizeof(offset));
   return buf;
 }
 
 #ifdef IS_BIG_ENDIAN
 /**
  * WriteUnicodeLE copies a unicode string from one buffer to another.  The
  * resulting unicode string is in little-endian format.  The input string is
  * assumed to be in the native endianness of the local machine.  It is safe
  * to pass the same buffer as both input and output, which is a handy way to
  * convert the unicode buffer to little-endian on big-endian platforms.
  */
-static void* WriteUnicodeLE(
-    void* buf, const base::char16* str, uint32 str_len) {
+static void* WriteUnicodeLE(void* buf,
+                            const base::char16* str,
+                            uint32_t str_len) {
   // Convert input string from BE to LE.
-  uint8* cursor = static_cast<uint8*>(buf);
-  const uint8* input  = reinterpret_cast<const uint8*>(str);
-  for (uint32 i = 0; i < str_len; ++i, input += 2, cursor += 2) {
+  uint8_t* cursor = static_cast<uint8_t*>(buf);
+  const uint8_t* input = reinterpret_cast<const uint8_t*>(str);
+  for (uint32_t i = 0; i < str_len; ++i, input += 2, cursor += 2) {
     // Allow for the case where |buf == str|.
-    uint8 temp = input[0];
+    uint8_t temp = input[0];
     cursor[0] = input[1];
     cursor[1] = temp;
   }
   return buf;
 }
 #endif
 
-static uint16 ReadUint16(const uint8*& buf) {
-  uint16 x = (static_cast<uint16>(buf[0]))      |
-             (static_cast<uint16>(buf[1]) << 8);
+static uint16_t ReadUint16(const uint8_t*& buf) {
+  uint16_t x =
+      (static_cast<uint16_t>(buf[0])) | (static_cast<uint16_t>(buf[1]) << 8);
   buf += sizeof(x);
   return x;
 }
 
-static uint32 ReadUint32(const uint8*& buf) {
-  uint32 x = (static_cast<uint32>(buf[0]))       |
-             (static_cast<uint32>(buf[1]) << 8)  |
-             (static_cast<uint32>(buf[2]) << 16) |
-             (static_cast<uint32>(buf[3]) << 24);
+static uint32_t ReadUint32(const uint8_t*& buf) {
+  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* hash) {
-  static const uint8 LM_MAGIC[] = "KGS!@#$%";
+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 k1[8], k2[8];
-  DESMakeKey(reinterpret_cast<const uint8*>(passbuf.data())    , k1);
-  DESMakeKey(reinterpret_cast<const uint8*>(passbuf.data()) + 7, k2);
+  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* hash) {
+static void NTLM_Hash(const base::string16& password, uint8_t* hash) {
 #ifdef IS_BIG_ENDIAN
-  uint32 len = password.length();
-  uint8* passbuf;
+  uint32_t len = password.length();
+  uint8_t* passbuf;
 
-  passbuf = static_cast<uint8*>(malloc(len * 2));
+  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*>(password.data()),
+  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* hash,
-                        const uint8* challenge,
-                        uint8* response) {
-  uint8 keybytes[21], k1[8], k2[8], k3[8];
+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);
 
   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);
 }
 
 //-----------------------------------------------------------------------------
 
 // Returns OK or a network error code.
-static int GenerateType1Msg(void** out_buf, uint32* out_len) {
+static int GenerateType1Msg(void** out_buf, uint32_t* out_len) {
   //
   // Verify that buf_len is sufficient.
   //
   *out_len = NTLM_TYPE1_HEADER_LEN;
   *out_buf = malloc(*out_len);
   if (!*out_buf)
     return ERR_OUT_OF_MEMORY;
 
   //
   // Write out type 1 message.
@@ skipping 20 matching lines @@
   // 16 : supplied domain security buffer (empty)
   cursor = WriteSecBuf(cursor, 0, 0);
 
   // 24 : supplied workstation security buffer (empty)
   cursor = WriteSecBuf(cursor, 0, 0);
 
   return OK;
 }
 
 struct Type2Msg {
-  uint32      flags;         // NTLM_Xxx bitwise combination
-  uint8       challenge[8];  // 8 byte challenge
+  uint32_t flags;            // NTLM_Xxx bitwise combination
+  uint8_t challenge[8];      // 8 byte challenge
   const void* target;        // target string (type depends on flags)
-  uint32      target_len;    // target length in bytes
+  uint32_t target_len;       // target length in bytes
 };
 
 // Returns OK or a network error code.
 // TODO(wtc): This function returns ERR_UNEXPECTED when the input message is
 // invalid.  We should return a better error code.
-static int ParseType2Msg(const void* in_buf, uint32 in_len, Type2Msg* msg) {
+static int ParseType2Msg(const void* in_buf, uint32_t in_len, Type2Msg* msg) {
   // Make sure in_buf is long enough to contain a meaningful type2 msg.
   //
   // 0  NTLMSSP Signature
   // 8  NTLM Message Type
   // 12 Target Name
   // 20 Flags
   // 24 Challenge
   // 32 end of header, start of optional data blocks
   //
   if (in_len < NTLM_TYPE2_HEADER_LEN)
     return ERR_UNEXPECTED;
 
-  const uint8* cursor = (const uint8*) in_buf;
+  const uint8_t* cursor = (const uint8_t*)in_buf;
 
   // verify NTLMSSP signature
   if (memcmp(cursor, NTLM_SIGNATURE, sizeof(NTLM_SIGNATURE)) != 0)
     return ERR_UNEXPECTED;
   cursor += sizeof(NTLM_SIGNATURE);
 
   // verify Type-2 marker
   if (memcmp(cursor, NTLM_TYPE2_MARKER, sizeof(NTLM_TYPE2_MARKER)) != 0)
     return ERR_UNEXPECTED;
   cursor += sizeof(NTLM_TYPE2_MARKER);
 
   // read target name security buffer
-  uint32 target_len = ReadUint16(cursor);
+  uint32_t target_len = ReadUint16(cursor);
   ReadUint16(cursor);  // discard next 16-bit value
-  uint32 offset = ReadUint32(cursor);  // get offset from in_buf
+  uint32_t offset = ReadUint32(cursor);  // get offset from in_buf
   msg->target_len = 0;
   msg->target = NULL;
   // Check the offset / length combo is in range of the input buffer, including
   // integer overflow checking.
   if (offset + target_len > offset && offset + target_len <= in_len) {
     msg->target_len = target_len;
-    msg->target = ((const uint8*) in_buf) + offset;
+    msg->target = ((const uint8_t*)in_buf) + offset;
   }
 
   // read flags
   msg->flags = ReadUint32(cursor);
 
   // read challenge
   memcpy(msg->challenge, cursor, sizeof(msg->challenge));
   cursor += sizeof(msg->challenge);
 
   NTLM_LOG(("NTLM type 2 message:\n"));
-  LogBuf("target", (const uint8*) msg->target, msg->target_len);
-  LogBuf("flags", (const uint8*) &msg->flags, 4);
+  LogBuf("target", (const uint8_t*)msg->target, msg->target_len);
+  LogBuf("flags", (const uint8_t*)&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) {
+static void GenerateRandom(uint8_t* output, size_t n) {
   for (size_t i = 0; i < n; ++i)
     output[i] = base::RandInt(0, 255);
 }
 
 // Returns OK or a network error code.
 static int GenerateType3Msg(const base::string16& domain,
                             const base::string16& username,
                             const base::string16& password,
                             const std::string& hostname,
                             const void* rand_8_bytes,
                             const void* in_buf,
-                            uint32 in_len,
+                            uint32_t in_len,
                             void** out_buf,
-                            uint32* out_len) {
+                            uint32_t* 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
   base::string16 ucs_domain_buf, ucs_user_buf;
 #endif
   base::string16 ucs_host_buf;
   // Temporary buffers for oem strings
   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;
+  uint32_t domain_len, user_len, host_len;
 
   //
   // Get domain name.
   //
   if (unicode) {
 #ifdef IS_BIG_ENDIAN
     ucs_domain_buf = domain;
     domain_ptr = ucs_domain_buf.data();
     domain_len = ucs_domain_buf.length() * 2;
     WriteUnicodeLE(const_cast<void*>(domain_ptr),
@@ skipping 51 matching lines @@
   //
   *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];
+  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 temp[16];
+    uint8_t temp[16];
 
     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);
     base::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);
     LM_Response(ntlm_hash, msg.challenge, ntlm_resp);
 
     if (SendLM()) {
-      uint8 lm_hash[LM_HASH_LEN];
+      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);
     }
   }
 
   //
   // Finally, we assemble the Type-3 msg :-)
   //
   void* cursor = *out_buf;
-  uint32 offset;
+  uint32_t offset;
 
   // 0 : signature
   cursor = WriteBytes(cursor, NTLM_SIGNATURE, sizeof(NTLM_SIGNATURE));
 
   // 8 : marker
   cursor = WriteBytes(cursor, NTLM_TYPE3_MARKER, sizeof(NTLM_TYPE3_MARKER));
 
   // 12 : LM response sec buf
   offset = NTLM_TYPE3_HEADER_LEN + domain_len + user_len + host_len;
   cursor = WriteSecBuf(cursor, LM_RESP_LEN, offset);
-  memcpy(static_cast<uint8*>(*out_buf) + offset, lm_resp, LM_RESP_LEN);
+  memcpy(static_cast<uint8_t*>(*out_buf) + offset, lm_resp, LM_RESP_LEN);
 
   // 20 : NTLM response sec buf
   offset += LM_RESP_LEN;
   cursor = WriteSecBuf(cursor, NTLM_RESP_LEN, offset);
-  memcpy(static_cast<uint8*>(*out_buf) + offset, ntlm_resp, NTLM_RESP_LEN);
+  memcpy(static_cast<uint8_t*>(*out_buf) + offset, ntlm_resp, NTLM_RESP_LEN);
 
   // 28 : domain name sec buf
   offset = NTLM_TYPE3_HEADER_LEN;
   cursor = WriteSecBuf(cursor, domain_len, offset);
-  memcpy(static_cast<uint8*>(*out_buf) + offset, domain_ptr, domain_len);
+  memcpy(static_cast<uint8_t*>(*out_buf) + offset, domain_ptr, domain_len);
 
   // 36 : user name sec buf
   offset += domain_len;
   cursor = WriteSecBuf(cursor, user_len, offset);
-  memcpy(static_cast<uint8*>(*out_buf) + offset, user_ptr, user_len);
+  memcpy(static_cast<uint8_t*>(*out_buf) + offset, user_ptr, user_len);
 
   // 44 : workstation (host) name sec buf
   offset += user_len;
   cursor = WriteSecBuf(cursor, host_len, offset);
-  memcpy(static_cast<uint8*>(*out_buf) + offset, host_ptr, host_len);
+  memcpy(static_cast<uint8_t*>(*out_buf) + offset, host_ptr, host_len);
 
   // 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;
 }
 
@@ skipping 49 matching lines @@
   return old_proc;
 }
 
 HttpAuthHandlerNTLM::Factory::Factory() {
 }
 
 HttpAuthHandlerNTLM::Factory::~Factory() {
 }
 
 int HttpAuthHandlerNTLM::GetNextToken(const void* in_token,
-                                      uint32 in_token_len,
+                                      uint32_t in_token_len,
                                       void** out_token,
-                                      uint32* out_token_len) {
+                                      uint32_t* out_token_len) {
   int rv = 0;
 
   // 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];
+    uint8_t rand_buf[8];
     generate_random_proc_(rand_buf, 8);
     rv = GenerateType3Msg(domain_,
                           credentials_.username(), credentials_.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)
@@ skipping 17 matching lines @@
   // NOTE: Default credentials are not supported for the portable implementation
   // of NTLM.
   scoped_ptr<HttpAuthHandler> tmp_handler(new HttpAuthHandlerNTLM);
   if (!tmp_handler->InitFromChallenge(challenge, target, origin, net_log))
     return ERR_INVALID_RESPONSE;
   handler->swap(tmp_handler);
   return OK;
 }
 
 }  // namespace net