Add a buffer reader/writer for NTLM.

net/http/ntlm_buffer_reader_unittest.cc

Index: net/http/ntlm_buffer_reader_unittest.cc
diff --git a/net/http/ntlm_buffer_reader_unittest.cc b/net/http/ntlm_buffer_reader_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..291447f08bb9df07b2909d1a7170fd083bd2275c
--- /dev/null
+++ b/net/http/ntlm_buffer_reader_unittest.cc
@@ -0,0 +1,350 @@
+// 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_reader.h"
+
+#include "base/macros.h"
+#include "net/http/ntlm_message.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+TEST(NtlmBufferReaderTest, Initialization) {
+  uint8_t buf[1];
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_EQ(arraysize(buf), reader.GetLength());
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.CanRead(1));
+  EXPECT_FALSE(reader.CanRead(2));
+}
+
+TEST(NtlmBufferReaderTest, Read16) {
+  uint8_t buf[2];
+  const uint16_t expected = 0x1122;
+  // Little endian.
+  buf[0] = expected & 0xff;
+  buf[1] = expected >> 8;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  uint16_t actual;
+  EXPECT_TRUE(reader.ReadUInt16(&actual));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUInt16(&actual));
+}
+
+TEST(NtlmBufferReaderTest, Read32) {
+  uint8_t buf[4];
+  const uint32_t expected = 0x11223344;
+  // Little endian.
+  buf[0] = expected & 0xff;
+  buf[1] = (expected & 0xff00) >> 8;
+  buf[2] = (expected & 0xff0000) >> 16;
+  buf[3] = (expected & 0xff000000) >> 24;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  uint32_t actual;
+  EXPECT_TRUE(reader.ReadUInt32(&actual));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUInt32(&actual));
+}
+
+TEST(NtlmBufferReaderTest, Read64) {
+  uint8_t buf[8];
+  const uint64_t expected = 0x1122334455667788;
+  // Little endian.
+  buf[0] = expected & 0xff;
+  buf[1] = (expected & 0xff00) >> 8;
+  buf[2] = (expected & 0xff0000) >> 16;
+  buf[3] = (expected & 0xff000000) >> 24;
+  buf[4] = (expected & 0xff00000000) >> 32;
+  buf[5] = (expected & 0xff0000000000) >> 40;
+  buf[6] = (expected & 0xff000000000000) >> 48;
+  buf[7] = expected >> 56;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  uint64_t actual;
+  EXPECT_TRUE(reader.ReadUInt64(&actual));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUInt64(&actual));
+}
+
+TEST(NtlmBufferReaderTest, ReadBytes) {
+  uint8_t expected[8];
+  uint8_t actual[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;
+
+  NtlmBufferReader reader(expected, arraysize(expected));
+
+  EXPECT_TRUE(reader.ReadBytes(actual, arraysize(actual)));
+  EXPECT_EQ(0, memcmp(actual, expected, arraysize(actual)));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadBytes(actual, 1));
+}
+
+TEST(NtlmBufferReaderTest, ReadSecurityBuffer) {
+  uint8_t buf[8];
+  uint16_t length = 0x1122;
+  uint16_t allocated = 0x3344;
+  uint32_t offset = 0x55667788;
+
+  buf[0] = length & 0xff;
+  buf[1] = length >> 8;
+  buf[2] = allocated & 0xff;
+  buf[3] = allocated >> 8;
+  buf[4] = offset & 0xff;
+  buf[5] = (offset & 0xff00) >> 8;
+  buf[6] = (offset & 0xff0000) >> 16;
+  buf[7] = (offset & 0xff000000) >> 24;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  uint16_t actual_length;
+  uint32_t actual_offset;
+  EXPECT_TRUE(reader.ReadSecurityBuffer(&actual_length, &actual_offset));
+  EXPECT_EQ(length, actual_length);
+  EXPECT_EQ(offset, actual_offset);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadSecurityBuffer(&actual_length, &actual_offset));
+}
+
+TEST(NtlmBufferReaderTest, ReadAsciiString) {
+  uint8_t buf[8];
+  std::string expected("12345678");
+  memcpy(buf, expected.c_str(), expected.size());
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  std::string actual;
+  EXPECT_TRUE(reader.ReadAsciiString(&actual, expected.size()));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadAsciiString(&actual, expected.size()));
+}
+
+TEST(NtlmBufferReaderTest, ReadUnicodeString) {
+  uint8_t buf[16];
+  std::string expected_ascii("12345678");
+  base::string16 expected;
+  expected.assign(expected_ascii.begin(), expected_ascii.end());
+  memcpy(buf, expected.c_str(), expected.size() * 2);
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  base::string16 actual;
+  EXPECT_TRUE(reader.ReadUnicodeString(&actual, expected.size() * 2));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUnicodeString(&actual, expected.size() * 2));
+}
+
+TEST(NtlmBufferReaderTest, ReadUnicodePayload) {
+  uint8_t buf[24];
+
+  std::string expected_ascii("12345678");
+  base::string16 expected;
+  expected.assign(expected_ascii.begin(), expected_ascii.end());
+
+  // Write a security buffer at the start.
+  memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN);
+  buf[0] = expected_ascii.length() * 2;
+  buf[2] = expected_ascii.length() * 2;
+  buf[4] = NtlmMessage::SECURITY_BUFFER_LEN;
+
+  // Put the string after the security buffer.
+  memcpy(buf + 8, expected.c_str(), expected.size() * 2);
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  base::string16 actual;
+  EXPECT_TRUE(reader.ReadUnicodePayload(&actual));
+  EXPECT_EQ(expected, actual);
+  // Read payload only advances the cursor over the security buffer.
+  EXPECT_EQ(NtlmMessage::SECURITY_BUFFER_LEN, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureTooShort) {
+  uint8_t buf[7];
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.CanRead(7));
+  EXPECT_FALSE(reader.MatchSignature());
+  EXPECT_TRUE(reader.CanRead(7));
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureNoMatch) {
+  uint8_t buf[8];
+  memset(buf, 0, arraysize(buf));
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.CanRead(8));
+  EXPECT_FALSE(reader.MatchSignature());
+  EXPECT_TRUE(reader.CanRead(8));
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureOk) {
+  uint8_t buf[8];
+  memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.MatchSignature());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadInvalidMessageType) {
+  uint8_t buf[4];
+  memset(buf, 0, arraysize(buf));
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  NtlmMessage::MessageType message_type;
+  EXPECT_FALSE(reader.ReadMessageType(&message_type));
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.CanRead(4));
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeNegotiate) {
+  uint8_t buf[4];
+  memset(buf, 0, arraysize(buf));
+  buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_NEGOTIATE);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  NtlmMessage::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(NtlmMessage::MESSAGE_NEGOTIATE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeChallenge) {
+  uint8_t buf[4];
+  memset(buf, 0, arraysize(buf));
+  buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_CHALLENGE);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  NtlmMessage::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(NtlmMessage::MESSAGE_CHALLENGE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeAuthenticate) {
+  uint8_t buf[4];
+  memset(buf, 0, arraysize(buf));
+  buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  NtlmMessage::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(NtlmMessage::MESSAGE_AUTHENTICATE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchMessageTypeAuthenticate) {
+  uint8_t buf[4];
+  memset(buf, 0, arraysize(buf));
+  buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.MatchMessageType(NtlmMessage::MESSAGE_AUTHENTICATE));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchAuthenticateHeader) {
+  uint8_t buf[12];
+  memset(buf, 0, arraysize(buf));
+  memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN);
+  buf[8] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE);
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.MatchMessageHeader(NtlmMessage::MESSAGE_AUTHENTICATE));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchFailsRollsBackCursor) {
+  uint8_t buf[12];
+  memset(buf, 0, arraysize(buf));
+  memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN);
+  buf[8] = 0x04;  // Invalid
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.MatchMessageHeader(NtlmMessage::MESSAGE_AUTHENTICATE));
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchZeros) {
+  uint8_t buf[12];
+  memset(buf, 0, arraysize(buf));
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.MatchZeros(arraysize(buf)));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.MatchZeros(1));
+}
+
+TEST(NtlmBufferReaderTest, MatchZerosFail) {
+  uint8_t buf[12];
+  memset(buf, 0, arraysize(buf));
+  buf[11] = 0x01;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.MatchZeros(arraysize(buf)));
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchEmptySecurityBuffer) {
+  uint8_t buf[NtlmMessage::SECURITY_BUFFER_LEN];
+  memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN);
+
+  NtlmBufferReader reader(buf, NtlmMessage::SECURITY_BUFFER_LEN);
+
+  EXPECT_TRUE(reader.MatchEmptySecurityBuffer());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.MatchEmptySecurityBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchEmptySecurityBufferFail) {
+  uint8_t buf[NtlmMessage::SECURITY_BUFFER_LEN];
+  memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN);
+  buf[NtlmMessage::SECURITY_BUFFER_LEN - 1] = 0x01;
+
+  NtlmBufferReader reader(buf, NtlmMessage::SECURITY_BUFFER_LEN);
+
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_FALSE(reader.MatchEmptySecurityBuffer());
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+}  // namespace net