Add a buffer reader/writer for NTLM.

net/http/ntlm_buffer_writer.cc

Index: net/http/ntlm_buffer_writer.cc
diff --git a/net/http/ntlm_buffer_writer.cc b/net/http/ntlm_buffer_writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1d689c4008d191ae77fef740117edf3023143af4
--- /dev/null
+++ b/net/http/ntlm_buffer_writer.cc
@@ -0,0 +1,200 @@
+// Copyright (c) 2017 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/ntlm_buffer_writer.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+#define IS_LITTLE_ENDIAN 1
+#undef IS_BIG_ENDIAN
+#elif defined(ARCH_CPU_BIG_ENDIAN)
+#define IS_BIG_ENDIAN 1
+#undef IS_LITTLE_ENDIAN
+#else
+#error "Unknown endianness"
+#endif
+
+namespace net {
+
+NtlmBufferWriter::NtlmBufferWriter(size_t buffer_len)
+    : buffer_len_(buffer_len), cursor_(0) {
+  buffer_.reset(new uint8_t[buffer_len]);
+}
+
+NtlmBufferWriter::~NtlmBufferWriter() {}
+
+bool NtlmBufferWriter::CanWrite(size_t len) const {
+  if (GetBufferPtr() == nullptr)

[Ryan Sleevi, 2017/06/08 18:36:34]

if (!GetBufferPtr())
  return false;

?

[zentaro, 2017/06/12 23:12:07]

Done.

+    return false;
+
+  DCHECK(cursor_ <= GetLength());

[Ryan Sleevi, 2017/06/08 18:36:34]

DCHECK_LE(cursor_, GetLength());

[zentaro, 2017/06/12 23:12:07]

Done.

+
+  if (len == 0)
+    return true;
+
+  return (cursor_ + len > cursor_) && (cursor_ + len <= GetLength());

[Ryan Sleevi, 2017/06/08 18:36:34]

len <= GetLength() && cursor_ <= GetLength() - len

[zentaro, 2017/06/12 23:12:07]

Done.

+}
+
+bool NtlmBufferWriter::SetCursor(size_t cursor) {
+  if ((GetBufferPtr() == nullptr) || (cursor > GetLength()))

[Ryan Sleevi, 2017/06/08 18:36:34]

if (!GetBufferPtr() || (cursor > GetLength()))

[zentaro, 2017/06/12 23:12:07]

Done.

+    return false;
+
+  cursor_ = cursor;
+  return true;
+}
+
+bool NtlmBufferWriter::WriteUInt64(uint64_t value) {
+  return WriteUInt<uint64_t>(value);
+}
+bool NtlmBufferWriter::WriteUInt32(uint32_t value) {
+  return WriteUInt<uint32_t>(value);
+}
+bool NtlmBufferWriter::WriteUInt16(uint16_t value) {
+  return WriteUInt<uint16_t>(value);
+}
+
+template <typename T>
+bool NtlmBufferWriter::WriteUInt(T value) {
+  size_t int_size = sizeof(T);
+  if (!CanWrite(int_size))
+    return false;
+
+  for (size_t i = 0; i < int_size; i++) {
+    GetBufferPtr()[cursor_++] = static_cast<uint8_t>(value & 0xff);
+    value >>= 8;
+  }
+
+  return true;
+}
+
+bool NtlmBufferWriter::WriteBytes(const uint8_t* buffer, size_t len) {
+  if (!CanWrite(len))
+    return false;
+
+  memcpy(reinterpret_cast<void*>(GetBufferPtr() + cursor_),
+         reinterpret_cast<const void*>(buffer), len);
+
+  cursor_ += len;
+  return true;
+}
+
+bool NtlmBufferWriter::WriteBytes(base::StringPiece bytes) {
+  return WriteBytes(reinterpret_cast<const uint8_t*>(bytes.data()),
+                    bytes.length());
+}
+
+bool NtlmBufferWriter::WriteSecurityBuffer(ntlm::SecurityBuffer sec_buf) {
+  if (!CanWrite(ntlm::SECURITY_BUFFER_LEN))
+    return false;
+
+  if (WriteUInt16(sec_buf.length) && WriteUInt16(sec_buf.length) &&

[asanka, 2017/06/08 19:40:09]

Nit: if (X) return true; return false ---> return X;

[zentaro, 2017/06/12 23:12:07]

I wrote it like that so I do NOTREACHED() but I reorganized to DCHECK the
result.

+      WriteUInt32(sec_buf.offset))
+    return true;
+
+  NOTREACHED();
+  return false;
+}
+
+bool NtlmBufferWriter::WriteEmptySecurityBuffer() {
+  return WriteSecurityBuffer(ntlm::SecurityBuffer());
+}
+
+bool NtlmBufferWriter::WriteNarrowString(const std::string& str) {

[asanka, 2017/06/08 19:40:09]

Nit: Rewrite this using WriteBytes()

[zentaro, 2017/06/12 23:12:07]

Done.

+  if (!CanWrite(str.length()))
+    return false;
+
+  memcpy(reinterpret_cast<void*>(GetBufferPtr() + cursor_), str.c_str(),
+         str.length());
+  cursor_ += str.length();
+  return true;
+}
+
+bool NtlmBufferWriter::WriteString16AsUTF8(const base::string16& str) {
+  // In practice this converts it to UTF8.
+  std::string utf8 = base::SysWideToNativeMB(base::UTF16ToWide(str));

[asanka, 2017/06/08 19:40:09]

Why not Utf16ToUtf8()? That way the behavior won't be sensitive to the CP in
use, which isn't necessarily UTF8.

[zentaro, 2017/06/12 23:12:07]

Done.

+  return WriteNarrowString(utf8);
+}
+
+bool NtlmBufferWriter::WriteUnicodeString(const base::string16& str) {
+  size_t num_bytes = str.length() * 2;
+  if (!CanWrite(num_bytes))
+    return false;
+
+#if IS_BIG_ENDIAN
+  uint8_t* ptr = reinterpret_cast<uint8_t*>(GetBufferPtr() + cursor_);
+
+  for (int i = 0; i < num_bytes; i += 2) {
+    ptr[i] = str[i / 2] % 0xff;
+    ptr[i + 1] = str[i / 2] >> 8;
+  }
+#else
+  memcpy(reinterpret_cast<void*>(GetBufferPtr() + cursor_), str.c_str(),
+         num_bytes);
+
+#endif
+
+  cursor_ += num_bytes;
+  return true;
+}
+
+bool NtlmBufferWriter::WriteNarrowStringAsString16(const std::string& str) {
+  base::string16 unicode;
+  unicode.assign(str.begin(), str.end());

[asanka, 2017/06/08 19:40:09]

not the same as Utf8ToUtf16.

[zentaro, 2017/06/12 23:12:07]

Done.

+  return WriteUnicodeString(unicode);
+}
+
+bool NtlmBufferWriter::WriteSignature() {
+  return WriteBytes(ntlm::SIGNATURE, ntlm::SIGNATURE_LEN);
+}
+
+bool NtlmBufferWriter::WriteZeros(size_t count) {
+  if (!CanWrite(count))
+    return false;
+
+  memset(GetBufferPtr() + cursor_, 0, count);
+  cursor_ += count;
+  return true;
+}
+
+bool NtlmBufferWriter::WriteMessageType(ntlm::MessageType message_type) {
+  return WriteUInt32(message_type);
+}
+
+bool NtlmBufferWriter::WriteMessageHeader(ntlm::MessageType message_type) {
+  if (!CanWrite(ntlm::SIGNATURE_LEN + sizeof(uint32_t)))
+    return false;
+
+  if (WriteSignature() && WriteMessageType(message_type))
+    return true;
+
+  NOTREACHED();
+  return false;
+}
+
+// static
+size_t NtlmBufferWriter::GetStringPayloadLength(const base::string16& str,
+                                                bool is_unicode) {
+  if (is_unicode)
+    return str.length() * 2;
+
+  // When |WriteString16AsUTF8| is called with a |base::string16|, the string
+  // is effectively converted to UTF8 by |base::SysWideToNativeMB|.
+  // Do the conversion to ensure that the character count is correct.
+  return base::SysWideToNativeMB(base::UTF16ToWide(str)).length();

[asanka, 2017/06/08 19:40:09]

Utf16ToUtf8().

[zentaro, 2017/06/12 23:12:07]

Done.

+}
+
+// static
+size_t NtlmBufferWriter::GetStringPayloadLength(const std::string& str,
+                                                bool is_unicode) {
+  // When |WriteUnicodePayload| is called with a |std::string|
+  // the string is assumed ASCII and the characters are zero-padded.

[asanka, 2017/06/08 19:40:09]

Seems a bit inconsistent whether input strings are required to be ASCII, or
UTF-8. If this is a hard requirement, it'll probably be better to call out
"Ascii" / "Utf8" in the function name.

[zentaro, 2017/06/12 23:12:07]

Per our offline discussion regarding the 8 bit version being OEM and that we
just treat all 8 bit strings as UTF8 or "don't care"

+  return is_unicode ? str.length() * 2 : str.length();
+}
+
+}  // namespace net