]>
Commit | Line | Data |
---|---|---|
d6c4cc29 | 1 | /* |
33388b44 | 2 | * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. |
d6c4cc29 | 3 | * |
909f1a2e | 4 | * Licensed under the Apache License 2.0 (the "License"). You may not use |
d6c4cc29 MC |
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> | |
a056ee28 | 12 | #include <openssl/rand.h> |
0d345f0e | 13 | #include "internal/packet.h" |
d6c4cc29 MC |
14 | #include "testutil.h" |
15 | ||
f44903a4 BK |
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 }; | |
a056ee28 MC |
25 | static const unsigned char simpleder[] = { |
26 | 0xfc, 0x04, 0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd | |
27 | }; | |
d6c4cc29 MC |
28 | |
29 | static BUF_MEM *buf; | |
30 | ||
adcd8e37 | 31 | static int cleanup(WPACKET *pkt) |
d6c4cc29 | 32 | { |
d6c4cc29 | 33 | WPACKET_cleanup(pkt); |
adcd8e37 | 34 | return 0; |
d6c4cc29 MC |
35 | } |
36 | ||
37 | static int test_WPACKET_init(void) | |
38 | { | |
39 | WPACKET pkt; | |
40 | int i; | |
41 | size_t written; | |
9b36b7d9 | 42 | unsigned char sbuf[3]; |
d6c4cc29 | 43 | |
adcd8e37 RS |
44 | if (!TEST_true(WPACKET_init(&pkt, buf)) |
45 | || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff)) | |
d6c4cc29 | 46 | /* Closing a top level WPACKET should fail */ |
adcd8e37 | 47 | || !TEST_false(WPACKET_close(&pkt)) |
d6c4cc29 | 48 | /* Finishing a top level WPACKET should succeed */ |
adcd8e37 | 49 | || !TEST_true(WPACKET_finish(&pkt)) |
d6c4cc29 MC |
50 | /* |
51 | * Can't call close or finish on a WPACKET that's already | |
52 | * finished. | |
53 | */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
59 | |
60 | /* Now try with a one byte length prefix */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
67 | |
68 | /* And a longer length prefix */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
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 | */ | |
adcd8e37 RS |
83 | if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256)) |
84 | return cleanup(&pkt); | |
d6c4cc29 | 85 | } |
adcd8e37 RS |
86 | if (!TEST_true(WPACKET_finish(&pkt))) |
87 | return cleanup(&pkt); | |
d6c4cc29 | 88 | |
9b36b7d9 | 89 | /* Test initialising from a fixed size buffer */ |
adcd8e37 | 90 | if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0)) |
9b36b7d9 | 91 | /* Adding 3 bytes should succeed */ |
adcd8e37 | 92 | || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff)) |
9b36b7d9 | 93 | /* Adding 1 more byte should fail */ |
adcd8e37 | 94 | || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff)) |
9b36b7d9 | 95 | /* Finishing the top level WPACKET should succeed */ |
adcd8e37 RS |
96 | || !TEST_true(WPACKET_finish(&pkt)) |
97 | || !TEST_true(WPACKET_get_total_written(&pkt, &written)) | |
98 | || !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf)) | |
9b36b7d9 | 99 | /* Initialise with 1 len byte */ |
adcd8e37 | 100 | || !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1)) |
9b36b7d9 | 101 | /* Adding 2 bytes should succeed */ |
adcd8e37 | 102 | || !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff)) |
9b36b7d9 | 103 | /* Adding 1 more byte should fail */ |
adcd8e37 RS |
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); | |
9b36b7d9 | 109 | |
d6c4cc29 MC |
110 | return 1; |
111 | } | |
112 | ||
d6c4cc29 MC |
113 | static int test_WPACKET_set_max_size(void) |
114 | { | |
115 | WPACKET pkt; | |
116 | size_t written; | |
d6c4cc29 | 117 | |
adcd8e37 | 118 | if (!TEST_true(WPACKET_init(&pkt, buf)) |
d6c4cc29 MC |
119 | /* |
120 | * No previous lenbytes set so we should be ok to set the max | |
121 | * possible max size | |
122 | */ | |
adcd8e37 | 123 | || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX)) |
d6c4cc29 | 124 | /* We should be able to set it smaller too */ |
adcd8e37 | 125 | || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1)) |
d6c4cc29 | 126 | /* And setting it bigger again should be ok */ |
adcd8e37 RS |
127 | || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX)) |
128 | || !TEST_true(WPACKET_finish(&pkt))) | |
129 | return cleanup(&pkt); | |
de451856 | 130 | |
adcd8e37 | 131 | if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)) |
de451856 MC |
132 | /* |
133 | * Should fail because we already consumed 1 byte with the | |
134 | * length | |
135 | */ | |
adcd8e37 | 136 | || !TEST_false(WPACKET_set_max_size(&pkt, 0)) |
d6c4cc29 MC |
137 | /* |
138 | * Max size can't be bigger than biggest that will fit in | |
139 | * lenbytes | |
140 | */ | |
adcd8e37 | 141 | || !TEST_false(WPACKET_set_max_size(&pkt, 0x0101)) |
d6c4cc29 | 142 | /* It can be the same as the maximum possible size */ |
adcd8e37 | 143 | || !TEST_true(WPACKET_set_max_size(&pkt, 0x0100)) |
d6c4cc29 | 144 | /* Or it can be less */ |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
156 | |
157 | return 1; | |
158 | } | |
159 | ||
160 | static int test_WPACKET_start_sub_packet(void) | |
161 | { | |
162 | WPACKET pkt; | |
163 | size_t written; | |
164 | size_t len; | |
165 | ||
adcd8e37 RS |
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)) | |
d6c4cc29 | 169 | /* Can't finish because we have a sub packet */ |
adcd8e37 RS |
170 | || !TEST_false(WPACKET_finish(&pkt)) |
171 | || !TEST_true(WPACKET_close(&pkt)) | |
d6c4cc29 | 172 | /* Sub packet is closed so can't close again */ |
adcd8e37 | 173 | || !TEST_false(WPACKET_close(&pkt)) |
d6c4cc29 | 174 | /* Now a top level so finish should succeed */ |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
179 | |
180 | /* Single sub-packet with length prefix */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
189 | |
190 | /* Nested sub-packets with length prefixes */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
206 | |
207 | /* Sequential sub-packets with length prefixes */ | |
adcd8e37 RS |
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); | |
d6c4cc29 | 219 | |
34254342 | 220 | /* Nested sub-packets with lengths filled before finish */ |
adcd8e37 RS |
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); | |
34254342 | 237 | |
d6c4cc29 MC |
238 | return 1; |
239 | } | |
240 | ||
241 | ||
242 | static int test_WPACKET_set_flags(void) | |
243 | { | |
244 | WPACKET pkt; | |
245 | size_t written; | |
246 | ||
247 | /* Set packet to be non-zero length */ | |
adcd8e37 RS |
248 | if (!TEST_true(WPACKET_init(&pkt, buf)) |
249 | || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) | |
d6c4cc29 | 250 | /* Should fail because of zero length */ |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
257 | |
258 | /* Repeat above test in a sub-packet */ | |
adcd8e37 RS |
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)) | |
d6c4cc29 | 262 | /* Should fail because of zero length */ |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
270 | |
271 | /* Set packet to abandon non-zero length */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
278 | |
279 | /* Repeat above test but only abandon a sub-packet */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
288 | |
289 | /* And repeat with a non empty sub-packet */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
299 | return 1; |
300 | } | |
301 | ||
302 | static int test_WPACKET_allocate_bytes(void) | |
303 | { | |
304 | WPACKET pkt; | |
305 | size_t written; | |
306 | unsigned char *bytes; | |
307 | ||
adcd8e37 RS |
308 | if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)) |
309 | || !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes))) | |
310 | return cleanup(&pkt); | |
d6c4cc29 MC |
311 | bytes[0] = 0xfe; |
312 | bytes[1] = 0xff; | |
adcd8e37 RS |
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); | |
d6c4cc29 | 317 | |
b2b3024e | 318 | /* Repeat with WPACKET_sub_allocate_bytes */ |
adcd8e37 RS |
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); | |
b2b3024e MC |
322 | bytes[0] = 0xfe; |
323 | bytes[1] = 0xff; | |
adcd8e37 RS |
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); | |
b2b3024e | 328 | |
d6c4cc29 MC |
329 | return 1; |
330 | } | |
331 | ||
332 | static int test_WPACKET_memcpy(void) | |
333 | { | |
334 | WPACKET pkt; | |
335 | size_t written; | |
336 | const unsigned char bytes[] = { 0xfe, 0xff }; | |
337 | ||
adcd8e37 RS |
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); | |
d6c4cc29 MC |
344 | |
345 | /* Repeat with WPACKET_sub_memcpy() */ | |
adcd8e37 RS |
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); | |
d6c4cc29 MC |
352 | |
353 | return 1; | |
354 | } | |
355 | ||
a056ee28 MC |
356 | static 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]; | |
12cbb8e0 RL |
363 | size_t size1, size2; |
364 | int flags = WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH; | |
a056ee28 MC |
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)) | |
12cbb8e0 RL |
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)) | |
a056ee28 MC |
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_true(RAND_bytes(&testdata2[3], sizeof(testdata2) - 3))) | |
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 | ||
ad887416 | 427 | int setup_tests(void) |
d6c4cc29 | 428 | { |
adcd8e37 RS |
429 | if (!TEST_ptr(buf = BUF_MEM_new())) |
430 | return 0; | |
d6c4cc29 | 431 | |
adcd8e37 RS |
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); | |
a056ee28 | 438 | ADD_TEST(test_WPACKET_init_der); |
ad887416 P |
439 | return 1; |
440 | } | |
d6c4cc29 | 441 | |
ad887416 P |
442 | void cleanup_tests(void) |
443 | { | |
adcd8e37 | 444 | BUF_MEM_free(buf); |
d6c4cc29 | 445 | } |