xref: /openssl/test/wpackettest.c (revision 7ed6de99)
1 /*
2  * Copyright 2016-2024 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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 <openssl/rand.h>
13 #include "internal/packet_quic.h"
14 #include "testutil.h"
15 
16 static const unsigned char simple1[] = { 0xff };
17 static const unsigned char simple2[] = { 0x01, 0xff };
18 static const unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
19 static const unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
20 static const unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
21 static const unsigned char empty[] = { 0x00 };
22 static const unsigned char alloc[] = { 0x02, 0xfe, 0xff };
23 static const unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
24 static const unsigned char fixed[] = { 0xff, 0xff, 0xff };
25 static const unsigned char simpleder[] = {
26     0xfc, 0x04, 0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd
27 };
28 
29 #ifndef OPENSSL_NO_QUIC
30 
31 /* QUIC sub-packet with 4-byte length prefix, containing a 1-byte vlint */
32 static const unsigned char quic1[] = { 0x80, 0x00, 0x00, 0x01, 0x09 };
33 /* QUIC sub-packet with 1-byte length prefix, containing a 1-byte vlint */
34 static const unsigned char quic2[] = { 0x01, 0x09 };
35 /* QUIC sub-packet with 2-byte length prefix, containing a 2-byte vlint */
36 static const unsigned char quic3[] = { 0x40, 0x02, 0x40, 0x41 };
37 /* QUIC sub-packet with 8-byte length prefix, containing a 4-byte vlint */
38 static const unsigned char quic4[] = {
39     0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
40     0x80, 0x01, 0x3c, 0x6a
41 };
42 /* QUIC sub-packet with 8-byte length prefix, containing a 8-byte vlint */
43 static const unsigned char quic5[] = {
44     0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
45     0xef, 0x77, 0x21, 0x3f, 0x3f, 0x50, 0x5b, 0xa5
46 };
47 /* QUIC sub-packet, length known up-front */
48 static const unsigned char quic6[] = { 0x03, 0x55, 0x66, 0x77 };
49 /* Nested and sequential sub-packets with length prefixes */
50 static const unsigned char quic7[] = {
51     0x07, 0x80, 0x00, 0x00, 0x08, 0x65, 0x14, 0x40, 0x01, 0x05,
52     0x40, 0x01, 0x11, 0x40, 0x01, 0x12, 0x40, 0x01, 0x13
53 };
54 
55 #endif
56 
57 static BUF_MEM *buf;
58 
cleanup(WPACKET * pkt)59 static int cleanup(WPACKET *pkt)
60 {
61     WPACKET_cleanup(pkt);
62     return 0;
63 }
64 
test_WPACKET_init(void)65 static int test_WPACKET_init(void)
66 {
67     WPACKET pkt;
68     int i;
69     size_t written;
70     unsigned char sbuf[3];
71 
72     if (!TEST_true(WPACKET_init(&pkt, buf))
73             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
74                 /* Closing a top level WPACKET should fail */
75             || !TEST_false(WPACKET_close(&pkt))
76                 /* Finishing a top level WPACKET should succeed */
77             || !TEST_true(WPACKET_finish(&pkt))
78                 /*
79                  * Can't call close or finish on a WPACKET that's already
80                  * finished.
81                  */
82             || !TEST_false(WPACKET_close(&pkt))
83             || !TEST_false(WPACKET_finish(&pkt))
84             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
85             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
86         return cleanup(&pkt);
87 
88     /* Now try with a one byte length prefix */
89     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
90             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
91             || !TEST_true(WPACKET_finish(&pkt))
92             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
93             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
94         return cleanup(&pkt);
95 
96     /* And a longer length prefix */
97     if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
98             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
99             || !TEST_true(WPACKET_finish(&pkt))
100             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
101             || !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
102         return cleanup(&pkt);
103 
104     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
105         return cleanup(&pkt);
106     for (i = 1; i < 257; i++) {
107         /*
108          * Putting more bytes in than fit for the size of the length prefix
109          * should fail
110          */
111         if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
112             return cleanup(&pkt);
113     }
114     if (!TEST_true(WPACKET_finish(&pkt)))
115         return cleanup(&pkt);
116 
117     /* Test initialising from a fixed size buffer */
118     if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
119                 /* Adding 3 bytes should succeed */
120             || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
121                 /* Adding 1 more byte should fail */
122             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
123                 /* Finishing the top level WPACKET should succeed */
124             || !TEST_true(WPACKET_finish(&pkt))
125             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
126             || !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
127                 /* Initialise with 1 len byte */
128             || !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
129                 /* Adding 2 bytes should succeed */
130             || !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
131                 /* Adding 1 more byte should fail */
132             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
133             || !TEST_true(WPACKET_finish(&pkt))
134             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
135             || !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
136         return cleanup(&pkt);
137 
138     return 1;
139 }
140 
test_WPACKET_set_max_size(void)141 static int test_WPACKET_set_max_size(void)
142 {
143     WPACKET pkt;
144     size_t written;
145 
146     if (!TEST_true(WPACKET_init(&pkt, buf))
147                 /*
148                  * No previous lenbytes set so we should be ok to set the max
149                  * possible max size
150                  */
151             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
152                 /* We should be able to set it smaller too */
153             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
154                 /* And setting it bigger again should be ok */
155             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
156             || !TEST_true(WPACKET_finish(&pkt)))
157         return cleanup(&pkt);
158 
159     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
160                 /*
161                  * Should fail because we already consumed 1 byte with the
162                  * length
163                  */
164             || !TEST_false(WPACKET_set_max_size(&pkt, 0))
165                 /*
166                  * Max size can't be bigger than biggest that will fit in
167                  * lenbytes
168                  */
169             || !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
170                 /* It can be the same as the maximum possible size */
171             || !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
172                 /* Or it can be less */
173             || !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
174                 /* Should fail because packet is already filled */
175             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
176                 /* You can't put in more bytes than max size */
177             || !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
178             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
179             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
180             || !TEST_true(WPACKET_finish(&pkt))
181             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
182             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
183         return cleanup(&pkt);
184 
185     return 1;
186 }
187 
test_WPACKET_start_sub_packet(void)188 static int test_WPACKET_start_sub_packet(void)
189 {
190     WPACKET pkt;
191     size_t written;
192     size_t len;
193 
194     if (!TEST_true(WPACKET_init(&pkt, buf))
195             || !TEST_true(WPACKET_start_sub_packet(&pkt))
196             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
197                 /* Can't finish because we have a sub packet */
198             || !TEST_false(WPACKET_finish(&pkt))
199             || !TEST_true(WPACKET_close(&pkt))
200                 /* Sub packet is closed so can't close again */
201             || !TEST_false(WPACKET_close(&pkt))
202                 /* Now a top level so finish should succeed */
203             || !TEST_true(WPACKET_finish(&pkt))
204             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
205             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
206         return cleanup(&pkt);
207 
208    /* Single sub-packet with length prefix */
209     if (!TEST_true(WPACKET_init(&pkt, buf))
210             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
211             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
212             || !TEST_true(WPACKET_close(&pkt))
213             || !TEST_true(WPACKET_finish(&pkt))
214             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
215             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
216         return cleanup(&pkt);
217 
218     /* Nested sub-packets with length prefixes */
219     if (!TEST_true(WPACKET_init(&pkt, buf))
220             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
221             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
222             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
223             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
224             || !TEST_true(WPACKET_get_length(&pkt, &len))
225             || !TEST_size_t_eq(len, 1)
226             || !TEST_true(WPACKET_close(&pkt))
227             || !TEST_true(WPACKET_get_length(&pkt, &len))
228             || !TEST_size_t_eq(len, 3)
229             || !TEST_true(WPACKET_close(&pkt))
230             || !TEST_true(WPACKET_finish(&pkt))
231             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
232             || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
233         return cleanup(&pkt);
234 
235     /* Sequential sub-packets with length prefixes */
236     if (!TEST_true(WPACKET_init(&pkt, buf))
237             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
238             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
239             || !TEST_true(WPACKET_close(&pkt))
240             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
241             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
242             || !TEST_true(WPACKET_close(&pkt))
243             || !TEST_true(WPACKET_finish(&pkt))
244             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
245             || !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
246         return cleanup(&pkt);
247 
248     /* Nested sub-packets with lengths filled before finish */
249     if (!TEST_true(WPACKET_init(&pkt, buf))
250             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
251             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
252             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
253             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
254             || !TEST_true(WPACKET_get_length(&pkt, &len))
255             || !TEST_size_t_eq(len, 1)
256             || !TEST_true(WPACKET_close(&pkt))
257             || !TEST_true(WPACKET_get_length(&pkt, &len))
258             || !TEST_size_t_eq(len, 3)
259             || !TEST_true(WPACKET_close(&pkt))
260             || !TEST_true(WPACKET_fill_lengths(&pkt))
261             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
262             || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
263             || !TEST_true(WPACKET_finish(&pkt)))
264         return cleanup(&pkt);
265 
266     return 1;
267 }
268 
269 
test_WPACKET_set_flags(void)270 static int test_WPACKET_set_flags(void)
271 {
272     WPACKET pkt;
273     size_t written;
274 
275     /* Set packet to be non-zero length */
276     if (!TEST_true(WPACKET_init(&pkt, buf))
277             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
278                 /* Should fail because of zero length */
279             || !TEST_false(WPACKET_finish(&pkt))
280             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
281             || !TEST_true(WPACKET_finish(&pkt))
282             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
283             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
284         return cleanup(&pkt);
285 
286     /* Repeat above test in a sub-packet */
287     if (!TEST_true(WPACKET_init(&pkt, buf))
288             || !TEST_true(WPACKET_start_sub_packet(&pkt))
289             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
290                 /* Should fail because of zero length */
291             || !TEST_false(WPACKET_close(&pkt))
292             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
293             || !TEST_true(WPACKET_close(&pkt))
294             || !TEST_true(WPACKET_finish(&pkt))
295             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
296             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
297         return cleanup(&pkt);
298 
299     /* Set packet to abandon non-zero length */
300     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
301             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
302             || !TEST_true(WPACKET_finish(&pkt))
303             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
304             || !TEST_size_t_eq(written, 0))
305         return cleanup(&pkt);
306 
307     /* Repeat above test but only abandon a sub-packet */
308     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
309             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
310             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
311             || !TEST_true(WPACKET_close(&pkt))
312             || !TEST_true(WPACKET_finish(&pkt))
313             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
314             || !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
315         return cleanup(&pkt);
316 
317     /* And repeat with a non empty sub-packet */
318     if (!TEST_true(WPACKET_init(&pkt, buf))
319             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
320             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
321             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
322             || !TEST_true(WPACKET_close(&pkt))
323             || !TEST_true(WPACKET_finish(&pkt))
324             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
325             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
326         return cleanup(&pkt);
327     return 1;
328 }
329 
test_WPACKET_allocate_bytes(void)330 static int test_WPACKET_allocate_bytes(void)
331 {
332     WPACKET pkt;
333     size_t written;
334     unsigned char *bytes;
335 
336     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
337             || !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
338         return cleanup(&pkt);
339     bytes[0] = 0xfe;
340     bytes[1] = 0xff;
341     if (!TEST_true(WPACKET_finish(&pkt))
342             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
343             || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
344         return cleanup(&pkt);
345 
346     /* Repeat with WPACKET_sub_allocate_bytes */
347     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
348             || !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
349         return cleanup(&pkt);
350     bytes[0] = 0xfe;
351     bytes[1] = 0xff;
352     if (!TEST_true(WPACKET_finish(&pkt))
353             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
354             || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
355         return cleanup(&pkt);
356 
357     return 1;
358 }
359 
test_WPACKET_memcpy(void)360 static int test_WPACKET_memcpy(void)
361 {
362     WPACKET pkt;
363     size_t written;
364     const unsigned char bytes[] = { 0xfe, 0xff };
365 
366     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
367             || !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
368             || !TEST_true(WPACKET_finish(&pkt))
369             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
370             || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
371         return cleanup(&pkt);
372 
373     /* Repeat with WPACKET_sub_memcpy() */
374     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
375             || !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
376             || !TEST_true(WPACKET_finish(&pkt))
377             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
378             || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
379         return cleanup(&pkt);
380 
381     return 1;
382 }
383 
test_WPACKET_init_der(void)384 static int test_WPACKET_init_der(void)
385 {
386     WPACKET pkt;
387     unsigned char sbuf[1024];
388     unsigned char testdata[] = { 0x00, 0x01, 0x02, 0x03 };
389     unsigned char testdata2[259]  = { 0x82, 0x01, 0x00 };
390     size_t written[2];
391     size_t size1, size2;
392     int flags = WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH;
393     int i;
394 
395     /* Test initialising for writing DER */
396     if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf)))
397             || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xfffefd))
398                /* Test writing data in a length prefixed sub-packet */
399             || !TEST_true(WPACKET_start_sub_packet(&pkt))
400             || !TEST_true(WPACKET_memcpy(&pkt, testdata, sizeof(testdata)))
401             || !TEST_true(WPACKET_close(&pkt))
402             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xfc))
403             /* this sub-packet is empty, and should render zero bytes */
404             || (!TEST_true(WPACKET_start_sub_packet(&pkt))
405                 || !TEST_true(WPACKET_set_flags(&pkt, flags))
406                 || !TEST_true(WPACKET_get_total_written(&pkt, &size1))
407                 || !TEST_true(WPACKET_close(&pkt))
408                 || !TEST_true(WPACKET_get_total_written(&pkt, &size2))
409                 || !TEST_size_t_eq(size1, size2))
410             || !TEST_true(WPACKET_finish(&pkt))
411             || !TEST_true(WPACKET_get_total_written(&pkt, &written[0]))
412             || !TEST_mem_eq(WPACKET_get_curr(&pkt), written[0], simpleder,
413                             sizeof(simpleder)))
414         return cleanup(&pkt);
415 
416     /* Generate random packet data for test */
417     if (!TEST_int_gt(RAND_bytes(&testdata2[3], sizeof(testdata2) - 3), 0))
418         return 0;
419 
420     /*
421      * Test with a sub-packet that has 2 length bytes. We do 2 passes - first
422      * with a NULL buffer, just to calculate lengths, and a second pass with a
423      * real buffer to actually generate a packet
424      */
425     for (i = 0; i < 2; i++) {
426         if (i == 0) {
427             if (!TEST_true(WPACKET_init_null_der(&pkt)))
428                 return 0;
429         } else {
430             if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf))))
431                 return 0;
432         }
433         if (!TEST_true(WPACKET_start_sub_packet(&pkt))
434             || !TEST_true(WPACKET_memcpy(&pkt, &testdata2[3],
435                                          sizeof(testdata2) - 3))
436             || !TEST_true(WPACKET_close(&pkt))
437             || !TEST_true(WPACKET_finish(&pkt))
438             || !TEST_true(WPACKET_get_total_written(&pkt, &written[i])))
439         return cleanup(&pkt);
440     }
441 
442     /*
443      * Check that the size calculated in the first pass equals the size of the
444      * packet actually generated in the second pass. Also check the generated
445      * packet looks as we expect it to.
446      */
447     if (!TEST_size_t_eq(written[0], written[1])
448             || !TEST_mem_eq(WPACKET_get_curr(&pkt), written[1], testdata2,
449                             sizeof(testdata2)))
450         return 0;
451 
452     return 1;
453 }
454 
455 #ifndef OPENSSL_NO_QUIC
456 
test_WPACKET_quic(void)457 static int test_WPACKET_quic(void)
458 {
459     WPACKET pkt;
460     size_t written, len;
461     unsigned char *bytes;
462 
463     /* QUIC sub-packet with 4-byte length prefix, containing a 1-byte vlint */
464     if (!TEST_true(WPACKET_init(&pkt, buf))
465             || !TEST_true(WPACKET_start_quic_sub_packet(&pkt))
466             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x09))
467                 /* Can't finish because we have a sub packet */
468             || !TEST_false(WPACKET_finish(&pkt))
469             || !TEST_true(WPACKET_close(&pkt))
470                 /* Sub packet is closed so can't close again */
471             || !TEST_false(WPACKET_close(&pkt))
472                 /* Now a top level so finish should succeed */
473             || !TEST_true(WPACKET_finish(&pkt))
474             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
475             || !TEST_mem_eq(buf->data, written, quic1, sizeof(quic1)))
476         return cleanup(&pkt);
477 
478     /* QUIC sub-packet with 1-byte length prefix, containing a 1-byte vlint */
479     if (!TEST_true(WPACKET_init(&pkt, buf))
480             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_1B_MAX))
481             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x09))
482             || !TEST_false(WPACKET_finish(&pkt))
483             || !TEST_true(WPACKET_close(&pkt))
484             || !TEST_false(WPACKET_close(&pkt))
485             || !TEST_true(WPACKET_finish(&pkt))
486             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
487             || !TEST_mem_eq(buf->data, written, quic2, sizeof(quic2)))
488         return cleanup(&pkt);
489 
490     /* QUIC sub-packet with 2-byte length prefix, containing a 2-byte vlint */
491     if (!TEST_true(WPACKET_init(&pkt, buf))
492             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_2B_MIN))
493             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x41))
494             || !TEST_false(WPACKET_finish(&pkt))
495             || !TEST_true(WPACKET_close(&pkt))
496             || !TEST_false(WPACKET_close(&pkt))
497             || !TEST_true(WPACKET_finish(&pkt))
498             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
499             || !TEST_mem_eq(buf->data, written, quic3, sizeof(quic3)))
500         return cleanup(&pkt);
501 
502     /* QUIC sub-packet with 8-byte length prefix, containing a 4-byte vlint */
503     if (!TEST_true(WPACKET_init(&pkt, buf))
504             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_8B_MIN))
505             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x13c6a))
506             || !TEST_false(WPACKET_finish(&pkt))
507             || !TEST_true(WPACKET_close(&pkt))
508             || !TEST_false(WPACKET_close(&pkt))
509             || !TEST_true(WPACKET_finish(&pkt))
510             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
511             || !TEST_mem_eq(buf->data, written, quic4, sizeof(quic4)))
512         return cleanup(&pkt);
513 
514     /* QUIC sub-packet with 8-byte length prefix, containing a 8-byte vlint */
515     if (!TEST_true(WPACKET_init(&pkt, buf))
516             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_8B_MIN))
517             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x2f77213f3f505ba5ULL))
518             || !TEST_false(WPACKET_finish(&pkt))
519             || !TEST_true(WPACKET_close(&pkt))
520             || !TEST_false(WPACKET_close(&pkt))
521             || !TEST_true(WPACKET_finish(&pkt))
522             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
523             || !TEST_mem_eq(buf->data, written, quic5, sizeof(quic5)))
524         return cleanup(&pkt);
525 
526     /* QUIC sub-packet, length known up-front */
527     if (!TEST_true(WPACKET_init(&pkt, buf))
528             || !TEST_true(WPACKET_quic_sub_allocate_bytes(&pkt, 3, &bytes)))
529         return cleanup(&pkt);
530 
531     bytes[0] = 0x55;
532     bytes[1] = 0x66;
533     bytes[2] = 0x77;
534 
535     if (!TEST_true(WPACKET_finish(&pkt))
536             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
537             || !TEST_mem_eq(buf->data, written, quic6, sizeof(quic6)))
538         return cleanup(&pkt);
539 
540     /* Nested and sequential sub-packets with length prefixes */
541     if (!TEST_true(WPACKET_init(&pkt, buf))
542             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x07))
543             || !TEST_true(WPACKET_get_length(&pkt, &len))
544             || !TEST_size_t_eq(len, 1)
545             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_4B_MIN))
546             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x2514))
547             || !TEST_true(WPACKET_get_length(&pkt, &len))
548             || !TEST_size_t_eq(len, 2)
549             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_2B_MIN))
550             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x05))
551             || !TEST_true(WPACKET_get_length(&pkt, &len))
552             || !TEST_size_t_eq(len, 1)
553             || !TEST_true(WPACKET_close(&pkt))
554             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_2B_MIN))
555             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x11))
556             || !TEST_true(WPACKET_close(&pkt))
557             || !TEST_true(WPACKET_get_length(&pkt, &len))
558             || !TEST_size_t_eq(len, 8)
559             || !TEST_true(WPACKET_close(&pkt))
560             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_2B_MIN))
561             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x12))
562             || !TEST_true(WPACKET_close(&pkt))
563             || !TEST_true(WPACKET_start_quic_sub_packet_bound(&pkt, OSSL_QUIC_VLINT_2B_MIN))
564             || !TEST_true(WPACKET_quic_write_vlint(&pkt, 0x13))
565             || !TEST_true(WPACKET_close(&pkt))
566             || !TEST_true(WPACKET_finish(&pkt))
567             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
568             || !TEST_mem_eq(buf->data, written, quic7, sizeof(quic7)))
569         return cleanup(&pkt);
570 
571     /* Trying to encode a value above OSSL_QUIC_VLINT_MAX should fail */
572     if (!TEST_true(WPACKET_init(&pkt, buf))
573             || !TEST_false(WPACKET_quic_write_vlint(&pkt, OSSL_QUIC_VLINT_MAX+1))
574             || !TEST_true(WPACKET_quic_write_vlint(&pkt, OSSL_QUIC_VLINT_MAX)))
575             return cleanup(&pkt);
576 
577     WPACKET_cleanup(&pkt);
578     return 1;
579 }
580 
test_WPACKET_quic_vlint_random(void)581 static int test_WPACKET_quic_vlint_random(void)
582 {
583     size_t i, written;
584     uint64_t expected, actual = 0;
585     unsigned char rand_data[9];
586     WPACKET pkt;
587     PACKET read_pkt = {0};
588 
589     for (i = 0; i < 10000; ++i) {
590         if (!TEST_int_gt(RAND_bytes(rand_data, sizeof(rand_data)), 0))
591             return cleanup(&pkt);
592 
593         expected = *(uint64_t*)rand_data;
594 
595         /*
596          * Ensure that all size classes get tested with equal probability.
597          */
598         switch (rand_data[8] & 3) {
599             case 0:
600                 expected &= OSSL_QUIC_VLINT_1B_MAX;
601                 break;
602             case 1:
603                 expected &= OSSL_QUIC_VLINT_2B_MAX;
604                 break;
605             case 2:
606                 expected &= OSSL_QUIC_VLINT_4B_MAX;
607                 break;
608             case 3:
609                 expected &= OSSL_QUIC_VLINT_8B_MAX;
610                 break;
611         }
612 
613         if (!TEST_true(WPACKET_init(&pkt, buf))
614                 || !TEST_true(WPACKET_quic_write_vlint(&pkt, expected))
615                 || !TEST_true(WPACKET_get_total_written(&pkt, &written)))
616             return cleanup(&pkt);
617 
618         if (!TEST_true(PACKET_buf_init(&read_pkt, (unsigned char *)buf->data, written))
619                 || !TEST_true(PACKET_get_quic_vlint(&read_pkt, &actual))
620                 || !TEST_uint64_t_eq(expected, actual))
621             return cleanup(&pkt);
622 
623         WPACKET_cleanup(&pkt);
624     }
625 
626     WPACKET_cleanup(&pkt);
627     return 1;
628 }
629 
630 #endif
631 
setup_tests(void)632 int setup_tests(void)
633 {
634     if (!TEST_ptr(buf = BUF_MEM_new()))
635             return 0;
636 
637     ADD_TEST(test_WPACKET_init);
638     ADD_TEST(test_WPACKET_set_max_size);
639     ADD_TEST(test_WPACKET_start_sub_packet);
640     ADD_TEST(test_WPACKET_set_flags);
641     ADD_TEST(test_WPACKET_allocate_bytes);
642     ADD_TEST(test_WPACKET_memcpy);
643     ADD_TEST(test_WPACKET_init_der);
644 #ifndef OPENSSL_NO_QUIC
645     ADD_TEST(test_WPACKET_quic);
646     ADD_TEST(test_WPACKET_quic_vlint_random);
647 #endif
648     return 1;
649 }
650 
cleanup_tests(void)651 void cleanup_tests(void)
652 {
653     BUF_MEM_free(buf);
654 }
655