Add a buffer reader/writer for NTLM.

net/http/ntlm_buffer_writer_unittest.cc

Index: net/http/ntlm_buffer_writer_unittest.cc
diff --git a/net/http/ntlm_buffer_writer_unittest.cc b/net/http/ntlm_buffer_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0ac731a8d5a6219691a20c671b30ad45d9a9eb74
--- /dev/null
+++ b/net/http/ntlm_buffer_writer_unittest.cc
@@ -0,0 +1,277 @@
+// Copyright 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 "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.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 {
+
+namespace {
+
+// Helper method to hide all the ugly casting.
+const uint8_t* GetBufferPtr(const NtlmBufferWriter& writer) {
+  return reinterpret_cast<const uint8_t*>(writer.GetBuffer().data());
+}
+
+// Helper method to get a byte at a specific index in the buffer.
+uint8_t GetByteFromBuffer(const NtlmBufferWriter& writer, size_t index) {
+  base::StringPiece piece(writer.GetBuffer());
+  EXPECT_TRUE(index < piece.length());
+  return static_cast<uint8_t>(piece.data()[index]);
+}
+
+}  // namespace
+
+TEST(NtlmBufferWriterTest, Initialization) {
+  NtlmBufferWriter writer(1);
+
+  EXPECT_EQ(1u, writer.GetLength());
+  EXPECT_EQ(1u, writer.GetBuffer().length());
+  EXPECT_EQ(0u, writer.GetCursor());
+  EXPECT_FALSE(writer.IsEndOfBuffer());
+  EXPECT_TRUE(writer.CanWrite(1));
+  EXPECT_FALSE(writer.CanWrite(2));
+}
+
+TEST(NtlmBufferWriterTest, Write16) {
+  uint8_t expected[2] = {0x22, 0x11};
+  const uint16_t value = 0x1122;
+
+  NtlmBufferWriter writer(sizeof(uint16_t));
+
+  EXPECT_TRUE(writer.WriteUInt16(value));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_EQ(arraysize(expected), writer.GetLength());
+  EXPECT_FALSE(writer.WriteUInt16(value));
+
+  std::unique_ptr<uint8_t[]> actual(writer.ReleaseBufferPtr());
+  EXPECT_EQ(0, memcmp(expected, actual.get(), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, Write16PastEob) {
+  NtlmBufferWriter writer(sizeof(uint16_t) - 1);
+
+  EXPECT_FALSE(writer.WriteUInt16(0));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, Write32) {
+  uint8_t expected[4] = {0x44, 0x33, 0x22, 0x11};
+  const uint32_t value = 0x11223344;
+
+  NtlmBufferWriter writer(sizeof(uint32_t));
+
+  EXPECT_TRUE(writer.WriteUInt32(value));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt32(value));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, Write32PastEob) {
+  NtlmBufferWriter writer(sizeof(uint32_t) - 1);
+
+  EXPECT_FALSE(writer.WriteUInt32(0));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, Write64) {
+  uint8_t expected[8] = {0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
+  const uint64_t value = 0x1122334455667788;
+
+  NtlmBufferWriter writer(sizeof(uint64_t));
+
+  EXPECT_TRUE(writer.WriteUInt64(value));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt64(value));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, Write64PastEob) {
+  NtlmBufferWriter writer(sizeof(uint64_t) - 1);
+
+  EXPECT_FALSE(writer.WriteUInt64(0));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, WriteBytes) {
+  uint8_t expected[8] = {0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
+
+  NtlmBufferWriter writer(arraysize(expected));
+
+  EXPECT_TRUE(writer.WriteBytes(expected, arraysize(expected)));
+  EXPECT_EQ(0, memcmp(GetBufferPtr(writer), expected, arraysize(expected)));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteBytes(expected, 1));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteBytesPastEob) {
+  uint8_t buffer[8];
+
+  NtlmBufferWriter writer(arraysize(buffer) - 1);
+
+  EXPECT_FALSE(writer.WriteBytes(buffer, arraysize(buffer)));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, WriteSecurityBuffer) {
+  uint8_t expected[8] = {0x22, 0x11, 0x22, 0x11, 0x88, 0x77, 0x66, 0x55};
+  uint16_t length = 0x1122;
+  uint32_t offset = 0x55667788;
+
+  NtlmBufferWriter writer(ntlm::SECURITY_BUFFER_LEN);
+
+  EXPECT_TRUE(writer.WriteSecurityBuffer(ntlm::SecurityBuffer(offset, length)));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(
+      writer.WriteSecurityBuffer(ntlm::SecurityBuffer(offset, length)));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteSecurityBufferPastEob) {
+  ntlm::SecurityBuffer sec_buf;
+  NtlmBufferWriter writer(ntlm::SECURITY_BUFFER_LEN - 1);
+
+  EXPECT_FALSE(writer.WriteSecurityBuffer(sec_buf));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, WriteNarrowString) {
+  uint8_t expected[8] = {'1', '2', '3', '4', '5', '6', '7', '8'};
+  std::string value("12345678");
+
+  NtlmBufferWriter writer(value.size());
+
+  EXPECT_TRUE(writer.WriteUtf8String(value));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUtf8String(value));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteAsciiStringPastEob) {
+  std::string str("12345678");
+  NtlmBufferWriter writer(str.length() - 1);
+
+  EXPECT_FALSE(writer.WriteUtf8String(str));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, WriteUtf16String) {
+  uint8_t expected[16] = {'1', 0, '2', 0, '3', 0, '4', 0,
+                          '5', 0, '6', 0, '7', 0, '8', 0};
+  base::string16 value = base::ASCIIToUTF16("12345678");
+
+  NtlmBufferWriter writer(value.size() * 2);
+
+  EXPECT_TRUE(writer.WriteUtf16String(value));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUtf16String(value));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteUtf16StringPastEob) {
+  base::string16 str = base::ASCIIToUTF16("12345678");
+  NtlmBufferWriter writer((str.length() * 2) - 1);
+
+  EXPECT_FALSE(writer.WriteUtf16String(str));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, WriteUtf8AsUtf16String) {
+  uint8_t expected[16] = {'1', 0, '2', 0, '3', 0, '4', 0,
+                          '5', 0, '6', 0, '7', 0, '8', 0};
+  std::string input = "12345678";
+
+  NtlmBufferWriter writer(input.size() * 2);
+
+  EXPECT_TRUE(writer.WriteUtf8AsUtf16String(input));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUtf8AsUtf16String(input));
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteSignature) {
+  uint8_t expected[8] = {'N', 'T', 'L', 'M', 'S', 'S', 'P', 0};
+  NtlmBufferWriter writer(ntlm::SIGNATURE_LEN);
+
+  EXPECT_TRUE(writer.WriteSignature());
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+
+  EXPECT_EQ(0, memcmp(expected, GetBufferPtr(writer), arraysize(expected)));
+}
+
+TEST(NtlmBufferWriterTest, WriteSignaturePastEob) {
+  NtlmBufferWriter writer(1);
+
+  EXPECT_FALSE(writer.WriteSignature());
+  EXPECT_FALSE(writer.IsEndOfBuffer());
+  EXPECT_EQ(0u, writer.GetCursor());
+  EXPECT_TRUE(writer.CanWrite(1));
+}
+
+TEST(NtlmBufferWriterTest, WriteMessageType) {
+  NtlmBufferWriter writer(4);
+
+  EXPECT_TRUE(writer.WriteMessageType(ntlm::MessageType::NEGOTIATE));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_EQ(static_cast<uint32_t>(ntlm::MessageType::NEGOTIATE),
+            GetByteFromBuffer(writer, 0));
+  EXPECT_EQ(0, GetByteFromBuffer(writer, 1));
+  EXPECT_EQ(0, GetByteFromBuffer(writer, 2));
+  EXPECT_EQ(0, GetByteFromBuffer(writer, 3));
+}
+
+TEST(NtlmBufferWriterTest, WriteMessageTypePastEob) {
+  NtlmBufferWriter writer(sizeof(uint32_t) - 1);
+
+  EXPECT_FALSE(writer.WriteMessageType(ntlm::MessageType::NEGOTIATE));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, ReleaseBufferPtr) {
+  size_t buf_len = 4;
+  NtlmBufferWriter writer(buf_len);
+
+  EXPECT_TRUE(writer.CanWrite(buf_len));
+  EXPECT_TRUE(GetBufferPtr(writer) != nullptr);
+  EXPECT_EQ(buf_len, writer.GetLength());
+  EXPECT_EQ(0u, writer.GetCursor());
+
+  // Write soemthing so that the cursor moves.
+  EXPECT_TRUE(writer.WriteUInt16(23));
+  EXPECT_EQ(sizeof(uint16_t), writer.GetCursor());
+  EXPECT_TRUE(writer.CanWrite(buf_len - sizeof(uint16_t)));
+
+  // Release the buffer from the writer.
+  std::unique_ptr<uint8_t[]> buf(writer.ReleaseBufferPtr());
+
+  // Expect that the writer behaves empty now.
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.CanWrite(buf_len - sizeof(uint16_t)));
+  EXPECT_EQ(0u, writer.GetCursor());
+  EXPECT_EQ(0u, writer.GetLength());
+  EXPECT_EQ(nullptr, GetBufferPtr(writer));
+}
+
+}  // namespace net