3ab293e0e98c8d43cc7bade97921c9d894d685cf
[openssl.git] / test / wpackettest.c
1 /*
2  * Copyright 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 <string.h>
11 #include <openssl/buffer.h>
12 #include "../ssl/packet_locl.h"
13 #include "testutil.h"
14 #include "test_main_custom.h"
15
16 const static unsigned char simple1 = 0xff;
17 const static unsigned char simple2[] = { 0x01, 0xff };
18 const static unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
19 const static unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
20 const static unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
21 const static unsigned char empty = 0x00;
22 const static unsigned char alloc[] = { 0x02, 0xfe, 0xff };
23 const static unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
24 const static unsigned char fixed[] = { 0xff, 0xff, 0xff };
25
26 static BUF_MEM *buf;
27
28 static void testfail(const char *msg, WPACKET *pkt)
29 {
30     fprintf(stderr, "%s", msg);
31     WPACKET_cleanup(pkt);
32 }
33
34 static int test_WPACKET_init(void)
35 {
36     WPACKET pkt;
37     int i;
38     size_t written;
39     unsigned char sbuf[3];
40
41     if (!WPACKET_init(&pkt, buf)
42             || !WPACKET_put_bytes_u8(&pkt, 0xff)
43                 /* Closing a top level WPACKET should fail */
44             ||  WPACKET_close(&pkt)
45                 /* Finishing a top level WPACKET should succeed */
46             || !WPACKET_finish(&pkt)
47                 /*
48                  * Can't call close or finish on a WPACKET that's already
49                  * finished.
50                  */
51             ||  WPACKET_close(&pkt)
52             ||  WPACKET_finish(&pkt)
53             || !WPACKET_get_total_written(&pkt, &written)
54             ||  written != sizeof(simple1)
55             ||  memcmp(buf->data, &simple1, written) != 0) {
56         testfail("test_WPACKET_init():1 failed\n", &pkt);
57         return 0;
58     }
59
60     /* Now try with a one byte length prefix */
61     if (!WPACKET_init_len(&pkt, buf, 1)
62             || !WPACKET_put_bytes_u8(&pkt, 0xff)
63             || !WPACKET_finish(&pkt)
64             || !WPACKET_get_total_written(&pkt, &written)
65             ||  written != sizeof(simple2)
66             ||  memcmp(buf->data, &simple2, written) != 0) {
67         testfail("test_WPACKET_init():2 failed\n", &pkt);
68         return 0;
69     }
70
71     /* And a longer length prefix */
72     if (!WPACKET_init_len(&pkt, buf, 4)
73             || !WPACKET_put_bytes_u8(&pkt, 0xff)
74             || !WPACKET_finish(&pkt)
75             || !WPACKET_get_total_written(&pkt, &written)
76             ||  written != sizeof(simple3)
77             ||  memcmp(buf->data, &simple3, written) != 0) {
78         testfail("test_WPACKET_init():3 failed\n", &pkt);
79         return 0;
80     }
81
82     if (!WPACKET_init_len(&pkt, buf, 1)) {
83         testfail("test_WPACKET_init():4 failed\n", &pkt);
84         return 0;
85     }
86     for (i = 1; i < 257; i++) {
87         /*
88          * Putting more bytes in than fit for the size of the length prefix
89          * should fail
90          */
91         if ((!WPACKET_put_bytes_u8(&pkt, 0xff)) == (i != 256)) {
92             testfail("test_WPACKET_init():4 failed\n", &pkt);
93             return 0;
94         }
95     }
96     if (!WPACKET_finish(&pkt)) {
97         testfail("test_WPACKET_init():4 failed\n", &pkt);
98         return 0;
99     }
100
101     /* Test initialising from a fixed size buffer */
102     if (!WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0)
103                 /* Adding 3 bytes should succeed */
104             || !WPACKET_put_bytes_u24(&pkt, 0xffffff)
105                 /* Adding 1 more byte should fail */
106             ||  WPACKET_put_bytes_u8(&pkt, 0xff)
107                 /* Finishing the top level WPACKET should succeed */
108             || !WPACKET_finish(&pkt)
109             || !WPACKET_get_total_written(&pkt, &written)
110             ||  written != sizeof(fixed)
111             || memcmp(sbuf, fixed, sizeof(sbuf)) != 0
112                 /* Initialise with 1 len byte */
113             || !WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1)
114                 /* Adding 2 bytes should succeed */
115             || !WPACKET_put_bytes_u16(&pkt, 0xfeff)
116                 /* Adding 1 more byte should fail */
117             ||  WPACKET_put_bytes_u8(&pkt, 0xff)
118             || !WPACKET_finish(&pkt)
119             || !WPACKET_get_total_written(&pkt, &written)
120             ||  written != sizeof(alloc)
121             ||  memcmp(sbuf, alloc, written) != 0) {
122         testfail("test_WPACKET_init():5 failed\n", &pkt);
123         return 0;
124     }
125
126     return 1;
127 }
128
129 static int test_WPACKET_set_max_size(void)
130 {
131     WPACKET pkt;
132     size_t written;
133
134     if (!WPACKET_init(&pkt, buf)
135                 /*
136                  * No previous lenbytes set so we should be ok to set the max
137                  * possible max size
138                  */
139             || !WPACKET_set_max_size(&pkt, SIZE_MAX)
140                 /* We should be able to set it smaller too */
141             || !WPACKET_set_max_size(&pkt, SIZE_MAX -1)
142                 /* And setting it bigger again should be ok */
143             || !WPACKET_set_max_size(&pkt, SIZE_MAX)
144             || !WPACKET_finish(&pkt)) {
145         testfail("test_WPACKET_set_max_size():1 failed\n", &pkt);
146         return 0;
147     }
148
149     if (!WPACKET_init_len(&pkt, buf, 1)
150                 /*
151                  * Should fail because we already consumed 1 byte with the
152                  * length
153                  */
154             ||  WPACKET_set_max_size(&pkt, 0)
155                 /*
156                  * Max size can't be bigger than biggest that will fit in
157                  * lenbytes
158                  */
159             ||  WPACKET_set_max_size(&pkt, 0x0101)
160                 /* It can be the same as the maximum possible size */
161             || !WPACKET_set_max_size(&pkt, 0x0100)
162                 /* Or it can be less */
163             || !WPACKET_set_max_size(&pkt, 0x01)
164                 /*
165                  * Should fail because packet is already filled
166                  */
167             ||  WPACKET_put_bytes_u8(&pkt, 0xff)
168                 /*
169                  * You can't put in more bytes than max size
170                  */
171             || !WPACKET_set_max_size(&pkt, 0x02)
172             || !WPACKET_put_bytes_u8(&pkt, 0xff)
173             ||  WPACKET_put_bytes_u8(&pkt, 0xff)
174             || !WPACKET_finish(&pkt)
175             || !WPACKET_get_total_written(&pkt, &written)
176             ||  written != sizeof(simple2)
177             ||  memcmp(buf->data, &simple2, written) != 0) {
178         testfail("test_WPACKET_set_max_size():2 failed\n", &pkt);
179         return 0;
180     }
181
182     return 1;
183 }
184
185 static int test_WPACKET_start_sub_packet(void)
186 {
187     WPACKET pkt;
188     size_t written;
189     size_t len;
190
191     if (!WPACKET_init(&pkt, buf)
192             || !WPACKET_start_sub_packet(&pkt)
193             || !WPACKET_put_bytes_u8(&pkt, 0xff)
194                 /* Can't finish because we have a sub packet */
195             ||  WPACKET_finish(&pkt)
196             || !WPACKET_close(&pkt)
197                 /* Sub packet is closed so can't close again */
198             ||  WPACKET_close(&pkt)
199                 /* Now a top level so finish should succeed */
200             || !WPACKET_finish(&pkt)
201             || !WPACKET_get_total_written(&pkt, &written)
202             ||  written != sizeof(simple1)
203             ||  memcmp(buf->data, &simple1, written) != 0) {
204         testfail("test_WPACKET_start_sub_packet():1 failed\n", &pkt);
205         return 0;
206     }
207
208    /* Single sub-packet with length prefix */
209     if (!WPACKET_init(&pkt, buf)
210             || !WPACKET_start_sub_packet_u8(&pkt)
211             || !WPACKET_put_bytes_u8(&pkt, 0xff)
212             || !WPACKET_close(&pkt)
213             || !WPACKET_finish(&pkt)
214             || !WPACKET_get_total_written(&pkt, &written)
215             ||  written != sizeof(simple2)
216             ||  memcmp(buf->data, &simple2, written) != 0) {
217         testfail("test_WPACKET_start_sub_packet():2 failed\n", &pkt);
218         return 0;
219     }
220
221     /* Nested sub-packets with length prefixes */
222     if (!WPACKET_init(&pkt, buf)
223             || !WPACKET_start_sub_packet_u8(&pkt)
224             || !WPACKET_put_bytes_u8(&pkt, 0xff)
225             || !WPACKET_start_sub_packet_u8(&pkt)
226             || !WPACKET_put_bytes_u8(&pkt, 0xff)
227             || !WPACKET_get_length(&pkt, &len)
228             || len != 1
229             || !WPACKET_close(&pkt)
230             || !WPACKET_get_length(&pkt, &len)
231             || len != 3
232             || !WPACKET_close(&pkt)
233             || !WPACKET_finish(&pkt)
234             || !WPACKET_get_total_written(&pkt, &written)
235             ||  written != sizeof(nestedsub)
236             ||  memcmp(buf->data, &nestedsub, written) != 0) {
237         testfail("test_WPACKET_start_sub_packet():3 failed\n", &pkt);
238         return 0;
239     }
240
241     /* Sequential sub-packets with length prefixes */
242     if (!WPACKET_init(&pkt, buf)
243             || !WPACKET_start_sub_packet_u8(&pkt)
244             || !WPACKET_put_bytes_u8(&pkt, 0xff)
245             || !WPACKET_close(&pkt)
246             || !WPACKET_start_sub_packet_u8(&pkt)
247             || !WPACKET_put_bytes_u8(&pkt, 0xff)
248             || !WPACKET_close(&pkt)
249             || !WPACKET_finish(&pkt)
250             || !WPACKET_get_total_written(&pkt, &written)
251             ||  written != sizeof(seqsub)
252             ||  memcmp(buf->data, &seqsub, written) != 0) {
253         testfail("test_WPACKET_start_sub_packet():4 failed\n", &pkt);
254         return 0;
255     }
256
257     /* Nested sub-packets with lengths filled before finish */
258     if (!WPACKET_init(&pkt, buf)
259             || !WPACKET_start_sub_packet_u8(&pkt)
260             || !WPACKET_put_bytes_u8(&pkt, 0xff)
261             || !WPACKET_start_sub_packet_u8(&pkt)
262             || !WPACKET_put_bytes_u8(&pkt, 0xff)
263             || !WPACKET_get_length(&pkt, &len)
264             || len != 1
265             || !WPACKET_close(&pkt)
266             || !WPACKET_get_length(&pkt, &len)
267             || len != 3
268             || !WPACKET_close(&pkt)
269             || !WPACKET_fill_lengths(&pkt)
270             || !WPACKET_get_total_written(&pkt, &written)
271             ||  written != sizeof(nestedsub)
272             ||  memcmp(buf->data, &nestedsub, written) != 0
273             || !WPACKET_finish(&pkt)) {
274         testfail("test_WPACKET_start_sub_packet():5 failed\n", &pkt);
275         return 0;
276     }
277
278     return 1;
279 }
280
281
282 static int test_WPACKET_set_flags(void)
283 {
284     WPACKET pkt;
285     size_t written;
286
287     /* Set packet to be non-zero length */
288     if (!WPACKET_init(&pkt, buf)
289             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
290                 /* Should fail because of zero length */
291             ||  WPACKET_finish(&pkt)
292             || !WPACKET_put_bytes_u8(&pkt, 0xff)
293             || !WPACKET_finish(&pkt)
294             || !WPACKET_get_total_written(&pkt, &written)
295             ||  written != sizeof(simple1)
296             ||  memcmp(buf->data, &simple1, written) != 0) {
297         testfail("test_WPACKET_set_flags():1 failed\n", &pkt);
298         return 0;
299     }
300
301     /* Repeat above test in a sub-packet */
302     if (!WPACKET_init(&pkt, buf)
303             || !WPACKET_start_sub_packet(&pkt)
304             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
305                 /* Should fail because of zero length */
306             ||  WPACKET_close(&pkt)
307             || !WPACKET_put_bytes_u8(&pkt, 0xff)
308             || !WPACKET_close(&pkt)
309             || !WPACKET_finish(&pkt)
310             || !WPACKET_get_total_written(&pkt, &written)
311             ||  written != sizeof(simple1)
312             ||  memcmp(buf->data, &simple1, written) != 0) {
313         testfail("test_WPACKET_set_flags():2 failed\n", &pkt);
314         return 0;
315     }
316
317     /* Set packet to abandon non-zero length */
318     if (!WPACKET_init_len(&pkt, buf, 1)
319             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
320             || !WPACKET_finish(&pkt)
321             || !WPACKET_get_total_written(&pkt, &written)
322             ||  written != 0) {
323         testfail("test_WPACKET_set_flags():3 failed\n", &pkt);
324         return 0;
325     }
326
327     /* Repeat above test but only abandon a sub-packet */
328     if (!WPACKET_init_len(&pkt, buf, 1)
329             || !WPACKET_start_sub_packet_u8(&pkt)
330             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
331             || !WPACKET_close(&pkt)
332             || !WPACKET_finish(&pkt)
333             || !WPACKET_get_total_written(&pkt, &written)
334             ||  written != sizeof(empty)
335             ||  memcmp(buf->data, &empty, written) != 0) {
336         testfail("test_WPACKET_set_flags():4 failed\n", &pkt);
337         return 0;
338     }
339
340     /* And repeat with a non empty sub-packet */
341     if (!WPACKET_init(&pkt, buf)
342             || !WPACKET_start_sub_packet_u8(&pkt)
343             || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
344             || !WPACKET_put_bytes_u8(&pkt, 0xff)
345             || !WPACKET_close(&pkt)
346             || !WPACKET_finish(&pkt)
347             || !WPACKET_get_total_written(&pkt, &written)
348             ||  written != sizeof(simple2)
349             ||  memcmp(buf->data, &simple2, written) != 0) {
350         testfail("test_WPACKET_set_flags():5 failed\n", &pkt);
351         return 0;
352     }
353     return 1;
354 }
355
356 static int test_WPACKET_allocate_bytes(void)
357 {
358     WPACKET pkt;
359     size_t written;
360     unsigned char *bytes;
361
362     if (!WPACKET_init_len(&pkt, buf, 1)
363             || !WPACKET_allocate_bytes(&pkt, 2, &bytes)) {
364         testfail("test_WPACKET_allocate_bytes():1 failed\n", &pkt);
365         return 0;
366     }
367     bytes[0] = 0xfe;
368     bytes[1] = 0xff;
369     if (!WPACKET_finish(&pkt)
370             || !WPACKET_get_total_written(&pkt, &written)
371             ||  written != sizeof(alloc)
372             ||  memcmp(buf->data, &alloc, written) != 0) {
373         testfail("test_WPACKET_allocate_bytes():2 failed\n", &pkt);
374         return 0;
375     }
376
377     /* Repeat with WPACKET_sub_allocate_bytes */
378     if (!WPACKET_init_len(&pkt, buf, 1)
379             || !WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)) {
380         testfail("test_WPACKET_allocate_bytes():3 failed\n", &pkt);
381         return 0;
382     }
383     bytes[0] = 0xfe;
384     bytes[1] = 0xff;
385     if (!WPACKET_finish(&pkt)
386             || !WPACKET_get_total_written(&pkt, &written)
387             ||  written != sizeof(submem)
388             ||  memcmp(buf->data, &submem, written) != 0) {
389         testfail("test_WPACKET_allocate_bytes():4 failed\n", &pkt);
390         return 0;
391     }
392
393     return 1;
394 }
395
396 static int test_WPACKET_memcpy(void)
397 {
398     WPACKET pkt;
399     size_t written;
400     const unsigned char bytes[] = { 0xfe, 0xff };
401
402     if (!WPACKET_init_len(&pkt, buf, 1)
403             || !WPACKET_memcpy(&pkt, bytes, sizeof(bytes))
404             || !WPACKET_finish(&pkt)
405             || !WPACKET_get_total_written(&pkt, &written)
406             ||  written != sizeof(alloc)
407             ||  memcmp(buf->data, &alloc, written) != 0) {
408         testfail("test_WPACKET_memcpy():1 failed\n", &pkt);
409         return 0;
410     }
411
412     /* Repeat with WPACKET_sub_memcpy() */
413     if (!WPACKET_init_len(&pkt, buf, 1)
414             || !WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes))
415             || !WPACKET_finish(&pkt)
416             || !WPACKET_get_total_written(&pkt, &written)
417             ||  written != sizeof(submem)
418             ||  memcmp(buf->data, &submem, written) != 0) {
419         testfail("test_WPACKET_memcpy():2 failed\n", &pkt);
420         return 0;
421     }
422
423     return 1;
424 }
425
426 int test_main(int argc, char *argv[])
427 {
428     int testresult = 0;
429
430     buf = BUF_MEM_new();
431     if (buf != NULL) {
432         ADD_TEST(test_WPACKET_init);
433         ADD_TEST(test_WPACKET_set_max_size);
434         ADD_TEST(test_WPACKET_start_sub_packet);
435         ADD_TEST(test_WPACKET_set_flags);
436         ADD_TEST(test_WPACKET_allocate_bytes);
437         ADD_TEST(test_WPACKET_memcpy);
438
439         testresult = run_tests(argv[0]);
440
441         BUF_MEM_free(buf);
442     }
443
444     return testresult;
445 }