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..ba6fa3651bc839f47e60168826736da8e6d40563
--- /dev/null
+++ b/net/http/ntlm_buffer_reader_unittest.cc
@@ -0,0 +1,461 @@
+// 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_reader.h"
+
+#include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "net/http/ntlm.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+TEST(NtlmBufferReaderTest, Initialization) {
+  const uint8_t buf[1] = {0};
+  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));
+  EXPECT_TRUE(reader.CanReadFrom(0, 1));
+  EXPECT_TRUE(reader.CanReadFrom(ntlm::SecurityBuffer(0, 1)));
+  EXPECT_FALSE(reader.CanReadFrom(1, 1));
+  EXPECT_FALSE(reader.CanReadFrom(ntlm::SecurityBuffer(1, 1)));
+  EXPECT_FALSE(reader.CanReadFrom(0, 2));
+  EXPECT_FALSE(reader.CanReadFrom(ntlm::SecurityBuffer(0, 2)));
+
+  // With length=0 the offset can be out of bounds.
+  EXPECT_TRUE(reader.CanReadFrom(99, 0));
+  EXPECT_TRUE(reader.CanReadFrom(ntlm::SecurityBuffer(99, 0)));
+}
+
+TEST(NtlmBufferReaderTest, Read16) {
+  const uint8_t buf[2] = {0x22, 0x11};
+  const uint16_t expected = 0x1122;
+
+  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) {
+  const uint8_t buf[4] = {0x44, 0x33, 0x22, 0x11};
+  const uint32_t expected = 0x11223344;
+
+  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) {
+  const uint8_t buf[8] = {0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
+  const uint64_t expected = 0x1122334455667788;
+
+  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) {
+  const uint8_t expected[8] = {0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11};
+  uint8_t actual[8];
+
+  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) {
+  const uint8_t buf[8] = {0x22, 0x11, 0xFF, 0xEE, 0x88, 0x77, 0x66, 0x55};
+  const uint16_t length = 0x1122;
+  const uint32_t offset = 0x55667788;
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::SecurityBuffer sec_buf;
+  EXPECT_TRUE(reader.ReadSecurityBuffer(&sec_buf));
+  EXPECT_EQ(length, sec_buf.length);
+  EXPECT_EQ(offset, sec_buf.offset);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadSecurityBuffer(&sec_buf));
+}
+
+TEST(NtlmBufferReaderTest, ReadSecurityBufferPastEob) {
+  const uint8_t buf[7] = {0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::SecurityBuffer sec_buf;
+  EXPECT_FALSE(reader.ReadSecurityBuffer(&sec_buf));
+}
+
+TEST(NtlmBufferReaderTest, ReadAsciiString) {
+  const uint8_t buf[8] = {'1', '2', '3', '4', '5', '6', '7', '8'};
+  const std::string expected("12345678");
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  std::string actual;
+  EXPECT_TRUE(reader.ReadUtf8String(&actual, expected.size()));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUtf8String(&actual, expected.size()));
+}
+
+TEST(NtlmBufferReaderTest, ReadAsciiStringPastEob) {
+  const size_t len = 8;
+  const uint8_t buf[len] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  std::string actual;
+  EXPECT_FALSE(reader.ReadUtf8String(&actual, len + 1));
+}
+
+TEST(NtlmBufferReaderTest, ReadUnicodeString) {
+  const uint8_t buf[16] = {
+      '1', 0, '2', 0, '3', 0, '4', 0, '5', 0, '6', 0, '7', 0, '8', 0,
+  };
+  const base::string16 expected = base::ASCIIToUTF16("12345678");
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  base::string16 actual;
+  EXPECT_TRUE(reader.ReadUtf16String(&actual, expected.size() * 2));
+  EXPECT_EQ(expected, actual);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.ReadUtf16String(&actual, expected.size() * 2));
+}
+
+TEST(NtlmBufferReaderTest, ReadUnicodeStringPastEob) {
+  const size_t len = 8;
+  const uint8_t buf[len] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  // Try to read one more character (2 bytes) than there is space.
+  base::string16 actual;
+  EXPECT_FALSE(reader.ReadUtf16String(&actual, len + 2));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, ReadUtf16StringOddLength) {
+  const size_t len = 8;
+  const uint8_t buf[len] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  // Try to read a 16-bit string with a length that isn't a multiple
+  // of 2.
+  base::string16 actual;
+  EXPECT_FALSE(reader.ReadUtf16String(&actual, len - 1));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, ReadUtf8Payload) {
+  const std::string expected("12345678");
+  const size_t len = expected.length();
+
+  const uint8_t buf[16] = {
+      len, 0,   len, 0,  ntlm::SECURITY_BUFFER_LEN, 0, 0, 0, '1', '2', '3', '4',
+      '5', '6', '7', '8'};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  std::string actual;
+  EXPECT_TRUE(reader.ReadUtf8Payload(&actual));
+  EXPECT_EQ(expected, actual);
+  // Read payload only advances the cursor over the security buffer.
+  EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, ReadUtf16Payload) {
+  const base::string16 expected = base::ASCIIToUTF16("12345678");
+  const size_t len = expected.length() * 2;
+  const uint8_t buf[24] = {len, 0,   len, 0,   ntlm::SECURITY_BUFFER_LEN,
+                           0,   0,   0,   '1', 0,
+                           '2', 0,   '3', 0,   '4',
+                           0,   '5', 0,   '6', 0,
+                           '7', 0,   '8', 0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  base::string16 actual;
+  EXPECT_TRUE(reader.ReadUtf16Payload(&actual));
+  EXPECT_EQ(expected, actual);
+  // Read payload only advances the cursor over the security buffer.
+  EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, SkipSecurityBuffer) {
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_TRUE(reader.SkipSecurityBuffer());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.SkipSecurityBuffer());
+}
+
+TEST(NtlmBufferReaderTest, SkipSecurityBufferPastEob) {
+  // The buffer is one byte shorter than security buffer.
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN - 1] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_FALSE(reader.SkipSecurityBuffer());
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, SkipSecurityBufferWithValidationEmpty) {
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_TRUE(reader.SkipSecurityBufferWithValidation());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.SkipSecurityBufferWithValidation());
+}
+
+TEST(NtlmBufferReaderTest, SkipSecurityBufferWithValidationValid) {
+  // A valid security buffer that points to the 1 payload byte.
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1] = {
+      0x01, 0, 0x01, 0, ntlm::SECURITY_BUFFER_LEN, 0, 0, 0, 0xFF};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_TRUE(reader.SkipSecurityBufferWithValidation());
+  EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor());
+  EXPECT_FALSE(reader.SkipSecurityBufferWithValidation());
+}
+
+TEST(NtlmBufferReaderTest,
+     SkipSecurityBufferWithValidationPayloadLengthPastEob) {
+  // Security buffer with length that points past the end of buffer.
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1] = {
+      0x02, 0, 0x02, 0, ntlm::SECURITY_BUFFER_LEN, 0, 0, 0, 0xFF};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_FALSE(reader.SkipSecurityBufferWithValidation());
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest,
+     SkipSecurityBufferWithValidationPayloadOffsetPastEob) {
+  // Security buffer with offset that points past the end of buffer.
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1] = {
+      0x02, 0, 0x02, 0, ntlm::SECURITY_BUFFER_LEN + 1, 0, 0, 0, 0xFF};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_FALSE(reader.SkipSecurityBufferWithValidation());
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest,
+     SkipSecurityBufferWithValidationZeroLengthPayloadOffsetPastEob) {
+  // Security buffer with offset that points past the end of buffer but
+  // length is 0.
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN] = {
+      0, 0, 0, 0, ntlm::SECURITY_BUFFER_LEN + 1, 0, 0, 0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+  EXPECT_TRUE(reader.SkipSecurityBufferWithValidation());
+  EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, SkipBytes) {
+  const uint8_t buf[8] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.SkipBytes(arraysize(buf)));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.SkipBytes(arraysize(buf)));
+}
+
+TEST(NtlmBufferReaderTest, SkipBytesPastEob) {
+  const uint8_t buf[8] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.SkipBytes(arraysize(buf) + 1));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureTooShort) {
+  const uint8_t buf[7] = {0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.CanRead(7));
+  EXPECT_FALSE(reader.MatchSignature());
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_TRUE(reader.CanRead(7));
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureNoMatch) {
+  // The last byte should be a 0.
+  const uint8_t buf[8] = {'N', 'T', 'L', 'M', 'S', 'S', 'P', 0xff};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.CanRead(8));
+  EXPECT_FALSE(reader.MatchSignature());
+  EXPECT_EQ(0u, reader.GetCursor());
+  EXPECT_TRUE(reader.CanRead(8));
+}
+
+TEST(NtlmBufferReaderTest, MatchSignatureOk) {
+  const uint8_t buf[8] = {'N', 'T', 'L', 'M', 'S', 'S', 'P', 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.MatchSignature());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadInvalidMessageType) {
+  // Only 0x01, 0x02, and 0x03 are valid message types.
+  const uint8_t buf[4] = {0x04, 0, 0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::MessageType message_type;
+  EXPECT_FALSE(reader.ReadMessageType(&message_type));
+  EXPECT_FALSE(reader.IsEndOfBuffer());
+  EXPECT_TRUE(reader.CanRead(4));
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeNegotiate) {
+  const uint8_t buf[4] = {static_cast<uint8_t>(ntlm::MessageType::NEGOTIATE), 0,
+                          0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(ntlm::MessageType::NEGOTIATE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeChallenge) {
+  const uint8_t buf[4] = {static_cast<uint8_t>(ntlm::MessageType::CHALLENGE), 0,
+                          0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(ntlm::MessageType::CHALLENGE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, ReadMessageTypeAuthenticate) {
+  const uint8_t buf[4] = {static_cast<uint8_t>(ntlm::MessageType::AUTHENTICATE),
+                          0, 0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  ntlm::MessageType message_type;
+  EXPECT_TRUE(reader.ReadMessageType(&message_type));
+  EXPECT_EQ(ntlm::MessageType::AUTHENTICATE, message_type);
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchMessageTypeAuthenticate) {
+  const uint8_t buf[4] = {static_cast<uint8_t>(ntlm::MessageType::AUTHENTICATE),
+                          0, 0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.MatchMessageType(ntlm::MessageType::AUTHENTICATE));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchMessageTypeInvalid) {
+  // Only 0x01, 0x02, and 0x03 are valid message types.
+  const uint8_t buf[4] = {0x04, 0, 0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.MatchMessageType(ntlm::MessageType::AUTHENTICATE));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchMessageTypeMismatch) {
+  const uint8_t buf[4] = {static_cast<uint8_t>(ntlm::MessageType::CHALLENGE), 0,
+                          0, 0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.MatchMessageType(ntlm::MessageType::AUTHENTICATE));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchAuthenticateHeader) {
+  const uint8_t buf[12] = {
+      'N', 'T', 'L',
+      'M', 'S', 'S',
+      'P', 0,   static_cast<uint8_t>(ntlm::MessageType::AUTHENTICATE),
+      0,   0,   0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.MatchMessageHeader(ntlm::MessageType::AUTHENTICATE));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchAuthenticateHeaderMisMatch) {
+  const uint8_t buf[12] = {
+      'N', 'T', 'L',
+      'M', 'S', 'S',
+      'P', 0,   static_cast<uint8_t>(ntlm::MessageType::CHALLENGE),
+      0,   0,   0};
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.MatchMessageType(ntlm::MessageType::AUTHENTICATE));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchZeros) {
+  const uint8_t buf[6] = {0, 0, 0, 0, 0, 0};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_TRUE(reader.MatchZeros(arraysize(buf)));
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.MatchZeros(1));
+}
+
+TEST(NtlmBufferReaderTest, MatchZerosFail) {
+  const uint8_t buf[6] = {0, 0, 0, 0, 0, 0xFF};
+
+  NtlmBufferReader reader(buf, arraysize(buf));
+
+  EXPECT_FALSE(reader.MatchZeros(arraysize(buf)));
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+TEST(NtlmBufferReaderTest, MatchEmptySecurityBuffer) {
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+  NtlmBufferReader reader(buf, ntlm::SECURITY_BUFFER_LEN);
+
+  EXPECT_TRUE(reader.MatchEmptySecurityBuffer());
+  EXPECT_TRUE(reader.IsEndOfBuffer());
+  EXPECT_FALSE(reader.MatchEmptySecurityBuffer());
+}
+
+TEST(NtlmBufferReaderTest, MatchEmptySecurityBufferFail) {
+  const uint8_t buf[ntlm::SECURITY_BUFFER_LEN] = {0, 0, 0, 0, 0, 0, 0, 0x01};
+
+  NtlmBufferReader reader(buf, ntlm::SECURITY_BUFFER_LEN);
+
+  EXPECT_FALSE(reader.MatchEmptySecurityBuffer());
+  EXPECT_EQ(0u, reader.GetCursor());
+}
+
+}  // namespace net