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