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 |