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