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..fdef32d20a547d7ff934ee5d604692f00a2a2543
--- /dev/null
+++ b/net/http/ntlm_buffer_writer_unittest.cc
@@ -0,0 +1,223 @@
+// 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 "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 {
+
+TEST(NtlmBufferWriterTest, Initialization) {
+  NtlmBufferWriter writer(1);
+
+  EXPECT_EQ(1u, writer.GetLength());
+  EXPECT_EQ(0u, writer.GetCursor());
+  EXPECT_FALSE(writer.IsEndOfBuffer());
+  EXPECT_TRUE(writer.CanWrite(1));
+  EXPECT_FALSE(writer.CanWrite(2));
+}
+
+TEST(NtlmBufferWriterTest, Write16) {
+  const uint16_t expected = 0x1122;
+
+  NtlmBufferWriter writer(sizeof(uint16_t));
+
+  EXPECT_TRUE(writer.WriteUInt16(expected));
+  EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]);
+  EXPECT_EQ(expected >> 8, writer.GetBufferPtr()[1]);
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt16(expected));
+}
+
+TEST(NtlmBufferWriterTest, Write32) {
+  const uint32_t expected = 0x11223344;
+
+  NtlmBufferWriter writer(sizeof(uint32_t));
+
+  EXPECT_TRUE(writer.WriteUInt32(expected));
+  EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]);
+  EXPECT_EQ((expected & 0xff00) >> 8, writer.GetBufferPtr()[1]);
+  EXPECT_EQ((expected & 0xff0000) >> 16, writer.GetBufferPtr()[2]);
+  EXPECT_EQ(expected >> 24, writer.GetBufferPtr()[3]);
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt32(expected));
+}
+
+TEST(NtlmBufferWriterTest, Write64) {
+  const uint64_t expected = 0x1122334455667788;
+
+  NtlmBufferWriter writer(sizeof(uint64_t));
+
+  EXPECT_TRUE(writer.WriteUInt64(expected));
+  EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]);
+  EXPECT_EQ((expected & 0xff00) >> 8, writer.GetBufferPtr()[1]);
+  EXPECT_EQ((expected & 0xff0000) >> 16, writer.GetBufferPtr()[2]);
+  EXPECT_EQ((expected & 0xff000000) >> 24, writer.GetBufferPtr()[3]);
+  EXPECT_EQ((expected & 0xff00000000) >> 32, writer.GetBufferPtr()[4]);
+  EXPECT_EQ((expected & 0xff0000000000) >> 40, writer.GetBufferPtr()[5]);
+  EXPECT_EQ((expected & 0xff000000000000) >> 48, writer.GetBufferPtr()[6]);
+  EXPECT_EQ(expected >> 56, writer.GetBufferPtr()[7]);
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt64(expected));
+}
+
+TEST(NtlmBufferWriterTest, WriteBytes) {
+  uint8_t expected[8];
+
+  expected[0] = 0x11;
+  expected[1] = 0x22;
+  expected[2] = 0x33;
+  expected[3] = 0x44;
+  expected[4] = 0x55;
+  expected[5] = 0x66;
+  expected[6] = 0x77;
+  expected[7] = 0x88;
+
+  NtlmBufferWriter writer(arraysize(expected));
+
+  EXPECT_TRUE(writer.WriteBytes(expected, arraysize(expected)));
+  EXPECT_EQ(0, memcmp(writer.GetBufferPtr(), expected, arraysize(expected)));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteBytes(expected, 1));
+}
+
+TEST(NtlmBufferWriterTest, WriteSecurityBuffer) {
+  uint16_t length = 0x1122;
+  uint32_t offset = 0x55667788;
+
+  NtlmBufferWriter writer(NtlmMessage::SECURITY_BUFFER_LEN);
+
+  EXPECT_TRUE(writer.WriteSecurityBuffer(length, offset));
+  EXPECT_EQ(length & 0xff, writer.GetBufferPtr()[0]);
+  EXPECT_EQ(length >> 8, writer.GetBufferPtr()[1]);
+
+  // The second 16 bit field repeats the length.
+  EXPECT_EQ(length & 0xff, writer.GetBufferPtr()[2]);
+  EXPECT_EQ(length >> 8, writer.GetBufferPtr()[3]);
+  EXPECT_EQ(offset & 0xff, writer.GetBufferPtr()[4]);
+  EXPECT_EQ((offset & 0xff00) >> 8, writer.GetBufferPtr()[5]);
+  EXPECT_EQ((offset & 0xff0000) >> 16, writer.GetBufferPtr()[6]);
+  EXPECT_EQ((offset & 0xff000000) >> 24, writer.GetBufferPtr()[7]);
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteSecurityBuffer(length, offset));
+}
+
+TEST(NtlmBufferWriterTest, WriteAsciiString) {
+  std::string expected("12345678");
+
+  NtlmBufferWriter writer(expected.size());
+
+  EXPECT_TRUE(writer.WriteNarrowString(expected));
+  EXPECT_EQ(0,
+            memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size()));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteNarrowString(expected));
+}
+
+TEST(NtlmBufferWriterTest, WriteUnicodeString) {
+  base::string16 expected = base::ASCIIToUTF16("12345678");
+
+  NtlmBufferWriter writer(expected.size() * 2);
+
+  EXPECT_TRUE(writer.WriteUnicodeString(expected));
+#if IS_BIG_ENDIAN
+  uint8_t* ptr =
+      const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(expected.c_str()));
+  for (size_t i = 0; i < expected.size() * 2; i += 2) {
+    std::swap(ptr[i], ptr[i + 1]);
+  }
+#endif
+  EXPECT_EQ(
+      0, memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size() * 2));
+
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUnicodeString(expected));
+}
+
+TEST(NtlmBufferWriterTest, WriteAsciiStringAsUnicode) {
+  std::string input = "12345678";
+  base::string16 expected;
+  expected.assign(input.begin(), input.end());
+
+  NtlmBufferWriter writer(input.size() * 2);
+
+  EXPECT_TRUE(writer.WriteNarrowStringAsString16(input));
+#if IS_BIG_ENDIAN
+  uint8_t* ptr =
+      const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(expected.c_str()));
+  for (size_t i = 0; i < expected.size() * 2; i += 2) {
+    std::swap(ptr[i], ptr[i + 1]);
+  }
+#endif
+  EXPECT_EQ(
+      0, memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size() * 2));
+
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteNarrowStringAsString16(input));
+}
+
+TEST(NtlmBufferWriterTest, WriteSignature) {
+  NtlmBufferWriter writer(NtlmMessage::SIGNATURE_LEN);
+
+  EXPECT_TRUE(writer.WriteSignature());
+  EXPECT_EQ(0, memcmp(NtlmMessage::SIGNATURE, writer.GetBufferPtr(),
+                      NtlmMessage::SIGNATURE_LEN));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferWriterTest, WriteSignatureNotEnoughSpace) {
+  NtlmBufferWriter writer(1);
+
+  EXPECT_FALSE(writer.WriteSignature());
+  EXPECT_FALSE(writer.IsEndOfBuffer());
+  EXPECT_TRUE(writer.CanWrite(1));
+}
+
+TEST(NtlmBufferWriterTest, WriteMessageType) {
+  NtlmBufferWriter writer(4);
+
+  EXPECT_TRUE(writer.WriteMessageType(NtlmMessage::MESSAGE_NEGOTIATE));
+  EXPECT_EQ(NtlmMessage::MESSAGE_NEGOTIATE, writer.GetBufferPtr()[0]);
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferWriterTest, ReleaseBufferPtr) {
+  size_t buf_len = 4;
+  NtlmBufferWriter writer(buf_len);
+
+  EXPECT_FALSE(writer.IsEndOfBuffer());
+  EXPECT_TRUE(writer.CanWrite(buf_len));
+  EXPECT_TRUE(writer.GetBufferPtr() != 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, writer.GetBufferPtr());
+}
+
+}  // namespace net