VirtualBox

source: vbox/trunk/src/libs/openssl-3.1.5/test/wpackettest.c@ 105770

Last change on this file since 105770 was 104078, checked in by vboxsync, 8 months ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette