OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "net/http/ntlm_buffer_writer.h" |
| 6 |
| 7 #include "base/macros.h" |
| 8 #include "base/strings/utf_string_conversions.h" |
| 9 #include "testing/gtest/include/gtest/gtest.h" |
| 10 |
| 11 #if defined(ARCH_CPU_LITTLE_ENDIAN) |
| 12 #define IS_LITTLE_ENDIAN 1 |
| 13 #undef IS_BIG_ENDIAN |
| 14 #elif defined(ARCH_CPU_BIG_ENDIAN) |
| 15 #define IS_BIG_ENDIAN 1 |
| 16 #undef IS_LITTLE_ENDIAN |
| 17 #else |
| 18 #error "Unknown endianness" |
| 19 #endif |
| 20 |
| 21 namespace net { |
| 22 |
| 23 TEST(NtlmBufferWriterTest, Initialization) { |
| 24 NtlmBufferWriter writer(1); |
| 25 |
| 26 EXPECT_EQ(1u, writer.GetLength()); |
| 27 EXPECT_EQ(0u, writer.GetCursor()); |
| 28 EXPECT_FALSE(writer.IsEndOfBuffer()); |
| 29 EXPECT_TRUE(writer.CanWrite(1)); |
| 30 EXPECT_FALSE(writer.CanWrite(2)); |
| 31 } |
| 32 |
| 33 TEST(NtlmBufferWriterTest, Write16) { |
| 34 const uint16_t expected = 0x1122; |
| 35 |
| 36 NtlmBufferWriter writer(sizeof(uint16_t)); |
| 37 |
| 38 EXPECT_TRUE(writer.WriteUInt16(expected)); |
| 39 EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]); |
| 40 EXPECT_EQ(expected >> 8, writer.GetBufferPtr()[1]); |
| 41 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 42 EXPECT_FALSE(writer.WriteUInt16(expected)); |
| 43 } |
| 44 |
| 45 TEST(NtlmBufferWriterTest, Write32) { |
| 46 const uint32_t expected = 0x11223344; |
| 47 |
| 48 NtlmBufferWriter writer(sizeof(uint32_t)); |
| 49 |
| 50 EXPECT_TRUE(writer.WriteUInt32(expected)); |
| 51 EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]); |
| 52 EXPECT_EQ((expected & 0xff00) >> 8, writer.GetBufferPtr()[1]); |
| 53 EXPECT_EQ((expected & 0xff0000) >> 16, writer.GetBufferPtr()[2]); |
| 54 EXPECT_EQ(expected >> 24, writer.GetBufferPtr()[3]); |
| 55 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 56 EXPECT_FALSE(writer.WriteUInt32(expected)); |
| 57 } |
| 58 |
| 59 TEST(NtlmBufferWriterTest, Write64) { |
| 60 const uint64_t expected = 0x1122334455667788; |
| 61 |
| 62 NtlmBufferWriter writer(sizeof(uint64_t)); |
| 63 |
| 64 EXPECT_TRUE(writer.WriteUInt64(expected)); |
| 65 EXPECT_EQ(expected & 0xff, writer.GetBufferPtr()[0]); |
| 66 EXPECT_EQ((expected & 0xff00) >> 8, writer.GetBufferPtr()[1]); |
| 67 EXPECT_EQ((expected & 0xff0000) >> 16, writer.GetBufferPtr()[2]); |
| 68 EXPECT_EQ((expected & 0xff000000) >> 24, writer.GetBufferPtr()[3]); |
| 69 EXPECT_EQ((expected & 0xff00000000) >> 32, writer.GetBufferPtr()[4]); |
| 70 EXPECT_EQ((expected & 0xff0000000000) >> 40, writer.GetBufferPtr()[5]); |
| 71 EXPECT_EQ((expected & 0xff000000000000) >> 48, writer.GetBufferPtr()[6]); |
| 72 EXPECT_EQ(expected >> 56, writer.GetBufferPtr()[7]); |
| 73 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 74 EXPECT_FALSE(writer.WriteUInt64(expected)); |
| 75 } |
| 76 |
| 77 TEST(NtlmBufferWriterTest, WriteBytes) { |
| 78 uint8_t expected[8]; |
| 79 |
| 80 expected[0] = 0x11; |
| 81 expected[1] = 0x22; |
| 82 expected[2] = 0x33; |
| 83 expected[3] = 0x44; |
| 84 expected[4] = 0x55; |
| 85 expected[5] = 0x66; |
| 86 expected[6] = 0x77; |
| 87 expected[7] = 0x88; |
| 88 |
| 89 NtlmBufferWriter writer(arraysize(expected)); |
| 90 |
| 91 EXPECT_TRUE(writer.WriteBytes(expected, arraysize(expected))); |
| 92 EXPECT_EQ(0, memcmp(writer.GetBufferPtr(), expected, arraysize(expected))); |
| 93 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 94 EXPECT_FALSE(writer.WriteBytes(expected, 1)); |
| 95 } |
| 96 |
| 97 TEST(NtlmBufferWriterTest, WriteSecurityBuffer) { |
| 98 uint16_t length = 0x1122; |
| 99 uint32_t offset = 0x55667788; |
| 100 |
| 101 NtlmBufferWriter writer(NtlmMessage::SECURITY_BUFFER_LEN); |
| 102 |
| 103 EXPECT_TRUE(writer.WriteSecurityBuffer(length, offset)); |
| 104 EXPECT_EQ(length & 0xff, writer.GetBufferPtr()[0]); |
| 105 EXPECT_EQ(length >> 8, writer.GetBufferPtr()[1]); |
| 106 |
| 107 // The second 16 bit field repeats the length. |
| 108 EXPECT_EQ(length & 0xff, writer.GetBufferPtr()[2]); |
| 109 EXPECT_EQ(length >> 8, writer.GetBufferPtr()[3]); |
| 110 EXPECT_EQ(offset & 0xff, writer.GetBufferPtr()[4]); |
| 111 EXPECT_EQ((offset & 0xff00) >> 8, writer.GetBufferPtr()[5]); |
| 112 EXPECT_EQ((offset & 0xff0000) >> 16, writer.GetBufferPtr()[6]); |
| 113 EXPECT_EQ((offset & 0xff000000) >> 24, writer.GetBufferPtr()[7]); |
| 114 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 115 EXPECT_FALSE(writer.WriteSecurityBuffer(length, offset)); |
| 116 } |
| 117 |
| 118 TEST(NtlmBufferWriterTest, WriteAsciiString) { |
| 119 std::string expected("12345678"); |
| 120 |
| 121 NtlmBufferWriter writer(expected.size()); |
| 122 |
| 123 EXPECT_TRUE(writer.WriteNarrowString(expected)); |
| 124 EXPECT_EQ(0, |
| 125 memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size())); |
| 126 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 127 EXPECT_FALSE(writer.WriteNarrowString(expected)); |
| 128 } |
| 129 |
| 130 TEST(NtlmBufferWriterTest, WriteUnicodeString) { |
| 131 base::string16 expected = base::ASCIIToUTF16("12345678"); |
| 132 |
| 133 NtlmBufferWriter writer(expected.size() * 2); |
| 134 |
| 135 EXPECT_TRUE(writer.WriteUnicodeString(expected)); |
| 136 #if IS_BIG_ENDIAN |
| 137 uint8_t* ptr = |
| 138 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(expected.c_str())); |
| 139 for (size_t i = 0; i < expected.size() * 2; i += 2) { |
| 140 std::swap(ptr[i], ptr[i + 1]); |
| 141 } |
| 142 #endif |
| 143 EXPECT_EQ( |
| 144 0, memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size() * 2)); |
| 145 |
| 146 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 147 EXPECT_FALSE(writer.WriteUnicodeString(expected)); |
| 148 } |
| 149 |
| 150 TEST(NtlmBufferWriterTest, WriteAsciiStringAsUnicode) { |
| 151 std::string input = "12345678"; |
| 152 base::string16 expected; |
| 153 expected.assign(input.begin(), input.end()); |
| 154 |
| 155 NtlmBufferWriter writer(input.size() * 2); |
| 156 |
| 157 EXPECT_TRUE(writer.WriteNarrowStringAsString16(input)); |
| 158 #if IS_BIG_ENDIAN |
| 159 uint8_t* ptr = |
| 160 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(expected.c_str())); |
| 161 for (size_t i = 0; i < expected.size() * 2; i += 2) { |
| 162 std::swap(ptr[i], ptr[i + 1]); |
| 163 } |
| 164 #endif |
| 165 EXPECT_EQ( |
| 166 0, memcmp(expected.c_str(), writer.GetBufferPtr(), expected.size() * 2)); |
| 167 |
| 168 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 169 EXPECT_FALSE(writer.WriteNarrowStringAsString16(input)); |
| 170 } |
| 171 |
| 172 TEST(NtlmBufferWriterTest, WriteSignature) { |
| 173 NtlmBufferWriter writer(NtlmMessage::SIGNATURE_LEN); |
| 174 |
| 175 EXPECT_TRUE(writer.WriteSignature()); |
| 176 EXPECT_EQ(0, memcmp(NtlmMessage::SIGNATURE, writer.GetBufferPtr(), |
| 177 NtlmMessage::SIGNATURE_LEN)); |
| 178 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 179 } |
| 180 |
| 181 TEST(NtlmBufferWriterTest, WriteSignatureNotEnoughSpace) { |
| 182 NtlmBufferWriter writer(1); |
| 183 |
| 184 EXPECT_FALSE(writer.WriteSignature()); |
| 185 EXPECT_FALSE(writer.IsEndOfBuffer()); |
| 186 EXPECT_TRUE(writer.CanWrite(1)); |
| 187 } |
| 188 |
| 189 TEST(NtlmBufferWriterTest, WriteMessageType) { |
| 190 NtlmBufferWriter writer(4); |
| 191 |
| 192 EXPECT_TRUE(writer.WriteMessageType(NtlmMessage::MESSAGE_NEGOTIATE)); |
| 193 EXPECT_EQ(NtlmMessage::MESSAGE_NEGOTIATE, writer.GetBufferPtr()[0]); |
| 194 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 195 } |
| 196 |
| 197 TEST(NtlmBufferWriterTest, ReleaseBufferPtr) { |
| 198 size_t buf_len = 4; |
| 199 NtlmBufferWriter writer(buf_len); |
| 200 |
| 201 EXPECT_FALSE(writer.IsEndOfBuffer()); |
| 202 EXPECT_TRUE(writer.CanWrite(buf_len)); |
| 203 EXPECT_TRUE(writer.GetBufferPtr() != nullptr); |
| 204 EXPECT_EQ(buf_len, writer.GetLength()); |
| 205 EXPECT_EQ(0u, writer.GetCursor()); |
| 206 |
| 207 // Write soemthing so that the cursor moves. |
| 208 EXPECT_TRUE(writer.WriteUInt16(23)); |
| 209 EXPECT_EQ(sizeof(uint16_t), writer.GetCursor()); |
| 210 EXPECT_TRUE(writer.CanWrite(buf_len - sizeof(uint16_t))); |
| 211 |
| 212 // Release the buffer from the writer. |
| 213 std::unique_ptr<uint8_t[]> buf(writer.ReleaseBufferPtr()); |
| 214 |
| 215 // Expect that the writer behaves empty now. |
| 216 EXPECT_TRUE(writer.IsEndOfBuffer()); |
| 217 EXPECT_FALSE(writer.CanWrite(buf_len - sizeof(uint16_t))); |
| 218 EXPECT_EQ(0u, writer.GetCursor()); |
| 219 EXPECT_EQ(0u, writer.GetLength()); |
| 220 EXPECT_EQ(nullptr, writer.GetBufferPtr()); |
| 221 } |
| 222 |
| 223 } // namespace net |
OLD | NEW |