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_reader.h" |
| 6 |
| 7 #include "base/macros.h" |
| 8 #include "net/http/ntlm_message.h" |
| 9 #include "testing/gtest/include/gtest/gtest.h" |
| 10 |
| 11 namespace net { |
| 12 |
| 13 TEST(NtlmBufferReaderTest, Initialization) { |
| 14 uint8_t buf[1]; |
| 15 NtlmBufferReader reader(buf, arraysize(buf)); |
| 16 |
| 17 EXPECT_EQ(arraysize(buf), reader.GetLength()); |
| 18 EXPECT_EQ(0u, reader.GetCursor()); |
| 19 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 20 EXPECT_TRUE(reader.CanRead(1)); |
| 21 EXPECT_FALSE(reader.CanRead(2)); |
| 22 } |
| 23 |
| 24 TEST(NtlmBufferReaderTest, Read16) { |
| 25 uint8_t buf[2]; |
| 26 const uint16_t expected = 0x1122; |
| 27 // Little endian. |
| 28 buf[0] = expected & 0xff; |
| 29 buf[1] = expected >> 8; |
| 30 |
| 31 NtlmBufferReader reader(buf, arraysize(buf)); |
| 32 |
| 33 uint16_t actual; |
| 34 EXPECT_TRUE(reader.ReadUInt16(&actual)); |
| 35 EXPECT_EQ(expected, actual); |
| 36 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 37 EXPECT_FALSE(reader.ReadUInt16(&actual)); |
| 38 } |
| 39 |
| 40 TEST(NtlmBufferReaderTest, Read32) { |
| 41 uint8_t buf[4]; |
| 42 const uint32_t expected = 0x11223344; |
| 43 // Little endian. |
| 44 buf[0] = expected & 0xff; |
| 45 buf[1] = (expected & 0xff00) >> 8; |
| 46 buf[2] = (expected & 0xff0000) >> 16; |
| 47 buf[3] = (expected & 0xff000000) >> 24; |
| 48 |
| 49 NtlmBufferReader reader(buf, arraysize(buf)); |
| 50 |
| 51 uint32_t actual; |
| 52 EXPECT_TRUE(reader.ReadUInt32(&actual)); |
| 53 EXPECT_EQ(expected, actual); |
| 54 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 55 EXPECT_FALSE(reader.ReadUInt32(&actual)); |
| 56 } |
| 57 |
| 58 TEST(NtlmBufferReaderTest, Read64) { |
| 59 uint8_t buf[8]; |
| 60 const uint64_t expected = 0x1122334455667788; |
| 61 // Little endian. |
| 62 buf[0] = expected & 0xff; |
| 63 buf[1] = (expected & 0xff00) >> 8; |
| 64 buf[2] = (expected & 0xff0000) >> 16; |
| 65 buf[3] = (expected & 0xff000000) >> 24; |
| 66 buf[4] = (expected & 0xff00000000) >> 32; |
| 67 buf[5] = (expected & 0xff0000000000) >> 40; |
| 68 buf[6] = (expected & 0xff000000000000) >> 48; |
| 69 buf[7] = expected >> 56; |
| 70 |
| 71 NtlmBufferReader reader(buf, arraysize(buf)); |
| 72 |
| 73 uint64_t actual; |
| 74 EXPECT_TRUE(reader.ReadUInt64(&actual)); |
| 75 EXPECT_EQ(expected, actual); |
| 76 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 77 EXPECT_FALSE(reader.ReadUInt64(&actual)); |
| 78 } |
| 79 |
| 80 TEST(NtlmBufferReaderTest, ReadBytes) { |
| 81 uint8_t expected[8]; |
| 82 uint8_t actual[8]; |
| 83 |
| 84 expected[0] = 0x11; |
| 85 expected[1] = 0x22; |
| 86 expected[2] = 0x33; |
| 87 expected[3] = 0x44; |
| 88 expected[4] = 0x55; |
| 89 expected[5] = 0x66; |
| 90 expected[6] = 0x77; |
| 91 expected[7] = 0x88; |
| 92 |
| 93 NtlmBufferReader reader(expected, arraysize(expected)); |
| 94 |
| 95 EXPECT_TRUE(reader.ReadBytes(actual, arraysize(actual))); |
| 96 EXPECT_EQ(0, memcmp(actual, expected, arraysize(actual))); |
| 97 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 98 EXPECT_FALSE(reader.ReadBytes(actual, 1)); |
| 99 } |
| 100 |
| 101 TEST(NtlmBufferReaderTest, ReadSecurityBuffer) { |
| 102 uint8_t buf[8]; |
| 103 uint16_t length = 0x1122; |
| 104 uint16_t allocated = 0x3344; |
| 105 uint32_t offset = 0x55667788; |
| 106 |
| 107 buf[0] = length & 0xff; |
| 108 buf[1] = length >> 8; |
| 109 buf[2] = allocated & 0xff; |
| 110 buf[3] = allocated >> 8; |
| 111 buf[4] = offset & 0xff; |
| 112 buf[5] = (offset & 0xff00) >> 8; |
| 113 buf[6] = (offset & 0xff0000) >> 16; |
| 114 buf[7] = (offset & 0xff000000) >> 24; |
| 115 |
| 116 NtlmBufferReader reader(buf, arraysize(buf)); |
| 117 |
| 118 uint16_t actual_length; |
| 119 uint32_t actual_offset; |
| 120 EXPECT_TRUE(reader.ReadSecurityBuffer(&actual_length, &actual_offset)); |
| 121 EXPECT_EQ(length, actual_length); |
| 122 EXPECT_EQ(offset, actual_offset); |
| 123 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 124 EXPECT_FALSE(reader.ReadSecurityBuffer(&actual_length, &actual_offset)); |
| 125 } |
| 126 |
| 127 TEST(NtlmBufferReaderTest, ReadAsciiString) { |
| 128 uint8_t buf[8]; |
| 129 std::string expected("12345678"); |
| 130 memcpy(buf, expected.c_str(), expected.size()); |
| 131 |
| 132 NtlmBufferReader reader(buf, arraysize(buf)); |
| 133 |
| 134 std::string actual; |
| 135 EXPECT_TRUE(reader.ReadAsciiString(&actual, expected.size())); |
| 136 EXPECT_EQ(expected, actual); |
| 137 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 138 EXPECT_FALSE(reader.ReadAsciiString(&actual, expected.size())); |
| 139 } |
| 140 |
| 141 TEST(NtlmBufferReaderTest, ReadUnicodeString) { |
| 142 uint8_t buf[16]; |
| 143 std::string expected_ascii("12345678"); |
| 144 base::string16 expected; |
| 145 expected.assign(expected_ascii.begin(), expected_ascii.end()); |
| 146 memcpy(buf, expected.c_str(), expected.size() * 2); |
| 147 |
| 148 NtlmBufferReader reader(buf, arraysize(buf)); |
| 149 |
| 150 base::string16 actual; |
| 151 EXPECT_TRUE(reader.ReadUnicodeString(&actual, expected.size() * 2)); |
| 152 EXPECT_EQ(expected, actual); |
| 153 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 154 EXPECT_FALSE(reader.ReadUnicodeString(&actual, expected.size() * 2)); |
| 155 } |
| 156 |
| 157 TEST(NtlmBufferReaderTest, ReadUnicodePayload) { |
| 158 uint8_t buf[24]; |
| 159 |
| 160 std::string expected_ascii("12345678"); |
| 161 base::string16 expected; |
| 162 expected.assign(expected_ascii.begin(), expected_ascii.end()); |
| 163 |
| 164 // Write a security buffer at the start. |
| 165 memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN); |
| 166 buf[0] = expected_ascii.length() * 2; |
| 167 buf[2] = expected_ascii.length() * 2; |
| 168 buf[4] = NtlmMessage::SECURITY_BUFFER_LEN; |
| 169 |
| 170 // Put the string after the security buffer. |
| 171 memcpy(buf + 8, expected.c_str(), expected.size() * 2); |
| 172 |
| 173 NtlmBufferReader reader(buf, arraysize(buf)); |
| 174 |
| 175 base::string16 actual; |
| 176 EXPECT_TRUE(reader.ReadUnicodePayload(&actual)); |
| 177 EXPECT_EQ(expected, actual); |
| 178 // Read payload only advances the cursor over the security buffer. |
| 179 EXPECT_EQ(NtlmMessage::SECURITY_BUFFER_LEN, reader.GetCursor()); |
| 180 } |
| 181 |
| 182 TEST(NtlmBufferReaderTest, MatchSignatureTooShort) { |
| 183 uint8_t buf[7]; |
| 184 |
| 185 NtlmBufferReader reader(buf, arraysize(buf)); |
| 186 |
| 187 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 188 EXPECT_TRUE(reader.CanRead(7)); |
| 189 EXPECT_FALSE(reader.MatchSignature()); |
| 190 EXPECT_TRUE(reader.CanRead(7)); |
| 191 } |
| 192 |
| 193 TEST(NtlmBufferReaderTest, MatchSignatureNoMatch) { |
| 194 uint8_t buf[8]; |
| 195 memset(buf, 0, arraysize(buf)); |
| 196 NtlmBufferReader reader(buf, arraysize(buf)); |
| 197 |
| 198 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 199 EXPECT_TRUE(reader.CanRead(8)); |
| 200 EXPECT_FALSE(reader.MatchSignature()); |
| 201 EXPECT_TRUE(reader.CanRead(8)); |
| 202 } |
| 203 |
| 204 TEST(NtlmBufferReaderTest, MatchSignatureOk) { |
| 205 uint8_t buf[8]; |
| 206 memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN); |
| 207 NtlmBufferReader reader(buf, arraysize(buf)); |
| 208 |
| 209 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 210 EXPECT_TRUE(reader.MatchSignature()); |
| 211 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 212 } |
| 213 |
| 214 TEST(NtlmBufferReaderTest, ReadInvalidMessageType) { |
| 215 uint8_t buf[4]; |
| 216 memset(buf, 0, arraysize(buf)); |
| 217 NtlmBufferReader reader(buf, arraysize(buf)); |
| 218 |
| 219 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 220 NtlmMessage::MessageType message_type; |
| 221 EXPECT_FALSE(reader.ReadMessageType(&message_type)); |
| 222 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 223 EXPECT_TRUE(reader.CanRead(4)); |
| 224 } |
| 225 |
| 226 TEST(NtlmBufferReaderTest, ReadMessageTypeNegotiate) { |
| 227 uint8_t buf[4]; |
| 228 memset(buf, 0, arraysize(buf)); |
| 229 buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_NEGOTIATE); |
| 230 NtlmBufferReader reader(buf, arraysize(buf)); |
| 231 |
| 232 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 233 NtlmMessage::MessageType message_type; |
| 234 EXPECT_TRUE(reader.ReadMessageType(&message_type)); |
| 235 EXPECT_EQ(NtlmMessage::MESSAGE_NEGOTIATE, message_type); |
| 236 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 237 } |
| 238 |
| 239 TEST(NtlmBufferReaderTest, ReadMessageTypeChallenge) { |
| 240 uint8_t buf[4]; |
| 241 memset(buf, 0, arraysize(buf)); |
| 242 buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_CHALLENGE); |
| 243 NtlmBufferReader reader(buf, arraysize(buf)); |
| 244 |
| 245 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 246 NtlmMessage::MessageType message_type; |
| 247 EXPECT_TRUE(reader.ReadMessageType(&message_type)); |
| 248 EXPECT_EQ(NtlmMessage::MESSAGE_CHALLENGE, message_type); |
| 249 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 250 } |
| 251 |
| 252 TEST(NtlmBufferReaderTest, ReadMessageTypeAuthenticate) { |
| 253 uint8_t buf[4]; |
| 254 memset(buf, 0, arraysize(buf)); |
| 255 buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE); |
| 256 NtlmBufferReader reader(buf, arraysize(buf)); |
| 257 |
| 258 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 259 NtlmMessage::MessageType message_type; |
| 260 EXPECT_TRUE(reader.ReadMessageType(&message_type)); |
| 261 EXPECT_EQ(NtlmMessage::MESSAGE_AUTHENTICATE, message_type); |
| 262 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 263 } |
| 264 |
| 265 TEST(NtlmBufferReaderTest, MatchMessageTypeAuthenticate) { |
| 266 uint8_t buf[4]; |
| 267 memset(buf, 0, arraysize(buf)); |
| 268 buf[0] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE); |
| 269 NtlmBufferReader reader(buf, arraysize(buf)); |
| 270 |
| 271 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 272 EXPECT_TRUE(reader.MatchMessageType(NtlmMessage::MESSAGE_AUTHENTICATE)); |
| 273 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 274 } |
| 275 |
| 276 TEST(NtlmBufferReaderTest, MatchAuthenticateHeader) { |
| 277 uint8_t buf[12]; |
| 278 memset(buf, 0, arraysize(buf)); |
| 279 memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN); |
| 280 buf[8] = static_cast<uint8_t>(NtlmMessage::MESSAGE_AUTHENTICATE); |
| 281 NtlmBufferReader reader(buf, arraysize(buf)); |
| 282 |
| 283 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 284 EXPECT_TRUE(reader.MatchMessageHeader(NtlmMessage::MESSAGE_AUTHENTICATE)); |
| 285 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 286 } |
| 287 |
| 288 TEST(NtlmBufferReaderTest, MatchFailsRollsBackCursor) { |
| 289 uint8_t buf[12]; |
| 290 memset(buf, 0, arraysize(buf)); |
| 291 memcpy(buf, NtlmMessage::SIGNATURE, NtlmMessage::SIGNATURE_LEN); |
| 292 buf[8] = 0x04; // Invalid |
| 293 NtlmBufferReader reader(buf, arraysize(buf)); |
| 294 |
| 295 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 296 EXPECT_EQ(0u, reader.GetCursor()); |
| 297 EXPECT_FALSE(reader.MatchMessageHeader(NtlmMessage::MESSAGE_AUTHENTICATE)); |
| 298 EXPECT_EQ(0u, reader.GetCursor()); |
| 299 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 300 } |
| 301 |
| 302 TEST(NtlmBufferReaderTest, MatchZeros) { |
| 303 uint8_t buf[12]; |
| 304 memset(buf, 0, arraysize(buf)); |
| 305 |
| 306 NtlmBufferReader reader(buf, arraysize(buf)); |
| 307 |
| 308 EXPECT_TRUE(reader.MatchZeros(arraysize(buf))); |
| 309 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 310 EXPECT_FALSE(reader.MatchZeros(1)); |
| 311 } |
| 312 |
| 313 TEST(NtlmBufferReaderTest, MatchZerosFail) { |
| 314 uint8_t buf[12]; |
| 315 memset(buf, 0, arraysize(buf)); |
| 316 buf[11] = 0x01; |
| 317 |
| 318 NtlmBufferReader reader(buf, arraysize(buf)); |
| 319 |
| 320 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 321 EXPECT_EQ(0u, reader.GetCursor()); |
| 322 EXPECT_FALSE(reader.MatchZeros(arraysize(buf))); |
| 323 EXPECT_EQ(0u, reader.GetCursor()); |
| 324 EXPECT_FALSE(reader.IsEndOfBuffer()); |
| 325 } |
| 326 |
| 327 TEST(NtlmBufferReaderTest, MatchEmptySecurityBuffer) { |
| 328 uint8_t buf[NtlmMessage::SECURITY_BUFFER_LEN]; |
| 329 memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN); |
| 330 |
| 331 NtlmBufferReader reader(buf, NtlmMessage::SECURITY_BUFFER_LEN); |
| 332 |
| 333 EXPECT_TRUE(reader.MatchEmptySecurityBuffer()); |
| 334 EXPECT_TRUE(reader.IsEndOfBuffer()); |
| 335 EXPECT_FALSE(reader.MatchEmptySecurityBuffer()); |
| 336 } |
| 337 |
| 338 TEST(NtlmBufferReaderTest, MatchEmptySecurityBufferFail) { |
| 339 uint8_t buf[NtlmMessage::SECURITY_BUFFER_LEN]; |
| 340 memset(buf, 0, NtlmMessage::SECURITY_BUFFER_LEN); |
| 341 buf[NtlmMessage::SECURITY_BUFFER_LEN - 1] = 0x01; |
| 342 |
| 343 NtlmBufferReader reader(buf, NtlmMessage::SECURITY_BUFFER_LEN); |
| 344 |
| 345 EXPECT_EQ(0u, reader.GetCursor()); |
| 346 EXPECT_FALSE(reader.MatchEmptySecurityBuffer()); |
| 347 EXPECT_EQ(0u, reader.GetCursor()); |
| 348 } |
| 349 |
| 350 } // namespace net |
OLD | NEW |