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.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 EXPECT_TRUE(reader.CanReadFrom(0, 1)); | |
23 EXPECT_TRUE(reader.CanReadFrom(ntlm::SecurityBuffer(0, 1))); | |
24 EXPECT_FALSE(reader.CanReadFrom(1, 1)); | |
25 EXPECT_FALSE(reader.CanReadFrom(ntlm::SecurityBuffer(1, 1))); | |
26 EXPECT_FALSE(reader.CanReadFrom(0, 2)); | |
27 EXPECT_FALSE(reader.CanReadFrom(ntlm::SecurityBuffer(0, 2))); | |
28 } | |
29 | |
30 TEST(NtlmBufferReaderTest, Read16) { | |
31 uint8_t buf[2]; | |
32 const uint16_t expected = 0x1122; | |
33 // Little endian. | |
34 buf[0] = expected & 0xff; | |
asanka
2017/06/08 19:40:09
Nit: it seems easier to read buf[] was initialized
zentaro
2017/06/12 23:12:06
Done.
| |
35 buf[1] = expected >> 8; | |
36 | |
37 NtlmBufferReader reader(buf, arraysize(buf)); | |
38 | |
39 uint16_t actual; | |
40 EXPECT_TRUE(reader.ReadUInt16(&actual)); | |
41 EXPECT_EQ(expected, actual); | |
42 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
43 EXPECT_FALSE(reader.ReadUInt16(&actual)); | |
44 } | |
45 | |
46 TEST(NtlmBufferReaderTest, Read32) { | |
47 uint8_t buf[4]; | |
48 const uint32_t expected = 0x11223344; | |
49 // Little endian. | |
50 buf[0] = expected & 0xff; | |
51 buf[1] = (expected & 0xff00) >> 8; | |
52 buf[2] = (expected & 0xff0000) >> 16; | |
53 buf[3] = (expected & 0xff000000) >> 24; | |
54 | |
55 NtlmBufferReader reader(buf, arraysize(buf)); | |
56 | |
57 uint32_t actual; | |
58 EXPECT_TRUE(reader.ReadUInt32(&actual)); | |
59 EXPECT_EQ(expected, actual); | |
60 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
61 EXPECT_FALSE(reader.ReadUInt32(&actual)); | |
62 } | |
63 | |
64 TEST(NtlmBufferReaderTest, Read64) { | |
65 uint8_t buf[8]; | |
66 const uint64_t expected = 0x1122334455667788; | |
67 // Little endian. | |
68 buf[0] = expected & 0xff; | |
69 buf[1] = (expected & 0xff00) >> 8; | |
70 buf[2] = (expected & 0xff0000) >> 16; | |
71 buf[3] = (expected & 0xff000000) >> 24; | |
72 buf[4] = (expected & 0xff00000000) >> 32; | |
73 buf[5] = (expected & 0xff0000000000) >> 40; | |
74 buf[6] = (expected & 0xff000000000000) >> 48; | |
75 buf[7] = expected >> 56; | |
76 | |
77 NtlmBufferReader reader(buf, arraysize(buf)); | |
78 | |
79 uint64_t actual; | |
80 EXPECT_TRUE(reader.ReadUInt64(&actual)); | |
81 EXPECT_EQ(expected, actual); | |
82 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
83 EXPECT_FALSE(reader.ReadUInt64(&actual)); | |
84 } | |
85 | |
86 TEST(NtlmBufferReaderTest, ReadBytes) { | |
87 uint8_t expected[8]; | |
88 uint8_t actual[8]; | |
89 | |
90 expected[0] = 0x11; | |
91 expected[1] = 0x22; | |
92 expected[2] = 0x33; | |
93 expected[3] = 0x44; | |
94 expected[4] = 0x55; | |
95 expected[5] = 0x66; | |
96 expected[6] = 0x77; | |
97 expected[7] = 0x88; | |
98 | |
99 NtlmBufferReader reader(expected, arraysize(expected)); | |
100 | |
101 EXPECT_TRUE(reader.ReadBytes(actual, arraysize(actual))); | |
102 EXPECT_EQ(0, memcmp(actual, expected, arraysize(actual))); | |
103 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
104 EXPECT_FALSE(reader.ReadBytes(actual, 1)); | |
105 } | |
106 | |
107 TEST(NtlmBufferReaderTest, ReadSecurityBuffer) { | |
108 uint8_t buf[8]; | |
109 uint16_t length = 0x1122; | |
110 uint16_t allocated = 0x3344; | |
111 uint32_t offset = 0x55667788; | |
112 | |
113 buf[0] = length & 0xff; | |
114 buf[1] = length >> 8; | |
115 buf[2] = allocated & 0xff; | |
116 buf[3] = allocated >> 8; | |
117 buf[4] = offset & 0xff; | |
118 buf[5] = (offset & 0xff00) >> 8; | |
119 buf[6] = (offset & 0xff0000) >> 16; | |
120 buf[7] = (offset & 0xff000000) >> 24; | |
121 | |
122 NtlmBufferReader reader(buf, arraysize(buf)); | |
123 | |
124 ntlm::SecurityBuffer sec_buf; | |
125 EXPECT_TRUE(reader.ReadSecurityBuffer(&sec_buf)); | |
126 EXPECT_EQ(length, sec_buf.length); | |
127 EXPECT_EQ(offset, sec_buf.offset); | |
128 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
129 EXPECT_FALSE(reader.ReadSecurityBuffer(&sec_buf)); | |
130 } | |
131 | |
132 TEST(NtlmBufferReaderTest, ReadSecurityBufferPastEob) { | |
133 uint8_t buf[7]; | |
134 NtlmBufferReader reader(buf, arraysize(buf)); | |
135 | |
136 ntlm::SecurityBuffer sec_buf; | |
137 EXPECT_FALSE(reader.ReadSecurityBuffer(&sec_buf)); | |
asanka
2017/06/08 19:40:09
Check cursor for failing Read* calls? Here and els
zentaro
2017/06/12 23:12:06
Done.
| |
138 } | |
139 | |
140 TEST(NtlmBufferReaderTest, ReadAsciiString) { | |
141 uint8_t buf[8]; | |
142 std::string expected("12345678"); | |
143 memcpy(buf, expected.c_str(), expected.size()); | |
144 | |
145 NtlmBufferReader reader(buf, arraysize(buf)); | |
146 | |
147 std::string actual; | |
148 EXPECT_TRUE(reader.ReadAsciiString(&actual, expected.size())); | |
149 EXPECT_EQ(expected, actual); | |
150 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
151 EXPECT_FALSE(reader.ReadAsciiString(&actual, expected.size())); | |
152 } | |
153 | |
154 TEST(NtlmBufferReaderTest, ReadAsciiStringPastEob) { | |
155 const size_t len = 8; | |
156 uint8_t buf[len]; | |
157 | |
158 NtlmBufferReader reader(buf, arraysize(buf)); | |
159 | |
160 std::string actual; | |
161 EXPECT_FALSE(reader.ReadAsciiString(&actual, len + 1)); | |
162 } | |
163 | |
164 TEST(NtlmBufferReaderTest, ReadUnicodeString) { | |
165 uint8_t buf[16]; | |
166 std::string expected_ascii("12345678"); | |
167 base::string16 expected; | |
168 expected.assign(expected_ascii.begin(), expected_ascii.end()); | |
asanka
2017/06/08 19:40:09
This test assumes that string16 encodes in UTF-16L
zentaro
2017/06/12 23:12:07
Done.
| |
169 memcpy(buf, expected.c_str(), expected.size() * 2); | |
170 | |
171 NtlmBufferReader reader(buf, arraysize(buf)); | |
172 | |
173 base::string16 actual; | |
174 EXPECT_TRUE(reader.ReadUnicodeString(&actual, expected.size() * 2)); | |
175 EXPECT_EQ(expected, actual); | |
176 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
177 EXPECT_FALSE(reader.ReadUnicodeString(&actual, expected.size() * 2)); | |
178 } | |
asanka
2017/06/08 19:41:52
For UnicodeString reads and writes, let's add some
| |
179 | |
180 TEST(NtlmBufferReaderTest, ReadUnicodeStringPastEob) { | |
181 const size_t len = 8; | |
182 uint8_t buf[len]; | |
183 | |
184 NtlmBufferReader reader(buf, arraysize(buf)); | |
185 | |
186 // Try to read one more character (2 bytes) than there is space. | |
187 base::string16 actual; | |
188 EXPECT_FALSE(reader.ReadUnicodeString(&actual, len + 2)); | |
189 } | |
190 | |
191 TEST(NtlmBufferReaderTest, ReadUnicodeStringOddLength) { | |
192 const size_t len = 8; | |
193 uint8_t buf[len]; | |
194 | |
195 NtlmBufferReader reader(buf, arraysize(buf)); | |
196 | |
197 // Try to read a 16-bit string with a length that isn't a multiple | |
198 // of 2. | |
199 base::string16 actual; | |
200 EXPECT_FALSE(reader.ReadUnicodeString(&actual, len - 1)); | |
201 } | |
202 | |
203 TEST(NtlmBufferReaderTest, ReadAsciiPayload) { | |
204 uint8_t buf[24]; | |
205 | |
206 std::string expected("12345678"); | |
207 | |
208 // Write a security buffer at the start. | |
209 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
210 buf[0] = expected.length(); | |
211 buf[2] = expected.length(); | |
212 buf[4] = ntlm::SECURITY_BUFFER_LEN; | |
213 | |
214 // Put the string after the security buffer. | |
215 memcpy(buf + ntlm::SECURITY_BUFFER_LEN, expected.c_str(), | |
216 expected.size() * 2); | |
217 | |
218 NtlmBufferReader reader(buf, arraysize(buf)); | |
219 | |
220 std::string actual; | |
221 EXPECT_TRUE(reader.ReadAsciiPayload(&actual)); | |
222 EXPECT_EQ(expected, actual); | |
223 // Read payload only advances the cursor over the security buffer. | |
224 EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor()); | |
225 } | |
226 | |
227 TEST(NtlmBufferReaderTest, ReadUnicodePayload) { | |
228 uint8_t buf[24]; | |
229 | |
230 std::string expected_ascii("12345678"); | |
231 base::string16 expected; | |
232 expected.assign(expected_ascii.begin(), expected_ascii.end()); | |
233 | |
234 // Write a security buffer at the start. | |
235 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
asanka
2017/06/08 19:40:09
Yup. Definitely initialize buf directly.
zentaro
2017/06/12 23:12:07
Done.
| |
236 buf[0] = expected_ascii.length() * 2; | |
237 buf[2] = expected_ascii.length() * 2; | |
238 buf[4] = ntlm::SECURITY_BUFFER_LEN; | |
239 | |
240 // Put the string after the security buffer. | |
241 memcpy(buf + 8, expected.c_str(), expected.size() * 2); | |
242 | |
243 NtlmBufferReader reader(buf, arraysize(buf)); | |
244 | |
245 base::string16 actual; | |
246 EXPECT_TRUE(reader.ReadUnicodePayload(&actual)); | |
247 EXPECT_EQ(expected, actual); | |
248 // Read payload only advances the cursor over the security buffer. | |
249 EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor()); | |
250 } | |
251 | |
252 TEST(NtlmBufferReaderTest, SkipSecurityBuffer) { | |
253 uint8_t buf[ntlm::SECURITY_BUFFER_LEN]; | |
254 | |
255 NtlmBufferReader reader(buf, arraysize(buf)); | |
256 EXPECT_TRUE(reader.SkipSecurityBuffer()); | |
257 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
258 EXPECT_FALSE(reader.SkipSecurityBuffer()); | |
259 } | |
260 | |
261 TEST(NtlmBufferReaderTest, SkipSecurityBufferPastEob) { | |
262 uint8_t buf[ntlm::SECURITY_BUFFER_LEN - 1]; | |
263 | |
264 // The buffer is one byte shorter than security buffer. | |
265 NtlmBufferReader reader(buf, arraysize(buf)); | |
266 EXPECT_FALSE(reader.SkipSecurityBuffer()); | |
267 EXPECT_EQ(0u, reader.GetCursor()); | |
268 } | |
269 | |
270 TEST(NtlmBufferReaderTest, SkipSecurityBufferWithValidationEmpty) { | |
asanka
2017/06/08 19:40:09
We are permissive about buffers with a length of z
zentaro
2017/06/12 23:12:06
Yes. Added explicit test.
| |
271 uint8_t buf[ntlm::SECURITY_BUFFER_LEN]; | |
272 | |
273 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
274 | |
275 NtlmBufferReader reader(buf, arraysize(buf)); | |
276 EXPECT_TRUE(reader.SkipSecurityBufferWithValidation()); | |
277 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
278 EXPECT_FALSE(reader.SkipSecurityBufferWithValidation()); | |
279 } | |
280 | |
281 TEST(NtlmBufferReaderTest, SkipSecurityBufferWithValidationValid) { | |
282 uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1]; | |
283 | |
284 // Write a valid security buffer that points to the 1 payload byte. | |
285 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
286 buf[0] = 1; | |
287 buf[2] = 1; | |
288 buf[4] = ntlm::SECURITY_BUFFER_LEN; | |
289 | |
290 NtlmBufferReader reader(buf, arraysize(buf)); | |
291 EXPECT_TRUE(reader.SkipSecurityBufferWithValidation()); | |
292 EXPECT_EQ(ntlm::SECURITY_BUFFER_LEN, reader.GetCursor()); | |
293 EXPECT_FALSE(reader.SkipSecurityBufferWithValidation()); | |
294 } | |
295 | |
296 TEST(NtlmBufferReaderTest, | |
297 SkipSecurityBufferWithValidationPayloadLengthPastEob) { | |
298 uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1]; | |
299 | |
300 // Security buffer with length that points past the end of buffer. | |
301 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
302 buf[0] = 2; | |
303 buf[2] = 2; | |
304 buf[4] = ntlm::SECURITY_BUFFER_LEN; | |
305 | |
306 NtlmBufferReader reader(buf, arraysize(buf)); | |
307 EXPECT_FALSE(reader.SkipSecurityBufferWithValidation()); | |
308 EXPECT_EQ(0u, reader.GetCursor()); | |
309 EXPECT_FALSE(reader.SkipSecurityBufferWithValidation()); | |
310 } | |
311 | |
312 TEST(NtlmBufferReaderTest, | |
313 SkipSecurityBufferWithValidationPayloadOffsetPastEob) { | |
314 uint8_t buf[ntlm::SECURITY_BUFFER_LEN + 1]; | |
315 | |
316 // Security buffer with offset that points past the end of buffer. | |
317 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
318 buf[0] = 1; | |
319 buf[2] = 1; | |
320 buf[4] = ntlm::SECURITY_BUFFER_LEN + 1; | |
321 | |
322 NtlmBufferReader reader(buf, arraysize(buf)); | |
323 EXPECT_FALSE(reader.SkipSecurityBufferWithValidation()); | |
324 EXPECT_EQ(0u, reader.GetCursor()); | |
325 } | |
326 | |
327 TEST(NtlmBufferReaderTest, SkipBytes) { | |
328 uint8_t buf[8]; | |
329 | |
330 NtlmBufferReader reader(buf, arraysize(buf)); | |
331 | |
332 EXPECT_TRUE(reader.SkipBytes(arraysize(buf))); | |
333 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
334 EXPECT_FALSE(reader.SkipBytes(arraysize(buf))); | |
335 } | |
336 | |
337 TEST(NtlmBufferReaderTest, SkipBytesPastEob) { | |
338 uint8_t buf[8]; | |
339 | |
340 NtlmBufferReader reader(buf, arraysize(buf)); | |
341 | |
342 EXPECT_FALSE(reader.SkipBytes(arraysize(buf) + 1)); | |
343 EXPECT_EQ(0u, reader.GetCursor()); | |
344 } | |
345 | |
346 TEST(NtlmBufferReaderTest, MatchSignatureTooShort) { | |
347 uint8_t buf[7]; | |
348 | |
349 NtlmBufferReader reader(buf, arraysize(buf)); | |
350 | |
351 EXPECT_TRUE(reader.CanRead(7)); | |
352 EXPECT_FALSE(reader.MatchSignature()); | |
353 EXPECT_TRUE(reader.CanRead(7)); | |
354 } | |
355 | |
356 TEST(NtlmBufferReaderTest, MatchSignatureNoMatch) { | |
357 uint8_t buf[8]; | |
358 memset(buf, 0, arraysize(buf)); | |
359 NtlmBufferReader reader(buf, arraysize(buf)); | |
360 | |
361 EXPECT_TRUE(reader.CanRead(8)); | |
362 EXPECT_FALSE(reader.MatchSignature()); | |
363 EXPECT_TRUE(reader.CanRead(8)); | |
364 } | |
365 | |
366 TEST(NtlmBufferReaderTest, MatchSignatureOk) { | |
367 uint8_t buf[8]; | |
368 memcpy(buf, ntlm::SIGNATURE, ntlm::SIGNATURE_LEN); | |
369 NtlmBufferReader reader(buf, arraysize(buf)); | |
370 | |
371 EXPECT_TRUE(reader.MatchSignature()); | |
372 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
373 } | |
374 | |
375 TEST(NtlmBufferReaderTest, ReadInvalidMessageType) { | |
376 uint8_t buf[4]; | |
377 memset(buf, 0, arraysize(buf)); | |
378 NtlmBufferReader reader(buf, arraysize(buf)); | |
379 | |
380 ntlm::MessageType message_type; | |
381 EXPECT_FALSE(reader.ReadMessageType(&message_type)); | |
382 EXPECT_FALSE(reader.IsEndOfBuffer()); | |
383 EXPECT_TRUE(reader.CanRead(4)); | |
384 } | |
385 | |
386 TEST(NtlmBufferReaderTest, ReadMessageTypeNegotiate) { | |
387 uint8_t buf[4]; | |
388 memset(buf, 0, arraysize(buf)); | |
389 buf[0] = static_cast<uint8_t>(ntlm::MESSAGE_NEGOTIATE); | |
390 NtlmBufferReader reader(buf, arraysize(buf)); | |
391 | |
392 ntlm::MessageType message_type; | |
393 EXPECT_TRUE(reader.ReadMessageType(&message_type)); | |
394 EXPECT_EQ(ntlm::MESSAGE_NEGOTIATE, message_type); | |
395 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
396 } | |
397 | |
398 TEST(NtlmBufferReaderTest, ReadMessageTypeChallenge) { | |
399 uint8_t buf[4]; | |
400 memset(buf, 0, arraysize(buf)); | |
401 buf[0] = static_cast<uint8_t>(ntlm::MESSAGE_CHALLENGE); | |
402 NtlmBufferReader reader(buf, arraysize(buf)); | |
403 | |
404 ntlm::MessageType message_type; | |
405 EXPECT_TRUE(reader.ReadMessageType(&message_type)); | |
406 EXPECT_EQ(ntlm::MESSAGE_CHALLENGE, message_type); | |
407 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
408 } | |
409 | |
410 TEST(NtlmBufferReaderTest, ReadMessageTypeAuthenticate) { | |
411 uint8_t buf[4]; | |
412 memset(buf, 0, arraysize(buf)); | |
413 buf[0] = static_cast<uint8_t>(ntlm::MESSAGE_AUTHENTICATE); | |
414 NtlmBufferReader reader(buf, arraysize(buf)); | |
415 | |
416 ntlm::MessageType message_type; | |
417 EXPECT_TRUE(reader.ReadMessageType(&message_type)); | |
418 EXPECT_EQ(ntlm::MESSAGE_AUTHENTICATE, message_type); | |
419 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
420 } | |
421 | |
422 TEST(NtlmBufferReaderTest, MatchMessageTypeAuthenticate) { | |
423 uint8_t buf[4]; | |
424 memset(buf, 0, arraysize(buf)); | |
425 buf[0] = static_cast<uint8_t>(ntlm::MESSAGE_AUTHENTICATE); | |
426 NtlmBufferReader reader(buf, arraysize(buf)); | |
427 | |
428 EXPECT_TRUE(reader.MatchMessageType(ntlm::MESSAGE_AUTHENTICATE)); | |
429 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
430 } | |
431 | |
432 TEST(NtlmBufferReaderTest, MatchMessageTypeInvalid) { | |
433 uint8_t buf[4]; | |
434 memset(buf, 0, arraysize(buf)); | |
435 // Invalid message type. | |
436 buf[0] = 99; | |
437 NtlmBufferReader reader(buf, arraysize(buf)); | |
438 | |
439 EXPECT_FALSE(reader.MatchMessageType(ntlm::MESSAGE_AUTHENTICATE)); | |
440 EXPECT_EQ(0u, reader.GetCursor()); | |
441 } | |
442 | |
443 TEST(NtlmBufferReaderTest, MatchMessageTypeMismatch) { | |
444 uint8_t buf[4]; | |
445 memset(buf, 0, arraysize(buf)); | |
446 buf[0] = static_cast<uint8_t>(ntlm::MESSAGE_CHALLENGE); | |
447 NtlmBufferReader reader(buf, arraysize(buf)); | |
448 | |
449 EXPECT_FALSE(reader.MatchMessageType(ntlm::MESSAGE_AUTHENTICATE)); | |
450 EXPECT_EQ(0u, reader.GetCursor()); | |
451 } | |
452 | |
453 TEST(NtlmBufferReaderTest, MatchAuthenticateHeader) { | |
454 uint8_t buf[12]; | |
455 memset(buf, 0, arraysize(buf)); | |
456 memcpy(buf, ntlm::SIGNATURE, ntlm::SIGNATURE_LEN); | |
457 buf[8] = static_cast<uint8_t>(ntlm::MESSAGE_AUTHENTICATE); | |
458 NtlmBufferReader reader(buf, arraysize(buf)); | |
459 | |
460 EXPECT_TRUE(reader.MatchMessageHeader(ntlm::MESSAGE_AUTHENTICATE)); | |
461 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
462 } | |
463 | |
464 TEST(NtlmBufferReaderTest, MatchAuthenticateHeaderMisMatch) { | |
465 uint8_t buf[12]; | |
466 memset(buf, 0, arraysize(buf)); | |
467 memcpy(buf, ntlm::SIGNATURE, ntlm::SIGNATURE_LEN); | |
468 buf[8] = static_cast<uint8_t>(ntlm::MESSAGE_CHALLENGE); | |
469 NtlmBufferReader reader(buf, arraysize(buf)); | |
470 | |
471 EXPECT_FALSE(reader.MatchMessageType(ntlm::MESSAGE_AUTHENTICATE)); | |
472 EXPECT_EQ(0u, reader.GetCursor()); | |
473 } | |
474 | |
475 TEST(NtlmBufferReaderTest, MatchFailsRollsBackCursor) { | |
476 uint8_t buf[12]; | |
477 memset(buf, 0, arraysize(buf)); | |
478 memcpy(buf, ntlm::SIGNATURE, ntlm::SIGNATURE_LEN); | |
479 buf[8] = 0x04; // Invalid | |
480 NtlmBufferReader reader(buf, arraysize(buf)); | |
481 | |
482 EXPECT_EQ(0u, reader.GetCursor()); | |
483 EXPECT_FALSE(reader.MatchMessageHeader(ntlm::MESSAGE_AUTHENTICATE)); | |
484 EXPECT_EQ(0u, reader.GetCursor()); | |
485 EXPECT_FALSE(reader.IsEndOfBuffer()); | |
486 } | |
487 | |
488 TEST(NtlmBufferReaderTest, MatchZeros) { | |
489 uint8_t buf[12]; | |
490 memset(buf, 0, arraysize(buf)); | |
491 | |
492 NtlmBufferReader reader(buf, arraysize(buf)); | |
493 | |
494 EXPECT_TRUE(reader.MatchZeros(arraysize(buf))); | |
495 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
496 EXPECT_FALSE(reader.MatchZeros(1)); | |
497 } | |
498 | |
499 TEST(NtlmBufferReaderTest, MatchZerosFail) { | |
500 uint8_t buf[12]; | |
501 memset(buf, 0, arraysize(buf)); | |
502 buf[11] = 0x01; | |
503 | |
504 NtlmBufferReader reader(buf, arraysize(buf)); | |
505 | |
506 EXPECT_EQ(0u, reader.GetCursor()); | |
507 EXPECT_FALSE(reader.MatchZeros(arraysize(buf))); | |
508 EXPECT_EQ(0u, reader.GetCursor()); | |
509 EXPECT_FALSE(reader.IsEndOfBuffer()); | |
510 } | |
511 | |
512 TEST(NtlmBufferReaderTest, MatchEmptySecurityBuffer) { | |
513 uint8_t buf[ntlm::SECURITY_BUFFER_LEN]; | |
514 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
515 | |
516 NtlmBufferReader reader(buf, ntlm::SECURITY_BUFFER_LEN); | |
517 | |
518 EXPECT_TRUE(reader.MatchEmptySecurityBuffer()); | |
519 EXPECT_TRUE(reader.IsEndOfBuffer()); | |
520 EXPECT_FALSE(reader.MatchEmptySecurityBuffer()); | |
521 } | |
522 | |
523 TEST(NtlmBufferReaderTest, MatchEmptySecurityBufferFail) { | |
524 uint8_t buf[ntlm::SECURITY_BUFFER_LEN]; | |
525 memset(buf, 0, ntlm::SECURITY_BUFFER_LEN); | |
526 buf[ntlm::SECURITY_BUFFER_LEN - 1] = 0x01; | |
527 | |
528 NtlmBufferReader reader(buf, ntlm::SECURITY_BUFFER_LEN); | |
529 | |
530 EXPECT_EQ(0u, reader.GetCursor()); | |
531 EXPECT_FALSE(reader.MatchEmptySecurityBuffer()); | |
532 EXPECT_EQ(0u, reader.GetCursor()); | |
533 } | |
534 | |
535 } // namespace net | |
OLD | NEW |