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..3f83ffc858459a62de82bad74cd7821586f45288
--- /dev/null
+++ b/net/http/ntlm_buffer_writer_unittest.cc
@@ -0,0 +1,300 @@
+// 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 {
+
+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) {
+  const uint16_t expected = 0x1122;
+
+  NtlmBufferWriter writer(sizeof(uint16_t));
+
+  EXPECT_TRUE(writer.WriteUInt16(expected));
+  EXPECT_EQ(expected & 0xff, GetByteFromBuffer(writer, 0));
+  EXPECT_EQ(expected >> 8, GetByteFromBuffer(writer, 1));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt16(expected));
+}
+
+TEST(NtlmBufferWriterTest, Write16PastEob) {
+  NtlmBufferWriter writer(sizeof(uint16_t) - 1);
+
+  EXPECT_FALSE(writer.WriteUInt16(0));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, Write32) {
+  const uint32_t expected = 0x11223344;
+
+  NtlmBufferWriter writer(sizeof(uint32_t));
+
+  EXPECT_TRUE(writer.WriteUInt32(expected));
+  EXPECT_EQ(expected & 0xff, GetByteFromBuffer(writer, 0));

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

As mentioned elsewhere, use literal buffers instead of constructions like this.
That way the tests are easier to evaluate and don't need to be conditioned on
the endianness.

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

Done.

+  EXPECT_EQ((expected & 0xff00) >> 8, GetByteFromBuffer(writer, 1));
+  EXPECT_EQ((expected & 0xff0000) >> 16, GetByteFromBuffer(writer, 2));
+  EXPECT_EQ(expected >> 24, GetByteFromBuffer(writer, 3));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt32(expected));
+}
+
+TEST(NtlmBufferWriterTest, Write32PastEob) {
+  NtlmBufferWriter writer(sizeof(uint32_t) - 1);
+
+  EXPECT_FALSE(writer.WriteUInt32(0));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+TEST(NtlmBufferWriterTest, Write64) {
+  const uint64_t expected = 0x1122334455667788;
+
+  NtlmBufferWriter writer(sizeof(uint64_t));
+
+  EXPECT_TRUE(writer.WriteUInt64(expected));
+  EXPECT_EQ(expected & 0xff, GetByteFromBuffer(writer, 0));
+  EXPECT_EQ((expected & 0xff00) >> 8, GetByteFromBuffer(writer, 1));
+  EXPECT_EQ((expected & 0xff0000) >> 16, GetByteFromBuffer(writer, 2));
+  EXPECT_EQ((expected & 0xff000000) >> 24, GetByteFromBuffer(writer, 3));
+  EXPECT_EQ((expected & 0xff00000000) >> 32, GetByteFromBuffer(writer, 4));
+  EXPECT_EQ((expected & 0xff0000000000) >> 40, GetByteFromBuffer(writer, 5));
+  EXPECT_EQ((expected & 0xff000000000000) >> 48, GetByteFromBuffer(writer, 6));
+  EXPECT_EQ(expected >> 56, GetByteFromBuffer(writer, 7));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUInt64(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];
+
+  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(GetBufferPtr(writer), expected, arraysize(expected)));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteBytes(expected, 1));
+}
+
+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) {
+  uint16_t length = 0x1122;
+  uint32_t offset = 0x55667788;
+
+  NtlmBufferWriter writer(ntlm::SECURITY_BUFFER_LEN);
+
+  EXPECT_TRUE(writer.WriteSecurityBuffer(ntlm::SecurityBuffer(offset, length)));
+  EXPECT_EQ(length & 0xff, GetByteFromBuffer(writer, 0));
+  EXPECT_EQ(length >> 8, GetByteFromBuffer(writer, 1));
+
+  // The second 16 bit field repeats the length.
+  EXPECT_EQ(length & 0xff, GetByteFromBuffer(writer, 2));
+  EXPECT_EQ(length >> 8, GetByteFromBuffer(writer, 3));
+  EXPECT_EQ(offset & 0xff, GetByteFromBuffer(writer, 4));
+  EXPECT_EQ((offset & 0xff00) >> 8, GetByteFromBuffer(writer, 5));
+  EXPECT_EQ((offset & 0xff0000) >> 16, GetByteFromBuffer(writer, 6));
+  EXPECT_EQ((offset & 0xff000000) >> 24, GetByteFromBuffer(writer, 7));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(
+      writer.WriteSecurityBuffer(ntlm::SecurityBuffer(offset, length)));
+}
+
+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) {
+  std::string expected("12345678");
+
+  NtlmBufferWriter writer(expected.size());
+
+  EXPECT_TRUE(writer.WriteNarrowString(expected));
+  EXPECT_EQ(0, memcmp(expected.c_str(), GetBufferPtr(writer), expected.size()));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteNarrowString(expected));
+}
+
+TEST(NtlmBufferWriterTest, WriteAsciiStringPastEob) {
+  std::string str("12345678");
+  NtlmBufferWriter writer(str.length() - 1);
+
+  EXPECT_FALSE(writer.WriteNarrowString(str));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+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(), GetBufferPtr(writer), expected.size() * 2));
+
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteUnicodeString(expected));
+}
+
+TEST(NtlmBufferWriterTest, WriteUnicodeStringPastEob) {
+  base::string16 str = base::ASCIIToUTF16("12345678");
+  NtlmBufferWriter writer(str.length() - 1);
+
+  EXPECT_FALSE(writer.WriteUnicodeString(str));
+  EXPECT_EQ(0u, writer.GetCursor());
+}
+
+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(), GetBufferPtr(writer), expected.size() * 2));
+
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+  EXPECT_FALSE(writer.WriteNarrowStringAsString16(input));
+}
+
+TEST(NtlmBufferWriterTest, WriteSignature) {
+  NtlmBufferWriter writer(ntlm::SIGNATURE_LEN);
+
+  EXPECT_TRUE(writer.WriteSignature());
+  EXPECT_EQ(0,
+            memcmp(ntlm::SIGNATURE, GetBufferPtr(writer), ntlm::SIGNATURE_LEN));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferWriterTest, WriteSignaturePastEob) {
+  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(ntlm::MESSAGE_NEGOTIATE));
+  EXPECT_EQ(ntlm::MESSAGE_NEGOTIATE, GetByteFromBuffer(writer, 0));
+  EXPECT_TRUE(writer.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferWriterTest, WriteMessageTypePastEob) {
+  NtlmBufferWriter writer(sizeof(uint32_t) - 1);
+
+  EXPECT_FALSE(writer.WriteMessageType(ntlm::MESSAGE_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