7ee4a08fe04752d46fac64a01cce4df8cf12e33f
[openssl.git] / test / packettest.c
1 /*
2  * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "../ssl/packet_locl.h"
11 #include "testutil.h"
12 #include "test_main.h"
13
14 #define BUF_LEN 255
15
16 static unsigned char smbuf[BUF_LEN];
17
18 static int test_PACKET_remaining()
19 {
20     PACKET pkt;
21
22     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
23             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
24             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
25             || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
26             || !TEST_true(PACKET_forward(&pkt, 1))
27             || !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
28         return 0;
29
30     return 1;
31 }
32
33 static int test_PACKET_end()
34 {
35     PACKET pkt;
36
37     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
38             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
39             || !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
40             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
41             || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
42             || !TEST_true(PACKET_forward(&pkt, 1))
43             || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
44         return 0;
45
46     return 1;
47 }
48
49 static int test_PACKET_get_1()
50 {
51     unsigned int i;
52     PACKET pkt;
53
54     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
55             || !TEST_true(PACKET_get_1(&pkt, &i))
56             || !TEST_uint_eq(i, 0x02)
57             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
58             || !TEST_true(PACKET_get_1(&pkt, &i))
59             || !TEST_uint_eq(i, 0xfe)
60             || !TEST_false(PACKET_get_1(&pkt, &i)))
61         return 0;
62
63     return 1;
64 }
65
66 static int test_PACKET_get_4()
67 {
68     unsigned long i;
69     PACKET pkt;
70
71     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
72             || !TEST_true(PACKET_get_4(&pkt, &i))
73             || !TEST_ulong_eq(i, 0x08060402UL)
74             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
75             || !TEST_true(PACKET_get_4(&pkt, &i))
76             || !TEST_ulong_eq(i, 0xfefcfaf8UL)
77             || !TEST_false(PACKET_get_4(&pkt, &i)))
78         return 0;
79
80     return 1;
81 }
82
83 static int test_PACKET_get_net_2()
84 {
85     unsigned int i;
86     PACKET pkt;
87
88     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
89             || !TEST_true(PACKET_get_net_2(&pkt, &i))
90             || !TEST_uint_eq(i, 0x0204)
91             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
92             || !TEST_true(PACKET_get_net_2(&pkt, &i))
93             || !TEST_uint_eq(i, 0xfcfe)
94             || !TEST_false(PACKET_get_net_2(&pkt, &i)))
95         return 0;
96
97     return 1;
98 }
99
100 static int test_PACKET_get_net_3()
101 {
102     unsigned long i;
103     PACKET pkt;
104
105     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
106             || !TEST_true(PACKET_get_net_3(&pkt, &i))
107             || !TEST_ulong_eq(i, 0x020406UL)
108             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
109             || !TEST_true(PACKET_get_net_3(&pkt, &i))
110             || !TEST_ulong_eq(i, 0xfafcfeUL)
111             || !TEST_false(PACKET_get_net_3(&pkt, &i)))
112         return 0;
113
114     return 1;
115 }
116
117 static int test_PACKET_get_net_4()
118 {
119     unsigned long i;
120     PACKET pkt;
121
122     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
123             || !TEST_true(PACKET_get_net_4(&pkt, &i))
124             || !TEST_ulong_eq(i, 0x02040608UL)
125             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
126             || !TEST_true(PACKET_get_net_4(&pkt, &i))
127             || !TEST_ulong_eq(i, 0xf8fafcfeUL)
128             || !TEST_false(PACKET_get_net_4(&pkt, &i)))
129         return 0;
130
131     return 1;
132 }
133
134 static int test_PACKET_get_sub_packet()
135 {
136     PACKET pkt, subpkt;
137     unsigned long i;
138
139     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
140             || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
141             || !TEST_true(PACKET_get_net_4(&subpkt, &i))
142             || !TEST_ulong_eq(i, 0x02040608UL)
143             || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
144             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
145             || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
146             || !TEST_true(PACKET_get_net_4(&subpkt, &i))
147             || !TEST_ulong_eq(i, 0xf8fafcfeUL)
148             || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
149             || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
150         return 0;
151
152     return 1;
153 }
154
155 static int test_PACKET_get_bytes()
156 {
157     const unsigned char *bytes;
158     PACKET pkt;
159
160     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
161             || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
162             || !TEST_uchar_eq(bytes[0], 2)
163             || !TEST_uchar_eq(bytes[1], 4)
164             || !TEST_uchar_eq(bytes[2], 6)
165             || !TEST_uchar_eq(bytes[3], 8)
166             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
167             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
168             || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
169             || !TEST_uchar_eq(bytes[0], 0xf8)
170             || !TEST_uchar_eq(bytes[1], 0xfa)
171             || !TEST_uchar_eq(bytes[2], 0xfc)
172             || !TEST_uchar_eq(bytes[3], 0xfe)
173             || !TEST_false(PACKET_remaining(&pkt)))
174         return 0;
175
176     return 1;
177 }
178
179 static int test_PACKET_copy_bytes()
180 {
181     unsigned char bytes[4];
182     PACKET pkt;
183
184     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
185             || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
186             || !TEST_char_eq(bytes[0], 2)
187             || !TEST_char_eq(bytes[1], 4)
188             || !TEST_char_eq(bytes[2], 6)
189             || !TEST_char_eq(bytes[3], 8)
190             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
191             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
192             || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
193             || !TEST_uchar_eq(bytes[0], 0xf8)
194             || !TEST_uchar_eq(bytes[1], 0xfa)
195             || !TEST_uchar_eq(bytes[2], 0xfc)
196             || !TEST_uchar_eq(bytes[3], 0xfe)
197             || !TEST_false(PACKET_remaining(&pkt)))
198         return 0;
199
200     return 1;
201 }
202
203 static int test_PACKET_copy_all()
204 {
205     unsigned char tmp[BUF_LEN];
206     PACKET pkt;
207     size_t len;
208
209     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
210             || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
211             || !TEST_size_t_eq(len, BUF_LEN)
212             || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
213             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
214             || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
215         return 0;
216
217     return 1;
218 }
219
220 static int test_PACKET_memdup()
221 {
222     unsigned char *data = NULL;
223     size_t len;
224     PACKET pkt;
225     int result = 0;
226
227     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
228             || !TEST_true(PACKET_memdup(&pkt, &data, &len))
229             || !TEST_size_t_eq(len, BUF_LEN)
230             || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
231             || !TEST_true(PACKET_forward(&pkt, 10))
232             || !TEST_true(PACKET_memdup(&pkt, &data, &len))
233             || !TEST_size_t_eq(len, BUF_LEN - 10)
234             || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
235         goto end;
236     result = 1;
237 end:
238     OPENSSL_free(data);
239     return result;
240 }
241
242 static int test_PACKET_strndup()
243 {
244     char buf1[10], buf2[10];
245     char *data = NULL;
246     PACKET pkt;
247     int result = 0;
248
249     memset(buf1, 'x', 10);
250     memset(buf2, 'y', 10);
251     buf2[5] = '\0';
252
253     if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
254             || !TEST_true(PACKET_strndup(&pkt, &data))
255             || !TEST_size_t_eq(strlen(data), 10)
256             || !TEST_strn_eq(data, buf1, 10)
257             || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
258             || !TEST_true(PACKET_strndup(&pkt, &data))
259             || !TEST_size_t_eq(strlen(data), 5)
260             || !TEST_str_eq(data, buf2))
261         goto end;
262
263     result = 1;
264 end:
265     OPENSSL_free(data);
266     return result;
267 }
268
269 static int test_PACKET_contains_zero_byte()
270 {
271     char buf1[10], buf2[10];
272     PACKET pkt;
273
274     memset(buf1, 'x', 10);
275     memset(buf2, 'y', 10);
276     buf2[5] = '\0';
277
278     if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
279             || !TEST_false(PACKET_contains_zero_byte(&pkt))
280             || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
281             || !TEST_true(PACKET_contains_zero_byte(&pkt)))
282         return 0;
283
284     return 1;
285 }
286
287 static int test_PACKET_forward()
288 {
289     const unsigned char *byte;
290     PACKET pkt;
291
292     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
293             || !TEST_true(PACKET_forward(&pkt, 1))
294             || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
295             || !TEST_uchar_eq(byte[0], 4)
296             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
297             || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
298             || !TEST_uchar_eq(byte[0], 0xfe))
299         return 0;
300
301     return 1;
302 }
303
304 static int test_PACKET_buf_init()
305 {
306     unsigned char buf1[BUF_LEN];
307     PACKET pkt;
308
309     /* Also tests PACKET_remaining() */
310     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
311             || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
312             || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
313             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
314             || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
315         return 0;
316
317     return 1;
318 }
319
320 static int test_PACKET_null_init()
321 {
322     PACKET pkt;
323
324     PACKET_null_init(&pkt);
325     if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
326             || !TEST_false(PACKET_forward(&pkt, 1)))
327         return 0;
328
329     return 1;
330 }
331
332 static int test_PACKET_equal()
333 {
334     PACKET pkt;
335
336     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
337             || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
338             || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
339             || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
340             || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
341             || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
342             || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
343             || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
344         return 0;
345
346     return 1;
347 }
348
349 static int test_PACKET_get_length_prefixed_1()
350 {
351     unsigned char buf1[BUF_LEN];
352     const size_t len = 16;
353     unsigned int i;
354     PACKET pkt, short_pkt, subpkt = {0};
355
356     buf1[0] = len;
357     for (i = 1; i < BUF_LEN; i++)
358         buf1[i] = (i * 2) & 0xff;
359
360     if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
361             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
362             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
363             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
364             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
365             || !TEST_uint_eq(i, 0x0204)
366             || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
367             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
368         return 0;
369
370     return 1;
371 }
372
373 static int test_PACKET_get_length_prefixed_2()
374 {
375     unsigned char buf1[1024];
376     const size_t len = 516;  /* 0x0204 */
377     unsigned int i;
378     PACKET pkt, short_pkt, subpkt = {0};
379
380     for (i = 1; i <= 1024; i++)
381         buf1[i - 1] = (i * 2) & 0xff;
382
383     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
384             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
385             || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
386             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
387             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
388             || !TEST_uint_eq(i, 0x0608)
389             || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
390             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
391         return 0;
392
393     return 1;
394 }
395
396 static int test_PACKET_get_length_prefixed_3()
397 {
398     unsigned char buf1[1024];
399     const size_t len = 516;  /* 0x000204 */
400     unsigned int i;
401     PACKET pkt, short_pkt, subpkt = {0};
402
403     for (i = 0; i < 1024; i++)
404         buf1[i] = (i * 2) & 0xff;
405
406     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
407             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
408             || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
409             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
410             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
411             || !TEST_uint_eq(i, 0x0608)
412             || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
413             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
414         return 0;
415
416     return 1;
417 }
418
419 static int test_PACKET_as_length_prefixed_1()
420 {
421     unsigned char buf1[BUF_LEN];
422     const size_t len = 16;
423     unsigned int i;
424     PACKET pkt, exact_pkt, subpkt;
425
426     buf1[0] = len;
427     for (i = 1; i < BUF_LEN; i++)
428         buf1[i] = (i * 2) & 0xff;
429
430     if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
431             || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
432             || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
433             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
434             || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
435             || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
436             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
437         return 0;
438
439     return 1;
440 }
441
442 static int test_PACKET_as_length_prefixed_2()
443 {
444     unsigned char buf[1024];
445     const size_t len = 516;  /* 0x0204 */
446     unsigned int i;
447     PACKET pkt, exact_pkt, subpkt;
448
449     for (i = 1; i <= 1024; i++)
450         buf[i-1] = (i * 2) & 0xff;
451
452     if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
453             || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
454             || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
455             || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
456             || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
457             || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
458             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
459         return 0;
460
461     return 1;
462 }
463
464 void register_tests(void)
465 {
466     unsigned int i;
467
468     for (i = 1; i <= BUF_LEN; i++)
469         smbuf[i - 1] = (i * 2) & 0xff;
470
471     ADD_TEST(test_PACKET_buf_init);
472     ADD_TEST(test_PACKET_null_init);
473     ADD_TEST(test_PACKET_remaining);
474     ADD_TEST(test_PACKET_end);
475     ADD_TEST(test_PACKET_equal);
476     ADD_TEST(test_PACKET_get_1);
477     ADD_TEST(test_PACKET_get_4);
478     ADD_TEST(test_PACKET_get_net_2);
479     ADD_TEST(test_PACKET_get_net_3);
480     ADD_TEST(test_PACKET_get_net_4);
481     ADD_TEST(test_PACKET_get_sub_packet);
482     ADD_TEST(test_PACKET_get_bytes);
483     ADD_TEST(test_PACKET_copy_bytes);
484     ADD_TEST(test_PACKET_copy_all);
485     ADD_TEST(test_PACKET_memdup);
486     ADD_TEST(test_PACKET_strndup);
487     ADD_TEST(test_PACKET_contains_zero_byte);
488     ADD_TEST(test_PACKET_forward);
489     ADD_TEST(test_PACKET_get_length_prefixed_1);
490     ADD_TEST(test_PACKET_get_length_prefixed_2);
491     ADD_TEST(test_PACKET_get_length_prefixed_3);
492     ADD_TEST(test_PACKET_as_length_prefixed_1);
493     ADD_TEST(test_PACKET_as_length_prefixed_2);
494 }